drb 2.4.2__tar.gz → 2.4.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drb
-Version: 2.4.2
+Version: 2.4.4
 Summary: Data Request Broker
 Author: GAEL Systems
 Author-email: drb-python@gael.fr
@@ -65,8 +65,6 @@ You can also join the moderators team. Please contact me.
 
 Contribution process is based on gitlab best practice and processes the following schema:
 
-![](docs/modification_process.png)
-
 ### How to contribute
 Contributor shall work in its own fork of the project and provides its contributions via the merge request process.
 The merge request shall be approved and merged by a maintainers. So the step-by-step procedure to contribute is:

{drb-2.4.2 → drb-2.4.4}/README.md

@@ -36,8 +36,6 @@ You can also join the moderators team. Please contact me.
 
 Contribution process is based on gitlab best practice and processes the following schema:
 
-![](docs/modification_process.png)
-
 ### How to contribute
 Contributor shall work in its own fork of the project and provides its contributions via the merge request process.
 The merge request shall be approved and merged by a maintainers. So the step-by-step procedure to contribute is:

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-06-26T17:44:46+0000",
+ "date": "2026-06-30T02:14:50+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "d6abeea9ba11991cf33d5cc12fc33405c6032658",
- "version": "2.4.2"
+ "full-revisionid": "6de9fd1d1e819008ecdd4ddbd56a71bd2e99c4ab",
+ "version": "2.4.4"
 }
 '''  # END VERSION_JSON
 

{drb-2.4.2 → drb-2.4.4}/drb/signatures/core.py

@@ -1,10 +1,44 @@
+import re
+import logging
+
 from drb.core import DrbNode
 from drb.core.predicate import Predicate
 from drb.utils.drb_python_script import exec_with_return
 from drb.exceptions.core import DrbException
 from drb.core.signature import Signature, SignatureAggregator
-import re
-import logging
+
+
+_INLINE_FLAG_GROUP = re.compile(r'\(\?([aiLmsux]+)\)')
+_FLAG_CHARS = {'a': re.A, 'i': re.I, 'L': re.L, 'm': re.M,
+               's': re.S, 'u': re.U, 'x': re.X}
+
+
+def _compile_regex(pattern: str):
+    """Compile a regex, tolerating global inline flags (e.g. ``(?i)``)
+    placed anywhere in the pattern. Python 3.11+ rejects a global inline
+    flag that is not at position 0, but drb-java / legacy descriptors
+    author them after an anchor (``^(?i)...``). A bare ``(?i)`` group is
+    already global, so its flags are moved to the compile-time ``flags``
+    argument and the group is stripped from the pattern. Scoped groups
+    like ``(?i:...)`` (with a colon) are untouched.
+
+    Args:
+        pattern: The raw regex pattern string, possibly containing
+            global inline flag groups.
+
+    Returns:
+        A compiled :class:`re.Pattern` with any extracted flags applied.
+    """
+    chars = set()
+    for m in _INLINE_FLAG_GROUP.finditer(pattern):
+        chars.update(m.group(1))
+    if not chars:
+        return re.compile(pattern)
+    cleaned = _INLINE_FLAG_GROUP.sub('', pattern)
+    flags = 0
+    for ch in chars:
+        flags |= _FLAG_CHARS[ch]
+    return re.compile(cleaned, flags)
 
 
 class NameSignature(Signature):
@@ -16,9 +50,10 @@ class NameSignature(Signature):
 
     def __init__(self, regex: str):
         self.__regex = regex
+        self.__pattern = _compile_regex(regex)
 
     def matches(self, node: DrbNode) -> bool:
-        return re.match(self.__regex, node.name) is not None
+        return self.__pattern.match(node.name) is not None
 
     def to_dict(self) -> dict:
         return {self.get_name(): self.__regex}
@@ -37,9 +72,10 @@ class NamespaceSignature(Signature):
 
     def __init__(self, regex: str):
         self.__regex = regex
+        self.__pattern = _compile_regex(regex)
 
     def matches(self, node: DrbNode) -> bool:
-        return re.match(self.__regex, node.namespace_uri) is not None
+        return self.__pattern.match(node.namespace_uri) is not None
 
     def to_dict(self) -> dict:
         return {self.get_name(): self.__regex}
@@ -92,9 +128,10 @@ class PathSignature(Signature):
 
     def __init__(self, regex: str):
         self.__regex = regex
+        self.__pattern = _compile_regex(regex)
 
     def matches(self, node: DrbNode) -> bool:
-        return re.match(self.__regex, node.path.name) is not None
+        return self.__pattern.match(node.path.name) is not None
 
     def to_dict(self) -> dict:
         return {self.get_name(): self.__regex}

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

@@ -4,6 +4,7 @@ import logging
 import pathlib
 import sys
 import re
+import threading
 
 from urllib.parse import urlparse
 from typing import List, Optional, Tuple, Union
@@ -19,6 +20,8 @@ from drb.addons.addon import AddonManager
 
 logger = logging.getLogger('DrbResolver')
 
+_resolution_guard = threading.local()
+
 
 def _is_remote_url(parsed_path):
     """
@@ -227,7 +230,7 @@ class _DrbFactoryResolver(DrbFactory):
             DrbTopic: the finest topic matching the given node
         """
         topics = [x for x in ManagerDao().get_all_drb_topics()
-                  if x.subClassOf is not None if x.subClassOf[0] == finest.id]
+                  if x.subClassOf is not None if finest.id in x.subClassOf]
         for topic in topics:
             node = forced_factory(topic, node)
             if topic.matches(node):
@@ -283,6 +286,24 @@ class _DrbFactoryResolver(DrbFactory):
         pp = urlparse(url)
 
         if curl is None and path is None:
+            # Chained scheme "<base>+<forced>://": resolve the base URL
+            # normally -- walking the path through any container (e.g. a zip
+            # inside an S3 object) -- then apply each forced driver to the
+            # descended leaf. Without this, the forced token is crammed onto
+            # the whole-path base resource (e.g. an S3 object key that
+            # includes the in-archive path), which cannot be opened.
+            if pp.scheme and '+' in pp.scheme:
+                base, *tokens = pp.scheme.split('+')
+                if base == '' or any(t == '' for t in tokens):
+                    raise DrbFactoryException(
+                        f'Invalid scheme "{pp.scheme}": empty segment')
+                clean_url = base + url[len(pp.scheme):]
+                node = self.__create_from_url(clean_url)
+                for token in tokens:
+                    _, factory = _resolve_token(token)
+                    node = factory.create(node)
+                return node
+
             try:
                 return self.create(UrlNode(url))
             except (DrbFactoryException, DrbException,
@@ -338,38 +359,57 @@ class _DrbFactoryResolver(DrbFactory):
             node = UrlNode(source)
         else:
             node = source
-        protocol = None
-        if node.parent is None:
-            dispatched = self.__dispatch_scheme(node)
-            if dispatched is not None:
-                protocol, node = dispatched
+        active = getattr(_resolution_guard, 'active', None)
+        if active is None:
+            active = set()
+            _resolution_guard.active = active
+        try:
+            key = node.path.path
+        except Exception:  # noqa: BLE001
+            key = None
+        if key is not None and key in active:
+            raise DrbFactoryException(
+                f'Cyclic resolution detected for node path: {key}')
+        if key is not None:
+            active.add(key)
+        try:
+            protocol = None
+            if node.parent is None:
+                dispatched = self.__dispatch_scheme(node)
+                if dispatched is not None:
+                    protocol, node = dispatched
+                else:
+                    protocol = self.__retrieve_protocol(node)
+                    if protocol is None:
+                        raise DrbFactoryException(
+                            f'Cannot resolve: {source}')
+                    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)
+
+            formatting = self.__retrieve_formatting(node)
+            if formatting is not None:
+                if formatting.factory is not None:
+                    node = _create_via_factory(formatting, node)
+                t, n = self.__finest_drb_topic(node, formatting)
+            elif container is not None:
+                t, n = container, node
+            elif protocol is not None:
+                t, n = protocol, node
             else:
-                protocol = self.__retrieve_protocol(node)
-                if protocol is None:
-                    raise DrbFactoryException(f'Cannot resolve: {source}')
-                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)
-
-        formatting = self.__retrieve_formatting(node)
-        if formatting is not None:
-            if formatting.factory is not None:
-                node = _create_via_factory(formatting, node)
-            t, n = self.__finest_drb_topic(node, formatting)
-        elif container is not None:
-            t, n = container, node
-        elif protocol is not None:
-            t, n = protocol, node
-        else:
-            raise DrbFactoryException(f'Cannot resolve: {source}')
-
-        addons = filter(lambda x: x.can_apply(t),
-                        AddonManager().get_all_addons())
-        for addon in addons:
-            node.add_impl(addon.return_type(), addon.apply, addon.identifier())
-        return t, n
+                raise DrbFactoryException(f'Cannot resolve: {source}')
+
+            addons = filter(lambda x: x.can_apply(t),
+                            AddonManager().get_all_addons())
+            for addon in addons:
+                node.add_impl(
+                    addon.return_type(), addon.apply, addon.identifier())
+            return t, n
+        finally:
+            if key is not None:
+                active.discard(key)
 
     def resolve(self, source: Union[str, DrbNode]) \
             -> Tuple[DrbTopic, Optional[DrbNode]]:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drb
-Version: 2.4.2
+Version: 2.4.4
 Summary: Data Request Broker
 Author: GAEL Systems
 Author-email: drb-python@gael.fr
@@ -65,8 +65,6 @@ You can also join the moderators team. Please contact me.
 
 Contribution process is based on gitlab best practice and processes the following schema:
 
-![](docs/modification_process.png)
-
 ### How to contribute
 Contributor shall work in its own fork of the project and provides its contributions via the merge request process.
 The merge request shall be approved and merged by a maintainers. So the step-by-step procedure to contribute is:

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

@@ -86,6 +86,7 @@ tests/test_drb_python_script.py
 tests/test_event.py
 tests/test_factory.py
 tests/test_factory_resolver.py
+tests/test_finest_multiparent.py
 tests/test_implementation_coupling.py
 tests/test_implementation_manager.py
 tests/test_keyring_bitwarden.py
@@ -100,9 +101,12 @@ 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_resolver_recursion_guard.py
 tests/test_scheme_force_impl.py
+tests/test_scheme_force_url.py
 tests/test_signature_exact.py
 tests/test_signature_hierarchy.py
+tests/test_signature_inline_flags.py
 tests/test_signatures.py
 tests/test_topic.py
 tests/test_topic_descriptor_discovery.py

drb-2.4.4/tests/test_finest_multiparent.py

@@ -0,0 +1,71 @@
+import os
+import tempfile
+import unittest
+import uuid
+
+from drb.nodes.logical_node import DrbLogicalNode
+from drb.topics.dao import ManagerDao
+from drb.topics.dao.rdf_dao import RDFDao
+import drb.topics.resolver as resolver
+
+_IDS = ("a1a1a1a1-0000-0000-0000-00000000000a",
+        "b2b2b2b2-0000-0000-0000-00000000000b",
+        "c3c3c3c3-0000-0000-0000-00000000000c")
+
+_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#> .
+@prefix t:    <http://example.org/mp/> .
+
+t:base_a a owl:Class ; rdfs:label "mp_base_a" ;
+    drb:id "a1a1a1a1-0000-0000-0000-00000000000a" ;
+    drb:category "CONTAINER" ;
+    rdfs:subClassOf <http://www.gael.fr/drb#item> ;
+    drb:signature [ drb:nameMatch "mpnode" ] .
+t:base_b a owl:Class ; rdfs:label "mp_base_b" ;
+    drb:id "b2b2b2b2-0000-0000-0000-00000000000b" ;
+    drb:category "CONTAINER" ;
+    rdfs:subClassOf <http://www.gael.fr/drb#item> ;
+    drb:signature [ drb:nameMatch "mpnode" ] .
+t:child a owl:Class ; rdfs:label "mp_child" ;
+    drb:id "c3c3c3c3-0000-0000-0000-00000000000c" ;
+    drb:category "CONTAINER" ;
+    rdfs:subClassOf t:base_a, t:base_b ;
+    drb:signature [ drb:nameMatch "mpnode" ] .
+"""
+
+
+class TestFinestMultiParent(unittest.TestCase):
+    def setUp(self):
+        fd, self._ttl = tempfile.mkstemp(suffix=".ttl")
+        with os.fdopen(fd, "w") as f:
+            f.write(_TTL)
+        ManagerDao().add_dao_instance(RDFDao(self._ttl))
+        self.addCleanup(self._clean)
+
+    def _clean(self):
+        for u in _IDS:
+            try:
+                ManagerDao().delete(uuid.UUID(u))
+            except Exception:
+                pass
+        try:
+            os.unlink(self._ttl)
+        except OSError:
+            pass
+
+    def test_descends_via_non_first_parent(self):
+        topics = ManagerDao().get_all_drb_topics()
+        child = [t for t in topics
+                 if t.uri and t.uri.endswith('/mp/child')][0]
+        # child has two parents; pick one that is NOT subClassOf[0]
+        self.assertEqual(2, len(child.subClassOf))
+        non_first = child.subClassOf[1]
+        parent = [t for t in topics if t.id == non_first][0]
+        res = resolver._DrbFactoryResolver()
+        node = DrbLogicalNode("mpnode")
+        topic, _ = res._DrbFactoryResolver__finest_drb_topic(node, parent)
+        self.assertTrue(
+            str(topic.uri).endswith('/mp/child'),
+            f"descent stopped at {topic.uri}, expected .../mp/child")

drb-2.4.4/tests/test_resolver_recursion_guard.py

@@ -0,0 +1,65 @@
+import os
+import tempfile
+import unittest
+
+import drb.topics.resolver as resolver
+from drb.nodes.logical_node import DrbLogicalNode
+from drb.topics.dao import ManagerDao
+from drb.topics.dao.rdf_dao import RDFDao
+from drb.topics.resolver import DrbNodeList
+
+
+# A node whose resolved children list contains itself -> a resolution cycle.
+class _CyclicNode(DrbLogicalNode):
+    @property
+    def children(self):
+        return DrbNodeList([self])
+
+
+_LOOP_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#> .
+@prefix t:    <http://example.org/test/> .
+
+t:loop a owl:Class ;
+    rdfs:label "loop" ;
+    drb:id "aaaaaaaa-0000-0000-0000-000000000001" ;
+    drb:category "CONTAINER" ;
+    rdfs:subClassOf <http://www.gael.fr/drb#item> ;
+    drb:signature [ drb:nameMatch "loop" ;
+                    drb:xqueryTest "*[fn:matches(fn:name(),'loop')]" ] .
+"""
+
+
+class TestResolverRecursionGuard(unittest.TestCase):
+    def setUp(self):
+        fd, self._ttl = tempfile.mkstemp(suffix=".ttl")
+        with os.fdopen(fd, "w") as f:
+            f.write(_LOOP_TTL)
+        self._dao = ManagerDao().add_dao_instance(RDFDao(self._ttl))
+        self.addCleanup(self._cleanup)
+
+    def _cleanup(self):
+        try:
+            import uuid
+            ManagerDao().delete(
+                uuid.UUID("aaaaaaaa-0000-0000-0000-000000000001"))
+        except Exception:
+            pass
+        try:
+            os.unlink(self._ttl)
+        except OSError:
+            pass
+
+    def test_cyclic_resolution_terminates(self):
+        # Without the guard this recurses without bound (RecursionError, then
+        # swallowed -> DrbFactoryException); with the guard it terminates and
+        # classifies the node as the 'loop' container.
+        # The node must have a parent so the resolver skips the protocol/root
+        # dispatch path and goes directly to container signature matching,
+        # where the xquery '*' iterates children via DrbNodeList -> create().
+        parent = DrbLogicalNode("root")
+        node = _CyclicNode("loop", parent=parent)
+        topic, _ = resolver.resolve(node)
+        self.assertEqual("loop", topic.label)

drb-2.4.4/tests/test_scheme_force_url.py

@@ -0,0 +1,81 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+import drb.topics.resolver as resolver_mod
+from drb.core.factory import DrbFactory
+from drb.core.node import DrbNode
+from drb.nodes.logical_node import DrbLogicalNode
+from drb.nodes.url_node import UrlNode
+from drb.exceptions.core import DrbFactoryException
+
+
+class _WrapFactory(DrbFactory):
+    """Wraps the received node and records the call order on a shared list."""
+    def __init__(self, tag, order):
+        self.tag = tag
+        self.order = order
+
+    def _create(self, node: DrbNode) -> DrbNode:
+        self.order.append(self.tag)
+        wrapped = DrbLogicalNode(self.tag)
+        wrapped.append_child(node)
+        return wrapped
+
+
+class TestForcedSchemeUrl(unittest.TestCase):
+    """``__create_from_url`` on a chained ``<base>+<forced>://`` scheme must
+    resolve the *base* URL (token stripped, so the existing path-walking can
+    descend any container) and then apply each forced driver to the resulting
+    leaf -- not cram the forced driver onto the whole-path base resource.
+    """
+
+    def _from_url(self, url, base_leaf, token_factories):
+        r = resolver_mod._DrbFactoryResolver()
+        with patch.object(r, 'create', return_value=base_leaf) as create, \
+             patch.object(resolver_mod, '_resolve_token',
+                          side_effect=lambda tok: (MagicMock(),
+                                                   token_factories[tok])):
+            result = r._DrbFactoryResolver__create_from_url(url)
+        return result, create
+
+    def test_base_url_resolved_with_token_stripped(self):
+        leaf = DrbLogicalNode('base-leaf')
+        order = []
+        result, create = self._from_url(
+            's3+xml://bucket/a.zip/inner', leaf,
+            {'xml': _WrapFactory('xml', order)})
+        # The base resolution must receive the clean s3:// URL.
+        self.assertEqual(1, create.call_count)
+        received = create.call_args[0][0]
+        self.assertIsInstance(received, UrlNode)
+        self.assertEqual('s3', received.path.scheme)
+        self.assertEqual('s3://bucket/a.zip/inner', received.path.name)
+
+    def test_forced_driver_applied_to_base_leaf(self):
+        leaf = DrbLogicalNode('base-leaf')
+        order = []
+        result, _ = self._from_url(
+            's3+xml://bucket/a.zip/inner', leaf,
+            {'xml': _WrapFactory('xml', order)})
+        self.assertEqual('xml', result.name)            # forced driver on top
+        self.assertEqual('base-leaf', result[0].name)   # wrapping the leaf
+        self.assertEqual(['xml'], order)
+
+    def test_multiple_tokens_applied_in_order(self):
+        leaf = DrbLogicalNode('base-leaf')
+        order = []
+        result, _ = self._from_url(
+            'https+odata+xml://host/x', leaf,
+            {'odata': _WrapFactory('odata', order),
+             'xml': _WrapFactory('xml', order)})
+        self.assertEqual(['odata', 'xml'], order)
+        self.assertEqual('xml', result.name)
+
+    def test_empty_scheme_segment_raises(self):
+        r = resolver_mod._DrbFactoryResolver()
+        with self.assertRaises(DrbFactoryException):
+            r._DrbFactoryResolver__create_from_url('s3++xml://host/x')
+
+
+if __name__ == '__main__':
+    unittest.main()

drb-2.4.4/tests/test_signature_inline_flags.py

@@ -0,0 +1,18 @@
+import unittest
+
+from drb.nodes.logical_node import DrbLogicalNode
+from drb.signatures.core import NameSignature
+
+
+class TestNameSignatureInlineFlags(unittest.TestCase):
+    def test_misplaced_inline_flag_compiles_and_matches(self):
+        # (?i) after the ^ anchor: invalid as a raw py3.11 regex.
+        sig = NameSignature(r'^(?i)S2[AB]_.*\.SAFE$')
+        self.assertTrue(sig.matches(DrbLogicalNode('S2B_x.SAFE')))
+        # global case-insensitivity preserved
+        self.assertTrue(sig.matches(DrbLogicalNode('s2b_x.safe')))
+        self.assertFalse(sig.matches(DrbLogicalNode('X9_x.SAFE')))
+
+    def test_to_dict_keeps_the_original_pattern(self):
+        pat = r'^(?i)S2[AB]_.*\.SAFE$'
+        self.assertEqual({'name': pat}, NameSignature(pat).to_dict())