assertpy2 2.12.0__tar.gz → 2.13.0__tar.gz

assertpy2-2.13.0/.github/dependabot.yml

@@ -0,0 +1,31 @@
+version: 2
+updates:
+  # Python dependencies via uv: the native `uv` ecosystem updates pyproject.toml
+  # AND keeps uv.lock in sync (the older `pip` ecosystem left the lock untouched).
+  - package-ecosystem: uv
+    directory: /
+    schedule:
+      interval: weekly
+    cooldown:
+      default-days: 7
+      semver-major-days: 7
+    commit-message:
+      prefix: "chore(deps)"
+    groups:
+      # One PR/week for all minor+patch bumps; majors stay individual for review.
+      python-minor-patch:
+        patterns: ["*"]
+        update-types: ["minor", "patch"]
+
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+    cooldown:
+      default-days: 7
+    commit-message:
+      prefix: "ci(deps)"
+    groups:
+      actions-minor-patch:
+        patterns: ["*"]
+        update-types: ["minor", "patch"]

{assertpy2-2.12.0 → assertpy2-2.13.0}/.github/workflows/ci.yml

@@ -21,12 +21,17 @@ jobs:
         os: [ubuntu-latest]
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
         include:
+          # the Codecov cell also installs every optional integration (pandas/polars/numpy extras plus
+          # pydantic/attrs/requests), so the tests the other minimal-env cells skip run here for real
+          - os: ubuntu-latest
+            python-version: "3.14"
+            full-deps: true
           - os: windows-latest
             python-version: "3.14"
           - os: macos-latest
             python-version: "3.14"
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           persist-credentials: false
 
@@ -34,14 +39,19 @@ jobs:
         uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
         with:
           python-version: ${{ matrix.python-version }}
           allow-prereleases: true
 
       - name: Install dependencies
+        if: '!matrix.full-deps'
         run: uv sync --extra json
 
+      - name: Install dependencies (all integrations)
+        if: matrix.full-deps
+        run: uv sync --extra json --extra data --group integrations
+
       - name: Test with coverage
         run: uv run pytest -v --cov=assertpy2 --cov-report=term-missing --cov-report=xml tests
 
@@ -55,7 +65,7 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           persist-credentials: false
 
@@ -63,7 +73,7 @@ jobs:
         uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
 
       - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
         with:
           python-version: "3.14"
 
@@ -84,3 +94,11 @@ jobs:
 
       - name: Type check (pyright, public typing surface)
         run: uv run pyright tests/test_typing.py
+
+  ci-ok:
+    needs: [test, lint]
+    if: always()
+    runs-on: ubuntu-latest
+    steps:
+      - name: Verify required jobs succeeded
+        run: '[ "${{ needs.test.result }}" = "success" ] && [ "${{ needs.lint.result }}" = "success" ]'

{assertpy2-2.12.0 → assertpy2-2.13.0}/.github/workflows/codeql.yml

@@ -17,7 +17,7 @@ jobs:
     permissions:
       security-events: write
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           persist-credentials: false
       - uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2

{assertpy2-2.12.0 → assertpy2-2.13.0}/.github/workflows/docs.yml

@@ -17,7 +17,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           persist-credentials: false
 
@@ -25,7 +25,7 @@ jobs:
         uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
 
       - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
         with:
           python-version: "3.14"
 

{assertpy2-2.12.0 → assertpy2-2.13.0}/.github/workflows/mutation.yml

@@ -21,7 +21,7 @@ jobs:
       matrix:
         module: [base, numeric, string, contains, collection, dict, date, matchers, helpers, _compare, dataframe, json_mixin, snapshot, bytes_mixin, dynamic, extracting, warning, exception, async_assertions, file, behave_matchers]
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           persist-credentials: false
 
@@ -29,7 +29,7 @@ jobs:
         uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
 
       - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
         with:
           python-version: "3.14"
 

{assertpy2-2.12.0 → assertpy2-2.13.0}/.github/workflows/publish.yml

