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

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

@@ -3,6 +3,53 @@
 All notable changes to `dotted` are recorded here. Versions prior to
 the ones listed are omitted — browse git history for earlier entries.
 
+## [0.46.1]
+
+### Changed
+- Each compiled wheel is built and tested in its own CI job, so a
+  release takes minutes rather than the better part of an hour. The CLI
+  tests write their input files under pytest's `tmp_path`, which
+  Windows accepts.
+
+## [0.46.0]
+
+### Added
+- The engine compiles to C. Wheels for CPython 3.11-3.14 on Linux
+  (glibc and musl, x86_64 and aarch64), macOS (Apple Silicon) and
+  Windows carry the compiled engine; every other Python installs the
+  same code as pure Python from the universal wheel. `DOTTED_NATIVE=0`
+  in the environment runs the Python engine regardless;
+  `dotted.native.active()` says which is loaded. Wildcard reads are
+  about 2.9x faster than 0.45.1 compiled and writes about 3.5x; pure
+  Python is faster too, writes by about a third.
+- For development: `make test` and `make bench` run both engines,
+  `test.python`/`test.native` and `bench.python`/`bench.native` one;
+  `make test.wheel` runs the suite against a wheel built from the
+  source distribution.
+
+### Changed
+- The `all` extra now means all of them: `formats` and `copium`. It was
+  an alias for `formats`, deprecated since 0.44.9.
+- A concrete key present in a node is no longer looked for among the
+  node's keys to return the node's own key object: it matches as
+  written. Concrete writes and `expand`, `pluck` and `unpack` on a
+  concrete key cost the same wherever the key sits in a large dict
+  (`update` of the 996th key of 1000: 11.5us to 3.3us compiled). The
+  one visible difference: a rendered path shows the key as written
+  where the node spells it differently but equal, `users.1` for a key
+  `1.0`, `RED` for a `StrEnum` member.
+
+## [0.45.1]
+
+### Changed
+- The extras no longer carry environment markers of their own. A marker
+  ahead of the extra condition made pypistats list `copium` and `tomli`
+  as hard requirements; only `pyparsing` is one. Two consequences:
+  `pip install dotted-notation[copium]` now fails where copium cannot be
+  installed (below CPython 3.10) instead of skipping it, and the `toml`,
+  `formats` and `all` extras install `tomli` on Python 3.11+ as well,
+  where it goes unused in favor of the standard library's `tomllib`.
+
 ## [0.45.0]
 
 A performance release. Figures compare against 0.44.11 on a document of

dotted_notation-0.46.1/MANIFEST.in

@@ -0,0 +1,4 @@
+include CHANGELOG.md
+recursive-include dotted *.pxd
+recursive-exclude dotted *.c *.so *.pyd
+prune tests

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

@@ -1,16 +1,15 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.45.0
+Version: 0.46.1
 Summary: Dotted notation for safe nested data traversal with optional chaining, pattern matching, and transforms
 Author-email: Frey Waid <logophage1@gmail.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/freywaid/dotted
 Project-URL: Source, https://github.com/freywaid/dotted
 Project-URL: Changelog, https://github.com/freywaid/dotted/blob/master/CHANGELOG.md
 Keywords: dotted,nested,path,pattern-matching,json,jsonb,sql,traversal
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.6
@@ -21,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Requires-Python: >=3.6
@@ -28,19 +28,20 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyparsing>=3.0
 Provides-Extra: copium
-Requires-Dist: copium>=0.1.0; (python_version >= "3.10" and platform_python_implementation == "CPython") and extra == "copium"
+Requires-Dist: copium>=0.1.0; extra == "copium"
 Provides-Extra: yaml
 Requires-Dist: PyYAML>=5.0; extra == "yaml"
 Provides-Extra: toml
-Requires-Dist: tomli>=1.0; python_version < "3.11" and extra == "toml"
+Requires-Dist: tomli>=1.0; extra == "toml"
 Requires-Dist: tomli_w>=1.0; extra == "toml"
 Provides-Extra: formats
 Requires-Dist: PyYAML>=5.0; extra == "formats"
