assertpy2 2.31.0__tar.gz → 2.32.0__tar.gz

{assertpy2-2.31.0 → assertpy2-2.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: assertpy2
-Version: 2.31.0
+Version: 2.32.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.31.0 → assertpy2-2.32.0}/assertpy2/_engine/_builder_check_typing.py

@@ -24,6 +24,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     import datetime
     import pathlib
+    import re
     from collections.abc import Callable, Hashable, Iterable, Mapping, Sized
     from pathlib import Path
     from typing import Any, Protocol, SupportsFloat, SupportsIndex, TypeVar, overload
@@ -155,9 +156,9 @@ if TYPE_CHECKING:
 
         def ends_with_ignoring_case(self: _CheckAnyValue[str], suffix: str) -> AssertionOutcome: ...
 
-        def matches(self: _CheckAnyValue[str], pattern: str) -> AssertionOutcome: ...
+        def matches(self: _CheckAnyValue[str], pattern: str | re.Pattern[str]) -> AssertionOutcome: ...
 
-        def does_not_match(self: _CheckAnyValue[str], pattern: str) -> AssertionOutcome: ...
+        def does_not_match(self: _CheckAnyValue[str], pattern: str | re.Pattern[str]) -> AssertionOutcome: ...
 
         def is_alpha(self: _CheckAnyValue[str]) -> AssertionOutcome: ...
 
@@ -571,9 +572,11 @@ if TYPE_CHECKING:
             allow_empty: bool = ...,
         ) -> AssertionOutcome: ...
 
-        def extracting_group(self: _CheckAnyValue[str], pattern: str, group: int | str = ...) -> AssertionOutcome: ...
+        def extracting_group(
+            self: _CheckAnyValue[str], pattern: str | re.Pattern[str], group: int | str = ...
+        ) -> AssertionOutcome: ...
 
-        def matches_with_groups(self: _CheckAnyValue[str], pattern: str) -> AssertionOutcome: ...
+        def matches_with_groups(self: _CheckAnyValue[str], pattern: str | re.Pattern[str]) -> AssertionOutcome: ...
 
         @overload
         def exists(self: _CheckAnyValue[str] | _CheckAnyValue[pathlib.Path]) -> AssertionOutcome: ...

{assertpy2-2.31.0 → assertpy2-2.32.0}/assertpy2/_engine/_capable_typing.py

@@ -24,6 +24,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     import datetime
     import logging
+    import re
     from collections.abc import Callable, Iterable, Mapping, Sized
     from pathlib import Path
     from typing import Any, Protocol, SupportsFloat, SupportsIndex, TypeVar, overload
@@ -297,7 +298,9 @@ if TYPE_CHECKING:
         ) -> _CapableAssertion[_CapableT_co]: ...
         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_match(
+            self: _CapableAssertion[str], pattern: str | re.Pattern[str]
+        ) -> _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]: ...
@@ -306,7 +309,7 @@ if TYPE_CHECKING:
         def exists(self: _CapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
         def extracting(self, *names: object, **kwargs: object) -> _ListAssertion[Any]: ...
         def extracting_group(
-            self: _CapableAssertion[str], pattern: str, group: int | str = ...
+            self: _CapableAssertion[str], pattern: str | re.Pattern[str], group: int | str = ...
         ) -> 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]: ...
@@ -427,7 +430,9 @@ if TYPE_CHECKING:
         def is_whitespace(self: _CapableAssertion[str]) -> _CapableAssertion[_CapableT_co]: ...
         def is_writable(self: _CapableAssertion[_PathLike]) -> _CapableAssertion[_CapableT_co]: ...
         def is_zero(self) -> Self: ...
-        def matches(self: _CapableAssertion[str], pattern: str) -> _CapableAssertion[_CapableT_co]: ...
+        def matches(
+            self: _CapableAssertion[str], pattern: str | re.Pattern[str]
+        ) -> _CapableAssertion[_CapableT_co]: ...
         def matches_contract_snapshot(self, id: str | None = ..., path: str = ...) -> Self: ...
         def matches_error_tree(self, *expected: type | list[Any]) -> Self: ...
         def matches_inline(
@@ -443,7 +448,9 @@ 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) -> AssertionBuilder[Any]: ...
+        def matches_with_groups(
+            self: _CapableAssertion[str], pattern: str | re.Pattern[str]
+        ) -> AssertionBuilder[Any]: ...
         def none_satisfy(self, matcher: Matcher[Any] | Callable[..., bool]) -> Self: ...
         def raised(self) -> AssertionBuilder[Any]: ...
         def returned(self) -> AssertionBuilder[Any]: ...