@@ -16,7 +16,7 @@ jobs:
       contents: write
       attestations: write
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           persist-credentials: false
 
@@ -26,7 +26,7 @@ jobs:
           enable-cache: false
 
       - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
         with:
           python-version: "3.15"
           allow-prereleases: true

{assertpy2-2.12.0 → assertpy2-2.13.0}/.github/workflows/scorecard.yml

@@ -16,7 +16,7 @@ jobs:
       security-events: write
       id-token: write
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           persist-credentials: false
       - uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3

{assertpy2-2.12.0 → assertpy2-2.13.0}/.github/workflows/zizmor.yml

@@ -19,7 +19,7 @@ jobs:
     permissions:
       security-events: write
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           persist-credentials: false
-      - uses: zizmorcore/zizmor-action@5f14fd08f7cf1cb1609c1e344975f152c7ee938d # v0.5.6
+      - uses: zizmorcore/zizmor-action@192e21d79ab29983730a13d1382995c2307fbcaa # v0.5.7

{assertpy2-2.12.0 → assertpy2-2.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.12.0
+Version: 2.13.0
 Summary: Fluent assertion library for Python with composable matchers, structural matching, and full type safety
 Project-URL: Homepage, https://github.com/Solganis/assertpy2
 Project-URL: Repository, https://github.com/Solganis/assertpy2
@@ -9,7 +9,7 @@ Author-email: Justin Shacklette <justin@saturnboy.com>
 Maintainer-email: Solganis <solganis.dev@gmail.com>
 License-Expression: BSD-3-Clause
 License-File: LICENSE
-Keywords: assert,assert_that,assertion,assertthat,pytest,test,testing,unittest
+Keywords: assert,assert_that,assertion,assertpy,assertthat,fluent,matchers,pytest,test,testing,type-safe,unittest
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License

{assertpy2-2.12.0 → assertpy2-2.13.0}/assertpy2/__init__.py

@@ -16,6 +16,7 @@ from .async_assertions import AsyncAssertionBuilder
 from .errors import AssertionFailure, DiffEntry, DiffResult
 from .file import contents_of
 from .matchers import Matcher, clear_custom_matchers, match, register_matcher, unregister_matcher
+from .snapshot import SnapshotCreatedWarning
 
 __all__ = [
     "AssertionFailure",
@@ -24,6 +25,7 @@ __all__ = [
     "DiffResult",
     "Matcher",
     "NegatedBuilder",
+    "SnapshotCreatedWarning",
     "SoftAssertionCollector",
     "WarningLoggingAdapter",
     "__version__",

{assertpy2-2.12.0 → assertpy2-2.13.0}/assertpy2/_compare.py

@@ -13,12 +13,15 @@ express to the type checker.
 
 from __future__ import annotations
 
+import dataclasses
 import math
 import numbers
 import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from ._introspection import is_mapping_like, is_model_dump_object
+
 if TYPE_CHECKING:
     from collections.abc import Callable
 
@@ -59,6 +62,89 @@ def _build_compare_config(tolerance, comparators) -> _CompareConfig | None:
     return _CompareConfig(tolerance=tolerance, comparators=comparators)
 
 
+def _ambiguous_array_operand(value: object, other: object) -> object | None:
+    """Return the array/frame-like operand whose ``==`` has no single truth value, else ``None``.
+
+    numpy/pandas/polars containers expose ``__array__`` and compare element-wise, so ``bool(a == b)``
+    raises rather than yielding one bool (and a ``DataFrame`` also quacks dict-like, which would otherwise
+    mis-dispatch the comparison).  The ``__array__`` gate keeps the extra comparison off the hot path; the
+    truth test is actually attempted, so 0-d / scalar array values (which *are* truth-testable) pass
+    through unchanged.
+    """
+    for candidate, counterpart in ((value, other), (other, value)):
+        if hasattr(candidate, "__array__"):
+            try:
+                bool(candidate == counterpart)
+            except (ValueError, TypeError):
+                return candidate
+    return None
+
+
+def _array_equality_error(method: str, operand: object) -> TypeError:
+    """Build the actionable error raised when ``method`` is given an element-wise array/frame-like."""
+    return TypeError(
+        f"{method}() cannot directly compare <{type(operand).__name__}>: its '==' is element-wise and has"
+        " no single truth value. Compare the value's own equality (e.g."
+        " assert_that(actual.equals(expected)).is_true()), assert on extracted scalars (columns, shape,"
+        " length), or use satisfies(...) with an explicit predicate."
+    )
+
+
+def _find_ambiguous_operand(actual, expected, _seen=None):
+    """Locate the array/frame-like member that broke a comparison, walking the diff engine's containers.
+
+    Cold error-path only; ``None`` means the error was not array-caused and must be re-raised unchanged.
+    """
+    if _seen is None:
+        _seen = set()
+    pair = (id(actual), id(expected))
+    if pair in _seen:
+        return None
+    _seen = _seen | {pair}
+    operand = _ambiguous_array_operand(actual, expected)
+    if operand is not None:
+        return operand
+    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
+    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
+    if is_model_dump_object(actual) and is_model_dump_object(expected):
+        return _find_ambiguous_operand(actual.model_dump(), expected.model_dump(), _seen)
+    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
+
+
+def _guarded_not_equal(actual, expected) -> bool:
+    """``bool(actual != expected)``, converting the ambiguity raised from *inside* a container's ``==``
+    (where the top-level operand gate cannot see the array member) into the actionable ``TypeError``."""
+    try:
+        return bool(actual != expected)
+    except (ValueError, TypeError) as error:
+        operand = _find_ambiguous_operand(actual, expected)
+        if operand is None:
+            raise
+        raise _array_equality_error("is_equal_to", operand) from error
+
+
 def _is_real_number(value) -> bool:
     """Return whether ``value`` is a real number eligible for tolerance (excludes ``bool`` and ``complex``).
 
@@ -114,7 +200,7 @@ def _node_decision(actual, expected, config: _CompareConfig | None, *, field=Non
             return "equal" if comparator(actual, expected) else "leaf"
         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 actual != expected else "equal"
+    return "recurse" if _guarded_not_equal(actual, expected) else "equal"
 
 
 def _spec_matches(key, value, specs) -> bool:

{assertpy2-2.12.0 → assertpy2-2.13.0}/assertpy2/_typing.py

@@ -48,7 +48,16 @@ if TYPE_CHECKING:
         def is_in(self, *items: object) -> Self: ...
         def is_not_in(self, *items: object) -> Self: ...
         # SnapshotMixin
-        def snapshot(self, id: str | None = ..., path: str = ...) -> Self: ...  # noqa: A002  # mirrors public snapshot() parameter
+        def snapshot(
+            self,
+            id: str | None = ...,  # noqa: A002  # mirrors public snapshot() parameter
+            path: str = ...,
+            *,
+            ignore: _KeySpecs | None = ...,
+            include: _KeySpecs | None = ...,
+            tolerance: float | None = ...,
+            comparators: dict[object, Callable[..., bool]] | None = ...,
+        ) -> Self: ...
         # NegatedBuilder
         @property
         def not_(self) -> NegatedBuilder: ...
@@ -258,4 +267,10 @@ if TYPE_CHECKING:
         def does_not_warn(self, warning: type[Warning] = ...) -> Self: ...
         # captured value (exception or warning message) is a str; returned() pivots to the call result
         def when_called_with(self, *some_args: object, **some_kwargs: object) -> _InvokedAssertion: ...
-        def eventually(self, *, timeout: float = ..., interval: float = ...) -> AsyncAssertionBuilder: ...
+        def eventually(
+            self,
+            *,
+            timeout: float = ...,
+            interval: float = ...,
+            ignoring: type[Exception] | tuple[type[Exception], ...] = ...,
+        ) -> AsyncAssertionBuilder: ...

{assertpy2-2.12.0 → assertpy2-2.13.0}/assertpy2/assertpy.py

@@ -29,7 +29,7 @@ if TYPE_CHECKING:
         _StringAssertion,
     )
 
-from .async_assertions import AsyncAssertionBuilder
+from .async_assertions import AsyncAssertionBuilder, _normalize_ignoring
 from .base import BaseMixin
 from .bytes_mixin import BytesMixin
 from .collection import CollectionMixin
@@ -49,7 +49,7 @@ from .snapshot import SnapshotMixin
 from .string import StringMixin
 from .warning import WarningMixin
 
-__version__ = "2.12.0"
+__version__ = "2.13.0"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch
@@ -631,7 +631,13 @@ class AssertionBuilder(
                 raise AssertionFailure(out, actual=actual, expected=expected, diff=diff)
             raise AssertionError(out)
 
-    def eventually(self, *, timeout: float = 5.0, interval: float = 0.5) -> AsyncAssertionBuilder:
+    def eventually(
+        self,
+        *,
+        timeout: float = 5.0,
+        interval: float = 0.5,
+        ignoring: type[Exception] | tuple[type[Exception], ...] = (),
+    ) -> AsyncAssertionBuilder:
         """Switch to async polling mode for eventual-consistency assertions.
 
         The current ``val`` must be a callable (sync or async).  Returns an
@@ -639,9 +645,16 @@ class AssertionBuilder(
         methods are coroutines that poll ``val()`` until the assertion passes or
         ``timeout`` expires.
 
+        By default only a failing assertion is retried: any exception raised by ``val()`` itself
+        propagates immediately.  A probe that signals "not ready yet" by raising (a connection refused
+        while a service boots, a record not yet visible) can be retried too by listing those exception
+        types in ``ignoring``.
+
         Args:
             timeout: maximum seconds to keep retrying (default ``5.0``)
             interval: seconds between retries (default ``0.5``)
+            ignoring: an ``Exception`` subclass (or tuple of them) the polling loop retries instead of
+                propagating (default: none)
 
         Examples:
             Usage:
@@ -659,11 +672,19 @@ class AssertionBuilder(
                     assert_that(get_count).eventually(timeout=2).is_equal_to(3)
                 )
 
+            Retry a probe that raises while the system under test is not ready yet:
+
+                await assert_that(get_order).eventually(timeout=10, ignoring=ConnectionError).has_status("PAID")
+
+                # or configure fluently on the returned builder
+                await assert_that(get_order).eventually().within(10).ignoring(ConnectionError).has_status("PAID")
+
         Returns:
             AsyncAssertionBuilder: an async builder whose assertion methods are awaitable
 
         Raises:
-            TypeError: if ``val`` is not callable
+            TypeError: if ``val`` is not callable, or if ``ignoring`` contains anything that is not an
+                ``Exception`` subclass
         """
         if not callable(self.val):
             raise TypeError("val must be callable when using eventually()")
@@ -673,4 +694,5 @@ class AssertionBuilder(
             description=self.description,
             timeout=timeout,
             interval=interval,
+            ignoring=_normalize_ignoring(ignoring),
         )

{assertpy2-2.12.0 → assertpy2-2.13.0}/assertpy2/async_assertions.py

@@ -12,6 +12,19 @@ if TYPE_CHECKING:
 __tracebackhide__ = True
 
 
+def _normalize_ignoring(ignoring) -> tuple[type[Exception], ...]:
+    """Normalize an ``ignoring`` spec (one exception type or a tuple of them) to a validated tuple.
+
+    Only ``Exception`` subclasses are accepted, so ``BaseException``-only classes such as
+    ``KeyboardInterrupt`` can never be swallowed by the polling loop.
+    """
+    exceptions = ignoring if isinstance(ignoring, tuple) else (ignoring,)
+    for exception_type in exceptions:
+        if not (isinstance(exception_type, type) and issubclass(exception_type, Exception)):
+            raise TypeError("given ignoring arg must be an Exception subclass or a tuple of Exception subclasses")
+    return exceptions
+
+
 class AsyncAssertionBuilder:
     """Async assertion builder that polls a callable until an assertion passes or timeout expires.
 
@@ -23,6 +36,7 @@ class AsyncAssertionBuilder:
         description: optional error description forwarded to the builder
         timeout: maximum seconds to keep retrying
         interval: seconds between retries
+        ignoring: exception types the polling loop retries instead of propagating
     """
 
     def __init__(
@@ -33,12 +47,14 @@ class AsyncAssertionBuilder:
         description: str = "",
         timeout: float = 5.0,
         interval: float = 0.5,
+        ignoring: tuple[type[Exception], ...] = (),
     ):
         self._func = func
         self._builder_func = builder_func
         self._description = description
         self._timeout = timeout
         self._interval = interval
+        self._ignoring = ignoring
 
     def within(self, timeout: float) -> Self:
         """Override the timeout (in seconds)."""
@@ -50,6 +66,20 @@ class AsyncAssertionBuilder:
         self._interval = interval
         return self
 
+    def ignoring(self, *exceptions: type[Exception]) -> Self:
+        """Replace the exception types the polling loop retries instead of propagating.
+
+        Examples:
+            Usage:
+
+                await assert_that(get_order).eventually().within(10).ignoring(ConnectionError).has_status("PAID")
+
+        Raises:
+            TypeError: if any argument is not an ``Exception`` subclass
+        """
+        self._ignoring = _normalize_ignoring(exceptions)
+        return self
+
     def __getattr__(self, name: str):
         if name.startswith("_"):
             raise AttributeError(name)
@@ -58,7 +88,7 @@ class AsyncAssertionBuilder:
             async def _poll():
                 loop = asyncio.get_running_loop()
                 deadline = loop.time() + self._timeout
-                last_error: AssertionError | None = None
+                last_error: Exception | None = None
                 while True:
                     try:
                         val = self._func()
@@ -68,12 +98,13 @@ class AsyncAssertionBuilder:
                         method = getattr(builder, name)
                         method(*args, **kwargs)
                         return builder
-                    except AssertionError as exc:  # noqa: PERF203  # retry-on-failure needs the try/except per poll iteration
+                    except (AssertionError, *self._ignoring) as exc:  # noqa: PERF203  # retry-on-failure needs the try/except per poll iteration
                         last_error = exc
                         if loop.time() >= deadline:
+                            # repr for ignored exceptions: their type name is the diagnostic, str() may be empty
+                            failure = str(last_error) if isinstance(last_error, AssertionError) else repr(last_error)
                             raise AssertionError(
-                                f"Expected condition not met after {self._timeout:.1f} seconds."
-                                f" Last failure: {last_error}"
+                                f"Expected condition not met after {self._timeout:.1f} seconds. Last failure: {failure}"
                             ) from last_error
                         await asyncio.sleep(self._interval)
 

{assertpy2-2.12.0 → assertpy2-2.13.0}/assertpy2/base.py

@@ -4,7 +4,13 @@ import collections.abc
 import dataclasses
 from typing import TYPE_CHECKING, Any, Final
 
-from ._compare import _build_compare_config, _node_decision
+from ._compare import (
+    _ambiguous_array_operand,
+    _array_equality_error,
+    _build_compare_config,
+    _guarded_not_equal,
+    _node_decision,
+)
 from ._introspection import is_mapping_like, is_model_dump_object, is_namedtuple
 from ._mixin_base import _MixinBase
 from .errors import DiffEntry, DiffResult
@@ -20,34 +26,6 @@ __tracebackhide__ = True
 _SENTINEL: Final = object()
 
 
-def _ambiguous_array_operand(value: object, other: object) -> object | None:
-    """Return the array/frame-like operand whose ``==`` has no single truth value, else ``None``.
-
-    numpy/pandas/polars containers expose ``__array__`` and compare element-wise, so ``bool(a == b)``
-    raises rather than yielding one bool (and a ``DataFrame`` also quacks dict-like, which would otherwise
-    mis-dispatch the comparison).  The ``__array__`` gate keeps the extra comparison off the hot path; the
-    truth test is actually attempted, so 0-d / scalar array values (which *are* truth-testable) pass
-    through unchanged.
-    """
-    for candidate, counterpart in ((value, other), (other, value)):
-        if hasattr(candidate, "__array__"):
-            try:
-                bool(candidate == counterpart)
-            except (ValueError, TypeError):
-                return candidate
-    return None
-
-
-def _array_equality_error(method: str, operand: object) -> TypeError:
-    """Build the actionable error raised when ``method`` is given an element-wise array/frame-like."""
-    return TypeError(
-        f"{method}() cannot directly compare <{type(operand).__name__}>: its '==' is element-wise and has"
-        " no single truth value. Compare the value's own equality (e.g."
-        " assert_that(actual.equals(expected)).is_true()), assert on extracted scalars (columns, shape,"
-        " length), or use satisfies(...) with an explicit predicate."
-    )
-
-
 class BaseMixin(_MixinBase):
     """Base mixin."""
 
@@ -149,7 +127,7 @@ class BaseMixin(_MixinBase):
 
                 # by type, or by field name (field name wins over type)
                 assert_that(actual).is_equal_to(expected, comparators={float: lambda a, e: round(a, 2) == round(e, 2)})
-                assert_that(actual).is_equal_to(expected, comparators={"created_at": lambda a, e: True})
+                assert_that(actual).is_equal_to(expected, comparators={"name": lambda a, e: a.lower() == e.lower()})
 
             Ignore fields by regex or by type:
 
@@ -170,9 +148,10 @@ class BaseMixin(_MixinBase):
             AssertionError: if actual is **not** equal to expected
             TypeError: if ``ignore``/``include`` is a one-shot or otherwise unsupported iterable, or is
                 used on a value that is neither dict-like nor has introspectable fields; if ``tolerance`` is
-                not a real number or ``comparators`` is not a dict of callables; or if val or other is an
-                element-wise array/frame-like (numpy/pandas/polars) whose ``==`` has no single truth value
-                (compare the value's own equality, e.g. ``actual.equals(expected)``, instead)
+                not a real number or ``comparators`` is not a dict of callables; or if val or other is (or
+                contains, at any nesting depth) an element-wise array/frame-like (numpy/pandas/polars) whose
+                ``==`` has no single truth value (compare the value's own equality, e.g.
+                ``actual.equals(expected)``, instead)
             ValueError: if ``tolerance`` is ``NaN`` or negative
 
         Tip:
@@ -219,7 +198,7 @@ class BaseMixin(_MixinBase):
                     diff=diff,
                 )
         else:
-            if self.val != other:
+            if _guarded_not_equal(self.val, other):
                 diff = self._build_equality_diff(self.val, other)
                 return self.error(
                     f"Expected <{self.val}> to be equal to <{other}>, but was not.",

{assertpy2-2.12.0 → assertpy2-2.13.0}/assertpy2/helpers.py

@@ -7,7 +7,7 @@ import re
 
 from assertpy2.errors import DiffResult
 
-from ._compare import _CompareConfig, _node_decision, _spec_matches
+from ._compare import _CompareConfig, _guarded_not_equal, _node_decision, _spec_matches
 from ._introspection import is_attrs_instance, is_model_dump_object, is_namedtuple
 from ._mixin_base import _MixinBase
 
@@ -138,7 +138,7 @@ class HelpersMixin(_MixinBase):
         _seen = _seen | {pair}
 
         if not (ignore or include or config is not None):
-            return val != other
+            return _guarded_not_equal(val, other)
 
         ignores = []  # bound for the nested-recursion use below; only read when ``ignore`` is set
         if ignore or include:
@@ -210,7 +210,7 @@ class HelpersMixin(_MixinBase):
                 )
                 if subdicts_not_equal:
                     return True
-            elif val[key] != other[key]:
+            elif _guarded_not_equal(val[key], other[key]):
                 return True
         return False