assertpy2 2.26.0__tar.gz → 2.27.1__tar.gz

{assertpy2-2.26.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.26.0 → assertpy2-2.27.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: assertpy2
-Version: 2.26.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.26.0 → assertpy2-2.27.1}/assertpy2/_clustering.py

@@ -239,6 +239,25 @@ def _shown(value: object) -> str:
     return _bounded(stable_repr(value))
 
 
+class _Absent:
+    """A side that held nothing at all.
+
+    An absent key carries `None`, and read as a value it printed as ``None`` and keyed with every
+    failure whose value really is `None`.
+    """
+
+    def __repr__(self) -> str:
+        return "<absent>"
+
+
+_ABSENT = _Absent()
+
+
+def _side_of(entry: DiffEntry, side: str) -> object:
+    """One side of an entry, or the absent marker where that side held nothing."""
+    return _ABSENT if entry.absent == side else (entry.actual if side == "actual" else entry.expected)
+
+
 def _identity(value: object) -> str:
     """A value as a cluster key: the whole of it, in a fixed number of characters.
 
@@ -265,7 +284,9 @@ def signature(diff: DiffResult, entry: DiffEntry, label: str | None = None) -> S
         return Signature(False, diff.kind, label=label)
     if diff.kind not in _VALUES_ARE_VALUES:
         return None
-    return Signature(False, diff.kind, values=(_identity(entry.actual), _identity(entry.expected)))
+    return Signature(
+        False, diff.kind, values=(_identity(_side_of(entry, "actual")), _identity(_side_of(entry, "expected")))
+    )
 
 
 def is_well_formed(key: Signature) -> bool:
@@ -305,7 +326,9 @@ def observations_of(diff: DiffResult | None, label: str | None = None) -> list[O
     for entry in diff.entries:
         key = signature(diff, entry, label)
         if key is not None:
-            seen.setdefault(key, Observation(key, _shown(entry.actual), _shown(entry.expected)))
+            seen.setdefault(
+                key, Observation(key, _shown(_side_of(entry, "actual")), _shown(_side_of(entry, "expected")))
+            )
     return list(seen.values())
 
 

{assertpy2-2.26.0 → assertpy2-2.27.1}/assertpy2/_engine/_builder_check_typing.py

@@ -27,7 +27,6 @@ if TYPE_CHECKING:
     from ..matchers import Matcher
     from ..outcome import AssertionOutcome
     from ._capable_typing import (
-        _Callable,
         _Indexed,
         _Keyed,
         _KeyedWithItems,
@@ -1136,15 +1135,6 @@ if TYPE_CHECKING:
             **options: Any,
         ) -> AssertionOutcome: ...
 
-        @overload
-        def when_called_with(
-            self: _CheckAnyValue[Callable[..., _P]], *some_args: object, **some_kwargs: object
-        ) -> AssertionOutcome: ...
-        @overload
-        def when_called_with(
-            self: _CheckAnyValue[_Callable], *some_args: object, **some_kwargs: object
-        ) -> AssertionOutcome: ...
-
         @overload
         def is_not_none(self: _CheckAnyValue[str | None]) -> AssertionOutcome: ...
         @overload

{assertpy2-2.26.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.26.0 → assertpy2-2.27.1}/assertpy2/_engine/_check_typing.py

@@ -150,6 +150,12 @@ if TYPE_CHECKING:
         @property
         def not_(self) -> Self: ...
 
+    class _CheckReturningAssertion(Protocol):
+        """The verdict twin of `_ReturningAssertion`."""
+
+        @property
+        def not_(self) -> Self: ...
+
     class _CheckZeroAssertion(Protocol):
         """The verdict twin of `_ZeroAssertion`."""
 
@@ -679,9 +685,41 @@ if TYPE_CHECKING:
         @property
         def not_(self) -> Self: ...
 
+    class _CheckWarnedAssertion(_CheckTextAssertion, _CheckReturningAssertion, Protocol):
+        """The verdict twin of `_WarnedAssertion`."""
+
+        @property
+        def not_(self) -> Self: ...
+
     class _CheckCallableAssertion(_CheckCoreAssertion, Protocol[_P_co]):
         """The verdict twin of `_CallableAssertion`."""
 
+        @property
+        def not_(self) -> Self: ...
+
+    class _CheckCompletedAssertion(_CheckCallableAssertion[_P_co], _CheckReturningAssertion, Protocol[_P_co]):
+        """The verdict twin of `_CompletedAssertion`."""
+
+        @property
+        def not_(self) -> Self: ...
+
+    class _CheckExpectedRaiseAssertion(_CheckCallableAssertion[_P_co], Protocol[_P_co]):
+        """The verdict twin of `_ExpectedRaiseAssertion`."""
+
+        def when_called_with(self, *some_args: object, **some_kwargs: object) -> AssertionOutcome: ...
+        @property
+        def not_(self) -> Self: ...
+
+    class _CheckExpectedWarningAssertion(_CheckCallableAssertion[_P_co], Protocol[_P_co]):
+        """The verdict twin of `_ExpectedWarningAssertion`."""
+
+        def when_called_with(self, *some_args: object, **some_kwargs: object) -> AssertionOutcome: ...
+        @property
+        def not_(self) -> Self: ...
+
+    class _CheckExpectedCompletionAssertion(_CheckCallableAssertion[_P_co], Protocol[_P_co]):
+        """The verdict twin of `_ExpectedCompletionAssertion`."""
+
         def when_called_with(self, *some_args: object, **some_kwargs: object) -> AssertionOutcome: ...
         @property
         def not_(self) -> Self: ...

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

@@ -16,6 +16,8 @@ from __future__ import annotations
 import dataclasses
 import datetime
 import decimal
+import fractions
+import inspect
 import math
 import numbers
 import pathlib
@@ -24,11 +26,21 @@ import uuid
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from ._introspection import is_mapping_like, is_model_dump_object
-from ._require import verdict
+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(
@@ -161,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:
@@ -225,16 +260,73 @@ def _is_real_number(value) -> bool:
 def _within_tolerance(actual, expected, tolerance) -> bool:
     """Return whether two real numbers are within ``tolerance`` (absolute); ``NaN`` is never within.
 
