assertpy 2.35.0__py3-none-any.whl

assertpy/warning.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING, cast
+
+from ._engine._mixin_base import _MixinBase
+from ._engine._require import refuse
+from .errors import _callable_name, _type_expression_name
+from .exception import _InertBuilder, _require_synchronous_result, named_classes
+
+if TYPE_CHECKING:
+    from ._engine._compat import Self
+    from ._matcher_impls import WarningInfo
+
+__tracebackhide__ = True
+
+
+class WarningMixin(_MixinBase):
+    """Expected warning mixin (a ``pytest.warns``-style assertion).
+
+    The front verbs ([`warns()`][assertpy.warning.WarningMixin.warns] /
+    [`does_not_warn()`][assertpy.warning.WarningMixin.does_not_warn]) only record the expected
+    warning
+    category; the actual invocation happens in
+    [`when_called_with()`][assertpy.exception.ExceptionMixin.when_called_with], which dispatches to the private
+    handlers below.
+    """
+
+    def warns(self, warning: type[Warning] | WarningInfo = Warning) -> Self:
+        """Asserts that val is callable and sets the expected warning category.
+
+        Just records the expectation, but never calls val.  You must chain to
+        [`when_called_with()`][assertpy.exception.ExceptionMixin.when_called_with] to invoke ``val()`` inside a
+        warning-capturing context.  On success, the matched warning's message becomes the new val so
+        you can chain further assertions on it.
+
+        Subclasses of the given category match, and the category defaults to the base `Warning`
+        (which matches any warning).
+
+        Args:
+            warning: the expected warning category (a `Warning` subclass), or a union or a tuple of
+                them any one of which will do
+
+        Examples:
+            Usage:
+
+                assert_that(deprecated_func).warns(DeprecationWarning).when_called_with("foo")
+                assert_that(deprecated_func).warns(DeprecationWarning).when_called_with("foo").matches("since 2.6")
+
+        Returns:
+            AssertionBuilder: returns a new instance (now with the expected warning) to chain to
+                [`when_called_with()`][assertpy.exception.ExceptionMixin.when_called_with]
+
+        Note:
+            Capturing warnings mutates process-global state, so this is **not** thread-safe across OS
+            threads (the same caveat as ``pytest.warns``).  It is safe within a single thread,
+            including multiple ``asyncio`` tasks on one event loop.
+        """
+        return self._warning_builder(warning)
+
+    def does_not_warn(self, warning: type[Warning] | WarningInfo = Warning) -> Self:
+        """Asserts that val is callable and sets the not-expected warning category.
+
+        Just records the expectation, but never calls val.  You must chain to
+        [`when_called_with()`][assertpy.exception.ExceptionMixin.when_called_with] to invoke ``val()`` and assert
+        that no warning of the given category is emitted.  The category defaults to the base
+        `Warning` (which forbids any warning).
+
+        Args:
+            warning: the warning category that should **not** be emitted (a `Warning` subclass), or a
+                union or a tuple of them
+
+        Examples:
+            Usage:
+
+                assert_that(safe_func).does_not_warn(DeprecationWarning).when_called_with("foo")
+
+        Returns:
+            AssertionBuilder: returns a new instance to chain to
+                [`when_called_with()`][assertpy.exception.ExceptionMixin.when_called_with]
+        """
+        new_builder = self._warning_builder(warning)
+        new_builder._not_expected = True
+        return new_builder
+
+    def _warning_builder(self, warning: type[Warning] | WarningInfo) -> Self:
+        """Validate args and build a new instance carrying the expected warning category."""
+        if not callable(self.val):
+            refuse(self.val, "callable")
+        # every member asked here: `issubclass` on a non-class raises with a message about the builtin instead
+        named_classes(warning, Warning, "a warning type, or a union or a non-empty tuple of them", subject="warning")
+        new_builder = self.builder(self.val, self.description, self.kind, logger=self.logger)
+        new_builder._expected_warning = warning
+        return new_builder
+
+    def _when_called_with_warning(self, expected: type[Warning] | WarningInfo, *some_args, **some_kwargs) -> Self:
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")  # bypass __warningregistry__ "show once" dedup and filterwarnings=error
+            result = self.val(*some_args, **some_kwargs)
+        _require_synchronous_result(result, self.val)
+        matched = [warning for warning in caught if issubclass(warning.category, expected)]
+        if matched:
+            captured = self.builder(str(matched[0].message), self.description, self.kind, logger=self.logger)
+            captured._return_value = result
+            return captured
+        if caught:
+            seen = ", ".join(sorted({warning.category.__name__ for warning in caught}))
+            self.error(
+                f"Expected <{_callable_name(self.val)}> to warn <{_type_expression_name(expected)}>"
+                f" when called with ({self._fmt_args_kwargs(*some_args, **some_kwargs)}),"
+                f" but warned <{seen}>.",
+                expected=expected,
+            )
+            return cast("Self", _InertBuilder(self._value_taint_reason))
+        self.error(
+            f"Expected <{_callable_name(self.val)}> to warn <{_type_expression_name(expected)}>"
+            f" when called with ({self._fmt_args_kwargs(*some_args, **some_kwargs)}).",
+            expected=expected,
+        )
+        return cast("Self", _InertBuilder(self._value_taint_reason))
+
+    def _when_called_with_not_warning(self, expected: type[Warning] | WarningInfo, *some_args, **some_kwargs) -> Self:
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")  # bypass __warningregistry__ "show once" dedup and filterwarnings=error
+            result = self.val(*some_args, **some_kwargs)
+        _require_synchronous_result(result, self.val)
+        matched = [warning for warning in caught if issubclass(warning.category, expected)]
+        if matched:
+            seen = ", ".join(sorted({warning.category.__name__ for warning in matched}))
+            self.error(
+                f"Expected <{_callable_name(self.val)}> to not warn <{_type_expression_name(expected)}>"
+                f" when called with ({self._fmt_args_kwargs(*some_args, **some_kwargs)}),"
+                f" but did warn <{seen}>."
+            )
+            return cast("Self", _InertBuilder(self._value_taint_reason))
+        self._return_value = result
+        return self

