assertpy2 2.3.4__tar.gz → 2.3.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertpy2
-Version: 2.3.4
+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,7 +160,7 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 
 ## Features
 
-- [**Composable matchers**](docs/api.md#composable-matchers): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~` operators.
+- [**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.
@@ -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.4 → assertpy2-2.3.5}/README.md

@@ -125,7 +125,7 @@ assert_that(items).is_type_of(list).is_length(3).contains("admin")
 
 ## Features
 
-- [**Composable matchers**](docs/api.md#composable-matchers): `match.greater_than(5)`, `match.is_uuid()`, combine with `&`, `|`, `~` operators.
+- [**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.
@@ -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.4 → 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.4"
+__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.4 → 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.4 → 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.4 → 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.4 → assertpy2-2.3.5}/assertpy2/matchers.py

@@ -43,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()
 
@@ -452,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
 
@@ -462,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
@@ -478,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
 

{assertpy2-2.3.4 → 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.4 → assertpy2-2.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "assertpy2"
-version = "2.3.4"
+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.4 → assertpy2-2.3.5}/tests/test_matchers.py

@@ -562,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.4 → 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" },