-    Only actual ``float`` operands are checked for ``NaN`` (other reals cannot be ``NaN``), which also keeps
-    ``math.isnan`` off arbitrary-precision ``int`` values that would overflow it.
+    Checked by type rather than through `math.isnan`, which overflows on an arbitrary-precision ``int``
+    and signals on a `Decimal` NaN.
+
+    The subtraction is tried as written, so two floats keep the arithmetic they always had.  A `Decimal`
+    against a ``float`` refuses to subtract at all and a bignum ``int`` overflows one, and those two pairs
+    are measured exactly instead, through `fractions.Fraction`.
     """
-    if isinstance(actual, float) and math.isnan(actual):
-        return False
-    if isinstance(expected, float) and math.isnan(expected):
+    if nan_operand(actual) or nan_operand(expected):
         return False
     if actual == expected:  # equal values (including inf == inf) are within any tolerance
         return True
-    return abs(actual - expected) <= tolerance
+    if _is_infinite(actual) or _is_infinite(expected):
+        return False  # unequal, and no distance from an infinity is within a finite tolerance
+    try:
+        return abs(actual - expected) <= tolerance
+    except (TypeError, OverflowError) as error:
+        if raised_inside(error):  # their own `__sub__` or `__abs__` raised: a bug in the value, not a refusal
+            raise
+        return abs(fractions.Fraction(actual) - fractions.Fraction(expected)) <= fractions.Fraction(tolerance)
+
+
+def _is_infinite(value) -> bool:
+    """A `float` or `Decimal` infinity, asked by type so nothing else is converted to a float to answer.
+
+    Through `Decimal`'s own method rather than the value's: a subclass overriding `is_infinite` would
+    otherwise decide this, and run its code before the arithmetic it is being asked about.
+    """
+    if isinstance(value, float):
+        return math.isinf(value)
+    return isinstance(value, decimal.Decimal) and decimal.Decimal.is_infinite(value)
+
+
+class WindowRefusedError(TypeError):
+    """The two operands form no window: neither the arithmetic nor an exact conversion takes them.
+
+    A `TypeError` still, so a caller that let the operand's own refusal out keeps letting this one out,
+    and a matcher, which may not raise, can tell it from a `__sub__` of somebody's own that raised.
+    """
+
+
+def tolerance_window(middle: Any, tolerance: Any) -> tuple[Any, Any]:
+    """The closed interval ``middle`` plus and minus ``tolerance``.
+
+    Typed as `Any` because the pairing is a run-time fact: the assertion has refused every combination
+    but two before it asks, a number against a number and a datetime against a timedelta, and a checker
+    reading the public signature alone is right to refuse the arithmetic.  The matcher asks without
+    refusing anything first, which is what `WindowRefusedError` is for: it hands back the operands' own
+    refusal as something a matcher may answer "no match" to.
+    """
+    if _is_infinite(middle) and _is_real_number(tolerance):
+        # its own window, the way a float infinity already gets one: no distance from it is finite.  The
+        # tolerance is still read, or an infinity paired with anything at all would answer "close enough"
+        return middle, middle
+    try:
+        return middle - tolerance, middle + tolerance
+    except TypeError as refusal:
+        if raised_inside(refusal):  # their own `__sub__` raised: that is a bug in the value
+            raise
+        if not all(isinstance(operand, numbers.Number) for operand in (middle, tolerance)):
+            raise WindowRefusedError(str(refusal)) from None
+        # a `Decimal` refuses arithmetic with a `float` or a `Fraction`, which both convert exactly, while
+        # an infinite or NaN one does not convert at all
+        try:
+            exact, span = fractions.Fraction(middle), fractions.Fraction(tolerance)
+        except (TypeError, ValueError, OverflowError) as failed:
+            raise WindowRefusedError(str(failed)) from None
+        return exact - span, exact + span
 
 
 def _resolve_comparator(actual, config: _CompareConfig, *, field):
@@ -246,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:
@@ -266,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
 
@@ -293,6 +386,51 @@ def _keyed_types_differ(actual, expected) -> bool:
     return False
 
 
+def _kinds_never_equal(actual, expected) -> bool:
+    """Whether ``==`` rejects the pair by its kind alone, which a walk over the parts cannot see.
+
+    Under a compare config the walker decides by parts, so ``[1.0]`` against ``(1.0,)``, or two dataclasses
+    of different classes holding the same fields, had no differing part and passed, while ``==`` rejects
+    both outright.  Asked only once ``==`` has already said no, so it never fails a pair ``==`` accepts.
+
+    The kind alone is not the answer: a list subclass may define ``__eq__`` to accept a tuple.  So a pair
+    of different kinds counts only when both sides' own ``__eq__`` decline it, which leaves ``==`` at
+    identity whatever the parts hold.  A pydantic model answers ``False`` rather than declining, so which of
+    class or fields decided cannot be told apart, and models are left to the walk.
+    """
+    if isinstance(actual, (list, tuple)) and isinstance(expected, (list, tuple)):
+        kinds_differ = isinstance(actual, list) is not isinstance(expected, list)
+    else:
+        both_dataclasses = all(
+            dataclasses.is_dataclass(side) and not isinstance(side, type) for side in (actual, expected)
+        )
+        both_attrs = is_attrs_instance(actual) and is_attrs_instance(expected)
+        kinds_differ = (both_dataclasses or both_attrs) and type(actual) is not type(expected)
+    return kinds_differ and _both_decline(actual, expected)
+
+
+def _declines(value: Any, other: Any) -> bool:
+    """Whether *value*'s own ``__eq__`` answers ``NotImplemented`` for *other*, asked as ``==`` asks it.
+
+    Read statically off the type, since `type(x).__eq__` is an ordinary read that a metaclass answers,
+    and bound through the descriptor protocol, since that is what turns a function, a `staticmethod` or
+    anything else on the class into the callable the operator uses.
+    """
+    held: Any = inspect.getattr_static(type(value), "__eq__", None)
+    bind: Any = getattr(type(held), "__get__", None)
+    # measured against `==` itself: a callable that binds to nothing is called with the other side alone
+    asking = held if bind is None else bind(held, value, type(value))
+    return asking(other) is NotImplemented
+
+
+def _both_decline(actual: Any, expected: Any) -> bool:
+    """Whether each side's own ``__eq__`` answers ``NotImplemented`` for the other."""
+    try:
+        return _declines(actual, expected) and _declines(expected, actual)
+    except Exception:  # an `__eq__` that raises decides nothing here, and the walk goes on as before
+        return False
+
+
 def _node_decision(actual, expected, config: _CompareConfig | None, *, field=None, at_root: bool = False) -> str:
     """Classify a node as ``"equal"``, ``"leaf"``, ``"recurse"`` or ``"strict"``.
 
@@ -307,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
@@ -325,9 +464,22 @@ 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"
-    return "recurse" if _guarded_not_equal(actual, expected) else "equal"
+        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)
+
+
+def _plain_decision(actual, expected, config: _CompareConfig | None, *, at_root: bool = False) -> str:
+    """``==``'s answer as a decision, where under a config a pair ruled out by its kind alone is a leaf."""
+    if actual is expected and not at_root:
+        # the same rule a container's own `==` applies to its members, and the verdict came from that `==`:
+        # without it the diff listed a NaN both sides hold as differing, and the hint blamed it
+        return "equal"
+    if not _guarded_not_equal(actual, expected):
+        return "equal"
+    return "leaf" if config is not None and _kinds_never_equal(actual, expected) else "recurse"
 
 
 def _spec_matches(key, value, specs) -> bool: