dotted-notation 0.44.3__tar.gz → 0.44.5__tar.gz

{dotted_notation-0.44.3 → dotted_notation-0.44.5}/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to `dotted` are recorded here. Versions prior to
 the ones listed are omitted — browse git history for earlier entries.
 
+## [0.44.5]
+
+### Performance
+- Transforms no longer disqualify the get() fast path: `a.b|int`
+  resolves via the direct-lookup chain and applies transforms on the
+  hit (~7x faster than walk). Plain paths are unaffected; `is_simple()`
+  semantics unchanged (still requires no transforms).
+
+## [0.44.4]
+
+### Added
+- Module-level escape hatches: `dotted.set_simple_fastpath(False)` disables
+  the get() fast path (everything goes through walk()), and
+  `dotted.set_parse_cache(size)` resizes the LRU cache behind parse()
+  (0 disables, None unbounded). Both return the previous setting.
+
+### Performance
+- `get()` fast path for simple paths (#58): a plain chain of literal
+  Key/Attr/Slot accesses (`a.b`, `a[0].b`, `a@x`) resolves with direct
+  dict/list/attr lookups, skipping the walk() machinery entirely. The
+  chain is computed once at parse time and cached on the `Dotted`
+  (`simple_chain`); unusual containers (dict subclasses, custom
+  mappings) fall back to the full traversal.
+- `Const.value`/`Numeric.value` are now computed once and cached on the
+  instance instead of recomputed per property access.
+- `Dotted.__hash__` is cached, making repeated cache lookups keyed on a
+  pre-parsed `Dotted` (e.g. `get(obj, parsed)`) much cheaper.
+
 ## [0.44.3]
 
 ### Fixed

{dotted_notation-0.44.3/dotted_notation.egg-info → dotted_notation-0.44.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.44.3
+Version: 0.44.5
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License: MIT

{dotted_notation-0.44.3 → dotted_notation-0.44.5}/dotted/__init__.py

@@ -58,6 +58,7 @@ For full documentation including all options and flags:
 from .api import \
     parse, is_pattern, is_template, is_reference, is_indeterminate, is_simple, \
     is_inverted, is_mutable, mutable, quote, ANY, AUTO, Attrs, GroupMode, \
+    set_simple_fastpath, set_parse_cache, \
     register, transform, \
     assemble, assemble_multi, \
     build, build_multi, \
@@ -87,6 +88,7 @@ __all__ = [
     'is_pattern', 'is_template', 'is_reference',
     'is_indeterminate', 'is_simple',
     'is_inverted', 'is_mutable', 'mutable',
+    'set_simple_fastpath', 'set_parse_cache',
     # SQL
     'sqlize', 'Resolver', 'SQLFragment', 'ParamStyle', 'ParamPool', 'TranslationError',
     # Constants

{dotted_notation-0.44.3 → dotted_notation-0.44.5}/dotted/api.py

@@ -69,6 +69,32 @@ class ParseError(Exception):
 
 _parse_lock = threading.Lock()
 
+_SIMPLE_FASTPATH = True
+
+
+def set_simple_fastpath(enable=True):
+    """
+    Enable/disable the simple-path fast path in get() (escape hatch: when
+    off, every lookup goes through the full walk() traversal). On by
+    default. Returns the previous setting.
+    """
+    global _SIMPLE_FASTPATH
+    prev = _SIMPLE_FASTPATH
+    _SIMPLE_FASTPATH = bool(enable)
+    return prev
+
+
+def set_parse_cache(size=CACHE_SIZE):
+    """
+    Resize the LRU cache behind parse(). 0 disables caching (every path
+    string is re-parsed from scratch); None makes it unbounded. Resizing
+    discards currently cached parses. Returns the previous size.
+    """
+    global _parse
+    prev = _parse.cache_info().maxsize
+    _parse = functools.lru_cache(size)(_parse.__wrapped__)
+    return prev
+
 
 @functools.lru_cache(CACHE_SIZE)
 def _parse(ops):
@@ -234,16 +260,6 @@ def is_indeterminate(path):
     return _is_template(parsed) or _is_reference(parsed)
 
 
-@functools.lru_cache(CACHE_SIZE)
-def _is_simple(ops):
-    for op in ops:
-        if not isinstance(op, (access.Key, access.Attr, access.Slot)):
-            return False
-        if not isinstance(op.op, matchers.Const):
-            return False
-    return True
-
-
 def is_simple(path):
     """
     True if the path is a plain chain of access ops (Key, Attr, Slot)
@@ -273,7 +289,7 @@ def is_simple(path):
     parsed = path if isinstance(path, results.Dotted) else parse(path)
     if parsed.transforms:
         return False
-    return _is_simple(parsed)
+    return parsed.simple_chain is not None
 
 
 def is_inverted(path):
@@ -433,6 +449,15 @@ def get(obj, path, default=None, pattern_default=(), apply_transforms=True, stri
     (7,)
     """
     ops = parse(path, bindings=bindings, partial=False)
+    chain = ops.simple_chain if _SIMPLE_FASTPATH else None
+    if chain is not None:
+        val = engine.simple_get(chain, obj, strict=strict)
+        if val is not engine.SIMPLE_BAIL:
+            if val is base.marker:
+                return default
+            if apply_transforms and ops.transforms:
+                return ops.apply(val)
+            return val
     vals = engine.iter_until_cut(engine.gets(ops, obj, strict=strict))
     if apply_transforms:
         vals = ( ops.apply(v) for v in vals )

{dotted_notation-0.44.3 → dotted_notation-0.44.5}/dotted/engine.py

@@ -48,6 +48,48 @@ def build(ops, node, deepcopy=True, **kwargs):
     return built or build_default([cur]+ops)
 
 
+SIMPLE_BAIL = object()
+
+
+def simple_get(chain, node, strict=False):
+    """
+    Fast path for simple paths (see Dotted.simple_chain): follow literal
+    keys with direct dict/list/attr access, skipping walk() entirely.
+    Returns the found value, base.marker when the path misses, or
+    SIMPLE_BAIL when a node's type falls outside the fast path — the
+    caller then falls back to the full traversal.
+    """
+    for kind, key in chain:
+        if kind == 'attr':
+            node = getattr(node, key, base.marker)
+            if node is base.marker:
+                return base.marker
+            continue
+        t = type(node)
+        if t is dict:
+            # strict: Slot never coerces to dict keys
+            if strict and kind == 'slot':
+                return base.marker
+            node = node.get(key, base.marker)
+            if node is base.marker:
+                return base.marker
+            continue
+        if t is list or t is tuple:
+            # strict: Key never coerces to sequence indices
+            if strict and kind == 'key':
+                return base.marker
+            if type(key) is not int:
+                return base.marker
+            try:
+                node = node[key]
+            except IndexError:
+                return base.marker
+            continue
+        # dict subclasses, custom containers, None, etc: full traversal
+        return SIMPLE_BAIL
+    return node
+
+
 def iter_until_cut(gen):
     """
     Consume a get generator until base.CUT_SENTINEL; yield values, stop on sentinel.

{dotted_notation-0.44.3 → dotted_notation-0.44.5}/dotted/matchers.py

@@ -10,6 +10,7 @@ import pyparsing as pp
 
 from . import base
 from .base import MatchOp
+from .utils import lazyprop
 from .utypes import ANY
 
 
@@ -19,8 +20,11 @@ _MISSING = object()
 class Const(MatchOp):
     _match_from = ('Const',)
 
-    @property
+    @lazyprop
     def value(self):
+        """
+        The literal value; computed once and cached on the instance.
+        """
         return self.args[0]
     def matches(self, vals):
         return (v for v in vals if self.value == v)
@@ -32,8 +36,11 @@ class Numeric(Const):
             return str(self.args[0]) == str(int(self.args[0]))
         except (ValueError, TypeError):
             return False
-    @property
+    @lazyprop
     def value(self):
+        """
+        The numeric value (int when possible); computed once and cached.
+        """
         return int(self.args[0]) if self.is_int() else float(self.args[0])
     def __repr__(self):
         return f'{self.value}'

{dotted_notation-0.44.3 → dotted_notation-0.44.5}/dotted/results.py

@@ -5,7 +5,9 @@ import itertools
 
 from . import predicates
 from . import utils
-from .access import Invert
+from .access import Attr, Invert, Key, Slot
+from .matchers import Const
+from .utils import lazyprop
 
 
 class rdoc(str):
@@ -35,6 +37,7 @@ class Dotted:
         else:
             self.guard = None
             self.guard_op = predicates.EQ
+        self._hash = None
 
     @property
     def guard_negate(self):
@@ -72,10 +75,12 @@ class Dotted:
             return tuple(sorted((k, Dotted._hashable(v)) for k, v in iterable))
         return obj
     def __hash__(self):
-        try:
-            return hash((self.ops, self.transforms, self.guard, self.guard_op))
-        except TypeError:
-            return hash((self.ops, Dotted._hashable(self.transforms), self.guard, self.guard_op))
+        if self._hash is None:
+            try:
+                self._hash = hash((self.ops, self.transforms, self.guard, self.guard_op))
+            except TypeError:
+                self._hash = hash((self.ops, Dotted._hashable(self.transforms), self.guard, self.guard_op))
+        return self._hash
     def __len__(self):
         return len(self.ops)
     def __iter__(self):
@@ -105,6 +110,29 @@ class Dotted:
     def apply(self, val):
         return apply_transforms(val, self.transforms)
 
+    @lazyprop
+    def simple_chain(self):
+        """
+        Tuple of (kind, key) pairs when the access chain is simple — a plain
+        chain of concrete Key/Attr/Slot accesses with no patterns,
+        substitutions, references, guards, or filters — else None. Transforms
+        are permitted (they apply after the lookup). Computed once and
+        cached; drives the fast path in get() that skips walk().
+        kind is 'key', 'attr', or 'slot'.
+        """
+        if self.guard is not None:
+            return None
+        chain = []
+        for op in self.ops:
+            # exact types: subclasses like SlotSpecial have different semantics
+            if type(op) not in (Key, Attr, Slot):
+                return None
+            if not isinstance(op.op, Const):
+                return None
+            kind = 'attr' if isinstance(op, Attr) else 'slot' if isinstance(op, Slot) else 'key'
+            chain.append((kind, op.op.value))
+        return tuple(chain)
+
 Dotted.registry.__doc__ = rdoc()
 
 

{dotted_notation-0.44.3 → dotted_notation-0.44.5}/dotted/utils.py

@@ -2,6 +2,25 @@
 Shared type-checking helpers (duck-typing).
 """
 
+class lazyprop:
+    """
+    Non-data descriptor: compute once on first access, cache the result
+    in the instance __dict__ (which then shadows the descriptor). Like
+    functools.cached_property but lock-free and available on 3.6+.
+    """
+    def __init__(self, fn):
+        self.fn = fn
+        self.name = fn.__name__
+        self.__doc__ = fn.__doc__
+
+    def __get__(self, obj, owner=None):
+        if obj is None:
+            return self
+        val = self.fn(obj)
+        obj.__dict__[self.name] = val
+        return val
+
+
 try:
     import dataclasses as _dc
 except ImportError:

{dotted_notation-0.44.3 → dotted_notation-0.44.5/dotted_notation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.44.3
+Version: 0.44.5
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License: MIT

{dotted_notation-0.44.3 → dotted_notation-0.44.5}/pyproject.toml

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