drb 2.3.3__tar.gz → 2.3.5__tar.gz

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

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

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-06-18T15:45:35+0000",
+ "date": "2026-06-22T12:26:43+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "eee66f5c219c052a2465479e0be57a251647a9fd",
- "version": "2.3.3"
+ "full-revisionid": "262f6e74bc146918a1facd65713ddd8a7cdcbfa1",
+ "version": "2.3.5"
 }
 '''  # END VERSION_JSON
 

drb-2.3.5/drb/core/context.py

@@ -0,0 +1,24 @@
+from typing import Dict
+
+
+class Context:
+    """Per-node store of named context buckets.
+
+    A bucket is a plain ``dict`` keyed by a name (e.g. ``'resolver'`` for
+    resolution state, ``'metadata'`` for an add-on's extracted values).
+    Buckets are created lazily on first access, so any consumer
+    (resolver, add-on) can stash per-node state without the node knowing
+    about it:
+
+        node.context['resolver']['topic'] = topic
+        node.context['metadata']['platform'] = 'S2A'
+    """
+
+    def __init__(self):
+        self._buckets: Dict[str, dict] = {}
+
+    def __getitem__(self, name: str) -> dict:
+        return self._buckets.setdefault(name, {})
+
+    def __contains__(self, name: str) -> bool:
+        return name in self._buckets

{drb-2.3.3 → drb-2.3.5}/drb/core/node.py

@@ -9,6 +9,7 @@ from deprecated import deprecated
 
 from .item import DrbItem
 from .path import ParsedPath, parse_path
+from .context import Context
 from .impls import ImplementationManager
 from ..exceptions.core import DrbException, DrbNotImplementationException
 from ..utils.utils import get_name_namespace_index, get_name_namespace_value
@@ -42,6 +43,7 @@ class DrbNode(DrbItem, abc.ABC):
         self.__namespace_aware = None
         self._attrs = {}
         self._parent = None
+        self._context = Context()
         self._impl_mng = ImplementationManager()
         for event_name in self.__event_type_node:
             self._event_manager.append_event_type(event_name)
@@ -464,5 +466,10 @@ class DrbNode(DrbItem, abc.ABC):
             return self.has_child(*item)
         return False
 
+    @property
+    def context(self) -> Context:
+        """Per-node store of named context buckets (resolver, add-ons...)."""
+        return self._context
+
     def __eq__(self, other):
         return self.path == other.path

{drb-2.3.3 → drb-2.3.5}/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.5}/drb/topics/dao/manager_dao.py

@@ -24,6 +24,23 @@ logger = logging.getLogger('DrbTopic')
 _HTTP_TIMEOUT = (10, 60)
 
 
+# Topic descriptor file names looked up in a topic package, in priority
+# order: ontology descriptors (TTL/OWL) first, legacy YAML cortex last. This
+# lets a package ship its topic as TTL (the knowledge-base format) while YAML
+# keeps working during the migration.
+_DESCRIPTOR_NAMES = ('cortex.ttl', 'cortex.owl', 'cortex.yml', 'cortex.yaml')
+
+
+def _find_topic_descriptor(directory: str):
+    """Return the topic descriptor path in ``directory`` (TTL/OWL preferred
+    over YAML), or None if none is present."""
+    for name in _DESCRIPTOR_NAMES:
+        path = os.path.join(directory, name)
+        if os.path.exists(path):
+            return path
+    return None
+
+
 def _load_all_drb_topic_dao() -> Dict[uuid.UUID, DrbTopicDao]:
     """
     Loads topics defined in the Python context
@@ -39,8 +56,13 @@ def _load_all_drb_topic_dao() -> Dict[uuid.UUID, DrbTopicDao]:
             logger.warning(f'Invalid entry point {ep.name}: {ex.msg}')
             continue
 
+        path = _find_topic_descriptor(module.__path__[0])
+        if path is None:
+            logger.warning(
+                f'No topic descriptor (cortex.ttl/.owl/.yml) for {ep.name}')
+            continue
+
         try:
-            path = os.path.join(module.__path__[0], 'cortex.yml')
             dao = DaoFactory().create(path)
             topics = dao.read_all()
             for topic in topics:
@@ -165,6 +187,24 @@ class ManagerDao:
 
         raise DrbException('No DrbTopic found')
 
+    def get_dao(self, identifier: uuid.UUID) -> DrbTopicDao:
+        """
+        Retrieves the DAO that loaded a topic.
+
+        Lets callers (e.g. add-ons) reach the source of a topic without the
+        manager knowing about their concern: for an RDF topic the returned
+        ``RDFDao`` exposes ``graph``, the ontology graph it was read from.
+
+        Parameters:
+            identifier (UUID): topic UUID
+        Returns:
+            DrbTopicDao: the DAO that loaded the topic identified by the
+                         given UUID.
+        """
+        if identifier in self.__topic_dao.keys():
+            return self.__topic_dao[identifier]
+        raise DrbException('No DrbTopic found')
+
     def is_subclass(self, actual: DrbTopic, expected: DrbTopic) -> bool:
         """
         Check if a topic is subclass of another.

{drb-2.3.3 → drb-2.3.5}/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.5/drb.egg-info}/PKG-INFO

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

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

@@ -16,6 +16,7 @@ drb.egg-info/top_level.txt
 drb/addons/addon.py
 drb/core/__init__.py
 drb/core/_version.py
+drb/core/context.py
 drb/core/cortex_validator.py
 drb/core/events.py
 drb/core/factory.py
@@ -75,6 +76,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
@@ -84,12 +86,15 @@ tests/test_implementation_manager.py
 tests/test_keyring_bitwarden.py
 tests/test_logical_node.py
 tests/test_manager_dao.py
+tests/test_manager_get_dao.py
+tests/test_node_context.py
 tests/test_node_descendant.py
 tests/test_path.py
 tests/test_rdf_dao.py
 tests/test_rdf_dao_multi_url.py
 tests/test_signatures.py
 tests/test_topic.py
+tests/test_topic_descriptor_discovery.py
 tests/test_url_node.py
 tests/test_url_security.py
 tests/test_xml_dao.py

drb-2.3.5/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()

drb-2.3.5/tests/test_manager_get_dao.py

@@ -0,0 +1,27 @@
+import unittest
+import uuid
+
+from drb.exceptions.core import DrbException
+from drb.topics.dao.manager_dao import ManagerDao
+from drb.topics.dao.topic_dao import DrbTopicDao
+
+
+class TestManagerGetDao(unittest.TestCase):
+    """ManagerDao.get_dao exposes the DAO that loaded a topic."""
+
+    def test_get_dao_returns_loading_dao(self):
+        manager = ManagerDao()
+        topics = list(manager.get_all_drb_topics())
+        self.assertTrue(topics, 'expected at least one loaded topic')
+        dao = manager.get_dao(topics[0].id)
+        self.assertIsInstance(dao, DrbTopicDao)
+        # The DAO can read back the same topic.
+        self.assertEqual(topics[0].id, dao.read(topics[0].id).id)
+
+    def test_get_dao_unknown_raises(self):
+        with self.assertRaises(DrbException):
+            ManagerDao().get_dao(uuid.uuid4())
+
+
+if __name__ == '__main__':
+    unittest.main()

drb-2.3.5/tests/test_node_context.py

@@ -0,0 +1,42 @@
+import unittest
+
+from drb.core.context import Context
+from drb.nodes.logical_node import DrbLogicalNode
+
+
+class TestNodeContext(unittest.TestCase):
+    """Per-node context store (recovered from feature_resolution_context)."""
+
+    def test_buckets_created_lazily(self):
+        ctx = Context()
+        self.assertNotIn('resolver', ctx)
+        bucket = ctx['resolver']
+        self.assertEqual({}, bucket)
+        self.assertIn('resolver', ctx)
+
+    def test_bucket_is_persistent_and_mutable(self):
+        ctx = Context()
+        ctx['resolver']['topic'] = 'X'
+        self.assertEqual('X', ctx['resolver']['topic'])
+
+    def test_buckets_are_independent(self):
+        ctx = Context()
+        ctx['resolver']['a'] = 1
+        ctx['metadata']['b'] = 2
+        self.assertEqual({'a': 1}, ctx['resolver'])
+        self.assertEqual({'b': 2}, ctx['metadata'])
+
+    def test_node_exposes_a_context(self):
+        node = DrbLogicalNode('n')
+        self.assertIsInstance(node.context, Context)
+        node.context['resolver']['seen'] = True
+        self.assertTrue(node.context['resolver']['seen'])
+
+    def test_each_node_has_its_own_context(self):
+        a, b = DrbLogicalNode('a'), DrbLogicalNode('b')
+        a.context['resolver']['x'] = 1
+        self.assertNotIn('x', b.context['resolver'])
+
+
+if __name__ == '__main__':
+    unittest.main()

drb-2.3.5/tests/test_topic_descriptor_discovery.py

@@ -0,0 +1,55 @@
+import os
+import shutil
+import tempfile
+import unittest
+
+from drb.topics.dao.manager_dao import _find_topic_descriptor, DaoFactory
+from drb.topics.dao.rdf_dao import RDFDao
+
+
+class TestTopicDescriptorDiscovery(unittest.TestCase):
+    """A topic package may ship a TTL/OWL descriptor; YAML still works."""
+
+    _ttl_fixture = os.path.join(
+        os.path.dirname(__file__), 'resources', 'landsat-8-topic.ttl')
+
+    def setUp(self):
+        self.dir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.dir, ignore_errors=True)
+
+    def _touch(self, name):
+        path = os.path.join(self.dir, name)
+        open(path, 'a').close()
+        return path
+
+    def test_prefers_ttl_over_yaml(self):
+        self._touch('cortex.yml')
+        ttl = self._touch('cortex.ttl')
+        self.assertEqual(ttl, _find_topic_descriptor(self.dir))
+
+    def test_owl_when_no_ttl(self):
+        self._touch('cortex.yml')
+        owl = self._touch('cortex.owl')
+        self.assertEqual(owl, _find_topic_descriptor(self.dir))
+
+    def test_yaml_fallback(self):
+        yml = self._touch('cortex.yml')
+        self.assertEqual(yml, _find_topic_descriptor(self.dir))
+
+    def test_none_when_no_descriptor(self):
+        self.assertIsNone(_find_topic_descriptor(self.dir))
+
+    def test_ttl_descriptor_loads_topics_via_daofactory(self):
+        # A package shipping cortex.ttl is loaded through RDFDao and yields
+        # topics (the migration target).
+        shutil.copy(self._ttl_fixture, os.path.join(self.dir, 'cortex.ttl'))
+        descriptor = _find_topic_descriptor(self.dir)
+        dao = DaoFactory().create(descriptor)
+        self.assertIsInstance(dao, RDFDao)
+        self.assertTrue(len(dao.read_all()) > 0)
+
+
+if __name__ == '__main__':
+    unittest.main()