assertpy2 2.27.1__tar.gz → 2.29.0__tar.gz

{assertpy2-2.27.1 → assertpy2-2.29.0}/PKG-INFO

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

{assertpy2-2.27.1 → assertpy2-2.29.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.1 → assertpy2-2.29.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.1 → assertpy2-2.29.0}/assertpy2/_engine/_capable_typing.py

@@ -45,6 +45,7 @@ if TYPE_CHECKING:
         _ExpectedCompletionAssertion,
         _ExpectedRaiseAssertion,
         _ExpectedWarningAssertion,
+        _Landed,
         _ListAssertion,
     )
 
@@ -168,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
@@ -205,7 +206,10 @@ if TYPE_CHECKING:
             trace: bool = ...,
         ) -> _SyncPoll[Any]: ...
         # where the callable view lands: flattened, the runtime's `-> Self` kept a caught message typed as the callable
-        def raises(self: _CapableAssertion[_Callable], ex: type) -> _ExpectedRaiseAssertion[Any]: ...
+        @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] = ...
@@ -243,7 +247,7 @@ if TYPE_CHECKING:
         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) -> AssertionBuilder[Any]: ...
-        def caused_by(self, ex: type) -> AssertionBuilder[Any]: ...
+        def caused_by(self, ex: ClassInfo) -> AssertionBuilder[Any]: ...
         def conforms_to_openapi(
             self,
             spec: dict[str, Any],
@@ -306,15 +310,15 @@ if TYPE_CHECKING:
         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) -> AssertionBuilder[Any]: ...
+        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]: ...
@@ -343,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]: ...
@@ -374,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
@@ -407,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: ...
@@ -492,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],
@@ -554,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]: ...
@@ -593,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(
@@ -630,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]: ...
@@ -671,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]: ...

{assertpy2-2.27.1 → assertpy2-2.29.0}/assertpy2/_engine/_check_typing.py

@@ -32,6 +32,7 @@ if TYPE_CHECKING:
         _ArrayT_co,
         _CapableT,
         _FrameT_co,
+        _Landed,
         _ObjectAssertion,
         _Other,
         _P_co,
@@ -41,6 +42,8 @@ if TYPE_CHECKING:
     _KeySpecs = Hashable | list[Hashable] | set[Hashable] | frozenset[Hashable]
 
     _E = TypeVar("_E")
+    # a verdict reads no exception back, so the twin's is covariant where the view's is not
+    _Exc_co = TypeVar("_Exc_co", bound=BaseException, covariant=True)
     _N = TypeVar("_N", int, float)
     _K = TypeVar("_K")
     _V = TypeVar("_V")
@@ -60,9 +63,9 @@ if TYPE_CHECKING:
         """The verdict twin of `_SizedAssertion`."""
 
         def has_same_size_as(self, other: Sized) -> AssertionOutcome: ...
-        def has_size_greater_than(self, size: int) -> AssertionOutcome: ...
-        def has_size_less_than(self, size: int) -> AssertionOutcome: ...
-        def has_size_between(self, low: int, high: int) -> AssertionOutcome: ...
+        def has_size_greater_than(self, size: SupportsIndex) -> AssertionOutcome: ...
+        def has_size_less_than(self, size: SupportsIndex) -> AssertionOutcome: ...
+        def has_size_between(self, low: SupportsIndex, high: SupportsIndex) -> AssertionOutcome: ...
         def is_empty(self) -> AssertionOutcome: ...
         def is_not_empty(self) -> AssertionOutcome: ...
         @property
@@ -92,8 +95,6 @@ if TYPE_CHECKING:
         def is_not_nan(self) -> AssertionOutcome: ...
         def is_inf(self) -> AssertionOutcome: ...
         def is_not_inf(self) -> AssertionOutcome: ...
-        def is_close_to(self, other: _Number, tolerance: _Number) -> AssertionOutcome: ...
-        def is_not_close_to(self, other: _Number, tolerance: _Number) -> AssertionOutcome: ...
         def is_not_between(self, low: _Number, high: _Number) -> AssertionOutcome: ...
         def is_between(self, low: _Number, high: _Number) -> AssertionOutcome: ...
         def is_greater_than(self, other: _Number) -> AssertionOutcome: ...
