Fix some bugs

Author: FraLotito

hypergraphx/core/base.py

@@ -752,9 +752,17 @@ def get_weights(self, order=None, size=None, up_to=False, asdict=False):
 
     # Info
     def max_order(self):
+        if not self._edge_list:
+            raise InvalidParameterError(
+                "Cannot compute max order of an empty hypergraph."
+            )
         return self.max_size() - 1
 
     def max_size(self):
+        if not self._edge_list:
+            raise InvalidParameterError(
+                "Cannot compute max size of an empty hypergraph."
+            )
         return max(self.get_sizes())
 
     def num_nodes(self):
@@ -881,6 +889,9 @@ def clear(self):
             adj.clear()
         self._weights.clear()
         self._hypergraph_metadata.clear()
+        self._hypergraph_metadata.update(
+            {"weighted": self._weighted, "type": self._type_name()}
+        )
         self._incidences_metadata.clear()
         self._node_metadata.clear()
         self._edge_metadata.clear()

hypergraphx/core/directed.py

@@ -311,16 +311,25 @@ def get_incident_edges(self, node, order: int = None, size: int = None):
         if order is not None and size is not None:
             raise InvalidParameterError("Order and size cannot be both specified.")
         if order is None and size is None:
-            return self.get_source_edges(node) + self.get_target_edges(node)
+            edges = self.get_source_edges(node) + self.get_target_edges(node)
         elif size is not None:
-            return self.get_source_edges(node, size=size) + self.get_target_edges(
+            edges = self.get_source_edges(node, size=size) + self.get_target_edges(
                 node, size=size
             )
-        elif order is not None:
-            return self.get_source_edges(node, order=order) + self.get_target_edges(
+        else:
+            edges = self.get_source_edges(node, order=order) + self.get_target_edges(
                 node, order=order
             )
 
+        seen = set()
+        unique_edges = []
+        for edge in edges:
+            if edge in seen:
+                continue
+            seen.add(edge)
+            unique_edges.append(edge)
+        return unique_edges
+
     def get_sources(self):
         """Returns the list of sources of the hyperedges in the hypergraph.
 

hypergraphx/core/multiplex.py

@@ -106,7 +106,7 @@ def _normalize_edge(self, edge, layer=None, **kwargs):
         Public API convention: multiplex edges are represented as an edge key
         `(layer, edge)` at boundaries. Most methods accept either:
         - separate arguments: `edge=<tuple>, layer=<str>`
-        - a packed edge key: `edge=(<tuple>, <str>)` and `layer=None`
+        - a packed edge key: `edge=(<str>, <tuple>)` and `layer=None`
 
         Note: to avoid ambiguity with 2-node hyperedges, a packed edge key is
         only inferred when the first element looks like a layer (string).
@@ -242,7 +242,7 @@ def add_edges(
 
         edge_layer : list, optional
             The list of layers to which the hyperedges belong. If not provided,
-            `edge_list` must contain packed `(edge, layer)` tuples.
+            `edge_list` must contain packed `(layer, edge)` tuples.
 
         weights : list, optional
             The list of weights of the hyperedges. If the hypergraph is weighted, this must be provided.
@@ -329,7 +329,7 @@ def add_edge(
             The hyperedge to add.
         layer : str, optional
             The layer to which the hyperedge belongs. If not provided, `edge`
-            must be a packed `(edge, layer)` tuple.
+            must be a packed `(layer, edge)` tuple.
         weight : float, optional
             The weight of the hyperedge. If the hypergraph is weighted, this must be provided.
         metadata : dict, optional
@@ -449,7 +449,7 @@ def set_weight(self, edge, layer=None, weight=None):
         Set edge weight.
 
         Accepts:
-        - `set_weight(edge, layer, weight)` (legacy, explicit layer)
+        - `set_weight(edge, layer, weight)` (explicit layer argument)
         - `set_weight((layer, edge), weight=<...>)` (packed edge key)
         - `set_weight((layer, edge), <weight>)` (packed edge key, positional weight)
         - `set_weight((edge, layer), <weight>)` (legacy packed edge key, positional weight)

hypergraphx/core/temporal.py

@@ -728,7 +728,7 @@ def subhypergraph(
         if add_all_nodes:
             for node in self.get_nodes():
                 for k, v in res.items():
-                    if v.check_node(node):
+                    if not v.check_node(node):
                         v.add_node(node)
 
         return res

tests/core/directed_hypergraphs/test_directed_hypergraph.py

@@ -110,6 +110,14 @@ def test_get_incident_edges_filters_by_size():
     assert incident_edges == [(("A", "C"), ("D",))]
 
 
+def test_get_incident_edges_deduplicates_source_and_target_overlap():
+    hg = DirectedHypergraph()
+    edge = (("A",), ("A", "B"))
+    hg.add_edge(edge)
+    incident_edges = hg.get_incident_edges("A")
+    assert incident_edges == [edge]
+
+
 def test_get_neighbors_undirected_union():
     hg = DirectedHypergraph()
     hg.add_edge((("A",), ("B",)))

tests/core/hypergraphs/test_hypergraphs.py

@@ -1,7 +1,7 @@
 import pytest
 
 from hypergraphx import Hypergraph
-from hypergraphx.exceptions import MissingEdgeError
+from hypergraphx.exceptions import InvalidParameterError, MissingEdgeError
 
 
 def test_hypergraph_initialization_with_metadata():
@@ -43,6 +43,28 @@ def test_is_uniform_empty_hypergraph():
     assert hg.is_uniform() is True  # An empty hypergraph is trivially uniform
 
 
+def test_max_size_and_order_on_empty_hypergraph_raise_invalid_parameter():
+    hg = Hypergraph()
+    with pytest.raises(
+        InvalidParameterError, match="Cannot compute max size of an empty hypergraph."
+    ):
+        hg.max_size()
+    with pytest.raises(
+        InvalidParameterError, match="Cannot compute max order of an empty hypergraph."
+    ):
+        hg.max_order()
+
+
+def test_clear_preserves_core_metadata_invariants():
+    hg = Hypergraph(weighted=False, hypergraph_metadata={"name": "demo"})
+    hg.add_edge((1, 2))
+    hg.clear()
+
+    metadata = hg.get_hypergraph_metadata()
+    assert metadata["weighted"] is False
+    assert metadata["type"] == "Hypergraph"
+
+
 def test_is_uniform_single_edge():
     """Test `is_uniform` method with a single hyperedge."""
     edges = [(1, 2, 3)]

tests/core/temporal_hypergraphs/test_temporal_hypergraphs.py

@@ -267,6 +267,17 @@ def test_aggregate_single_window():
     assert window_0.get_edge_metadata((3, 4)) == {"type": "B"}
 
 
+def test_subhypergraph_add_all_nodes_adds_missing_nodes_to_each_snapshot():
+    thg = TemporalHypergraph(weighted=False)
+    thg.add_edges([("A", "B"), ("B", "C")], [0, 1])
+
+    snapshots = thg.subhypergraph(add_all_nodes=True)
+
+    assert set(snapshots.keys()) == {0, 1}
+    assert set(snapshots[0].get_nodes()) == {"A", "B", "C"}
+    assert set(snapshots[1].get_nodes()) == {"A", "B", "C"}
+
+
 def test_aggregate_with_isolated_nodes():
     """Test aggregation ensures isolated nodes are preserved."""
     thg = TemporalHypergraph(weighted=True)