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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.43.2
+Version: 0.43.3
 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

{dotted_notation-0.43.2 → dotted_notation-0.43.3}/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.3/dotted_notation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.43.2
+Version: 0.43.3
 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

{dotted_notation-0.43.2 → dotted_notation-0.43.3}/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.3",
     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/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'