memoize GlobPathMatcher to remove exponential cliff

The wildcard matcher previously made ~280k recursive calls on a pattern
like root[**][**][**][**][**]['x'] against a 20-deep target — the **
backtracking explored overlapping (pi, ti) states repeatedly.

Add a per-call memo dict keyed on (pi, ti) to both _match_segments and
_could_match_descendant, bounding work to O(len(pattern) * len(target)).
Same input now uses ~940 calls.

Also collapse match_or_is_descendant from an O(len(target)) loop over
every prefix into a single _match_segments pass with allow_extra_target=True
— equivalent to 'pattern matches some prefix of target'.

Switch sentinel comparisons from == to is (the wildcards are module-level
singletons; saves the _WildcardToken.__eq__ call on the hot path).

Add two regression tests asserting bounded call counts so this can't
silently regress.

Author: seperman

deepdiff/path.py

@@ -389,89 +389,100 @@ def __init__(self, pattern_path):
 
     def match(self, path_string):
         """Return True if *path_string* matches this pattern exactly."""
-        elements = _path_to_elements(path_string, root_element=('root', GETATTR))
-        target = elements[1:]
-        return self._match_segments(self._pattern, target, 0, 0)
+        target = _path_to_elements(path_string, root_element=('root', GETATTR))[1:]
+        return self._match_segments(target, 0, 0, {}, allow_extra_target=False)
 
     def match_or_is_ancestor(self, path_string):
         """Return True if *path_string* matches OR is an ancestor of a potential match.
 
         This is needed for ``include_paths``: we must not prune a path that
         could lead to a matching descendant.
         """
-        elements = _path_to_elements(path_string, root_element=('root', GETATTR))
-        target = elements[1:]
-        return (self._match_segments(self._pattern, target, 0, 0) or
-                self._could_match_descendant(self._pattern, target, 0, 0))
+        target = _path_to_elements(path_string, root_element=('root', GETATTR))[1:]
+        memo = {}
+        return (self._match_segments(target, 0, 0, memo, allow_extra_target=False)
+                or self._could_match_descendant(target, 0, 0, {}))
 
     def match_or_is_descendant(self, path_string):
         """Return True if *path_string* matches OR is a descendant of a matching path.
 
-        This checks whether the pattern matches any prefix of *path_string*,
-        meaning the path is "inside" a matched subtree.
+        Equivalent to: the pattern matches some prefix of *path_string*.
         """
-        elements = _path_to_elements(path_string, root_element=('root', GETATTR))
-        target = elements[1:]
-        # Check exact match first
-        if self._match_segments(self._pattern, target, 0, 0):
-            return True
-        # Check if any prefix of target matches (making this path a descendant)
-        for length in range(len(target)):
-            if self._match_segments(self._pattern, target[:length], 0, 0):
-                return True
-        return False
-
-    @staticmethod
-    def _match_segments(pattern, target, pi, ti):
-        """Recursive segment matcher with backtracking for ``**``."""
-        while pi < len(pattern) and ti < len(target):
-            pat_elem = pattern[pi][0]
+        target = _path_to_elements(path_string, root_element=('root', GETATTR))[1:]
+        return self._match_segments(target, 0, 0, {}, allow_extra_target=True)
+
+    def _match_segments(self, target, pi, ti, memo, allow_extra_target):
+        """Recursive segment matcher with backtracking for ``**``.
 
-            if pat_elem == MULTI_WILDCARD:
+        ``memo`` is a per-top-level-call dict keyed by ``(pi, ti)`` so each
+        state is computed at most once — turns the worst case from
+        exponential to ``O(len(pattern) * len(target))``.
+        """
+        key = (pi, ti)
+        if key in memo:
+            return memo[key]
+        pattern = self._pattern
+        target_len = len(target)
+        pattern_len = len(pattern)
+
+        while pi < pattern_len and ti < target_len:
+            pat_elem = pattern[pi][0]
+            if pat_elem is MULTI_WILDCARD:
                 # ** matches zero or more segments — try every suffix
-                for k in range(ti, len(target) + 1):
-                    if GlobPathMatcher._match_segments(pattern, target, pi + 1, k):
+                for k in range(ti, target_len + 1):
+                    if self._match_segments(target, pi + 1, k, memo, allow_extra_target):
+                        memo[key] = True
                         return True
+                memo[key] = False
                 return False
-            elif pat_elem == SINGLE_WILDCARD:
-                # * matches exactly one segment regardless of value/action
+            elif pat_elem is SINGLE_WILDCARD:
                 pi += 1
                 ti += 1
             else:
