assertpy2 2.11.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.11.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.11.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.11.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.11.0 → assertpy2-2.13.0}/.github/workflows/mutation.yml

@@ -19,9 +19,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        module: [base, numeric, string, contains, collection, dict, date, matchers, helpers]
+        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,12 +29,12 @@ 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"
 
       - name: Install dependencies
-        run: uv sync --extra json --group mutation
+        run: uv sync --extra json --extra behave --group mutation
 
       - name: Run mutation testing
         env:

{assertpy2-2.11.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.11.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.11.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.11.0 → assertpy2-2.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.11.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
@@ -135,7 +135,7 @@ assert_that(response).is_equal_to(expected)
   <img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-equal.png" width="300" alt="Structured diff in the terminal: user.role shown with its path, removal in red and addition in green">
 </p>
 
-Recursive diffs work for dicts, dataclasses, namedtuples, attrs, and Pydantic models.
+Recursive diffs work for dicts, dataclasses, namedtuples, and Pydantic models.
 For responses with dynamic fields (IDs, timestamps), validate a subset with
 [`matches_structure()`](https://solganis.github.io/assertpy2/matchers/#structural-matching) instead of exact equality.
 
@@ -160,16 +160,16 @@ Your IDE shows only methods relevant to the value you're testing, not all 100+:
 
 See the [**Type Safety**](https://solganis.github.io/assertpy2/type-safety/) guide for the full walkthrough.
 
----
-
 <h2 align="center">Features</h2>
 
 **Fluent API**
 
 - [**Composable matchers**](https://solganis.github.io/assertpy2/matchers/): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~`. Also work with plain `assert ==`.
 - [**Structural matching**](https://solganis.github.io/assertpy2/matchers/#structural-matching): `matches_structure()` for declarative dict/API response validation, reporting the exact path to each mismatch on failure.
+- [**Recursive field assertions**](https://solganis.github.io/assertpy2/assertions/#recursive-field-assertions): `all_fields_satisfy()` / `has_no_none_fields()` apply a predicate to every leaf of an object graph, reporting the exact path.
 - [**Universal negation**](https://solganis.github.io/assertpy2/fluent/#universal-negation): `.not_` inverts any assertion without dedicated `is_not_*` methods.
 - [**Collection pipeline**](https://solganis.github.io/assertpy2/fluent/#collection-pipeline): `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()`.
+- [**Positional & pairwise checks**](https://solganis.github.io/assertpy2/assertions/#lists): `satisfies_exactly()`, `zip_satisfies()`, `contains_only_once()`, `has_same_size_as()`.
 - [**Fluent chaining**](https://solganis.github.io/assertpy2/fluent/#chaining): write assertions as readable one-liners that chain naturally.
 
 **Built-in types**
@@ -177,7 +177,8 @@ See the [**Type Safety**](https://solganis.github.io/assertpy2/type-safety/) gui
 - [Strings](https://solganis.github.io/assertpy2/assertions/#strings), [numbers](https://solganis.github.io/assertpy2/assertions/#numbers), [lists](https://solganis.github.io/assertpy2/assertions/#lists), [tuples](https://solganis.github.io/assertpy2/assertions/#tuples), [sets](https://solganis.github.io/assertpy2/assertions/#sets), [dicts](https://solganis.github.io/assertpy2/assertions/#dicts), [dates](https://solganis.github.io/assertpy2/assertions/#dates), [booleans](https://solganis.github.io/assertpy2/assertions/#booleans), [objects](https://solganis.github.io/assertpy2/assertions/#objects), [bytes](https://solganis.github.io/assertpy2/assertions/#bytes--bytearray), [files](https://solganis.github.io/assertpy2/assertions/#files), [exceptions](https://solganis.github.io/assertpy2/errors/#expected-exceptions).
 - [**Bytes assertions**](https://solganis.github.io/assertpy2/assertions/#bytes--bytearray): `is_valid_utf8()`, `starts_with_bytes()`, `is_hex_equal_to()`, `decoded_as()` for `bytes`/`bytearray`.
 - [**Dynamic assertions**](https://solganis.github.io/assertpy2/assertions/#dynamic-assertions-on-objects): `has_<name>()` for any attribute, property, or zero-argument method.
-- [**Dict comparison**](https://solganis.github.io/assertpy2/assertions/#selective-comparison-ignore--include): `is_equal_to()` with `ignore` and `include` for selective key/field matching (dicts, dataclasses, namedtuples, Pydantic models, attrs, plain objects).
+- [**Dict comparison**](https://solganis.github.io/assertpy2/assertions/#selective-comparison-ignore--include): `is_equal_to()` with `ignore` and `include` for selective key/field matching (dicts, dataclasses, namedtuples, Pydantic models, attrs, plain objects), including by regex or type.
+- [**Recursive comparison**](https://solganis.github.io/assertpy2/assertions/#recursive-comparison-tolerance--custom-comparators): `is_equal_to()` with `tolerance` (absolute float tolerance at any depth) or `comparators` (per-type / per-field predicates) for nested structures.
 - [**Extracting**](https://solganis.github.io/assertpy2/assertions/#extracting-attributes-from-objects): flatten collections on attributes with `filter` and `sort` support.
 
 **Testing**
@@ -202,8 +203,6 @@ See the [**Type Safety**](https://solganis.github.io/assertpy2/type-safety/) gui
 
 See the [full documentation](https://solganis.github.io/assertpy2/) for all assertion methods, examples, and advanced features.
 
----
-
 <h2 align="center"><a href="https://solganis.github.io/assertpy2/integrations/">Integrations</a></h2>
 
 Optional adapters, each its own extra; full configuration and examples are in the

{assertpy2-2.11.0 → assertpy2-2.13.0}/README.md

@@ -87,7 +87,7 @@ assert_that(response).is_equal_to(expected)
   <img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-equal.png" width="300" alt="Structured diff in the terminal: user.role shown with its path, removal in red and addition in green">
 </p>
 
-Recursive diffs work for dicts, dataclasses, namedtuples, attrs, and Pydantic models.
+Recursive diffs work for dicts, dataclasses, namedtuples, and Pydantic models.
 For responses with dynamic fields (IDs, timestamps), validate a subset with
 [`matches_structure()`](https://solganis.github.io/assertpy2/matchers/#structural-matching) instead of exact equality.
 
@@ -112,16 +112,16 @@ Your IDE shows only methods relevant to the value you're testing, not all 100+:
 
 See the [**Type Safety**](https://solganis.github.io/assertpy2/type-safety/) guide for the full walkthrough.
 
----
-
 <h2 align="center">Features</h2>
 
 **Fluent API**
 
 - [**Composable matchers**](https://solganis.github.io/assertpy2/matchers/): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~`. Also work with plain `assert ==`.
 - [**Structural matching**](https://solganis.github.io/assertpy2/matchers/#structural-matching): `matches_structure()` for declarative dict/API response validation, reporting the exact path to each mismatch on failure.
+- [**Recursive field assertions**](https://solganis.github.io/assertpy2/assertions/#recursive-field-assertions): `all_fields_satisfy()` / `has_no_none_fields()` apply a predicate to every leaf of an object graph, reporting the exact path.
 - [**Universal negation**](https://solganis.github.io/assertpy2/fluent/#universal-negation): `.not_` inverts any assertion without dedicated `is_not_*` methods.
 - [**Collection pipeline**](https://solganis.github.io/assertpy2/fluent/#collection-pipeline): `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()`.
+- [**Positional & pairwise checks**](https://solganis.github.io/assertpy2/assertions/#lists): `satisfies_exactly()`, `zip_satisfies()`, `contains_only_once()`, `has_same_size_as()`.
 - [**Fluent chaining**](https://solganis.github.io/assertpy2/fluent/#chaining): write assertions as readable one-liners that chain naturally.
 
 **Built-in types**
@@ -129,7 +129,8 @@ See the [**Type Safety**](https://solganis.github.io/assertpy2/type-safety/) gui
 - [Strings](https://solganis.github.io/assertpy2/assertions/#strings), [numbers](https://solganis.github.io/assertpy2/assertions/#numbers), [lists](https://solganis.github.io/assertpy2/assertions/#lists), [tuples](https://solganis.github.io/assertpy2/assertions/#tuples), [sets](https://solganis.github.io/assertpy2/assertions/#sets), [dicts](https://solganis.github.io/assertpy2/assertions/#dicts), [dates](https://solganis.github.io/assertpy2/assertions/#dates), [booleans](https://solganis.github.io/assertpy2/assertions/#booleans), [objects](https://solganis.github.io/assertpy2/assertions/#objects), [bytes](https://solganis.github.io/assertpy2/assertions/#bytes--bytearray), [files](https://solganis.github.io/assertpy2/assertions/#files), [exceptions](https://solganis.github.io/assertpy2/errors/#expected-exceptions).
 - [**Bytes assertions**](https://solganis.github.io/assertpy2/assertions/#bytes--bytearray): `is_valid_utf8()`, `starts_with_bytes()`, `is_hex_equal_to()`, `decoded_as()` for `bytes`/`bytearray`.
 - [**Dynamic assertions**](https://solganis.github.io/assertpy2/assertions/#dynamic-assertions-on-objects): `has_<name>()` for any attribute, property, or zero-argument method.
-- [**Dict comparison**](https://solganis.github.io/assertpy2/assertions/#selective-comparison-ignore--include): `is_equal_to()` with `ignore` and `include` for selective key/field matching (dicts, dataclasses, namedtuples, Pydantic models, attrs, plain objects).
+- [**Dict comparison**](https://solganis.github.io/assertpy2/assertions/#selective-comparison-ignore--include): `is_equal_to()` with `ignore` and `include` for selective key/field matching (dicts, dataclasses, namedtuples, Pydantic models, attrs, plain objects), including by regex or type.
+- [**Recursive comparison**](https://solganis.github.io/assertpy2/assertions/#recursive-comparison-tolerance--custom-comparators): `is_equal_to()` with `tolerance` (absolute float tolerance at any depth) or `comparators` (per-type / per-field predicates) for nested structures.
 - [**Extracting**](https://solganis.github.io/assertpy2/assertions/#extracting-attributes-from-objects): flatten collections on attributes with `filter` and `sort` support.
 
 **Testing**
@@ -154,8 +155,6 @@ See the [**Type Safety**](https://solganis.github.io/assertpy2/type-safety/) gui
 
 See the [full documentation](https://solganis.github.io/assertpy2/) for all assertion methods, examples, and advanced features.
 
----
-
 <h2 align="center"><a href="https://solganis.github.io/assertpy2/integrations/">Integrations</a></h2>
 
 Optional adapters, each its own extra; full configuration and examples are in the

{assertpy2-2.11.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.13.0/assertpy2/_compare.py

@@ -0,0 +1,222 @@
+"""Per-call configuration for tolerant / custom-comparator equality, shared by the equality and diff code.
+
+``is_equal_to`` builds a `_CompareConfig` from its ``tolerance``/``comparators`` kwargs and threads it
+through both the boolean comparison (`HelpersMixin._dict_not_equal()`) and the diff/message rendering
+(`BaseMixin._sub_diff_entries()`, `HelpersMixin._dict_err()`).  `_node_decision()` is the single
+switch both sides consult, so a tolerated or comparator-equal leaf is reported in neither.  With ``config is
+None`` every helper reproduces the engine's historical ``actual != expected`` behavior exactly.
+
+Following the package convention, the impl helpers take unannotated args (the typed public surface lives in
+`assertpy2._typing`); they operate on arbitrary user values whose operators ``numbers.Number`` cannot
+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
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class _CompareConfig:
+    """Tolerance and custom comparators for a single ``is_equal_to`` call.
+
+    ``tolerance`` is an absolute tolerance applied to real-number leaves; ``comparators`` maps a ``type`` or
+    an immediate field name to a ``(actual, expected) -> bool`` predicate that owns matching leaves.
+    """
+
+    tolerance: float | None = None
+    comparators: dict[object, Callable[[object, object], bool]] | None = None
+
+
+def _build_compare_config(tolerance, comparators) -> _CompareConfig | None:
+    """Validate the ``is_equal_to`` ``tolerance``/``comparators`` kwargs and build a config (``None`` if neither).
+
+    ``tolerance`` must be a non-negative real number (not ``bool``/``complex``/``NaN``); ``comparators`` must be a
+    dict of ``(actual, expected) -> bool`` callables keyed by ``type`` or field name.
+    """
+    if tolerance is None and comparators is None:
+        return None
+    if tolerance is not None:
+        if isinstance(tolerance, bool) or not isinstance(tolerance, numbers.Number) or isinstance(tolerance, complex):
+            raise TypeError("given tolerance arg must be a real number")
+        if math.isnan(tolerance):
+            raise ValueError("given tolerance arg must not be NaN")
+        if tolerance < 0:
+            raise ValueError("given tolerance arg must not be negative")
+    if comparators is not None:
+        if not isinstance(comparators, dict):
+            raise TypeError("given comparators arg must be a dict")
+        for comparator in comparators.values():
+            if not callable(comparator):
+                raise TypeError("each comparator must be callable")
+    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``).
+
+    Array/frame-likes are not `numbers.Number`, so they are excluded too - tolerance never triggers
+    their element-wise ``==`` that has no single truth value.
+    """
+    return isinstance(value, numbers.Number) and not isinstance(value, (bool, complex))
+
+
+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.
+    """
+    if isinstance(actual, float) and math.isnan(actual):
+        return False
+    if isinstance(expected, float) and math.isnan(expected):
+        return False
+    return abs(actual - expected) <= tolerance
+
+
+def _resolve_comparator(actual, config: _CompareConfig, *, field):
+    """Resolve the comparator owning a leaf: immediate field name first, then exact type, then ``isinstance``.
+
+    ``field`` is the leaf's immediate key/field name (``None`` for sequence elements and bare scalars, which
+    have no name).  Returns ``None`` when no comparator applies, so the caller falls back to tolerance / ``==``.
+    """
+    comparators = config.comparators
+    if comparators is None:
+        return None
+    if field is not None and not isinstance(field, type) and field in comparators:
+        return comparators[field]
+    if type(actual) in comparators:
+        return comparators[type(actual)]
+    for key, comparator in comparators.items():
+        if isinstance(key, type) and isinstance(actual, key):
+            return comparator
+    return None
+
+
+def _node_decision(actual, expected, config: _CompareConfig | None, *, field=None) -> str:
+    """Classify a node as ``"equal"``, ``"leaf"`` or ``"recurse"``.
+
+    With ``config is None`` this is exactly the engine's historical behavior: differing values ``"recurse"``
+    (to decompose into a sub-diff), equal values are ``"equal"`` (skipped); ``"leaf"`` never occurs.  With a
+    config, a matching comparator or tolerance owns the node - it is classified ``"equal"`` or ``"leaf"`` and
+    never recursed into.
+    """
+    if config is not None:
+        comparator = _resolve_comparator(actual, config, field=field)
+        if comparator is not None:
+            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 _guarded_not_equal(actual, expected) else "equal"
+
+
+def _spec_matches(key, value, specs) -> bool:
+    """Return whether a dict ``key``/``value`` matches any ignore/include ``spec``.
+
+    A spec matches by exact key equality (today's behavior), by a compiled `re.Pattern` searched
+    against ``str(key)``, or by a ``type`` the ``value`` is an instance of.  Nested-path tuples never match
+    here - they are expanded by the recursion in `HelpersMixin._dict_not_equal()`.
+    """
+    for spec in specs:
+        if isinstance(spec, re.Pattern):
+            if spec.search(str(key)):
+                return True
+        elif isinstance(spec, type):
+            if isinstance(value, spec):
+                return True
+        elif spec == key:
+            return True
+    return False

{assertpy2-2.11.0 → assertpy2-2.13.0}/assertpy2/_compat.py

@@ -1,6 +1,6 @@
 """Internal compatibility shims.
 
-``Self`` entered the standard library's :mod:`typing` in Python 3.11; on 3.10 it is provided by
+``Self`` entered the standard library's `typing` in Python 3.11; on 3.10 it is provided by
 ``typing_extensions``. Re-exporting it from one place lets every mixin import ``Self`` without repeating
 the version gate, and lets ``typing_extensions`` be dropped as a runtime dependency on Python 3.11+.
 """

{assertpy2-2.11.0 → assertpy2-2.13.0}/assertpy2/_mixin_base.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     import logging
 
+    from ._compare import _CompareConfig
     from ._compat import Self
     from .errors import DiffEntry, DiffResult
 
@@ -60,7 +61,7 @@ class _MixinBase:
 
         def _is_dict_like(
             self,
-            d: object,
+            candidate: object,
             check_keys: bool = ...,
             check_values: bool = ...,
             check_getitem: bool = ...,
@@ -68,7 +69,7 @@ class _MixinBase:
 
         def _require_dict_like(
             self,
-            d: object,
+            candidate: object,
             check_keys: bool = ...,
             check_values: bool = ...,
             check_getitem: bool = ...,
@@ -83,6 +84,7 @@ class _MixinBase:
             other: object,
             ignore: object = ...,
             include: object = ...,
+            config: _CompareConfig | None = ...,
         ) -> bool: ...
 
         def _dict_err(
@@ -91,6 +93,7 @@ class _MixinBase:
             other: object,
             ignore: object = ...,
             include: object = ...,
+            config: _CompareConfig | None = ...,
         ) -> None: ...
 
         @staticmethod
@@ -98,7 +101,12 @@ class _MixinBase:
 
         @staticmethod
         def _sub_diff_entries(
-            actual: object, expected: object, prefix: str, *, _seen: set[int] | None = ...
+            actual: object,
+            expected: object,
+            prefix: str,
+            *,
+            _seen: set[int] | None = ...,
+            config: _CompareConfig | None = ...,
         ) -> list[DiffEntry] | None: ...
 
         # NumericMixin class attrs used by HelpersMixin._validate_between_args