dotted-notation 0.43.0__tar.gz → 0.43.1__tar.gz

{dotted_notation-0.43.0/dotted_notation.egg-info → dotted_notation-0.43.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.43.0
+Version: 0.43.1
 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.0 → dotted_notation-0.43.1}/dotted/matchers.py

@@ -13,6 +13,9 @@ from .base import MatchOp
 from .utypes import ANY
 
 
+_MISSING = object()
+
+
 class Const(MatchOp):
     _match_from = ('Const',)
 
@@ -190,14 +193,26 @@ class Subst(Pattern):
     def resolve(self, bindings, partial=False):
         """
         Resolve this substitution against bindings.
-        """
-        try:
-            val = self._apply_transforms(bindings[self.value])
-            return ResolvedValue(val)
-        except (KeyError, IndexError, TypeError):
-            if partial:
-                return self
-            raise
+
+        For string names, honor dotted notation for nested lookup: `$(a.b)`
+        resolves to `bindings['a']['b']` when present. Falls back to a
+        literal `bindings[name]` lookup (preserves the rare case of a key
+        that actually contains a dot). Integer names always use positional
+        lookup via __getitem__.
+        """
+        name = self.value
+        val = _MISSING
+        if isinstance(name, str):
+            from .api import get
+            val = get(bindings, name, default=_MISSING)
+        if val is _MISSING:
+            try:
+                val = bindings[name]
+            except (KeyError, IndexError, TypeError):
+                if partial:
+                    return self
+                raise
+        return ResolvedValue(self._apply_transforms(val))
 
     def __repr__(self):
         suffix = self._transform_suffix()

{dotted_notation-0.43.0 → dotted_notation-0.43.1}/dotted/sqlize.py

@@ -46,6 +46,46 @@ def _quote_ident(name):
     return '"' + name.replace('"', '""') + '"'
 
 
+# Subst names may themselves be dotted paths. To survive as SQL bind
+# parameter names (which must be plain identifiers), the access operators
+# are encoded with mnemonic tokens. This preserves the distinction
+# between `a.b`, `a@b`, and `a[0]` in the placeholder name.
+_OP_ENCODE = {
+    '.': '_dot_',
+    '@': '_at_',
+    '[': '_br_',
+    ']': '',
+}
+
+
+def _encode_subst_name(name):
+    """
+    Encode a subst name (a dotted path) into a plain SQL identifier.
+    Recognised access ops become mnemonic tokens; unsupported characters
+    raise TranslationError.
+    """
+    if _IDENT_RE.fullmatch(name):
+        return name
+    out = []
+    for c in name:
+        if c in _OP_ENCODE:
+            out.append(_OP_ENCODE[c])
+        elif c.isalnum() or c == '_':
+            out.append(c)
+        else:
+            raise TranslationError(
+                f'cannot encode character {c!r} in substitution name {name!r}; '
+                'resolve via bindings= at sqlize time'
+            )
+    encoded = ''.join(out)
+    if not _IDENT_RE.fullmatch(encoded):
+        raise TranslationError(
+            f'substitution name {name!r} does not encode to a valid '
+            'SQL identifier'
+        )
+    return encoded
+
+
 def _pg_path_segment(seg):
     """
     Escape a segment for a Postgres text[] path literal like '{a,b,c}'.
@@ -93,12 +133,17 @@ class _ParamState:
     def hoist_named(self, name):
         """
         Hoist a named substitution. If a value is supplied later it lands
-        under `name`; until then the name is recorded in `missing`.
+        under the encoded name; until then it's recorded in `missing`.
+
+        Names that already are plain identifiers are used as-is. Dotted
+        paths (`$(user.age)`, `$(users[0].name)`, `$(obj@attr)`) are
+        encoded into plain identifiers using mnemonic tokens for access
+        ops so they can serve as SQL bind-parameter names.
         """
-        name = str(name)
-        if name not in self.params and name not in self.missing:
-            self.missing.append(name)
-        return name
+        encoded = _encode_subst_name(str(name))
+        if encoded not in self.params and encoded not in self.missing:
+            self.missing.append(encoded)
+        return encoded
 
 
 class _Translator:

