assertpy2 2.9.0__tar.gz → 2.10.0__tar.gz

{assertpy2-2.9.0 → assertpy2-2.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.9.0
+Version: 2.10.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
@@ -62,6 +62,8 @@ Description-Content-Type: text/markdown
   <a href="https://github.com/astral-sh/ty"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json" alt="ty"></a>
   <a href="https://scorecard.dev/viewer/?uri=github.com/Solganis/assertpy2"><img src="https://api.scorecard.dev/projects/github.com/Solganis/assertpy2/badge" alt="OpenSSF Scorecard"></a>
   <a href="https://www.bestpractices.dev/projects/12990"><img src="https://www.bestpractices.dev/projects/12990/badge" alt="OpenSSF Best Practices"></a>
+  <br>
+  <a href="https://solganis.github.io/assertpy2/type-safety/"><img src="https://img.shields.io/badge/type--checked-ty%20%7C%20mypy%20%7C%20pyright-2ea043" alt="public overloads type-checked by ty, mypy --strict, and pyright with zero suppressions"></a>
 </p>
 
 ---
@@ -119,12 +121,16 @@ assertpy2 reports the [exact path to every difference](https://solganis.github.i
 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: status and user.role shown with their paths, removals in red and additions in green">
+<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">
 
 Recursive diffs work for dicts, dataclasses, namedtuples, attrs, 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.
 
+The same path-level treatment for dicts, lists, sets, and matcher predicates:
+
+<img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-gallery.png" width="640" alt="Structured diffs in the terminal: dict path, list element, set extra/missing, and structural-matcher predicate diffs, side by side">
+
 ## [Type-aware autocomplete](https://solganis.github.io/assertpy2/type-safety/)
 
 `assert_that()` uses `@overload` to return type-specific Protocols.

{assertpy2-2.9.0 → assertpy2-2.10.0}/README.md

@@ -24,6 +24,8 @@
   <a href="https://github.com/astral-sh/ty"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json" alt="ty"></a>
   <a href="https://scorecard.dev/viewer/?uri=github.com/Solganis/assertpy2"><img src="https://api.scorecard.dev/projects/github.com/Solganis/assertpy2/badge" alt="OpenSSF Scorecard"></a>
   <a href="https://www.bestpractices.dev/projects/12990"><img src="https://www.bestpractices.dev/projects/12990/badge" alt="OpenSSF Best Practices"></a>
+  <br>
+  <a href="https://solganis.github.io/assertpy2/type-safety/"><img src="https://img.shields.io/badge/type--checked-ty%20%7C%20mypy%20%7C%20pyright-2ea043" alt="public overloads type-checked by ty, mypy --strict, and pyright with zero suppressions"></a>
 </p>
 
 ---
@@ -81,12 +83,16 @@ assertpy2 reports the [exact path to every difference](https://solganis.github.i
 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: status and user.role shown with their paths, removals in red and additions in green">
+<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">
 
 Recursive diffs work for dicts, dataclasses, namedtuples, attrs, 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.
 
+The same path-level treatment for dicts, lists, sets, and matcher predicates:
+
+<img src="https://raw.githubusercontent.com/Solganis/assertpy2/main/docs/assets/diff-gallery.png" width="640" alt="Structured diffs in the terminal: dict path, list element, set extra/missing, and structural-matcher predicate diffs, side by side">
+
 ## [Type-aware autocomplete](https://solganis.github.io/assertpy2/type-safety/)
 
 `assert_that()` uses `@overload` to return type-specific Protocols.

{assertpy2-2.9.0 → assertpy2-2.10.0}/assertpy2/assertpy.py

@@ -48,7 +48,7 @@ from .snapshot import SnapshotMixin
 from .string import StringMixin
 from .warning import WarningMixin
 
-__version__ = "2.9.0"
+__version__ = "2.10.0"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch

{assertpy2-2.9.0 → assertpy2-2.10.0}/assertpy2/base.py

@@ -187,6 +187,58 @@ class BaseMixin(_MixinBase):
                     expected=expected_item,
                 )
 
+    @staticmethod
+    def _sequence_diff_entries(actual, expected, prefix, seen) -> list[DiffEntry]:
+        """Diff two sequences element-by-element, recursing into nested containers.
+
+        ``seen`` must already include the ids of ``actual``/``expected`` so a self-referential element
+        is caught.  Shared by the top-level (:meth:`_build_equality_diff`) and nested
+        (:meth:`_sub_diff_entries`) paths so both decompose sequences identically.
+        """
+        entries: list[DiffEntry] = []
+        max_len = max(len(actual), len(expected))
+        for i in range(max_len):
+            path = f"{prefix}[{i}]" if prefix else f"[{i}]"
+            if i >= len(actual):
+                entries.append(DiffEntry(path=path, actual=None, expected=expected[i]))
+            elif i >= len(expected):
+                entries.append(DiffEntry(path=path, actual=actual[i], expected=None))
+            elif actual[i] != expected[i]:
+                sub_entries = BaseMixin._sub_diff_entries(actual[i], expected[i], path, _seen=seen)
+                if sub_entries:
+                    entries.extend(sub_entries)
+                else:
+                    entries.append(DiffEntry(path=path, actual=actual[i], expected=expected[i]))
+        return entries
+
+    @staticmethod
+    def _dataclass_diff_entries(actual, expected, prefix, seen) -> list[DiffEntry]:
+        """Diff two dataclasses over the sorted union of field names, both directions, recursing.
+
+        Reports fields present on only one side, and recurses into nested containers.  ``seen`` must
+        already include the ids of ``actual``/``expected``.  Shared by the top-level and nested paths
+        so both report dataclass fields identically.
+        """
+        entries: list[DiffEntry] = []
+        actual_names = {field.name for field in dataclasses.fields(actual)}
+        expected_names = {field.name for field in dataclasses.fields(expected)}
+        for field in sorted(actual_names | expected_names):
+            path = f"{prefix}.{field}"
+            if field not in expected_names:
+                entries.append(DiffEntry(path=path, actual=getattr(actual, field), expected=None))
+            elif field not in actual_names:
+                entries.append(DiffEntry(path=path, actual=None, expected=getattr(expected, field)))
+            else:
+                actual_value = getattr(actual, field)
+                expected_value = getattr(expected, field)
+                if actual_value != expected_value:
+                    sub_entries = BaseMixin._sub_diff_entries(actual_value, expected_value, path, _seen=seen)
+                    if sub_entries is not None:
+                        entries.extend(sub_entries)
+                    else:
+                        entries.append(DiffEntry(path=path, actual=actual_value, expected=expected_value))
+        return entries
+
     @staticmethod
     def _build_equality_diff(
         actual: object, expected: object, *, _prefix: str = "", _seen: set[int] | None = None
@@ -229,21 +281,10 @@ class BaseMixin(_MixinBase):
             and dataclasses.is_dataclass(expected)
             and not isinstance(expected, type)
         ):
-            entries = []
-            actual_names = {field.name for field in dataclasses.fields(actual)}
-            expected_names = {field.name for field in dataclasses.fields(expected)}
-            for field in sorted(actual_names | expected_names):
-                path = f"{_prefix}.{field}"
-                if field not in expected_names:
-                    entries.append(DiffEntry(path=path, actual=getattr(actual, field), expected=None))
-                elif field not in actual_names:
-                    entries.append(DiffEntry(path=path, actual=None, expected=getattr(expected, field)))
-                else:
-                    actual_value = getattr(actual, field)
-                    expected_value = getattr(expected, field)
-                    if actual_value != expected_value:
-                        entries.extend(_field_entries(actual_value, expected_value, path))
-            return DiffResult(kind="dataclass", entries=entries)
+            return DiffResult(
+                kind="dataclass",
+                entries=BaseMixin._dataclass_diff_entries(actual, expected, _prefix, _seen),
+            )
         if is_model_dump_object(actual) and is_model_dump_object(expected):
             actual_dict = actual.model_dump()
             expected_dict = expected.model_dump()
@@ -262,21 +303,10 @@ class BaseMixin(_MixinBase):
                         entries.append(DiffEntry(path=path, actual=actual_dict[key], expected=expected_dict[key]))
             return DiffResult(kind="model", entries=entries)
         if isinstance(actual, (list, tuple)) and isinstance(expected, (list, tuple)):
-            entries = []
-            max_len = max(len(actual), len(expected))
-            for i in range(max_len):
-                path = f"{_prefix}[{i}]" if _prefix else f"[{i}]"
-                if i >= len(actual):
-                    entries.append(DiffEntry(path=path, actual=None, expected=expected[i]))
-                elif i >= len(expected):
-                    entries.append(DiffEntry(path=path, actual=actual[i], expected=None))
-                elif actual[i] != expected[i]:
-                    sub_entries = BaseMixin._sub_diff_entries(actual[i], expected[i], path, _seen=_seen)
-                    if sub_entries:
-                        entries.extend(sub_entries)
-                    else:
-                        entries.append(DiffEntry(path=path, actual=actual[i], expected=expected[i]))
-            return DiffResult(kind="sequence", entries=entries)
+            return DiffResult(
+                kind="sequence",
+                entries=BaseMixin._sequence_diff_entries(actual, expected, _prefix, _seen),
+            )
         if isinstance(actual, (set, frozenset)) and isinstance(expected, (set, frozenset)):
             entries = []
             for item in sorted(actual - expected, key=repr):
@@ -333,23 +363,7 @@ class BaseMixin(_MixinBase):
             and not isinstance(expected, type)
         ):
             child_seen = _seen | {id(actual), id(expected)}
-            entries = []
-            for field in dataclasses.fields(actual):
-                actual_value = getattr(actual, field.name)
-                expected_value = getattr(expected, field.name, _SENTINEL)
-                if expected_value is _SENTINEL:
-                    entries.append(DiffEntry(path=f"{prefix}.{field.name}", actual=actual_value, expected=None))
-                elif actual_value != expected_value:
-                    sub_entries = BaseMixin._sub_diff_entries(
-                        actual_value, expected_value, f"{prefix}.{field.name}", _seen=child_seen
-                    )
-                    if sub_entries is not None:
-                        entries.extend(sub_entries)
-                    else:
-                        entries.append(
-                            DiffEntry(path=f"{prefix}.{field.name}", actual=actual_value, expected=expected_value)
-                        )
-            return entries or None
+            return BaseMixin._dataclass_diff_entries(actual, expected, prefix, child_seen) or None
         if is_namedtuple(actual) and is_namedtuple(expected):
             child_seen = _seen | {id(actual), id(expected)}
             entries = []
@@ -394,6 +408,9 @@ class BaseMixin(_MixinBase):
                     else:
                         entries.append(DiffEntry(path=path, actual=actual_dict[key], expected=expected_dict[key]))
             return entries or None
+        if isinstance(actual, (list, tuple)) and isinstance(expected, (list, tuple)):
+            child_seen = _seen | {id(actual), id(expected)}
+            return BaseMixin._sequence_diff_entries(actual, expected, prefix, child_seen) or None
         return None
 
     def satisfies(self, matcher) -> Self:
@@ -488,11 +505,12 @@ class BaseMixin(_MixinBase):
         return self
 
     def matches_structure(self, spec: dict[Any, Any]) -> Self:
-        """Asserts that val is a dict matching the given structure specification.
+        """Asserts that val matches the given structure specification.
 
-        Each key in ``spec`` maps to either a :class:`~assertpy2.matchers.Matcher`, a raw value
-        (checked via ``==``), or a nested ``dict`` for recursive matching.  Extra keys in val
-        that are absent from the spec are allowed.
+        ``val`` may be a dict or a pydantic-style model (anything exposing ``model_dump()``), which is
+        normalized to its dict before matching.  Each key in ``spec`` maps to either a
+        :class:`~assertpy2.matchers.Matcher`, a raw value (checked via ``==``), or a nested ``dict``
+        for recursive matching.  Extra keys in val that are absent from the spec are allowed.
 
         Args:
             spec: a dict where values can be Matcher instances, raw values, or nested dicts
@@ -515,7 +533,7 @@ class BaseMixin(_MixinBase):
         Raises:
             AssertionError: if val does **not** match the structure spec
         """
-        if not isinstance(self.val, dict):
+        if not isinstance(self.val, dict) and not is_model_dump_object(self.val):
             raise TypeError("val must be a dict")
         if not isinstance(spec, dict):
             raise TypeError("given arg must be a dict")

{assertpy2-2.9.0 → assertpy2-2.10.0}/assertpy2/extracting.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import collections.abc
 from typing import TYPE_CHECKING
 
-from ._introspection import is_namedtuple
+from ._introspection import is_model_dump_object, is_namedtuple
 from ._mixin_base import _MixinBase
 
 if TYPE_CHECKING:
@@ -155,7 +155,7 @@ class ExtractingMixin(_MixinBase):
                     return getattr(item, name)
                 else:  # val has no attribute <foo>
                     raise ValueError(f"item attributes {item._fields} did not contain attribute <{name}>")
-            elif isinstance(item, collections.abc.Iterable):
+            elif isinstance(item, collections.abc.Iterable) and not is_model_dump_object(item):
                 self._check_iterable(item, name="item")
                 return item[name]
             elif hasattr(item, name):

{assertpy2-2.9.0 → assertpy2-2.10.0}/assertpy2/matchers.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 import re
 import threading
 import uuid as _uuid_mod
-from typing import TYPE_CHECKING, Any, Final, Protocol, runtime_checkable
+from typing import TYPE_CHECKING, Any, Final, NamedTuple, Protocol, runtime_checkable
+
+from ._introspection import is_model_dump_object
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -548,95 +550,95 @@ def _describe_spec_value(value: object) -> str:
     return f"<{value}>"
 
 
+class _SpecMismatch(NamedTuple):
+    """One structural mismatch produced by a single spec walk.
+
+    ``expected_desc`` is the public "expected" half (as exposed by ``collect_mismatches``); ``detail``
+    carries a matcher's ``describe_mismatch(actual)`` so fail-fast failure text keeps its per-value
+    detail without a second traversal.
+    """
+
+    path: str
+    actual: object
+    expected_desc: str
+    detail: str | None
+
+
 class StructureMatcher(BaseMatcher):
-    """Matches dicts against a structure spec where values are matchers, raw values, or nested dicts."""
+    """Matches dicts (or pydantic-style models via ``model_dump()``) against a structure spec whose
+    values are matchers, raw values, or nested dicts."""
 
     def __init__(self, spec: dict[Any, Any]):
         self._spec = spec
 
+    @staticmethod
+    def _as_mapping(value: Any) -> Any:
+        """Normalize a pydantic-style model (anything exposing ``model_dump()``) to its dict, so a
+        model can be matched structurally just like a plain dict; pass other values through."""
+        return value.model_dump() if is_model_dump_object(value) else value
+
     def matches(self, value: Any) -> bool:
+        value = self._as_mapping(value)
         if not isinstance(value, dict):
             return False
-        return self._match_recursive(value, self._spec, "", set()) is None
+        return not self._walk(value, self._spec, "", set())
 
     def describe(self) -> str:
         return f"a dict matching structure {_describe_spec_value(self._spec)}"
 
     def describe_mismatch(self, value: Any) -> str:
+        value = self._as_mapping(value)
         if not isinstance(value, dict):
             return f"was not a dict: <{value}>"
-        error = self._match_recursive(value, self._spec, "", set())
-        if error:
-            return error
-        return f"was <{value}>"
-
-    def _match_recursive(
-        self, value: dict[Any, Any], spec: dict[Any, Any], path: str, seen: set[tuple[int, int]]
-    ) -> str | None:
-        pair_id = (id(value), id(spec))
-        if pair_id in seen:
-            return f"circular reference detected at <{path or 'root'}>"
-        seen.add(pair_id)
-        for key, expected in spec.items():
-            current_path = f"{path}.{key}" if path else str(key)
-            if key not in value:
-                return f"missing key <{current_path}>"
-            actual = value[key]
-            if isinstance(expected, StructureMatcher):
-                if not isinstance(actual, dict):
-                    return f"at <{current_path}>: expected a dict, but was <{actual}>"
-                error = self._match_recursive(actual, expected._spec, current_path, seen)
-                if error:
-                    return error
-            elif isinstance(expected, Matcher):
-                if not expected.matches(actual):
-                    return (
-                        f"at <{current_path}>: expected {expected.describe()}, but {expected.describe_mismatch(actual)}"
-                    )
-            elif isinstance(expected, dict):
-                if not isinstance(actual, dict):
-                    return f"at <{current_path}>: expected a dict, but was <{actual}>"
-                error = self._match_recursive(actual, expected, current_path, seen)
-                if error:
-                    return error
-            elif actual != expected:
-                return f"at <{current_path}>: expected <{expected}>, but was <{actual}>"
-        return None
-
-    def collect_mismatches(self, value: dict[Any, Any]) -> list[tuple[str, object, str]]:
+        mismatches = self._walk(value, self._spec, "", set())
+        if not mismatches:
+            return f"was <{value}>"
+        first = mismatches[0]
+        if first.actual is _MISSING:
+            return f"missing key <{first.path}>"
+        if first.expected_desc == "<circular ref>":  # cycle sentinel emitted by _walk
+            return f"circular reference detected at <{first.path}>"
+        if first.detail is not None:
+            return f"at <{first.path}>: expected {first.expected_desc}, but {first.detail}"
+        return f"at <{first.path}>: expected {first.expected_desc}, but was <{first.actual}>"
+
+    def collect_mismatches(self, value: Any) -> list[tuple[str, object, str]]:
         """Collect every structural mismatch as ``(path, actual, expected_description)``.
 
         Unlike :meth:`describe_mismatch`, this does not stop at the first failure and joins nested
         paths, so callers can build a path-level :class:`~assertpy2.errors.DiffResult`.
         """
-        return self._collect(value, self._spec, "", set())
+        value = self._as_mapping(value)
+        return [(m.path, m.actual, m.expected_desc) for m in self._walk(value, self._spec, "", set())]
 
-    def _collect(
+    def _walk(
         self, value: dict[Any, Any], spec: dict[Any, Any], path: str, seen: set[tuple[int, int]]
-    ) -> list[tuple[str, object, str]]:
+    ) -> list[_SpecMismatch]:
         pair_id = (id(value), id(spec))
         if pair_id in seen:
-            return [(path or "root", "<circular ref>", "<circular ref>")]
+            return [_SpecMismatch(path or "root", "<circular ref>", "<circular ref>", None)]
         seen = seen | {pair_id}
-        mismatches: list[tuple[str, object, str]] = []
+        mismatches: list[_SpecMismatch] = []
         for key, expected in spec.items():
             current_path = f"{path}.{key}" if path else str(key)
             if key not in value:
-                mismatches.append((current_path, _MISSING, _describe_spec_value(expected)))
+                mismatches.append(_SpecMismatch(current_path, _MISSING, _describe_spec_value(expected), None))
                 continue
             actual = value[key]
             if isinstance(expected, StructureMatcher) and isinstance(actual, dict):
-                mismatches.extend(self._collect(actual, expected._spec, current_path, seen))
+                mismatches.extend(self._walk(actual, expected._spec, current_path, seen))
             elif isinstance(expected, Matcher):
                 if not expected.matches(actual):
-                    mismatches.append((current_path, actual, expected.describe()))
+                    mismatches.append(
+                        _SpecMismatch(current_path, actual, expected.describe(), expected.describe_mismatch(actual))
+                    )
             elif isinstance(expected, dict):
                 if isinstance(actual, dict):
-                    mismatches.extend(self._collect(actual, expected, current_path, seen))
+                    mismatches.extend(self._walk(actual, expected, current_path, seen))
                 else:
-                    mismatches.append((current_path, actual, "a dict"))
+                    mismatches.append(_SpecMismatch(current_path, actual, "a dict", None))
             elif actual != expected:
-                mismatches.append((current_path, actual, f"<{expected}>"))
+                mismatches.append(_SpecMismatch(current_path, actual, f"<{expected}>", None))
         return mismatches
 
 

{assertpy2-2.9.0 → assertpy2-2.10.0}/docs/assertions.md

@@ -335,7 +335,7 @@ assert_that(people).extracting("name").contains("Fred Smith", "Bob Barr")
 assert_that(people).extracting("say_hello").contains("Hello, Fred!", "Hello, Bob!")  # method
 ```
 
-It also works on collections of dicts (extracting by key) and across subclasses in a mixed collection.
+It also works on collections of dicts (extracting by key), Pydantic models, and across subclasses in a mixed collection.
 
 #### Filtering
 

assertpy2-2.10.0/docs/assets/diff-equal.svg

@@ -0,0 +1,51 @@
+<svg width="250" height="120" viewBox="0 0 250 119.6" xmlns="http://www.w3.org/2000/svg">
+    <style>
+
+    .terminal-346716669-matrix {
+        font-family: Fira Code, monospace;
+        font-size: 20px;
+        line-height: 24.4px;
+        font-variant-east-asian: full-width;
+    }
+
+    .terminal-346716669-title {
+        font-size: 18px;
+        font-weight: bold;
+        font-family: arial;
+    }
+
+    .terminal-346716669-r1 { fill: #68a0b3 }
+.terminal-346716669-r2 { fill: #c5c8c6 }
+.terminal-346716669-r3 { fill: #cc555a }
+.terminal-346716669-r4 { fill: #98a84b }
+    </style>
+
+    <defs>
+    <clipPath id="terminal-346716669-clip-terminal">
+      <rect x="0" y="0" width="230.79999999999998" height="96.6" />
+    </clipPath>
+    <clipPath id="terminal-346716669-line-0">
+    <rect x="0" y="1.5" width="231.8" height="24.65"/>
+            </clipPath>
+<clipPath id="terminal-346716669-line-1">
+    <rect x="0" y="25.9" width="231.8" height="24.65"/>
+            </clipPath>
+<clipPath id="terminal-346716669-line-2">
+    <rect x="0" y="50.3" width="231.8" height="24.65"/>
+            </clipPath>
+    </defs>
+
+    <rect fill="#292929" stroke="rgba(255,255,255,0.35)" stroke-width="1" x="1" y="1" width="248" height="117.6" rx="8"/>
+            
+        
+    <g transform="translate(9, 13)" clip-path="url(#terminal-346716669-clip-terminal)">
+    
+    <g class="terminal-346716669-matrix">
+    <text class="terminal-346716669-r1" x="0" y="20" textLength="146.4" clip-path="url(#terminal-346716669-line-0)">diff&#160;(dict):</text><text class="terminal-346716669-r2" x="231.8" y="20" textLength="12.2" clip-path="url(#terminal-346716669-line-0)">
+</text><text class="terminal-346716669-r2" x="0" y="44.4" textLength="146.4" clip-path="url(#terminal-346716669-line-1)">&#160;&#160;user.role:</text><text class="terminal-346716669-r2" x="231.8" y="44.4" textLength="12.2" clip-path="url(#terminal-346716669-line-1)">
+</text><text class="terminal-346716669-r3" x="48.8" y="68.8" textLength="170.8" clip-path="url(#terminal-346716669-line-2)">-&#160;&#x27;superadmin&#x27;</text><text class="terminal-346716669-r2" x="231.8" y="68.8" textLength="12.2" clip-path="url(#terminal-346716669-line-2)">
+</text><text class="terminal-346716669-r4" x="48.8" y="93.2" textLength="109.8" clip-path="url(#terminal-346716669-line-3)">+&#160;&#x27;admin&#x27;</text><text class="terminal-346716669-r2" x="231.8" y="93.2" textLength="12.2" clip-path="url(#terminal-346716669-line-3)">
+</text>
+    </g>
+    </g>
+</svg>

{assertpy2-2.9.0 → assertpy2-2.10.0}/docs/assets/diff-match.svg

@@ -1,5 +1,4 @@
-<svg class="rich-terminal" width="933" height="120" viewBox="0 0 933 119.6" xmlns="http://www.w3.org/2000/svg">
-    <!-- Generated with Rich https://www.textualize.io -->
+<svg width="933" height="120" viewBox="0 0 933 119.6" xmlns="http://www.w3.org/2000/svg">
     <style>
 
     .terminal-4172749894-matrix {

{assertpy2-2.9.0 → assertpy2-2.10.0}/docs/assets/diff-sequence.svg

@@ -1,5 +1,4 @@
-<svg class="rich-terminal" width="226" height="120" viewBox="0 0 226 119.6" xmlns="http://www.w3.org/2000/svg">
-    <!-- Generated with Rich https://www.textualize.io -->
+<svg width="226" height="120" viewBox="0 0 226 119.6" xmlns="http://www.w3.org/2000/svg">
     <style>
 
     .terminal-4133779467-matrix {

{assertpy2-2.9.0 → assertpy2-2.10.0}/docs/assets/diff-set.svg

@@ -1,5 +1,4 @@
-<svg class="rich-terminal" width="275" height="95" viewBox="0 0 275 95.19999999999999" xmlns="http://www.w3.org/2000/svg">
-    <!-- Generated with Rich https://www.textualize.io -->
+<svg width="275" height="95" viewBox="0 0 275 95.19999999999999" xmlns="http://www.w3.org/2000/svg">
     <style>
 
     .terminal-3363794957-matrix {

{assertpy2-2.9.0 → assertpy2-2.10.0}/docs/comparison.md

@@ -117,6 +117,19 @@ Only assertpy2 prints the path (`user.role`) and the exact predicate that failed
 assertpy2 `==` form both hand rendering to pytest, which dumps the whole differing container for you to
 scan. The fluent form trades the zero-import convenience of `==` for a path-level diff.
 
+### With a Pydantic model
+
+When the value is a Pydantic model, `matches_structure()` accepts it directly, with no `.model_dump()`
+step, and prints a path-level diff just like the one above:
+
+```python
+assert_that(user).matches_structure({"role": match.is_in("admin", "user")})
+```
+
+dirty-equals cannot compare a model against a spec dict, because Pydantic's `__eq__` only matches another
+model. You dump it first (`assert user.model_dump() == {"role": IsOneOf("admin", "user")}`), and pytest
+again dumps the whole differing container. assertpy2 keeps a path-level diff on a model.
+
 ## Style and typing
 
 | | pytest assert | PyHamcrest | assertpy | dirty-equals | **assertpy2** |
@@ -161,7 +174,7 @@ scan. The fluent form trades the zero-import convenience of `==` for a path-leve
 
 | | pytest assert | PyHamcrest | assertpy | dirty-equals | **assertpy2** |
 |---|:---:|:---:|:---:|:---:|:---:|
-| Latest release | built-in | 2.1.0 | 1.1 (2020) | 0.9.0 | **2.9.0** |
+| Maintained | built-in | Yes | No (since 2020) | Yes | **Yes** |
 | Property-based tests | n/a | No | No | No | **Yes** |
 | Runtime dependencies | **none** | **none** | **none** | **none** | **none on 3.11+** |
 | License | MIT | BSD | BSD | MIT | BSD-3 |

{assertpy2-2.9.0 → assertpy2-2.10.0}/docs/errors.md

@@ -39,7 +39,7 @@ rendered by the plugin as colored diff sections.
 
 | Type | Diff kind | How it works |
 |---|---|---|
-| `list`, `tuple` | `sequence` | Element-by-element, recursive into nested dicts/dataclasses/models |
+| `list`, `tuple` | `sequence` | Element-by-element, recursive into nested dicts, lists, dataclasses, and models |
 | `set`, `frozenset` | `set` | Extra and missing items |
 | `str` | `string` | Line-by-line comparison |
 | `dict` | `dict` | Key-by-key, recursive into nested dicts and lists |

{assertpy2-2.9.0 → assertpy2-2.10.0}/docs/getting-started.md

@@ -43,7 +43,7 @@ straight at the differing field instead of dumping the whole value:
 assert_that(actual).is_equal_to(expected)
 ```
 
-![Colored dict diff: status and user.role shown with their paths, removals in red and additions in green](assets/diff-equal.svg)
+![Colored dict diff: user.role shown with its path, removal in red and addition in green](assets/diff-equal.svg)
 
 The same path-level diff backs `matches_structure()`, `satisfies()`, and `each()`. See
 [Errors & Reporting](errors.md) for the full diff format and configuration.

{assertpy2-2.9.0 → assertpy2-2.10.0}/docs/index.md

@@ -12,7 +12,7 @@ rich structural diffs on failure.
   ones, and a type checker rejects `assert_that("foo").is_positive()` before the test runs. The core
   advantage over `assertpy` and most alternatives - [see how it works](type-safety.md).
 - **Composable matchers.** `match.greater_than(5)`, `match.is_uuid()`, combined with `&`, `|`, `~`.
-- **Structural matching.** Declarative validation of dicts and API responses, with the exact path to each mismatch on failure.
+- **Structural matching.** Declarative validation of dicts, Pydantic models, and API responses, with the exact path to each mismatch on failure.
 - **Soft and async assertions.** Collect multiple failures; poll for eventual consistency with `eventually()`.
 - **Structured failures.** `AssertionFailure` exposes `.actual`, `.expected`, and `.diff`; the pytest plugin
   renders recursive diffs for lists, dicts, dataclasses, namedtuples, and Pydantic models.

{assertpy2-2.9.0 → assertpy2-2.10.0}/docs/matchers.md

@@ -124,7 +124,7 @@ assert 42 == (match.is_positive() & match.less_than(100))
 | `match.is_non_empty_string()` | a non-empty string |
 | `match.ignore()` | anything (placeholder for structural matching) |
 | `match.each_item(matcher)` | an iterable whose every item matches `matcher` |
-| `match.structure(spec)` | a dict matching a nested `spec` |
+| `match.structure(spec)` | a dict or model matching a nested `spec` |
 | `match.all_of(*matchers)` | a value matching all of `matchers` |
 | `match.any_of(*matchers)` | a value matching any of `matchers` |
 | `match.not_(matcher)` | a value not matching `matcher` |
@@ -153,6 +153,30 @@ assert_that(response).matches_structure({
 })
 ```
 
+The value under test can be a plain dict or a Pydantic model (anything exposing `model_dump()`); a
+model is normalized to its dict before matching, so the same spec works either way, including inside
+`satisfies()` and the `==` form:
+
+```python
+from pydantic import BaseModel
+
+class User(BaseModel):
+    id: str
+    name: str
+
+user = User(id="550e8400-e29b-41d4-a716-446655440000", name="Alice")
+
+assert_that(user).matches_structure({"id": match.is_uuid(), "name": match.equal_to("Alice")})
+assert_that(user).satisfies(match.structure({"id": match.is_uuid()}))
+assert user == match.structure({"id": match.is_uuid()})
+```
+
+!!! note
+    A model is matched in its `model_dump()` form: nested models become dicts, `@field_serializer` and
+    `@computed_field` outputs are applied, and spec keys are the model's field names (not aliases). The
+    spec is matched against this serialized shape, not the live attributes. This is a runtime structural
+    check; the spec keys and values are not type-checked against the model's schema.
+
 ### Nested structures
 
 Use `match.structure()` for nested dicts:

{assertpy2-2.9.0 → assertpy2-2.10.0}/docs/type-safety.md

@@ -42,9 +42,14 @@ assert_that("foo").is_positive()        # type error: is_positive is not a strin
 assert_that(42).is_instance_of("int")   # type error: expected `type`, got `str`
 ```
 
-[ty](https://github.com/astral-sh/ty), [Pyright](https://github.com/microsoft/pyright), and
-[Mypy](https://github.com/python/mypy) all report these in the editor and in CI, turning a class of test
-bugs into errors you see while typing.
+[ty](https://github.com/astral-sh/ty), [mypy `--strict`](https://github.com/python/mypy), and
+[Pyright](https://github.com/microsoft/pyright) all report these in the editor and in CI, turning a class
+of test bugs into errors you see while typing.
+
+Every public `assert_that` overload is pinned by an `assert_type` check in
+[`tests/test_typing.py`](https://github.com/Solganis/assertpy2/blob/main/tests/test_typing.py); CI runs all
+three checkers against that file on every push, with **zero suppressions**, so a regression that broadens or
+changes a return type fails the build. `ty` additionally type-checks the whole package.
 
 !!! note "Callables and captured values stay typed too"
     `assert_that(func).raises(...).when_called_with(...)` exposes string assertions on the captured