dotted-notation 0.44.11__tar.gz → 0.45.0__tar.gz

{dotted_notation-0.44.11 → dotted_notation-0.45.0}/CHANGELOG.md

@@ -3,6 +3,58 @@
 All notable changes to `dotted` are recorded here. Versions prior to
 the ones listed are omitted — browse git history for earlier entries.
 
+## [0.45.0]
+
+A performance release. Figures compare against 0.44.11 on a document of
+1000 records, using `python -m benchmarks`.
+
+### Performance
+- `unpack()` no longer grows with the square of the leaf count. A soft
+  cut compared every new path against every path already yielded; those
+  paths are now indexed by their leading keys. A recursive op with a
+  negative depth also recomputed each node's depth-to-leaf for every
+  ancestor; a traversal now remembers it. 16,000 leaves: 382s to 0.21s.
+- `unpack(project=...)` matches projections against the paths the walk
+  already has instead of parsing each leaf path it generated.
+- A concrete key is no longer found by comparing it against every key
+  of the node: an absent key matches without a scan and a present one
+  stops at the first match. `update()` looks each level up once, not
+  twice. Concrete `update` and `remove` into a 1000-key dict take about
+  70% less time.
+- Writing paths out is cheaper: quoting no longer imports per call,
+  tests for an integer by catching an exception, or scans characters in
+  a Python loop. `pluck()` and `expand()` take about 40% less time.
+- `setdefault`, `update` and `remove` with `AUTO`, `pluck`, `translate`,
+  `match_multi` and `unpack` compile each path once per call.
+- Pattern reads shed per-match layers that did nothing without filters
+  or transforms: wildcard and recursive `get` take 15-21% less time,
+  pattern `update` 30-40%.
+- `build()` takes about 60% less time, `match_multi` 40%.
+- Imports that ran inside hot functions are now at module level.
+
+### Added
+- `compile()`, an alias for `parse()`. Every API that takes a path also
+  takes the compiled result.
+- Benchmark cases for `unpack`, `translate`, `match_multi`,
+  `setdefault`, filters, a late key and an absent key.
+
+### Fixed
+- A top-level key starting with `-` was written out bare, so it read
+  back as an inverted path and `pack(unpack(obj))` lost it. Such a key
+  is now quoted when it leads a path: `'-n'` with quotes, `#'-1'` for a
+  negative number.
+
+### Changed
+- Paths returned by `pluck`, `expand`, `unpack` and `walk` quote a
+  leading `-` key as above, and so do `match()` captures that begin
+  with one. Keys elsewhere in a path are unchanged.
+- A dict-like whose `in` disagrees with its `keys()` can see a present
+  key reported as absent, since a concrete key is now tested for
+  membership before the keys are scanned.
+- `match()` without `groups` no longer assembles the unmatched tail of
+  a partial match, so a hand-built path containing an op that cannot be
+  written as text no longer raises there.
+
 ## [0.44.11]
 
 ### Changed

