drb 2.3.3__tar.gz → 2.3.4__tar.gz

{drb-2.3.3/drb.egg-info → drb-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drb
-Version: 2.3.3
+Version: 2.3.4
 Summary: Data Request Broker
 Author: GAEL Systems
 Author-email: drb-python@gael.fr

{drb-2.3.3 → drb-2.3.4}/drb/core/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-06-18T15:45:35+0000",
+ "date": "2026-06-19T11:01:35+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "eee66f5c219c052a2465479e0be57a251647a9fd",
- "version": "2.3.3"
+ "full-revisionid": "ad5712117cb18c0a99fbddcf98e59256eafd435e",
+ "version": "2.3.4"
 }
 '''  # END VERSION_JSON
 

{drb-2.3.3 → drb-2.3.4}/drb/nodes/abstract_node.py

@@ -61,6 +61,29 @@ class AbstractNode(DrbNode, abc.ABC):
             return DrbNodeList(children)
         raise TypeError(f"{type(item)} type not supported.")
 
+    @property
+    def children_unresolved(self) -> List[DrbNode]:
+        """Direct children without topic resolution of each child.
+
+        ``children`` (and bracket browsing) resolve every child to its
+        topic-specific node, so a recursive walk descends into the *content*
+        of each file (e.g. the XML element tree of a metadata file inside an
+        archive), which can dwarf the container's own structure. This
+        accessor returns the children as produced by the node itself, so a
+        structural traversal stays within the container (TICKET-003):
+
+            def walk(n):
+                return 1 + sum(walk(c) for c in n.children_unresolved)
+
+        Returns:
+            list: the unresolved direct children.
+        """
+        from drb.topics.resolver import DrbNodeList
+        children = self._browse_children()
+        if isinstance(children, DrbNodeList):
+            return children.unresolved
+        return list(children)
+
     def descendant(self, path: str) -> DrbNode:
         """Navigate to a descendant node by a relative path.
 

{drb-2.3.3 → drb-2.3.4}/drb/topics/resolver.py

@@ -301,6 +301,12 @@ class DrbNodeList(list):
         super(DrbNodeList, self).__init__()
         self._list: List[DrbNode] = children
 
+    @property
+    def unresolved(self) -> List[DrbNode]:
+        """The backing children as produced by the node, without resolving
+        each one to its topic-specific type."""
+        return list(self._list)
+
     @staticmethod
     def __resolve_node(node: DrbNode):
         try:

{drb-2.3.3 → drb-2.3.4/drb.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drb
-Version: 2.3.3
+Version: 2.3.4
 Summary: Data Request Broker
 Author: GAEL Systems
 Author-email: drb-python@gael.fr

{drb-2.3.3 → drb-2.3.4}/drb.egg-info/SOURCES.txt

@@ -75,6 +75,7 @@ drb/xquery/drb_xquery_visitor.py
 drb/xquery/exceptions.py
 tests/test_abstract_node.py
 tests/test_addon.py
+tests/test_children_unresolved.py
 tests/test_drb_node_list.py
 tests/test_drb_python_script.py
 tests/test_event.py

drb-2.3.4/tests/test_children_unresolved.py

@@ -0,0 +1,62 @@
+import unittest
+
+from drb.nodes.abstract_node import AbstractNode
+from drb.nodes.logical_node import DrbLogicalNode
+from drb.topics.resolver import DrbNodeList
+
+
+class _StubContainer(AbstractNode):
+    """Node whose children are wrapped in a DrbNodeList, like a driver
+    using @resolve_children."""
+
+    def __init__(self, name, raw_children):
+        super().__init__()
+        self.name = name
+        self._raw = raw_children
+
+    @property
+    def children(self):
+        return DrbNodeList(self._raw)
+
+
+class TestChildrenUnresolved(unittest.TestCase):
+    """Structural (non-resolving) child access (TICKET-003)."""
+
+    def test_node_list_unresolved_returns_backing(self):
+        a, b = DrbLogicalNode('a'), DrbLogicalNode('b')
+        nl = DrbNodeList([a, b])
+        self.assertEqual([a, b], nl.unresolved)
+        # The backing objects are returned as-is (no resolution attempted).
+        self.assertIs(a, nl.unresolved[0])
+
+    def test_children_unresolved_bypasses_resolution(self):
+        a, b = DrbLogicalNode('a.xml'), DrbLogicalNode('b.zip')
+        stub = _StubContainer('c', [a, b])
+        unresolved = stub.children_unresolved
+        self.assertEqual(['a.xml', 'b.zip'], [n.name for n in unresolved])
+        # Same raw objects as provided, untouched by the resolver.
+        self.assertIs(a, unresolved[0])
+        self.assertIs(b, unresolved[1])
+
+    def test_children_unresolved_on_plain_list_node(self):
+        root = DrbLogicalNode('root')
+        root.append_child(DrbLogicalNode('child'))
+        self.assertEqual(['child'],
+                         [n.name for n in root.children_unresolved])
+
+    def test_structural_walk_is_bounded(self):
+        # A small tree; walking via children_unresolved counts every node
+        # exactly once without descending into any resolved content.
+        root = DrbLogicalNode('root')
+        sub = DrbLogicalNode('sub')
+        sub.append_child(DrbLogicalNode('leaf'))
+        root.append_child(sub)
+
+        def walk(n):
+            return 1 + sum(walk(c) for c in n.children_unresolved)
+
+        self.assertEqual(3, walk(root))
+
+
+if __name__ == '__main__':
+    unittest.main()