assertpy2 2.27.0__tar.gz → 2.27.1__tar.gz

{assertpy2-2.27.0 → assertpy2-2.27.1}/CONTRIBUTING.md

@@ -114,6 +114,20 @@ change. The baseline test passes the same target itself, so it gives one answer
 - `tests/test_docs_examples.py` is run separately because it executes the snippets in `docs/`, which
   needs the `docs-examples` group and a different collection.
 
+### When a gate says an answer moved
+
+Two gates record what the library currently decides rather than what it should. Both fail on a change
+and neither is a failure to paper over: read the diff, decide whether the change is meant to ship, then
+re-record it in the same commit so the diff carries the decision into review.
+
+```bash
+ASSERTPY2_UPDATE_API=1 uv run pytest tests/test_api_compatibility.py      # the public surface
+ASSERTPY2_UPDATE_VERDICTS=1 uv run pytest tests/test_verdict_corpus.py    # what each input decides
+```
+
+The second one's diff is the draft of the release's Behaviour changes section, so read it before
+writing that section rather than after.
+
 ## Commit style
 
 Use [Conventional Commits](https://www.conventionalcommits.org/): `feat:`, `fix:`, `refactor:`, `test:`, `docs:`, `chore:`, etc.

{assertpy2-2.27.0 → assertpy2-2.27.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: assertpy2
-Version: 2.27.0
-Summary: Fluent assertion library for Python with composable matchers, structural matching, and full type safety
+Version: 2.27.1
+Summary: Fluent, fully typed assertion library for Python: your type checker sees only the assertions that fit the value, and every failure carries a structured diff. Soft assertions, polling, inline snapshots, OpenAPI contracts.
 Project-URL: Homepage, https://github.com/Solganis/assertpy2
 Project-URL: Repository, https://github.com/Solganis/assertpy2
 Project-URL: Issues, https://github.com/Solganis/assertpy2/issues

{assertpy2-2.27.0 → assertpy2-2.27.1}/assertpy2/_engine/_capable_typing.py

@@ -35,8 +35,18 @@ if TYPE_CHECKING:
     from ..matchers import Matcher
     from ._builder_check_typing import _CheckAnyValue
     from ._compat import Self
-    from ._poll_typing import _AsyncPoll, _SyncPoll
-    from ._typing import _E, _K, _R, _U, _V
+    from ._poll_typing import _AsyncPoll, _NoExpectationOnAChain, _SyncPoll
+    from ._typing import (
+        _E,
+        _K,
+        _R,
+        _U,
+        _V,
+        _ExpectedCompletionAssertion,
+        _ExpectedRaiseAssertion,
+        _ExpectedWarningAssertion,
+        _ListAssertion,
+    )
 
     # covariant: the façade only ever hands the subject back, through `value`
     _CapableT_co = TypeVar("_CapableT_co", covariant=True)
@@ -194,6 +204,18 @@ if TYPE_CHECKING:
             ignoring: type[Exception] | tuple[type[Exception], ...] = ...,
             trace: bool = ...,
         ) -> _SyncPoll[Any]: ...
+        # where the callable view lands: flattened, the runtime's `-> Self` kept a caught message typed as the callable
+        def raises(self: _CapableAssertion[_Callable], ex: type) -> _ExpectedRaiseAssertion[Any]: ...
+        def does_not_raise(self: _CapableAssertion[_Callable], ex: type) -> _ExpectedCompletionAssertion[Any]: ...
+        def warns(
+            self: _CapableAssertion[_Callable], warning: type[Warning] = ...
+        ) -> _ExpectedWarningAssertion[Any]: ...
+        def does_not_warn(
+            self: _CapableAssertion[_Callable], warning: type[Warning] = ...
+        ) -> _ExpectedCompletionAssertion[Any]: ...
+
+        when_called_with: _NoExpectationOnAChain
+
         # the builder's own helpers: left to `__getattr__`, `builder()` read as this facade over the value already here
         def builder(
             self,
@@ -220,8 +242,8 @@ if TYPE_CHECKING:
         ) -> Self: ...
         def all_satisfy(self, matcher: Matcher[Any] | Callable[..., bool], *, allow_empty: bool = ...) -> Self: ...
         def any_satisfy(self, matcher: Matcher[Any] | Callable[..., bool]) -> Self: ...
-        def at_json_path(self, path: str) -> Self: ...
-        def caused_by(self, ex: type) -> Self: ...
+        def at_json_path(self, path: str) -> AssertionBuilder[Any]: ...
+        def caused_by(self, ex: type) -> AssertionBuilder[Any]: ...
         def conforms_to_openapi(
             self,
             spec: dict[str, Any],
@@ -255,9 +277,7 @@ if TYPE_CHECKING:
         def contains_value(
             self: _CapableAssertion[_KeyedWithValues], *values: object
         ) -> _CapableAssertion[_CapableT_co]: ...
-        def decoded_as(
-            self: _CapableAssertion[bytes | bytearray], encoding: str = ...
-        ) -> _CapableAssertion[_CapableT_co]: ...
+        def decoded_as(self: _CapableAssertion[bytes | bytearray], encoding: str = ...) -> AssertionBuilder[Any]: ...
         def decoded_as_json(self) -> AssertionBuilder[object]: ...
         def described_as(self, description: str) -> Self: ...
         def does_not_contain(self, *items: object) -> Self: ...
@@ -273,28 +293,24 @@ if TYPE_CHECKING:
         def does_not_exist(self: _CapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
         def does_not_have_json_path(self, path: str) -> Self: ...
         def does_not_match(self: _CapableAssertion[str], pattern: str) -> _CapableAssertion[_CapableT_co]: ...
-        def does_not_raise(self: _CapableAssertion[_Callable], ex: type) -> _CapableAssertion[_CapableT_co]: ...
-        def does_not_warn(
-            self: _CapableAssertion[_Callable], warning: type[Warning] = ...
-        ) -> _CapableAssertion[_CapableT_co]: ...
         def each(self, matcher: Matcher[Any] | Callable[..., bool], *, allow_empty: bool = ...) -> Self: ...
         def ends_with(self, suffix: object) -> Self: ...
         def ends_with_ignoring_case(self: _CapableAssertion[str], suffix: str) -> _CapableAssertion[_CapableT_co]: ...
-        def error_of(self, ex: type) -> Self: ...
-        def errors(self) -> Self: ...
+        def error_of(self, ex: type) -> AssertionBuilder[Any]: ...
+        def errors(self) -> AssertionBuilder[Any]: ...
         def exists(self: _CapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
-        def extracting(self, *names: object, **kwargs: object) -> Self: ...
+        def extracting(self, *names: object, **kwargs: object) -> _ListAssertion[Any]: ...
         def extracting_group(
             self: _CapableAssertion[str], pattern: str, group: int | str = ...
-        ) -> _CapableAssertion[_CapableT_co]: ...
-        def filtered_on(self, predicate: Matcher[Any] | Callable[[Any], bool]) -> Self: ...
-        def flat_mapped(self, func: Callable[[Any], Iterable[Any]]) -> Self: ...
+        ) -> AssertionBuilder[Any]: ...
+        def filtered_on(self, predicate: Matcher[Any] | Callable[[Any], bool]) -> _ListAssertion[Any]: ...
+        def flat_mapped(self, func: Callable[[Any], Iterable[Any]]) -> _ListAssertion[Any]: ...
         def has_byte_at(
             self: _CapableAssertion[bytes | bytearray], index: int, expected: int
         ) -> _CapableAssertion[_CapableT_co]: ...
         def has_json_path(self, path: str) -> Self: ...
         def has_no_none_fields(self, *, allow_empty: bool = ...) -> Self: ...
-        def has_root_cause(self, ex: type) -> Self: ...
+        def has_root_cause(self, ex: type) -> AssertionBuilder[Any]: ...
         def has_same_size_as(self, other: Sized) -> Self: ...
         def has_size_between(self, low: int, high: int) -> Self: ...
         def has_size_greater_than(self, size: int) -> Self: ...
@@ -420,11 +436,10 @@ if TYPE_CHECKING:
         def matches_json_schema(self, schema: dict[str, Any]) -> Self: ...
         def matches_json_schema_from_file(self, path: str | Path) -> Self: ...
         def matches_structure(self, spec: dict[Any, Any]) -> Self: ...
-        def matches_with_groups(self: _CapableAssertion[str], pattern: str) -> _CapableAssertion[_CapableT_co]: ...
+        def matches_with_groups(self: _CapableAssertion[str], pattern: str) -> AssertionBuilder[Any]: ...
         def none_satisfy(self, matcher: Matcher[Any] | Callable[..., bool]) -> Self: ...
-        def raised(self) -> Self: ...
-        def raises(self: _CapableAssertion[_Callable], ex: type) -> _CapableAssertion[_CapableT_co]: ...
-        def returned(self) -> Self: ...
+        def raised(self) -> AssertionBuilder[Any]: ...
+        def returned(self) -> AssertionBuilder[Any]: ...
         def satisfies_exactly(self, *matchers: Matcher[Any] | Callable[..., bool]) -> Self: ...
         def satisfies_exactly_in_any_order(self, *matchers: Matcher[Any] | Callable[..., bool]) -> Self: ...
         def snapshot(
@@ -443,12 +458,6 @@ if TYPE_CHECKING:
             self: _CapableAssertion[bytes | bytearray], prefix: bytes | bytearray
         ) -> _CapableAssertion[_CapableT_co]: ...
         def starts_with_ignoring_case(self: _CapableAssertion[str], prefix: str) -> _CapableAssertion[_CapableT_co]: ...
-        def warns(
-            self: _CapableAssertion[_Callable], warning: type[Warning] = ...
-        ) -> _CapableAssertion[_CapableT_co]: ...
-        def when_called_with(
-            self: _CapableAssertion[_Callable], *some_args: object, **some_kwargs: object
-        ) -> _CapableAssertion[_CapableT_co]: ...
         def zip_satisfies(
             self, other: Iterable[object], predicate: Callable[..., bool], *, allow_empty: bool = ...
         ) -> Self: ...
@@ -721,9 +730,6 @@ if TYPE_CHECKING:
         def starts_with_ignoring_case(
             self: _NegatedCapableAssertion[str], prefix: str
         ) -> _CapableAssertion[_CapableT_co]: ...
-        def when_called_with(
-            self: _NegatedCapableAssertion[_Callable], *some_args: object, **some_kwargs: object
-        ) -> _CapableAssertion[_CapableT_co]: ...
         def zip_satisfies(
             self, other: Iterable[object], predicate: Callable[..., bool], *, allow_empty: bool = ...
         ) -> _CapableAssertion[_CapableT_co]: ...

{assertpy2-2.27.0 → assertpy2-2.27.1}/assertpy2/_engine/_compare.py

@@ -26,12 +26,21 @@ import uuid
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from ._introspection import is_attrs_instance, is_mapping_like, is_model_dump_object
+from ._introspection import (
+    KeyedValue,
+    as_held,
+    eq_keyed,
+    is_attrs_instance,
+    is_mapping_like,
+    is_model_dump_object,
+    kind_of,
+    model_field_values,
+)
 from ._ordering import nan_operand
 from ._require import raised_inside, verdict
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Iterable
 
 
 _EQ_ATOMIC = frozenset(
@@ -164,33 +173,56 @@ def _find_ambiguous_operand(actual, expected, _seen=None):
     operand = _ambiguous_array_operand(actual, expected)
     if operand is not None:
         return operand
+    for left, right in _members_compared(actual, expected):
+        found = _find_ambiguous_operand(left, right, _seen)
+        if found is not None:
+            return found
+    return None
+
+
+def _members_compared(actual: Any, expected: Any) -> Iterable[tuple[Any, Any]]:
+    """The pairs ``==`` walks into for two values of one container kind, and none for any other pair."""
     if is_mapping_like(actual) and is_mapping_like(expected):
         expected_keys = set(expected)
-        for key in actual:
-            if key in expected_keys:
-                found = _find_ambiguous_operand(actual[key], expected[key], _seen)
-                if found is not None:
-                    return found
-        return None
+        return ((actual[key], expected[key]) for key in actual if key in expected_keys)
     if (
         dataclasses.is_dataclass(actual)
         and not isinstance(actual, type)
         and dataclasses.is_dataclass(expected)
         and not isinstance(expected, type)
     ):
-        for field in dataclasses.fields(actual):
-            found = _find_ambiguous_operand(getattr(actual, field.name), getattr(expected, field.name, None), _seen)
-            if found is not None:
-                return found
-        return None
+        return (
+            (getattr(actual, one.name), getattr(expected, one.name, None))
+            for one in dataclasses.fields(actual)
+            if one.compare
+        )
+    if is_attrs_instance(actual) and is_attrs_instance(expected):
+        return _keyed_members(actual, expected)
     if is_model_dump_object(actual) and is_model_dump_object(expected):
-        return _find_ambiguous_operand(actual.model_dump(), expected.model_dump(), _seen)
+        return ((model_field_values(actual), model_field_values(expected)),)
     if isinstance(actual, (list, tuple)) and isinstance(expected, (list, tuple)):
-        for actual_item, expected_item in zip(actual, expected, strict=False):
-            found = _find_ambiguous_operand(actual_item, expected_item, _seen)
-            if found is not None:
-                return found
-    return None
+        return zip(actual, expected, strict=False)
+    return ()
+
+
+def _keyed_members(actual: Any, expected: Any) -> tuple[tuple[Any, Any], ...]:
+    """The attrs fields ``==`` compares, each read through its key as ``==`` reads it, or none.
+
+    Only what ``==`` compares can have broken it.  attrs reads every key before it compares a field, so a key
+    that raises is the error being explained and no array is to blame: read again here, it raised a second
+    error while the first was handled, and skipped, it let a later array take the blame.
+    """
+    try:
+        return tuple(
+            (
+                eq_keyed(one, getattr(actual, one.name)),
+                eq_keyed(one, getattr(expected, one.name)) if hasattr(expected, one.name) else None,
+            )
+            for one in actual.__attrs_attrs__
+            if one.eq is not False
+        )
+    except (TypeError, ValueError):  # the two errors `_guarded_not_equal` hands to this search
+        return ()
 
 
 def _guarded_not_equal(actual, expected, *, method="is_equal_to") -> bool:
@@ -306,6 +338,7 @@ def _resolve_comparator(actual, config: _CompareConfig, *, field):
     comparators = config.comparators
     if comparators is None:
         return None
+    actual = as_held(actual)
     if field is not None and not isinstance(field, type) and field in comparators:
         return comparators[field]
     if type(actual) in comparators:
@@ -326,7 +359,7 @@ def _types_differ(actual, expected) -> bool:
     ``_is_matcher`` is imported here rather than at module scope because ``_matcher_impls`` imports
     ``_guarded_not_equal`` from this module, so the module-level import would be a cycle.
     """
-    if type(actual) is type(expected):
+    if kind_of(actual) is kind_of(expected):
         return False
     from .._matcher_impls import _is_matcher
 
@@ -412,11 +445,12 @@ def _node_decision(actual, expected, config: _CompareConfig | None, *, field=Non
     `assertpy2._engine._diff._child_entries()` is the single place to know.
     """
     if config is not None:
-        if config.ignore_null and field is not None and expected is None:
+        if config.ignore_null and field is not None and as_held(expected) is None:
             return "equal"  # a named field the expected side leaves None is not compared
         comparator = _resolve_comparator(actual, config, field=field)
         if comparator is not None:
-            return "equal" if verdict(comparator(actual, expected), subject="the comparator") else "leaf"
+            agreed = verdict(comparator(as_held(actual), as_held(expected)), subject="the comparator")
+            return "equal" if agreed else "leaf"
         if config.strict_types:
             if actual is expected and not at_root:
                 # identity, free from `PyObject_RichCompareBool`.  Not at the root, where it made `strict_types` weaker
@@ -430,8 +464,10 @@ def _node_decision(actual, expected, config: _CompareConfig | None, *, field=Non
             if type(actual) not in _EQ_ATOMIC and not _guarded_not_equal(actual, expected):
                 # `[True] == [1]`: a container says nothing about the types inside it, so the walk keeps going
                 return "strict"
-        if config.tolerance is not None and _is_real_number(actual) and _is_real_number(expected):
-            return "equal" if _within_tolerance(actual, expected, config.tolerance) else "leaf"
+        if config.tolerance is not None and _is_real_number(as_held(actual)) and _is_real_number(as_held(expected)):
+            # a keyed field's key still holds equal what the tolerance would not: it only ever loosens `==`
+            within = _within_tolerance(as_held(actual), as_held(expected), config.tolerance)
+            return "equal" if within or (type(actual) is KeyedValue and actual == expected) else "leaf"
     return _plain_decision(actual, expected, config, at_root=at_root)
 
 

{assertpy2-2.27.0 → assertpy2-2.27.1}/assertpy2/_engine/_diff.py

@@ -34,7 +34,17 @@ from typing import TYPE_CHECKING, TypeVar
 
 from ..errors import DiffEntry, DiffResult, _safe_repr
 from ._compare import _guarded_not_equal, _node_decision
-from ._introspection import is_attrs_instance, is_mapping_like, is_model_dump_object, is_namedtuple, keyed_snapshot
+from ._introspection import (
+    TakenApart,
+    is_attrs_instance,
+    is_mapping_like,
+    is_model_dump_object,
+    is_namedtuple,
+    keyed_names,
+    keyed_pair,
+    keyed_snapshot,
+    model_field_values,
+)
 from ._path import _ROOT, _Path
 
 if TYPE_CHECKING:
@@ -46,10 +56,20 @@ __tracebackhide__ = True
 
 
 def _field_dict(obj, is_model):
-    """Field mapping of a pydantic-style model (``model_dump()``) or an attrs instance (shallow)."""
+    """Field mapping of a pydantic-style model or an attrs instance (shallow), as the values its fields hold.
+
+    An attrs instance's carries the keys its fields are compared through, so the walk decides a field by the
+    key both sides declare and still shows the values held: ``str.lower`` would otherwise print a value
+    neither side has, and listed a field ``==`` holds equal.
+    """
     if is_model:
-        return obj.model_dump()
-    return {field.name: getattr(obj, field.name) for field in obj.__attrs_attrs__ if field.eq is not False}
+        return model_field_values(obj)
+    compared = [field for field in obj.__attrs_attrs__ if field.eq is not False]
+    return TakenApart(
+        type(obj),
+        {field.name: getattr(obj, field.name) for field in compared},
+        {field.name: field.eq_key for field in compared if getattr(field, "eq_key", None) is not None},
+    )
 
 
 def _child_entries(actual, expected, path: _Path, *, descended_for, _seen=None, config=None) -> list[DiffEntry]:
@@ -422,8 +442,8 @@ def _build_equality_diff(
     both_model = is_model_dump_object(actual) and is_model_dump_object(expected)
     both_attrs = is_attrs_instance(actual) and is_attrs_instance(expected)
     if both_model or both_attrs:
-        actual_dict = _field_dict(actual, both_model)
-        expected_dict = _field_dict(expected, both_model)
+        actual_dict, expected_dict = _field_dict(actual, both_model), _field_dict(expected, both_model)
+        keyed = keyed_names(actual_dict, expected_dict)
         entries = []
         for key in _ordered_keys(actual_dict, expected_dict):
             if key not in expected_dict:
@@ -431,7 +451,11 @@ def _build_equality_diff(
             elif key not in actual_dict:
                 entries.append(_prefix.attr(key).entry(actual=None, absent="actual", expected=expected_dict[key]))
             else:
-                decision = _node_decision(actual_dict[key], expected_dict[key], config, field=key)
+                decision = (
+                    _node_decision(*keyed_pair(actual_dict, expected_dict, key), config, field=key)
+                    if key in keyed
+                    else _node_decision(actual_dict[key], expected_dict[key], config, field=key)
+                )
                 if decision == "leaf":
                     entries.append(_prefix.attr(key).entry(actual=actual_dict[key], expected=expected_dict[key]))
                 elif decision != "equal":
@@ -495,6 +519,7 @@ def _mapping_diff_entries(actual, expected, prefix: _Path, child_seen: set[int],
     actual_keys = set(kept)
     expected_keys = set(kept_expected)
     entries.extend(_order_entries(actual, expected, kept, kept_expected, prefix))
+    keyed = keyed_names(kept, kept_expected)
     if config is not None and config.strict_types:
         # `{True} & {1}` hands back whichever side the set drew from, losing the type that differs
         stored = {key: key for key in kept_expected}
@@ -508,7 +533,11 @@ def _mapping_diff_entries(actual, expected, prefix: _Path, child_seen: set[int],
         elif key not in actual_keys:
             entries.append(prefix.key(key).entry(actual=None, absent="actual", expected=kept_expected[key]))
         else:
-            decision = _node_decision(kept[key], kept_expected[key], config, field=key)
+            decision = (
+                _node_decision(*keyed_pair(kept, kept_expected, key), config, field=key)
+                if key in keyed
+                else _node_decision(kept[key], kept_expected[key], config, field=key)
+            )
             if decision == "leaf":
                 entries.append(prefix.key(key).entry(actual=kept[key], expected=kept_expected[key]))
             elif decision != "equal":
@@ -596,8 +625,8 @@ def _sub_diff_entries(
     both_attrs = is_attrs_instance(actual) and is_attrs_instance(expected)
     if both_model or both_attrs:
         child_seen = _seen | {id(actual), id(expected)}
-        actual_dict = _field_dict(actual, both_model)
-        expected_dict = _field_dict(expected, both_model)
+        actual_dict, expected_dict = _field_dict(actual, both_model), _field_dict(expected, both_model)
+        keyed = keyed_names(actual_dict, expected_dict)
         entries = []
         for key in _ordered_keys(actual_dict, expected_dict):
             if key not in expected_dict:
@@ -605,7 +634,11 @@ def _sub_diff_entries(
             elif key not in actual_dict:
                 entries.append(prefix.attr(key).entry(actual=None, absent="actual", expected=expected_dict[key]))
             else:
-                decision = _node_decision(actual_dict[key], expected_dict[key], config, field=key)
+                decision = (
+                    _node_decision(*keyed_pair(actual_dict, expected_dict, key), config, field=key)
+                    if key in keyed
+                    else _node_decision(actual_dict[key], expected_dict[key], config, field=key)
+                )
                 if decision == "leaf":
                     entries.append(prefix.attr(key).entry(actual=actual_dict[key], expected=expected_dict[key]))
                 elif decision != "equal":
@@ -661,9 +694,9 @@ def _walk_leaves(value, prefix: _Path = _ROOT, _seen=None):
         return
     if is_model_dump_object(value):
         child_seen = _seen | {id(value)}
-        dumped = value.model_dump()
-        for key in dumped:
-            yield from _walk_leaves(dumped[key], prefix.attr(str(key), dotted_at_root=False), child_seen)
+        held = model_field_values(value)
+        for key in held:
+            yield from _walk_leaves(held[key], prefix.attr(str(key), dotted_at_root=False), child_seen)
         return
     if is_attrs_instance(value):
         child_seen = _seen | {id(value)}

{assertpy2-2.27.0 → assertpy2-2.27.1}/assertpy2/_engine/_equality.py

@@ -32,9 +32,18 @@ from ._compare import (
     _kinds_never_equal,
     _node_decision,
     _spec_matches,
+    _types_differ,
 )
 from ._diff import _sub_diff_entries
-from ._introspection import is_attrs_instance, is_model_dump_object, is_namedtuple
+from ._introspection import (
+    TakenApart,
+    is_attrs_instance,
+    is_model_dump_object,
+    is_namedtuple,
+    keyed_names,
+    keyed_pair,
+    model_field_values,
+)
 from ._path import _ROOT
 from ._require import refuse
 
@@ -74,22 +83,21 @@ def comparable_fields(obj: object) -> dict | None:
 
     Dataclasses are converted by reference rather than through `dataclasses.asdict`, which deep-copies and
     crashes on a field that cannot be copied, and a field declared ``compare=False`` is left out, as the
-    dataclass's own ``==`` leaves it out.  An attrs field declared ``eq=False`` is left out the same way.
+    dataclass's own ``==`` leaves it out.  An attrs field declared ``eq=False`` is left out the same way, and
+    one declared with a key, ``eq=str.lower``, is read through it: `attrs.asdict` read the raw value, and
+    ``ignore=`` failed on two instances ``==`` holds equal.
 
     A value of a builtin kind is not a bag of fields even when it carries a ``__dict__``: a subclass of
     `Decimal` or `str` has an empty one, and reading it made every two such values compare equal.
     """
     if dataclasses.is_dataclass(obj) and not isinstance(obj, type):
-        return cast("dict", _shallow_fields(obj))
+        return cast("dict", _flattened(obj, frozenset({"dataclass"})))
     if is_namedtuple(obj):
-        return dict(obj._asdict())
+        return TakenApart(type(obj), obj._asdict())
     if is_model_dump_object(obj):
-        return obj.model_dump()
+        return cast("dict", _flattened(obj, frozenset({"model", "dataclass"})))
     if is_attrs_instance(obj):
-        # deferred: at module level it cost 8.5 ms and 22 modules of a 39.8 ms import wherever attrs is installed
-        import attrs
-
-        return attrs.asdict(obj, filter=lambda attribute, _value: attribute.eq is not False)
+        return cast("dict", _flattened(obj, frozenset({"attrs"})))
     builtin_kinds = (
         type,
         numbers.Number,
@@ -104,27 +112,58 @@ def comparable_fields(obj: object) -> dict | None:
         pathlib.PurePath,
     )
     if hasattr(obj, "__dict__") and not isinstance(obj, builtin_kinds):
-        return dict(vars(obj))
+        return TakenApart(type(obj), vars(obj))
     return None
 
 
-def _shallow_fields(node: Any) -> Any:
-    """`dataclasses.asdict` by reference, without the copy, and without the fields ``==`` leaves out."""
-    if dataclasses.is_dataclass(node) and not isinstance(node, type):
-        return {
-            field.name: _shallow_fields(getattr(node, field.name))
-            for field in dataclasses.fields(node)
-            if field.compare
-        }
+def _flattened(node: Any, through: frozenset[str]) -> Any:
+    """Fields by reference, as each value's ``==`` reads them, taken apart through the kinds *through* names.
+
+    A nested value is taken apart where the conversion each kind used to go through took it apart, so a
+    nested value is judged as it was: `dataclasses.asdict` went through dataclasses, `attrs.asdict` through
+    attrs instances, and `model_dump()` through models and the dataclasses inside them.  What is read is
+    what is held, though, not what a serialiser or a copy makes of it.
+    """
+    if "dataclass" in through and dataclasses.is_dataclass(node) and not isinstance(node, type):
+        return TakenApart(
+            type(node),
+            {
+                field.name: _flattened(getattr(node, field.name), through)
+                for field in dataclasses.fields(node)
+                if field.compare
+            },
+        )
+    if "attrs" in through and is_attrs_instance(node):
+        compared = [attribute for attribute in node.__attrs_attrs__ if attribute.eq is not False]
+        keys = {attribute.name: _key_of(attribute) for attribute in compared}
+        return TakenApart(
+            type(node),
+            {
+                attribute.name: getattr(node, attribute.name)
+                if keys[attribute.name]
+                else _flattened(getattr(node, attribute.name), through)
+                for attribute in compared
+            },
+            {name: key for name, key in keys.items() if key is not None},
+        )
+    if "model" in through and is_model_dump_object(node):
+        return TakenApart(
+            type(node), {name: _flattened(value, through) for name, value in model_field_values(node).items()}
+        )
     if isinstance(node, tuple) and hasattr(node, "_fields"):
-        return type(node)(*[_shallow_fields(item) for item in node])
+        return type(node)(*[_flattened(item, through) for item in node])
     if isinstance(node, (list, tuple)):
-        return type(node)(_shallow_fields(item) for item in node)
+        return type(node)(_flattened(item, through) for item in node)
     if isinstance(node, dict):
-        return {_shallow_fields(key): _shallow_fields(value) for key, value in node.items()}
+        return {_flattened(key, through): _flattened(value, through) for key, value in node.items()}
     return node
 
 
+def _key_of(attribute: Any) -> Any:
+    """The key an attrs field is compared through, given as ``eq=``, or ``None``: its value is then held raw."""
+    return getattr(attribute, "eq_key", None)
+
+
 def _as_fields(value: object) -> dict | None:
     """A plain dict as itself, anything else through `comparable_fields`."""
     return value if isinstance(value, dict) else comparable_fields(value)
@@ -356,15 +395,20 @@ def mapping_differs(
     if (
         config is not None
         and config.strict_types
-        and _keyed_types_differ(
-            dict.fromkeys(key for key in left if key in keys_in_actual),
-            dict.fromkeys(key for key in right if key in keys_in_expected),
+        and (
+            # two elements taken apart reach here with no parent walk to have compared their classes
+            _types_differ(actual, expected)
+            or _keyed_types_differ(
+                dict.fromkeys(key for key in left if key in keys_in_actual),
+                dict.fromkeys(key for key in right if key in keys_in_expected),
+            )
         )
     ):
         # `{True: "a"}` and `{1: "a"}` are equal to Python and not under strict types; only the keys still compared
         return True
+    keyed = keyed_names(actual, expected)
     for key in keys_in_actual:
-        nested_left, nested_right = left[key], right[key]
+        nested_left, nested_right = keyed_pair(left, right, key) if key in keyed else (left[key], right[key])
         if config is not None:
             decision = _node_decision(nested_left, nested_right, config, field=key)
             if decision == "equal":