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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dotted_notation
-Version: 0.42.8
+Version: 0.43.0
 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
@@ -164,6 +164,7 @@ Or pick only what you need:
   - [Built-in Transforms](#built-in-transforms)
   - [Container transform arguments](#container-transform-arguments)
   - [Custom Transforms](#custom-transforms)
+- [SQL Translation (`sqlize`)](#sqlize) — *under development*
 - [Constants and Exceptions](#constants-and-exceptions)
 - [CLI (`dq`)](#cli-dq)
   - [File input](#file-input)
@@ -176,6 +177,7 @@ Or pick only what you need:
   - [Why do I get a tuple for my get?](#why-do-i-get-a-tuple-for-my-get)
   - [How do I craft an efficient path?](#how-do-i-craft-an-efficient-path)
   - [Why do I get a RuntimeError when updating with a slice filter?](#why-do-i-get-a-runtimeerror-when-updating-with-a-slice-filter)
+  - [Why can't I use patterns to discover keys/attrs on my Stripe object?](#why-cant-i-use-patterns-on-stripe-objects)
 
 <a id="safe-traversal-optional-chaining"></a>
 ## Safe Traversal (Optional Chaining)
@@ -893,8 +895,10 @@ _attr_ `@` field uses `getattr/setattr/delattr`.
 
 A key field is expressed as `a` or part of a dotted expression, such as `a.b`.  The
 grammar parser is permissive for what can be in a key field.  Pretty much any non-reserved
-char will match.  Note that key fields will only work on objects that have a `keys`
-method.  Basically, they work with dictionary or dictionary-like objects.
+char will match.  Key fields work best with objects that have a `keys` method
+(dictionaries and dictionary-like objects).  For concrete access like `.name`, objects
+with `__getitem__` and `__contains__` but no `keys` method are also supported via direct
+lookup (though pattern access like `.*` requires `keys`).
 
     >>> import dotted
     >>> dotted.get({'a': {'b': 'hello'}}, 'a.b')
@@ -930,6 +934,27 @@ Two important reasons: nested expressions and patterns.
     >>> dotted.get(ns, '@hello.me')
     'goodbye'
 
+**Concrete access** (`@name`) works on any object — dotted tries enumeration first,
+then falls back to `getattr` directly.  This means objects that provide attributes
+via `__getattr__` (such as Stripe API objects and other dynamic-attribute wrappers)
+work out of the box.
+
+**Pattern access** (`@*`, `@/regex/`) requires enumerable attributes.  Dotted discovers
+attribute names from `__dict__` (standard instance attributes), `__slots__` (slot-based
+classes), and `_fields` (namedtuples, which store data in the tuple itself and don't
+expose field names through either `__dict__` or `__slots__`):
+
+    >>> class Point:
+    ...     __slots__ = ('x', 'y')
+    ...     def __init__(self, x, y):
+    ...         self.x = x
+    ...         self.y = y
+    >>> dotted.get(Point(3, 4), '@*')
+    (3, 4)
+
+Objects that rely solely on `__getattr__` without exposing their keys through any of
+these mechanisms will support concrete attr access but not [pattern matching](#patterns).
+
 <a id="slicing"></a>
 ### Slicing
 
@@ -1114,7 +1139,9 @@ expressions.  You'll note that patterns always return a tuple of matches.
     >>> dotted.get(d, '/h.*/.*')
     ([1, 2, 3],)
 
-Dotted will return all values that match the pattern(s).
+Dotted will return all values that match the pattern(s).  Patterns can only discover
+what is advertised — they work by enumerating keys or attributes, so the object must
+expose them via `keys()` (dicts), `__dict__`, `__slots__`, or `_fields` (namedtuples).
 
 <a id="wildcards"></a>
 ### Wildcards
@@ -2762,6 +2789,141 @@ Register custom transforms using `register` or the `@transform` decorator:
 
 View all registered transforms with `dotted.registry()`.
 
+<a id="sqlize"></a>
+## SQL Translation (`sqlize`)
+
+> **Under development.** The API shape, output format, and supported subset
+> of dotted features may still change. Postgres-only, SQLAlchemy-style named
+> placeholders, scalar paths plus absolute-root references. Patterns (`*`,
+> `**`, `[*]`, filter-on-array) are not supported yet.
+
+`dotted.sqlize` translates a dotted path into SQL clause components — a
+`select` expression, a `where` predicate, and a `params` dict with hoisted
+values. Literals are hoisted for injection safety; substitutions are
+preserved as named placeholders so callers can late-bind them.
+
+The first segment of the dotted path is the SQL column. Any further segments
+are JSON navigation inside that column (JSONB). This means scalar columns
+and JSONB columns share one surface:
+
+    >>> import dotted
+    >>> dotted.sqlize("status = 'active'")
+    {'select': 'status', 'where': 'status = :_p1', 'params': {'_p1': 'active'}}
+
+    >>> dotted.sqlize("data.user.age >= 30")
+    {'select': "data #>> '{user,age}'", 'where': "(data #>> '{user,age}')::numeric >= :_p1", 'params': {'_p1': 30}}
+
+    >>> dotted.sqlize("data.user.name")   # pure traversal, no predicate
+    {'select': "data #>> '{user,name}'", 'params': {}}
+
+Guards encode the predicate:
+
+    >>> dotted.sqlize("age >= 30")
+    {'select': 'age', 'where': 'age >= :_p1', 'params': {'_p1': 30}}
+
+    >>> dotted.sqlize("deleted_at = None")
+    {'select': 'deleted_at', 'where': 'deleted_at IS NULL', 'params': {}}
+
+    >>> dotted.sqlize("name = /^alice/")
+    {'select': 'name', 'where': 'name ~ :_p1', 'params': {'_p1': '^alice'}}
+
+Boolean grouping maps directly onto `AND` / `OR` / `NOT`:
+
+    >>> dotted.sqlize('(age >= 18 & status = "active")')
+    {'where': '(age >= :_p1) AND (status = :_p2)', 'params': {'_p1': 18, '_p2': 'active'}}
+
+    >>> dotted.sqlize('data.(user.age >= 30 & status = "active")')['where']
+    "((data #>> '{user,age}')::numeric >= :_p1) AND ((data #>> '{status}') = :_p2)"
+
+Guard transforms become SQL casts (`int`, `float`, `str`, `bool`):
+
+    >>> dotted.sqlize("data.user.age|int >= 30")['where']
+    "(data #>> '{user,age}')::int >= :_p1"
+
+### Hoisted params
+
+Every RHS value becomes an entry in the `params` dict, keyed by name. This
+is the mechanism that makes the output safe — user input can't end up as
+SQL text, only as a parameter value.
+
+    >>> r = dotted.sqlize(f"name = {repr(user_input)}")   # user input literal
+    >>> r['where']
+    'name = :_p1'
+    >>> r['params']
+    {'_p1': "'; DROP TABLE users;--"}     # stays a value, never parsed as SQL
+
+Literal values get generated names (`_p1`, `_p2`, …). Substitutions keep
+their declared names — see below.
+
+### Substitutions (late binding)
+
+A substitution is preserved in the SQL output as a named placeholder,
+letting the caller supply the value at execute time rather than sqlize
+time:
+
+    >>> r = dotted.sqlize("age >= $(min_age)")
+    >>> r
+    {'select': 'age', 'where': 'age >= :min_age', 'params': {}, 'missing': ['min_age']}
+
+`missing` lists names that still need a value. Fill them in before passing
+`params` to a driver:
+
+    >>> r['params']['min_age'] = 30
+    >>> # hand (r['where'], r['params']) to cursor.execute / session.execute / etc.
+
+Repeated uses of the same name share one placeholder automatically:
+
+    >>> dotted.sqlize('(age >= $(x) & weight = $(x))')
+    {'where': '(age >= :x) AND (weight = :x)', 'params': {}, 'missing': ['x']}
+
+If you pass `bindings=`, substitutions are resolved at sqlize time and hoisted
+like any other literal:
+
+    >>> dotted.sqlize("age >= $(min_age)", bindings={'min_age': 30})
+    {'select': 'age', 'where': 'age >= :_p1', 'params': {'_p1': 30}}
+
+### References
+
+Absolute-root references (`$$(path)`) map to dynamic JSON key lookups —
+Postgres's `->` / `#>` accept runtime-computed keys:
+
+    >>> dotted.sqlize('data.$$(data.config.field) = "Alice"')
+    {'select': "data ->> (data #>> '{config,field}')", 'where': "(data ->> (data #>> '{config,field}')) = :_p1", 'params': {'_p1': 'Alice'}}
+
+Relative references (`^`) and parent references (`^^+`) are not supported
+yet.
+
+### Output keys
+
+Returned dict may contain any subset of:
+
+| Key       | Type        | Meaning                                             |
+|-----------|-------------|-----------------------------------------------------|
+| `select`  | `str`       | Expression yielding the value dotted would return   |
+| `where`   | `str`       | Predicate from guards / filters / boolean groups    |
+| `params`  | `dict`      | Hoisted values keyed by name                        |
+| `missing` | `list[str]` | Substitution names still awaiting a value           |
+
+`select` is omitted when combining predicates across different columns
+(e.g. top-level groups), since there's no single meaningful expression.
+`where` is omitted when the path is pure traversal. Usage pattern:
+
+    >>> r = dotted.sqlize("data.user.age >= 30")
+    >>> sql = f"SELECT {r['select']} FROM users WHERE {r['where']}"
+    >>> # sql, r['params'] go to your driver
+
+### Keyword arguments
+
+`dotted.sqlize(path, *, bindings=None, flavor='postgres', format='sqlalchemy')`
+
+- `bindings` — resolve substitutions at sqlize time.
+- `flavor` — SQL flavor for JSONB operators; only `'postgres'` is
+  implemented.
+- `format` — placeholder style; only `'sqlalchemy'` (`:name`) is supported
+  in v1.
+
+Unsupported features and pattern paths raise `dotted.TranslationError`.
+
 <a id="constants-and-exceptions"></a>
 ## Constants and Exceptions
 
@@ -2943,3 +3105,15 @@ Prefer a concrete path when it expresses what you want; use pattern + `?` when y
 A slice filter like `[id=1]` returns the **filtered sublist** as a single value — it operates on the list itself, not on individual items. Updating that sublist in place is ambiguous: the matching items may be at non-contiguous indices, so there's no clean way to splice a replacement back into the original.
 
 But you probably don't want to update a slice filter anyway — instead, use a pattern like `[*&id=1]` which walks the items individually and updates each match in place.
+
+<a id="why-cant-i-use-patterns-on-stripe-objects"></a>
+### Why can't I use patterns to discover keys/attrs on my Stripe object?
+
+Pattern access (`@*`, `.*`) works by enumerating an object's known keys or attributes. Dotted checks `__dict__`, `__slots__`, `_fields` (namedtuples), and `keys()` (for key fields). Stripe objects don't use any of these — they store data in an internal `_data` dict and expose it through a custom `__getattr__`. Since Python has no standard protocol for asking "what keys does your `__getattr__` accept?", there's nothing for dotted to enumerate.
+
+**Concrete access works fine.** `@name`, `@email`, `.id` — anything where you specify the exact key will work, because dotted falls back to trying `getattr`/`__getitem__` directly.
+
+**Pattern access can't discover what you don't advertise.** This is a limitation of the object, not dotted. If you need pattern access, convert to a dict first:
+
+    obj_dict = obj.to_dict()        # Stripe objects support this
+    dotted.get(obj_dict, '*')       # now enumerable

{dotted_notation-0.42.8 → dotted_notation-0.43.0}/README.md

@@ -127,6 +127,7 @@ Or pick only what you need:
   - [Built-in Transforms](#built-in-transforms)
   - [Container transform arguments](#container-transform-arguments)
   - [Custom Transforms](#custom-transforms)
+- [SQL Translation (`sqlize`)](#sqlize) — *under development*
 - [Constants and Exceptions](#constants-and-exceptions)
 - [CLI (`dq`)](#cli-dq)
   - [File input](#file-input)
@@ -139,6 +140,7 @@ Or pick only what you need:
   - [Why do I get a tuple for my get?](#why-do-i-get-a-tuple-for-my-get)
   - [How do I craft an efficient path?](#how-do-i-craft-an-efficient-path)
   - [Why do I get a RuntimeError when updating with a slice filter?](#why-do-i-get-a-runtimeerror-when-updating-with-a-slice-filter)
+  - [Why can't I use patterns to discover keys/attrs on my Stripe object?](#why-cant-i-use-patterns-on-stripe-objects)
 
 <a id="safe-traversal-optional-chaining"></a>
 ## Safe Traversal (Optional Chaining)
@@ -856,8 +858,10 @@ _attr_ `@` field uses `getattr/setattr/delattr`.
 
 A key field is expressed as `a` or part of a dotted expression, such as `a.b`.  The
 grammar parser is permissive for what can be in a key field.  Pretty much any non-reserved
-char will match.  Note that key fields will only work on objects that have a `keys`
-method.  Basically, they work with dictionary or dictionary-like objects.
+char will match.  Key fields work best with objects that have a `keys` method
+(dictionaries and dictionary-like objects).  For concrete access like `.name`, objects
+with `__getitem__` and `__contains__` but no `keys` method are also supported via direct
+lookup (though pattern access like `.*` requires `keys`).
 
     >>> import dotted
     >>> dotted.get({'a': {'b': 'hello'}}, 'a.b')
@@ -893,6 +897,27 @@ Two important reasons: nested expressions and patterns.
     >>> dotted.get(ns, '@hello.me')
     'goodbye'
 
+**Concrete access** (`@name`) works on any object — dotted tries enumeration first,
+then falls back to `getattr` directly.  This means objects that provide attributes
+via `__getattr__` (such as Stripe API objects and other dynamic-attribute wrappers)
+work out of the box.
+
+**Pattern access** (`@*`, `@/regex/`) requires enumerable attributes.  Dotted discovers
+attribute names from `__dict__` (standard instance attributes), `__slots__` (slot-based
+classes), and `_fields` (namedtuples, which store data in the tuple itself and don't
+expose field names through either `__dict__` or `__slots__`):
+
+    >>> class Point:
+    ...     __slots__ = ('x', 'y')
+    ...     def __init__(self, x, y):
+    ...         self.x = x
+    ...         self.y = y
+    >>> dotted.get(Point(3, 4), '@*')
+    (3, 4)
+
+Objects that rely solely on `__getattr__` without exposing their keys through any of
+these mechanisms will support concrete attr access but not [pattern matching](#patterns).
+
 <a id="slicing"></a>
 ### Slicing
 
@@ -1077,7 +1102,9 @@ expressions.  You'll note that patterns always return a tuple of matches.
     >>> dotted.get(d, '/h.*/.*')
     ([1, 2, 3],)
 
-Dotted will return all values that match the pattern(s).
+Dotted will return all values that match the pattern(s).  Patterns can only discover
+what is advertised — they work by enumerating keys or attributes, so the object must
+expose them via `keys()` (dicts), `__dict__`, `__slots__`, or `_fields` (namedtuples).
 
 <a id="wildcards"></a>
 ### Wildcards
@@ -2725,6 +2752,141 @@ Register custom transforms using `register` or the `@transform` decorator:
 
 View all registered transforms with `dotted.registry()`.
 
+<a id="sqlize"></a>
+## SQL Translation (`sqlize`)
+
+> **Under development.** The API shape, output format, and supported subset
+> of dotted features may still change. Postgres-only, SQLAlchemy-style named
+> placeholders, scalar paths plus absolute-root references. Patterns (`*`,
+> `**`, `[*]`, filter-on-array) are not supported yet.
+
+`dotted.sqlize` translates a dotted path into SQL clause components — a
+`select` expression, a `where` predicate, and a `params` dict with hoisted
+values. Literals are hoisted for injection safety; substitutions are
+preserved as named placeholders so callers can late-bind them.
+
+The first segment of the dotted path is the SQL column. Any further segments
+are JSON navigation inside that column (JSONB). This means scalar columns
+and JSONB columns share one surface:
+
+    >>> import dotted
+    >>> dotted.sqlize("status = 'active'")
+    {'select': 'status', 'where': 'status = :_p1', 'params': {'_p1': 'active'}}
+
+    >>> dotted.sqlize("data.user.age >= 30")
+    {'select': "data #>> '{user,age}'", 'where': "(data #>> '{user,age}')::numeric >= :_p1", 'params': {'_p1': 30}}
+
+    >>> dotted.sqlize("data.user.name")   # pure traversal, no predicate
+    {'select': "data #>> '{user,name}'", 'params': {}}
+
+Guards encode the predicate:
+
+    >>> dotted.sqlize("age >= 30")
+    {'select': 'age', 'where': 'age >= :_p1', 'params': {'_p1': 30}}
+
+    >>> dotted.sqlize("deleted_at = None")
+    {'select': 'deleted_at', 'where': 'deleted_at IS NULL', 'params': {}}
+
+    >>> dotted.sqlize("name = /^alice/")
+    {'select': 'name', 'where': 'name ~ :_p1', 'params': {'_p1': '^alice'}}
+
+Boolean grouping maps directly onto `AND` / `OR` / `NOT`:
+
+    >>> dotted.sqlize('(age >= 18 & status = "active")')
+    {'where': '(age >= :_p1) AND (status = :_p2)', 'params': {'_p1': 18, '_p2': 'active'}}
+
+    >>> dotted.sqlize('data.(user.age >= 30 & status = "active")')['where']
+    "((data #>> '{user,age}')::numeric >= :_p1) AND ((data #>> '{status}') = :_p2)"
+
+Guard transforms become SQL casts (`int`, `float`, `str`, `bool`):
+
+    >>> dotted.sqlize("data.user.age|int >= 30")['where']
+    "(data #>> '{user,age}')::int >= :_p1"
+
+### Hoisted params
+
+Every RHS value becomes an entry in the `params` dict, keyed by name. This
+is the mechanism that makes the output safe — user input can't end up as
+SQL text, only as a parameter value.
+
+    >>> r = dotted.sqlize(f"name = {repr(user_input)}")   # user input literal
+    >>> r['where']
+    'name = :_p1'
+    >>> r['params']
+    {'_p1': "'; DROP TABLE users;--"}     # stays a value, never parsed as SQL
+
+Literal values get generated names (`_p1`, `_p2`, …). Substitutions keep
+their declared names — see below.
+
+### Substitutions (late binding)
+
+A substitution is preserved in the SQL output as a named placeholder,
+letting the caller supply the value at execute time rather than sqlize
+time:
+
+    >>> r = dotted.sqlize("age >= $(min_age)")
+    >>> r
+    {'select': 'age', 'where': 'age >= :min_age', 'params': {}, 'missing': ['min_age']}
+
+`missing` lists names that still need a value. Fill them in before passing
+`params` to a driver:
+
+    >>> r['params']['min_age'] = 30
+    >>> # hand (r['where'], r['params']) to cursor.execute / session.execute / etc.
+
+Repeated uses of the same name share one placeholder automatically:
+
+    >>> dotted.sqlize('(age >= $(x) & weight = $(x))')
+    {'where': '(age >= :x) AND (weight = :x)', 'params': {}, 'missing': ['x']}
+
+If you pass `bindings=`, substitutions are resolved at sqlize time and hoisted
+like any other literal:
+
+    >>> dotted.sqlize("age >= $(min_age)", bindings={'min_age': 30})
+    {'select': 'age', 'where': 'age >= :_p1', 'params': {'_p1': 30}}
+
+### References
+
+Absolute-root references (`$$(path)`) map to dynamic JSON key lookups —
+Postgres's `->` / `#>` accept runtime-computed keys:
+
+    >>> dotted.sqlize('data.$$(data.config.field) = "Alice"')
+    {'select': "data ->> (data #>> '{config,field}')", 'where': "(data ->> (data #>> '{config,field}')) = :_p1", 'params': {'_p1': 'Alice'}}
+
+Relative references (`^`) and parent references (`^^+`) are not supported
+yet.
+
+### Output keys
+
+Returned dict may contain any subset of:
+
+| Key       | Type        | Meaning                                             |
+|-----------|-------------|-----------------------------------------------------|
+| `select`  | `str`       | Expression yielding the value dotted would return   |
+| `where`   | `str`       | Predicate from guards / filters / boolean groups    |
+| `params`  | `dict`      | Hoisted values keyed by name                        |
+| `missing` | `list[str]` | Substitution names still awaiting a value           |
+
+`select` is omitted when combining predicates across different columns
+(e.g. top-level groups), since there's no single meaningful expression.
+`where` is omitted when the path is pure traversal. Usage pattern:
+
+    >>> r = dotted.sqlize("data.user.age >= 30")
+    >>> sql = f"SELECT {r['select']} FROM users WHERE {r['where']}"
+    >>> # sql, r['params'] go to your driver
+
+### Keyword arguments
+
+`dotted.sqlize(path, *, bindings=None, flavor='postgres', format='sqlalchemy')`
+
+- `bindings` — resolve substitutions at sqlize time.
+- `flavor` — SQL flavor for JSONB operators; only `'postgres'` is
+  implemented.
+- `format` — placeholder style; only `'sqlalchemy'` (`:name`) is supported
+  in v1.
+
+Unsupported features and pattern paths raise `dotted.TranslationError`.
+
 <a id="constants-and-exceptions"></a>
 ## Constants and Exceptions
 
@@ -2906,3 +3068,15 @@ Prefer a concrete path when it expresses what you want; use pattern + `?` when y
 A slice filter like `[id=1]` returns the **filtered sublist** as a single value — it operates on the list itself, not on individual items. Updating that sublist in place is ambiguous: the matching items may be at non-contiguous indices, so there's no clean way to splice a replacement back into the original.
 
 But you probably don't want to update a slice filter anyway — instead, use a pattern like `[*&id=1]` which walks the items individually and updates each match in place.
+
+<a id="why-cant-i-use-patterns-on-stripe-objects"></a>
+### Why can't I use patterns to discover keys/attrs on my Stripe object?
+
+Pattern access (`@*`, `.*`) works by enumerating an object's known keys or attributes. Dotted checks `__dict__`, `__slots__`, `_fields` (namedtuples), and `keys()` (for key fields). Stripe objects don't use any of these — they store data in an internal `_data` dict and expose it through a custom `__getattr__`. Since Python has no standard protocol for asking "what keys does your `__getattr__` accept?", there's nothing for dotted to enumerate.
+
+**Concrete access works fine.** `@name`, `@email`, `.id` — anything where you specify the exact key will work, because dotted falls back to trying `getattr`/`__getitem__` directly.
+
+**Pattern access can't discover what you don't advertise.** This is a limitation of the object, not dotted. If you need pattern access, convert to a dict first:
+
+    obj_dict = obj.to_dict()        # Stripe objects support this
+    dotted.get(obj_dict, '*')       # now enumerable

{dotted_notation-0.42.8 → dotted_notation-0.43.0}/dotted/__init__.py

@@ -68,6 +68,7 @@ from .api import \
     update, update_multi, pack, update_if, update_if_multi, \
     remove, remove_multi, remove_if, remove_if_multi, \
     pluck, pluck_multi, walk, walk_multi, unpack, keys, values, items
+from .sqlize import sqlize, TranslationError
 
 __all__ = [
     # Core
@@ -82,6 +83,8 @@ __all__ = [
     'apply', 'apply_multi', 'register', 'transform',
     # Utility
     'parse', 'assemble', 'assemble_multi', 'quote', 'is_pattern', 'is_template', 'is_inverted', 'mutable',
+    # SQL
+    'sqlize', 'TranslationError',
     # Constants
     'ANY', 'AUTO', 'Attrs', 'GroupMode',
 ]

{dotted_notation-0.42.8 → dotted_notation-0.43.0}/dotted/access.py

@@ -411,6 +411,13 @@ class Key(AccessOp):
             return ()
         key = self.op.value
         if not isinstance(key, int):
+            # Concrete non-int key on object with __getitem__ but no keys():
+            # try direct access (e.g. Stripe-like objects)
+            if hasattr(node, '__contains__') and key in node:
+                try:
+                    return iter([(key, node[key])])
+                except (KeyError, TypeError):
+                    pass
             return ()
         if not filtered:
             return self._items(node, range(len(node)), filtered=False)
@@ -515,18 +522,65 @@ class Attr(Key):
 
         return _items()
 
+    @staticmethod
+    def _all_keys(node):
+        """
+        Collect all known attribute names from an object:
+        __dict__, _fields (namedtuple), and __slots__ (MRO walk).
+        Preserves insertion order.
+        """
+        seen = set()
+        keys = []
+        try:
+            for k in node.__dict__.keys():
+                if k not in seen:
+                    seen.add(k)
+                    keys.append(k)
+        except AttributeError:
+            pass
+        if isinstance(node, tuple):
+            for k in getattr(node, '_fields', ()):
+                if k not in seen:
+                    seen.add(k)
+                    keys.append(k)
+        for cls in type(node).__mro__:
+            for s in getattr(cls, '__slots__', ()):
+                if s not in ('__dict__', '__weakref__') and s not in seen:
+                    seen.add(s)
+                    keys.append(s)
+        return keys
+
+    def _concrete_fallback(self, node, inner, filtered):
+        """
+        Wrap an items iterator: yield from inner, and if nothing
+        was yielded, try getattr directly for concrete (non-pattern) ops.
+        """
+        found = False
+        for pair in inner:
+            found = True
+            yield pair
+        if found:
+            return
+        key = self.op.value
+        try:
+            v = getattr(node, key)
+        except AttributeError:
+            return
+        if filtered and not tuple(self.filtered(iter((v,)))):
+            return
+        yield (key, v)
+
     def items(self, node, filtered=True, **kwargs):
         if self.is_reference():
             return itertools.chain.from_iterable(
                 r.items(node, filtered=filtered, **kwargs)
                 for r in self._resolved(node=node, **kwargs))
-        # Try __dict__ first (normal objects), then _fields (namedtuple)
-        try:
-            all_keys = node.__dict__.keys()
-        except AttributeError:
-            all_keys = getattr(node, '_fields', ())
+        all_keys = self._all_keys(node)
         keys = self.op.matches(all_keys) if filtered else all_keys
-        return self._items(node, keys, filtered)
+        result = self._items(node, keys, filtered)
+        if not self.is_pattern():
+            result = self._concrete_fallback(node, result, filtered)
+        return result
 
     def default(self):
         o = types.SimpleNamespace()
@@ -555,10 +609,7 @@ class Attr(Key):
             return self.update(node, self.op.value, val)
         keys = tuple(self.keys(node))
         # Try mutable update first
-        try:
-            node_keys = node.__dict__.keys()
-        except AttributeError:
-            node_keys = getattr(node, '_fields', ())
+        node_keys = self._all_keys(node)
         iterable = ((k, getattr(node, k)) for k in node_keys if k not in keys)
         items = list(itertools.chain(iterable, ((k, val) for k in keys)))
         try:

{dotted_notation-0.42.8 → dotted_notation-0.43.0}/dotted/engine.py

@@ -106,7 +106,8 @@ def _is_container(obj):
         return False
     # Dict-like, sequence-like, or has attributes
     return (hasattr(obj, 'keys') or hasattr(obj, '__len__') or
-            hasattr(obj, '__iter__') or hasattr(obj, '__dict__'))
+            hasattr(obj, '__iter__') or hasattr(obj, '__dict__') or
+            hasattr(type(obj), '__slots__'))
 
 
 def _format_path(segments):