@@ -548,7 +555,9 @@ if TYPE_CHECKING:
         ) -> _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 does_not_match(
+            self: _NegatedCapableAssertion[str], pattern: str | re.Pattern[str]
+        ) -> _CapableAssertion[_CapableT_co]: ...
         def each(
             self, matcher: Matcher[Any] | Callable[..., bool], *, allow_empty: bool = ...
         ) -> _CapableAssertion[_CapableT_co]: ...
@@ -559,7 +568,7 @@ if TYPE_CHECKING:
         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 = ...
+            self: _NegatedCapableAssertion[str], pattern: str | re.Pattern[str], group: int | str = ...
         ) -> _CapableAssertion[_CapableT_co]: ...
         def has_byte_at(
             self: _NegatedCapableAssertion[bytes | bytearray], index: SupportsIndex, expected: SupportsIndex
@@ -694,7 +703,9 @@ if TYPE_CHECKING:
         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(
+            self: _NegatedCapableAssertion[str], pattern: str | re.Pattern[str]
+        ) -> _CapableAssertion[_CapableT_co]: ...
         def matches_contract_snapshot(
             self, id: str | None = ..., path: str = ...
         ) -> _CapableAssertion[_CapableT_co]: ...
@@ -713,7 +724,7 @@ if TYPE_CHECKING:
         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
+            self: _NegatedCapableAssertion[str], pattern: str | re.Pattern[str]
         ) -> _CapableAssertion[_CapableT_co]: ...
         def none_satisfy(self, matcher: Matcher[Any] | Callable[..., bool]) -> _CapableAssertion[_CapableT_co]: ...
         def satisfies_exactly(

{assertpy2-2.31.0 → assertpy2-2.32.0}/assertpy2/_engine/_check_typing.py

@@ -14,6 +14,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     import datetime
+    import re
     from collections.abc import Callable, Hashable, Iterable, Mapping, Sized
     from pathlib import Path
     from typing import Any, Protocol, SupportsFloat, SupportsIndex, TypeVar, overload
@@ -401,8 +402,8 @@ if TYPE_CHECKING:
         def starts_with_ignoring_case(self, prefix: str) -> AssertionOutcome: ...
         def ends_with(self, suffix: str) -> AssertionOutcome: ...
         def ends_with_ignoring_case(self, suffix: str) -> AssertionOutcome: ...
-        def matches(self, pattern: str) -> AssertionOutcome: ...
-        def does_not_match(self, pattern: str) -> AssertionOutcome: ...
+        def matches(self, pattern: str | re.Pattern[str]) -> AssertionOutcome: ...
+        def does_not_match(self, pattern: str | re.Pattern[str]) -> AssertionOutcome: ...
         def is_alpha(self) -> AssertionOutcome: ...
         def is_digit(self) -> AssertionOutcome: ...
         def is_lower(self) -> AssertionOutcome: ...
@@ -439,8 +440,8 @@ if TYPE_CHECKING:
         def zip_satisfies(
             self, other: Iterable[_Other], predicate: Callable[[str, _Other], object], *, allow_empty: bool = ...
         ) -> AssertionOutcome: ...
-        def extracting_group(self, pattern: str, group: int | str = ...) -> AssertionOutcome: ...
-        def matches_with_groups(self, pattern: str) -> AssertionOutcome: ...
+        def extracting_group(self, pattern: str | re.Pattern[str], group: int | str = ...) -> AssertionOutcome: ...
+        def matches_with_groups(self, pattern: str | re.Pattern[str]) -> AssertionOutcome: ...
         @property
         def not_(self) -> Self: ...
 

{assertpy2-2.31.0 → assertpy2-2.32.0}/assertpy2/_engine/_negated_typing.py

@@ -17,6 +17,7 @@ from typing import TYPE_CHECKING, Protocol
 
 if TYPE_CHECKING:
     import datetime
+    import re
     from collections.abc import Callable, Hashable, Iterable, Mapping, Sized
     from pathlib import Path
     from typing import Any, SupportsFloat, SupportsIndex, TypeVar, overload
@@ -88,8 +89,8 @@ if TYPE_CHECKING:
         def starts_with_ignoring_case(self, prefix: str) -> _StringAssertion: ...
         def ends_with(self, suffix: str) -> _StringAssertion: ...
         def ends_with_ignoring_case(self, suffix: str) -> _StringAssertion: ...
-        def matches(self, pattern: str) -> _StringAssertion: ...
-        def does_not_match(self, pattern: str) -> _StringAssertion: ...
+        def matches(self, pattern: str | re.Pattern[str]) -> _StringAssertion: ...
+        def does_not_match(self, pattern: str | re.Pattern[str]) -> _StringAssertion: ...
         def is_alpha(self) -> _StringAssertion: ...
         def is_digit(self) -> _StringAssertion: ...
         def is_lower(self) -> _StringAssertion: ...
@@ -126,8 +127,8 @@ if TYPE_CHECKING:
         def zip_satisfies(
             self, other: Iterable[_Other], predicate: Callable[[str, _Other], object], *, allow_empty: bool = ...
         ) -> _StringAssertion: ...
-        def extracting_group(self, pattern: str, group: int | str = ...) -> _StringAssertion: ...
-        def matches_with_groups(self, pattern: str) -> _StringAssertion: ...
+        def extracting_group(self, pattern: str | re.Pattern[str], group: int | str = ...) -> _StringAssertion: ...
+        def matches_with_groups(self, pattern: str | re.Pattern[str]) -> _StringAssertion: ...
         def exists(self) -> _StringAssertion: ...
         def does_not_exist(self) -> _StringAssertion: ...
         def is_file(self) -> _StringAssertion: ...
@@ -1492,8 +1493,8 @@ if TYPE_CHECKING:
         def starts_with_ignoring_case(self, prefix: str) -> _WarnedAssertion[_P_co]: ...
         def ends_with(self, suffix: str) -> _WarnedAssertion[_P_co]: ...
         def ends_with_ignoring_case(self, suffix: str) -> _WarnedAssertion[_P_co]: ...
-        def matches(self, pattern: str) -> _WarnedAssertion[_P_co]: ...
-        def does_not_match(self, pattern: str) -> _WarnedAssertion[_P_co]: ...
+        def matches(self, pattern: str | re.Pattern[str]) -> _WarnedAssertion[_P_co]: ...
+        def does_not_match(self, pattern: str | re.Pattern[str]) -> _WarnedAssertion[_P_co]: ...
         def is_alpha(self) -> _WarnedAssertion[_P_co]: ...
         def is_digit(self) -> _WarnedAssertion[_P_co]: ...
         def is_lower(self) -> _WarnedAssertion[_P_co]: ...
@@ -1530,8 +1531,10 @@ if TYPE_CHECKING:
         def zip_satisfies(
             self, other: Iterable[_Other], predicate: Callable[[str, _Other], object], *, allow_empty: bool = ...
         ) -> _WarnedAssertion[_P_co]: ...
-        def extracting_group(self, pattern: str, group: int | str = ...) -> _WarnedAssertion[_P_co]: ...
-        def matches_with_groups(self, pattern: str) -> _WarnedAssertion[_P_co]: ...
+        def extracting_group(
+            self, pattern: str | re.Pattern[str], group: int | str = ...
+        ) -> _WarnedAssertion[_P_co]: ...
+        def matches_with_groups(self, pattern: str | re.Pattern[str]) -> _WarnedAssertion[_P_co]: ...
         def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _WarnedAssertion[_P_co]: ...
         def contains_duplicates(self) -> _WarnedAssertion[_P_co]: ...
         def does_not_contain_duplicates(self) -> _WarnedAssertion[_P_co]: ...
@@ -1724,8 +1727,8 @@ if TYPE_CHECKING:
         def starts_with_ignoring_case(self, prefix: str) -> _TextAssertion: ...
         def ends_with(self, suffix: str) -> _TextAssertion: ...
         def ends_with_ignoring_case(self, suffix: str) -> _TextAssertion: ...
-        def matches(self, pattern: str) -> _TextAssertion: ...
-        def does_not_match(self, pattern: str) -> _TextAssertion: ...
+        def matches(self, pattern: str | re.Pattern[str]) -> _TextAssertion: ...
+        def does_not_match(self, pattern: str | re.Pattern[str]) -> _TextAssertion: ...
         def is_alpha(self) -> _TextAssertion: ...
         def is_digit(self) -> _TextAssertion: ...
         def is_lower(self) -> _TextAssertion: ...
@@ -1762,8 +1765,8 @@ if TYPE_CHECKING:
         def zip_satisfies(
             self, other: Iterable[_Other], predicate: Callable[[str, _Other], object], *, allow_empty: bool = ...
         ) -> _TextAssertion: ...
-        def extracting_group(self, pattern: str, group: int | str = ...) -> _TextAssertion: ...
-        def matches_with_groups(self, pattern: str) -> _TextAssertion: ...
+        def extracting_group(self, pattern: str | re.Pattern[str], group: int | str = ...) -> _TextAssertion: ...
+        def matches_with_groups(self, pattern: str | re.Pattern[str]) -> _TextAssertion: ...
         def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _TextAssertion: ...
         def contains_duplicates(self) -> _TextAssertion: ...
         def does_not_contain_duplicates(self) -> _TextAssertion: ...
@@ -1981,8 +1984,8 @@ if TYPE_CHECKING:
         def starts_with_ignoring_case(self, prefix: str) -> _InvokedAssertion[_Exc]: ...
         def ends_with(self, suffix: str) -> _InvokedAssertion[_Exc]: ...
         def ends_with_ignoring_case(self, suffix: str) -> _InvokedAssertion[_Exc]: ...
-        def matches(self, pattern: str) -> _InvokedAssertion[_Exc]: ...
-        def does_not_match(self, pattern: str) -> _InvokedAssertion[_Exc]: ...
+        def matches(self, pattern: str | re.Pattern[str]) -> _InvokedAssertion[_Exc]: ...
+        def does_not_match(self, pattern: str | re.Pattern[str]) -> _InvokedAssertion[_Exc]: ...
         def is_alpha(self) -> _InvokedAssertion[_Exc]: ...
         def is_digit(self) -> _InvokedAssertion[_Exc]: ...
         def is_lower(self) -> _InvokedAssertion[_Exc]: ...
@@ -2019,8 +2022,10 @@ if TYPE_CHECKING:
         def zip_satisfies(
             self, other: Iterable[_Other], predicate: Callable[[str, _Other], object], *, allow_empty: bool = ...
         ) -> _InvokedAssertion[_Exc]: ...
-        def extracting_group(self, pattern: str, group: int | str = ...) -> _InvokedAssertion[_Exc]: ...
-        def matches_with_groups(self, pattern: str) -> _InvokedAssertion[_Exc]: ...
+        def extracting_group(
+            self, pattern: str | re.Pattern[str], group: int | str = ...
+        ) -> _InvokedAssertion[_Exc]: ...
+        def matches_with_groups(self, pattern: str | re.Pattern[str]) -> _InvokedAssertion[_Exc]: ...
         def is_subset_of(self, *supersets: object, allow_empty: bool = ...) -> _InvokedAssertion[_Exc]: ...
         def contains_duplicates(self) -> _InvokedAssertion[_Exc]: ...
         def does_not_contain_duplicates(self) -> _InvokedAssertion[_Exc]: ...

{assertpy2-2.31.0 → assertpy2-2.32.0}/assertpy2/_engine/_poll_typing.py

@@ -31,6 +31,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     import datetime
     import pathlib
+    import re
     from collections.abc import Callable, Generator, Hashable, Iterable, Mapping, Sized
     from pathlib import Path
     from typing import Any, Protocol, SupportsFloat, SupportsIndex, TypeVar, overload
@@ -263,9 +264,9 @@ if TYPE_CHECKING:
 
         def ends_with_ignoring_case(self: _SyncPoll[str], suffix: str) -> _SyncPoll[_P_co]: ...
 
-        def matches(self: _SyncPoll[str], pattern: str) -> _SyncPoll[_P_co]: ...
+        def matches(self: _SyncPoll[str], pattern: str | re.Pattern[str]) -> _SyncPoll[_P_co]: ...
 
-        def does_not_match(self: _SyncPoll[str], pattern: str) -> _SyncPoll[_P_co]: ...
+        def does_not_match(self: _SyncPoll[str], pattern: str | re.Pattern[str]) -> _SyncPoll[_P_co]: ...
 
         def is_alpha(self: _SyncPoll[str]) -> _SyncPoll[_P_co]: ...
 
@@ -687,9 +688,11 @@ if TYPE_CHECKING:
         @overload
         def flat_mapped(self: _SyncPoll[_CapableT], func: Callable[[str], Iterable[_R]]) -> _SyncPoll[Any]: ...
 
-        def extracting_group(self: _SyncPoll[str], pattern: str, group: int | str = ...) -> _SyncPoll[_P_co]: ...
+        def extracting_group(
+            self: _SyncPoll[str], pattern: str | re.Pattern[str], group: int | str = ...
+        ) -> _SyncPoll[_P_co]: ...
 
-        def matches_with_groups(self: _SyncPoll[str], pattern: str) -> _SyncPoll[Any]: ...
+        def matches_with_groups(self: _SyncPoll[str], pattern: str | re.Pattern[str]) -> _SyncPoll[Any]: ...
 
         @overload
         def exists(self: _SyncPoll[str] | _SyncPoll[pathlib.Path]) -> _SyncPoll[_P_co]: ...
@@ -1621,9 +1624,9 @@ if TYPE_CHECKING:
 
         def ends_with_ignoring_case(self: _NegatedSyncPoll[str], suffix: str) -> _SyncPoll[_P_co]: ...
 
-        def matches(self: _NegatedSyncPoll[str], pattern: str) -> _SyncPoll[_P_co]: ...
+        def matches(self: _NegatedSyncPoll[str], pattern: str | re.Pattern[str]) -> _SyncPoll[_P_co]: ...
 
-        def does_not_match(self: _NegatedSyncPoll[str], pattern: str) -> _SyncPoll[_P_co]: ...
+        def does_not_match(self: _NegatedSyncPoll[str], pattern: str | re.Pattern[str]) -> _SyncPoll[_P_co]: ...
 
         def is_alpha(self: _NegatedSyncPoll[str]) -> _SyncPoll[_P_co]: ...
 
@@ -2047,9 +2050,11 @@ if TYPE_CHECKING:
             allow_empty: bool = ...,
         ) -> _SyncPoll[_P_co]: ...
 