@@ -150,12 +151,6 @@ if TYPE_CHECKING:
         @property
         def not_(self) -> Self: ...
 
-    class _CheckReturningAssertion(Protocol):
-        """The verdict twin of `_ReturningAssertion`."""
-
-        @property
-        def not_(self) -> Self: ...
-
     class _CheckZeroAssertion(Protocol):
         """The verdict twin of `_ZeroAssertion`."""
 
@@ -188,9 +183,9 @@ if TYPE_CHECKING:
         def is_type_of(self, some_type: type) -> AssertionOutcome: ...
         def is_instance_of(self, some_class: ClassInfo) -> AssertionOutcome: ...
         def is_instance_of_any(self, *some_classes: ClassInfo) -> AssertionOutcome: ...
-        def is_subclass_of(self, some_class: type) -> AssertionOutcome: ...
-        def is_length(self, length: int) -> AssertionOutcome: ...
-        def is_length_between(self, low: int, high: int) -> AssertionOutcome: ...
+        def is_subclass_of(self, some_class: ClassInfo) -> AssertionOutcome: ...
+        def is_length(self, length: SupportsIndex) -> AssertionOutcome: ...
+        def is_length_between(self, low: SupportsIndex, high: SupportsIndex) -> AssertionOutcome: ...
         def is_callable(self) -> AssertionOutcome: ...
         def is_not_callable(self) -> AssertionOutcome: ...
         def is_iterable(self) -> AssertionOutcome: ...
@@ -456,6 +451,8 @@ if TYPE_CHECKING:
     class _CheckNumericAssertion(_CheckRealNumberAssertion, _CheckZeroAssertion, _CheckCoreAssertion, Protocol[_N]):
         """The verdict twin of `_NumericAssertion`."""
 
+        def is_close_to(self, other: _Number, tolerance: _Number) -> AssertionOutcome: ...
+        def is_not_close_to(self, other: _Number, tolerance: _Number) -> AssertionOutcome: ...
         @overload
         def satisfies(self, matcher: Callable[[_N], TypeIs[str]]) -> AssertionOutcome: ...
         @overload
@@ -492,7 +489,7 @@ if TYPE_CHECKING:
         def satisfies(self, matcher: Matcher[_N] | Callable[[_N], object]) -> AssertionOutcome: ...
         def is_even(self) -> AssertionOutcome: ...
         def is_odd(self) -> AssertionOutcome: ...
-        def is_divisible_by(self, divisor: int) -> AssertionOutcome: ...
+        def is_divisible_by(self, divisor: SupportsIndex) -> AssertionOutcome: ...
         @property
         def not_(self) -> Self: ...
 
@@ -587,6 +584,7 @@ if TYPE_CHECKING:
         """The verdict twin of `_CollectionShapedAssertion`."""
 
         def contains(self, *items: object) -> AssertionOutcome: ...
+        def does_not_contain(self, *items: object) -> AssertionOutcome: ...
         def contains_only(self, *items: object) -> AssertionOutcome: ...
         @property
         def not_(self) -> Self: ...
@@ -622,6 +620,7 @@ if TYPE_CHECKING:
         def is_less_than(self, other: datetime.date) -> AssertionOutcome: ...
         def is_less_than_or_equal_to(self, other: datetime.date) -> AssertionOutcome: ...
         def is_between(self, low: datetime.date, high: datetime.date) -> AssertionOutcome: ...
+        def is_not_between(self, low: datetime.date, high: datetime.date) -> AssertionOutcome: ...
         @property
         def not_(self) -> Self: ...
 
@@ -633,6 +632,7 @@ if TYPE_CHECKING:
         def is_less_than(self, other: datetime.datetime) -> AssertionOutcome: ...
         def is_less_than_or_equal_to(self, other: datetime.datetime) -> AssertionOutcome: ...
         def is_between(self, low: datetime.datetime, high: datetime.datetime) -> AssertionOutcome: ...
