fix(community): improve C++ compatibility, fallbacks, and add test suite

- localsearch: replace C++17 structured binding with std::tie for C++14
  compatibility (parent/dist destructuring in BFS queue)
- louvain / motif / graph_coloring: detect OpenMP support via _OPENMP
  macro and emit a clear runtime warning when OpenMP is unavailable,
  falling back to serial execution gracefully
- modularity: handle edge cases (empty node list, edgeless graph) by
  returning 0.0 and skip zero-degree nodes without division-by-zero
- tests/: add a complete unittest suite covering modularity,
  greedy_modularity, enumerate_subgraph, louvain (parallel + serial),
  LPA, ego_graph (+ CSR variant), and localsearch, plus a run_all_tests.py
  entry point with a friendly summary

Author: Musicaldg

cpp_easygraph/functions/community/graph_coloring.cpp

@@ -11,6 +11,8 @@
 
 #ifdef _OPENMP
 #include <omp.h>
+#else
+#warning "OpenMP is not available: omp_graph_coloring will fall back to single-threaded execution."
 #endif
 
 #include "../../classes/linkgraph.h"

cpp_easygraph/functions/community/localsearch.cpp

@@ -154,7 +154,8 @@ py::object cpp_localsearch(
     }
 
     while (!bfs_queue.empty()) {
-        auto [parent, dist] = bfs_queue.front();
+        int parent, dist;
+        std::tie(parent, dist) = bfs_queue.front();
         bfs_queue.pop();
 
         for (int pred : dag_pred[parent]) {

cpp_easygraph/functions/community/louvain.cpp

@@ -6,7 +6,11 @@
 #include <cstdint>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
+#ifdef _OPENMP
 #include <omp.h>
+#else
+#warning "OpenMP is not available: cpp_louvain_communities will fall back to single-threaded execution."
+#endif
 #include "../../classes/graph.h"
 #include "../../common/utils.h"
 #include "../../classes/linkgraph.h"
@@ -467,7 +471,9 @@ py::object cpp_louvain_communities_serial(py::object G, py::object weight, py::o
 py::object cpp_louvain_communities(py::object G, py::object weight, py::object threshold, py::object resolution) {
     Graph& G_ = G.cast<Graph&>();
 
+    #ifdef _OPENMP
     omp_set_num_threads(8);
+    #endif
 
     Graph_L original_GL = G_._get_linkgraph_structure();
 

cpp_easygraph/functions/community/modularity.cpp

@@ -2,7 +2,11 @@
 #include <unordered_map>
 #include <unordered_set>
 #include <string>
+#ifdef _OPENMP
 #include <omp.h>
+#else
+#warning "OpenMP is not available: modularity utility functions will fall back to single-threaded execution."
+#endif
 
 #include "../../classes/graph.h"
 #include "../../common/utils.h"
@@ -143,15 +147,35 @@ void calculate_degrees_and_edges_adj_serial(
     }
 }
 
+    // The input `communities` may be either:
+    //   (a) a membership list: a flat sequence of ints, membership[i] = community id of node (i+1); or
+    //   (b) a community list: a sequence of iterables of node ids
+
 py::object cpp_modularity(py::object G, py::object communities, py::object weight=py::str("weight")) {
     Graph& G_ = G.cast<Graph&>();
     bool directed = G.attr("is_directed")().cast<bool>();
     adj_dict_factory& adj = G_.adj;
     const int N = G_.node.size();
 
-    // The input `communities` may be either:
-    //   (a) a membership list: a flat sequence of ints, membership[i] = community id of node (i+1); or
-    //   (b) a community list: a sequence of iterables of node ids
+
+    {
+        bool is_empty_seq = false;
+        try {
+            py::sequence seq = communities.cast<py::sequence>();
+            is_empty_seq = (seq.size() == 0);
+        } catch (const py::cast_error&) {
+            is_empty_seq = false;
+        }
+        if (is_empty_seq) {
+            py::module warnings = py::module::import("warnings");
+            warnings.attr("warn")(
+                "cpp_modularity: received an empty community list; returning Q = 0.0."
+            );
+            return py::float_(0.0);
+        }
+    }
+
+
     std::vector<int> membership_vec;
 
     bool is_membership = false;
@@ -205,7 +229,19 @@ py::object cpp_modularity(py::object G, py::object communities, py::object weigh
     }
 
     if (!directed) addVectorsInPlace(k_out, k_in);
-    
+
+    // Handle empty graph / zero total edge weight: m == 0 makes
+    // `norm = 1.0 / (directed_factor * m)` divide by zero and produces
+    // inf / nan. Define Q = 0.0 in this degenerate case (no edges -> no
+    // community structure to measure), with a Python warning.
+    if (m == 0.0) {
+        py::module warnings = py::module::import("warnings");
+        warnings.attr("warn")(
+            "cpp_modularity: graph has no edges (m == 0); returning Q = 0.0."
+        );
+        return py::float_(0.0);
+    }
+
     double directed_factor = directed ? 1.0 : 2.0;
     double norm = 1.0 / (directed_factor * m);
     e *= norm;

cpp_easygraph/functions/community/motif.cpp

@@ -8,7 +8,11 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/numpy.h>
+#ifdef _OPENMP
 #include <omp.h>
+#else
+#warning "OpenMP is not available: motif counting functions will fall back to single-threaded execution."
+#endif
 #include "../../classes/graph.h"
 #include "../../classes/linkgraph.h"
 #include "motif.h"
@@ -245,11 +249,16 @@ class MotifEnumerator {
         }
 
         vector<vector<MotifResult>> thread_results(8);
-        
+
+        #ifdef _OPENMP
         omp_set_num_threads(8);
+        #endif
         #pragma omp parallel
         {
-            int thread_id = omp_get_thread_num();
+            int thread_id = 0;
+            #ifdef _OPENMP
+            thread_id = omp_get_thread_num();
+            #endif
             vector<MotifResult>& local_results = thread_results[thread_id];
             local_results.reserve(10000);
 
@@ -350,7 +359,9 @@ class MotifEnumerator {
             return count;
         }
 
+        #ifdef _OPENMP
         omp_set_num_threads(8);
+        #endif
         #pragma omp parallel reduction(+:count)
         {
             #pragma omp for schedule(dynamic)

cpp_easygraph/functions/community/tests/__init__.py

@@ -0,0 +1 @@
+# TEST package init

cpp_easygraph/functions/community/tests/cpp_LPA_test.py

@@ -0,0 +1,139 @@
+import unittest
+
+import easygraph as eg
+
+
+def _get_cpp_module():
+    try:
+        import cpp_easygraph
+        return cpp_easygraph
+    except ImportError:
+        return None
+
+
+def _to_undirected_cpp(G_cpp_digraph):
+    import cpp_easygraph
+
+    G_cpp = cpp_easygraph.Graph()
+    G_cpp.graph.update(G_cpp_digraph.graph)
+    for node, node_attr in G_cpp_digraph.nodes.items():
+        G_cpp.add_node(node, **node_attr)
+
+    seen_edges = set()
+    for u, v, edge_data in G_cpp_digraph.edges:
+        edge = (min(u, v), max(u, v))
+        if edge not in seen_edges:
+            seen_edges.add(edge)
+            G_cpp.add_edge(u, v, **edge_data)
+
+    return G_cpp
+
+
+class TestLPA(unittest.TestCase):
+    def setUp(self):
+        self.G_simple = eg.Graph()
+        self.G_simple.add_edges_from([(0, 1), (1, 2), (3, 4)])
+
+        self.G_weighted = eg.Graph()
+        self.G_weighted.add_edges_from([
+            (0, 1, {"weight": 3}),
+            (1, 2, {"weight": 2}),
+            (2, 0, {"weight": 4}),
+            (3, 4, {"weight": 1}),
+        ])
+
+        self.G_disconnected = eg.Graph()
+        self.G_disconnected.add_edges_from([(0, 1), (2, 3), (4, 5)])
+
+        self.G_single = eg.Graph()
+        self.G_single.add_node(42)
+
+        self.G_empty = eg.Graph()
+
+    def _get_cpp_module(self):
+        return _get_cpp_module()
+
+    def test_lpa_simple(self):
+        cpeg = self._get_cpp_module()
+        if cpeg is None:
+            self.skipTest("cpp_easygraph module not available")
+
+        result = cpeg.cpp_LPA(self.G_simple.cpp())
+        self.assertIsInstance(result, dict)
+
+        all_nodes = set()
+        for community in result.values():
+            all_nodes.update(community)
+        self.assertEqual(all_nodes, set(self.G_simple.nodes))
+
+    def test_lpa_weighted(self):
+        cpeg = self._get_cpp_module()
+        if cpeg is None:
+            self.skipTest("cpp_easygraph module not available")
+
+        result = cpeg.cpp_LPA(self.G_weighted.cpp())
+        self.assertIsInstance(result, dict)
+
+        all_nodes = set(self.G_weighted.nodes)
+        result_nodes = set()
+        for community in result.values():
+            result_nodes.update(community)
+        self.assertEqual(all_nodes, result_nodes)
+
+    def test_lpa_disconnected(self):
+        cpeg = self._get_cpp_module()
+        if cpeg is None:
+            self.skipTest("cpp_easygraph module not available")
+
+        result = cpeg.cpp_LPA(self.G_disconnected.cpp())
+        self.assertIsInstance(result, dict)
+
+        all_nodes = set(self.G_disconnected.nodes)
+        result_nodes = set()
+        for community in result.values():
+            result_nodes.update(community)
+        self.assertEqual(all_nodes, result_nodes)
+
+    def test_lpa_single_node(self):
+        cpeg = self._get_cpp_module()
+        if cpeg is None:
+            self.skipTest("cpp_easygraph module not available")
+
+        result = cpeg.cpp_LPA(self.G_single.cpp())
+        self.assertIsInstance(result, dict)
+        self.assertEqual(len(result), 1)
+        for community in result.values():
+            self.assertIn(42, community)
+
+    def test_lpa_empty_graph(self):
+        cpeg = self._get_cpp_module()
+        if cpeg is None:
+            self.skipTest("cpp_easygraph module not available")
+
+        result = cpeg.cpp_LPA(self.G_empty.cpp())
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result, {})
+
+    def test_python_cpp_consistency(self):
+        cpeg = self._get_cpp_module()
+        if cpeg is None:
+            self.skipTest("cpp_easygraph module not available")
+
+        result_cpp = cpeg.cpp_LPA(self.G_simple.cpp())
+        result_py = eg.functions.community.LPA(self.G_simple)
+
+        self.assertEqual(len(result_cpp), len(result_py))
+
+        cpp_nodes = set()
+        for community in result_cpp.values():
+            cpp_nodes.update(community)
+        
+        py_nodes = set()
+        for community in result_py.values():
+            py_nodes.update(community)
+        
+        self.assertEqual(cpp_nodes, py_nodes)
+
+
+if __name__ == "__main__":
+    unittest.main()