assertpy2 2.3.3__tar.gz → 2.3.5__tar.gz

{assertpy2-2.3.3 → assertpy2-2.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.3.3
+Version: 2.3.5
 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
@@ -160,25 +160,25 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 
 ## Features
 
-- **Composable matchers**: `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~` operators.
-- **Structural matching**: `matches_structure()` for declarative dict/API response validation.
-- **Async assertions**: `eventually()` with polling/retry for async and eventual consistency testing.
-- **Structured errors**: `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
+- [**Composable matchers**](docs/api.md#composable-matchers): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~`. Also work with plain `assert ==`.
+- [**Structural matching**](docs/api.md#structural-matching): `matches_structure()` for declarative dict/API response validation.
+- [**Async assertions**](docs/api.md#async-assertions): `eventually()` with polling/retry for async and eventual consistency testing.
+- [**Structured errors**](docs/api.md#structured-errors): `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
 - **Typed overloads**: `assert_that()` returns type-specific Protocols, IDE shows only relevant methods per type.
 - **Type safety**: `Self` return types, `py.typed` ([PEP 561](https://peps.python.org/pep-0561/)).
-- **Soft assertions**: thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
-- **Fluent chaining**: write assertions as readable one-liners that chain naturally.
-- **Dynamic assertions**: `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
-- **Dict comparison**: `is_equal_to()` with `ignore` and `include` for selective key matching.
-- **Extracting**: flatten collections on attributes with `filter` and `sort` support.
-- **File assertions**: `exists()`, `is_file()`, `is_readable()`, `is_writable()`, `is_executable()` with `pathlib.Path` support.
-- **Snapshot testing**: store and compare data structures in JSON format, inspired by Jest.
-- **Allure integration**: auto-attach structured diff and actual/expected data to Allure reports.
-- **Behave step matchers**: ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
-- **Custom matchers**: register domain-specific matchers via `register_matcher()`, composable with `&`, `|`, `~`.
-- **Regex group extraction**: `extracting_group()` and `matches_with_groups()` to assert on regex captures fluently.
-- **Extensions**: add custom assertions via `add_extension()`.
-- Strings, numbers, lists, tuples, sets, dicts, dates, booleans, objects, exceptions.
+- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
+- [**Fluent chaining**](docs/api.md#chaining): write assertions as readable one-liners that chain naturally.
+- [**Dynamic assertions**](docs/api.md#objects): `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
+- [**Dict comparison**](docs/api.md#dicts): `is_equal_to()` with `ignore` and `include` for selective key matching.
+- [**Extracting**](docs/api.md#objects): flatten collections on attributes with `filter` and `sort` support.
+- [**File assertions**](docs/api.md#files): `exists()`, `is_file()`, `is_readable()`, `is_writable()`, `is_executable()` with `pathlib.Path` support.
+- [**Snapshot testing**](docs/api.md#snapshot-testing): store and compare data structures in JSON format, inspired by Jest.
+- [**Allure integration**](docs/api.md#allure-integration): auto-attach structured diff and actual/expected data to Allure reports.
+- [**Behave step matchers**](docs/api.md#behave-step-matchers): ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
+- [**Custom matchers**](docs/api.md#custom-matchers---registering-domain-matchers): register domain-specific matchers via `register_matcher()`, composable with `&`, `|`, `~`.
+- [**Regex group extraction**](docs/api.md#regex-group-extraction): `extracting_group()` and `matches_with_groups()` to assert on regex captures fluently.
+- [**Extensions**](docs/api.md#extension-system---adding-custom-assertions): add custom assertions via `add_extension()`.
+- [Strings](docs/api.md#strings), [numbers](docs/api.md#numbers), [lists](docs/api.md#lists), [tuples](docs/api.md#tuples), [sets](docs/api.md#sets), [dicts](docs/api.md#dicts), [dates](docs/api.md#dates), [booleans](docs/api.md#booleans), [objects](docs/api.md#objects), [exceptions](docs/api.md#failure).
 
 
 ## Composable matchers
@@ -204,6 +204,15 @@ assert_that("hello").satisfies(~match.equal_to("world"))
 assert_that(150).satisfies(match.is_negative() | match.greater_than(100))
 ```
 
+Matchers also support `==` directly, so you can use them with plain `assert` or mix into dicts and lists:
+
+```py
+from assertpy2 import match
+
+assert 42 == match.is_positive()
+assert {"id": 5, "name": "Alice"} == {"id": match.is_positive(), "name": match.is_non_empty_string()}
+```
+
 Available matchers: `equal_to`, `greater_than`, `greater_than_or_equal_to`, `less_than`, `less_than_or_equal_to`, `between`, `close_to`, `is_none`, `is_not_none`, `is_instance_of`, `has_length`, `is_empty`, `is_not_empty`, `is_positive`, `is_negative`, `is_zero`, `is_even`, `is_odd`, `is_divisible_by`, `is_callable`, `is_in`, `has_property`, `contains_string`, `matches_regex`, `is_uuid`, `is_non_empty_string`, `ignore`, `each_item`, `structure`.
 
 

{assertpy2-2.3.3 → assertpy2-2.3.5}/README.md

@@ -125,25 +125,25 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 
 ## Features
 
-- **Composable matchers**: `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~` operators.
-- **Structural matching**: `matches_structure()` for declarative dict/API response validation.
-- **Async assertions**: `eventually()` with polling/retry for async and eventual consistency testing.
-- **Structured errors**: `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
+- [**Composable matchers**](docs/api.md#composable-matchers): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~`. Also work with plain `assert ==`.
+- [**Structural matching**](docs/api.md#structural-matching): `matches_structure()` for declarative dict/API response validation.
+- [**Async assertions**](docs/api.md#async-assertions): `eventually()` with polling/retry for async and eventual consistency testing.
+- [**Structured errors**](docs/api.md#structured-errors): `AssertionFailure` with `.actual`, `.expected`, `.diff` attributes, pytest plugin with rich diff output.
 - **Typed overloads**: `assert_that()` returns type-specific Protocols, IDE shows only relevant methods per type.
 - **Type safety**: `Self` return types, `py.typed` ([PEP 561](https://peps.python.org/pep-0561/)).
-- **Soft assertions**: thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
-- **Fluent chaining**: write assertions as readable one-liners that chain naturally.
-- **Dynamic assertions**: `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
-- **Dict comparison**: `is_equal_to()` with `ignore` and `include` for selective key matching.
-- **Extracting**: flatten collections on attributes with `filter` and `sort` support.
-- **File assertions**: `exists()`, `is_file()`, `is_readable()`, `is_writable()`, `is_executable()` with `pathlib.Path` support.
-- **Snapshot testing**: store and compare data structures in JSON format, inspired by Jest.
-- **Allure integration**: auto-attach structured diff and actual/expected data to Allure reports.
-- **Behave step matchers**: ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
-- **Custom matchers**: register domain-specific matchers via `register_matcher()`, composable with `&`, `|`, `~`.
-- **Regex group extraction**: `extracting_group()` and `matches_with_groups()` to assert on regex captures fluently.
-- **Extensions**: add custom assertions via `add_extension()`.
-- Strings, numbers, lists, tuples, sets, dicts, dates, booleans, objects, exceptions.
+- [**Soft assertions**](docs/api.md#soft-assertions): thread-safe and async-safe via `contextvars`, collect all failures with `soft_assertions()`.
+- [**Fluent chaining**](docs/api.md#chaining): write assertions as readable one-liners that chain naturally.
+- [**Dynamic assertions**](docs/api.md#objects): `has_<name>()` for any attribute, property, or zero-argument method on objects and dicts.
+- [**Dict comparison**](docs/api.md#dicts): `is_equal_to()` with `ignore` and `include` for selective key matching.
+- [**Extracting**](docs/api.md#objects): flatten collections on attributes with `filter` and `sort` support.
+- [**File assertions**](docs/api.md#files): `exists()`, `is_file()`, `is_readable()`, `is_writable()`, `is_executable()` with `pathlib.Path` support.
+- [**Snapshot testing**](docs/api.md#snapshot-testing): store and compare data structures in JSON format, inspired by Jest.
+- [**Allure integration**](docs/api.md#allure-integration): auto-attach structured diff and actual/expected data to Allure reports.
+- [**Behave step matchers**](docs/api.md#behave-step-matchers): ready-made parameter types (`PositiveInt`, `BoolLike`, etc.) for Behave step definitions.
+- [**Custom matchers**](docs/api.md#custom-matchers---registering-domain-matchers): register domain-specific matchers via `register_matcher()`, composable with `&`, `|`, `~`.
+- [**Regex group extraction**](docs/api.md#regex-group-extraction): `extracting_group()` and `matches_with_groups()` to assert on regex captures fluently.
+- [**Extensions**](docs/api.md#extension-system---adding-custom-assertions): add custom assertions via `add_extension()`.
+- [Strings](docs/api.md#strings), [numbers](docs/api.md#numbers), [lists](docs/api.md#lists), [tuples](docs/api.md#tuples), [sets](docs/api.md#sets), [dicts](docs/api.md#dicts), [dates](docs/api.md#dates), [booleans](docs/api.md#booleans), [objects](docs/api.md#objects), [exceptions](docs/api.md#failure).
 
 
 ## Composable matchers
@@ -169,6 +169,15 @@ assert_that("hello").satisfies(~match.equal_to("world"))
 assert_that(150).satisfies(match.is_negative() | match.greater_than(100))
 ```
 
+Matchers also support `==` directly, so you can use them with plain `assert` or mix into dicts and lists:
+
+```py
+from assertpy2 import match
+
+assert 42 == match.is_positive()
+assert {"id": 5, "name": "Alice"} == {"id": match.is_positive(), "name": match.is_non_empty_string()}
+```
+
 Available matchers: `equal_to`, `greater_than`, `greater_than_or_equal_to`, `less_than`, `less_than_or_equal_to`, `between`, `close_to`, `is_none`, `is_not_none`, `is_instance_of`, `has_length`, `is_empty`, `is_not_empty`, `is_positive`, `is_negative`, `is_zero`, `is_even`, `is_odd`, `is_divisible_by`, `is_callable`, `is_in`, `has_property`, `contains_string`, `matches_regex`, `is_uuid`, `is_non_empty_string`, `ignore`, `each_item`, `structure`.
 
 

{assertpy2-2.3.3 → assertpy2-2.3.5}/assertpy2/__init__.py

@@ -12,7 +12,7 @@ from .assertpy import (
 from .async_assertions import AsyncAssertionBuilder
 from .errors import AssertionFailure, DiffEntry, DiffResult
 from .file import contents_of
-from .matchers import Matcher, match, register_matcher, unregister_matcher
+from .matchers import Matcher, clear_custom_matchers, match, register_matcher, unregister_matcher
 
 __all__ = [
     "AssertionFailure",
@@ -25,6 +25,7 @@ __all__ = [
     "add_extension",
     "assert_that",
     "assert_warn",
+    "clear_custom_matchers",
     "contents_of",
     "fail",
     "match",

{assertpy2-2.3.3 → assertpy2-2.3.5}/assertpy2/assertpy.py

@@ -73,7 +73,7 @@ from .numeric import NumericMixin
 from .snapshot import SnapshotMixin
 from .string import StringMixin
 
-__version__ = "2.3.3"
+__version__ = "2.3.5"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # ty: ignore[unresolved-attribute]  # pytest monkey-patch
@@ -397,7 +397,6 @@ def _builder(val, description="", kind=None, expected=None, logger=None):
     """Internal helper to build a new :class:`AssertionBuilder` instance and glue on any extension methods."""
     ab = AssertionBuilder(val, description, kind, expected, logger)
     if _extensions:
-        # glue extension method onto new builder instance
         for name, func in _extensions.items():
             meth = types.MethodType(func, ab)
             setattr(ab, name, meth)
@@ -410,13 +409,11 @@ class WarningLoggingAdapter(logging.LoggerAdapter):
 
     def process(self, msg, kwargs):
         def _unwind(frame):
-            # walk all the frames
             frames = []
             while frame:
                 frames.append((frame.f_code.co_filename, frame.f_lineno))
                 frame = frame.f_back
 
-            # in reverse, find the first assertpy frame (and return the previous one)
             prev = None
             for frame in reversed(
                 frames

{assertpy2-2.3.3 → assertpy2-2.3.5}/assertpy2/collection.py

@@ -118,7 +118,6 @@ class CollectionMixin(_MixinBase):
 
         missing = []
         if hasattr(self.val, "keys") and callable(self.val.keys) and hasattr(self.val, "__getitem__"):
-            # flatten superset dicts
             superdict = {}
             for idx, j in enumerate(supersets):
                 self._check_dict_like(j, check_values=False, name=f"arg #{idx + 1}")
@@ -136,7 +135,6 @@ class CollectionMixin(_MixinBase):
                     f"but {self._fmt_items(missing)} {'was' if len(missing) == 1 else 'were'} missing."
                 )
         else:
-            # flatten supersets
             superset = set()
             for j in supersets:
                 try:

{assertpy2-2.3.3 → assertpy2-2.3.5}/assertpy2/exception.py

@@ -73,7 +73,6 @@ class ExceptionMixin(_MixinBase):
         if not issubclass(ex, BaseException):
             raise TypeError("given arg must be exception")
 
-        # chain on with ex as the expected exception
         return self.builder(self.val, self.description, self.kind, ex, self.logger)
 
     def when_called_with(self, *some_args, **some_kwargs) -> Self:

{assertpy2-2.3.3 → assertpy2-2.3.5}/assertpy2/helpers.py

@@ -163,7 +163,6 @@ class HelpersMixin(_MixinBase):
             ignores = self._dict_ignore(ignore)
             includes = self._dict_include(include)
 
-            # guarantee include keys are in val
             if include:
                 missing = []
                 for i in includes:
@@ -181,7 +180,6 @@ class HelpersMixin(_MixinBase):
                         f" but did not include key{missing_suffix} {missing_fmt}."
                     )
 
-            # calc val keys given ignores and includes
             if ignore and include:
                 k1 = {k for k in val if k not in ignores and k in includes}
             elif ignore:
@@ -189,7 +187,6 @@ class HelpersMixin(_MixinBase):
             else:  # include
                 k1 = {k for k in val if k in includes}
 
-            # calc other keys given ignores and includes
             if ignore and include:
                 k2 = {k for k in other if k not in ignores and k in includes}
             elif ignore:
@@ -198,7 +195,6 @@ class HelpersMixin(_MixinBase):
                 k2 = {k for k in other if k in includes}
 
             if k1 != k2:
-                # different set of keys, so not equal
                 return True
             else:
                 for k in k1:
@@ -214,10 +210,8 @@ class HelpersMixin(_MixinBase):
                             else None,
                         )
                         if subdicts_not_equal:
-                            # fast fail inside the loop since sub-dicts are not equal
                             return True
                     elif val[k] != other[k]:
-                        # fast fail inside the loop since values are not equal
                         return True
             return False
         else:

{assertpy2-2.3.3 → assertpy2-2.3.5}/assertpy2/matchers.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+import threading
 import uuid as _uuid_mod
 from collections.abc import Callable
 from typing import Any, Protocol, runtime_checkable
@@ -42,6 +43,12 @@ class BaseMatcher:
     def __invert__(self) -> NotMatcher:
         return NotMatcher(self)
 
+    def __eq__(self, other: object) -> bool:
+        return self.matches(other)
+
+    def __hash__(self) -> int:
+        return id(self)
+
     def __repr__(self) -> str:
         return self.describe()
 
@@ -117,7 +124,10 @@ class GreaterThanMatcher(BaseMatcher):
         self.boundary = boundary
 
     def matches(self, value: Any) -> bool:
-        return value > self.boundary
+        try:
+            return value > self.boundary
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value greater than <{self.boundary}>"
@@ -128,7 +138,10 @@ class GreaterThanOrEqualToMatcher(BaseMatcher):
         self.boundary = boundary
 
     def matches(self, value: Any) -> bool:
-        return value >= self.boundary
+        try:
+            return value >= self.boundary
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value greater than or equal to <{self.boundary}>"
@@ -139,7 +152,10 @@ class LessThanMatcher(BaseMatcher):
         self.boundary = boundary
 
     def matches(self, value: Any) -> bool:
-        return value < self.boundary
+        try:
+            return value < self.boundary
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value less than <{self.boundary}>"
@@ -150,7 +166,10 @@ class LessThanOrEqualToMatcher(BaseMatcher):
         self.boundary = boundary
 
     def matches(self, value: Any) -> bool:
-        return value <= self.boundary
+        try:
+            return value <= self.boundary
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value less than or equal to <{self.boundary}>"
@@ -162,7 +181,10 @@ class BetweenMatcher(BaseMatcher):
         self.high = high
 
     def matches(self, value: Any) -> bool:
-        return self.low <= value <= self.high
+        try:
+            return self.low <= value <= self.high
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value between <{self.low}> and <{self.high}>"
@@ -174,7 +196,10 @@ class CloseToMatcher(BaseMatcher):
         self.tolerance = tolerance
 
     def matches(self, value: Any) -> bool:
-        return abs(value - self.expected) <= self.tolerance
+        try:
+            return abs(value - self.expected) <= self.tolerance
+        except TypeError:
+            return False
 
     def describe(self) -> str:
         return f"a value within <{self.tolerance}> of <{self.expected}>"
@@ -433,8 +458,6 @@ class EndsWithMatcher(BaseMatcher):
 
 
 class IgnoreMatcher(BaseMatcher):
-    """Always matches. Used in structure specs to accept any value for a field."""
-
     def matches(self, value: Any) -> bool:
         return True
 
@@ -443,8 +466,6 @@ class IgnoreMatcher(BaseMatcher):
 
 
 class IsUuidMatcher(BaseMatcher):
-    """Matches valid UUID strings."""
-
     def matches(self, value: Any) -> bool:
         if not isinstance(value, str):
             return False
@@ -459,8 +480,6 @@ class IsUuidMatcher(BaseMatcher):
 
 
 class IsNonEmptyStringMatcher(BaseMatcher):
-    """Matches non-empty strings."""
-
     def matches(self, value: Any) -> bool:
         return isinstance(value, str) and len(value) > 0
 
@@ -502,7 +521,7 @@ class StructureMatcher(BaseMatcher):
     def matches(self, value: Any) -> bool:
         if not isinstance(value, dict):
             return False
-        return self._match_recursive(value, self._spec, "") is None
+        return self._match_recursive(value, self._spec, "", set()) is None
 
     def describe(self) -> str:
         return f"a dict matching structure {self._describe_spec(self._spec)}"
@@ -510,12 +529,16 @@ class StructureMatcher(BaseMatcher):
     def describe_mismatch(self, value: Any) -> str:
         if not isinstance(value, dict):
             return f"was not a dict: <{value}>"
-        error = self._match_recursive(value, self._spec, "")
+        error = self._match_recursive(value, self._spec, "", set())
         if error:
             return error
         return f"was <{value}>"
 
-    def _match_recursive(self, value: dict, spec: dict, path: str) -> str | None:
+    def _match_recursive(self, value: dict, spec: dict, 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:
@@ -529,7 +552,7 @@ class StructureMatcher(BaseMatcher):
             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)
+                error = self._match_recursive(actual, expected, current_path, seen)
                 if error:
                     return error
             elif actual != expected:
@@ -551,6 +574,7 @@ class StructureMatcher(BaseMatcher):
 # --- Custom matcher registry ---
 
 _custom_matchers: dict[str, Callable[..., BaseMatcher]] = {}
+_custom_matchers_lock = threading.Lock()
 
 
 def register_matcher(name: str) -> Callable[[Callable[..., BaseMatcher]], Callable[..., BaseMatcher]]:
@@ -587,7 +611,8 @@ def register_matcher(name: str) -> Callable[[Callable[..., BaseMatcher]], Callab
     def decorator(func: Callable[..., BaseMatcher]) -> Callable[..., BaseMatcher]:
         if not callable(func):
             raise TypeError("func must be callable")
-        _custom_matchers[name] = func
+        with _custom_matchers_lock:
+            _custom_matchers[name] = func
         return func
 
     return decorator
@@ -602,9 +627,16 @@ def unregister_matcher(name: str) -> None:
     Raises:
         KeyError: if the name is not registered
     """
-    if name not in _custom_matchers:
-        raise KeyError(f"no custom matcher registered with name {name!r}")
-    del _custom_matchers[name]
+    with _custom_matchers_lock:
+        if name not in _custom_matchers:
+            raise KeyError(f"no custom matcher registered with name {name!r}")
+        del _custom_matchers[name]
+
+
+def clear_custom_matchers() -> None:
+    """Remove all registered custom matchers."""
+    with _custom_matchers_lock:
+        _custom_matchers.clear()
 
 
 # --- Namespace ---
@@ -766,10 +798,11 @@ class _MatchNamespace:
         return StructureMatcher(spec)
 
     def __getattr__(self, name: str) -> Callable[..., BaseMatcher]:
-        try:
-            factory = _custom_matchers[name]
-        except KeyError:
-            raise AttributeError(f"match has no matcher {name!r}") from None
+        with _custom_matchers_lock:
+            try:
+                factory = _custom_matchers[name]
+            except KeyError:
+                raise AttributeError(f"match has no matcher {name!r}") from None
         return factory
 
 

{assertpy2-2.3.3 → assertpy2-2.3.5}/docs/api.md

@@ -977,6 +977,38 @@ assert_that(50).satisfies(complex_check)
 assert_that(-1).satisfies(complex_check)
 ```
 
+### Using matchers with `==`
+
+Matchers implement `__eq__`, so they work with plain `assert` and pytest introspection. No `assert_that()` wrapper needed:
+
+```py
+from assertpy2 import match
+
+# simple value check
+assert 42 == match.is_positive()
+assert "hello" == match.is_non_empty_string()
+
+# dict comparison with matchers as expected values
+assert {"id": 5, "name": "Alice"} == {
+    "id": match.is_positive(),
+    "name": match.is_non_empty_string(),
+}
+
+# list comparison
+assert [1, 2, 3] == [match.is_positive(), match.is_positive(), match.is_positive()]
+
+# composition works too
+assert 42 == (match.is_positive() & match.less_than(100))
+```
+
+On failure, pytest shows the matcher description in the assertion message:
+
+```
+AssertionError: assert -5 == a positive value
+```
+
+This makes matchers a drop-in addition to existing test suites: add one import, use `match.*` in any `==` comparison, no rewrite required.
+
 ### Available matchers
 
 | Matcher | Description |

{assertpy2-2.3.3 → assertpy2-2.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "assertpy2"
-version = "2.3.3"
+version = "2.3.5"
 description = "Fluent assertion library for Python with composable matchers, structural matching, and full type safety"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -80,4 +80,4 @@ select = ["E", "E301", "F", "I", "UP", "B", "SIM", "RUF"]
 ignore = ["E501"]
 
 [tool.ruff.lint.per-file-ignores]
-"tests/*" = ["E741", "SIM102"]
+"tests/*" = ["E741", "SIM102", "SIM300"]

{assertpy2-2.3.3 → assertpy2-2.3.5}/tests/test_matcher_registry.py

@@ -2,13 +2,12 @@ from __future__ import annotations
 
 import pytest
 
-from assertpy2 import assert_that, match, register_matcher, unregister_matcher
-from assertpy2.matchers import _custom_matchers
+from assertpy2 import assert_that, clear_custom_matchers, match, register_matcher, unregister_matcher
 
 
 class TestRegisterMatcher:
     def teardown_method(self):
-        _custom_matchers.clear()
+        clear_custom_matchers()
 
     def test_simple_matcher(self):
         @register_matcher("is_short")
@@ -113,7 +112,7 @@ class TestRegisterMatcher:
 
 class TestRegisterMatcherErrors:
     def teardown_method(self):
-        _custom_matchers.clear()
+        clear_custom_matchers()
 
     def test_name_not_string(self):
         with pytest.raises(TypeError, match="name must be a string"):
@@ -138,7 +137,7 @@ class TestRegisterMatcherErrors:
 
 class TestUnregisterMatcher:
     def teardown_method(self):
-        _custom_matchers.clear()
+        clear_custom_matchers()
 
     def test_unregister(self):
         @register_matcher("temp")
@@ -153,3 +152,19 @@ class TestUnregisterMatcher:
     def test_unregister_unknown_name(self):
         with pytest.raises(KeyError, match="no custom matcher registered"):
             unregister_matcher("nonexistent")
+
+    def test_clear_custom_matchers(self):
+        @register_matcher("a")
+        def a():
+            return match.is_positive()
+
+        @register_matcher("b")
+        def b():
+            return match.is_negative()
+
+        assert_that(1).satisfies(match.a())
+        clear_custom_matchers()
+        with pytest.raises(AttributeError):
+            match.a()
+        with pytest.raises(AttributeError):
+            match.b()

{assertpy2-2.3.3 → assertpy2-2.3.5}/tests/test_matchers.py

@@ -118,6 +118,43 @@ class TestCloseToMatcher:
         assert_that(match.close_to(10.0, 0.5).describe()).is_equal_to("a value within <0.5> of <10.0>")
 
 
+class TestOrderingMatchersIncompatibleTypes:
+    def test_greater_than_incompatible(self):
+        assert_that(match.greater_than(5).matches("hello")).is_false()
+
+    def test_greater_than_none(self):
+        assert_that(match.greater_than(5).matches(None)).is_false()
+
+    def test_greater_than_or_equal_to_incompatible(self):
+        assert_that(match.greater_than_or_equal_to(5).matches("hello")).is_false()
+
+    def test_less_than_incompatible(self):
+        assert_that(match.less_than(5).matches("hello")).is_false()
+
+    def test_less_than_none(self):
+        assert_that(match.less_than(5).matches(None)).is_false()
+
+    def test_less_than_or_equal_to_incompatible(self):
+        assert_that(match.less_than_or_equal_to(5).matches([1, 2])).is_false()
+
+    def test_between_incompatible(self):
+        assert_that(match.between(1, 10).matches("hello")).is_false()
+
+    def test_between_none(self):
+        assert_that(match.between(1, 10).matches(None)).is_false()
+
+    def test_close_to_incompatible(self):
+        assert_that(match.close_to(10.0, 0.5).matches("hello")).is_false()
+
+    def test_close_to_none(self):
+        assert_that(match.close_to(10.0, 0.5).matches(None)).is_false()
+
+    def test_composition_with_type_check(self):
+        m = match.is_instance_of(int) & match.greater_than(5)
+        assert_that(m.matches("hello")).is_false()
+        assert_that(m.matches(10)).is_true()
+
+
 class TestIsNoneMatcher:
     def test_matches(self):
         assert_that(match.is_none().matches(None)).is_true()
@@ -525,3 +562,70 @@ class TestDescribeCoverage:
 
     def test_ends_with_describe(self):
         assert_that(match.ends_with("bar").describe()).is_equal_to("a string ending with <bar>")
+
+
+class TestMatcherEqProtocol:
+    def test_eq_positive_match(self):
+        assert 5 == match.is_positive()
+
+    def test_eq_negative_match(self):
+        assert (-5 == match.is_positive()) is False
+
+    def test_eq_equal_to(self):
+        assert 42 == match.equal_to(42)
+
+    def test_eq_between(self):
+        assert 5 == match.between(1, 10)
+
+    def test_eq_string_matcher(self):
+        assert "hello" == match.is_non_empty_string()
+
+    def test_eq_not_equal(self):
+        assert -5 != match.is_positive()
+
+    def test_eq_reverse_order(self):
+        assert match.is_positive() == 5
+
+    def test_eq_dict(self):
+        assert {"id": 5, "name": "Alice"} == {"id": match.is_positive(), "name": match.is_non_empty_string()}
+
+    def test_eq_dict_mismatch(self):
+        assert {"id": -5} != {"id": match.is_positive()}
+
+    def test_eq_nested_dict(self):
+        data = {"user": {"name": "Alice", "age": 30}}
+        assert data == {"user": {"name": match.is_non_empty_string(), "age": match.is_positive()}}
+
+    def test_eq_list(self):
+        assert [1, 2, 3] == [match.is_positive(), match.is_positive(), match.is_positive()]
+
+    def test_eq_composition_and(self):
+        assert 5 == (match.is_positive() & match.less_than(10))
+
+    def test_eq_composition_or(self):
+        assert -1 == (match.is_positive() | match.is_negative())
+
+    def test_eq_negated_matcher(self):
+        assert -5 == ~match.is_positive()
+
+    def test_hash_unique_instances(self):
+        m1 = match.is_positive()
+        m2 = match.is_positive()
+        s = {m1, m2}
+        assert_that(s).is_length(2)
+
+    def test_hash_same_instance(self):
+        m = match.is_positive()
+        s = {m, m}
+        assert_that(s).is_length(1)
+
+    def test_repr_unchanged(self):
+        assert_that(repr(match.is_positive())).is_equal_to("a positive value")
+
+    def test_eq_with_pytest_assert_message(self):
+        try:
+            assert -5 == match.is_positive()
+        except AssertionError:
+            pass
+        else:
+            raise AssertionError("Expected AssertionError")

{assertpy2-2.3.3 → assertpy2-2.3.5}/tests/test_structural.py

@@ -218,6 +218,30 @@ class TestStructureMatcher:
         m = match.structure({"a": 1})
         assert_that(m.describe_mismatch({"a": 1})).is_equal_to("was <{'a': 1}>")
 
+    def test_circular_reference_detected(self):
+        d = {}
+        d["self"] = d
+        spec = {}
+        spec["self"] = spec
+        m = match.structure(spec)
+        assert_that(m.matches(d)).is_false()
+        assert_that(m.describe_mismatch(d)).contains("circular reference")
+
+    def test_deep_nesting(self):
+        value = {"a": 1}
+        spec = {"a": 1}
+        current_v = value
+        current_s = spec
+        for _i in range(20):
+            inner_v = {"a": 1}
+            inner_s = {"a": 1}
+            current_v["nested"] = inner_v
+            current_s["nested"] = inner_s
+            current_v = inner_v
+            current_s = inner_s
+        m = match.structure(spec)
+        assert_that(m.matches(value)).is_true()
+
 
 class TestMatchesStructureMethod:
     def test_basic(self):

{assertpy2-2.3.3 → assertpy2-2.3.5}/uv.lock

@@ -30,7 +30,7 @@ wheels = [
 
 [[package]]
 name = "assertpy2"
-version = "2.3.1"
+version = "2.3.5"
 source = { editable = "." }
 dependencies = [
     { name = "typing-extensions" },