nx.Graph CRUD Interface

.github/workflows/build.yaml

@@ -21,11 +21,10 @@ jobs:
           cache: 'pip'
           cache-dependency-path: setup.py
 
-      - name: Set up ArangoDB Instance via Docker
-        run: docker create --name adb -p 8529:8529 -e ARANGO_ROOT_PASSWORD=test arangodb/arangodb
-
-      - name: Start ArangoDB Instance
-        run: docker start adb
+      - name: Set up ArangoDB
+        run: |
+          chmod +x starter.sh
+          ./starter.sh
 
       - name: Setup pip
         run: python -m pip install --upgrade pip setuptools wheel

README.md

@@ -3,29 +3,85 @@ Development Sandbox:
 <a href="https://colab.research.google.com/drive/1gIfJDEumN6UdZou_VlSbG874xGkHwtU2?usp=sharing" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
 
 What's currently possible:
-- Algorithm dispatching for GPU & CPU (`betweenness_centrality`, `pagerank`, `louvain_communities`)
-- Data Load from ArangoDB to `nx`
-- Data Load from ArangoDB to `nxcg`
+- ArangoDB CRUD Interface for `nx.Graph`
+- Algorithm dispatching to `nx` & `nxcg` (`betweenness_centrality`, `pagerank`, `louvain_communities`)
+- Algorithm dispatching to ArangoDB (`shortest_path`)
+- Data Load from ArangoDB to `nx` object
+- Data Load from ArangoDB to `nxcg` object
+- Data Load from ArangoDB via dictionary-based remote connection
 
-Next Milestone:
-- NetworkX CRUD Interface for ArangoDB
+Next steps:
+- Generalize `nxadb`'s support for `nx` & `nxcg` algorithms
+- Improve support for `nxadb.DiGraph`
+- CRUD Interface Improvements
 
