drb 2.3.8__tar.gz → 2.3.9__tar.gz

{drb-2.3.8/drb.egg-info → drb-2.3.9}/PKG-INFO

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

{drb-2.3.8 → drb-2.3.9}/drb/core/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-06-25T20:48:59+0000",
+ "date": "2026-06-25T22:03:16+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "15fc9c3ff4c5c9f27c0ec6e7bba7d7c3e3885305",
- "version": "2.3.8"
+ "full-revisionid": "e77eb7f024e245d4ecab611276e4c247ccdd516a",
+ "version": "2.3.9"
 }
 '''  # END VERSION_JSON
 

{drb-2.3.8 → drb-2.3.9}/drb/topics/dao/rdf_dao.py

@@ -91,6 +91,9 @@ class RDFDao(DrbTopicDao):
                 (GROUP_CONCAT(DISTINCT IF(BOUND(?parentClassId),
                 STR(?parentClassId),
                 ?parentClass); separator="§ ") AS ?parentClasses)
+                (GROUP_CONCAT(DISTINCT IF(BOUND(?scheme),
+                STR(?scheme), ""); separator=" ")
+                AS ?schemes)
                 WHERE {
                 {
                   ?Class rdfs:subClassOf+ <http://www.gael.fr/drb#item> .
@@ -101,6 +104,7 @@ class RDFDao(DrbTopicDao):
                 OPTIONAL { ?Class drb:id ?id .}
                 OPTIONAL { ?Class drb:category ?category .}
                 OPTIONAL { ?Class drb:implementationIdentifier ?factory .}
+                OPTIONAL { ?Class drb:scheme ?scheme .}
                 OPTIONAL {
                 ?Class rdfs:subClassOf ?parentClass .
                 OPTIONAL { ?parentClass drb:id ?parentClassId .}
@@ -190,6 +194,9 @@ class RDFDao(DrbTopicDao):
         if row.factory is not None:
             data['factory'] = row.factory.toPython()
 
+        schemes = str(row.schemes) if row.schemes is not None else ''
+        data['scheme'] = schemes.split() if schemes else []
+
         data['subClassOf'] = None
 
         if uri_parents is not None:

{drb-2.3.8 → drb-2.3.9}/drb/topics/resolver.py

@@ -10,7 +10,6 @@ from typing import List, Optional, Tuple, Union
 
 from drb.core.node import DrbNode
 from drb.core.factory import DrbFactory, FactoryLoader
-from drb.core.protocol import ProtocolLoader
 from drb.topics.topic import DrbTopic, TopicCategory
 from drb.exceptions.core import DrbFactoryException, DrbException
 from drb.nodes.url_node import UrlNode
@@ -55,7 +54,6 @@ def _create_via_factory(topic: DrbTopic, node: DrbNode) -> DrbNode:
 
 def _topic_by_factory(name: str):
     """The PROTOCOL topic whose implementationIdentifier == name, or None."""
-    from drb.topics.dao import ManagerDao
     for topic in ManagerDao().get_drb_topics_by_category(
             TopicCategory.PROTOCOL):
         if topic.factory == name:
@@ -63,6 +61,15 @@ def _topic_by_factory(name: str):
     return None
 
 
+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(
+            TopicCategory.PROTOCOL):
+        if scheme in (topic.scheme or []):
+            return topic
+    return None
+
+
 class _DrbFactoryResolver(DrbFactory):
     """ The factory resolver
 
@@ -100,22 +107,25 @@ class _DrbFactoryResolver(DrbFactory):
         return None
 
     def __dispatch_scheme(self, node):
-        """Dispatch a root URL by its scheme via drb.protocol, then apply a
-        ``+<name>`` forced driver if present. Returns (topic, node) or None
-        when the base scheme is not registered (caller falls back to
-        signature matching)."""
+        """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)."""
         scheme = node.path.scheme
         if not scheme:
             return None
         parts = scheme.split('+', 1)
         base = parts[0]
         forced = parts[1] if len(parts) > 1 else None
-        base_factory = ProtocolLoader().get_factory(base)
+        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
         created = base_factory.create(node)
         if forced is None:
-            return _topic_by_factory(base), created
+            return base_topic, created
         forced_factory = FactoryLoader().get_factory(forced)
         if forced_factory is None:
             raise DrbFactoryException(

{drb-2.3.8 → drb-2.3.9}/drb/topics/topic.py

@@ -31,6 +31,7 @@ class DrbTopic:
     factory: str = field(default=None, repr=False)
     description: str = field(default=None, repr=False)
     forced: bool = field(default=False, repr=False)
+    scheme: List[str] = field(default_factory=list, repr=False)
     signatures: List[Signature] = field(default=None, repr=False)
     override: bool = field(default=False, repr=False)
 

{drb-2.3.8 → drb-2.3.9/drb.egg-info}/PKG-INFO

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

{drb-2.3.8 → drb-2.3.9}/drb.egg-info/SOURCES.txt

@@ -25,7 +25,6 @@ drb/core/item.py
 drb/core/node.py
 drb/core/path.py
 drb/core/predicate.py
-drb/core/protocol.py
 drb/core/signature.py
 drb/drivers/file/__init__.py
 drb/drivers/file/file.py
@@ -94,9 +93,9 @@ tests/test_node_context.py
 tests/test_node_descendant.py
 tests/test_path.py
 tests/test_protocol_dispatch.py
-tests/test_protocol_loader.py
 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_signature_exact.py
 tests/test_signature_hierarchy.py

{drb-2.3.8 → drb-2.3.9}/setup.cfg

@@ -25,7 +25,6 @@ console_scripts =
 drb.driver = 
 	xml = drb.drivers.xml:XmlNodeFactory
 	file = drb.drivers.file.file:DrbFileFactory
-drb.protocol = 
 drb.topic = 
 	xml = drb.topics.xml
 	file = drb.topics.file

drb-2.3.9/tests/test_protocol_dispatch.py

@@ -0,0 +1,102 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from drb.core.factory import DrbFactory
+from drb.core.node import DrbNode
+from drb.nodes.logical_node import DrbLogicalNode
+import drb.topics.resolver as resolver_mod
+
+
+class _Node(DrbLogicalNode):
+    pass
+
+
+class _BaseFactory(DrbFactory):
+    def _create(self, node: DrbNode) -> DrbNode:
+        return _Node('dispatched')
+
+
+class _ForcedNode(DrbLogicalNode):
+    pass
+
+
+class _ForcedFactory(DrbFactory):
+    received = None
+
+    def _create(self, node: DrbNode) -> DrbNode:
+        _ForcedFactory.received = node
+        return _ForcedNode('forced')
+
+
+def _topic(factory, scheme):
+    t = MagicMock()
+    t.factory = factory
+    t.scheme = scheme
+    return t
+
+
+class TestSchemeDispatch(unittest.TestCase):
+    def _resolve(self, url, protocol_topics, factories):
+        r = resolver_mod._DrbFactoryResolver()
+        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 = \
+                protocol_topics
+            gf.side_effect = lambda name: factories.get(name)
+            return r._DrbFactoryResolver__dispatch_scheme(DrbLogicalNode(url))
+
+    def test_scheme_decoupled_from_factory(self):
+        topic = _topic('aws3', ['s3'])
+        result = self._resolve('s3://bucket/key', [topic],
+                               {'aws3': _BaseFactory()})
+        self.assertIsNotNone(result)
+        t, n = result
+        self.assertIs(t, topic)
+        self.assertIsInstance(n, _Node)
+
+    def test_two_topics_one_factory_pick_right(self):
+        http = _topic('http', ['http'])
+        https = _topic('http', ['https'])
+        result = self._resolve('https://host', [http, https],
+                               {'http': _BaseFactory()})
+        t, _ = result
+        self.assertIs(t, https)
+
+    def test_unknown_scheme_returns_none(self):
+        topic = _topic('aws3', ['s3'])
+        self.assertIsNone(
+            self._resolve('ftp://h', [topic], {'aws3': _BaseFactory()}))
+
+    def test_factory_absent_returns_none(self):
+        topic = _topic('aws3', ['s3'])
+        self.assertIsNone(
+            self._resolve('s3://b', [topic], {}))   # aws3 not installed
+
+    def test_force_by_name(self):
+        base = _topic('http', ['https'])
+        forced = _topic('odata', [])
+        r = resolver_mod._DrbFactoryResolver()
+        with patch.object(resolver_mod, 'ManagerDao') as md, \
+             patch.object(resolver_mod.FactoryLoader, 'get_factory') as gf, \
+             patch.object(resolver_mod, '_topic_by_factory',
+                          return_value=forced):
+            md.return_value.get_drb_topics_by_category.return_value = [base]
+            facs = {'http': _BaseFactory(), 'odata': _ForcedFactory()}
+            gf.side_effect = lambda name: facs.get(name)
+            t, n = r._DrbFactoryResolver__dispatch_scheme(
+                DrbLogicalNode('https+odata://host'))
+        self.assertIs(t, forced)
+        self.assertIsInstance(n, _ForcedNode)
+        self.assertIsInstance(_ForcedFactory.received, _Node)
+
+    def test_unknown_forced_raises(self):
+        base = _topic('http', ['https'])
+        from drb.exceptions.core import DrbFactoryException
+        r = resolver_mod._DrbFactoryResolver()
+        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]
+            gf.side_effect = lambda name: (
+                {'http': _BaseFactory()}).get(name)
+            with self.assertRaises(DrbFactoryException):
+                r._DrbFactoryResolver__dispatch_scheme(
+                    DrbLogicalNode('https+nosuch://host'))

drb-2.3.9/tests/test_rdf_dao_scheme.py

@@ -0,0 +1,34 @@
+import os
+import tempfile
+import unittest
+from drb.topics.dao.rdf_dao import RDFDao
+
+_TTL = '''
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix drb: <http://www.gael.fr/drb#> .
+<http://www.gael.fr/drb#> a owl:Ontology .
+
+drb:s3demo a owl:Class ;
+   drb:id "66666666-6666-6666-6666-666666666666" ;
+   drb:category "PROTOCOL" ;
+   rdfs:subClassOf drb:item ;
+   rdfs:label "s3demo" ;
+   drb:scheme "s3" ;
+   drb:implementationIdentifier "aws3" .
+'''
+
+
+class TestRdfDaoScheme(unittest.TestCase):
+    def test_scheme_parsed_into_topic(self):
+        fd, path = tempfile.mkstemp(suffix='.ttl')
+        os.close(fd)
+        with open(path, 'w') as f:
+            f.write(_TTL)
+        try:
+            dao = RDFDao(path)
+            topic = next(t for t in dao.read_all() if t.label == 's3demo')
+            self.assertEqual(['s3'], topic.scheme)
+            self.assertEqual('aws3', topic.factory)
+        finally:
+            os.remove(path)

drb-2.3.8/drb/core/protocol.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-import importlib
-import inspect
-import logging
-from typing import Optional
-
-import drb.utils.plugins
-from drb.core.factory import DrbFactory
-
-
-class ProtocolLoader:
-    """Loads ``drb.protocol`` entry points into a scheme -> factory map.
-
-    Each entry point's name is a URL scheme (e.g. ``s3``, ``https``) and its
-    value is ``module:FactoryClass`` (a ``DrbFactory`` subclass). Mirrors
-    :class:`drb.core.factory.FactoryLoader`.
-    """
-    __instance = None
-    __factories = None
-
-    def __new__(cls, *args, **kwargs):
-        if cls.__instance is None:
-            cls.__instance = super(ProtocolLoader, cls).__new__(cls)
-            cls.__factories = cls.__load()
-        return cls.__instance
-
-    @classmethod
-    def __is_class(cls, class_name: str):
-        return lambda obj: inspect.isclass(obj) and class_name == obj.__name__
-
-    @classmethod
-    def __load(cls) -> dict:
-        factories = {}
-        for ep in drb.utils.plugins.get_entry_points('drb.protocol'):
-            if ep.name in factories:
-                continue
-            m, c = ep.value.split(':')
-            try:
-                module = importlib.import_module(m)
-                for _, obj in inspect.getmembers(module, cls.__is_class(c)):
-                    if obj != DrbFactory and issubclass(obj, DrbFactory):
-                        factories[ep.name] = obj()
-                    else:
-                        logging.getLogger().warning(
-                            f'Failed to load protocol "{ep.name}": '
-                            f'invalid factory: {ep.value}')
-            except ModuleNotFoundError:
-                logging.getLogger().warning(
-                    f'Failed to load protocol "{ep.name}": module {m} '
-                    f'not found')
-        return factories
-
-    def get_schemes(self) -> set:
-        return set(self.__factories.keys())
-
-    def get_factory(self, scheme: str) -> Optional[DrbFactory]:
-        return self.__factories.get(scheme, None)

drb-2.3.8/tests/test_protocol_dispatch.py

@@ -1,115 +0,0 @@
-import unittest
-from unittest.mock import patch, MagicMock
-import drb.core.protocol as protocol_mod
-from drb.core.factory import DrbFactory
-from drb.core.node import DrbNode
-from drb.nodes.logical_node import DrbLogicalNode
-import drb.topics.resolver as resolver_mod
-
-
-class _SchemeNode(DrbLogicalNode):
-    pass
-
-
-class _BaseFactory(DrbFactory):
-    def _create(self, node: DrbNode) -> DrbNode:
-        n = _SchemeNode('dispatched')
-        return n
-
-
-class TestProtocolDispatch(unittest.TestCase):
-    def setUp(self):
-        protocol_mod.ProtocolLoader._ProtocolLoader__instance = None
-        protocol_mod.ProtocolLoader._ProtocolLoader__factories = None
-
-    def _loader_with(self, scheme, factory):
-        ep = MagicMock()
-        ep.name = scheme
-        ep.value = f'{__name__}:{type(factory).__name__}'
-        with patch.object(protocol_mod.drb.utils.plugins, 'get_entry_points',
-                          return_value=[ep]):
-            return protocol_mod.ProtocolLoader()
-
-    def test_base_scheme_dispatch_creates_node(self):
-        loader = self._loader_with('foo', _BaseFactory())
-        topic = MagicMock()
-        topic.factory = 'foo'
-        with patch.object(
-                resolver_mod, 'ProtocolLoader', return_value=loader), \
-             patch.object(
-                resolver_mod, '_topic_by_factory', return_value=topic):
-            r = resolver_mod._DrbFactoryResolver()
-            result = r._DrbFactoryResolver__dispatch_scheme(
-                DrbLogicalNode('foo://host/x'))
-        self.assertIsNotNone(result)
-        t, n = result
-        self.assertIs(t, topic)
-        self.assertIsInstance(n, _SchemeNode)
-
-    def test_unknown_scheme_returns_none(self):
-        loader = self._loader_with('foo', _BaseFactory())
-        with patch.object(resolver_mod, 'ProtocolLoader',
-                          return_value=loader):
-            r = resolver_mod._DrbFactoryResolver()
-            result = r._DrbFactoryResolver__dispatch_scheme(
-                DrbLogicalNode('bar://host/x'))
-        self.assertIsNone(result)
-
-
-class _ForcedNode(DrbLogicalNode):
-    pass
-
-
-class _ForcedFactory(DrbFactory):
-    received = None
-
-    def _create(self, node: DrbNode) -> DrbNode:
-        _ForcedFactory.received = node
-        return _ForcedNode('forced')
-
-
-class TestForceByName(unittest.TestCase):
-    def setUp(self):
-        protocol_mod.ProtocolLoader._ProtocolLoader__instance = None
-        protocol_mod.ProtocolLoader._ProtocolLoader__factories = None
-        _ForcedFactory.received = None
-
-    def test_force_applies_named_factory(self):
-        ep = MagicMock()
-        ep.name = 'foo'
-        ep.value = f'{__name__}:_BaseFactory'
-        with patch.object(protocol_mod.drb.utils.plugins, 'get_entry_points',
-                          return_value=[ep]):
-            loader = protocol_mod.ProtocolLoader()
-        forced = _ForcedFactory()
-        forced_topic = MagicMock()
-        forced_topic.factory = 'bar'
-        with patch.object(
-                resolver_mod, 'ProtocolLoader', return_value=loader), \
-             patch.object(resolver_mod.FactoryLoader, 'get_factory',
-                          return_value=forced), \
-             patch.object(resolver_mod, '_topic_by_factory',
-                          return_value=forced_topic):
-            r = resolver_mod._DrbFactoryResolver()
-            t, n = r._DrbFactoryResolver__dispatch_scheme(
-                DrbLogicalNode('foo+bar://host/x'))
-        self.assertIs(t, forced_topic)
-        self.assertIsInstance(n, _ForcedNode)
-        self.assertIsInstance(_ForcedFactory.received, _SchemeNode)
-
-    def test_unknown_forced_name_raises(self):
-        ep = MagicMock()
-        ep.name = 'foo'
-        ep.value = f'{__name__}:_BaseFactory'
-        with patch.object(protocol_mod.drb.utils.plugins, 'get_entry_points',
-                          return_value=[ep]):
-            loader = protocol_mod.ProtocolLoader()
-        from drb.exceptions.core import DrbFactoryException
-        with patch.object(
-                resolver_mod, 'ProtocolLoader', return_value=loader), \
-             patch.object(resolver_mod.FactoryLoader, 'get_factory',
-                          return_value=None):
-            r = resolver_mod._DrbFactoryResolver()
-            with self.assertRaises(DrbFactoryException):
-                r._DrbFactoryResolver__dispatch_scheme(
-                    DrbLogicalNode('foo+nosuch://host/x'))

drb-2.3.8/tests/test_protocol_loader.py

@@ -1,29 +0,0 @@
-import unittest
-from unittest.mock import patch, MagicMock
-import drb.core.protocol as protocol_mod
-from drb.core.factory import DrbFactory
-from drb.core.node import DrbNode
-
-
-class _FakeProtoFactory(DrbFactory):
-    def _create(self, node: DrbNode) -> DrbNode:
-        return node
-
-
-class TestProtocolLoader(unittest.TestCase):
-    def setUp(self):
-        # reset the singleton so each test loads its own entry points
-        protocol_mod.ProtocolLoader._ProtocolLoader__instance = None
-        protocol_mod.ProtocolLoader._ProtocolLoader__factories = None
-
-    def test_loads_scheme_to_factory(self):
-        ep = MagicMock()
-        ep.name = 'testscheme'
-        ep.value = f'{__name__}:_FakeProtoFactory'
-        with patch.object(protocol_mod.drb.utils.plugins, 'get_entry_points',
-                          return_value=[ep]):
-            loader = protocol_mod.ProtocolLoader()
-        self.assertIn('testscheme', loader.get_schemes())
-        self.assertIsInstance(loader.get_factory('testscheme'),
-                              _FakeProtoFactory)
-        self.assertIsNone(loader.get_factory('absent'))