drb 2.4.3__tar.gz → 2.4.4__tar.gz

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

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

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-06-26T23:35:37+0000",
+ "date": "2026-06-30T02:14:50+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "3fe10812b0582229d483dc9325051d2e70c16653",
- "version": "2.4.3"
+ "full-revisionid": "6de9fd1d1e819008ecdd4ddbd56a71bd2e99c4ab",
+ "version": "2.4.4"
 }
 '''  # END VERSION_JSON
 

{drb-2.4.3 → 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.3 → 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):
@@ -356,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.3 → drb-2.4.4/drb.egg-info}/PKG-INFO

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

{drb-2.4.3 → 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,10 +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_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())