assertpy-2.35.0.dist-info/METADATA

@@ -0,0 +1,324 @@
+Metadata-Version: 2.5
+Name: assertpy
+Version: 2.35.0
+Summary: Fluent, fully typed assertion library for Python: your type checker sees only the assertions that fit the value, and every failure carries a structured diff. Soft assertions, polling, inline snapshots, OpenAPI contracts.
+Project-URL: Homepage, https://github.com/assertpy/assertpy
+Project-URL: Repository, https://github.com/assertpy/assertpy
+Project-URL: Issues, https://github.com/assertpy/assertpy/issues
+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,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
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: typing-extensions>=4.0; python_version < '3.11'
+Provides-Extra: allure
+Requires-Dist: allure-pytest>=2.13; extra == 'allure'
+Provides-Extra: behave
+Requires-Dist: behave>=1.3.0; extra == 'behave'
+Provides-Extra: data
+Requires-Dist: numpy>=1.26; extra == 'data'
+Requires-Dist: pandas>=2.0; extra == 'data'
+Requires-Dist: polars>=1.0; extra == 'data'
+Provides-Extra: inline
+Requires-Dist: asttokens>=2.0.4; extra == 'inline'
+Requires-Dist: executing>=2.2; extra == 'inline'
+Provides-Extra: json
+Requires-Dist: idna>=3.7; extra == 'json'
+Requires-Dist: jsonpath-ng>=1.8; extra == 'json'
+Requires-Dist: jsonschema>=4.18; extra == 'json'
+Requires-Dist: referencing>=0.28.4; extra == 'json'
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.26; extra == 'numpy'
+Provides-Extra: pandas
+Requires-Dist: pandas>=2.0; extra == 'pandas'
+Provides-Extra: polars
+Requires-Dist: polars>=1.0; extra == 'polars'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/logo-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="docs/logo.svg">
+    <img src="docs/logo.svg" alt="assertpy" width="280">
+  </picture>
+  <br>
+  <b>Fully typed fluent assertion library for Python</b>
+</p>
+
+<p align="center">
+  <a href="https://github.com/assertpy/assertpy/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/assertpy/assertpy/ci.yml?branch=main&amp;label=CI" alt="CI"></a>
+  <a href="https://codecov.io/gh/assertpy/assertpy"><img src="https://codecov.io/gh/assertpy/assertpy/graph/badge.svg" alt="Coverage"></a>
+  <a href="https://pypi.org/project/assertpy/"><img src="https://img.shields.io/pypi/v/assertpy" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/assertpy/"><img src="https://img.shields.io/pypi/pyversions/assertpy" alt="Python"></a>
+  <a href="https://pepy.tech/projects/assertpy"><img src="https://static.pepy.tech/badge/assertpy/month" alt="Downloads"></a>
+  <br>
+  <a href="https://assertpy.github.io/assertpy/concepts/type-safety/"><img src="https://img.shields.io/badge/overloads-ty%20%7C%20mypy%20%7C%20pyright%20%7C%20pyrefly-2ea043" alt="every public overload checked by ty, mypy --strict, pyright and pyrefly with zero suppressions"></a>
+  <a href="https://assertpy.github.io/assertpy/"><img src="https://img.shields.io/badge/docs-online-black" alt="Documentation"></a>
+  <a href="https://scorecard.dev/viewer/?uri=github.com/assertpy/assertpy"><img src="https://img.shields.io/ossf-scorecard/github.com/assertpy/assertpy?label=OpenSSF%20Scorecard" alt="OpenSSF Scorecard"></a>
+</p>
+
+<h2 align="center"><a href="https://assertpy.github.io/assertpy/getting-started/quickstart/">Quick start</a></h2>
+
+```bash
+pip install assertpy
+```
+
+```python
+from assertpy import assert_that
+
+def test_user():
+    user = {"name": "Alice", "age": 30, "roles": ["viewer", "editor"]}
+
+    assert_that(user).contains_key("name", "age")
+    assert_that(user).contains_entry({"name": "Alice"})
+    assert_that(user["age"]).is_between(18, 120)
+    assert_that(user["roles"]).contains("viewer").does_not_contain("admin")
+```
+
+The [full documentation](https://assertpy.github.io/assertpy/) covers every assertion, matcher, and integration.
+
+<table>
+<tr>
+<td valign="top" width="50%">
+<a href="#why-fluent-assertions"><b>Failures that point at the difference</b></a><br>
+A recursive diff names the exact path that differs, in color, instead of dumping both structures
+</td>
+<td valign="top" width="50%">
+<a href="#type-aware-autocomplete"><b>Type-aware autocomplete</b></a><br>
+<code>assert_that()</code> returns a protocol per value type, so your IDE offers the methods that fit
+</td>
+</tr>
+<tr>
+<td valign="top">
+<a href="#typed-narrowing"><b>Typed narrowing</b></a><br>
+An assertion hands the value back statically narrowed, with no <code>cast</code> and no bare <code>assert</code>
+</td>
+<td valign="top">
+<a href="#features"><b>Composable matchers</b></a><br>
+45 matchers that combine with <code>&amp;</code>, <code>|</code>, <code>~</code> and nest inside the expected structure itself
+</td>
+</tr>
+<tr>
+<td valign="top">
+<a href="#features"><b>Built for test suites</b></a><br>
+Soft assertions, polling for eventual consistency, snapshots, and expected-exception chains
+</td>
+<td valign="top">
+<a href="#integrations"><b>Integrations</b></a><br>
+Allure, Behave, JSON Path and Schema, pandas, polars, numpy, and OpenAPI response contracts
+</td>
+</tr>
+</table>
+
+<h2 align="center"><a href="https://assertpy.github.io/assertpy/getting-started/comparison/">Why fluent assertions?</a></h2>
+
+`assert` states a condition well. pytest reports it well.
+
+What it cannot say is *where* two structures differ. It prints both and leaves the reading to you:
+
+```text
+assert response == expected
+E   AssertionError: assert {'id': 1, ...} == {'id': 1, ...}
+E     Omitting 1 identical items, use -vv to show
+E     Differing items:
+E     {'user': {'name': 'Alice', 'role': 'superadmin'}} != {'user': {'name': 'Alice', 'role': 'admin'}}
+E     {'status': 'active'} != {'status': 'disabled'}
+```
+
+assertpy names the [exact path](https://assertpy.github.io/assertpy/guides/errors/#rich-pytest-diffs), in color:
+
+<!-- docs-guard: skip -->
+```python
+assert_that(response).is_equal_to(expected)
+```
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/assertpy/assertpy/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>
+
+It recurses through nested containers. Matcher predicates get the same treatment.
+
+For dynamic fields like IDs, assert a subset with
+[`matches_structure()`](https://assertpy.github.io/assertpy/guides/matchers/#structural-matching).
+
+The chain is the other half. Your IDE offers only the
+[methods that fit the value](https://assertpy.github.io/assertpy/concepts/type-safety/).
+
+<!-- docs-guard: skip -->
+```python
+assert_that(items).is_instance_of(list).is_length(3).contains("admin")
+```
+
+Matchers are ordinary values that answer `==`, the way `unittest.mock.ANY` does.
+
+Nothing is patched, so a matcher can sit inside the expected structure at any depth:
+
+```python
+response = {"id": 7, "user": {"name": "Alice", "age": 30}, "tags": ["a", "b"]}
+
+assert_that(response).is_equal_to(
+    {
+        "id": match.greater_than(0),
+        "user": {"name": "Alice", "age": match.between(18, 120)},
+        "tags": ["a", "b"],
+    }
+)
+
+# or keep the bare `assert`, and pytest's own rewriting reports it
+assert response == {
+    "id": match.greater_than(0),
+    "user": match.ignore(),
+    "tags": ["a", "b"],
+}
+```
+
+The fluent form keeps the path-level diff, the bare form keeps pytest's.
+
+There are [45 matchers](https://assertpy.github.io/assertpy/guides/matchers/), combining with `&`, `|` and `~`.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/assertpy/assertpy/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">
+</p>
+
+<h2 align="center"><a href="https://assertpy.github.io/assertpy/concepts/type-safety/">Type-aware autocomplete</a></h2>
+
+`assert_that()` uses `@overload` to return type-specific Protocols.<br>
+Your IDE shows only methods relevant to the value you're testing, not the whole surface:
+
+- `assert_that("hello").` &rarr; string methods: `starts_with`, `matches`, `is_alpha`, ...
+- `assert_that(42).` &rarr; numeric methods: `is_positive`, `is_between`, `is_close_to`, ...
+- `assert_that(Path("/tmp")).` &rarr; path methods: `exists`, `is_file`, `is_readable`, ...
+- `assert_that(my_dict).` &rarr; dict methods: `contains_key`, `contains_entry`, `has_json_path`, ...
+- `assert_that(b"\x89PNG").` &rarr; bytes methods: `starts_with_bytes`, `is_valid_utf8`, `decoded_as`, ...
+
+15 type-specific Protocols instead of one `Any`<br>
+Works in PyCharm, VS Code, and any editor that runs a type checker
+
+<h2 align="center"><a href="https://assertpy.github.io/assertpy/concepts/type-safety/#typed-narrowing-with-value">Typed narrowing</a></h2>
+
+An assertion hands the value back, statically narrowed.
+
+`is_not_none()` strips `None`, `is_instance_of()` narrows to the class, and `.value` returns it:
+
+<!-- docs-guard: skip -->
+```python
+order = assert_that(repo.find(42)).is_not_none().is_instance_of(PaidOrder).value
+order.refund()  # statically PaidOrder - verified by ty, mypy, pyright and pyrefly
+```
+
+For API tests,
+[`assert_conforms()`](https://assertpy.github.io/assertpy/concepts/type-safety/#contract-narrowing-with-assert_conforms)
+validates a payload against a Pydantic model and narrows to it. `exact=True` catches contract drift:
+
+<!-- docs-guard: skip -->
+```python
+data = assert_conforms(response.json(), OrderModel).value  # data: OrderModel
+```
+
+<h2 align="center"><a href="https://assertpy.github.io/assertpy/guides/errors/#asking-instead-of-asserting">A failure you can read from code</a></h2>
+
+An exception is the right default. Reading the result means catching it.
+
+`check()` runs the next assertion for its verdict instead:
+
+```python
+response = {"user": {"name": "Alice", "role": "superadmin"}, "status": "active"}
+expected = {"user": {"name": "Alice", "role": "admin"}, "status": "active"}
+
+outcome = assert_that(response).check().is_equal_to(expected)
+
+if not outcome and outcome.diff:
+    print(outcome.diff.entries[0].path)  # user.role
+```
+
+It is truthy when the assertion held. When it did not, it carries `.message`, `.actual`, `.expected`
+and a walkable `.diff`. So does `AssertionFailure`.
+
+So a reporter reads structure instead of parsing a string. That is how the
+[Allure integration](https://assertpy.github.io/assertpy/extending/integrations/#allure) works.
+Anything else you build can too.
+
+<h2 align="center">Features</h2>
+
+**Fluent API**
+
+- [**Structural matching**](https://assertpy.github.io/assertpy/guides/matchers/#structural-matching): `matches_structure()` for declarative dict/API-response validation
+- [**Recursive field assertions**](https://assertpy.github.io/assertpy/guides/assertions/#recursive-field-assertions): `all_fields_satisfy()` / `has_no_none_fields()` apply a predicate to every leaf of an object graph
+- [**Universal negation**](https://assertpy.github.io/assertpy/guides/fluent/#universal-negation): `.not_` inverts any assertion, no dedicated `is_not_*` methods
+- [**Collection pipeline**](https://assertpy.github.io/assertpy/guides/fluent/#collection-pipeline): `filtered_on()`, `mapped()`, `flat_mapped()`, `first()`, `last()`, `element()`, `single()`
+- [**Positional & pairwise checks**](https://assertpy.github.io/assertpy/guides/assertions/#lists): `satisfies_exactly()`, `zip_satisfies()`, `contains_only_once()`, `has_same_size_as()`, plus `*_in_any_order` variants
+
+**Type safety**
+
+- [**Refinement predicates**](https://assertpy.github.io/assertpy/concepts/type-safety/#refinement-narrowing-with-a-typeis-predicate-advanced): `satisfies()` takes a `TypeIs` predicate, so a domain check narrows the chain too
+- [**Contract testing**](https://assertpy.github.io/assertpy/concepts/type-safety/#contract-narrowing-with-assert_conforms): `assert_conforms()` validates a raw payload against a Pydantic model and narrows to it. [`exact=True`](https://assertpy.github.io/assertpy/concepts/type-safety/#contract-drift-with-exacttrue) catches contract drift, `each=True` validates list endpoints
+
+**Built-in types**
+
+- [Strings](https://assertpy.github.io/assertpy/guides/assertions/#strings), [numbers](https://assertpy.github.io/assertpy/guides/assertions/#numbers), [lists](https://assertpy.github.io/assertpy/guides/assertions/#lists), [tuples](https://assertpy.github.io/assertpy/guides/assertions/#tuples), [sets](https://assertpy.github.io/assertpy/guides/assertions/#sets), [dicts](https://assertpy.github.io/assertpy/guides/assertions/#dicts), [dates](https://assertpy.github.io/assertpy/guides/assertions/#dates), [booleans](https://assertpy.github.io/assertpy/guides/assertions/#booleans), [objects](https://assertpy.github.io/assertpy/guides/assertions/#objects), [bytes](https://assertpy.github.io/assertpy/guides/assertions/#bytes--bytearray), [files](https://assertpy.github.io/assertpy/guides/assertions/#files), [exceptions](https://assertpy.github.io/assertpy/guides/errors/#expected-exceptions)
+- [**Bytes assertions**](https://assertpy.github.io/assertpy/guides/assertions/#bytes--bytearray): `is_valid_utf8()`, `starts_with_bytes()`, `is_hex_equal_to()`, `decoded_as()` for `bytes`/`bytearray`
+- [**Dynamic assertions**](https://assertpy.github.io/assertpy/guides/assertions/#dynamic-assertions-on-objects): `has_<name>()` for any attribute, property, or zero-argument method
+- [**Dict comparison**](https://assertpy.github.io/assertpy/guides/assertions/#selective-comparison-ignore--include): `is_equal_to(ignore=..., include=...)` for selective key/field matching by name, regex, or type
+- [**Recursive comparison**](https://assertpy.github.io/assertpy/guides/assertions/#recursive-comparison-tolerance--custom-comparators): `is_equal_to()` with `tolerance`, `comparators`, or `ignore_null` for nested structures
+- [**Extracting**](https://assertpy.github.io/assertpy/guides/assertions/#extracting-attributes-from-objects): flatten collections on attributes with `filter` and `sort` support
+- [**Regex group extraction**](https://assertpy.github.io/assertpy/guides/data/#regex-group-extraction): `extracting_group()` and `matches_with_groups()` for regex captures
+
+**Testing**
+
+- [**Soft assertions**](https://assertpy.github.io/assertpy/guides/testing/#soft-assertions): thread-safe and async-safe via `contextvars`, each failure reported with its `file:line`. Group with `sa.group()` or `assert_all()`
+- [**Polling assertions**](https://assertpy.github.io/assertpy/guides/testing/#async-assertions): `eventually()` (async) / `eventually_sync()` (blocking) retry for eventual consistency, with a convergence trace on timeout
+- [**Expected exceptions**](https://assertpy.github.io/assertpy/guides/errors/#expected-exceptions): `raises().when_called_with()`, walk the cause chain (`caused_by()`, `has_root_cause()`), search an `ExceptionGroup` (`contains_error()`, `errors()`, `error_of()`), or pivot to the object (`raised()`)
+- [**HTTP responses**](https://assertpy.github.io/assertpy/recipes/#test-an-http-api-response): assert on the response itself and every failure names the request it came from, with `decoded_as_json()` to step into the body. No client library is a dependency
+- [**Snapshot testing**](https://assertpy.github.io/assertpy/guides/testing/#snapshot-testing): an external JSON file, an [inline](https://assertpy.github.io/assertpy/guides/testing/#inline-snapshots) value recorded into the test source, or a [value-tolerant contract](https://assertpy.github.io/assertpy/guides/testing/#contract-snapshots), all updated with `--assertpy-snapshot-update`
+- [**OpenAPI response contracts**](https://assertpy.github.io/assertpy/reference/json/#assertpy.json_mixin.JsonMixin.conforms_to_openapi): `conforms_to_openapi()` checks a JSON body against an operation's response schema, reporting every violation with its JSON path
+
+**Failure reporting**
+
+- [**Structured errors**](https://assertpy.github.io/assertpy/guides/errors/#structured-errors): `AssertionFailure` carries `.actual`, `.expected` and `.diff`, and the diff renders into the message, so it shows off pytest too
+- [**Assertions as values**](https://assertpy.github.io/assertpy/guides/errors/#asking-instead-of-asserting): `check()` runs the next assertion for its verdict instead of raising, handing back an `AssertionOutcome`
+- [**Rich pytest diffs**](https://assertpy.github.io/assertpy/guides/errors/#rich-pytest-diffs): recursive diffs across containers, dataclasses, attrs and Pydantic models, with intra-line carets for strings
+- [**Failures that say why**](https://assertpy.github.io/assertpy/guides/errors/#some-failures-say-why-not-only-what): where one fact explains a failure, a line under the message says it. An id the payload holds as text (`7` against `"7"`), a NaN, two instances compared by identity, surrounding whitespace. A failed `contains()` or `is_in()` names the closest row, and forty rows that differ in one field are named as one place
+
+**Plugin for pytest**
+
+Set from the command line or from `[tool.pytest.ini_options]`, not from a call
+
+- [**Failure clustering**](https://assertpy.github.io/assertpy/guides/errors/#what-the-failures-had-in-common): forty failing tests are usually not forty problems. Where three or more differ at the same place, the run ends with a line saying where. On by default, `assertpy_failure_clusters = "off"` turns it off
+- [**IDE comparison window**](https://assertpy.github.io/assertpy/guides/errors/#the-comparison-window-of-an-ide): a failed `is_equal_to()` or `has_<name>()` gets PyCharm's "Click to see difference" link, as a plain `assert` does, and the window shows the two values it compared. Under `ignore=` or `include=` those go without the keys left out. The plugin hands them to `pytest_assertrepr_compare`, the hook the IDE's runner listens to. On by default, `assertpy_comparison = "off"` turns it off
+- [**Diagnostic profiles**](https://assertpy.github.io/assertpy/guides/errors/#configuration): `assertpy_profile` turns the guards below on in one line. `compatible` (default) leaves them off, `safe` warns, `strict` fails the tests they find. A setting you name yourself still wins
+- [**Vacuous-assertion guard**](https://assertpy.github.io/assertpy/guides/assertions/#assertions-that-checked-nothing): `--assertpy-vacuous` warns when a universal assertion passes over an empty collection, having checked nothing
+- [**Dangling-assertion detector**](https://assertpy.github.io/assertpy/guides/assertions/#assertions-that-never-ran): `--assertpy-dangling` warns when a chain builds an assertion and never runs it. `assert assert_that(x).is_positive` passes on any value, and neither ruff nor coverage sees it
+
+**Extensibility**
+
+- [**Custom matchers**](https://assertpy.github.io/assertpy/guides/matchers/#custom-matchers): `register_matcher()` composes existing ones, `BaseMatcher` carries its own predicate. Both compose with `&`, `|`, `~`
+- [**Custom assertions**](https://assertpy.github.io/assertpy/extending/custom-assertions/): `add_extension()` adds a method to the builder
+
+<h2 align="center"><a href="https://assertpy.github.io/assertpy/extending/integrations/">Integrations</a></h2>
+
+- [**Allure**](https://assertpy.github.io/assertpy/extending/integrations/#allure) (`pip install assertpy[allure]`): the pytest plugin auto-attaches structured diff and actual/expected data to Allure reports, in three configurable modes
+- [**Behave**](https://assertpy.github.io/assertpy/extending/integrations/#behave) (`pip install assertpy[behave]`): ready-made parameter types (`PositiveInt`, `NonEmptyString`, ...) for step definitions like `{age:PositiveInt}`
+- [**JSON**](https://assertpy.github.io/assertpy/guides/data/#json-path--schema) (`pip install assertpy[json]`): JSONPath navigation (`at_json_path()`, `has_json_path()`) and JSON Schema validation (`matches_json_schema()`)
+- [**Data frames**](https://assertpy.github.io/assertpy/extending/integrations/#data-frames-and-arrays) (`pip install assertpy[pandas]` / `[polars]` / `[numpy]`): fluent equality for pandas/polars frames and numpy arrays, carrying each library's own diff
+
+---
+
+<p align="center">
+  <a href="https://github.com/assertpy/assertpy/blob/main/LICENSE">BSD 3-Clause License</a>
+</p>

assertpy-2.35.0.dist-info/RECORD

@@ -0,0 +1,63 @@
+assertpy/__init__.py,sha256=Rf_S0hzUuzp1n6oRAqoHhCSLS6TzJ8YcB7TmU-74mmg,1835
+assertpy/_clustering.py,sha256=VJRziYs35uNSRSW3jCw3aoMws5YQiysCzpshg9k7GX0,25569
+assertpy/_dangling.py,sha256=0tERUBRQJhhPWF55WAFgkM7sz78T4ncOUQYcrGZSdxw,24916
+assertpy/_hints.py,sha256=Xofscs0ZXzrrJMqThn_xqFqC5V3VrRy9i_KbN556zNo,59046
+assertpy/_inline.py,sha256=QhNY-O4wVko1tqood9XlC82I-_HRa8Ld4dTOkpOdaog,21951
+assertpy/_matcher_impls.py,sha256=GtUcIcOFxqfZkz75kRRYn-EQNpceqiFdAjFg2zoMldA,81000
+assertpy/_passes.py,sha256=lKILSfdxO3b4vWLq4KMwd1MBUUMoWFCnsBKLVq_brP8,10283
+assertpy/_renamed.py,sha256=1n2UEJ70BFqQbvaIu6A6KOiMF2A7f3BhrxmPBbQipoE,1849
+assertpy/_satisfies.py,sha256=sm25E4PjxAAEbaCn9TlIDqSE4NorxVFYGk36wdUm4P8,36055
+assertpy/_snapshot_codec.py,sha256=L3uJnWFB3m20IT4UAyLOScStq0y873hSSdakIBKPOfs,13247
+assertpy/assertpy.py,sha256=ETv6uDjBz_q8nQ3hHCoskAHNo96U81ruqvsJpVsctpw,121672
+assertpy/async_assertions.py,sha256=HIg7PbZ3lqovBQAfaBnwmT_KxDwd4ofSJyIz_AdVFLM,41947
+assertpy/base.py,sha256=Hr9_WEXzNPUr5202i7W3FZ-p7iUb9NcVWYlUeZ7RYLw,39155
+assertpy/behave_matchers.py,sha256=46bFFVa31oXK9edvcCqk4JUaAeVU1DGWhV9l8fIDCic,2865
+assertpy/bytes_mixin.py,sha256=hoin-zxlMN31L0kpWYLwUWwMnO77tacTQy8HM_ppQJo,5972
+assertpy/collection.py,sha256=-fBHGBCCxVdBEQ0GltNqQjH349pF9Odu2u3GiR9ghsc,20683
+assertpy/contains.py,sha256=H62NmHmOVT12Cv8UkbmQ9jtDU4JyIIPh73MAPlgJB5E,47433
+assertpy/dataframe.py,sha256=e4LC8_rhlGcBBBcdrRMPpgT-lhn_e6sCssjM3wFvy3s,9647
+assertpy/date.py,sha256=FEE7d2EFw518CIdYy6V3yppamSL_-EiLkMMrGcAjwGc,13102
+assertpy/dict.py,sha256=CaXDMD72hPTJm2ClrmXWRsVD4iscqcFx8v826cqOQII,10006
+assertpy/dynamic.py,sha256=kjFMJgklJ4vzNStvj3AqpWrDnO_H9ULvGFB0XyBMiqg,11705
+assertpy/errors.py,sha256=7ZJD4C251iP-rrdXa-QbAiggbP3bCahshcPNhi8_Qdc,37119
+assertpy/exception.py,sha256=QbFuOGRC2bfdCr6Oi1f02HjxdRh_Y1z4eT1MaMJp80s,38916
+assertpy/extracting.py,sha256=3YOdyngjSjwTTJ6KemM1xnucp1aXHjU7w02ulUDToTY,12173
+assertpy/file.py,sha256=QE0bEYsJNmzEmGxVqsFzY639QwcWL3XsiYYMl6Ecmpw,11869
+assertpy/helpers.py,sha256=h5VfNtyPBCasO0Ouqiq9AnOIFrhSYaogBE5NcuXTLPg,35609
+assertpy/http_mixin.py,sha256=IyEEc8S833rTqqTZkeAaLM_Fj-mTg7buV7FflRwsCMU,10363
+assertpy/json_mixin.py,sha256=m1hebcT3Yi6onDFcHmDusebc_LAtEyrtx04PZ9a6taM,59463
+assertpy/matchers.py,sha256=pB4PkVnOzUSVyUXoM9cVIKWm8sxPuStFffPl3GLQk7U,25364
+assertpy/numeric.py,sha256=b5ZgxH_EiVupEYr5gVL0Xn7z1XJNxR4djUNKMU_BGgY,26434
+assertpy/outcome.py,sha256=TcB5POBCobIH7aaoP8m5O-vW_qelpN6og-pl7dCX7oU,7152
+assertpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+assertpy/pytest_plugin.py,sha256=G8qwCLX2Pdp62NbH_8n9Bqmg7bz9cjcZx5rZiND-hkc,74962
+assertpy/snapshot.py,sha256=Kr6K-vRBbzhuVARGqCIcIPP5IvPdwSazF42CqJw-ZSQ,49850
+assertpy/string.py,sha256=qrfoiYvx_L4cAyVOCVfAvz8v99Vd7dfwq4XNY0K6b1k,32804
+assertpy/warning.py,sha256=htSduXVFuFPHs5eRmM8O9gq2oUowVDAgLQooQ0NMr9Y,6762
+assertpy/_engine/__init__.py,sha256=xvRm6rIBsDmUvMEVWciNeVHw3I_AiVCUUyya_75nIlw,91
+assertpy/_engine/_builder_check_typing.py,sha256=CxS-ojY2PYnshBhuuvnuSl0yyvrYGXnR3KDwmRdDWGM,55705
+assertpy/_engine/_capable_typing.py,sha256=NSYZgncn-Xal-5lsOnFftbmAA_LZDom0l8P8lu-p1FA,43304
+assertpy/_engine/_check_typing.py,sha256=x6GHpvMGb7CQKdOdwFxWqEheS6qZUOqYYfwxD6MkQ8c,38146
+assertpy/_engine/_compare.py,sha256=4zsxtujLT0R3MGwTJjRUrkR1xnHiHpBTnH7Y70Ky1rg,49026
+assertpy/_engine/_compat.py,sha256=P2W8_P7c4WNiAF4P0f_t7KmpJ85fk6-z_j_IKpF57xQ,1742
+assertpy/_engine/_contract.py,sha256=YmhmZoIT53AZeyOB9xoQGDFumXPOpMaXn8g-0uDnuI0,91115
+assertpy/_engine/_diff.py,sha256=Rj3SGm-AW2FjJMP_rn1AhWqQla_2U78Kctu8L1Hp3-k,55669
+assertpy/_engine/_equality.py,sha256=W_LEf2K6lmRXiwV45yTOhBqbG_FW6ZOQbKipuCoOKFc,40647
+assertpy/_engine/_introspection.py,sha256=A2S_FvoynFGZGYyKnF1yM44pTrbIYx7bEAqYgbv6OHo,33572
+assertpy/_engine/_membership.py,sha256=cq2Roes8tq1kXH9VtyK4Wr4GZ51ZWPgpF3ZwOB4NoRY,24267
+assertpy/_engine/_mixin_base.py,sha256=mSyIybzvnbhO02a6BRsAvRfVsTI-o3wjqkBDQRwZaSE,10296
+assertpy/_engine/_negated_typing.py,sha256=UpveYN_KBj8va_Yd51SbrmiygrkjxXkmiq8YXHzuTrM,123905
+assertpy/_engine/_operations.py,sha256=TncowBzkbVGhl5UK-jBDNewPzm4dywguzwyOo_EweAs,3037
+assertpy/_engine/_ordering.py,sha256=wOKyH-MO2sGDGa5x66_BBzm3a5OGBwljF9Wmo6FCDuA,44498
+assertpy/_engine/_pairing.py,sha256=4YuylWUS3uCBOXzMu9Rd_VIzGItdRqhRLjw1RTdWoKo,2700
+assertpy/_engine/_path.py,sha256=rKggawa5iiOxaXl4jITlbqbeZZ7sIVYocWe8w2BCTOg,7565
+assertpy/_engine/_poll_typing.py,sha256=KiXF-PFTM_xP7Mea8PW5pvXmQNJEmRORUHPBJPbfNXI,253721
+assertpy/_engine/_require.py,sha256=SiNmreJZ9tjDfGEyaJiF9zMIIRQlZqQkLzoMRGoPX4M,14897
+assertpy/_engine/_size.py,sha256=D1ezRB7LA6UsuoyIQvwHbt0wStDefFlx4vukRxe46do,1519
+assertpy/_engine/_text.py,sha256=HMhlBLHGRO5mClvtXHVAEbwjYpRiNGKGRppPl69o3A4,1737
+assertpy/_engine/_typing.py,sha256=ZGc6qbCY6BIeHcrBzzq-CPDE5ZwfYnFi5ZFGDEID-PM,63766
+assertpy-2.35.0.dist-info/METADATA,sha256=G40ygiMryOkSTpCr55gal9DQdLGx3MazsNcKppIEu2U,21103
+assertpy-2.35.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+assertpy-2.35.0.dist-info/entry_points.txt,sha256=0bXpJmVXTIHw3qgPiN62hfbYztMJidYdYsPUvkJZq74,45
+assertpy-2.35.0.dist-info/licenses/LICENSE,sha256=ep-e6x7HTPIdDUdZXDzKJIpOUZJg5Y1Q6kI56qYjPbM,1547
+assertpy-2.35.0.dist-info/RECORD,,

assertpy-2.35.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

assertpy-2.35.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+assertpy = assertpy.pytest_plugin

assertpy-2.35.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2015-2019, Activision Publishing, Inc.
+Copyright (c) 2026, Solganis
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.