-        def extracting_group(self: _NegatedSyncPoll[str], pattern: str, group: int | str = ...) -> _SyncPoll[_P_co]: ...
+        def extracting_group(
+            self: _NegatedSyncPoll[str], pattern: str | re.Pattern[str], group: int | str = ...
+        ) -> _SyncPoll[_P_co]: ...
 
-        def matches_with_groups(self: _NegatedSyncPoll[str], pattern: str) -> _SyncPoll[_P_co]: ...
+        def matches_with_groups(self: _NegatedSyncPoll[str], pattern: str | re.Pattern[str]) -> _SyncPoll[_P_co]: ...
 
         @overload
         def exists(self: _NegatedSyncPoll[str] | _NegatedSyncPoll[pathlib.Path]) -> _SyncPoll[_P_co]: ...
@@ -2975,9 +2980,9 @@ if TYPE_CHECKING:
 
         def ends_with_ignoring_case(self: _AsyncPoll[str], suffix: str) -> _AsyncPoll[_P_co]: ...
 
-        def matches(self: _AsyncPoll[str], pattern: str) -> _AsyncPoll[_P_co]: ...
+        def matches(self: _AsyncPoll[str], pattern: str | re.Pattern[str]) -> _AsyncPoll[_P_co]: ...
 
-        def does_not_match(self: _AsyncPoll[str], pattern: str) -> _AsyncPoll[_P_co]: ...
+        def does_not_match(self: _AsyncPoll[str], pattern: str | re.Pattern[str]) -> _AsyncPoll[_P_co]: ...
 
         def is_alpha(self: _AsyncPoll[str]) -> _AsyncPoll[_P_co]: ...
 
