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

{dotted_notation-0.43.2/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.2
+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.2 → 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.2 → 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.2 → 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.2 → dotted_notation-0.43.4}/dotted/grammar.py

@@ -147,8 +147,9 @@ _ccomma = pp.Optional(pp.White()).suppress() + comma + pp.Optional(pp.White()).s
 # Forward for recursive container values
 container_value = pp.Forward()
 
-# Scalar atoms usable inside containers (same as value atoms minus containers)
-_val_atoms = bytes_literal | string | wildcard | var | regex | numeric_quoted | none | true | false | numeric_extended | numeric_key
+# Scalar atoms usable inside containers (same as value atoms minus containers).
+# Uses numeric_slot (ppc.number) so floats parse in value position.
+_val_atoms = bytes_literal | string | wildcard | var | regex | numeric_quoted | none | true | false | numeric_extended | numeric_slot
 
 # Glob inside containers: ... with optional /regex/ then optional count
 # Regex pattern for glob (unsuppressed slashes handled inline)
@@ -385,7 +386,7 @@ concrete_value <<= (
 value = pp.Forward()
 _value_group_inner = value + OM(_ccomma + value)
 value_group = (S('(') + _value_group_inner + S(')')).set_parse_action(lambda t: [ct.ValueGroup(*t)])
-value <<= value_group | container_value | string_glob | bytes_literal | string | wildcard | var | regex | numeric_quoted | none | true | false | numeric_extended | numeric_key
+value <<= value_group | container_value | string_glob | bytes_literal | string | wildcard | var | regex | numeric_quoted | none | true | false | numeric_extended | numeric_slot
 # ---------------------------------------------------------------------------
 # Concat: part+part for key construction using Python's native + operator.
 # Each part can carry per-part transforms: part|xform+part|xform
@@ -859,9 +860,11 @@ rec_dstar = _dstar_body().set_parse_action(
 rec_pat = _pat_body().set_parse_action(
     lambda t: _make_recursive(t))
 
-recursive_op = (
-    _rec_dstar_guarded_all | _rec_pat_guarded_all |
+recursive_op_nonguarded = (
     rec_dstar_first | rec_dstar | rec_pat_first | rec_pat)
+recursive_op_guarded = (
+    _rec_dstar_guarded_all | _rec_pat_guarded_all)
+recursive_op = recursive_op_guarded | recursive_op_nonguarded
 
 empty = pp.Empty().set_parse_action(access.Empty)
 
@@ -877,15 +880,23 @@ _dot_keycmd = (dot + keycmd).set_parse_action(lambda t: t[0])
 # op_seq_item uses _nop_wrap (defined later); Forward for circular ref
 op_seq_item = pp.Forward()     # first item: allows bare (a,b)
 _op_seq_cont = pp.Forward()    # continuation: requires explicit ops
-op_seq = pp.Group(op_seq_item + ZM(_op_seq_cont))
+_op_seq_guarded = pp.Forward() # guarded terminator (resolved below)
+# op_seq: guarded op is always terminal — either the sole op (alt 1), or
+# optionally trailing a non-guarded path (alt 2).
+op_seq = pp.Group(
+    _op_seq_guarded
+    | (op_seq_item + ZM(_op_seq_cont) + Opt(_op_seq_guarded))
+)
 
 # Continuation items (absorbed from former multi grammar):
 # .~ and ~. with grouped expressions — prefix shorthand requires bare keys inside
 _dot_nop_grouped = ((dot + tilde) | (tilde + dot)) + (_inner_grouped_bare_first | _inner_grouped_bare)
 _dot_nop_grouped = _dot_nop_grouped.set_parse_action(lambda t: wrappers.NopWrap(t[-1]))
 _dot_plain_grouped = (dot + (_inner_grouped_bare_first | _inner_grouped_bare)).set_parse_action(lambda t: t[0])
-# .recursive
-_dot_recursive = (dot + recursive_op).set_parse_action(lambda t: t[0])
+# .recursive (split into guarded / non-guarded)
+_dot_recursive_nonguarded = (dot + recursive_op_nonguarded).set_parse_action(lambda t: t[0])
+_dot_recursive_guarded = (dot + recursive_op_guarded).set_parse_action(lambda t: t[0])
+_dot_recursive = _dot_recursive_guarded | _dot_recursive_nonguarded
 # @(group) — attribute group access: @(a,b) == (@a,@b), prefix requires bare keys
 _at_plain_grouped = (at + (_inner_grouped_bare_first | _inner_grouped_bare)).set_parse_action(
     lambda t: groups.as_attrs_opgroup(t[0])
@@ -916,28 +927,63 @@ _explicit_nop_inner = (
 )
 _explicit_nop_wrap = (tilde + _explicit_nop_inner).set_parse_action(lambda t: wrappers.NopWrap(t[1]))
 
-# Resolve forward: op_seq_item is the atom of op_seq, used in the precedence tower
-# Continuation items: everything that can appear after the first item in an op_seq.
-# Bare (a,b) is NOT allowed here — only explicit-op groups like (.a,.b).
+# Guarded variants — terminal within op_seq. After a `=value`, no more ops
+# may follow (guards have no right-side delimiter, so continuations are
+# ambiguous/meaningless — `a=1.b` is not a legal path).
+_op_seq_guarded << (
+    _keycmd_guarded_all |
+    _dot_keycmd_guarded_nop | _dot_keycmd_guarded_plain |
+    _slotcmd_guarded_all |
+    recursive_op_guarded |
+    _dot_recursive_guarded
+)
+
+# Lookahead: a non-guarded continuation must NOT be followed by a guarded
+# suffix (`|transform* + pred_op`). If it is, the whole thing belongs to
+# the trailing `_op_seq_guarded` terminator, not to this continuation.
+# A bare `|transform` (without pred_op) is fine — that's a template-level
+# transform applied after the path resolves.
+_guard_la = pp.NotAny(ZM(pipe + transform) + _pred_op_re)
+
+# Continuation items for the ZM middle of op_seq — guarded variants excluded.
+# Items that could be the LHS of a guard get a `_guard_la` lookahead so
+# they don't greedily eat what belongs to the trailing guarded terminator.
 _op_seq_cont_items = (
     _nop_wrap |
     _inner_grouped_explicit_first | _inner_grouped_explicit |
-    recursive_op |
-    _keycmd_guarded_all | keycmd |
-    _dot_keycmd_guarded_nop | _dot_keycmd_guarded_plain |
-    _dot_recursive |
-    _dot_keycmd_nop | _dot_keycmd |
+    (recursive_op_nonguarded + _guard_la) |
+    (keycmd + _guard_la) |
+    _dot_recursive_nonguarded |
+    ((_dot_keycmd_nop | _dot_keycmd) + _guard_la) |
     _dot_nop_grouped | _dot_plain_grouped |
     _at_nop_grouped | _at_plain_grouped |
     attrcmd |
     slotgroup_first | slotgroup |
-    _slotcmd_guarded_all | slotcmd |
+    (slotcmd + _guard_la) |
     slotspecial | slicefilter | slicecmd
 )
 _op_seq_cont << _op_seq_cont_items
+
+# First-item items — same set but WITHOUT the lookahead: the first position
+# doesn't need it because alt 1 (_op_seq_guarded) handles sole-guard cases
+# like `first=7` before we fall into this branch.
+_op_seq_first_items = (
+    _nop_wrap |
+    _inner_grouped_explicit_first | _inner_grouped_explicit |
+    recursive_op_nonguarded |
+    keycmd |
+    _dot_recursive_nonguarded |
+    _dot_keycmd_nop | _dot_keycmd |
+    _dot_nop_grouped | _dot_plain_grouped |
+    _at_nop_grouped | _at_plain_grouped |
+    attrcmd |
+    slotgroup_first | slotgroup |
+    slotcmd |
+    slotspecial | slicefilter | slicecmd
+)
 # First item also allows bare grouped expressions — (a,b) with bare keys.
 # This is valid at the start of a path (top-level inference).
-op_seq_item << (inner_grouped_first | inner_grouped | _op_seq_cont_items)
+op_seq_item << (inner_grouped_first | inner_grouped | _op_seq_first_items)
 
 # Precedence tower (atoms are op_seqs)
 inner_atom = op_seq

{dotted_notation-0.43.2 → 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.2 → 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.2 → 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.2
+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.2 → 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.2",
+    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.2 → 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():

dotted_notation-0.43.4/tests/test_numeric.py

@@ -0,0 +1,199 @@
+import dotted
+
+
+def test_numeric_get_key():
+    T = {111: {'stuff': 'hi'}}
+
+    m = dotted.get(T, '111.stuff')
+    assert m == 'hi'
+
+    m = dotted.get(T, '111.0.stuff')
+    assert m != 'hi'
+
+    # 111.0 == 111
+    m = dotted.get(T, '#"111.0".stuff')
+    assert m == 'hi'
+
+
+def test_numeric_get_slot():
+    T = {111: {'stuff': 'hi'}}
+
+    m = dotted.get(T, '[111].stuff')
+    assert m == 'hi'
+
+    # 111.0 == 111
+    m = dotted.get(T, '[111.0].stuff')
+    assert m == 'hi'
+
+    # 111.0 == 111
+    m = dotted.get(T, '[#"111.0"].stuff')
+    assert m == 'hi'
+
+
+def test_numeric_expand_int():
+    T = {111: {'stuff': 'hi'}}
+
+    m = dotted.expand(T, '*.*')
+    assert m == ('111.stuff',)
+
+    m = dotted.expand(T, '[*].*')
+    assert m == ('[111].stuff',)
+
+
+def test_numeric_expand_float():
+    T = {111.0: {'stuff': 'hi'}}
+
+    m = dotted.expand(T, '*.*')
+    assert m == ("#'111.0'.stuff",)
+
+    m = dotted.expand(T, '[*].*')
+    assert m == ('[111.0].stuff',)
+
+
+def test_numeric_update():
+    m = dotted.update({}, '07a', 8)
+    assert m == {'07a': 8}
+
+
+# Extended numeric literals
+
+def test_numeric_extended_scientific():
+    lst = list(range(11))
+    assert dotted.get(lst, '[1e1]') == 10
+    d = {10000000000: 'big'}
+    assert dotted.get(d, '1e10') == 'big'
+    assert dotted.get(d, '1e+10') == 'big'
+    # negative exponent — float key
+    d2 = {1e-12: 'tiny'}
+    assert dotted.get(d2, '1e-12') == 'tiny'
+
+
+def test_numeric_extended_underscore():
+    lst = list(range(1001))
+    assert dotted.get(lst, '[1_000]') == 1000
+    d = {1000: 'thousand'}
+    assert dotted.get(d, '1_000') == 'thousand'
+
+
+def test_numeric_extended_hex():
+    lst = list(range(32))
+    assert dotted.get(lst, '[0x1F]') == 31
+    d = {31: 'hex'}
+    assert dotted.get(d, '0x1F') == 'hex'
+
+
+def test_numeric_extended_octal():
+    lst = list(range(16))
+    assert dotted.get(lst, '[0o17]') == 15
+    d = {15: 'octal'}
+    assert dotted.get(d, '0o17') == 'octal'
+
+
+def test_numeric_extended_binary():
+    lst = list(range(11))
+    assert dotted.get(lst, '[0b1010]') == 10
+    d = {10: 'binary'}
+    assert dotted.get(d, '0b1010') == 'binary'
+
+
+def test_numeric_extended_negative_slot():
+    lst = [None] * 5 + ['neg_sci']
+    assert dotted.get(lst, '[-1e1]') is None  # -10, out of range for len 6
+    d = {-100000: 'neg_sci'}
+    assert dotted.get(d, '[-1e5]') == 'neg_sci'
+
+
+# --- Floats in RHS (value) positions ---
+
+def test_rhs_float_guard():
+    """
+    a=0.9 parses as a float guard, not (a=0, .9).
+    """
+    p = dotted.parse('a=0.9')
+    assert dotted.assemble(p) == 'a=0.9'
+    assert dotted.get({'a': 0.9}, 'a=0.9') == 0.9
+    assert dotted.get({'a': 1}, 'a=0.9') is None
+
+def test_rhs_float_dotted_keycmd_guard():
+    """
+    a.b=7.1 must parse as (a, b=7.1), not (a, b=7, 1).
+    """
+    p = dotted.parse('a.b=7.1')
+    assert dotted.assemble(p) == 'a.b=7.1'
+    assert dotted.get({'a': {'b': 7.1}}, 'a.b=7.1') == 7.1
+
+def test_rhs_float_negative():
+    assert dotted.get({'a': -0.9}, 'a=-0.9') == -0.9
+
+def test_rhs_float_scientific():
+    assert dotted.get({'a': 150.0}, 'a=1.5e2') == 150.0
+
+def test_rhs_float_in_filter():
+    data = [{'x': 0.9}, {'x': 1.1}]
+    assert dotted.get(data, '[x=0.9]') == [{'x': 0.9}]
+
+def test_rhs_float_in_slot_guard():
+    assert dotted.get([0.1, 0.9, 0.5], '[*]=0.9') == (0.9,)
+
+def test_rhs_float_in_container():
+    p = dotted.parse('a=[0.1, 0.2]')
+    assert dotted.assemble(p) == 'a=[0.1, 0.2]'
+    assert dotted.get({'a': [0.1, 0.2]}, 'a=[0.1, 0.2]') == [0.1, 0.2]
+
+def test_rhs_float_in_transform_arg():
+    """
+    Transform arguments accept floats.
+    """
+    assert dotted.get({'a': 0.5}, 'a|round:0') == 0
+
+
+# --- Guarded ops are terminal within op_seq ---
+
+def test_guard_terminal_keycmd():
+    """
+    a=1.b: guard `a=1` cannot have a continuation `.b` after it.
+    """
+    import pytest
+    from dotted.api import ParseError
+    with pytest.raises(ParseError):
+        dotted.parse('a=1.b')
+    with pytest.raises(ParseError):
+        dotted.parse('a=1.0b')
+
+def test_guard_terminal_dotted_keycmd():
+    """
+    a.b=7.c: guard `b=7` is already terminal; adding `.c` after must fail.
+    """
+    import pytest
+    from dotted.api import ParseError
+    with pytest.raises(ParseError):
+        dotted.parse('a.b=7.c')
+
+def test_guard_terminal_slot():
+    """
+    a[0]=7.b: slot guard `[0]=7` must be terminal.
+    """
+    import pytest
+    from dotted.api import ParseError
+    with pytest.raises(ParseError):
+        dotted.parse('a[0]=7.b')
+    with pytest.raises(ParseError):
+        dotted.parse('[0]=7.a')
+
+def test_guard_terminal_recursive_dstar():
+    """
+    **=7.a: recursive wildcard guard must be terminal.
+    """
+    import pytest
+    from dotted.api import ParseError
+    with pytest.raises(ParseError):
+        dotted.parse('**=7.a')
+
+def test_guard_terminal_recursive_pattern():
+    """
+    *x=7.a: recursive pattern guard must be terminal.
+    """
+    import pytest
+    from dotted.api import ParseError
+    with pytest.raises(ParseError):
+        dotted.parse('*x=7.a')

dotted_notation-0.43.2/tests/test_numeric.py

@@ -1,103 +0,0 @@
-import dotted
-
-
-def test_numeric_get_key():
-    T = {111: {'stuff': 'hi'}}
-
-    m = dotted.get(T, '111.stuff')
-    assert m == 'hi'
-
-    m = dotted.get(T, '111.0.stuff')
-    assert m != 'hi'
-
-    # 111.0 == 111
-    m = dotted.get(T, '#"111.0".stuff')
-    assert m == 'hi'
-
-
-def test_numeric_get_slot():
-    T = {111: {'stuff': 'hi'}}
-
-    m = dotted.get(T, '[111].stuff')
-    assert m == 'hi'
-
-    # 111.0 == 111
-    m = dotted.get(T, '[111.0].stuff')
-    assert m == 'hi'
-
-    # 111.0 == 111
-    m = dotted.get(T, '[#"111.0"].stuff')
-    assert m == 'hi'
-
-
-def test_numeric_expand_int():
-    T = {111: {'stuff': 'hi'}}
-
-    m = dotted.expand(T, '*.*')
-    assert m == ('111.stuff',)
-
-    m = dotted.expand(T, '[*].*')
-    assert m == ('[111].stuff',)
-
-
-def test_numeric_expand_float():
-    T = {111.0: {'stuff': 'hi'}}
-
-    m = dotted.expand(T, '*.*')
-    assert m == ("#'111.0'.stuff",)
-
-    m = dotted.expand(T, '[*].*')
-    assert m == ('[111.0].stuff',)
-
-
-def test_numeric_update():
-    m = dotted.update({}, '07a', 8)
-    assert m == {'07a': 8}
-
-
-# Extended numeric literals
-
-def test_numeric_extended_scientific():
-    lst = list(range(11))
-    assert dotted.get(lst, '[1e1]') == 10
-    d = {10000000000: 'big'}
-    assert dotted.get(d, '1e10') == 'big'
-    assert dotted.get(d, '1e+10') == 'big'
-    # negative exponent — float key
-    d2 = {1e-12: 'tiny'}
-    assert dotted.get(d2, '1e-12') == 'tiny'
-
-
-def test_numeric_extended_underscore():
-    lst = list(range(1001))
-    assert dotted.get(lst, '[1_000]') == 1000
-    d = {1000: 'thousand'}
-    assert dotted.get(d, '1_000') == 'thousand'
-
-
-def test_numeric_extended_hex():
-    lst = list(range(32))
-    assert dotted.get(lst, '[0x1F]') == 31
-    d = {31: 'hex'}
-    assert dotted.get(d, '0x1F') == 'hex'
-
-
-def test_numeric_extended_octal():
-    lst = list(range(16))
-    assert dotted.get(lst, '[0o17]') == 15
-    d = {15: 'octal'}
-    assert dotted.get(d, '0o17') == 'octal'
-
-
-def test_numeric_extended_binary():
-    lst = list(range(11))
-    assert dotted.get(lst, '[0b1010]') == 10
-    d = {10: 'binary'}
-    assert dotted.get(d, '0b1010') == 'binary'
-
-
-def test_numeric_extended_negative_slot():
-    lst = [None] * 5 + ['neg_sci']
-    assert dotted.get(lst, '[-1e1]') is None  # -10, out of range for len 6
-    d = {-100000: 'neg_sci'}
-    assert dotted.get(d, '[-1e5]') == 'neg_sci'