assertpy2 2.25.0__tar.gz → 2.26.0__tar.gz

{assertpy2-2.25.0 → assertpy2-2.26.0}/CONTRIBUTING.md

@@ -25,7 +25,7 @@ Read more about how pulls work on GitHub's [About pull requests](https://help.gi
 
 ## Before you change a public signature
 
-Read [ARCHITECTURE.md](ARCHITECTURE.md). Four files under `assertpy2/_engine/` are generated, the public
+Read [ARCHITECTURE.md](ARCHITECTURE.md). Five files under `assertpy2/_engine/` are generated, the public
 surface is pinned by a recorded snapshot, and neither is discoverable from the files themselves.
 
 ## Verification pipeline
@@ -86,15 +86,16 @@ Run these after the main gate, not before. `uv run --group typecheck` adds the c
 
 ```bash
 uv run --group typecheck mypy --strict --follow-imports=silent tests/test_typing.py
-PYRIGHT_PYTHON_FORCE_VERSION=1.1.413 uv run --group typecheck pyright --pythonversion 3.14 tests/test_typing.py
+PYRIGHT_PYTHON_FORCE_VERSION=1.1.414 uv run --group typecheck pyright --pythonversion 3.14 tests/test_typing.py
 uv run --group typecheck pyrefly check tests/test_typing.py
 uv run --group typecheck pytest tests/test_pyright_baseline.py
 ```
 
 `PYRIGHT_PYTHON_FORCE_VERSION` picks the engine rather than the launcher. The `pyright` distribution on
-PyPI stopped at 1.1.411 on 25 June while npm has shipped 1.1.412 and 1.1.413 since, so the launcher and
-the engine move apart. The baseline is recorded against one engine, and `tests/typing_harness.py` pins
-the same build, so only this direct invocation needs the variable.
+PyPI is released separately from the npm engine it launches, and the two have drifted apart before: PyPI
+stayed at 1.1.411 from June to September while npm shipped two builds. The baseline is recorded against
+one engine, and `tests/typing_harness.py` pins the same build, so only this direct invocation needs the
+variable.
 
 `--pythonversion 3.14` is not decoration. Pyright reports against the interpreter it finds unless
 told otherwise, and the count moves with it: 174 diagnostics for this package on 3.10 against 169 on
@@ -123,9 +124,11 @@ Write tests for every new feature or bug fix. Use `assertpy2` assertions in test
 
 ## Documentation examples
 
-Guide code blocks are executed and type-checked in CI, so an example you add has to run. A block that
+Guide code blocks are type-checked in CI, and every page that can run in the suite is executed, with what
+each block prints compared with the comment beside it, so an example you add has to run. A block that
 cannot (pseudo-context, a deliberate failure, a rejected counter-example) is marked with an HTML comment
-above the fence: `tests/test_docs_examples.py` lists the markers and what each one exempts.
+above the fence. `tests/test_docs_examples.py` lists the markers and what each one exempts, and it and
+`tests/test_docs_typing.py` each name the pages they leave out, with the reason.
 
 Setup a page assumes (a domain class, a repository, an HTTP response) goes in
 `tests/docs_fixtures.py`, not into an extra block on the page.