{dotted_notation-0.44.11/dotted_notation.egg-info → dotted_notation-0.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.44.11
+Version: 0.45.0
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
 License: MIT
@@ -1456,6 +1456,13 @@ When `partial=True` (the default for `parse()`), unresolved substitutions are
 allowed through. When `partial=False` (the default for traversal APIs),
 unresolved templates raise `TypeError`.
 
+`compile()` is an alias for `parse()`. Every API that takes a path also takes
+the parsed result, so a path used many times can be compiled once:
+
+    >>> ops = dotted.compile('a.b')
+    >>> dotted.get({'a': {'b': 1}}, ops)
+    1
+
 <a id="references"></a>
 ### References
 

{dotted_notation-0.44.11 → dotted_notation-0.45.0}/README.md

@@ -1410,6 +1410,13 @@ When `partial=True` (the default for `parse()`), unresolved substitutions are
 allowed through. When `partial=False` (the default for traversal APIs),
 unresolved templates raise `TypeError`.
 
+`compile()` is an alias for `parse()`. Every API that takes a path also takes
+the parsed result, so a path used many times can be compiled once:
+
+    >>> ops = dotted.compile('a.b')
+    >>> dotted.get({'a': {'b': 1}}, ops)
+    1
+
 <a id="references"></a>
 ### References
 

{dotted_notation-0.44.11 → dotted_notation-0.45.0}/dotted/__init__.py

@@ -56,7 +56,7 @@ For full documentation including all options and flags:
     or see README.md
 """
 from .api import \
-    parse, is_pattern, is_template, is_reference, is_indeterminate, is_simple, \
+    parse, compile, 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, \
@@ -84,7 +84,7 @@ __all__ = [
     # Transform
     'apply', 'apply_multi', 'register', 'transform',
     # Utility
-    'parse', 'assemble', 'assemble_multi', 'quote',
+    'parse', 'compile', 'assemble', 'assemble_multi', 'quote',
     'is_pattern', 'is_template', 'is_reference',
     'is_indeterminate', 'is_simple',
     'is_inverted', 'is_mutable', 'mutable',

{dotted_notation-0.44.11 → dotted_notation-0.45.0}/dotted/access.py

@@ -2,68 +2,18 @@
 """
 import functools
 import itertools
-import re
+import numbers
 import types
 
 from . import base
 from . import matchers
+from . import utils
 
 
 def itemof(node, val):
     return val if isinstance(node, (str, bytes)) else node.__class__([val])
 
 
-# ---- quoting utilities ----
-
-_RESERVED = frozenset('.[]*:|+?/=,@&()!~#{}$<>')
-_NEEDS_QUOTE = _RESERVED | frozenset(' \t\n\r')
-
-_NUMERIC_RE = re.compile(
-    r'[-]?0[xX][0-9a-fA-F]+$'           # hex
-    r'|[-]?0[oO][0-7]+$'                # octal
-    r'|[-]?0[bB][01]+$'                 # binary
-    r'|[-]?[0-9][0-9_]*[eE][+-]?[0-9]+$' # scientific notation
-    r'|[-]?[0-9]+(?:_[0-9]+)+$'         # underscore separators
-    r'|[-]?[0-9]+$'                     # plain integers
-)
-
-
-def _needs_quoting(s):
-    """
-    Return True if a string key must be quoted in dotted notation.
-    """
-    if not s:
-        return True
-    # matchers.Numeric forms (integers, scientific notation, underscore separators)
-    # are handled by the grammar and don't need quoting, even if they
-    # contain reserved characters like '+' in '1e+10'.
-    if s[0].isdigit() or (len(s) > 1 and s[0] == '-' and s[1].isdigit()):
-        return not _NUMERIC_RE.match(s)
-    if any(c in _NEEDS_QUOTE for c in s):
-        return True
-    return False
-
-
-def _is_numeric_str(s):
-    """
-    Return True if s is a string that parses as an integer.
-    """
-    try:
-        int(s)
-        return True
-    except (ValueError, TypeError):
-        return False
-
-
-def _quote_str(s):
-    """
-    Wrap a string in single quotes, escaping backslashes and single quotes.
-    """
-    s = s.replace('\\', '\\\\').replace("'", "\\'")
-    return f"'{s}'"
-
-
-
 class BaseOp(base.TraversalOp):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -92,32 +42,32 @@ class BaseOp(base.TraversalOp):
         return (v for _, v in self.items(node, **kwargs))
 
     def do_update(self, ops, node, val, has_defaults, _path, nop, nop_from_unwrap=False, **kwargs):
-        from . import engine
-        from . import wrappers
         if not ops:
             if nop:
                 return node
             if kwargs.get('strict') and not any(True for _ in self.items(node, **kwargs)):
                 return node
             return self.upsert(node, val)
-        if self.is_empty(node) and not has_defaults:
-            if nop or isinstance(ops[0], wrappers.NopWrap):
-                return node
-            built = engine.updates(ops, engine.build_default(ops), val, True, _path, nop, **kwargs)
-            return self.upsert(node, built)
+        items = self.update_items(node, **kwargs)
+        if items is None:
+            if not has_defaults:
+                if nop or isinstance(ops[0], wrappers.NopWrap):
+                    return node
+                built = engine.updates(ops, engine.build_default(ops), val, True, _path, nop, **kwargs)
+                return self.upsert(node, built)
+            items = self.items(node, **kwargs)
         inner_kwargs = kwargs
         if kwargs.get('_parents') is not None:
             inner_kwargs = dict(kwargs)
             inner_kwargs['_parents'] = (node,) + kwargs['_parents']
         pass_nop = nop and not nop_from_unwrap
-        for k, v in self.items(node, **kwargs):
+        for k, v in items:
             if v is None:
                 v = engine.build_default(ops)
             node = self.update(node, k, engine.updates(ops, v, val, has_defaults, _path + [(self, k)], pass_nop, **inner_kwargs))
         return node
 
     def do_remove(self, ops, node, val, nop, **kwargs):
-        from . import engine
         if not ops:
             if nop:
                 return node
@@ -343,6 +293,21 @@ class AccessOp(SimpleOp):
     def is_empty(self, node):
         return not any(True for _ in self.keys(node))
 
+    def update_items(self, node, **kwargs):
+        """
+        One lookup, not two: is_empty() above asks whether items() yields
+        anything, so take the first item and keep the rest. Only when the
+        two would see the same items: is_empty() ignores strict, and a
+        subclass may define emptiness differently.
+        """
+        if kwargs.get('strict') or type(self).is_empty is not AccessOp.is_empty:
+            return super().update_items(node, **kwargs)
+        items = iter(self.items(node, **kwargs))
+        first = next(items, base.marker)
+        if first is base.marker:
+            return None
+        return itertools.chain((first,), items)
+
 
 class Key(AccessOp):
     """
@@ -361,18 +326,28 @@ class Key(AccessOp):
     @classmethod
     @functools.lru_cache()
     def _concrete_cached(cls, _type, val):
-        import numbers
         if isinstance(val, numbers.Number):
             return cls(matchers.NumericQuoted(val))
         return cls(matchers.Word(val))
 
     def operator(self, top=False):
-        q = self.op.quote()
         if top:
-            return q
-        return '.' + q
+            return self.op.quote_top()
+        return '.' + self.op.quote()
 
     def _items(self, node, keys, filtered=True):
+        if not filtered or not self.filters:
+            # nothing to filter: one generator, not two threaded through a filter
+            def _unfiltered():
+                for k in keys:
+                    try:
+                        v = node[k]
+                    except (TypeError, KeyError, IndexError):
+                        continue
+                    yield (k, v)
+
+            return _unfiltered()
+
         curkey = None
 
         def _values():
@@ -399,7 +374,7 @@ class Key(AccessOp):
                 for r in self._resolved(node=node, **kwargs))
         # Dict-like: use key matching
         if hasattr(node, 'keys'):
-            keys = self.op.matches(node.keys()) if filtered else node.keys()
+            keys = self.op.match_keys(node) if filtered else node.keys()
             return self._items(node, keys, filtered)
         # In strict mode, numeric keys never coerce to list indices
         if kwargs.get('strict'):
@@ -433,7 +408,6 @@ class Key(AccessOp):
         return {self.op.value: None}
 
     def match(self, op, specials=False):
-        from . import wrappers
         if isinstance(op, wrappers.FilterWrap):
             op = op.inner
         if not isinstance(op, Key):
@@ -503,6 +477,18 @@ class Attr(Key):
         return '@' + self.op.quote()
 
     def _items(self, node, keys, filtered=True):
+        if not filtered or not self.filters:
+            # nothing to filter: one generator, not two threaded through a filter
+            def _unfiltered():
+                for k in keys:
+                    try:
+                        v = getattr(node, k)
+                    except AttributeError:
+                        continue
+                    yield (k, v)
+
+            return _unfiltered()
+
         curkey = None
 
         def _values():
@@ -600,9 +586,8 @@ class Attr(Key):
         if hasattr(node, '_replace'):
             return node._replace(**{key: val})
         # Try dataclasses.replace for frozen dataclass (skipped on 3.6)
-        from .utils import is_dataclass, dataclass_replace
-        if is_dataclass(node):
-            return dataclass_replace(node, **{key: val})
+        if utils.is_dataclass(node):
+            return utils.dataclass_replace(node, **{key: val})
         raise AttributeError(f"Cannot set attribute '{key}' on {type(node).__name__}")
     def upsert(self, node, val):
         if not self.is_pattern():
@@ -622,9 +607,8 @@ class Attr(Key):
         updates = {k: val for k in keys}
         if hasattr(node, '_replace'):
             return node._replace(**updates)
-        from .utils import is_dataclass, dataclass_replace
-        if is_dataclass(node):
-            return dataclass_replace(node, **updates)
+        if utils.is_dataclass(node):
+            return utils.dataclass_replace(node, **updates)
         raise AttributeError(f"Cannot set attributes on {type(node).__name__}")
 
     def pop(self, node, key):
@@ -652,7 +636,6 @@ class Slot(Key):
     @classmethod
     @functools.lru_cache()
     def _concrete_cached(cls, _type, val):
-        import numbers
         if isinstance(val, numbers.Number):
             return cls(matchers.Numeric(val))
         return cls(matchers.String(val))
@@ -1092,10 +1075,14 @@ class Invert(SimpleOp):
         yield node
 
     def do_update(self, ops, node, val, has_defaults, _path, nop, nop_from_unwrap=False, **kwargs):
-        from . import engine
         return engine.removes(ops, node, val, **kwargs)
 
     def do_remove(self, ops, node, val, nop, **kwargs):
-        from . import engine
         assert val is not base.ANY, 'Value required'
         return engine.updates(ops, node, val, **kwargs)
+
+
+# engine and wrappers both import this module, so they can only be bound
+# once the classes above exist.
+from . import engine  # noqa: E402
+from . import wrappers  # noqa: E402

{dotted_notation-0.44.11 → dotted_notation-0.45.0}/dotted/api.py

@@ -131,6 +131,9 @@ def parse(path, bindings=None, partial=True):
     return ops
 
 
+compile = parse
+
+
 def quote(key, as_key=True):
     """
     Quote a key for use in a dotted path.  Idempotent: quote(quote(x)) == quote(x).
@@ -315,8 +318,7 @@ def _is_mutable_container(obj):
     if hasattr(obj, '_fields') and hasattr(obj, '_replace'):
         return False
     # Frozen dataclasses (no-op on Python 3.6 — no dataclasses module)
-    from .utils import is_dataclass
-    if is_dataclass(obj) and obj.__dataclass_fields__:
+    if utils.is_dataclass(obj) and obj.__dataclass_fields__:
         # Check if frozen
         try:
             # Try to detect frozen - frozen dataclasses raise FrozenInstanceError
@@ -425,7 +427,9 @@ def build_multi(obj, paths, strict=False, bindings=None):
     for path in paths:
         ops = parse(path, bindings=bindings, partial=False)
         built = engine.build(ops, obj, strict=strict)
-        obj = update_multi(obj, _pluck_parsed(built, ops, strict=strict), strict=strict)
+        # walked paths are concrete: nothing for update() to resolve or check
+        for found, val in _pluck_parsed(built, ops, strict=strict):
+            obj = engine.updates(found, obj, found.apply(val), strict=strict)
     return obj
 
 
@@ -476,8 +480,8 @@ def get(obj, path, default=None, pattern_default=(), apply_transforms=True, stri
             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 = engine.values(ops, obj, strict=strict)
+    if apply_transforms and ops.transforms:
         vals = ( ops.apply(v) for v in vals )
     if ops.guard is not None:
         vals = (v for v in vals if ops.guard_matches(v))
@@ -522,12 +526,13 @@ def setdefault(obj, path, val, apply_transforms=True, strict=False, bindings=Non
     >>> setdefault({}, 'a.b.c', 7)
     7
     """
+    ops = parse(path, bindings=bindings, partial=False)
     if obj is AUTO:
-        obj = _auto_root_from_path(path)
-    if has(obj, path, strict=strict, bindings=bindings):
-        return  get(obj, path, apply_transforms=apply_transforms, strict=strict, bindings=bindings)
-    obj = update(obj, path, val, apply_transforms=apply_transforms, strict=strict, bindings=bindings)
-    return get(obj, path, apply_transforms=False, strict=strict, bindings=bindings)
+        obj = _auto_root_from_path(ops)
+    if has(obj, ops, strict=strict):
+        return get(obj, ops, apply_transforms=apply_transforms, strict=strict)
+    obj = update(obj, ops, val, apply_transforms=apply_transforms, strict=strict)
+    return get(obj, ops, apply_transforms=False, strict=strict)
 
 
 def setdefault_multi(obj, pathvalues, apply_transforms=True, strict=False, bindings=None):
@@ -559,8 +564,10 @@ def update_if(obj, path, val, pred=lambda val: val is not None, mutable=True, ap
     >>> update_if({}, 'a', '', pred=bool)
     {}
     """
+    parsed = path
     if obj is AUTO:
-        obj = _auto_root_from_path(path)
+        parsed = parse(path)
+        obj = _auto_root_from_path(parsed)
     if not mutable and _is_mutable_container(obj):
         obj = utils.deepcopy(obj)
         mutable = True
@@ -568,7 +575,7 @@ def update_if(obj, path, val, pred=lambda val: val is not None, mutable=True, ap
     if pred is not None and not pred(val):
         return obj
 
-    ops = parse(path, bindings=bindings, partial=False)
+    ops = parse(parsed, bindings=bindings, partial=False)
     return engine.updates(ops, obj, ops.apply(val) if apply_transforms else val, strict=strict)
 
 
@@ -661,8 +668,10 @@ def remove_if(obj, path, pred=lambda path: path is not None, val=ANY, mutable=Tr
     >>> remove_if({'a': 1}, None)
     {'a': 1}
     """
+    parsed = path
     if obj is AUTO:
-        obj = _auto_root_from_path(path)
+        parsed = parse(path)
+        obj = _auto_root_from_path(parsed)
     if not mutable and _is_mutable_container(obj):
         obj = utils.deepcopy(obj)
         mutable = True
@@ -670,7 +679,7 @@ def remove_if(obj, path, pred=lambda path: path is not None, val=ANY, mutable=Tr
     if pred is not None and not pred(path):
         return obj
 
-    return engine.removes(parse(path, bindings=bindings, partial=False), obj, val, strict=strict)
+    return engine.removes(parse(parsed, bindings=bindings, partial=False), obj, val, strict=strict)
 
 
 def remove_if_multi(obj, items, paths_only=True, pred=lambda path: path is not None, mutable=True, strict=False, bindings=None):
@@ -821,6 +830,13 @@ def match(pattern, path, groups=False, partial=True, strict=False):
     '*b'
     >>> match('*', '**')
     """
+    return _match_parsed(parse(pattern), parse(path), path, groups, partial)
+
+
+def _match_parsed(pats, path_ops, path, groups, partial):
+    """
+    match() on parsed arguments. `path` is what a successful match returns.
+    """
     # groups can be a bool, a GroupMode member, or its string value.
     _patterns_only = (groups == GroupMode.patterns
                       or groups == GroupMode.patterns.value)
@@ -832,19 +848,17 @@ def match(pattern, path, groups=False, partial=True, strict=False):
             matches = [m for m, ip in zip(matches, is_pat) if ip]
         return (r, tuple(matches))
 
-    pats = parse(pattern)
-    path_ops = parse(path)
-
     # Variadic ops (recursive, groups) consume variable-length path
     # segments — use the recursive matcher.  On the path side they make
     # the path denote multiple expansions, which likewise needs it.
-    if any(op.is_variadic() for op in pats) or any(op.is_variadic() for op in path_ops):
+    if pats.variadic or path_ops.variadic:
         result = base.match_ops(list(pats), list(path_ops), partial)
         if result is None:
             return returns(None, [])
         return returns(path, [v for v, _ in result], [p for _, p in result])
 
     # Original non-recursive match logic
+    collect = bool(groups)
     _matches = []
     _is_pat = []
     for idx,(pop,kop) in enumerate(zip(pats, path_ops)):
@@ -856,12 +870,17 @@ def match(pattern, path, groups=False, partial=True, strict=False):
         m = pop.match(kop, specials=True)
         if not m:
             return returns(None, [], [])
+        if not collect:
+            # captures are only returned with groups
+            continue
+        is_pat = pop.is_pattern()
         if isinstance(m, (tuple, list)):
-            _matches.extend(_m.val for _m in m)
-            _is_pat.extend(pop.is_pattern() for _ in m)
+            for _m in m:
+                _matches.append(_m.val)
+                _is_pat.append(is_pat)
         else:
             _matches.append(m.val)
-            _is_pat.append(pop.is_pattern())
+            _is_pat.append(is_pat)
 
     # we've completed matching but the last item in match groups is treated 'greedily'
     assert kop is not None          # sanity
@@ -875,6 +894,8 @@ def match(pattern, path, groups=False, partial=True, strict=False):
         return returns(None, [], [])
 
     # otherwise inexact (partial) match
+    if not collect:
+        return path
     # assemble remaining segments
     rpath = path_ops.assemble(start=idx)
     if pop is None:
@@ -891,7 +912,14 @@ def match_multi(pattern, iterable, groups=False, partial=True, strict=False):
     >>> list(match_multi('/h.*/', ['hello', 'there', 'hi']))
     ['hello', 'hi']
     """
-    matches = (match(pattern, p, groups=groups, partial=partial, strict=strict) for p in iterable)
+    def _matches():
+        pats = None
+        for p in iterable:
+            if pats is None:
+                pats = parse(pattern)
+            yield _match_parsed(pats, parse(p), p, groups, partial)
+
+    matches = _matches()
     if groups:
         return (m for m in matches if m[0])
     return (m for m in matches if m)
@@ -925,8 +953,12 @@ def translate(path, pattern_map):
     True
     """
     map_items = pattern_map.items() if hasattr(pattern_map, 'items') else pattern_map
+    path_ops = None
     for pattern, template in map_items:
-        (r, groups) = match(pattern, path, groups=GroupMode.patterns, partial=False)
+        pats = parse(pattern)
+        if path_ops is None:
+            path_ops = parse(path)
+        (r, groups) = _match_parsed(pats, path_ops, path, GroupMode.patterns, False)
         if not r:
             continue
         try:
@@ -1049,7 +1081,7 @@ def apply_multi(obj, patterns, strict=False, bindings=None):
             if ops in seen:
                 continue
             seen[ops] = None
-            first = next(engine.iter_until_cut(engine.gets(ops, obj, strict=strict)), _marker)
+            first = next(engine.values(ops, obj, strict=strict), _marker)
             if first is _marker:
                 continue
             val = ops.apply(first)
@@ -1075,17 +1107,26 @@ def pluck_multi(obj, patterns, default=None, strict=False, bindings=None):
     >>> list(pluck_multi(d, ('hello', 'a.b')))
     [('hello', 7), ('a.b', 'seven')]
     """
+    return ((field, val) for field, _, val in _pluck_written(obj, patterns, strict=strict, bindings=bindings))
+
+
+def _pluck_written(obj, patterns, strict=False, bindings=None):
+    """
+    Yield deduped (field, parsed field, value) triples from obj matching any
+    of `patterns`: what pluck_multi yields, plus each field already parsed,
+    so a caller that needs the field as a path does not parse the string.
+    """
     seen = {}
     for pattern in patterns:
         ops = parse(pattern, bindings=bindings, partial=False)
         for path, val in engine.walk(ops, obj, paths=True, strict=strict):
             if path is utypes.CUT_SENTINEL:
                 break
-            field = results.Dotted({'ops': path, 'transforms': ops.transforms}).assemble()
+            field, parsed = results.Dotted({'ops': path, 'transforms': ops.transforms}).written()
             if field in seen:
                 continue
             seen[field] = None
-            yield (field, val)
+            yield (field, parsed, val)
 
 
 def pluck(obj, pattern, default=None, strict=False, bindings=None):
@@ -1097,10 +1138,11 @@ def pluck(obj, pattern, default=None, strict=False, bindings=None):
     >>> pluck(d, 'a.b')
     ('a.b', 'seven')
     """
-    out = tuple(pluck_multi(obj, (pattern,), default=default, strict=strict, bindings=bindings))
+    parsed = parse(pattern)
+    out = tuple(pluck_multi(obj, (parsed,), default=default, strict=strict, bindings=bindings))
     if not out:
         return ()
-    if is_pattern(pattern):
+    if is_pattern(parsed):
         return out
     return out[0]
 
@@ -1196,16 +1238,30 @@ def unpack(obj, attrs=None, project=None, partial=True):
         extra = ', @/(?!__).*/'
     else:
         extra = ', @/__.*/'
-    result = dict(pluck(obj, f'*(*#, [*]:!(str, bytes){extra}):-2(.*, []{extra})##, (*, []{extra})'))
+    pattern = f'*(*#, [*]:!(str, bytes){extra}):-2(.*, []{extra})##, (*, []{extra})'
     if project is None:
-        return result
+        return dict(pluck(obj, pattern))
+    leaves = list(_pluck_written(obj, (pattern,)))
     if isinstance(project, str):
         project = [project]
     # Normalize each entry to (pattern, partial); bare patterns inherit the
     # global `partial`, (pattern, partial) tuples override it per-field.
     specs = [(p, partial) if isinstance(p, str) else tuple(p) for p in project]
-    return {k: v for k, v in result.items()
-            if any(match(pat, k, partial=pp) for pat, pp in specs)}
+    compiled = [None] * len(specs)
+
+    def selected(field, path_ops):
+        """
+        True if a leaf matches any projection. Each pattern is compiled when
+        first reached; the leaf's path comes parsed from the walk.
+        """
+        for i, (pat, pp) in enumerate(specs):
+            if compiled[i] is None:
+                compiled[i] = parse(pat)
+            if _match_parsed(compiled[i], path_ops, field, False, pp):
+                return True
+        return False
+
+    return {field: val for field, path_ops, val in leaves if selected(field, path_ops)}
 
 
 def items(obj, attrs=None, project=None, partial=True):