Support DiHypergraph in from_bipartite_graph (#633)

* Support DiHypergraph in from_bipartite_graph

* PR feedback

* Add the ability to check bipartiteness of directed and undirected

* format with black .

* PR feedback

* fix additional PR comments

* fixed small bugs

---------

Co-authored-by: Nicholas Landry <nicholas.landry.91@gmail.com>

Author: colltoaction

tests/conftest.py

@@ -135,6 +135,37 @@ def bipartite_graph4():
     return G
 
 
+@pytest.fixture
+def bipartite_digraph1():
+    G = nx.DiGraph()
+    G.add_nodes_from([1, 2, 3, 4], bipartite=0)
+    G.add_nodes_from(["a", "b", "c"], bipartite=1)
+    G.add_edges_from(
+        [
+            ("a", 1),
+            (1, "b"),
+            ("b", 2),
+            (2, "c"),
+            ("c", 3),
+            (4, "a"),
+        ]
+    )
+    return G
+
+
+@pytest.fixture
+def bipartite_digraph2():
+    G = nx.DiGraph()
+    G.add_nodes_from([1], bipartite=0)
+    G.add_nodes_from(["a"], bipartite=1)
+    G.add_edges_from(
+        [
+            ("a", 1, {"direction": "invalid"}),
+        ]
+    )
+    return G
+
+
 @pytest.fixture
 def attr0():
     return {"color": "brown", "name": "camel"}

tests/convert/test_bipartite_graph.py

@@ -1,10 +1,11 @@
+import networkx as nx
 import pytest
 
 import xgi
 from xgi.exception import XGIError
 
 
-def test_to_bipartite_graph(edgelist1, edgelist3, edgelist4):
+def test_to_bipartite_graph(edgelist1, edgelist3, edgelist4, diedgelist1):
     H1 = xgi.Hypergraph(edgelist1)
     H2 = xgi.Hypergraph(edgelist3)
     H3 = xgi.Hypergraph(edgelist4)
@@ -49,9 +50,26 @@ def test_to_bipartite_graph(edgelist1, edgelist3, edgelist4):
     assert sorted(bi_el3) == sorted(true_bi_el3)
     assert G3.edges() == xgi.to_bipartite_graph(H3, index=False).edges()
 
+    ## Directed
+    H = xgi.DiHypergraph(diedgelist1)
+    G = xgi.to_bipartite_graph(H)
+
+    assert isinstance(G, nx.DiGraph)
+    assert set(G.nodes) == {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+    assert (0, 8) in G.edges
+    assert (8, 0) not in G.edges
+    assert (9, 6) in G.edges
+    assert (6, 9) not in G.edges
+    assert (9, 5) in G.edges
+    assert (9, 5) in G.edges
+
 
 def test_from_bipartite_graph(
-    bipartite_graph1, bipartite_graph2, bipartite_graph3, bipartite_graph4
+    bipartite_graph1,
+    bipartite_graph2,
+    bipartite_graph3,
+    bipartite_graph4,
+    bipartite_digraph1,
 ):
     H = xgi.from_bipartite_graph(bipartite_graph1)
 
@@ -81,3 +99,15 @@ def test_from_bipartite_graph(
     # not bipartite
     with pytest.raises(XGIError):
         H = xgi.from_bipartite_graph(bipartite_graph4, dual=True)
+
+    ### Directed
+    H = xgi.from_bipartite_graph(bipartite_digraph1)
+
+    assert set(H.nodes) == {1, 2, 3, 4}
+    assert set(H.edges) == {"a", "b", "c"}
+    assert H.edges.head("a") == {1}
+    assert H.edges.tail("a") == {4}
+    assert H.edges.head("b") == {2}
+    assert H.edges.tail("b") == {1}
+    assert H.edges.head("c") == {3}
+    assert H.edges.tail("c") == {2}

xgi/convert/bipartite_graph.py

@@ -1,15 +1,14 @@
 """Methods for converting to and from bipartite graphs."""
 
 import networkx as nx
-from networkx import bipartite
 
+from ..core import DiHypergraph, Hypergraph
 from ..exception import XGIError
-from ..generators import empty_hypergraph
 
 __all__ = ["from_bipartite_graph", "to_bipartite_graph"]
 
 
-def from_bipartite_graph(G, create_using=None, dual=False):
+def from_bipartite_graph(G, dual=False):
     """
     Create a Hypergraph from a NetworkX bipartite graph.
 
@@ -30,16 +29,13 @@ def from_bipartite_graph(G, create_using=None, dual=False):
         A networkx bipartite graph. Each node in the graph has a property
         'bipartite' taking the value of 0 or 1 indicating the type of node.
 
-    create_using : Hypergraph constructor, optional
-        The hypergraph object to add the data to, by default None
-
     dual : bool, default : False
         If True, get edges from bipartite=0 and nodes from bipartite=1
 
     Returns
     -------
-    Hypergraph
-        The equivalent hypergraph
+    Hypergraph or DiHypergraph
+        The equivalent hypergraph or directed hypergraph
 
     References
     ----------
@@ -58,8 +54,14 @@ def from_bipartite_graph(G, create_using=None, dual=False):
     >>> H = xgi.from_bipartite_graph(G)
 
     """
+    if isinstance(G, nx.DiGraph):
+        directed = True
+    else:
+        directed = False
+
     edges = []
     nodes = []
+
     for n, d in G.nodes(data=True):
         try:
             node_type = d["bipartite"]
@@ -73,34 +75,59 @@ def from_bipartite_graph(G, create_using=None, dual=False):
         else:
             raise XGIError("Invalid type specifier")
 
-    if not bipartite.is_bipartite_node_set(G, nodes):
+    if not _is_bipartite(G, nodes, edges):
         raise XGIError("The network is not bipartite")
 
-    H = empty_hypergraph(create_using)
+    if directed:
+        H = DiHypergraph()
+    else:
+        H = Hypergraph()
+
     H.add_nodes_from(nodes)
-    for edge in edges:
-        nodes_in_edge = list(G.neighbors(edge))
-        H.add_edge(nodes_in_edge, idx=edge)
+
+    for u, v in G.edges:
+        if directed:
+            if v in edges:
+                H.add_node_to_edge(v, u, direction="in")
+            else:
+                H.add_node_to_edge(u, v, direction="out")
+        else:
+            H.add_node_to_edge(v, u)
+
     return H.dual() if dual else H
 
 
+def _is_bipartite(G, nodes1, nodes2):
+    """Assumption is that nodes1.union(nodes2) == G.nodes"""
+    for i, j in G.edges:
+        cond1 = i in nodes1
+        cond2 = j in nodes2
+        if not cond1 == cond2:  # if not both true or both false
+            return False
+    return True
+
+
 def to_bipartite_graph(H, index=False):
     """Create a NetworkX bipartite network from a hypergraph.
 
     Parameters
     ----------
-    H: xgi.Hypergraph
+    H: xgi.Hypergraph or xgi.DiHypergraph
         The XGI hypergraph object of interest
     index: bool (default False)
         If False (default), return only the graph.  If True, additionally return the
         index-to-node and index-to-edge mappings.
 
     Returns
     -------
-    nx.Graph[, dict, dict]
-        The resulting equivalent bipartite graph, and optionally the index-to-unit
-        mappings.
-
+    if xgi.Hypergraph
+        nx.Graph[, dict, dict]
+            The resulting equivalent bipartite graph, and optionally the index-to-unit
+            mappings.
+    if xgi.Hypergraph
+        nx.DiGraph[, dict, dict]
+            The resulting equivalent directed bipartite graph, and optionally the index-to-unit
+            mappings.
     References
     ----------
     The Why, How, and When of Representations for Complex Systems,
@@ -116,24 +143,41 @@ def to_bipartite_graph(H, index=False):
     >>> G, itn, ite = xgi.to_bipartite_graph(H, index=True)
 
     """
-    G = nx.Graph()
+    if isinstance(H, DiHypergraph):
+        directed = True
+    else:
+        directed = False
 
     n = H.num_nodes
     m = H.num_edges
 
     node_dict = dict(zip(H.nodes, range(n)))
     edge_dict = dict(zip(H.edges, range(n, n + m)))
+
+    if directed:
+        G = nx.DiGraph()
+    else:
+        G = nx.Graph()
+
     G.add_nodes_from(node_dict.values(), bipartite=0)
     G.add_nodes_from(edge_dict.values(), bipartite=1)
-    for node in H.nodes:
-        for edge in H.nodes.memberships(node):
-            G.add_edge(node_dict[node], edge_dict[edge])
+
+    if directed:
+        for e in H.edges:
+            for v in H.edges.tail(e):
+                G.add_edge(node_dict[v], edge_dict[e])
+            for v in H.edges.head(e):
+                G.add_edge(edge_dict[e], node_dict[v])
+    else:
+        for e in H.edges:
+            for v in H.edges.members(e):
+                G.add_edge(node_dict[v], edge_dict[e])
 
     if index:
         return (
             G,
-            dict(zip(range(n), H.nodes)),
-            dict(zip(range(n, n + m), H.edges)),
+            {v: k for k, v in node_dict.items()},
+            {v: k for k, v in edge_dict.items()},
         )
     else:
         return G