@@ -3411,9 +3416,11 @@ if TYPE_CHECKING:
         @overload
         def flat_mapped(self: _AsyncPoll[_CapableT], func: Callable[[str], Iterable[_R]]) -> _AsyncPoll[Any]: ...
 
-        def extracting_group(self: _AsyncPoll[str], pattern: str, group: int | str = ...) -> _AsyncPoll[_P_co]: ...
+        def extracting_group(
+            self: _AsyncPoll[str], pattern: str | re.Pattern[str], group: int | str = ...
+        ) -> _AsyncPoll[_P_co]: ...
 
-        def matches_with_groups(self: _AsyncPoll[str], pattern: str) -> _AsyncPoll[Any]: ...
+        def matches_with_groups(self: _AsyncPoll[str], pattern: str | re.Pattern[str]) -> _AsyncPoll[Any]: ...
 
         @overload
         def exists(self: _AsyncPoll[str] | _AsyncPoll[pathlib.Path]) -> _AsyncPoll[_P_co]: ...
@@ -4336,9 +4343,9 @@ if TYPE_CHECKING:
 
         def ends_with_ignoring_case(self: _NegatedAsyncPoll[str], suffix: str) -> _AsyncPoll[_P_co]: ...
 
-        def matches(self: _NegatedAsyncPoll[str], pattern: str) -> _AsyncPoll[_P_co]: ...
+        def matches(self: _NegatedAsyncPoll[str], pattern: str | re.Pattern[str]) -> _AsyncPoll[_P_co]: ...
 