-Planned, but not yet scopped:
-- NetworkX Graph Query Method
-- Data Write to ArangoDB from `nx`
-- Data Write to ArangoDB from `nxcg`
+Planned:
+- Support for `nxadb.MultiGraph` & `nxadb.MultiDiGraph`
+- Data Load from `nx` to ArangoDB
+- Data Load from `nxcg` to ArangoDB
 
 ```py
-
+import os
 import networkx as nx
 import nx_arangodb as nxadb
 
-G_1 = nx.karate_club_graph()
+os.environ["DATABASE_HOST"] = "http://localhost:8529"
+os.environ["DATABASE_USERNAME"] = "root"
+os.environ["DATABASE_PASSWORD"] = "password"
+os.environ["DATABASE_NAME"] = "_system"
+
+G = nxadb.Graph(graph_name="KarateGraph")
+
+G_nx = nx.karate_club_graph()
+assert len(G.nodes) == len(G_nx.nodes)
+assert len(G.adj) == len(G_nx.adj)
+assert len(G.edges) == len(G_nx.edges)
+
+nx.betweenness_centrality(G)
+nx.pagerank(G)
+nx.community.louvain_communities(G)
+nx.shortest_path(G, "person/1", "person/34")
+nx.all_neighbors(G, "person/1")
+
+G.nodes(data='club', default='unknown')
+G.edges(data='weight', default=1000)
+
+G.nodes["person/1"]
+G.adj["person/1"]
+G.edges[("person/1", "person/3")]
+
+G.nodes["person/1"]["name"] = "John Doe"
+G.nodes["person/1"].update({"age": 40})
+del G.nodes["person/1"]["name"]
+
+G.adj["person/1"]["person/3"]["weight"] = 2
+G.adj["person/1"]["person/3"].update({"weight": 3})
+del G.adj["person/1"]["person/3"]["weight"]
+
+G.edges[("person/1", "person/3")]["weight"] = 0.5
+assert G.adj["person/1"]["person/3"]["weight"] == 0.5
+
+G.add_node("person/35", name="Jane Doe")
+G.add_nodes_from(
+    [("person/36", {"name": "Jack Doe"}), ("person/37", {"name": "Jill Doe"})]
+)
+G.add_edge("person/1", "person/35", weight=1.5, _edge_type="knows")
+G.add_edges_from(
+    [
+        ("person/1", "person/36", {"weight": 2}),
+        ("person/1", "person/37", {"weight": 3}),
+    ],
+    _edge_type="knows",
+)
+
+G.remove_edge("person/1", "person/35")
+G.remove_edges_from([("person/1", "person/36"), ("person/1", "person/37")])
+G.remove_node("person/35")
+G.remove_nodes_from(["person/36", "person/37"])
 
-G_2 = nxadb.Graph(G_1)
+G.clear()
 
-bc_1 = nx.betweenness_centrality(G_1)
-bc_2 = nx.betweenness_centrality(G_2)
-bc_3 = nx.betweenness_centrality(G_1, backend="arangodb")
-bc_4 = nx.betweenness_centrality(G_2, backend="arangodb")
-```
+assert len(G.nodes) == len(G_nx.nodes)
+assert len(G.adj) == len(G_nx.adj)
+assert len(G.edges) == len(G_nx.edges)
+```

_nx_arangodb/__init__.py

@@ -1,5 +1,3 @@
-# Copied from nx-cugraph
-
 """Tell NetworkX about the arangodb backend. This file can update itself:
 
 $ make plugin-info
@@ -31,20 +29,25 @@
     "functions": {
         # BEGIN: functions
         "betweenness_centrality",
+        "is_partition",
         "louvain_communities",
         "louvain_partitions",
         "modularity",
         "pagerank",
+        "shortest_path",
         "to_scipy_sparse_array",
         # END: functions
     },
     "additional_docs": {
         # BEGIN: additional_docs
-
+        "shortest_path": "limited version of nx.shortest_path",
         # END: additional_docs
     },
     "additional_parameters": {
         # BEGIN: additional_parameters
+        "is_partition": {
+            "dtype : dtype or None, optional": "The data type (np.float32, np.float64, or None) to use for the edge weights in the algorithm. If None, then dtype is determined by the edge values.",
+        },
         "louvain_communities": {
             "dtype : dtype or None, optional": "The data type (np.float32, np.float64, or None) to use for the edge weights in the algorithm. If None, then dtype is determined by the edge values.",
         },
@@ -57,6 +60,9 @@
         "pagerank": {
             "dtype : dtype or None, optional": "The data type (np.float32, np.float64, or None) to use for the edge weights in the algorithm. If None, then dtype is determined by the edge values.",
         },
+        "shortest_path": {
+            "dtype : dtype or None, optional": "The data type (np.float32, np.float64, or None) to use for the edge weights in the algorithm. If None, then dtype is determined by the edge values.",
+        },
         "to_scipy_sparse_array": {
             "dtype : dtype or None, optional": "The data type (np.float32, np.float64, or None) to use for the edge weights in the algorithm. If None, then dtype is determined by the edge values.",
         },

nx_arangodb/__init__.py

@@ -1,5 +1,3 @@
-# Copied from nx-cugraph
-
 from networkx.exception import *
 
 from . import utils
@@ -13,4 +11,6 @@
 from . import algorithms
 from .algorithms import *
 
+from .logger import logger
+
 from _nx_arangodb._version import __git_commit__, __version__

nx_arangodb/algorithms/__init__.py

@@ -1,4 +1,5 @@
-from . import centrality, community, link_analysis
+from . import centrality, community, link_analysis, shortest_paths
 from .centrality import *
 from .community import *
 from .link_analysis import *
+from .shortest_paths import *

nx_arangodb/algorithms/centrality/betweenness.py

@@ -1,24 +1,19 @@
-from networkx.algorithms.centrality import betweenness as nx_betweenness
+import networkx as nx
 
 from nx_arangodb.convert import _to_nxadb_graph, _to_nxcg_graph
+from nx_arangodb.logger import logger
 from nx_arangodb.utils import networkx_algorithm
 
 try:
     import nx_cugraph as nxcg
 
     GPU_ENABLED = True
-    print("ANTHONY: GPU is enabled")
 except ModuleNotFoundError:
     GPU_ENABLED = False
-    print("ANTHONY: GPU is disabled")
 
 
 __all__ = ["betweenness_centrality"]
 
-# 1. If GPU is enabled, call nx-cugraph bc() after converting to an ncxg graph (in-memory graph)
-# 2. If GPU is not enabled, call networkx bc() after converting to an nxadb graph (in-memory graph)
-# 3. If GPU is not enabled, call networkx bc() **without** converting to a nxadb graph (remote graph)
-
 
 @networkx_algorithm(
     is_incomplete=True,
@@ -27,56 +22,26 @@
     _plc="betweenness_centrality",
 )
 def betweenness_centrality(
-    G, k=None, normalized=True, weight=None, endpoints=False, seed=None, run_on_gpu=True
+    G,
+    k=None,
+    normalized=True,
+    weight=None,
+    endpoints=False,
+    seed=None,
+    run_on_gpu=True,
+    pull_graph_on_cpu=True,
 ):
-    print("ANTHONY: Calling betweenness_centrality from nx_arangodb")
+    logger.debug(f"nxadb.betweenness_centrality for {G.__class__.__name__}")
 
-    # 1.
     if GPU_ENABLED and run_on_gpu:
-        print("ANTHONY: to_nxcg")
         G = _to_nxcg_graph(G, weight)
 
-        print("ANTHONY: Using nxcg bc()")
+        logger.debug("using nxcg.betweenness_centrality")
         return nxcg.betweenness_centrality(G, k=k, normalized=normalized, weight=weight)
 
-    # 2.
-    else:
-
-        print("ANTHONY: to_nxadb")
-        G = _to_nxadb_graph(G)
-
-        print("ANTHONY: Using nx bc()")
-
-        betweenness = dict.fromkeys(G, 0.0)  # b[v]=0 for v in G
-        if k is None:
-            nodes = G
-        else:
-            nodes = seed.sample(list(G.nodes()), k)
-        for s in nodes:
-            # single source shortest paths
-            if weight is None:  # use BFS
-                S, P, sigma, _ = nx_betweenness._single_source_shortest_path_basic(G, s)
-            else:  # use Dijkstra's algorithm
-                S, P, sigma, _ = nx_betweenness._single_source_dijkstra_path_basic(
-                    G, s, weight
-                )
-            # accumulation
-            if endpoints:
-                betweenness, _ = nx_betweenness._accumulate_endpoints(
-                    betweenness, S, P, sigma, s
-                )
-            else:
-                betweenness, _ = nx_betweenness._accumulate_basic(
-                    betweenness, S, P, sigma, s
-                )
-
-        betweenness = nx_betweenness._rescale(
-            betweenness,
-            len(G),
-            normalized=normalized,
-            directed=G.is_directed(),
-            k=k,
-            endpoints=endpoints,
-        )
+    G = _to_nxadb_graph(G, pull_graph=pull_graph_on_cpu)
 
-        return betweenness
+    logger.debug("using nx.betweenness_centrality")
+    return nx.betweenness_centrality.orig_func(
+        G, k=k, normalized=normalized, weight=weight, endpoints=endpoints, seed=seed
+    )