{assertpy2-2.25.0 → assertpy2-2.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: assertpy2
-Version: 2.25.0
+Version: 2.26.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

{assertpy2-2.25.0 → assertpy2-2.26.0}/assertpy2/__init__.py

@@ -35,7 +35,7 @@ from .matchers import (
     register_matcher,
     unregister_matcher,
 )
-from .outcome import AssertionOutcome
+from .outcome import AssertionOutcome, Requirement
 from .snapshot import (
     SnapshotCreatedWarning,
     SnapshotKeyReusedWarning,
@@ -57,6 +57,7 @@ __all__ = [
     "NegatedBuilder",
     "PollSample",
     "PollTrace",
+    "Requirement",
     "SnapshotCreatedWarning",
     "SnapshotKeyReusedWarning",
     "SnapshotUpdatedWarning",

{assertpy2-2.25.0 → assertpy2-2.26.0}/assertpy2/_engine/_builder_check_typing.py

@@ -26,7 +26,15 @@ if TYPE_CHECKING:
     from .._matcher_impls import ClassInfo
     from ..matchers import Matcher
     from ..outcome import AssertionOutcome
-    from ._capable_typing import _Callable, _Keyed, _KeyedWithItems, _KeyedWithValues, _Orderable, _PathLike
+    from ._capable_typing import (
+        _Callable,
+        _Indexed,
+        _Keyed,
+        _KeyedWithItems,
+        _KeyedWithValues,
+        _Orderable,
+        _PathLike,
+    )
     from ._introspection import MappingLike
     from ._typing import (
         _U,
@@ -551,6 +559,53 @@ if TYPE_CHECKING:
 
         def matches_with_groups(self: _CheckAnyValue[str], pattern: str) -> AssertionOutcome: ...
 
+        @overload
+        def exists(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
+        @overload
+        def exists(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
+
+        @overload
+        def does_not_exist(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
+        @overload
+        def does_not_exist(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
+
+        @overload
+        def is_file(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
+        @overload
+        def is_file(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
+
+        @overload
+        def is_directory(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
+        @overload
+        def is_directory(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
+
+        @overload
+        def is_named(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path], filename: str) -> AssertionOutcome: ...
+        @overload
+        def is_named(self: _CheckAnyValue[_PathLike], filename: str) -> AssertionOutcome: ...
+
+        @overload
+        def is_child_of(
+            self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path], parent: object
+        ) -> AssertionOutcome: ...
+        @overload
+        def is_child_of(self: _CheckAnyValue[_PathLike], parent: object) -> AssertionOutcome: ...
+
+        @overload
+        def is_readable(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
+        @overload
+        def is_readable(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
+
+        @overload
+        def is_writable(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
+        @overload
+        def is_writable(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
+
+        @overload
+        def is_executable(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
+        @overload
+        def is_executable(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
+
         @overload
         def is_subset_of(
             self: _CheckAnyValue[str]
@@ -574,10 +629,11 @@ if TYPE_CHECKING:
             self: _CheckAnyValue[_CapableT], *supersets: object, allow_empty: bool = ...
         ) -> AssertionOutcome: ...
 
+        @overload
+        def contains_duplicates(self: _CheckAnyValue[str]) -> AssertionOutcome: ...
         @overload
         def contains_duplicates(
-            self: _CheckAnyValue[str]
-            | _CheckAnyValue[list[_E]]
+            self: _CheckAnyValue[list[_E]]
             | _CheckAnyValue[tuple[_E, ...]]
             | _CheckAnyValue[set[_E]]
             | _CheckAnyValue[frozenset[_E]],
@@ -585,10 +641,11 @@ if TYPE_CHECKING:
         @overload
         def contains_duplicates(self: _CheckAnyValue[_CapableT]) -> AssertionOutcome: ...
 
+        @overload
+        def does_not_contain_duplicates(self: _CheckAnyValue[str]) -> AssertionOutcome: ...
         @overload
         def does_not_contain_duplicates(
-            self: _CheckAnyValue[str]
-            | _CheckAnyValue[list[_E]]
+            self: _CheckAnyValue[list[_E]]
             | _CheckAnyValue[tuple[_E, ...]]
             | _CheckAnyValue[set[_E]]
             | _CheckAnyValue[frozenset[_E]],
@@ -596,10 +653,11 @@ if TYPE_CHECKING:
         @overload
         def does_not_contain_duplicates(self: _CheckAnyValue[_CapableT]) -> AssertionOutcome: ...
 
+        @overload
+        def contains_only_once(self: _CheckAnyValue[str], *items: object) -> AssertionOutcome: ...
         @overload
         def contains_only_once(
-            self: _CheckAnyValue[str]
-            | _CheckAnyValue[list[_E]]
+            self: _CheckAnyValue[list[_E]]
             | _CheckAnyValue[tuple[_E, ...]]
             | _CheckAnyValue[set[_E]]
             | _CheckAnyValue[frozenset[_E]],
@@ -608,17 +666,20 @@ if TYPE_CHECKING:
         @overload
         def contains_only_once(self: _CheckAnyValue[_CapableT], *items: object) -> AssertionOutcome: ...
 
+        @overload
+        def contains_in_order(self: _CheckAnyValue[str], *items: str | Matcher[str]) -> AssertionOutcome: ...
         @overload
         def contains_in_order(
-            self: _CheckAnyValue[str]
-            | _CheckAnyValue[list[_E]]
+            self: _CheckAnyValue[list[_E]]
             | _CheckAnyValue[tuple[_E, ...]]
             | _CheckAnyValue[set[_E]]
             | _CheckAnyValue[frozenset[_E]],
             *items: _E | Matcher[_E],
         ) -> AssertionOutcome: ...
         @overload
-        def contains_in_order(self: _CheckAnyValue[_CapableT], *items: _E | Matcher[_E]) -> AssertionOutcome: ...
+        def contains_in_order(
+            self: _CheckAnyValue[Iterable[_E] | _Indexed[_E]], *items: _E | Matcher[_E]
+        ) -> AssertionOutcome: ...
 
         @overload
         def has_same_size_as(
@@ -721,53 +782,6 @@ if TYPE_CHECKING:
         @overload
         def is_not_empty(self: _CheckAnyValue[_CapableT]) -> AssertionOutcome: ...
 
-        @overload
-        def exists(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
-        @overload
-        def exists(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
-
-        @overload
-        def does_not_exist(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
-        @overload
-        def does_not_exist(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
-
-        @overload
-        def is_file(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
-        @overload
-        def is_file(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
-
-        @overload
-        def is_directory(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
-        @overload
-        def is_directory(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
-
-        @overload
-        def is_named(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path], filename: str) -> AssertionOutcome: ...
-        @overload
-        def is_named(self: _CheckAnyValue[_PathLike], filename: str) -> AssertionOutcome: ...
-
-        @overload
-        def is_child_of(
-            self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path], parent: object
-        ) -> AssertionOutcome: ...
-        @overload
-        def is_child_of(self: _CheckAnyValue[_PathLike], parent: object) -> AssertionOutcome: ...
-
-        @overload
-        def is_readable(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
-        @overload
-        def is_readable(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
-
-        @overload
-        def is_writable(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
-        @overload
-        def is_writable(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
-
-        @overload
-        def is_executable(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...
-        @overload
-        def is_executable(self: _CheckAnyValue[_PathLike]) -> AssertionOutcome: ...
-
         @overload
         def is_positive(
             self: _CheckAnyValue[bool] | _CheckAnyValue[int] | _CheckAnyValue[float],

{assertpy2-2.25.0 → assertpy2-2.26.0}/assertpy2/_engine/_capable_typing.py

@@ -24,7 +24,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     import datetime
     import logging
-    from collections.abc import Callable, Collection, Iterable, Mapping, Sized
+    from collections.abc import Callable, Iterable, Mapping, Sized
     from pathlib import Path
     from typing import Any, Protocol, SupportsFloat, SupportsIndex, TypeVar, overload
 
@@ -49,6 +49,21 @@ if TYPE_CHECKING:
 
         def __lt__(self, other: Any, /) -> Any: ...
 
+    class _Indexed(Protocol[_E_co]):
+        """The older way to be a sequence: integer lookup that stops with `IndexError`, and no `__iter__`.
+
+        `list(value)` accepts it, so `contains_in_order()` runs on it, and asking only for `Iterable`
+        refused a value that works.
+
+        One shape gets through that the runtime refuses, and it cannot be spelled out of: a class with
+        this lookup and ``__iter__ = None`` disables the fallback, so `list(value)` raises while this
+        still matches.  Structural typing has no way to ask for the absence of a member, and the
+        direction is the safe one: the call is accepted here and refused with "val must be iterable"
+        when it runs, which is what every other umbrella rung already does.
+        """
+
+        def __getitem__(self, index: int, /) -> _E_co: ...
+
     class _Keyed(Protocol):
         """`keys()`, which the dict gate reads before anything else.
 
@@ -82,10 +97,14 @@ if TYPE_CHECKING:
         def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
 
     class _ElementSource(Protocol[_E_co]):
-        """Anything whose value is a collection of `_E_co`, spelled the way the builder spells it."""
+        """Anything whose value can be walked for `_E_co`, spelled the way the builder spells it.
+
+        `Iterable` and not `Collection`: a value with only `__iter__` fell through to the `Self` overload,
+        so `first()` kept the container's type after the value had become an element.
+        """
 
         @property
-        def value(self) -> Collection[_E_co]: ...
+        def value(self) -> Iterable[_E_co]: ...
 
     class _CapableAssertion(Protocol[_CapableT_co]):
         """What a value the umbrella claims can be asked."""
@@ -100,7 +119,7 @@ if TYPE_CHECKING:
         @property
         def value(self) -> _CapableT_co: ...
         @property
-        def not_(self) -> Self: ...
+        def not_(self) -> _NegatedCapableAssertion[_CapableT_co]: ...
         def __getattr__(self, name: str) -> Callable[..., Self]: ...
 
         # the builder's ladders, carried across: a narrowing lost here is lost for every value the umbrella claims
@@ -225,7 +244,9 @@ if TYPE_CHECKING:
         def contains_exactly(self, *items: object) -> Self: ...
         def contains_exactly_in_any_order(self, *items: object) -> Self: ...
         def contains_ignoring_case(self, *items: str) -> Self: ...
-        def contains_in_order(self, *items: object) -> Self: ...
+        def contains_in_order(
+            self: _CapableAssertion[Iterable[_E] | _Indexed[_E]], *items: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
         def contains_key(self: _CapableAssertion[_Keyed], *keys: object) -> _CapableAssertion[_CapableT_co]: ...
         def contains_none_of(self, *items: str) -> Self: ...
         def contains_only(self, *items: object) -> Self: ...
@@ -431,3 +452,278 @@ if TYPE_CHECKING:
         def zip_satisfies(
             self, other: Iterable[object], predicate: Callable[..., bool], *, allow_empty: bool = ...
         ) -> Self: ...
+
+    class _NegatedCapableAssertion(Protocol[_CapableT_co]):
+        """The negation twin of the capability facade: one step, then it back."""
+
+        def is_not_none(self) -> _CapableAssertion[_CapableT_co]: ...
+        @overload
+        def is_instance_of(self, some_class: tuple[type[_U], type[_U2]]) -> _CapableAssertion[_CapableT_co]: ...
+        @overload
+        def is_instance_of(
+            self, some_class: tuple[type[_U], type[_U2], type[_U3]]
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        @overload
+        def is_instance_of(self, some_class: type[_U]) -> _CapableAssertion[_CapableT_co]: ...
+        @overload
+        def is_instance_of(self, some_class: ClassInfo) -> _CapableAssertion[_CapableT_co]: ...
+        @overload
+        def is_instance_of_any(self, first: type[_U], second: type[_U2], /) -> _CapableAssertion[_CapableT_co]: ...
+        @overload
+        def is_instance_of_any(
+            self, first: type[_U], second: type[_U2], third: type[_U3], /
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        @overload
+        def is_instance_of_any(self, *some_classes: ClassInfo) -> _CapableAssertion[_CapableT_co]: ...
+        def satisfies(self, matcher: Matcher[Any] | Callable[..., bool]) -> _CapableAssertion[_CapableT_co]: ...
+        def all_fields_satisfy(
+            self, matcher: Matcher[Any] | Callable[..., bool], *, allow_empty: bool = ...
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def all_satisfy(
+            self, matcher: Matcher[Any] | Callable[..., bool], *, allow_empty: bool = ...
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def any_satisfy(self, matcher: Matcher[Any] | Callable[..., bool]) -> _CapableAssertion[_CapableT_co]: ...
+        def caused_by(self, ex: type) -> _CapableAssertion[_CapableT_co]: ...
+        def conforms_to_openapi(
+            self,
+            spec: dict[str, Any],
+            path: str,
+            method: str,
+            *,
+            status: str | int | None = ...,
+            content_type: str = ...,
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def contains(self, *items: object) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_any_of(self, *items: str) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_bytes(
+            self: _NegatedCapableAssertion[bytes | bytearray], sub: bytes | bytearray
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_duplicates(self) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_entry(
+            self: _NegatedCapableAssertion[_KeyedWithItems], *args: object, **kwargs: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_error(self, *ex_types: type) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_exactly(self, *items: object) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_exactly_in_any_order(self, *items: object) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_ignoring_case(self, *items: str) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_in_order(
+            self: _NegatedCapableAssertion[Iterable[_E] | _Indexed[_E]], *items: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_key(self: _NegatedCapableAssertion[_Keyed], *keys: object) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_none_of(self, *items: str) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_only(self, *items: object) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_only_once(self, *items: object) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_sequence(self, *items: object) -> _CapableAssertion[_CapableT_co]: ...
+        def contains_value(
+            self: _NegatedCapableAssertion[_KeyedWithValues], *values: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def does_not_contain(self, *items: object) -> _CapableAssertion[_CapableT_co]: ...
+        def does_not_contain_duplicates(self) -> _CapableAssertion[_CapableT_co]: ...
+        def does_not_contain_entry(
+            self: _NegatedCapableAssertion[_KeyedWithItems], *args: object, **kwargs: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def does_not_contain_error(self, *ex_types: type) -> _CapableAssertion[_CapableT_co]: ...
+        def does_not_contain_key(
+            self: _NegatedCapableAssertion[_Keyed], *keys: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def does_not_contain_value(
+            self: _NegatedCapableAssertion[_KeyedWithValues], *values: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def does_not_exist(self: _NegatedCapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
+        def does_not_have_json_path(self, path: str) -> _CapableAssertion[_CapableT_co]: ...
+        def does_not_match(self: _NegatedCapableAssertion[str], pattern: str) -> _CapableAssertion[_CapableT_co]: ...
+        def each(
+            self, matcher: Matcher[Any] | Callable[..., bool], *, allow_empty: bool = ...
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def ends_with(self, suffix: object) -> _CapableAssertion[_CapableT_co]: ...
+        def ends_with_ignoring_case(
+            self: _NegatedCapableAssertion[str], suffix: str
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def error_of(self, ex: type) -> _CapableAssertion[_CapableT_co]: ...
+        def exists(self: _NegatedCapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
+        def extracting_group(
+            self: _NegatedCapableAssertion[str], pattern: str, group: int | str = ...
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def has_byte_at(
+            self: _NegatedCapableAssertion[bytes | bytearray], index: int, expected: int
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def has_json_path(self, path: str) -> _CapableAssertion[_CapableT_co]: ...
+        def has_no_none_fields(self, *, allow_empty: bool = ...) -> _CapableAssertion[_CapableT_co]: ...
+        def has_root_cause(self, ex: type) -> _CapableAssertion[_CapableT_co]: ...
+        def has_same_size_as(self, other: Sized) -> _CapableAssertion[_CapableT_co]: ...
+        def has_size_between(self, low: int, high: int) -> _CapableAssertion[_CapableT_co]: ...
+        def has_size_greater_than(self, size: int) -> _CapableAssertion[_CapableT_co]: ...
+        def has_size_less_than(self, size: int) -> _CapableAssertion[_CapableT_co]: ...
+        def is_after(
+            self: _NegatedCapableAssertion[datetime.datetime], other: datetime.datetime
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_after_or_equal_to(
+            self: _NegatedCapableAssertion[datetime.datetime], other: datetime.datetime
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_alpha(self: _NegatedCapableAssertion[str]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_alphanumeric(self: _NegatedCapableAssertion[str]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_array_close_to(
+            self, expected: object, *, rtol: float = ..., atol: float = ..., equal_nan: bool = ..., **options: Any
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_array_equal(self, expected: object, **options: Any) -> _CapableAssertion[_CapableT_co]: ...
+        def is_before(
+            self: _NegatedCapableAssertion[datetime.datetime], other: datetime.datetime
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_before_or_equal_to(
+            self: _NegatedCapableAssertion[datetime.datetime], other: datetime.datetime
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_between(self, low: object, high: object) -> _CapableAssertion[_CapableT_co]: ...
+        def is_callable(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_child_of(
+            self: _NegatedCapableAssertion[_PathLike], parent: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_close_to(
+            self: _NegatedCapableAssertion[SupportsFloat | SupportsIndex],
+            other: SupportsFloat | SupportsIndex | datetime.datetime,
+            tolerance: SupportsFloat | SupportsIndex | datetime.timedelta,
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_digit(self: _NegatedCapableAssertion[str]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_directory(self: _NegatedCapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_divisible_by(self: _NegatedCapableAssertion[int], divisor: int) -> _CapableAssertion[_CapableT_co]: ...
+        def is_empty(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_equal_to(self, other: object, **kwargs: object) -> _CapableAssertion[_CapableT_co]: ...
+        def is_equal_to_ignoring_case(
+            self: _NegatedCapableAssertion[str], other: str
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_equal_to_ignoring_milliseconds(
+            self: _NegatedCapableAssertion[datetime.datetime], other: datetime.datetime
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_equal_to_ignoring_seconds(
+            self: _NegatedCapableAssertion[datetime.datetime], other: datetime.datetime
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_equal_to_ignoring_time(
+            self: _NegatedCapableAssertion[datetime.datetime], other: datetime.datetime
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_equal_to_ignoring_whitespace(
+            self: _NegatedCapableAssertion[str], other: str
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_even(self: _NegatedCapableAssertion[int]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_executable(self: _NegatedCapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_false(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_file(self: _NegatedCapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_frame_equal(self, expected: object, **options: Any) -> _CapableAssertion[_CapableT_co]: ...
+        def is_greater_than(
+            self: _NegatedCapableAssertion[_Orderable], other: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_greater_than_or_equal_to(
+            self: _NegatedCapableAssertion[_Orderable], other: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_hex_equal_to(
+            self: _NegatedCapableAssertion[bytes | bytearray], expected_hex: str
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_in(self, *items: object) -> _CapableAssertion[_CapableT_co]: ...
+        def is_inf(
+            self: _NegatedCapableAssertion[SupportsFloat | SupportsIndex],
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_iterable(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_length(self, length: int) -> _CapableAssertion[_CapableT_co]: ...
+        def is_length_between(self, low: int, high: int) -> _CapableAssertion[_CapableT_co]: ...
+        def is_less_than(
+            self: _NegatedCapableAssertion[_Orderable], other: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_less_than_or_equal_to(
+            self: _NegatedCapableAssertion[_Orderable], other: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_lower(self: _NegatedCapableAssertion[str]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_named(self: _NegatedCapableAssertion[_PathLike], filename: str) -> _CapableAssertion[_CapableT_co]: ...
+        def is_nan(
+            self: _NegatedCapableAssertion[SupportsFloat | SupportsIndex],
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_negative(self: _NegatedCapableAssertion[_Orderable]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_none(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_between(self, low: object, high: object) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_callable(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_close_to(
+            self,
+            other: SupportsFloat | SupportsIndex | datetime.datetime,
+            tolerance: SupportsFloat | SupportsIndex | datetime.timedelta,
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_empty(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_equal_to(self, other: object) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_in(self, *items: object) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_inf(
+            self: _NegatedCapableAssertion[SupportsFloat | SupportsIndex],
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_iterable(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_nan(
+            self: _NegatedCapableAssertion[SupportsFloat | SupportsIndex],
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_same_as(self, other: object) -> _CapableAssertion[_CapableT_co]: ...
+        def is_not_zero(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_odd(self: _NegatedCapableAssertion[int]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_positive(self: _NegatedCapableAssertion[_Orderable]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_readable(self: _NegatedCapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_same_as(self, other: object) -> _CapableAssertion[_CapableT_co]: ...
+        def is_sorted(
+            self, key: Callable[[Any], Any] = ..., reverse: bool = ..., *, allow_empty: bool = ...
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_subclass_of(self, some_class: type) -> _CapableAssertion[_CapableT_co]: ...
+        def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _CapableAssertion[_CapableT_co]: ...
+        def is_true(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_type_of(self, some_type: type) -> _CapableAssertion[_CapableT_co]: ...
+        def is_unicode(self) -> _CapableAssertion[_CapableT_co]: ...
+        def is_upper(self: _NegatedCapableAssertion[str]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_valid_encoding(
+            self: _NegatedCapableAssertion[bytes | bytearray], encoding: str
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def is_valid_utf8(self: _NegatedCapableAssertion[bytes | bytearray]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_whitespace(self: _NegatedCapableAssertion[str]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_writable(self: _NegatedCapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
+        def is_zero(self) -> _CapableAssertion[_CapableT_co]: ...
+        def matches(self: _NegatedCapableAssertion[str], pattern: str) -> _CapableAssertion[_CapableT_co]: ...
+        def matches_contract_snapshot(
+            self, id: str | None = ..., path: str = ...
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def matches_error_tree(self, *expected: type | list[Any]) -> _CapableAssertion[_CapableT_co]: ...
+        def matches_inline(
+            self,
+            expected: object = ...,
+            *,
+            ignore: object = ...,
+            include: object = ...,
+            tolerance: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def matches_json_schema(self, schema: dict[str, Any]) -> _CapableAssertion[_CapableT_co]: ...
+        def matches_json_schema_from_file(self, path: str | Path) -> _CapableAssertion[_CapableT_co]: ...
+        def matches_structure(self, spec: dict[Any, Any]) -> _CapableAssertion[_CapableT_co]: ...
+        def matches_with_groups(
+            self: _NegatedCapableAssertion[str], pattern: str
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def none_satisfy(self, matcher: Matcher[Any] | Callable[..., bool]) -> _CapableAssertion[_CapableT_co]: ...
+        def satisfies_exactly(
+            self, *matchers: Matcher[Any] | Callable[..., bool]
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def satisfies_exactly_in_any_order(
+            self, *matchers: Matcher[Any] | Callable[..., bool]
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def snapshot(
+            self,
+            id: str | None = ...,
+            path: str = ...,
+            *,
+            ignore: object = ...,
+            include: object = ...,
+            tolerance: float | None = ...,
+            comparators: dict[Any, Callable[[Any, Any], Any]] | None = ...,
+            placeholders: Mapping[Any, Matcher[Any] | Callable[[Any], object]] | None = ...,
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def starts_with(self, prefix: object) -> _CapableAssertion[_CapableT_co]: ...
+        def starts_with_bytes(
+            self: _NegatedCapableAssertion[bytes | bytearray], prefix: bytes | bytearray
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def starts_with_ignoring_case(
+            self: _NegatedCapableAssertion[str], prefix: str
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def when_called_with(
+            self: _NegatedCapableAssertion[_Callable], *some_args: object, **some_kwargs: object
+        ) -> _CapableAssertion[_CapableT_co]: ...
+        def zip_satisfies(
+            self, other: Iterable[object], predicate: Callable[..., bool], *, allow_empty: bool = ...
+        ) -> _CapableAssertion[_CapableT_co]: ...

{assertpy2-2.25.0 → assertpy2-2.26.0}/assertpy2/_engine/_mixin_base.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     from ..errors import AssertionFailure, DiffResult, PollTrace
     from ..http_mixin import _Response
-    from ..outcome import AssertionOutcome
+    from ..outcome import AssertionOutcome, Requirement
     from ._compare import _CompareConfig
     from ._compat import Self
     from ._introspection import WarningLogger
@@ -45,6 +45,7 @@ class _MixinBase:
             actual: object = ...,
             expected: object = ...,
             diff: DiffResult | None = ...,
+            requirement: Requirement | None = ...,
             suppress_context: bool = ...,
         ) -> Self: ...
 
@@ -56,6 +57,7 @@ class _MixinBase:
             expected: object,
             diff: DiffResult | None,
             trace: PollTrace | None,
+            requirement: Requirement | None = ...,
         ) -> AssertionOutcome: ...
 
         @staticmethod