-        def does_not_match(self: _NegatedAsyncPoll[str], pattern: str) -> _AsyncPoll[_P_co]: ...
+        def does_not_match(self: _NegatedAsyncPoll[str], pattern: str | re.Pattern[str]) -> _AsyncPoll[_P_co]: ...
 
         def is_alpha(self: _NegatedAsyncPoll[str]) -> _AsyncPoll[_P_co]: ...
 
@@ -4763,10 +4770,10 @@ if TYPE_CHECKING:
         ) -> _AsyncPoll[_P_co]: ...
 
         def extracting_group(
-            self: _NegatedAsyncPoll[str], pattern: str, group: int | str = ...
+            self: _NegatedAsyncPoll[str], pattern: str | re.Pattern[str], group: int | str = ...
         ) -> _AsyncPoll[_P_co]: ...
 
-        def matches_with_groups(self: _NegatedAsyncPoll[str], pattern: str) -> _AsyncPoll[_P_co]: ...
+        def matches_with_groups(self: _NegatedAsyncPoll[str], pattern: str | re.Pattern[str]) -> _AsyncPoll[_P_co]: ...
 
         @overload
         def exists(self: _NegatedAsyncPoll[str] | _NegatedAsyncPoll[pathlib.Path]) -> _AsyncPoll[_P_co]: ...

