drb 2.3.2__tar.gz → 2.3.4__tar.gz

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

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

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

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

{drb-2.3.2 → 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.2 → 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.2 → drb-2.3.4}/drb/xquery/drb_xquery_visitor.py

@@ -1,3 +1,5 @@
+import re
+
 from antlr4 import InputStream, CommonTokenStream
 from antlr4.error.ErrorListener import ErrorListener
 from antlr4.tree.Tree import TerminalNodeImpl
@@ -1351,6 +1353,16 @@ class DrbQueryVisitor(XQueryParserVisitor):
                 elif exp.getText() == '//':
                     step_nav = NavigationStep.DESCENDANT_OR_SELF
             elif isinstance(exp, XQueryParser.StepExprContext):
+                # A path step whose whole text is digits is parsed as a numeric
+                # literal because an NCName cannot start with a digit; in
+                # path-step position it is a name test (e.g. /2026/01/15).
+                # Resolve it as such (TICKET-006).
+                if re.fullmatch(r'\d+', exp.getText()):
+                    self.list_context = self._numeric_name_step(
+                        exp.getText(), step_nav)
+                    result = self.list_context
+                    continue
+
                 result = []
                 index = 0
                 for node in self.list_context:
@@ -1373,6 +1385,36 @@ class DrbQueryVisitor(XQueryParserVisitor):
                 self.list_context = result
         return result
 
+    def _numeric_name_step(self, name, step_nav):
+        """Resolve a numeric path step as a name test (TICKET-006).
+
+        Selects, from the current context, the children named exactly
+        ``name`` (CHILD navigation) or any such descendant ('//' navigation).
+        """
+        result = []
+        for ctx_node in self.list_context:
+            node = ctx_node.node \
+                if isinstance(ctx_node, DynamicContext) else ctx_node
+            if not isinstance(node, DrbNode):
+                continue
+            if step_nav == NavigationStep.DESCENDANT_OR_SELF:
+                candidates = self._all_descendants(node)
+            else:
+                candidates = node._browse_children()
+            for child in candidates:
+                if child.name == name:
+                    result.append(DynamicContext(
+                        child, position=len(result) + 1))
+        return result
+
+    @staticmethod
+    def _all_descendants(node):
+        result = []
+        for child in node._browse_children():
+            result.append(child)
+            result.extend(DrbQueryVisitor._all_descendants(child))
+        return result
+
         # Visit a parse tree produced by XQueryParser#enclosedContentExpr.
 
     def visitEnclosedExpression(self,

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

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

{drb-2.3.2 → 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()