{dotted_notation-0.43.0 → dotted_notation-0.43.1/dotted_notation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.43.0
+Version: 0.43.1
 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.0 → dotted_notation-0.43.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "rt") as f:
 
 setuptools.setup(
     name="dotted_notation",
-    version="0.43.0",
+    version="0.43.1",
     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.0 → dotted_notation-0.43.1}/tests/test_named_subst.py

@@ -62,6 +62,40 @@ def test_replace_named_missing_raises():
         replace('$(name)', {})
 
 
+# ---- dotted-path lookup in named subst ----
+
+def test_replace_dotted_subst():
+    # $(a.b) resolves via nested lookup in bindings
+    assert replace('prefix.$(a.b)', {'a': {'b': 'val'}}) == 'prefix.val'
+
+
+def test_replace_dotted_subst_deep():
+    assert replace('$(x.y.z)', {'x': {'y': {'z': 42}}}) == '42'
+
+
+def test_replace_dotted_subst_falls_back_to_literal():
+    # When nested lookup finds nothing, a literal dotted key still works
+    assert replace('$(a.b)', {'a.b': 'literal'}) == 'literal'
+
+
+def test_replace_dotted_subst_nested_wins_over_literal():
+    # Nested match is preferred over literal key
+    assert replace('$(a.b)', {'a.b': 'literal', 'a': {'b': 'nested'}}) == 'nested'
+
+
+def test_replace_dotted_subst_missing_raises():
+    with pytest.raises(KeyError):
+        replace('$(a.b)', {'a': {}})
+
+
+def test_replace_dotted_subst_partial():
+    assert replace('$(a.b)', {}, partial=True) == '$(a.b)'
+
+
+def test_replace_dotted_subst_with_transform():
+    assert replace('$(a.b|int)', {'a': {'b': '42'}}) == '42'
+
+
 # ---- is_template ----
 
 def test_is_template_named():

{dotted_notation-0.43.0 → dotted_notation-0.43.1}/tests/test_sqlize.py

@@ -326,11 +326,64 @@ def test_mixed_subst_and_literal():
     }
 
 
+def test_value_sub_dotted_name_with_bindings():
+    # Dotted subst name resolves via nested lookup in bindings
+    result = sqlize('age>=$(user.min_age)',
+                    bindings={'user': {'min_age': 30}})
+    assert result == {
+        'select': 'age',
+        'where': 'age >= :_p1',
+        'params': {'_p1': 30},
+    }
+
+
+def test_value_sub_dotted_name_encoded():
+    # Dotted subst name is encoded into a plain SQL identifier.
+    result = sqlize('age>=$(user.min_age)')
+    assert result == {
+        'select': 'age',
+        'where': 'age >= :user_dot_min_age',
+        'params': {},
+        'missing': ['user_dot_min_age'],
+    }
+
+
+def test_value_sub_attr_name_encoded():
+    result = sqlize('age>=$(obj@attr)')
+    assert result['where'] == 'age >= :obj_at_attr'
+    assert result['missing'] == ['obj_at_attr']
+
+
+def test_value_sub_slot_name_encoded():
+    result = sqlize('age>=$(arr[0])')
+    assert result['where'] == 'age >= :arr_br_0'
+    assert result['missing'] == ['arr_br_0']
+
+
+def test_value_sub_mixed_path_name_encoded():
+    result = sqlize('age>=$(users[0].name)')
+    assert result['where'] == 'age >= :users_br_0_dot_name'
+    assert result['missing'] == ['users_br_0_dot_name']
+
+
+def test_value_sub_unencodable_char_errors():
+    # Characters outside the supported op set raise
+    with pytest.raises(TranslationError):
+        sqlize('age>=$(user age)')
+
+
 def test_path_sub_with_binding():
     result = sqlize('data.$(field)', bindings={'field': 'name'})
     assert result == {'select': "data #>> '{name}'", 'params': {}}
 
 
+def test_path_sub_dotted_name_with_bindings():
+    # Dotted subst name in path position resolves via nested lookup
+    result = sqlize('data.$(cfg.field)',
+                    bindings={'cfg': {'field': 'name'}})
+    assert result == {'select': "data #>> '{name}'", 'params': {}}
+
+
 def test_path_sub_without_binding_errors():
     with pytest.raises(TranslationError):
         sqlize('data.$(field)')