{assertpy2-2.31.0 → assertpy2-2.32.0}/assertpy2/_engine/_require.py

@@ -27,6 +27,7 @@ import decimal
 import difflib
 import functools
 import inspect
+import re
 import types
 from typing import Any, Final, NoReturn, TypeVar
 
@@ -173,6 +174,22 @@ def argument(name: str) -> str:
     return f"given {name} arg"
 
 
+def require_pattern(pattern: object) -> re.Pattern[str]:
+    """*pattern* compiled, refused unless it is a string or a pattern compiled from one, and not empty.
+
+    A pattern compiled from bytes is never found in a string, and an empty one is found in every string.  A
+    string goes through ``re.compile`` and its cache, as ``re.search`` would take it.  A compiled one comes back
+    as it is, flags and all.
+    """
+    text = pattern.pattern if isinstance(pattern, re.Pattern) else pattern
+    if not isinstance(text, str):
+        refuse(pattern, "a string or a pattern compiled from one", subject=argument("pattern"))
+    if len(text) == 0:
+        _assertpy2_refusal = True
+        raise ValueError("given pattern arg must not be empty")
+    return pattern if isinstance(pattern, re.Pattern) else re.compile(text)
+
+
 def sized_len(value: object, *, subject: str = "val") -> int:
     """The length of *value*, refusing it in the shared shape when it has none.
 

{assertpy2-2.31.0 → assertpy2-2.32.0}/assertpy2/_engine/_typing.py

@@ -22,6 +22,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     import datetime
+    import re
     from collections.abc import Awaitable, Callable, Hashable, Iterable, Mapping, Sized
     from pathlib import Path
     from typing import Any, ClassVar, Protocol, SupportsFloat, SupportsIndex, TypeVar, overload
@@ -579,8 +580,8 @@ if TYPE_CHECKING:
         def starts_with_ignoring_case(self, prefix: str) -> Self: ...
         def ends_with(self, suffix: str) -> Self: ...
         def ends_with_ignoring_case(self, suffix: str) -> Self: ...
-        def matches(self, pattern: str) -> Self: ...
-        def does_not_match(self, pattern: str) -> Self: ...
+        def matches(self, pattern: str | re.Pattern[str]) -> Self: ...
+        def does_not_match(self, pattern: str | re.Pattern[str]) -> Self: ...
         def is_alpha(self) -> Self: ...
         def is_digit(self) -> Self: ...
         def is_lower(self) -> Self: ...
@@ -621,9 +622,9 @@ if TYPE_CHECKING:
         def last(self) -> _TextAssertion: ...
         def element(self, index: SupportsIndex) -> _TextAssertion: ...
         def single(self) -> _TextAssertion: ...
-        def extracting_group(self, pattern: str, group: int | str = ...) -> Self: ...
+        def extracting_group(self, pattern: str | re.Pattern[str], group: int | str = ...) -> Self: ...
         # which of the two a pattern yields cannot be known statically
-        def matches_with_groups(self, pattern: str) -> AssertionBuilder[Any]: ...
+        def matches_with_groups(self, pattern: str | re.Pattern[str]) -> AssertionBuilder[Any]: ...
 
     class _StringAssertion(_TextAssertion, _FilesystemAssertion, Protocol):
         """Assertions available for ``str`` values.