+        def is_not_between(self, low: datetime.datetime, high: datetime.datetime) -> AssertionOutcome: ...
         def is_before(self, other: datetime.datetime) -> AssertionOutcome: ...
         def is_after(self, other: datetime.datetime) -> AssertionOutcome: ...
         def is_before_or_equal_to(self, other: datetime.datetime) -> AssertionOutcome: ...
@@ -655,6 +655,7 @@ if TYPE_CHECKING:
         """The verdict twin of `_BytesAssertion`."""
 
         def contains(self, *items: object) -> AssertionOutcome: ...
+        def does_not_contain(self, *items: object) -> AssertionOutcome: ...
         def is_sorted(
             self, key: Callable[[int], object] = ..., reverse: bool = ..., *, allow_empty: bool = ...
         ) -> AssertionOutcome: ...
@@ -664,7 +665,7 @@ if TYPE_CHECKING:
         def is_valid_encoding(self, encoding: str) -> AssertionOutcome: ...
         def starts_with_bytes(self, prefix: bytes | bytearray) -> AssertionOutcome: ...
         def contains_bytes(self, sub: bytes | bytearray) -> AssertionOutcome: ...
-        def has_byte_at(self, index: int, expected: int) -> AssertionOutcome: ...
+        def has_byte_at(self, index: SupportsIndex, expected: SupportsIndex) -> AssertionOutcome: ...
         def is_hex_equal_to(self, expected_hex: str) -> AssertionOutcome: ...
         def is_greater_than(self, other: bytes | bytearray) -> AssertionOutcome: ...
         def is_greater_than_or_equal_to(self, other: bytes | bytearray) -> AssertionOutcome: ...
@@ -673,19 +674,28 @@ if TYPE_CHECKING:
         @property
         def not_(self) -> Self: ...
 
-    class _CheckInvokedAssertion(_CheckTextAssertion, Protocol):
+    class _CheckInvokedAssertion(_CheckTextAssertion, Protocol[_Exc_co]):
         """The verdict twin of `_InvokedAssertion`."""
 
-        def caused_by(self, ex: type) -> AssertionOutcome: ...
+        @overload
+        def caused_by(self, ex: type[_Landed]) -> AssertionOutcome: ...
+        @overload
+        def caused_by(self, ex: ClassInfo) -> AssertionOutcome: ...
+        @overload
+        def error_of(self, ex: type[_Landed]) -> AssertionOutcome: ...
+        @overload
         def error_of(self, ex: type) -> AssertionOutcome: ...
         def does_not_contain_error(self, *ex_types: type) -> AssertionOutcome: ...
-        def has_root_cause(self, ex: type) -> AssertionOutcome: ...
+        @overload
+        def has_root_cause(self, ex: type[_Landed]) -> AssertionOutcome: ...
+        @overload
+        def has_root_cause(self, ex: ClassInfo) -> AssertionOutcome: ...
         def contains_error(self, *ex_types: type) -> AssertionOutcome: ...
         def matches_error_tree(self, *expected: type | list[Any]) -> AssertionOutcome: ...
         @property
         def not_(self) -> Self: ...
 
-    class _CheckWarnedAssertion(_CheckTextAssertion, _CheckReturningAssertion, Protocol):
+    class _CheckWarnedAssertion(_CheckTextAssertion, Protocol[_P_co]):
         """The verdict twin of `_WarnedAssertion`."""
 
         @property
@@ -697,13 +707,13 @@ if TYPE_CHECKING:
         @property
         def not_(self) -> Self: ...
 
-    class _CheckCompletedAssertion(_CheckCallableAssertion[_P_co], _CheckReturningAssertion, Protocol[_P_co]):
+    class _CheckCompletedAssertion(_CheckCallableAssertion[_P_co], Protocol[_P_co]):
         """The verdict twin of `_CompletedAssertion`."""
 
         @property
         def not_(self) -> Self: ...
 
-    class _CheckExpectedRaiseAssertion(_CheckCallableAssertion[_P_co], Protocol[_P_co]):
+    class _CheckExpectedRaiseAssertion(_CheckCallableAssertion[_P_co], Protocol[_P_co, _Exc_co]):
         """The verdict twin of `_ExpectedRaiseAssertion`."""
 
         def when_called_with(self, *some_args: object, **some_kwargs: object) -> AssertionOutcome: ...