dotted-notation 0.43.3__tar.gz → 0.43.4__tar.gz

{dotted_notation-0.43.3/dotted_notation.egg-info → dotted_notation-0.43.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.43.3
+Version: 0.43.4
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Home-page: https://github.com/freywaid/dotted
 Author: Frey Waid
@@ -244,6 +244,14 @@ Several Python libraries handle nested data access. Here's how dotted compares:
 <a id="breaking-changes"></a>
 ## Breaking Changes
 
+### v0.43.4
+- **`is_pattern` no longer returns `True` for substitutions**. `Subst` previously
+  inherited from `Pattern` in the class hierarchy, so any path containing a
+  substitution in an access position (e.g. `a.$(x)`, `a.$0`) reported as a
+  pattern. Substitutions resolve to a single key, not a set — that was a
+  misclassification. Use `is_template(path)` to check "contains a
+  substitution."
+
 ### v0.40.0
 - **`unpack()` now returns a `dict`**: Previously returned a tuple of
   `(path, value)` pairs. Now returns `{path: value, ...}` directly.

{dotted_notation-0.43.3 → dotted_notation-0.43.4}/README.md

@@ -207,6 +207,14 @@ Several Python libraries handle nested data access. Here's how dotted compares:
 <a id="breaking-changes"></a>
 ## Breaking Changes
 
+### v0.43.4
+- **`is_pattern` no longer returns `True` for substitutions**. `Subst` previously
+  inherited from `Pattern` in the class hierarchy, so any path containing a
+  substitution in an access position (e.g. `a.$(x)`, `a.$0`) reported as a
+  pattern. Substitutions resolve to a single key, not a set — that was a
+  misclassification. Use `is_template(path)` to check "contains a
+  substitution."
+
 ### v0.40.0
 - **`unpack()` now returns a `dict`**: Previously returned a tuple of
   `(path, value)` pairs. Now returns `{path: value, ...}` directly.

{dotted_notation-0.43.3 → dotted_notation-0.43.4}/dotted/access.py

@@ -862,6 +862,14 @@ class SliceFilter(BaseOp):
     def is_pattern(self):
         return False
 
+    def is_template(self):
+        """
+        True if any attached filter contains a substitution reference.
+        """
+        return any(
+            hasattr(f, 'is_template') and f.is_template()
+            for f in self.filters)
+
     def is_empty(self, node):
         return not node
 

{dotted_notation-0.43.3 → dotted_notation-0.43.4}/dotted/filters.py

@@ -6,6 +6,13 @@ from . import predicates
 from .access import Slot, Slice
 
 
+def _any_template(items):
+    """
+    True if any item in an iterable has is_template() returning True.
+    """
+    return any(hasattr(x, 'is_template') and x.is_template() for x in items)
+
+
 class FilterOp(base.MatchOp):
     def is_pattern(self):
         return False
@@ -50,6 +57,12 @@ class FilterKey(base.MatchOp):
     def is_dotted(self):
         return len(self.parts) > 1
 
+    def is_template(self):
+        """
+        True if any part of the filter key contains a substitution reference.
+        """
+        return _any_template(self.parts)
+
     def get_values(self, node):
         """
         Get all values from node matching this key, traversing dotted path if needed.
@@ -188,6 +201,16 @@ class FilterKeyValue(FilterOp):
         t_str = ''.join('|' + t.operator() for t in self.transforms) if self.transforms else ''
         return f'{self.key}{t_str}{self._eq_str}{self.val}'
 
+    def is_template(self):
+        """
+        True if the key, value, or any transform contains a substitution.
+        """
+        if hasattr(self.key, 'is_template') and self.key.is_template():
+            return True
+        if hasattr(self.val, 'is_template') and self.val.is_template():
+            return True
+        return _any_template(self.transforms)
+
     def _eq_match(self, node):
         """
         True if any value from self.key in node matches self.val (after transforms).
@@ -351,6 +374,11 @@ class FilterGroup(FilterOp):
             return None
         return self.inner.match(op.inner)
 
+    def is_template(self):
+        return (self.inner is not None
+                and hasattr(self.inner, 'is_template')
+                and self.inner.is_template())
+
     def resolve(self, bindings, partial=False):
         """
         Resolve $N in inner filter.
@@ -403,6 +431,9 @@ class FilterAnd(FilterOp):
             results.append(m)
         return FilterAnd(*results)
 
+    def is_template(self):
+        return _any_template(self.filters)
+
     def resolve(self, bindings, partial=False):
         """
         Resolve $N in each filter.
@@ -443,6 +474,9 @@ class FilterOr(FilterOp):
                     seen.add(item_id)
                     yield item
 
+    def is_template(self):
+        return _any_template(self.filters)
+
     def resolve(self, bindings, partial=False):
         """
         Resolve $N in each filter.
@@ -488,6 +522,11 @@ class FilterKeyValueFirst(FilterOp):
             return self.inner.match(op.inner)
         return None
 
+    def is_template(self):
+        return (self.inner is not None
+                and hasattr(self.inner, 'is_template')
+                and self.inner.is_template())
+
     def resolve(self, bindings, partial=False):
         """
         Resolve $N in inner filter.
@@ -541,6 +580,11 @@ class FilterNot(FilterOp):
             return None
         return self.inner.match(op.inner)
 
+    def is_template(self):
+        return (self.inner is not None
+                and hasattr(self.inner, 'is_template')
+                and self.inner.is_template())
+
     def resolve(self, bindings, partial=False):
         """
         Resolve $N in inner filter.

{dotted_notation-0.43.3 → dotted_notation-0.43.4}/dotted/matchers.py

@@ -150,12 +150,16 @@ class Pattern(MatchOp):
         return True
 
 
-class Subst(Pattern):
+class Subst(MatchOp):
     """
     Substitution op: $0, $(name), $(0|transform), $(name|int), etc.
     Resolves against bindings via __getitem__: list for positional,
     dict for named or numeric keys.  Optional transforms applied
     after lookup.
+
+    Not a Pattern subclass — substitutions resolve to a single key, not
+    a set of keys. is_template() is the right check for "contains a
+    substitution".
     """
     def __init__(self, *args, transforms=(), **kwargs):
         super().__init__(*args, **kwargs)

{dotted_notation-0.43.3 → dotted_notation-0.43.4}/dotted/wrappers.py

@@ -202,6 +202,20 @@ class ValueGuard(Wrap):
     def is_pattern(self):
         return self.inner.is_pattern()
 
+    def is_template(self):
+        """
+        True if the inner op, the guard value, or any transform contains
+        a substitution reference.
+        """
+        if self.inner.is_template():
+            return True
+        if hasattr(self.guard, 'is_template') and self.guard.is_template():
+            return True
+        for t in self.transforms:
+            if hasattr(t, 'is_template') and t.is_template():
+                return True
+        return False
+
     def is_recursive(self):
         return self.inner.is_recursive()
 
@@ -419,6 +433,17 @@ class FilterWrap(Wrap):
             return s[:-1] + filter_str + ']'
         return s + filter_str
 
+    def is_template(self):
+        """
+        True if the inner op or any attached filter contains a
+        substitution reference.
+        """
+        if self.inner.is_template():
+            return True
+        return any(
+            hasattr(f, 'is_template') and f.is_template()
+            for f in self.filters)
+
     def default(self):
         """
         Filters imply the value has structure to check against,

{dotted_notation-0.43.3 → dotted_notation-0.43.4/dotted_notation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.43.3
+Version: 0.43.4
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Home-page: https://github.com/freywaid/dotted
 Author: Frey Waid
@@ -244,6 +244,14 @@ Several Python libraries handle nested data access. Here's how dotted compares:
 <a id="breaking-changes"></a>
 ## Breaking Changes
 
+### v0.43.4
+- **`is_pattern` no longer returns `True` for substitutions**. `Subst` previously
+  inherited from `Pattern` in the class hierarchy, so any path containing a
+  substitution in an access position (e.g. `a.$(x)`, `a.$0`) reported as a
+  pattern. Substitutions resolve to a single key, not a set — that was a
+  misclassification. Use `is_template(path)` to check "contains a
+  substitution."
+
 ### v0.40.0
 - **`unpack()` now returns a `dict`**: Previously returned a tuple of
   `(path, value)` pairs. Now returns `{path: value, ...}` directly.

{dotted_notation-0.43.3 → dotted_notation-0.43.4}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "rt") as f:
 
 setuptools.setup(
     name="dotted_notation",
-    version="0.43.3",
+    version="0.43.4",
     author="Frey Waid",
     author_email="logophage1@gmail.com",
     description="Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms",

{dotted_notation-0.43.3 → dotted_notation-0.43.4}/tests/test_named_subst.py

@@ -106,6 +106,80 @@ def test_is_template_named_escaped():
     assert dotted.is_template('\\$(name)') is False
 
 
+# ---- is_template catches substs in all positions ----
+
+def test_is_template_guard_value():
+    # Subst as guard RHS (previously missed)
+    assert dotted.is_template('a=$(x)') is True
+    assert dotted.is_template('a>=$(x)') is True
+    assert dotted.is_template('a!=$(x)') is True
+
+
+def test_is_template_guard_transform():
+    # Subst combined with guard cast
+    assert dotted.is_template('a|int=$(x)') is True
+
+
+def test_is_template_filter_wrap_value():
+    # Subst inside filter-wrap predicate value
+    assert dotted.is_template('a[*&x=$(y)]') is True
+
+
+def test_is_template_filter_wrap_key():
+    # Subst as filter key
+    assert dotted.is_template('a[$(k)=1]') is True
+
+
+def test_is_template_filter_wrap_transform():
+    # Subst with filter transform
+    assert dotted.is_template('a[*&x|int=$(y)]') is True
+
+
+def test_is_template_filter_negation():
+    # Subst under filter negation
+    assert dotted.is_template('a[!x=$(y)]') is True
+
+
+def test_is_template_filter_group():
+    # Subst inside filter group (AND/OR of predicates)
+    assert dotted.is_template('a[*&(b=$(x) & c=1)]') is True
+
+
+def test_is_template_slice_filter():
+    # SliceFilter (compact [filter] form) carrying a subst
+    assert dotted.is_template('a[$(k)=1]') is True
+
+
+def test_is_template_group_branch():
+    # Subst in an access-op group branch
+    assert dotted.is_template('(a=$(x) & b=1)') is True
+
+
+def test_is_template_false_for_refs():
+    # References are not templates (resolve against data, not bindings)
+    assert dotted.is_template('a.$$(b)') is False
+    assert dotted.is_template('a=$$(b)') is False
+
+
+def test_is_template_false_for_patterns():
+    # Plain patterns are not templates
+    assert dotted.is_template('a.*.b') is False
+    assert dotted.is_template('a=/re/') is False
+
+
+# ---- is_pattern: substitutions are NOT patterns (single-yield) ----
+
+def test_is_pattern_false_for_subst_in_access():
+    # $(x) as an access-position matcher is not a pattern (yields one key).
+    assert dotted.is_pattern('a.$(x)') is False
+    assert dotted.is_pattern('a.$0') is False
+
+
+def test_is_pattern_false_for_subst_in_guard():
+    # Concrete access with subst guard is still not a pattern
+    assert dotted.is_pattern('a=$(x)') is False
+
+
 # ---- quote ----
 
 def test_quote_named_subst_literal():