{assertpy2-2.31.0 → assertpy2-2.32.0}/assertpy2/_matcher_impls.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import functools
-import re
 import sys
 import uuid as _uuid_mod
 from dataclasses import dataclass
@@ -86,6 +85,7 @@ from ._engine._require import (
     raised_on_purpose,
     refuse,
     reject_unknown_kwargs,
+    require_pattern,
     verdict,
 )
 from ._engine._size import length_of
@@ -96,6 +96,7 @@ from ._hints import matcher_for_a_class, type_beside_a_class
 from .errors import _capped, _capped_format, _capped_repr, _safe_repr, _told_apart, _type_expression_name
 
 if TYPE_CHECKING:
+    import re
     from collections.abc import Callable
     from typing import TypeAlias
 
@@ -1106,13 +1107,10 @@ _TEXTS = (str, bytes, bytearray)
 
 
 class MatchesRegexMatcher(BaseMatcher):
-    def __init__(self, pattern: str):
-        # asked here: through the helper a build cost 50% more
-        if (type(pattern) is str or issubclass(type(pattern), _TEXTS)) and len(pattern) == 0:
-            _refuse_empty("pattern")
+    def __init__(self, pattern: str | re.Pattern[str]):
         self.pattern = pattern
         # compiled eagerly so an invalid pattern raises at the call site, not inside `matches()` or a combinator
-        self._compiled = re.compile(pattern)
+        self._compiled = require_pattern(pattern)
 
     def matches(self, value: Any) -> bool:
         if not isinstance(value, str):

{assertpy2-2.31.0 → assertpy2-2.32.0}/assertpy2/assertpy.py

@@ -111,7 +111,7 @@ from .snapshot import SnapshotMixin
 from .string import StringMixin
 from .warning import WarningMixin
 
-__version__ = "2.31.0"
+__version__ = "2.32.0"
 
 # the tracked value type of the generic AssertionBuilder fallback (_U appears only in narrowing stubs)
 _T = TypeVar("_T")

{assertpy2-2.31.0 → assertpy2-2.32.0}/assertpy2/matchers.py

@@ -69,6 +69,7 @@ from ._matcher_impls import (
 )
 
 if TYPE_CHECKING:
+    import re
     from collections.abc import Callable, Iterable
 
     # the element a membership matcher judges, so `match.contains("x")` is a matcher for collections of strings
@@ -460,8 +461,8 @@ class _MatchNamespace:
         return ContainsStringMatcher(substring)
 
     @staticmethod
-    def matches_regex(pattern: str) -> Matcher[str]:
-        """Matcher for a string in which ``pattern`` is found (``re.search``)."""
+    def matches_regex(pattern: str | re.Pattern[str]) -> Matcher[str]:
+        """Matcher for a string in which ``pattern`` (a string, or compiled from one) is found (``re.search``)."""
         return MatchesRegexMatcher(pattern)
 
     @staticmethod