rebulk 4.2.0__tar.gz → 4.2.2__tar.gz

{rebulk-4.2.0 → rebulk-4.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rebulk
-Version: 4.2.0
+Version: 4.2.2
 Summary: Rebulk - Define simple search patterns in bulk to perform advanced matching on any string.
 Keywords: re,regexp,regular expression,search,pattern,string,match
 Author: Rémi Alvergnat

{rebulk-4.2.0 → rebulk-4.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rebulk"
-version = "4.2.0"
+version = "4.2.2"
 description = "Rebulk - Define simple search patterns in bulk to perform advanced matching on any string."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -105,6 +105,11 @@ select = [
 python_version = "3.10"
 files = ["rebulk"]
 strict = true
+
+[[tool.mypy.overrides]]
+# `regex` (the optional `native` extra) ships no type information; scope the
+# relaxation to it instead of silencing missing imports across the whole project.
+module = ["regex.*"]
 ignore_missing_imports = true
 
 [tool.pytest.ini_options]

{rebulk-4.2.0 → rebulk-4.2.2}/rebulk/__version__.py

@@ -3,5 +3,4 @@
 Version module
 """
 
-# pragma: no cover
-__version__ = "4.2.0"
+__version__ = "4.2.2"

{rebulk-4.2.0 → rebulk-4.2.2}/rebulk/chain.py

@@ -216,7 +216,10 @@ class Chain(Pattern, Builder):
     @staticmethod
     def _group_by_match_index(matches: Iterable[Match]) -> dict[int, list[Match]]:
         grouped_matches_dict: dict[int, list[Match]] = {}
-        for match_index, match in itertools.groupby(matches, lambda m: m.match_index):
+        # groupby only groups consecutive equal keys, so sort by match_index first
+        # to avoid splitting (and overwriting) groups when matches are unordered.
+        sorted_matches = sorted(matches, key=lambda m: m.match_index)
+        for match_index, match in itertools.groupby(sorted_matches, lambda m: m.match_index):
             grouped_matches_dict[match_index] = list(match)
         return grouped_matches_dict
 

{rebulk-4.2.0 → rebulk-4.2.2}/rebulk/loose.py

@@ -5,17 +5,9 @@ Various utilities functions
 
 from __future__ import annotations
 
-from inspect import isclass
+from inspect import getfullargspec, isclass
 from typing import TYPE_CHECKING, Any, cast
 
-try:
-    from inspect import getfullargspec as getargspec
-
-    _FULLARGSPEC_SUPPORTED = True
-except ImportError:
-    _FULLARGSPEC_SUPPORTED = False
-    from inspect import getargspec  # type: ignore[assignment]  # removed in Python 3.11, dead on supported versions
-
 from .utils import is_iterable
 
 if TYPE_CHECKING:
@@ -66,7 +58,7 @@ def function_args(callable_: Any, *args: Any, **kwargs: Any) -> tuple[Any, Any]:
     :return: (args, kwargs) matching the function signature
     :rtype: tuple
     """
-    argspec = getargspec(callable_)
+    argspec = getfullargspec(callable_)
     return argspec_args(argspec, False, *args, **kwargs)
 
 
@@ -83,7 +75,7 @@ def constructor_args(class_: Any, *args: Any, **kwargs: Any) -> tuple[Any, Any]:
     :return: (args, kwargs) matching the function signature
     :rtype: tuple
     """
-    argspec = getargspec(_constructor(class_))
+    argspec = getfullargspec(_constructor(class_))
     return argspec_args(argspec, True, *args, **kwargs)
 
 
@@ -107,30 +99,6 @@ def argspec_args(argspec: FullArgSpec, constructor: bool, *args: Any, **kwargs:
     return call_args, call_kwarg
 
 
-if not _FULLARGSPEC_SUPPORTED:
-
-    def argspec_args_legacy(argspec: Any, constructor: bool, *args: Any, **kwargs: Any) -> tuple[Any, Any]:
-        """
-        Return (args, kwargs) matching the argspec object
-
-        :param argspec: argspec to use
-        :type argspec: argspec
-        :param constructor: is it a constructor ?
-        :type constructor: bool
-        :param args:
-        :type args:
-        :param kwargs:
-        :type kwargs:
-        :return: (args, kwargs) matching the function signature
-        :rtype: tuple
-        """
-        call_kwarg = kwargs if argspec.keywords else {k: kwargs[k] for k in kwargs if k in argspec.args}
-        call_args = args if argspec.varargs else args[: len(argspec.args) - (1 if constructor else 0)]
-        return call_args, call_kwarg
-
-    argspec_args = argspec_args_legacy
-
-
 def ensure_list(param: Any) -> list[Any]:
     """
     Retrieves a list from given parameter.

{rebulk-4.2.0 → rebulk-4.2.2}/rebulk/match.py

@@ -1164,7 +1164,11 @@ class Match:
         return self.end - self.start
 
     def __hash__(self) -> int:
-        return hash(Match) + hash(self.start) + hash(self.end) + hash(self.value)
+        # Hash on the span only (a subset of the __eq__ fields), never on the
+        # mutable value: a match kept in a set/dict must stay findable after its
+        # value is changed. Equal matches still share a hash; same-span matches
+        # with different values collide harmlessly and __eq__ tells them apart.
+        return hash((Match, self.start, self.end))
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Match):

{rebulk-4.2.0 → rebulk-4.2.2}/rebulk/pattern.py

@@ -20,6 +20,11 @@ if TYPE_CHECKING:
     from collections.abc import Callable, Iterator, Sequence
 
 
+def _callable_or_none(value: Any) -> Callable[..., Any] | None:
+    """Return ``value`` if it is callable, else ``None``."""
+    return value if callable(value) else None
+
+
 class BasePattern(metaclass=ABCMeta):
     """
     Base class for Pattern like objects
@@ -144,21 +149,9 @@ class Pattern(BasePattern, metaclass=ABCMeta):
         self._log_level = log_level
         self._properties = properties
         self.defined_at = debug.defined_at()
-        self.post_processor: Callable[..., Any] | None
-        if not callable(post_processor):
-            self.post_processor = None
-        else:
-            self.post_processor = post_processor
-        self.pre_match_processor: Callable[..., Any] | None
-        if not callable(pre_match_processor):
-            self.pre_match_processor = None
-        else:
-            self.pre_match_processor = pre_match_processor
-        self.post_match_processor: Callable[..., Any] | None
-        if not callable(post_match_processor):
-            self.post_match_processor = None
-        else:
-            self.post_match_processor = post_match_processor
+        self.post_processor = _callable_or_none(post_processor)
+        self.pre_match_processor = _callable_or_none(pre_match_processor)
+        self.post_match_processor = _callable_or_none(post_match_processor)
 
     @property
     def log_level(self) -> int:
@@ -517,32 +510,22 @@ class RePattern(Pattern):
                 for i in range(1, pattern.groups + 1):
                     name = names.get(i, main_match.name)
                     if self.repeated_captures:
-                        for start, end in match_object.spans(i):
-                            child_match = Match(
-                                start,
-                                end,
-                                name=name,
-                                parent=main_match,
-                                pattern=self,
-                                input_string=input_string,
-                                **self._children_match_kwargs,
-                            )
-                            if child_match:
-                                main_match.children.append(child_match)
+                        spans = match_object.spans(i)
                     else:
-                        start, end = match_object.span(i)
-                        if start > -1 and end > -1:
-                            child_match = Match(
-                                start,
-                                end,
-                                name=name,
-                                parent=main_match,
-                                pattern=self,
-                                input_string=input_string,
-                                **self._children_match_kwargs,
-                            )
-                            if child_match:
-                                main_match.children.append(child_match)
+                        span = match_object.span(i)
+                        spans = [span] if span[0] > -1 and span[1] > -1 else []
+                    for child_start, child_end in spans:
+                        child_match = Match(
+                            child_start,
+                            child_end,
+                            name=name,
+                            parent=main_match,
+                            pattern=self,
+                            input_string=input_string,
+                            **self._children_match_kwargs,
+                        )
+                        if child_match:
+                            main_match.children.append(child_match)
 
             if main_match:
                 yield main_match

{rebulk-4.2.0 → rebulk-4.2.2}/rebulk/rebulk.py

@@ -189,9 +189,6 @@ class Rebulk(Builder):
                     pattern_matches = pattern.matches(cast("str", matches.input_string), context)
                     if pattern_matches:
                         log(pattern.log_level, "Pattern has %s match(es). (%s)", len(pattern_matches), pattern)
-                    else:
-                        pass
-                        # log(pattern.log_level, "Pattern doesn't match. (%s)" % (pattern,))
                     for match in pattern_matches:
                         if match.marker:
                             log(pattern.log_level, "Marker found. (%s)", match)

{rebulk-4.2.0 → rebulk-4.2.2}/rebulk/test/test_chain.py

@@ -8,11 +8,12 @@ from typing import TYPE_CHECKING, Any
 from rebulk.pattern import FunctionalPattern, RePattern, StringPattern
 
 from ..chain import Chain
+from ..match import Match
 from ..rebulk import Rebulk
 from ..validators import chars_surround
 
 if TYPE_CHECKING:
-    from ..match import Match, Matches
+    from ..match import Matches
 
 
 def test_chain_close() -> None:
@@ -489,3 +490,22 @@ def test_chain_breaker_defaults2() -> None:
     matches[0].value = 1
     matches[1].value = 2
     matches[2].value = 3
+
+
+def test_group_by_match_index_sorts_unordered_input() -> None:
+    # groupby only groups consecutive equal keys, so _group_by_match_index must
+    # sort by match_index first; otherwise unordered matches split (and overwrite)
+    # groups sharing an index.
+    matches: list[Match] = []
+    for start, match_index in ((0, 2), (5, 0), (10, 1), (15, 2)):
+        match = Match(start, start + 1, name="test")
+        match.match_index = match_index
+        matches.append(match)
+
+    grouped = Chain._group_by_match_index(matches)
+
+    assert sorted(grouped) == [0, 1, 2]
+    assert [m.start for m in grouped[0]] == [5]
+    assert [m.start for m in grouped[1]] == [10]
+    # both match_index=2 matches are kept, in their original relative order
+    assert [m.start for m in grouped[2]] == [0, 15]

{rebulk-4.2.0 → rebulk-4.2.2}/rebulk/test/test_match.py

@@ -51,12 +51,24 @@ class TestMatchClass:
         other = object()
 
         assert hash(match1) != hash(match2)
-        assert hash(match1) != hash(match3)
+        # same span, different value: hashes collide (hash must not depend on the
+        # mutable value); equality still tells them apart below.
+        assert hash(match1) == hash(match3)
 
         assert match1 != other
         assert match1 != match2
         assert match1 != match3
 
+    def test_hash_is_stable_under_value_mutation(self) -> None:
+        match = Match(1, 3, value="es")
+        bucket = {match}
+
+        match.value = "changed"
+
+        # The hash must not change when the value is mutated, so the match stays
+        # findable in the set it was added to.
+        assert match in bucket
+
     def test_length(self) -> None:
         match1 = Match(0, 4, value="test")
         match2 = Match(0, 2, value="spanIsUsed")

rebulk-4.2.2/rebulk/test/test_utils.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+from typing import Any
+
+from ..utils import extend_safe
+
+
+def test_extend_safe_hashable() -> None:
+    target = [1, 2]
+    extend_safe(target, [2, 3, 3, 4])
+    assert target == [1, 2, 3, 4]
+
+
+def test_extend_safe_unhashable() -> None:
+    # Unhashable elements (e.g. introspected list/dict property values) must
+    # still be deduplicated via linear membership instead of raising.
+    target: list[Any] = [["a"]]
+    extend_safe(target, [["a"], ["b"], ["b"]])
+    assert target == [["a"], ["b"]]
+
+
+def test_extend_safe_mixed_falls_back_without_duplicating() -> None:
+    # Hashable elements go through the fast set path; the first unhashable one
+    # switches to the linear fallback, and already-added elements are not
+    # appended twice.
+    target: list[Any] = [1]
+    extend_safe(target, [1, 2, ["x"], ["x"], 2])
+    assert target == [1, 2, ["x"]]

{rebulk-4.2.0 → rebulk-4.2.2}/rebulk/toposort.py

@@ -1,18 +1,10 @@
 #!/usr/bin/env python
-# Copyright 2014 True Blade Systems, Inc.
+# Vendored from toposort 1.4 (https://bitbucket.org/ericvsmith/toposort),
+# Copyright 2014 True Blade Systems, Inc., licensed under the Apache License,
+# Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0).
 #
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Original:
-#   - https://bitbucket.org/ericvsmith/toposort (1.4)
-# Modifications:
-#   - merged Pull request #2 for CyclicDependency error
-#   - import reduce as original name
-#   - support python 2.6 dict comprehension
+# Local changes: CyclicDependency error (upstream pull request #2), Python 3
+# only, fully type-annotated.
 
 from __future__ import annotations
 
@@ -27,7 +19,7 @@ _T = TypeVar("_T")
 
 class CyclicDependency(ValueError):
     def __init__(self, cyclic: dict[_T, set[_T]]) -> None:
-        s = "Cyclic dependencies exist among these items: {}".format(", ".join(repr(x) for x in cyclic.items()))
+        s = f"Cyclic dependencies exist among these items: {', '.join(repr(x) for x in cyclic.items())}"
         super().__init__(s)
         self.cyclic = cyclic
 
@@ -38,7 +30,7 @@ def toposort(data: dict[_T, set[_T]]) -> Iterator[set[_T]]:
     and whose values are a set of dependent items. Output is a list of
     sets in topological order. The first set consists of items with no
     dependences, each subsequent set consists of items that depend upon
-    items in the preceeding sets.
+    items in the preceding sets.
     :param data:
     :type data:
     :return:

{rebulk-4.2.0 → rebulk-4.2.2}/rebulk/utils.py

@@ -102,15 +102,28 @@ def is_iterable(obj: Any) -> bool:
 
 def extend_safe(target: list[_T], source: Iterable[_T]) -> None:
     """
-    Extends source list to target list only if elements doesn't exists in target list.
+    Extends target with elements from source that are not already present.
+
+    Uses a set for O(1) membership checks when elements are hashable (the common
+    case: patterns and rules are deduplicated on every ``matches()`` call), and
+    falls back to linear membership when they are not (e.g. unhashable
+    introspected property values).
+
     :param target:
     :type target: list
     :param source:
     :type source: list
     """
-    for elt in source:
-        if elt not in target:
-            target.append(elt)
+    try:
+        seen = set(target)
+        for elt in source:
+            if elt not in seen:
+                target.append(elt)
+                seen.add(elt)
+    except TypeError:  # unhashable element: fall back to linear membership checks
+        for elt in source:
+            if elt not in target:
+                target.append(elt)
 
 
 class _Ref: