assertpy2 2.27.0__tar.gz → 2.28.0__tar.gz

{assertpy2-2.27.0 → assertpy2-2.28.0}/CONTRIBUTING.md

@@ -114,6 +114,20 @@ change. The baseline test passes the same target itself, so it gives one answer
 - `tests/test_docs_examples.py` is run separately because it executes the snippets in `docs/`, which
   needs the `docs-examples` group and a different collection.
 
+### When a gate says an answer moved
+
+Two gates record what the library currently decides rather than what it should. Both fail on a change
+and neither is a failure to paper over: read the diff, decide whether the change is meant to ship, then
+re-record it in the same commit so the diff carries the decision into review.
+
+```bash
+ASSERTPY2_UPDATE_API=1 uv run pytest tests/test_api_compatibility.py      # the public surface
+ASSERTPY2_UPDATE_VERDICTS=1 uv run pytest tests/test_verdict_corpus.py    # what each input decides
+```
+
+The second one's diff is the draft of the release's Behaviour changes section, so read it before
+writing that section rather than after.
+
 ## Commit style
 
 Use [Conventional Commits](https://www.conventionalcommits.org/): `feat:`, `fix:`, `refactor:`, `test:`, `docs:`, `chore:`, etc.

{assertpy2-2.27.0 → assertpy2-2.28.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: assertpy2
-Version: 2.27.0
-Summary: Fluent assertion library for Python with composable matchers, structural matching, and full type safety
+Version: 2.28.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/Solganis/assertpy2
 Project-URL: Repository, https://github.com/Solganis/assertpy2
 Project-URL: Issues, https://github.com/Solganis/assertpy2/issues

{assertpy2-2.27.0 → assertpy2-2.28.0}/assertpy2/_dangling.py

@@ -40,7 +40,7 @@ from __future__ import annotations
 import ast
 import io
 import tokenize
-from typing import Final, NamedTuple
+from typing import TYPE_CHECKING, Final, NamedTuple
 
 from ._engine._operations import (
     ALSO_ASSERTS,
@@ -52,6 +52,9 @@ from ._engine._operations import (
     WITHOUT_A_VERDICT,
 )
 
+if TYPE_CHECKING:
+    import pathlib
+
 __tracebackhide__ = True
 
 # the builder factories and only those: everything else either asserts by itself or is not an entry point
@@ -440,6 +443,23 @@ def _silenced(statement: ast.stmt, marked: frozenset[int]) -> bool:
     return any(line in marked for line in range(statement.lineno, last + 1))
 
 
+def read_module(path: pathlib.Path) -> str:
+    """A test module's text as the interpreter decodes it, which is what `findings` reads.
+
+    The encoding a PEP 263 cookie or a BOM declares, found the way `tokenize` finds it, and UTF-8 where
+    none is declared.  A byte that still does not decode is replaced rather than refused: 3.10 to 3.13
+    import a module whose comment is not UTF-8, and reading it strictly aborted a whole run from the
+    collection hook.  A comment's text is not something the check reads.
+    """
+    data = path.read_bytes()
+    try:
+        encoding = tokenize.detect_encoding(io.BytesIO(data).readline)[0]
+    except SyntaxError:
+        # a first line that is not UTF-8 and names no encoding, which 3.10 to 3.13 import all the same
+        encoding = "utf-8"
+    return data.decode(encoding, errors="replace")
+
+
 def findings(source: str, path: str, extra_entries: frozenset[str] = frozenset()) -> list[Finding]:
     """Report the offending statements in one module's source.
 

{assertpy2-2.27.0 → assertpy2-2.28.0}/assertpy2/_engine/_builder_check_typing.py

@@ -272,7 +272,15 @@ if TYPE_CHECKING:
             *items: _E | Matcher[_E],
         ) -> AssertionOutcome: ...
         @overload
-        def does_not_contain(self: _CheckAnyValue[_CapableT], *items: str | Matcher[str]) -> AssertionOutcome: ...
+        def does_not_contain(
+            self: _CheckAnyValue[bytes] | _CheckAnyValue[bytearray], *items: object
+        ) -> AssertionOutcome: ...
+        @overload
+        def does_not_contain(
+            self: _CheckAnyValue[_FrameT_co] | _CheckAnyValue[_ArrayT_co], *items: object
+        ) -> AssertionOutcome: ...
+        @overload
+        def does_not_contain(self: _CheckAnyValue[_CapableT], *items: object) -> AssertionOutcome: ...
 
         @overload
         def contains_only(self: _CheckAnyValue[str], *items: str | Matcher[str]) -> AssertionOutcome: ...
@@ -709,10 +717,10 @@ if TYPE_CHECKING:
             | _CheckAnyValue[bytearray]
             | _CheckAnyValue[_FrameT_co]
             | _CheckAnyValue[_ArrayT_co],
-            size: int,
+            size: SupportsIndex,
         ) -> AssertionOutcome: ...
         @overload
-        def has_size_greater_than(self: _CheckAnyValue[_CapableT], size: int) -> AssertionOutcome: ...
+        def has_size_greater_than(self: _CheckAnyValue[_CapableT], size: SupportsIndex) -> AssertionOutcome: ...
 
         @overload
         def has_size_less_than(
@@ -726,10 +734,10 @@ if TYPE_CHECKING:
             | _CheckAnyValue[bytearray]
             | _CheckAnyValue[_FrameT_co]
             | _CheckAnyValue[_ArrayT_co],
-            size: int,
+            size: SupportsIndex,
         ) -> AssertionOutcome: ...
         @overload
-        def has_size_less_than(self: _CheckAnyValue[_CapableT], size: int) -> AssertionOutcome: ...
+        def has_size_less_than(self: _CheckAnyValue[_CapableT], size: SupportsIndex) -> AssertionOutcome: ...
 
         @overload
         def has_size_between(
@@ -743,11 +751,13 @@ if TYPE_CHECKING:
             | _CheckAnyValue[bytearray]
             | _CheckAnyValue[_FrameT_co]
             | _CheckAnyValue[_ArrayT_co],
-            low: int,
-            high: int,
+            low: SupportsIndex,
+            high: SupportsIndex,
         ) -> AssertionOutcome: ...
         @overload
-        def has_size_between(self: _CheckAnyValue[_CapableT], low: int, high: int) -> AssertionOutcome: ...
+        def has_size_between(
+            self: _CheckAnyValue[_CapableT], low: SupportsIndex, high: SupportsIndex
+        ) -> AssertionOutcome: ...
 
         @overload
         def is_empty(
@@ -820,46 +830,16 @@ if TYPE_CHECKING:
         def is_not_inf(self: _CheckAnyValue[SupportsFloat | SupportsIndex]) -> AssertionOutcome: ...
 
         @overload
-        def is_close_to(
-            self: _CheckAnyValue[bool] | _CheckAnyValue[int] | _CheckAnyValue[float], other: _Number, tolerance: _Number
-        ) -> AssertionOutcome: ...
-        @overload
-        def is_close_to(
-            self: _CheckAnyValue[datetime.datetime], other: datetime.datetime, tolerance: datetime.timedelta
-        ) -> AssertionOutcome: ...
-        @overload
-        def is_close_to(
-            self: _CheckAnyValue[SupportsFloat | SupportsIndex],
-            other: SupportsFloat | SupportsIndex,
-            tolerance: SupportsFloat | SupportsIndex,
-        ) -> AssertionOutcome: ...
-        @overload
-        def is_close_to(
-            self: _CheckAnyValue[SupportsFloat | SupportsIndex], other: _Number, tolerance: _Number
-        ) -> AssertionOutcome: ...
-
-        @overload
-        def is_not_close_to(
-            self: _CheckAnyValue[bool] | _CheckAnyValue[int] | _CheckAnyValue[float], other: _Number, tolerance: _Number
-        ) -> AssertionOutcome: ...
-        @overload
-        def is_not_close_to(
-            self: _CheckAnyValue[datetime.datetime], other: datetime.datetime, tolerance: datetime.timedelta
-        ) -> AssertionOutcome: ...
-        @overload
-        def is_not_close_to(
-            self: _CheckAnyValue[SupportsFloat | SupportsIndex],
-            other: SupportsFloat | SupportsIndex,
-            tolerance: SupportsFloat | SupportsIndex,
+        def is_not_between(
+            self: _CheckAnyValue[bool] | _CheckAnyValue[int] | _CheckAnyValue[float], low: _Number, high: _Number
         ) -> AssertionOutcome: ...
         @overload
-        def is_not_close_to(
-            self: _CheckAnyValue[_CapableT], other: _Number, tolerance: _Number
+        def is_not_between(
+            self: _CheckAnyValue[datetime.datetime], low: datetime.datetime, high: datetime.datetime
         ) -> AssertionOutcome: ...
-
         @overload
         def is_not_between(
-            self: _CheckAnyValue[bool] | _CheckAnyValue[int] | _CheckAnyValue[float], low: _Number, high: _Number
+            self: _CheckAnyValue[datetime.date], low: datetime.date, high: datetime.date
         ) -> AssertionOutcome: ...
         @overload
         def is_not_between(self: _CheckAnyValue[_T], low: Any, high: Any) -> AssertionOutcome: ...
@@ -901,6 +881,44 @@ if TYPE_CHECKING:
         @overload
         def is_not_zero(self: _CheckAnyValue[_CapableT]) -> AssertionOutcome: ...
 
+        @overload
+        def is_close_to(
+            self: _CheckAnyValue[int] | _CheckAnyValue[float], other: _Number, tolerance: _Number
+        ) -> AssertionOutcome: ...
+        @overload
+        def is_close_to(
+            self: _CheckAnyValue[datetime.datetime], other: datetime.datetime, tolerance: datetime.timedelta
+        ) -> AssertionOutcome: ...
+        @overload
+        def is_close_to(
+            self: _CheckAnyValue[SupportsFloat | SupportsIndex],
+            other: SupportsFloat | SupportsIndex,
+            tolerance: SupportsFloat | SupportsIndex,
+        ) -> AssertionOutcome: ...
+        @overload
+        def is_close_to(
+            self: _CheckAnyValue[SupportsFloat | SupportsIndex], other: _Number, tolerance: _Number
+        ) -> AssertionOutcome: ...
+
+        @overload
+        def is_not_close_to(
+            self: _CheckAnyValue[int] | _CheckAnyValue[float], other: _Number, tolerance: _Number
+        ) -> AssertionOutcome: ...
+        @overload
+        def is_not_close_to(
+            self: _CheckAnyValue[datetime.datetime], other: datetime.datetime, tolerance: datetime.timedelta
+        ) -> AssertionOutcome: ...
+        @overload
+        def is_not_close_to(
+            self: _CheckAnyValue[SupportsFloat | SupportsIndex],
+            other: SupportsFloat | SupportsIndex,
+            tolerance: SupportsFloat | SupportsIndex,
+        ) -> AssertionOutcome: ...
+        @overload
+        def is_not_close_to(
+            self: _CheckAnyValue[_CapableT], other: _Number, tolerance: _Number
+        ) -> AssertionOutcome: ...
+
         @overload
         def is_even(self: _CheckAnyValue[int] | _CheckAnyValue[float]) -> AssertionOutcome: ...
         @overload
@@ -912,9 +930,11 @@ if TYPE_CHECKING:
         def is_odd(self: _CheckAnyValue[int]) -> AssertionOutcome: ...
 
         @overload
-        def is_divisible_by(self: _CheckAnyValue[int] | _CheckAnyValue[float], divisor: int) -> AssertionOutcome: ...
+        def is_divisible_by(
+            self: _CheckAnyValue[int] | _CheckAnyValue[float], divisor: SupportsIndex
+        ) -> AssertionOutcome: ...
         @overload
-        def is_divisible_by(self: _CheckAnyValue[int], divisor: int) -> AssertionOutcome: ...
+        def is_divisible_by(self: _CheckAnyValue[int], divisor: SupportsIndex) -> AssertionOutcome: ...
 
         @overload
         def contains_key(self: _CheckAnyValue[dict[_K, _V]], *keys: _K | Matcher[_K]) -> AssertionOutcome: ...
@@ -1090,10 +1110,12 @@ if TYPE_CHECKING:
 
         @overload
         def has_byte_at(
-            self: _CheckAnyValue[bytes] | _CheckAnyValue[bytearray], index: int, expected: int
+            self: _CheckAnyValue[bytes] | _CheckAnyValue[bytearray], index: SupportsIndex, expected: SupportsIndex
         ) -> AssertionOutcome: ...
         @overload
-        def has_byte_at(self: _CheckAnyValue[bytes | bytearray], index: int, expected: int) -> AssertionOutcome: ...
+        def has_byte_at(
+            self: _CheckAnyValue[bytes | bytearray], index: SupportsIndex, expected: SupportsIndex
+        ) -> AssertionOutcome: ...
 
         @overload
         def is_hex_equal_to(
@@ -1248,11 +1270,11 @@ if TYPE_CHECKING:
 
         def is_type_of(self, some_type: type) -> AssertionOutcome: ...
 
-        def is_subclass_of(self, some_class: type) -> AssertionOutcome: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> AssertionOutcome: ...
 
-        def is_length(self, length: int) -> AssertionOutcome: ...
+        def is_length(self, length: SupportsIndex) -> AssertionOutcome: ...
 
-        def is_length_between(self, low: int, high: int) -> AssertionOutcome: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> AssertionOutcome: ...
 
         def is_callable(self) -> AssertionOutcome: ...
 

{assertpy2-2.27.0 → assertpy2-2.28.0}/assertpy2/_engine/_capable_typing.py

@@ -35,8 +35,19 @@ if TYPE_CHECKING:
     from ..matchers import Matcher
     from ._builder_check_typing import _CheckAnyValue
     from ._compat import Self
-    from ._poll_typing import _AsyncPoll, _SyncPoll
-    from ._typing import _E, _K, _R, _U, _V
+    from ._poll_typing import _AsyncPoll, _NoExpectationOnAChain, _SyncPoll
+    from ._typing import (
+        _E,
+        _K,
+        _R,
+        _U,
+        _V,
+        _ExpectedCompletionAssertion,
+        _ExpectedRaiseAssertion,
+        _ExpectedWarningAssertion,
+        _Landed,
+        _ListAssertion,
+    )
 
     # covariant: the façade only ever hands the subject back, through `value`
     _CapableT_co = TypeVar("_CapableT_co", covariant=True)
@@ -158,11 +169,11 @@ if TYPE_CHECKING:
         @overload
         def last(self) -> Self: ...
         @overload
-        def element(self: _CapableAssertion[Mapping[_K, _V]], index: int) -> AssertionBuilder[_K]: ...
+        def element(self: _CapableAssertion[Mapping[_K, _V]], index: SupportsIndex) -> AssertionBuilder[_K]: ...
         @overload
-        def element(self: _ElementSource[_E], index: int) -> AssertionBuilder[_E]: ...
+        def element(self: _ElementSource[_E], index: SupportsIndex) -> AssertionBuilder[_E]: ...
         @overload
-        def element(self, index: int) -> Self: ...
+        def element(self, index: SupportsIndex) -> Self: ...
         @overload
         def mapped(self: _ElementSource[_E], func: Callable[[_E], _R]) -> AssertionBuilder[list[_R]]: ...
         @overload
@@ -194,6 +205,21 @@ if TYPE_CHECKING:
             ignoring: type[Exception] | tuple[type[Exception], ...] = ...,
             trace: bool = ...,
         ) -> _SyncPoll[Any]: ...
+        # where the callable view lands: flattened, the runtime's `-> Self` kept a caught message typed as the callable
+        @overload
+        def raises(self: _CapableAssertion[_Callable], ex: type[_Landed]) -> _ExpectedRaiseAssertion[Any, _Landed]: ...
+        @overload
+        def raises(self: _CapableAssertion[_Callable], ex: type) -> _ExpectedRaiseAssertion[Any, BaseException]: ...
+        def does_not_raise(self: _CapableAssertion[_Callable], ex: type) -> _ExpectedCompletionAssertion[Any]: ...
+        def warns(
+            self: _CapableAssertion[_Callable], warning: type[Warning] = ...
+        ) -> _ExpectedWarningAssertion[Any]: ...
+        def does_not_warn(
+            self: _CapableAssertion[_Callable], warning: type[Warning] = ...
+        ) -> _ExpectedCompletionAssertion[Any]: ...
+
+        when_called_with: _NoExpectationOnAChain
+
         # the builder's own helpers: left to `__getattr__`, `builder()` read as this facade over the value already here
         def builder(
             self,
@@ -220,8 +246,8 @@ if TYPE_CHECKING:
         ) -> Self: ...
         def all_satisfy(self, matcher: Matcher[Any] | Callable[..., bool], *, allow_empty: bool = ...) -> Self: ...
         def any_satisfy(self, matcher: Matcher[Any] | Callable[..., bool]) -> Self: ...
-        def at_json_path(self, path: str) -> Self: ...
-        def caused_by(self, ex: type) -> Self: ...
+        def at_json_path(self, path: str) -> AssertionBuilder[Any]: ...
+        def caused_by(self, ex: ClassInfo) -> AssertionBuilder[Any]: ...
         def conforms_to_openapi(
             self,
             spec: dict[str, Any],
@@ -255,9 +281,7 @@ if TYPE_CHECKING:
         def contains_value(
             self: _CapableAssertion[_KeyedWithValues], *values: object
         ) -> _CapableAssertion[_CapableT_co]: ...
-        def decoded_as(
-            self: _CapableAssertion[bytes | bytearray], encoding: str = ...
-        ) -> _CapableAssertion[_CapableT_co]: ...
+        def decoded_as(self: _CapableAssertion[bytes | bytearray], encoding: str = ...) -> AssertionBuilder[Any]: ...
         def decoded_as_json(self) -> AssertionBuilder[object]: ...
         def described_as(self, description: str) -> Self: ...
         def does_not_contain(self, *items: object) -> Self: ...
@@ -273,32 +297,28 @@ if TYPE_CHECKING:
         def does_not_exist(self: _CapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
         def does_not_have_json_path(self, path: str) -> Self: ...
         def does_not_match(self: _CapableAssertion[str], pattern: str) -> _CapableAssertion[_CapableT_co]: ...
-        def does_not_raise(self: _CapableAssertion[_Callable], ex: type) -> _CapableAssertion[_CapableT_co]: ...
-        def does_not_warn(
-            self: _CapableAssertion[_Callable], warning: type[Warning] = ...
-        ) -> _CapableAssertion[_CapableT_co]: ...
         def each(self, matcher: Matcher[Any] | Callable[..., bool], *, allow_empty: bool = ...) -> Self: ...
         def ends_with(self, suffix: object) -> Self: ...
         def ends_with_ignoring_case(self: _CapableAssertion[str], suffix: str) -> _CapableAssertion[_CapableT_co]: ...
-        def error_of(self, ex: type) -> Self: ...
-        def errors(self) -> Self: ...
+        def error_of(self, ex: type) -> AssertionBuilder[Any]: ...
+        def errors(self) -> AssertionBuilder[Any]: ...
         def exists(self: _CapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
-        def extracting(self, *names: object, **kwargs: object) -> Self: ...
+        def extracting(self, *names: object, **kwargs: object) -> _ListAssertion[Any]: ...
         def extracting_group(
             self: _CapableAssertion[str], pattern: str, group: int | str = ...
-        ) -> _CapableAssertion[_CapableT_co]: ...
-        def filtered_on(self, predicate: Matcher[Any] | Callable[[Any], bool]) -> Self: ...
-        def flat_mapped(self, func: Callable[[Any], Iterable[Any]]) -> Self: ...
+        ) -> AssertionBuilder[Any]: ...
+        def filtered_on(self, predicate: Matcher[Any] | Callable[[Any], bool]) -> _ListAssertion[Any]: ...
+        def flat_mapped(self, func: Callable[[Any], Iterable[Any]]) -> _ListAssertion[Any]: ...
         def has_byte_at(
-            self: _CapableAssertion[bytes | bytearray], index: int, expected: int
+            self: _CapableAssertion[bytes | bytearray], index: SupportsIndex, expected: SupportsIndex
         ) -> _CapableAssertion[_CapableT_co]: ...
         def has_json_path(self, path: str) -> Self: ...
         def has_no_none_fields(self, *, allow_empty: bool = ...) -> Self: ...
-        def has_root_cause(self, ex: type) -> Self: ...
+        def has_root_cause(self, ex: ClassInfo) -> AssertionBuilder[Any]: ...
         def has_same_size_as(self, other: Sized) -> Self: ...
-        def has_size_between(self, low: int, high: int) -> Self: ...
-        def has_size_greater_than(self, size: int) -> Self: ...
-        def has_size_less_than(self, size: int) -> Self: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> Self: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> Self: ...
+        def has_size_less_than(self, size: SupportsIndex) -> Self: ...
         def is_after(
             self: _CapableAssertion[datetime.datetime], other: datetime.datetime
         ) -> _CapableAssertion[_CapableT_co]: ...
@@ -327,7 +347,9 @@ if TYPE_CHECKING:
         ) -> _CapableAssertion[_CapableT_co]: ...
         def is_digit(self: _CapableAssertion[str]) -> _CapableAssertion[_CapableT_co]: ...
         def is_directory(self: _CapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
-        def is_divisible_by(self: _CapableAssertion[int], divisor: int) -> _CapableAssertion[_CapableT_co]: ...
+        def is_divisible_by(
+            self: _CapableAssertion[int], divisor: SupportsIndex
+        ) -> _CapableAssertion[_CapableT_co]: ...
         def is_empty(self) -> Self: ...
         def is_equal_to(self, other: object, **kwargs: object) -> Self: ...
         def is_equal_to_ignoring_case(self: _CapableAssertion[str], other: str) -> _CapableAssertion[_CapableT_co]: ...
@@ -358,8 +380,8 @@ if TYPE_CHECKING:
         def is_in(self, *items: object) -> Self: ...
         def is_inf(self: _CapableAssertion[SupportsFloat | SupportsIndex]) -> _CapableAssertion[_CapableT_co]: ...
         def is_iterable(self) -> Self: ...
-        def is_length(self, length: int) -> Self: ...
-        def is_length_between(self, low: int, high: int) -> Self: ...
+        def is_length(self, length: SupportsIndex) -> Self: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> Self: ...
         def is_less_than(self: _CapableAssertion[_Orderable], other: object) -> _CapableAssertion[_CapableT_co]: ...
         def is_less_than_or_equal_to(
             self: _CapableAssertion[_Orderable], other: object
@@ -391,7 +413,7 @@ if TYPE_CHECKING:
         def is_sorted(
             self, key: Callable[[Any], Any] = ..., reverse: bool = ..., *, allow_empty: bool = ...
         ) -> Self: ...
-        def is_subclass_of(self, some_class: type) -> Self: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> Self: ...
         def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> Self: ...
         def is_true(self) -> Self: ...
         def is_type_of(self, some_type: type) -> Self: ...
@@ -420,11 +442,10 @@ if TYPE_CHECKING:
         def matches_json_schema(self, schema: dict[str, Any]) -> Self: ...
         def matches_json_schema_from_file(self, path: str | Path) -> Self: ...
         def matches_structure(self, spec: dict[Any, Any]) -> Self: ...
-        def matches_with_groups(self: _CapableAssertion[str], pattern: str) -> _CapableAssertion[_CapableT_co]: ...
+        def matches_with_groups(self: _CapableAssertion[str], pattern: str) -> AssertionBuilder[Any]: ...
         def none_satisfy(self, matcher: Matcher[Any] | Callable[..., bool]) -> Self: ...
-        def raised(self) -> Self: ...
-        def raises(self: _CapableAssertion[_Callable], ex: type) -> _CapableAssertion[_CapableT_co]: ...
-        def returned(self) -> Self: ...
+        def raised(self) -> AssertionBuilder[Any]: ...
+        def returned(self) -> AssertionBuilder[Any]: ...
         def satisfies_exactly(self, *matchers: Matcher[Any] | Callable[..., bool]) -> Self: ...
         def satisfies_exactly_in_any_order(self, *matchers: Matcher[Any] | Callable[..., bool]) -> Self: ...
         def snapshot(
@@ -443,12 +464,6 @@ if TYPE_CHECKING:
             self: _CapableAssertion[bytes | bytearray], prefix: bytes | bytearray
         ) -> _CapableAssertion[_CapableT_co]: ...
         def starts_with_ignoring_case(self: _CapableAssertion[str], prefix: str) -> _CapableAssertion[_CapableT_co]: ...
-        def warns(
-            self: _CapableAssertion[_Callable], warning: type[Warning] = ...
-        ) -> _CapableAssertion[_CapableT_co]: ...
-        def when_called_with(
-            self: _CapableAssertion[_Callable], *some_args: object, **some_kwargs: object
-        ) -> _CapableAssertion[_CapableT_co]: ...
         def zip_satisfies(
             self, other: Iterable[object], predicate: Callable[..., bool], *, allow_empty: bool = ...
         ) -> Self: ...
@@ -483,7 +498,7 @@ if TYPE_CHECKING:
             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 caused_by(self, ex: ClassInfo) -> _CapableAssertion[_CapableT_co]: ...
         def conforms_to_openapi(
             self,
             spec: dict[str, Any],
@@ -545,15 +560,15 @@ if TYPE_CHECKING:
             self: _NegatedCapableAssertion[str], pattern: str, group: int | str = ...
         ) -> _CapableAssertion[_CapableT_co]: ...
         def has_byte_at(
-            self: _NegatedCapableAssertion[bytes | bytearray], index: int, expected: int
+            self: _NegatedCapableAssertion[bytes | bytearray], index: SupportsIndex, expected: SupportsIndex
         ) -> _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_root_cause(self, ex: ClassInfo) -> _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 has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> _CapableAssertion[_CapableT_co]: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> _CapableAssertion[_CapableT_co]: ...
+        def has_size_less_than(self, size: SupportsIndex) -> _CapableAssertion[_CapableT_co]: ...
         def is_after(
             self: _NegatedCapableAssertion[datetime.datetime], other: datetime.datetime
         ) -> _CapableAssertion[_CapableT_co]: ...
@@ -584,7 +599,9 @@ if TYPE_CHECKING:
         ) -> _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_divisible_by(
+            self: _NegatedCapableAssertion[int], divisor: SupportsIndex
+        ) -> _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(
@@ -621,8 +638,8 @@ if TYPE_CHECKING:
             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_length(self, length: SupportsIndex) -> _CapableAssertion[_CapableT_co]: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> _CapableAssertion[_CapableT_co]: ...
         def is_less_than(
             self: _NegatedCapableAssertion[_Orderable], other: object
         ) -> _CapableAssertion[_CapableT_co]: ...
@@ -662,7 +679,7 @@ if TYPE_CHECKING:
         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_subclass_of(self, some_class: ClassInfo) -> _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]: ...
@@ -721,9 +738,6 @@ if TYPE_CHECKING:
         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]: ...