-Requires-Dist: tomli>=1.0; python_version < "3.11" and extra == "formats"
+Requires-Dist: tomli>=1.0; extra == "formats"
 Requires-Dist: tomli_w>=1.0; extra == "formats"
 Provides-Extra: all
+Requires-Dist: copium>=0.1.0; extra == "all"
 Requires-Dist: PyYAML>=5.0; extra == "all"
-Requires-Dist: tomli>=1.0; python_version < "3.11" and extra == "all"
+Requires-Dist: tomli>=1.0; extra == "all"
 Requires-Dist: tomli_w>=1.0; extra == "all"
 Dynamic: license-file
 
@@ -73,8 +74,9 @@ Or pick only what you need:
 
     pip install dotted-notation[yaml,toml]
 
-> **Deprecated:** the `all` extra is an alias for `formats` and will be removed
-> in a future release. Use `formats` instead.
+Or everything, formats and copium (below) alike:
+
+    pip install dotted-notation[all]
 
 For faster `mutable=False` updates and removes, install the
 [copium](https://github.com/Bobronium/copium) extra, a C implementation of

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

@@ -27,8 +27,9 @@ Or pick only what you need:
 
     pip install dotted-notation[yaml,toml]
 
-> **Deprecated:** the `all` extra is an alias for `formats` and will be removed
-> in a future release. Use `formats` instead.
+Or everything, formats and copium (below) alike:
+
+    pip install dotted-notation[all]
 
 For faster `mutable=False` updates and removes, install the
 [copium](https://github.com/Bobronium/copium) extra, a C implementation of

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

@@ -55,6 +55,12 @@ For full documentation including all options and flags:
     $ pydoc dotted.api
     or see README.md
 """
+from . import native
+
+# before anything else of dotted's is imported: see dotted.native
+if not native.wanted():
+    native.use_source()
+
 from .api import \
     parse, compile, is_pattern, is_template, is_reference, is_indeterminate, is_simple, \
     is_inverted, is_mutable, mutable, quote, ANY, AUTO, Attrs, GroupMode, \

dotted_notation-0.46.1/dotted/access.pxd

@@ -0,0 +1,57 @@
+# Type declarations for the compiler; see base.pxd.
+from . cimport base
+from . cimport matchers
+
+
+cdef class BaseOp(base.TraversalOp):
+    cdef public tuple filters
+
+    cpdef filtered(self, items)
+
+
+cdef class SimpleOp(BaseOp):
+    cpdef items(self, node, settings=*, filtered=*)
+
+
+cdef class Empty(SimpleOp):
+    pass
+
+
+cdef class AccessOp(SimpleOp):
+    cdef public object op
+
+    cpdef quote(self)
+    cpdef is_pattern(self)
+    cpdef is_template(self)
+    cpdef is_reference(self)
+
+
+cdef class Key(AccessOp):
+    cpdef _const_items(self, node)
+    cpdef operator(self, top=*)
+    cpdef default(self)
+    cpdef match(self, op, specials=*)
+
+
+cdef class Attr(Key):
+    pass
+
+
+cdef class Slot(Key):
+    pass
+
+
+cdef class SlotSpecial(Slot):
+    pass
+
+
+cdef class SliceFilter(BaseOp):
+    pass
+
+
+cdef class Slice(SimpleOp):
+    pass
+
+
+cdef class Invert(SimpleOp):
+    pass

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

@@ -35,51 +35,45 @@ class BaseOp(base.TraversalOp):
             items = f.filtered(items)
         return items
 
-    def keys(self, node, **kwargs):
-        return (k for k, _ in self.items(node, **kwargs))
+    def keys(self, node, settings=base.SETTINGS):
+        return (k for k, _ in self.items(node, settings=settings))
 
-    def values(self, node, **kwargs):
-        return (v for _, v in self.items(node, **kwargs))
+    def values(self, node, settings=base.SETTINGS):
+        return (v for _, v in self.items(node, settings=settings))
 
-    def do_update(self, ops, node, val, has_defaults, _path, nop, nop_from_unwrap=False, **kwargs):
+    def do_update(self, ops, node, val, has_defaults, _path, nop, nop_from_unwrap=False, settings=base.SETTINGS):
         if not ops:
             if nop:
                 return node
-            if kwargs.get('strict') and not any(True for _ in self.items(node, **kwargs)):
+            if settings.strict and not any(True for _ in self.items(node, settings=settings)):
                 return node
             return self.upsert(node, val)
-        items = self.update_items(node, **kwargs)
+        items = self.update_items(node, settings=settings)
         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)
+                built = engine.updates(ops, engine.build_default(ops), val, True, _path, nop, settings=settings)
                 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']
+            items = self.items(node, settings=settings)
+        inner = settings.below(node)
         pass_nop = nop and not nop_from_unwrap
         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))
+            node = self.update(node, k, engine.updates(ops, v, val, has_defaults, _path + [(self, k)], pass_nop, settings=inner))
         return node
 
-    def do_remove(self, ops, node, val, nop, **kwargs):
+    def do_remove(self, ops, node, val, nop, settings=base.SETTINGS):
         if not ops:
             if nop:
                 return node
-            if kwargs.get('strict') and not any(True for _ in self.items(node, **kwargs)):
+            if settings.strict and not any(True for _ in self.items(node, settings=settings)):
                 return node
             return self.remove(node, val)
-        inner_kwargs = kwargs
-        if kwargs.get('_parents') is not None:
-            inner_kwargs = dict(kwargs)
-            inner_kwargs['_parents'] = (node,) + kwargs['_parents']
-        for k, v in self.items(node, **kwargs):
-            node = self.update(node, k, engine.removes(ops, v, val, nop=False, **inner_kwargs))
+        inner = settings.below(node)
+        for k, v in self.items(node, settings=settings):
+            node = self.update(node, k, engine.removes(ops, v, val, nop=False, settings=inner))
         return node
 
 
@@ -89,6 +83,12 @@ class SimpleOp(BaseOp):
     Base for ops with items()/concrete() that share the standard walk pattern.
     """
 
+    def items(self, node, settings=base.SETTINGS, filtered=True):
+        """
+        (key, value) for each match of this op in node.
+        """
+        raise NotImplementedError
+
     def push_children(self, stack, frame, paths):
         """
         Push matching children onto the traversal stack.
@@ -97,18 +97,13 @@ class SimpleOp(BaseOp):
         NOTE: We tried skipping list()+reversed() for concrete (non-pattern)
         keys since they match at most one item.  Benchmarked as neutral —
         the is_pattern() check costs roughly what the single-item reversal
-        saves.  We also tried removing the ``or {}`` guard on kwargs
-        (always passing a dict instead of None).  Also neutral.  Keeping
-        the simple uniform path for clarity.
+        saves.  Keeping the simple uniform path for clarity.
         """
-        children = list(self.items(frame.node, **(frame.kwargs or {})))
-        kw = frame.kwargs
-        if kw and kw.get('_parents') is not None:
-            kw = dict(kw)
-            kw['_parents'] = (frame.node,) + kw['_parents']
+        children = list(self.items(frame.node, settings=frame.settings))
+        below = frame.settings.below(frame.node)
         for k, v in reversed(children):
             cp = frame.prefix + (self.concrete(k),) if paths else frame.prefix
-            stack.push(base.Frame(frame.ops, v, cp, kwargs=kw))
+            stack.push(base.Frame(frame.ops, v, cp, settings=below))
         return ()
 
 
@@ -143,20 +138,24 @@ class Empty(SimpleOp):
     def operator(self, top=False):
         return self.__repr__()
 
-    def items(self, node, **kwargs):
+    def items(self, node, settings=base.SETTINGS, filtered=True):
         """
-        Yield the root as a single item with empty key.
+        The root as a single item with empty key.
         """
+        return self._root_items(node)
+
+    def _root_items(self, node):
         for v in self.filtered((node,)):
             yield ('', v)
 
-    def keys(self, node, **kwargs):
+    def keys(self, node, settings=base.SETTINGS):
         """
         Yield empty string as the 'key' for root.
         """
-        return (k for k, _ in self.items(node, **kwargs))
+        items = self.items(node, settings=settings)
+        return (k for k, _ in items)
 
-    def values(self, node, **kwargs):
+    def values(self, node, settings=base.SETTINGS):
         return self.filtered((node,))
 
     def default(self):
@@ -254,14 +253,14 @@ class AccessOp(SimpleOp):
             return self
         return self.__class__(new_op)
 
-    def _resolved(self, node=None, **kwargs):
+    def _resolved(self, node=None, settings=base.SETTINGS):
         """
         Resolve a Reference against the appropriate target.  Returns a
         tuple of concrete ops (empty if the reference path is not found).
         Callers must guard with is_reference() before calling.
         """
-        root = (kwargs or {}).get('_root')
-        parents = (kwargs or {}).get('_parents', ())
+        root = settings.root
+        parents = settings.parents or ()
         try:
             val = self.op.resolve_ref(root, node=node, parents=parents)
         except KeyError:
@@ -270,39 +269,40 @@ class AccessOp(SimpleOp):
             return tuple(self.__class__(matchers.Const(v)) for v in val)
         return (self.__class__(matchers.Const(val)),)
 
-    def do_update(self, ops, node, val, has_defaults, _path, nop, nop_from_unwrap=False, **kwargs):
+    def do_update(self, ops, node, val, has_defaults, _path, nop, nop_from_unwrap=False, settings=base.SETTINGS):
         """
         Resolve references before updating.
         """
         if self.is_reference():
-            for r in self._resolved(node=node, **kwargs):
-                node = r.do_update(ops, node, val, has_defaults, _path, nop, nop_from_unwrap=nop_from_unwrap, **kwargs)
+            for r in self._resolved(node=node, settings=settings):
+                node = r.do_update(ops, node, val, has_defaults, _path, nop, nop_from_unwrap=nop_from_unwrap, settings=settings)
             return node
-        return super().do_update(ops, node, val, has_defaults, _path, nop, nop_from_unwrap=nop_from_unwrap, **kwargs)
+        return super().do_update(ops, node, val, has_defaults, _path, nop, nop_from_unwrap=nop_from_unwrap, settings=settings)
 
-    def do_remove(self, ops, node, val, nop, **kwargs):
+    def do_remove(self, ops, node, val, nop, settings=base.SETTINGS):
         """
         Resolve references before removing.
         """
         if self.is_reference():
-            for r in self._resolved(node=node, **kwargs):
-                node = r.do_remove(ops, node, val, nop, **kwargs)
+            for r in self._resolved(node=node, settings=settings):
+                node = r.do_remove(ops, node, val, nop, settings=settings)
             return node
-        return super().do_remove(ops, node, val, nop, **kwargs)
+        return super().do_remove(ops, node, val, nop, settings=settings)
 
     def is_empty(self, node):
         return not any(True for _ in self.keys(node))
 
-    def update_items(self, node, **kwargs):
+    def update_items(self, node, settings=base.SETTINGS):
         """
         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))
+        if settings.strict or type(self).is_empty is not AccessOp.is_empty:
+            # explicit super: the compiler gives a cpdef method no __class__ cell
+            return super(AccessOp, self).update_items(node, settings=settings)
+        items = iter(self.items(node, settings=settings))
         first = next(items, base.marker)
         if first is base.marker:
             return None
@@ -367,17 +367,39 @@ class Key(AccessOp):
 
         return _items()
 
-    def items(self, node, filtered=True, **kwargs):
+    def _reference_items(self, node, filtered, settings):
+        """
+        The items of each op this reference resolves to, chained.
+        """
+        return itertools.chain.from_iterable(
+            r.items(node, filtered=filtered, settings=settings)
+            for r in self._resolved(node=node, settings=settings))
+
+    def _const_items(self, node):
+        """
+        The items of a constant key: what _items(node, match_keys(node))
+        yields, looked up now instead of through a generator, since there is
+        at most one.
+        """
+        pairs = []
+        for k in self.op.match_keys(node):
+            try:
+                pairs.append((k, node[k]))
+            except (TypeError, KeyError, IndexError):
+                continue
+        return iter(pairs)
+
+    def items(self, node, settings=base.SETTINGS, filtered=True):
         if self.is_reference():
-            return itertools.chain.from_iterable(
-                r.items(node, filtered=filtered, **kwargs)
-                for r in self._resolved(node=node, **kwargs))
+            return self._reference_items(node, filtered, settings)
         # Dict-like: use key matching
         if hasattr(node, 'keys'):
+            if filtered and not self.filters and isinstance(self.op, matchers.Const):
+                return self._const_items(node)
             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'):
+        if settings.strict:
             return ()
         # Key only handles lists with concrete numeric keys
         if not hasattr(node, '__getitem__'):
@@ -415,7 +437,8 @@ class Key(AccessOp):
         if not self.op.matchable(op.op, specials):
             return None
 
-        results = super().match(op)
+        # explicit super: the compiler gives a cpdef method no __class__ cell
+        results = super(Key, self).match(op)
         if results is None:
             return None
 
@@ -460,8 +483,8 @@ class Key(AccessOp):
         except TypeError:
             pass
         return type(node)((k, v) for k, v in node.items() if k != key)
-    def remove(self, node, val, **kwargs):
-        to_remove = [k for k, v in self.items(node, **kwargs) if val is base.ANY or v == val]
+    def remove(self, node, val, settings=base.SETTINGS):
+        to_remove = [k for k, v in self.items(node, settings=settings) if val is base.ANY or v == val]
         for k in to_remove:
             node = self.pop(node, k)
         return node
@@ -556,11 +579,9 @@ class Attr(Key):
             return
         yield (key, v)
 
-    def items(self, node, filtered=True, **kwargs):
+    def items(self, node, settings=base.SETTINGS, filtered=True):
         if self.is_reference():
-            return itertools.chain.from_iterable(
-                r.items(node, filtered=filtered, **kwargs)
-                for r in self._resolved(node=node, **kwargs))
+            return self._reference_items(node, filtered, settings)
         all_keys = self._all_keys(node)
         keys = self.op.matches(all_keys) if filtered else all_keys
         result = self._items(node, keys, filtered)
@@ -618,8 +639,8 @@ class Attr(Key):
             pass
         return node
 
-    def remove(self, node, val, **kwargs):
-        to_remove = [k for k, v in self.items(node, **kwargs) if val is base.ANY or v == val]
+    def remove(self, node, val, settings=base.SETTINGS):
+        to_remove = [k for k, v in self.items(node, settings=settings) if val is base.ANY or v == val]
         for k in to_remove:
             self.pop(node, k)
         return node
@@ -645,15 +666,14 @@ class Slot(Key):
             return '[]'
         return '[' + self.op.quote() + ']'
 
-    def items(self, node, filtered=True, **kwargs):
+    def items(self, node, settings=base.SETTINGS, filtered=True):
         if self.is_reference():
-            return itertools.chain.from_iterable(
-                r.items(node, filtered=filtered, **kwargs)
-                for r in self._resolved(node=node, **kwargs))
+            return self._reference_items(node, filtered, settings)
         if hasattr(node, 'keys'):
-            if kwargs.get('strict'):
+            if settings.strict:
                 return ()
-            return super().items(node, filtered, **kwargs)
+            # explicit super: the compiler gives a cpdef method no __class__ cell
+            return super(Slot, self).items(node, filtered=filtered, settings=settings)
 
         if not hasattr(node, '__getitem__'):
             return ()
@@ -661,7 +681,7 @@ class Slot(Key):
         if not filtered:
             keys = range(len(node))
         elif self.is_pattern():
-            keys = self.op.matches(idx for idx, _ in enumerate(node))
+            keys = self.op.matches(utils.indices(node))
         else:
             keys = (self.op.value,)
 
@@ -670,7 +690,8 @@ class Slot(Key):
     def default(self):
         if isinstance(self.op, matchers.Numeric) and self.op.is_int():
             return []
-        return super().default()
+        # explicit super: the compiler gives a cpdef method no __class__ cell
+        return super(Slot, self).default()
 
     def update(self, node, key, val):
         if hasattr(node, 'keys'):
@@ -777,7 +798,10 @@ class SlotSpecial(Slot):
     def default(self):
         return []
 
-    def items(self, node, **kwargs):
+    def items(self, node, settings=base.SETTINGS, filtered=True):
+        return self._last_item(node)
+
+    def _last_item(self, node):
         try:
             yield -1, node[-1]
         except (TypeError, IndexError):
@@ -869,7 +893,7 @@ class SliceFilter(BaseOp):
             return None
         return super().match(op)
 
-    def items(self, node, **kwargs):
+    def items(self, node, settings=base.SETTINGS):
         for idx, v in enumerate(node):
             if any(True for _ in self.filtered((v,))):
                 yield (idx, v)
@@ -880,8 +904,8 @@ class SliceFilter(BaseOp):
     def update(self, node, key, val):
         raise RuntimeError('Updates not supported for slice filtering')
 
-    def remove(self, node, val, **kwargs):
-        removes = [idx for idx, _ in self.items(node, **kwargs)]
+    def remove(self, node, val, settings=base.SETTINGS):
+        removes = [idx for idx, _ in self.items(node, settings=settings)]
 
         if not removes:
             return node
@@ -918,7 +942,7 @@ class SliceFilter(BaseOp):
         """
         filtered = type(frame.node)(self.filtered(frame.node))
         cp = frame.prefix + (Slice.concrete(slice(None)),) if paths else frame.prefix
-        stack.push(base.Frame(frame.ops, filtered, cp, kwargs=frame.kwargs))
+        stack.push(base.Frame(frame.ops, filtered, cp, settings=frame.settings))
         return ()
 
 
@@ -980,16 +1004,19 @@ class Slice(SimpleOp):
             return 1 << 64
         return max(0, int((stop - start) / step))
 
-    def keys(self, node, **kwargs):
+    def keys(self, node, settings=base.SETTINGS):
         return (self.slice(node),)
-    def items(self, node, **kwargs):
-        for k in self.keys(node, **kwargs):
+    def items(self, node, settings=base.SETTINGS, filtered=True):
+        return self._slice_items(node, settings)
+    def _slice_items(self, node, settings):
+        for k in self.keys(node, settings=settings):
             try:
                 yield (k, node[k])
             except (TypeError, KeyError, IndexError):
                 pass
-    def values(self, node, **kwargs):
-        return (v for _, v in self.items(node, **kwargs))
+    def values(self, node, settings=base.SETTINGS):
+        items = self.items(node, settings=settings)
+        return (v for _, v in items)
     def is_empty(self, node):
         return not node[self.slice(node)]
     def default(self):
@@ -1067,19 +1094,19 @@ class Invert(SimpleOp):
         return '-'
     def match(self, op, specials=False):
         return base.MatchResult('-') if isinstance(op, Invert) else None
-    def items(self, node, **kwargs):
-        yield ('-', node)
-    def keys(self, node, **kwargs):
+    def items(self, node, settings=base.SETTINGS, filtered=True):
+        return iter((('-', node),))
+    def keys(self, node, settings=base.SETTINGS):
         yield '-'
-    def values(self, node, **kwargs):
+    def values(self, node, settings=base.SETTINGS):
         yield node
 
-    def do_update(self, ops, node, val, has_defaults, _path, nop, nop_from_unwrap=False, **kwargs):
-        return engine.removes(ops, node, val, **kwargs)
+    def do_update(self, ops, node, val, has_defaults, _path, nop, nop_from_unwrap=False, settings=base.SETTINGS):
+        return engine.removes(ops, node, val, settings=settings)
 
-    def do_remove(self, ops, node, val, nop, **kwargs):
+    def do_remove(self, ops, node, val, nop, settings=base.SETTINGS):
         assert val is not base.ANY, 'Value required'
-        return engine.updates(ops, node, val, **kwargs)
+        return engine.updates(ops, node, val, settings=settings)
 
 
 # engine and wrappers both import this module, so they can only be bound

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

@@ -372,6 +372,7 @@ def mutable(obj, path, strict=False, bindings=None):
         return False
 
     # Walk the path - if we find any mutable container, mutation will occur
+    settings = base.Settings(obj, strict)
     current = obj
     for op in ops:
         if isinstance(op, access.Invert):
@@ -382,7 +383,7 @@ def mutable(obj, path, strict=False, bindings=None):
 
         # Traverse to next level (consume only first value)
         _marker = object()
-        first = next(op.values(current, strict=strict), _marker)
+        first = next(op.values(current, settings=settings), _marker)
         if first is _marker:
             # Path doesn't exist - would be created, but parent is immutable
             return False