Support attribute-based node grouping

ngraph/network.py

@@ -224,19 +224,31 @@ def _build_graph(
         return graph
 
     def select_node_groups_by_path(self, path: str) -> Dict[str, List[Node]]:
-        """Select and group nodes whose names match a given regular expression.
+        """Select and group nodes using a regex pattern or attribute directive.
 
-        Uses re.match(), so the pattern is anchored at the start of the node name.
-        If the pattern includes capturing groups, the group label is formed by
-        joining all non-None captures with '|'. If no capturing groups exist,
-        the group label is the original pattern string.
+        If ``path`` begins with ``"attr:"``, the remainder specifies an attribute
+        name. Nodes are grouped by the value of this attribute; nodes without the
+        attribute are ignored. Otherwise, ``path`` is treated as a regular
+        expression anchored at the start of each node name. If the pattern
+        includes capturing groups, the group label joins captures with ``"|"``.
+        Without capturing groups, the label is the pattern string itself.
 
         Args:
-            path (str): A Python regular expression pattern (e.g., "^foo", "bar(\\d+)", etc.).
+            path: Regular expression pattern or ``"attr:<name>"`` directive.
 
         Returns:
-            Dict[str, List[Node]]: A mapping from group label -> list of matching nodes.
+            Mapping from group label to list of matching nodes.
         """
+        if path.startswith("attr:"):
+            attr_name = path[5:]
+            groups_map: Dict[str, List[Node]] = {}
+            for node in self.nodes.values():
+                value = node.attrs.get(attr_name)
+                if value is not None:
+                    label = str(value)
+                    groups_map.setdefault(label, []).append(node)
+            return groups_map
+
         pattern = re.compile(path)
         groups_map: Dict[str, List[Node]] = {}
 

ngraph/network_view.py

@@ -160,10 +160,10 @@ def to_strict_multidigraph(self, add_reverse: bool = True) -> "StrictMultiDiGrap
         return cache[add_reverse]
 
     def select_node_groups_by_path(self, path: str) -> Dict[str, List["Node"]]:
-        """Select and group visible nodes matching a regex pattern.
+        """Select and group visible nodes using regex or attribute directive.
 
         Args:
-            path: Regular expression pattern to match node names.
+            path: Regular expression pattern or ``"attr:<name>"`` directive.
 
         Returns:
             Dictionary mapping group labels to lists of matching visible nodes.

tests/test_network_selection.py

@@ -97,6 +97,21 @@ def test_select_node_groups_multiple_capture_groups(self, complex_network):
         # Should have groups for each combination found
         assert len(node_groups) >= 2
 
+    def test_select_node_groups_by_attr(self):
+        """Test grouping nodes by attribute value."""
+        net = Network()
+        net.add_node(Node("r1", attrs={"metro": "SEA"}))
+        net.add_node(Node("r2", attrs={"metro": "SEA"}))
+        net.add_node(Node("r3", attrs={"metro": "SFO"}))
+
+        groups = net.select_node_groups_by_path("attr:metro")
+
+        assert set(groups) == {"SEA", "SFO"}
+        sea = {n.name for n in groups["SEA"]}
+        assert sea == {"r1", "r2"}
+        sfo = {n.name for n in groups["SFO"]}
+        assert sfo == {"r3"}
+
 
 class TestLinkUtilities:
     """Tests for link utility methods."""

tests/test_network_view.py

@@ -428,6 +428,23 @@ def test_select_empty_after_filtering(self):
         # Should return empty dict since all dc1 nodes are hidden
         assert len(groups) == 0
 
+    def test_select_by_attribute(self):
+        """Test grouping visible nodes by attribute value."""
+        net = Network()
+        net.add_node(Node("a", attrs={"role": "core"}))
+        net.add_node(Node("b", attrs={"role": "core"}))
+        net.add_node(Node("c", attrs={"role": "edge"}))
+        net.nodes["b"].disabled = True
+        view = NetworkView(_base=net)
+
+        groups = view.select_node_groups_by_path("attr:role")
+
+        assert set(groups) == {"core", "edge"}
+        core = {n.name for n in groups["core"]}
+        assert core == {"a"}
+        edge = {n.name for n in groups["edge"]}
+        assert edge == {"c"}
+
 
 class TestNetworkViewEdgeCases:
     """Test NetworkView edge cases and error conditions."""