dotted-notation 0.44.5__tar.gz → 0.44.7__tar.gz

{dotted_notation-0.44.5 → dotted_notation-0.44.7}/CHANGELOG.md

@@ -3,6 +3,49 @@
 All notable changes to `dotted` are recorded here. Versions prior to
 the ones listed are omitted — browse git history for earlier entries.
 
+## [0.44.7]
+
+### Fixed
+- `groups='patterns'` capture positions for variadic patterns: literals
+  are now correctly excluded when the pattern contains a group or
+  recursive op, so `translate`'s `$N` numbering counts pattern segments
+  only, as documented. Previously `a.(x,y).*` numbered `$0='a'` (a
+  literal), and `**.c` captured the literal `c`.
+
+### Changed
+- A group is one pattern segment: it captures the path segments its
+  matching branch consumed as a single group, keeping `$N` positions
+  stable across branches of different lengths. `x.(a.b,c)` matching
+  `x.a.b` now captures `('x', 'a.b')` instead of `('x', 'a', 'b')`.
+  Parentheses thereby act as a regex-like capture group: `x.(a.b)`
+  captures `'a.b'` as one group where `x.a.b` captures `'a', 'b'`.
+  Nested patterns inside a branch fold into the group's capture, as
+  with `**`.
+
+## [0.44.6]
+
+### Added
+- `match()` supports op groups: disjunction `(a,b)`, first-match `(a,b)?`,
+  conjunction `(a&b)`, and negation `(!a)` now match paths instead of
+  raising `AttributeError`. A path matches a group if it matches any
+  branch followed by the rest of the pattern (a concrete path is only
+  ever one branch's output, so Or/First/And all reduce to this);
+  negation matches one segment its inner pattern does not.
+  Multi-segment branches, nested groups, recursive ops inside branches,
+  cut markers, and `groups=True` captures all supported.
+
+### Fixed
+- Wrapped variadic patterns in `match()`: `~(a,b)` (nop-wrapped group)
+  silently matched nothing and `**=7` (value-guarded recursive) raised
+  `AttributeError`; both now match.
+
+### Changed
+- Path matching is polymorphic: `base.match_ops()` dispatches to each
+  op's `do_match`, which decides how many path segments it consumes
+  (single-segment default; backtracking on `Recursive`; branch
+  expansion on groups; `Wrap` delegates to variadic inners). The api
+  layer no longer special-cases op types.
+
 ## [0.44.5]
 
 ### Performance

{dotted_notation-0.44.5/dotted_notation.egg-info → dotted_notation-0.44.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.44.5
+Version: 0.44.7
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License: MIT
@@ -508,6 +508,17 @@ excluding literals:
     >>> dotted.match('hello.*', 'hello.there.bye', groups=GroupMode.patterns)
     ('hello.there.bye', ('there.bye',))
 
+Op groups match like regex alternation, and parentheses act as a capture
+group: a group captures the segments its matching branch consumed as a
+single group, and counts as one pattern position:
+
+    >>> dotted.match('a.(x,y).*', 'a.x.z', groups=GroupMode.patterns, partial=False)
+    ('a.x.z', ('x', 'z'))
+    >>> dotted.match('x.(a.b,c)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+    >>> dotted.match('x.(a.b)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+
 <a id="replace"></a>
 ### Replace
 

{dotted_notation-0.44.5 → dotted_notation-0.44.7}/README.md

@@ -468,6 +468,17 @@ excluding literals:
     >>> dotted.match('hello.*', 'hello.there.bye', groups=GroupMode.patterns)
     ('hello.there.bye', ('there.bye',))
 
+Op groups match like regex alternation, and parentheses act as a capture
+group: a group captures the segments its matching branch consumed as a
+single group, and counts as one pattern position:
+
+    >>> dotted.match('a.(x,y).*', 'a.x.z', groups=GroupMode.patterns, partial=False)
+    ('a.x.z', ('x', 'z'))
+    >>> dotted.match('x.(a.b,c)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+    >>> dotted.match('x.(a.b)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+
 <a id="replace"></a>
 ### Replace
 

{dotted_notation-0.44.5 → dotted_notation-0.44.7}/dotted/api.py

@@ -722,51 +722,6 @@ def remove_multi(obj, iterable, paths_only=True, mutable=True, strict=False, bin
     return remove_if_multi(obj, iterable, paths_only=False, pred=None, mutable=mutable, strict=strict, bindings=bindings)
 
 
-def _match_ops(pats, path_ops, partial):
-    """
-    Recursive match of pattern ops against path ops.
-    Returns list of match values on success, None on failure.
-    Handles Recursive ops which can consume variable-length path segments.
-    """
-    if not pats:
-        if not path_ops:
-            return []
-        if partial:
-            return []
-        return None
-
-    pop = pats[0]
-    rest_pats = pats[1:]
-
-    # Non-recursive op: consume exactly one path segment
-    if not pop.is_recursive():
-        if not path_ops:
-            return None
-        kop = path_ops[0]
-        m = pop.match(kop, specials=True)
-        if not m:
-            return None
-        rest_result = _match_ops(rest_pats, path_ops[1:], partial)
-        if rest_result is None:
-            return None
-        if isinstance(m, (tuple, list)):
-            return [_m.val for _m in m] + rest_result
-        return [m.val] + rest_result
-
-    # Recursive op: try consuming 1, 2, ... N path segments via backtracking
-    for n in range(1, len(path_ops) + 1):
-        kop = path_ops[n - 1]
-        seg_val = getattr(getattr(kop, 'op', kop), 'value', kop)
-        matched = any(True for _ in pop.inner.matches((seg_val,)))
-        if not matched:
-            break  # chain-following: stop extending once a segment fails
-        rest_result = _match_ops(rest_pats, path_ops[n:], partial)
-        if rest_result is not None:
-            combined = results.assemble(path_ops[:n])
-            return [combined] + rest_result
-    return None
-
-
 def match(pattern, path, groups=False, partial=True, strict=False):
     """
     Returns `path` if `pattern` matches; otherwise `None`
@@ -791,6 +746,29 @@ def match(pattern, path, groups=False, partial=True, strict=False):
     >>> match('hello.*', 'hello.there.bye', groups='patterns')
     ('hello.there.bye', ('there.bye',))
 
+    Group patterns match if any branch matches:
+    >>> match('(a,b)', 'a')
+    'a'
+    >>> match('(a,b)', 'c')
+    >>> match('x.(a,b)', 'x.b')
+    'x.b'
+    >>> match('(a.b,c)', 'a.b')
+    'a.b'
+    >>> match('(a,b)?', 'b')
+    'b'
+    >>> match('x(.a&.b)', 'x.a')
+    'x.a'
+    >>> match('(!a)', 'b')
+    'b'
+    >>> match('(!a)', 'a')
+
+    A group is one pattern segment: it captures the segments its branch
+    consumed as a single group, and counts as one pattern position:
+    >>> match('x.(a.b,c)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+    >>> match('a.(x,y).*', 'a.x.z', groups='patterns', partial=False)
+    ('a.x.z', ('x', 'z'))
+
     Recursive patterns:
     >>> match('**.c', 'a.b.c')
     'a.b.c'
@@ -812,15 +790,13 @@ def match(pattern, path, groups=False, partial=True, strict=False):
     pats = parse(pattern)
     path_ops = parse(path)
 
-    # Check if any pattern op is Recursive — use new recursive matcher
-    has_recursive = any(op.is_recursive() for op in pats)
-
-    if has_recursive:
-        result = _match_ops(list(pats), list(path_ops), partial)
+    # Variadic ops (recursive, groups) consume variable-length path
+    # segments — use the recursive matcher
+    if any(op.is_variadic() for op in pats):
+        result = base.match_ops(list(pats), list(path_ops), partial)
         if result is None:
             return returns(None, [])
-        # TODO: pattern-only filtering for recursive matches
-        return returns(path, result)
+        return returns(path, [v for v, _ in result], [p for _, p in result])
 
     # Original non-recursive match logic
     _matches = []

{dotted_notation-0.44.5 → dotted_notation-0.44.7}/dotted/base.py

@@ -42,6 +42,22 @@ def has_any(gen):
     return any(True for _ in gen)
 
 
+def match_ops(pats, path_ops, partial):
+    """
+    Match a list of pattern ops against a list of path ops.
+    Returns a list of (value, is_pattern) capture pairs on success, None
+    on failure.  Dispatches to each op's do_match, which decides how
+    many path segments it consumes.
+    """
+    if pats:
+        return pats[0].do_match(pats[1:], path_ops, partial)
+    if not path_ops:
+        return []
+    if partial:
+        return []
+    return None
+
+
 class MatchResult:
     def __init__(self, val):
         self.val = val
@@ -75,6 +91,12 @@ class Op:
         return False
     def is_slice(self):
         return False
+    def is_variadic(self):
+        """
+        True if this op can consume a variable number of path segments when
+        matching a path (recursive ops, groups).
+        """
+        return False
 
 
 class MetaNOP(type):
@@ -185,6 +207,25 @@ class TraversalOp(Op):
         """
         return False
 
+    def do_match(self, rest_pats, path_ops, partial):
+        """
+        Match this op against exactly one path segment, then continue with
+        the remaining pattern ops.  Variadic ops (recursive, groups)
+        override to consume a variable number of segments.
+        """
+        if not path_ops:
+            return None
+        m = self.match(path_ops[0], specials=True)
+        if not m:
+            return None
+        rest = match_ops(rest_pats, path_ops[1:], partial)
+        if rest is None:
+            return None
+        is_pat = self.is_pattern()
+        if isinstance(m, (tuple, list)):
+            return [(_m.val, is_pat) for _m in m] + rest
+        return [(m.val, is_pat)] + rest
+
 
 class MatchOp(Op):
     """

{dotted_notation-0.44.5 → dotted_notation-0.44.7}/dotted/groups.py

@@ -32,6 +32,9 @@ class OpGroup(base.TraversalOp):
     def is_pattern(self):
         return True
 
+    def is_variadic(self):
+        return True
+
     def is_template(self):
         """
         True if any branch contains a template op.
@@ -99,6 +102,32 @@ class OpGroup(base.TraversalOp):
     def operator(self, top=False):
         return self._render(top)
 
+    def do_match(self, rest_pats, path_ops, partial):
+        """
+        Match a concrete path against this group: the path matches if it
+        matches any branch followed by the remaining pattern ops.  A single
+        concrete path can only be produced by one branch at a time, so
+        disjunction, first-match, and conjunction all reduce to "any branch
+        matches"; cut markers don't constrain matching either.
+
+        The group is one pattern segment: it contributes a single capture —
+        the path segments its branch consumed, assembled — flagged as a
+        pattern match (like Recursive).
+        """
+        from . import results
+        for branch in base.branches_only(self.branches):
+            branch_ops = list(branch)
+            for n in range(len(path_ops) + 1):
+                consumed = base.match_ops(branch_ops, path_ops[:n], False)
+                if consumed is None:
+                    continue
+                rest = base.match_ops(list(rest_pats), path_ops[n:], partial)
+                if rest is None:
+                    continue
+                combined = results.assemble(path_ops[:n])
+                return [(combined, True)] + rest
+        return None
+
     def _render(self, top=True):
         """
         Render the group as a string. Subclasses override this.
@@ -518,6 +547,25 @@ class OpGroupNot(OpGroup):
             stack.push(base.Frame(frame.ops, v, cp, kwargs=frame.kwargs))
         return ()
 
+    def do_match(self, rest_pats, path_ops, partial):
+        """
+        Match one path segment NOT matched by the inner pattern's first op,
+        then continue with the rest of the inner branch and remaining ops.
+        """
+        inner = self.inner
+        if not inner:
+            return None
+        if not path_ops:
+            return None
+        kop = path_ops[0]
+        if base.match_ops([inner[0]], [kop], False) is not None:
+            return None
+        rest = base.match_ops(list(inner[1:]) + list(rest_pats), path_ops[1:], partial)
+        if rest is None:
+            return None
+        seg_val = getattr(getattr(kop, 'op', kop), 'value', kop)
+        return [(seg_val, True)] + rest
+
     def do_update(self, ops, node, val, has_defaults, _path, nop, nop_from_unwrap=False, **kwargs):
         inner = self.inner
         if not inner:

{dotted_notation-0.44.5 → dotted_notation-0.44.7}/dotted/recursive.py

@@ -64,6 +64,9 @@ class Recursive(BaseOp):
     def is_recursive(self):
         return True
 
+    def is_variadic(self):
+        return True
+
     def operator(self, top=False):
         if self.accessors is not None:
             s = f'*({self._render_accessors()})'
@@ -114,6 +117,25 @@ class Recursive(BaseOp):
     def match(self, op, specials=False):
         return self.inner.matchable(op, specials=specials)
 
+    def do_match(self, rest_pats, path_ops, partial):
+        """
+        Match by consuming 1..N path segments via backtracking.  Each
+        consumed segment must match the inner pattern (chain-following);
+        stop extending once a segment fails.
+        """
+        from . import results
+        for n in range(1, len(path_ops) + 1):
+            kop = path_ops[n - 1]
+            seg_val = getattr(getattr(kop, 'op', kop), 'value', kop)
+            if not any(True for _ in self.inner.matches((seg_val,))):
+                return None
+            rest = base.match_ops(rest_pats, path_ops[n:], partial)
+            if rest is None:
+                continue
+            combined = results.assemble(path_ops[:n])
+            return [(combined, True)] + rest
+        return None
+
     def _effective_branches(self):
         """
         Return accessor branches that drive recursion.

{dotted_notation-0.44.5 → dotted_notation-0.44.7}/dotted/wrappers.py

@@ -72,6 +72,18 @@ class Wrap(base.TraversalOp):
         except TypeError:
             return self.inner.match(op)
 
+    def is_variadic(self):
+        return self.inner.is_variadic() if hasattr(self.inner, 'is_variadic') else False
+
+    def do_match(self, rest_pats, path_ops, partial):
+        """
+        Variadic inners (recursive ops, groups) decide their own segment
+        consumption; otherwise match one segment via this wrap's match.
+        """
+        if self.is_variadic():
+            return self.inner.do_match(rest_pats, path_ops, partial)
+        return super().do_match(rest_pats, path_ops, partial)
+
     def concrete(self, val):
         return self.inner.concrete(val)
 

{dotted_notation-0.44.5 → dotted_notation-0.44.7/dotted_notation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.44.5
+Version: 0.44.7
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License: MIT
@@ -508,6 +508,17 @@ excluding literals:
     >>> dotted.match('hello.*', 'hello.there.bye', groups=GroupMode.patterns)
     ('hello.there.bye', ('there.bye',))
 
+Op groups match like regex alternation, and parentheses act as a capture
+group: a group captures the segments its matching branch consumed as a
+single group, and counts as one pattern position:
+
+    >>> dotted.match('a.(x,y).*', 'a.x.z', groups=GroupMode.patterns, partial=False)
+    ('a.x.z', ('x', 'z'))
+    >>> dotted.match('x.(a.b,c)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+    >>> dotted.match('x.(a.b)', 'x.a.b', groups=True)
+    ('x.a.b', ('x', 'a.b'))
+
 <a id="replace"></a>
 ### Replace
 

{dotted_notation-0.44.5 → dotted_notation-0.44.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dotted_notation"
-version = "0.44.5"
+version = "0.44.7"
 description = "Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms"
 readme = "README.md"
 requires-python = ">=3.6"