-                tgt_elem = target[ti][0]
-                if pat_elem != tgt_elem:
+                if pat_elem != target[ti][0]:
+                    memo[key] = False
                     return False
                 pi += 1
                 ti += 1
 
         # Consume any trailing ** (they can match zero segments)
-        while pi < len(pattern) and pattern[pi][0] == MULTI_WILDCARD:
+        while pi < pattern_len and pattern[pi][0] is MULTI_WILDCARD:
             pi += 1
 
-        return pi == len(pattern) and ti == len(target)
+        if allow_extra_target:
+            result = pi == pattern_len
+        else:
+            result = pi == pattern_len and ti == target_len
+        memo[key] = result
+        return result
 
-    @staticmethod
-    def _could_match_descendant(pattern, target, pi, ti):
+    def _could_match_descendant(self, target, pi, ti, memo):
         """Check if *target* is a prefix that could lead to a match deeper down."""
+        key = (pi, ti)
+        if key in memo:
+            return memo[key]
+        pattern = self._pattern
         if ti == len(target):
-            # Target exhausted — it's an ancestor if pattern has remaining segments
-            return pi < len(pattern)
-
+            result = pi < len(pattern)
+            memo[key] = result
+            return result
         if pi >= len(pattern):
+            memo[key] = False
             return False
 
         pat_elem = pattern[pi][0]
-
-        if pat_elem == MULTI_WILDCARD:
-            return (GlobPathMatcher._could_match_descendant(pattern, target, pi + 1, ti) or
-                    GlobPathMatcher._could_match_descendant(pattern, target, pi, ti + 1))
-        elif pat_elem == SINGLE_WILDCARD:
-            return GlobPathMatcher._could_match_descendant(pattern, target, pi + 1, ti + 1)
+        if pat_elem is MULTI_WILDCARD:
+            result = (self._could_match_descendant(target, pi + 1, ti, memo)
+                      or self._could_match_descendant(target, pi, ti + 1, memo))
+        elif pat_elem is SINGLE_WILDCARD:
+            result = self._could_match_descendant(target, pi + 1, ti + 1, memo)
         else:
-            tgt_elem = target[ti][0]
-            if pat_elem != tgt_elem:
+            if pat_elem != target[ti][0]:
+                memo[key] = False
                 return False
-            return GlobPathMatcher._could_match_descendant(pattern, target, pi + 1, ti + 1)
+            result = self._could_match_descendant(target, pi + 1, ti + 1, memo)
+        memo[key] = result
+        return result
 
 
 def compile_glob_paths(paths):

tests/test_glob_paths.py

@@ -717,3 +717,46 @@ def test_mixed_exact_include_and_glob_include(self):
         assert "root['b']['x']" in changed
         # root['b']['y'] is NOT covered by either
         assert "root['b']['y']" not in changed
+
+
+class TestGlobMatcherPerformance:
+    """Guards against exponential blowup in the glob matcher.
+
+    Memoization caps the recursion at O(len(pattern) * len(target)) states.
+    Without it, patterns with multiple ``**`` and long targets exploded into
+    hundreds of thousands of recursive calls.
+    """
+
+    def _instrument(self, monkeypatch):
+        counts = {'ms': 0, 'cmd': 0}
+        orig_ms = GlobPathMatcher._match_segments
+        orig_cmd = GlobPathMatcher._could_match_descendant
+
+        def wrap_ms(self, *a, **k):
+            counts['ms'] += 1
+            return orig_ms(self, *a, **k)
+
+        def wrap_cmd(self, *a, **k):
+            counts['cmd'] += 1
+            return orig_cmd(self, *a, **k)
+
+        monkeypatch.setattr(GlobPathMatcher, '_match_segments', wrap_ms)
+        monkeypatch.setattr(GlobPathMatcher, '_could_match_descendant', wrap_cmd)
+        return counts
+
+    def test_match_or_is_descendant_bounded(self, monkeypatch):
+        # Pre-memoization this exact case made ~280k recursive calls.
+        counts = self._instrument(monkeypatch)
+        m = GlobPathMatcher('root' + '[**]' * 5 + "['x']")
+        target = 'root' + ''.join(f'[{i}]' for i in range(20))
+        m.match_or_is_descendant(target)
+        assert counts['ms'] < 5000, f"_match_segments call count regressed: {counts['ms']}"
+
+    def test_match_or_is_ancestor_bounded(self, monkeypatch):
+        counts = self._instrument(monkeypatch)
+        m = GlobPathMatcher('root' + '[**]' * 8)
+        target = 'root' + ''.join(f'[{i}]' for i in range(40)) + "['extra']"
+        m.match_or_is_ancestor(target)
+        assert counts['ms'] + counts['cmd'] < 5000, (
+            f"call count regressed: ms={counts['ms']}, cmd={counts['cmd']}"
+        )