Refactor algorithms + Add interface as entry point for networkx (#20)

* Add interface as entry point for networkx

- Include convert method to handle auto dispatch conversion calls
- Remove monkey patch code; switch to env variable to toggle
networkx to auto dispatch during testing

* Refactor to separate GraphBLAS algorithms from NetworkX wrappers

- Update code to pass NetworkX tests

* Format setup.py

* Run NetworkX tests

* Write out NetworkX test explicitly

* Remove networkx as a hard dependency

Author: jim22k

.github/workflows/test.yml

@@ -33,15 +33,19 @@ jobs:
           conda install -c conda-forge python-graphblas scipy pandas \
             pytest-cov pytest-randomly black flake8-comprehensions flake8-bugbear
             # matplotlib lxml pygraphviz pydot sympy  # Extra networkx deps we don't need yet
-          pip install git+https://github.com/networkx/networkx.git@main --no-deps
+          pip install git+https://github.com/jim22k/networkx.git@nx-sparse --no-deps
           pip install -e . --no-deps
       - name: Style checks
         run: |
           flake8
           black . --check --diff
       - name: PyTest
         run: |
+          python -c 'import sys, graphblas_algorithms; assert "networkx" not in sys.modules'
           coverage run --branch -m pytest -v
+          coverage report
+          NETWORKX_GRAPH_CONVERT=graphblas pytest --pyargs networkx --cov --cov-append
+          coverage report
           coverage xml
       - name: Coverage
         uses: codecov/codecov-action@v2

graphblas_algorithms/__init__.py

@@ -1,5 +1,6 @@
 from . import _version
-from .algorithms import *
 from .classes import *
 
+from .algorithms import *  # isort:skip
+
 __version__ = _version.get_versions()["version"]

graphblas_algorithms/algorithms/__init__.py

@@ -1,4 +1,4 @@
-from . import cluster, tournament
+from . import exceptions
 from .boundary import *
 from .cluster import *
 from .core import *
@@ -12,4 +12,5 @@
 from .simple_paths import *
 from .smetric import *
 from .structuralholes import *
+from .tournament import *
 from .triads import *

graphblas_algorithms/algorithms/approximation/tests/__init__.py

@@ -1,13 +1,10 @@
-import itertools
-
 from graphblas import binary
 from graphblas.semiring import any_pair
 
-from graphblas_algorithms.classes.digraph import to_graph
-from graphblas_algorithms.utils import get_all
+__all__ = ["edge_boundary", "node_boundary"]
 
 
-def edge_boundary_core(G, nbunch1, nbunch2=None, *, is_weighted=False):
+def edge_boundary(G, nbunch1, nbunch2=None, *, is_weighted=False):
     if is_weighted:
         B = binary.second(nbunch1 & G._A).new(name="boundary")
     else:
@@ -23,59 +20,10 @@ def edge_boundary_core(G, nbunch1, nbunch2=None, *, is_weighted=False):
     return B
 
 
-def edge_boundary(G, nbunch1, nbunch2=None, data=False, keys=False, default=None):
-    # TODO: figure out data, keys, and default arguments and handle multigraph
-    # data=True will be tested in test_mst.py
-    is_multigraph = G.is_multigraph()
-    # This may be wrong for multi-attributed graphs
-    if data is True:
-        weight = "weight"
-    elif not data:
-        weight = None
-    else:
-        weight = data
-    G = to_graph(G, weight=weight)
-    v1 = G.set_to_vector(nbunch1, ignore_extra=True)
-    v2 = G.set_to_vector(nbunch2, ignore_extra=True)
-    result = edge_boundary_core(G, v1, v2, is_weighted=is_multigraph or data)
-    rows, cols, vals = result.to_values(values=is_multigraph or data)
-    id_to_key = G.id_to_key
-    if data:
-        it = zip(
-            (id_to_key[row] for row in rows),
-            (id_to_key[col] for col in cols),
-            # Unsure about this; data argument may mean *all* edge attributes
-            ({weight: val} for val in vals),
-        )
-    else:
-        it = zip(
-            (id_to_key[row] for row in rows),
-            (id_to_key[col] for col in cols),
-        )
-    if is_multigraph:
-        # Edge weights indicate number of times to repeat edges
-        it = itertools.chain.from_iterable(itertools.starmap(itertools.repeat, zip(it, vals)))
-    return it
-
-
-def node_boundary_core(G, nbunch1, *, mask=None):
+def node_boundary(G, nbunch1, *, mask=None):
     if mask is None:
         mask = ~nbunch1.S
     else:
         mask = mask & (~nbunch1.S)
     bdy = any_pair(G._A.T @ nbunch1).new(mask=mask, name="boundary")
     return bdy
-
-
-def node_boundary(G, nbunch1, nbunch2=None):
-    G = to_graph(G)
-    v1 = G.set_to_vector(nbunch1, ignore_extra=True)
-    if nbunch2 is not None:
-        mask = G.set_to_vector(nbunch2, ignore_extra=True).S
-    else:
-        mask = None
-    result = node_boundary_core(G, v1, mask=mask)
-    return G.vector_to_set(result)
-
-
-__all__ = get_all(__name__)