dotted-notation 0.51.1__tar.gz → 0.51.2__tar.gz

{dotted_notation-0.51.1 → dotted_notation-0.51.2}/CHANGELOG.md

@@ -3,6 +3,19 @@
 All notable changes to `dotted` are recorded here. Versions prior to
 the ones listed are omitted — browse git history for earlier entries.
 
+## [0.51.2]
+
+### Added
+- `getter(path, ...)`: a read of `path` as a callable `obj -> value`,
+  returning what `get(obj, path, ...)` would, with the parse, the
+  resolver's `lex`, `fold` and `literals` and the fast-path decision
+  settled once when it is made, so repeated reads skip `get`'s setup.
+
+### Fixed
+- On `get`'s fast path, a resolver answering a reference in a trailing
+  transform's argument saw `settings.strict` as `False` whatever the
+  call's `strict`.
+
 ## [0.51.1]
 
 ### Added

{dotted_notation-0.51.1/dotted_notation.egg-info → dotted_notation-0.51.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.51.1
+Version: 0.51.2
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License-Expression: MIT
@@ -437,6 +437,17 @@ Get the value at a dotted path. See the Paths, Patterns, and Operators sections
     >>> dotted.get({'a': {'b': {'c': {'d': 'nested'}}}}, 'a.b.c.d')
     'nested'
 
+A path read many times can be made into a **getter** once: a callable
+`obj -> value` that returns what `get` would, with the parse, the resolver's
+hooks and the fast-path decision settled when it is made, against the
+resolver in force then. It takes `get`'s arguments, the object aside.
+
+    >>> d_of = dotted.getter('a.b.c.d', default='none')
+    >>> d_of({'a': {'b': {'c': {'d': 'nested'}}}})
+    'nested'
+    >>> d_of({})
+    'none'
+
 <a id="update"></a>
 ### Update
 

{dotted_notation-0.51.1 → dotted_notation-0.51.2}/README.md

@@ -389,6 +389,17 @@ Get the value at a dotted path. See the Paths, Patterns, and Operators sections
     >>> dotted.get({'a': {'b': {'c': {'d': 'nested'}}}}, 'a.b.c.d')
     'nested'
 
+A path read many times can be made into a **getter** once: a callable
+`obj -> value` that returns what `get` would, with the parse, the resolver's
+hooks and the fast-path decision settled when it is made, against the
+resolver in force then. It takes `get`'s arguments, the object aside.
+
+    >>> d_of = dotted.getter('a.b.c.d', default='none')
+    >>> d_of({'a': {'b': {'c': {'d': 'nested'}}}})
+    'nested'
+    >>> d_of({})
+    'none'
+
 <a id="update"></a>
 ### Update
 

{dotted_notation-0.51.1 → dotted_notation-0.51.2}/dotted/__init__.py

@@ -71,7 +71,7 @@ from .api import \
     expand, expand_multi, \
     match, match_multi, replace, overlaps, translate, translate_multi, \
     apply, apply_multi, \
-    get, get_multi, \
+    get, get_multi, getter, \
     has, setdefault, setdefault_multi, \
     update, update_multi, pack, update_if, update_if_multi, \
     remove, remove_multi, remove_if, remove_if_multi, \
@@ -82,7 +82,7 @@ from .base import Resolver as ReferenceResolver, UnresolvedReference
 
 __all__ = [
     # Core
-    'get', 'update', 'remove', 'has', 'setdefault',
+    'get', 'getter', 'update', 'remove', 'has', 'setdefault',
     'ReferenceResolver', 'UnresolvedReference', 'set_resolver', 'get_resolver',
     # Multi
     'get_multi', 'update_multi', 'pack', 'update_if', 'update_if_multi', 'remove_multi', 'remove_if', 'remove_if_multi', 'setdefault_multi',

{dotted_notation-0.51.1 → dotted_notation-0.51.2}/dotted/api.py

@@ -511,8 +511,25 @@ def get(obj, path, default=None, pattern_default=(), apply_transforms=True, stri
     >>> get({'a': {'b': 7, 'c': 3}}, '**=7')
     (7,)
     """
+    ops, chain = _get_setup(path, bindings, resolver)
+    return _get_read(obj, ops, chain, default, pattern_default, apply_transforms, strict, resolver)
+
+
+def _get_setup(path, bindings, resolver):
+    """
+    What a read of path settles before it sees an object: the parsed path,
+    with its resolver's lex and fold, and the fast path's chain, None when
+    the read takes the full traversal.
+    """
     ops = _prepare(parse(path, bindings=bindings, partial=False, resolver=resolver), resolver)
     chain = ops.simple_chain if _SIMPLE_FASTPATH and not _literals(resolver) else None
+    return ops, chain
+
+
+def _get_read(obj, ops, chain, default, pattern_default, apply_transforms, strict, resolver):
+    """
+    A read of obj through ops, set up by _get_setup.
+    """
     if chain is not None:
         val = engine.simple_get(chain, obj, strict=strict)
         if val is not engine.SIMPLE_BAIL:
@@ -521,7 +538,7 @@ def get(obj, path, default=None, pattern_default=(), apply_transforms=True, stri
             if not (apply_transforms and ops.transforms):
                 return val
             try:
-                return ops.apply(val, base.Settings(obj, resolver=resolver))
+                return ops.apply(val, base.Settings(obj, strict, resolver=resolver))
             except base.UnresolvedReference:
                 return default
     found = tuple(engine.values(ops, obj, strict=strict, resolver=resolver, transforms=apply_transforms))
@@ -530,6 +547,31 @@ def get(obj, path, default=None, pattern_default=(), apply_transforms=True, stri
     return found if found else pattern_default
 
 
+def getter(path, default=None, pattern_default=(), apply_transforms=True, strict=False, bindings=None, resolver=None):
+    """
+    A read of path as a callable obj -> value, as get(obj, path, ...)
+    returns it. The parse, the resolver's lex, fold and literals and the
+    fast-path decision are settled once, here, against the resolver in
+    force now, so a call is the read and nothing else.
+
+    >>> first = getter('hello.there[0]')
+    >>> first({'hello': {'there': [1, 2]}})
+    1
+    >>> getter('[*].a')([{'a': 1}, {'a': 2}])
+    (1, 2)
+    """
+    r = base.RESOLVER if resolver is None else resolver
+    ops, chain = _get_setup(path, bindings, r)
+
+    def read(obj):
+        """
+        obj read through the getter's path.
+        """
+        return _get_read(obj, ops, chain, default, pattern_default, apply_transforms, strict, r)
+
+    return read
+
+
 def get_multi(obj, iterable, apply_transforms=True, strict=False, bindings=None, resolver=None):
     """
     Get all values from obj in iterable; return iterable

{dotted_notation-0.51.1 → dotted_notation-0.51.2/dotted_notation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.51.1
+Version: 0.51.2
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License-Expression: MIT
@@ -437,6 +437,17 @@ Get the value at a dotted path. See the Paths, Patterns, and Operators sections
     >>> dotted.get({'a': {'b': {'c': {'d': 'nested'}}}}, 'a.b.c.d')
     'nested'
 
+A path read many times can be made into a **getter** once: a callable
+`obj -> value` that returns what `get` would, with the parse, the resolver's
+hooks and the fast-path decision settled when it is made, against the
+resolver in force then. It takes `get`'s arguments, the object aside.
+
+    >>> d_of = dotted.getter('a.b.c.d', default='none')
+    >>> d_of({'a': {'b': {'c': {'d': 'nested'}}}})
+    'nested'
+    >>> d_of({})
+    'none'
+
 <a id="update"></a>
 ### Update
 

{dotted_notation-0.51.1 → dotted_notation-0.51.2}/pyproject.toml

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