drb 2.7.2__tar.gz → 2.7.3__tar.gz

{drb-2.7.2/drb.egg-info → drb-2.7.3}/PKG-INFO

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

{drb-2.7.2 → drb-2.7.3}/drb/core/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-07-07T13:58:00+0000",
+ "date": "2026-07-09T07:37:18+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "0ca7a30d2606890cfee27aa9c615247cf1a7be67",
- "version": "2.7.2"
+ "full-revisionid": "db4dbac9d91e0226023e52ccca1fda79506fb923",
+ "version": "2.7.3"
 }
 '''  # END VERSION_JSON
 

{drb-2.7.2 → drb-2.7.3}/drb/nodes/abstract_node.py

@@ -162,14 +162,14 @@ class AbstractNode(DrbNode, abc.ABC):
         occ = occurrence
         cpt = 0
         if self.namespace_aware or namespace_uri is not None:
-            for x in self._browse_children():
+            for x in self.children_unresolved:
                 if x.name == name and x.namespace_uri == namespace_uri:
                     if occ <= 0:
                         return cpt
                     occ -= 1
                 cpt += 1
         else:
-            for x in self._browse_children():
+            for x in self.children_unresolved:
                 if x.name == name:
                     return cpt
                 cpt += 1
@@ -199,12 +199,16 @@ class AbstractNode(DrbNode, abc.ABC):
             IndexError: if item is out of range of found children
             DrbException: if no child following given criteria is found
         """
+        # Match unresolved children and let the caller resolve only the
+        # selected node: a targeted named lookup must not resolve unrelated
+        # siblings (contract: the driver owns optimized access; the core
+        # resolves only when necessary). drb-testbench#21.
         if self.namespace_aware or namespace_uri is not None:
-            named_children = [x for x in self._browse_children()
+            named_children = [x for x in self.children_unresolved
                               if x.name == name
                               and x.namespace_uri == namespace_uri]
         else:
-            named_children = [x for x in self._browse_children()
+            named_children = [x for x in self.children_unresolved
                               if x.name == name]
         if len(named_children) <= 0:
             raise DrbException(f'No child found having name: {name} and'
@@ -225,13 +229,13 @@ class AbstractNode(DrbNode, abc.ABC):
 
         result = []
         if name is not None and namespace is not None:
-            result = [x for x in self._browse_children()
+            result = [x for x in self.children_unresolved
                       if x.name == name and x.namespace_uri == namespace]
         if name is None:
-            result = [x for x in self._browse_children()
+            result = [x for x in self.children_unresolved
                       if x.namespace_uri == namespace]
         if namespace is None:
-            result = [x for x in self._browse_children() if x.name == name]
+            result = [x for x in self.children_unresolved if x.name == name]
 
         return len(result) > 0
 

{drb-2.7.2 → drb-2.7.3}/drb/topics/resolver.py

@@ -94,6 +94,31 @@ def _topic_by_factory(name: str):
     return None
 
 
+def _driver_topic(topic: DrbTopic) -> Optional[DrbTopic]:
+    """Nearest topic in the ``subClassOf`` chain (``topic`` first) that
+    declares a driver ``factory``.
+
+    A semantic refinement (e.g. a mission-specific container/formatting topic
+    such as ``Sentinel-2 …: Zip``) may declare no ``factory`` of its own; the
+    node must still be built by the driver of the nearest ancestor that has
+    one -- the refinement only relabels it, it does not rebuild it. Returns
+    ``None`` when no topic in the chain declares a factory.
+    """
+    by_id = {t.id: t for t in ManagerDao().get_all_drb_topics()}
+    seen = set()
+    queue = [topic]
+    while queue:
+        current = queue.pop(0)
+        if current is None or current.id in seen:
+            continue
+        seen.add(current.id)
+        if current.factory is not None:
+            return current
+        for parent_id in (current.subClassOf or []):
+            queue.append(by_id.get(parent_id))
+    return None
+
+
 def _topic_by_scheme_any(scheme: str):
     """The topic (any category) declaring ``scheme`` in its ``drb:scheme``.
 
@@ -477,13 +502,16 @@ class _DrbFactoryResolver(DrbFactory):
                     node = _create_via_factory(protocol, node)
 
             container, node = self.__retrieve_container(node)
-            if container is not None and container.factory is not None:
-                node = _create_via_factory(container, node)
+            if container is not None:
+                driver = _driver_topic(container)
+                if driver is not None:
+                    node = _create_via_factory(driver, node)
 
             formatting = self.__retrieve_formatting(node)
             if formatting is not None:
-                if formatting.factory is not None:
-                    node = _create_via_factory(formatting, node)
+                driver = _driver_topic(formatting)
+                if driver is not None:
+                    node = _create_via_factory(driver, node)
                 t, n = self.__finest_drb_topic(node, formatting)
             elif container is not None:
                 t, n = container, node

{drb-2.7.2 → drb-2.7.3/drb.egg-info}/PKG-INFO

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

{drb-2.7.2 → drb-2.7.3}/drb.egg-info/SOURCES.txt

@@ -96,6 +96,7 @@ tests/test_keyring_bitwarden.py
 tests/test_logical_node.py
 tests/test_manager_dao.py
 tests/test_manager_get_dao.py
+tests/test_named_child_no_sibling_resolution.py
 tests/test_node_context.py
 tests/test_node_context_manager.py
 tests/test_node_descendant.py
@@ -106,6 +107,7 @@ tests/test_rdf_dao_multi_url.py
 tests/test_rdf_dao_scheme.py
 tests/test_rdf_dao_signatures.py
 tests/test_resolver_auth.py
+tests/test_resolver_factoryless_refinement.py
 tests/test_resolver_format_alias.py
 tests/test_resolver_implicit_file.py
 tests/test_resolver_recursion_guard.py

drb-2.7.3/tests/test_named_child_no_sibling_resolution.py

@@ -0,0 +1,60 @@
+"""A named-child lookup must not resolve unrelated siblings (drb-testbench#21).
+
+``_get_named_child`` served a targeted lookup by iterating the *resolved*
+children list and filtering by name -- so it resolved **every** sibling to
+return one child. That scales as O(N) resolutions on large containers and lets
+an unrelated sibling's factory crash the lookup (e.g. a GRIB signature firing
+``io.FileIO`` on ``~/.gradle``). Per the driver/core contract the core must
+delegate optimized access to the driver and resolve only when necessary: a
+named lookup matches unresolved children and resolves only the selected node.
+"""
+import os
+import tempfile
+import unittest
+from unittest import mock
+
+import drb.topics.resolver as resolver
+
+
+class TestNamedChildNoSiblingResolution(unittest.TestCase):
+    def setUp(self):
+        # A real directory: the file driver's children are resolved on
+        # iteration (@resolve_children), which is where sibling resolution
+        # leaks in.
+        self.dir = tempfile.mkdtemp()
+        for name in ('good', 'bad'):
+            open(os.path.join(self.dir, name), 'w').close()
+
+    def test_named_lookup_resolves_only_the_target(self):
+        node = resolver.create(self.dir)
+        resolved = []
+        real = resolver.create
+
+        def spy(n, *args, **kwargs):
+            resolved.append(getattr(n, 'name', None))
+            return real(n, *args, **kwargs)
+
+        with mock.patch.object(resolver, 'create', side_effect=spy):
+            child = node['good']
+
+        self.assertEqual('good', child.name)
+        self.assertNotIn('bad', resolved,
+                         'named lookup must not resolve unrelated siblings')
+
+    def test_named_lookup_survives_unresolvable_sibling(self):
+        node = resolver.create(self.dir)
+        real = resolver.create
+
+        def spy(n, *args, **kwargs):
+            if getattr(n, 'name', None) == 'bad':
+                raise OSError('sibling factory blew up (must not be touched)')
+            return real(n, *args, **kwargs)
+
+        with mock.patch.object(resolver, 'create', side_effect=spy):
+            child = node['good']
+
+        self.assertEqual('good', child.name)
+
+
+if __name__ == '__main__':
+    unittest.main()

drb-2.7.3/tests/test_resolver_factoryless_refinement.py

@@ -0,0 +1,75 @@
+"""A factory-less semantic refinement must not suppress its driver.
+
+Regression for drb-python/drb-testbench#20: when a container/formatting topic
+is refined by a sub-topic that declares no driver ``factory`` (e.g. the
+Sentinel-2 KB topic ``… : Zip`` which ``subClassOf`` the generic ``zip``
+topic), resolution used to apply only the *finest* topic's factory -- so the
+generic ``zip`` driver was never applied and the node was left un-navigable.
+
+``resolver._driver_topic`` returns the nearest topic in the ``subClassOf``
+chain that actually declares a driver, so the node is built by that driver
+while the finest topic still labels it.
+"""
+import unittest
+import uuid
+from unittest import mock
+
+from drb.topics import resolver
+from drb.topics.topic import TopicCategory
+
+
+class _Topic:
+    def __init__(self, factory, sub=None):
+        self.id = uuid.uuid4()
+        self.factory = factory
+        self.subClassOf = sub
+        self.label = f'topic-{factory}-{self.id.hex[:6]}'
+        self.category = TopicCategory.CONTAINER
+        self.signatures = []
+
+    def matches(self, node):  # pragma: no cover - not exercised here
+        return True
+
+
+class TestDriverTopic(unittest.TestCase):
+    @staticmethod
+    def _driver(topic, all_topics):
+        with mock.patch.object(resolver.ManagerDao, 'get_all_drb_topics',
+                               return_value=all_topics):
+            return resolver._driver_topic(topic)
+
+    def test_topic_with_factory_returns_itself(self):
+        zip_t = _Topic('zip')
+        self.assertIs(zip_t, self._driver(zip_t, [zip_t]))
+
+    def test_factoryless_refinement_ascends_to_driver(self):
+        # zip (driver) <- abstract-zip (no factory) <- product-zip (no factory)
+        zip_t = _Topic('zip')
+        abstract = _Topic(None, sub=[zip_t.id])
+        product = _Topic(None, sub=[abstract.id])
+        self.assertIs(
+            zip_t, self._driver(product, [zip_t, abstract, product]))
+
+    def test_returns_nearest_driver_not_the_root(self):
+        # inner driver must win over a further ancestor driver
+        outer = _Topic('outer')
+        inner = _Topic('inner', sub=[outer.id])
+        leaf = _Topic(None, sub=[inner.id])
+        self.assertIs(inner, self._driver(leaf, [outer, inner, leaf]))
+
+    def test_no_factory_anywhere_returns_none(self):
+        a = _Topic(None)
+        b = _Topic(None, sub=[a.id])
+        self.assertIsNone(self._driver(b, [a, b]))
+
+    def test_multi_parent_chain_finds_the_driver_branch(self):
+        # a refinement subClassOf a semantic parent AND the zip driver
+        semantic = _Topic(None)
+        zip_t = _Topic('zip')
+        refine = _Topic(None, sub=[semantic.id, zip_t.id])
+        self.assertIs(
+            zip_t, self._driver(refine, [semantic, zip_t, refine]))
+
+
+if __name__ == '__main__':
+    unittest.main()