drb 2.4.0__tar.gz → 2.4.2__tar.gz

{drb-2.4.0/drb.egg-info → drb-2.4.2}/PKG-INFO

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

{drb-2.4.0 → drb-2.4.2}/drb/core/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-06-26T09:21:52+0000",
+ "date": "2026-06-26T17:44:46+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "25b4cf76ffd3fba8d829bfb3b992a9ca4351a815",
- "version": "2.4.0"
+ "full-revisionid": "d6abeea9ba11991cf33d5cc12fc33405c6032658",
+ "version": "2.4.2"
 }
 '''  # END VERSION_JSON
 

{drb-2.4.0 → drb-2.4.2}/drb/topics/file/cortex.ttl

@@ -8,5 +8,6 @@ drb:file
    drb:category "PROTOCOL" ;
    rdfs:subClassOf drb:item ;
    rdfs:label "file" ;
+   drb:scheme "file" ;
    drb:signature [ drb:pythonTest "return node.path.scheme is None or '' == node.path.scheme or 'file' == node.path.scheme" ] ;
    drb:implementationIdentifier "file" .

{drb-2.4.0 → drb-2.4.2}/drb/topics/resolver.py

@@ -53,14 +53,59 @@ def _create_via_factory(topic: DrbTopic, node: DrbNode) -> DrbNode:
 
 
 def _topic_by_factory(name: str):
-    """The PROTOCOL topic whose implementationIdentifier == name, or None."""
-    for topic in ManagerDao().get_drb_topics_by_category(
-            TopicCategory.PROTOCOL):
+    """The topic (any category) whose implementationIdentifier == name.
+
+    Returns ``None`` when no topic declares that factory."""
+    for topic in ManagerDao().get_all_drb_topics():
         if topic.factory == name:
             return topic
     return None
 
 
+def _topic_by_scheme_any(scheme: str):
+    """The topic (any category) declaring ``scheme`` in its ``drb:scheme``.
+
+    Unlike :func:`_topic_by_scheme` (PROTOCOL-only, for transport detection),
+    this searches every category so a forced token can resolve to a
+    CONTAINER/FORMATTING topic. Raises :class:`DrbFactoryException` when two
+    distinct topics declare the same scheme (ambiguity)."""
+    matches = [t for t in ManagerDao().get_all_drb_topics()
+               if scheme in (t.scheme or [])]
+    if len(matches) > 1:
+        raise DrbFactoryException(
+            f'Ambiguous scheme token "{scheme}": '
+            f'{[getattr(t, "label", t) for t in matches]}')
+    return matches[0] if matches else None
+
+
+def _resolve_token(token: str):
+    """Resolve a forced scheme token to ``(topic, factory)``.
+
+    Primary: a topic declaring ``token`` in ``drb:scheme`` (any category),
+    with its installed factory. Fallback: ``token`` as a driver entry-point
+    name (topic via :func:`_topic_by_factory`). Raises
+    :class:`DrbFactoryException` when neither resolves or the matched topic's
+    factory is not installed."""
+    topic = _topic_by_scheme_any(token)
+    if topic is not None:
+        factory = FactoryLoader().get_factory(topic.factory)
+        if factory is None:
+            raise DrbFactoryException(
+                f"No driver implementation '{topic.factory}' installed for "
+                f'forced scheme token "{token}"')
+        return topic, factory
+    factory = FactoryLoader().get_factory(token)
+    if factory is None:
+        raise DrbFactoryException(
+            f'No driver registered for forced scheme "+{token}"')
+    topic = _topic_by_factory(token)
+    if topic is None:
+        raise DrbFactoryException(
+            f'Driver "{token}" is registered but declares no topic; '
+            f'cannot classify forced scheme token')
+    return topic, factory
+
+
 def _topic_by_scheme(scheme: str):
     """The PROTOCOL topic declaring this scheme (drb:scheme), or None."""
     for topic in ManagerDao().get_drb_topics_by_category(
@@ -107,35 +152,38 @@ class _DrbFactoryResolver(DrbFactory):
         return None
 
     def __dispatch_scheme(self, node):
-        """Dispatch a root URL by drb:scheme, then apply a +<name> forced
-        driver if present. Returns (topic, node), or None when no PROTOCOL
-        topic declares the base scheme or its factory is not installed
-        (caller falls back to signature matching)."""
+        """Dispatch a root URL by drb:scheme, then apply an ordered stack of
+        +<token> forced drivers. Returns (topic, node), or None when no
+        PROTOCOL topic declares the base scheme or its factory is not
+        installed (caller falls back to signature matching). Raises on an
+        empty scheme segment."""
         scheme = node.path.scheme
         if not scheme:
             return None
-        parts = scheme.split('+', 1)
+        parts = scheme.split('+')
         base = parts[0]
-        forced = parts[1] if len(parts) > 1 else None
+        tokens = parts[1:]
+        if base == '' or any(t == '' for t in tokens):
+            raise DrbFactoryException(
+                f'Invalid scheme "{scheme}": empty segment')
         base_topic = _topic_by_scheme(base)
         if base_topic is None:
             return None
         base_factory = FactoryLoader().get_factory(base_topic.factory)
         if base_factory is None:
             return None
-        if forced is not None:
-            # Strip the +forced token so the base factory receives a clean
-            # <base>:// URL (e.g. https+odata://h/x -> https://h/x).
-            clean_url = base + node.path.name[len(node.path.scheme):]
+        if tokens:
+            # Strip every +token so the base factory receives a clean
+            # <base>:// URL (https+odata+xml://h/x -> https://h/x).
+            clean_url = base + node.path.name[len(scheme):]
             node = UrlNode(clean_url)
         created = base_factory.create(node)
-        if forced is None:
-            return base_topic, created
-        forced_factory = FactoryLoader().get_factory(forced)
-        if forced_factory is None:
-            raise DrbFactoryException(
-                f'No driver registered for forced scheme "+{forced}"')
-        return _topic_by_factory(forced), forced_factory.create(created)
+        topic = base_topic
+        for token in tokens:
+            token_topic, token_factory = _resolve_token(token)
+            created = token_factory.create(created)
+            topic = token_topic
+        return topic, created
 
     def __retrieve_container(
             self, node: DrbNode) -> Tuple[Optional[DrbTopic], DrbNode]:

{drb-2.4.0 → drb-2.4.2/drb.egg-info}/PKG-INFO

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

{drb-2.4.0 → drb-2.4.2}/drb.egg-info/SOURCES.txt

@@ -100,6 +100,7 @@ tests/test_rdf_dao.py
 tests/test_rdf_dao_multi_url.py
 tests/test_rdf_dao_scheme.py
 tests/test_rdf_dao_signatures.py
+tests/test_scheme_force_impl.py
 tests/test_signature_exact.py
 tests/test_signature_hierarchy.py
 tests/test_signatures.py

{drb-2.4.0 → drb-2.4.2}/tests/test_core_topic_ttl.py

@@ -40,3 +40,11 @@ class TestCoreTopicTtl(unittest.TestCase):
         self.assertTrue(any(s.matches(_Node(scheme='')) for s in sigs))
         self.assertTrue(any(s.matches(_Node(scheme=None)) for s in sigs))
         self.assertFalse(any(s.matches(_Node(scheme='http')) for s in sigs))
+
+    def test_file_topic_declares_file_scheme(self):
+        # drb:scheme "file" makes 'file' a routable base scheme for the
+        # dispatcher, enabling forced drivers such as ``file+zip://`` on
+        # paths whose extension does not match the container signature.
+        dao = RDFDao(_FILE_TTL)
+        topic = next(t for t in dao.read_all() if t.label == 'file')
+        self.assertEqual(['file'], topic.scheme)

{drb-2.4.0 → drb-2.4.2}/tests/test_protocol_dispatch.py

@@ -89,6 +89,7 @@ class TestSchemeDispatch(unittest.TestCase):
              patch.object(resolver_mod, '_topic_by_factory',
                           return_value=forced):
             md.return_value.get_drb_topics_by_category.return_value = [base]
+            md.return_value.get_all_drb_topics.return_value = [base]
             facs = {'http': _BaseFactory(), 'odata': _ForcedFactory()}
             gf.side_effect = lambda name: facs.get(name)
             t, n = r._DrbFactoryResolver__dispatch_scheme(
@@ -104,6 +105,7 @@ class TestSchemeDispatch(unittest.TestCase):
         with patch.object(resolver_mod, 'ManagerDao') as md, \
              patch.object(resolver_mod.FactoryLoader, 'get_factory') as gf:
             md.return_value.get_drb_topics_by_category.return_value = [base]
+            md.return_value.get_all_drb_topics.return_value = [base]
             gf.side_effect = lambda name: (
                 {'http': _BaseFactory()}).get(name)
             with self.assertRaises(DrbFactoryException):
@@ -121,6 +123,7 @@ class TestSchemeDispatch(unittest.TestCase):
              patch.object(resolver_mod, '_topic_by_factory',
                           return_value=forced_topic):
             md.return_value.get_drb_topics_by_category.return_value = [base]
+            md.return_value.get_all_drb_topics.return_value = [base]
             facs = {
                 'http': _RecordingBaseFactory(),
                 'odata': _ForcedFactory(),

drb-2.4.2/tests/test_scheme_force_impl.py

@@ -0,0 +1,170 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+import drb.topics.resolver as resolver_mod
+from drb.core.factory import DrbFactory
+from drb.nodes.logical_node import DrbLogicalNode
+from drb.exceptions.core import DrbFactoryException
+
+
+def _topic(factory, scheme, label='t'):
+    t = MagicMock()
+    t.factory = factory
+    t.scheme = scheme
+    t.label = label
+    return t
+
+
+class TestTopicBySchemeAny(unittest.TestCase):
+    def _call(self, scheme, topics):
+        with patch.object(resolver_mod, 'ManagerDao') as md:
+            md.return_value.get_all_drb_topics.return_value = topics
+            return resolver_mod._topic_by_scheme_any(scheme)
+
+    def test_returns_topic_any_category(self):
+        zip_t = _topic('zip', ['zip'])
+        result = self._call('zip', [_topic('aws3', ['s3']), zip_t])
+        self.assertIs(result, zip_t)
+
+    def test_returns_none_when_absent(self):
+        self.assertIsNone(self._call('nope', [_topic('aws3', ['s3'])]))
+
+    def test_raises_on_ambiguity(self):
+        a = _topic('f1', ['x'], 'A')
+        b = _topic('f2', ['x'], 'B')
+        with self.assertRaises(DrbFactoryException):
+            self._call('x', [a, b])
+
+
+class TestResolveToken(unittest.TestCase):
+    def test_via_scheme_index(self):
+        zip_t = _topic('zip', ['zip'])
+        fac = object()
+        with patch.object(resolver_mod, '_topic_by_scheme_any',
+                          return_value=zip_t), \
+             patch.object(resolver_mod.FactoryLoader, 'get_factory',
+                          return_value=fac) as gf:
+            topic, factory = resolver_mod._resolve_token('zip')
+        self.assertIs(topic, zip_t)
+        self.assertIs(factory, fac)
+        gf.assert_called_with('zip')          # looked up by topic.factory
+
+    def test_factory_name_fallback(self):
+        forced_t = _topic('odata', [])
+        fac = object()
+        with patch.object(resolver_mod, '_topic_by_scheme_any',
+                          return_value=None), \
+             patch.object(resolver_mod, '_topic_by_factory',
+                          return_value=forced_t), \
+             patch.object(resolver_mod.FactoryLoader, 'get_factory',
+                          return_value=fac):
+            topic, factory = resolver_mod._resolve_token('odata')
+        self.assertIs(topic, forced_t)
+        self.assertIs(factory, fac)
+
+    def test_factory_name_fallback_non_protocol_topic(self):
+        """Fallback path must accept a non-PROTOCOL (e.g. CONTAINER) topic."""
+        container_t = _topic('zip', [], 'ZipContainer')
+        fac = object()
+        with patch.object(resolver_mod, '_topic_by_scheme_any',
+                          return_value=None), \
+             patch.object(resolver_mod, '_topic_by_factory',
+                          return_value=container_t), \
+             patch.object(resolver_mod.FactoryLoader, 'get_factory',
+                          return_value=fac):
+            topic, factory = resolver_mod._resolve_token('zip')
+        self.assertIs(topic, container_t)
+        self.assertIs(factory, fac)
+
+    def test_factory_registered_but_no_topic_raises(self):
+        """When factory is registered but _topic_by_factory returns None,
+        a clear DrbFactoryException must be raised."""
+        fac = object()
+        with patch.object(resolver_mod, '_topic_by_scheme_any',
+                          return_value=None), \
+             patch.object(resolver_mod, '_topic_by_factory',
+                          return_value=None), \
+             patch.object(resolver_mod.FactoryLoader, 'get_factory',
+                          return_value=fac):
+            with self.assertRaises(DrbFactoryException):
+                resolver_mod._resolve_token('orphan')
+
+    def test_unknown_raises(self):
+        with patch.object(resolver_mod, '_topic_by_scheme_any',
+                          return_value=None), \
+             patch.object(resolver_mod.FactoryLoader, 'get_factory',
+                          return_value=None):
+            with self.assertRaises(DrbFactoryException):
+                resolver_mod._resolve_token('nosuch')
+
+    def test_scheme_topic_factory_not_installed_raises(self):
+        zip_t = _topic('zip', ['zip'])
+        with patch.object(resolver_mod, '_topic_by_scheme_any',
+                          return_value=zip_t), \
+             patch.object(resolver_mod.FactoryLoader, 'get_factory',
+                          return_value=None):
+            with self.assertRaises(DrbFactoryException):
+                resolver_mod._resolve_token('zip')
+
+
+class _TagFactory(DrbFactory):
+    """Records call order via a shared list; returns a tagged node."""
+    def __init__(self, tag, order):
+        self.tag = tag
+        self.order = order
+
+    def _create(self, node):
+        self.order.append(self.tag)
+        return DrbLogicalNode(self.tag)
+
+
+class TestMultiTokenDispatch(unittest.TestCase):
+    def test_ordered_stack(self):
+        order = []
+        base = _topic('http', ['https'])
+        oda = _topic('odata', ['odata'])
+        xml = _topic('xml', ['xml'])
+        tok = {'odata': oda, 'xml': xml}
+        facs = {
+            'http': _TagFactory('http', order),
+            'odata': _TagFactory('odata', order),
+            'xml': _TagFactory('xml', order),
+        }
+        r = resolver_mod._DrbFactoryResolver()
+        with patch.object(resolver_mod, '_topic_by_scheme',
+                          return_value=base), \
+             patch.object(resolver_mod, '_topic_by_scheme_any',
+                          side_effect=lambda s: tok.get(s)), \
+             patch.object(resolver_mod.FactoryLoader, 'get_factory',
+                          side_effect=lambda n: facs.get(n)):
+            t, n = r._DrbFactoryResolver__dispatch_scheme(
+                DrbLogicalNode('https+odata+xml://host/x'))
+        self.assertEqual(order, ['http', 'odata', 'xml'])
+        self.assertIs(t, xml)
+        self.assertEqual(n.name, 'xml')
+
+    def test_empty_segment_raises(self):
+        r = resolver_mod._DrbFactoryResolver()
+        with self.assertRaises(DrbFactoryException):
+            r._DrbFactoryResolver__dispatch_scheme(
+                DrbLogicalNode('https++xml://host'))
+
+    def test_unknown_base_returns_none(self):
+        r = resolver_mod._DrbFactoryResolver()
+        with patch.object(resolver_mod, '_topic_by_scheme',
+                          return_value=None):
+            self.assertIsNone(
+                r._DrbFactoryResolver__dispatch_scheme(
+                    DrbLogicalNode('ftp://host')))
+
+
+class TestTopicByFactory(unittest.TestCase):
+    def test_finds_container_category_topic(self):
+        """_topic_by_factory must find topics from any category, not just
+        PROTOCOL. Regression for the bug where only PROTOCOL topics were
+        searched."""
+        zip_t = _topic('zip', ['zip'], 'ZipContainer')
+        with patch.object(resolver_mod, 'ManagerDao') as md:
+            md.return_value.get_all_drb_topics.return_value = [zip_t]
+            result = resolver_mod._topic_by_factory('zip')
+        self.assertIs(result, zip_t)