dycw-utilities 0.110.4__tar.gz → 0.110.6__tar.gz

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.110.4
+Version: 0.110.6
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.110.4"
+version = "0.110.6"
 
 [project.optional-dependencies]
 test = [
@@ -337,7 +337,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.110.4"
+current_version = "0.110.6"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/tests/test_modules.py

@@ -28,6 +28,8 @@ if TYPE_CHECKING:
     from collections.abc import Callable
     from types import ModuleType
 
+    from utilities.types import TypeLike
+
 
 class TestIsInstalled:
     @given(case=sampled_from([("importlib", True), ("invalid", False)]))
@@ -90,7 +92,7 @@ class TestYieldModuleContents:
         self,
         *,
         case1: tuple[ModuleType, bool, int],
-        case2: tuple[type[Any] | tuple[type[Any], ...], Callable[[Any], bool], int],
+        case2: tuple[TypeLike[Any], Callable[[Any], bool], int],
     ) -> None:
         module, recursive, factor = case1
         type_, predicate, expected = case2

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/tests/test_parse.py

@@ -61,11 +61,11 @@ from utilities.version import Version
 
 
 class TestSerializeAndParseObject:
-    @given(value=booleans())
-    def test_bool(self, *, value: bool) -> None:
-        serialized = serialize_object(value)
+    @given(bool_=booleans())
+    def test_bool(self, *, bool_: bool) -> None:
+        serialized = serialize_object(bool_)
         result = parse_object(bool, serialized)
-        assert result is value
+        assert result is bool_
 
     @given(date=dates())
     def test_date(self, *, date: dt.date) -> None:
@@ -79,11 +79,11 @@ class TestSerializeAndParseObject:
         result = parse_object(dt.datetime, serialized)
         assert result == datetime
 
-    @given(value=dictionaries(dates(), zoned_datetimes()))
-    def test_dict(self, *, value: dict[dt.date, dt.datetime]) -> None:
-        serialized = serialize_object(value)
+    @given(mapping=dictionaries(dates(), zoned_datetimes()))
+    def test_dict(self, *, mapping: dict[dt.date, dt.datetime]) -> None:
+        serialized = serialize_object(mapping)
         result = parse_object(dict[dt.date, dt.datetime], serialized)
-        assert result == value
+        assert result == mapping
 
     @given(duration=datetime_durations(two_way=True))
     def test_duration(self, *, duration: Duration) -> None:
@@ -97,22 +97,22 @@ class TestSerializeAndParseObject:
         result = parse_object(TruthEnum, serialized)
         assert result is truth
 
-    @given(value=integers())
-    def test_extra_type(self, *, value: int) -> None:
-        serialized = serialize_object(value)
+    @given(int_=integers())
+    def test_extra_type(self, *, int_: int) -> None:
+        serialized = serialize_object(int_)
         result = parse_object(
             DataClassFutureInt,
             serialized,
             extra={DataClassFutureInt: lambda text: DataClassFutureInt(int_=int(text))},
         )
-        expected = DataClassFutureInt(int_=value)
+        expected = DataClassFutureInt(int_=int_)
         assert result == expected
 
-    @given(value=floats())
-    def test_float(self, *, value: float) -> None:
-        serialized = serialize_object(value)
+    @given(float_=floats())
+    def test_float(self, *, float_: float) -> None:
+        serialized = serialize_object(float_)
         result = parse_object(float, serialized)
-        assert is_equal(result, value)
+        assert is_equal(result, float_)
 
     @given(values=frozensets(dates()))
     def test_frozenset(self, *, values: frozenset[dt.date]) -> None:
@@ -120,11 +120,11 @@ class TestSerializeAndParseObject:
         result = parse_object(frozenset[dt.date], serialized)
         assert result == values
 
-    @given(value=integers())
-    def test_int(self, *, value: int) -> None:
-        serialized = serialize_object(value)
+    @given(int_=integers())
+    def test_int(self, *, int_: int) -> None:
+        serialized = serialize_object(int_)
         result = parse_object(int, serialized)
-        assert result == value
+        assert result == int_
 
     @given(values=lists(dates()))
     def test_list(self, *, values: list[dt.date]) -> None:
@@ -193,11 +193,11 @@ class TestSerializeAndParseObject:
         result = parse_object(int | None, serialized)
         assert result is None
 
-    @given(value=integers())
-    def test_nullable_int_int(self, *, value: int) -> None:
-        serialized = serialize_object(value)
+    @given(int_=integers())
+    def test_nullable_int_int(self, *, int_: int) -> None:
+        serialized = serialize_object(int_)
         result = parse_object(int | None, serialized)
-        assert result == value
+        assert result == int_
 
     def test_sentinel(self) -> None:
         serialized = serialize_object(sentinel)
@@ -238,58 +238,58 @@ class TestSerializeAndParseObject:
         result = parse_object(TrueOrFalseFutureTypeLit, truth)
         assert result == truth
 
-    @given(value=integers())
-    def test_type_union_with_extra(self, *, value: int) -> None:
+    @given(int_=integers())
+    def test_type_union_with_extra(self, *, int_: int) -> None:
         def parser(text: str, /) -> DataClassFutureIntEvenOrOddTypeUnion:
-            value = int(text)
-            match value % 2:
+            int_ = int(text)
+            match int_ % 2:
                 case 0:
-                    return DataClassFutureIntEven(even_int=value)
+                    return DataClassFutureIntEven(even_int=int_)
                 case 1:
-                    return DataClassFutureIntOdd(odd_int=value)
+                    return DataClassFutureIntOdd(odd_int=int_)
                 case _:
-                    raise ImpossibleCaseError(case=[f"{value=}"])
+                    raise ImpossibleCaseError(case=[f"{int_=}"])
 
-        serialized = serialize_object(value)
+        serialized = serialize_object(int_)
         result = parse_object(
             DataClassFutureIntEvenOrOddTypeUnion,
             serialized,
             extra={DataClassFutureIntEvenOrOddTypeUnion: parser},
         )
-        match value % 2:
+        match int_ % 2:
             case 0:
-                expected = DataClassFutureIntEven(even_int=value)
+                expected = DataClassFutureIntEven(even_int=int_)
             case 1:
-                expected = DataClassFutureIntOdd(odd_int=value)
+                expected = DataClassFutureIntOdd(odd_int=int_)
             case _:
-                raise ImpossibleCaseError(case=[f"{value=}"])
+                raise ImpossibleCaseError(case=[f"{int_=}"])
         assert result == expected
 
-    @given(value=integers())
-    def test_union_with_extra(self, *, value: int) -> None:
+    @given(int_=integers())
+    def test_union_with_extra(self, *, int_: int) -> None:
         def parser(text: str, /) -> DataClassFutureIntEvenOrOddUnion:
-            value = int(text)
-            match value % 2:
+            int_ = int(text)
+            match int_ % 2:
                 case 0:
-                    return DataClassFutureIntEven(even_int=value)
+                    return DataClassFutureIntEven(even_int=int_)
                 case 1:
-                    return DataClassFutureIntOdd(odd_int=value)
+                    return DataClassFutureIntOdd(odd_int=int_)
                 case _:
-                    raise ImpossibleCaseError(case=[f"{value=}"])
+                    raise ImpossibleCaseError(case=[f"{int_=}"])
 
-        serialized = serialize_object(value)
+        serialized = serialize_object(int_)
         result = parse_object(
             DataClassFutureIntEvenOrOddUnion,
             serialized,
             extra={DataClassFutureIntEvenOrOddUnion: parser},
         )
-        match value % 2:
+        match int_ % 2:
             case 0:
-                expected = DataClassFutureIntEven(even_int=value)
+                expected = DataClassFutureIntEven(even_int=int_)
             case 1:
-                expected = DataClassFutureIntOdd(odd_int=value)
+                expected = DataClassFutureIntOdd(odd_int=int_)
             case _:
-                raise ImpossibleCaseError(case=[f"{value=}"])
+                raise ImpossibleCaseError(case=[f"{int_=}"])
         assert result == expected
 
     @given(version=versions())
@@ -355,15 +355,15 @@ class TestParseObject:
         ):
             _ = parse_object(DataClassFutureInt, "invalid", extra={})
 
-    @given(value=integers())
-    def test_error_extra_non_unique(self, *, value: int) -> None:
+    @given(int_=integers())
+    def test_error_extra_non_unique(self, *, int_: int) -> None:
         with raises(
             _ParseObjectExtraNonUniqueError,
             match="Unable to parse <class '.*'> since `extra` must contain exactly one parent class; got <function .*>, <function .*> and perhaps more",
         ):
             _ = parse_object(
                 DataClassFutureIntChild,
-                serialize_object(value),
+                serialize_object(int_),
                 extra={
                     DataClassFutureIntParentFirst: lambda text: DataClassFutureIntChild(
                         int1=int(text), int2=0
@@ -531,6 +531,63 @@ class TestParseObject:
 
 
 class TestSerializeObject:
+    @given(int_=integers())
+    def test_type_with_extra(self, *, int_: int) -> None:
+        obj = DataClassFutureInt(int_=int_)
+
+        def serializer(obj: DataClassFutureInt, /) -> str:
+            return str(obj.int_)
+
+        serialized = serialize_object(obj, extra={DataClassFutureInt: serializer})
+        expected = str(int_)
+        assert serialized == expected
+
+    @given(int_=integers())
+    def test_type_union_with_extra(self, *, int_: int) -> None:
+        match int_ % 2:
+            case 0:
+                obj = DataClassFutureIntEven(even_int=int_)
+            case 1:
+                obj = DataClassFutureIntOdd(odd_int=int_)
+            case _:
+                raise ImpossibleCaseError(case=[f"{int_=}"])
+
+        def serializer(obj: DataClassFutureIntEvenOrOddTypeUnion, /) -> str:
+            match obj:
+                case DataClassFutureIntEven():
+                    return str(obj.even_int)
+                case DataClassFutureIntOdd():
+                    return str(obj.odd_int)
+
+        serialized = serialize_object(
+            obj, extra={DataClassFutureIntEvenOrOddTypeUnion: serializer}
+        )
+        expected = str(int_)
+        assert serialized == expected
+
+    @given(int_=integers())
+    def test_union_with_extra(self, *, int_: int) -> None:
+        match int_ % 2:
+            case 0:
+                obj = DataClassFutureIntEven(even_int=int_)
+            case 1:
+                obj = DataClassFutureIntOdd(odd_int=int_)
+            case _:
+                raise ImpossibleCaseError(case=[f"{int_=}"])
+
+        def serializer(obj: DataClassFutureIntEvenOrOddUnion, /) -> str:
+            match obj:
+                case DataClassFutureIntEven():
+                    return str(obj.even_int)
+                case DataClassFutureIntOdd():
+                    return str(obj.odd_int)
+
+        serialized = serialize_object(
+            obj, extra={DataClassFutureIntEvenOrOddUnion: serializer}
+        )
+        expected = str(int_)
+        assert serialized == expected
+
     def test_error_extra_empty(self) -> None:
         with raises(
             _SerializeObjectSerializeError,

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.110.4"
+__version__ = "0.110.6"

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/utilities/eventkit.py

@@ -39,7 +39,7 @@ from eventkit import (
 from utilities.functions import apply_decorators
 from utilities.iterables import always_iterable
 from utilities.logging import get_logger
-from utilities.types import TCallable, TCallableMaybeCoroutine1None
+from utilities.types import TCallable, TCallableMaybeCoroutine1None, TypeLike
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -59,7 +59,7 @@ def add_listener(
     /,
     *,
     error: Callable[[Event, BaseException], MaybeCoroutine1[None]] | None = None,
-    ignore: type[BaseException] | tuple[type[BaseException], ...] | None = None,
+    ignore: TypeLike[BaseException] | None = None,
     logger: LoggerOrName | None = None,
     decorators: MaybeIterable[Callable[[TCallable], TCallable]] | None = None,
     done: Callable[..., MaybeCoroutine1[None]] | None = None,
@@ -104,7 +104,7 @@ class LiftedEvent(Generic[TCallableMaybeCoroutine1None]):
         /,
         *,
         error: Callable[[Event, BaseException], MaybeCoroutine1[None]] | None = None,
-        ignore: type[BaseException] | tuple[type[BaseException], ...] | None = None,
+        ignore: TypeLike[BaseException] | None = None,
         logger: LoggerOrName | None = None,
         decorators: MaybeIterable[Callable[[TCallable], TCallable]] | None = None,
         done: Callable[..., MaybeCoroutine1[None]] | None = None,
@@ -267,7 +267,7 @@ class TypedEvent(Event, Generic[TCallableMaybeCoroutine1None]):
         done: Callable[[Self], MaybeCoroutine1[None]] | None = None,
         keep_ref: bool = False,
         *,
-        ignore: type[BaseException] | tuple[type[BaseException], ...] | None = None,
+        ignore: TypeLike[BaseException] | None = None,
         logger: LoggerOrName | None = None,
         decorators: MaybeIterable[Callable[[TCallable], TCallable]] | None = None,
     ) -> Self:
@@ -295,7 +295,7 @@ def lift_listener(
     /,
     *,
     error: Callable[[Event, BaseException], MaybeCoroutine1[None]] | None = None,
-    ignore: type[BaseException] | tuple[type[BaseException], ...] | None = None,
+    ignore: TypeLike[BaseException] | None = None,
     logger: LoggerOrName | None = None,
     decorators: MaybeIterable[Callable[[TCallable], TCallable]] | None = None,
 ) -> Callable[..., MaybeCoroutine1[None]]:

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/utilities/functions.py

@@ -40,6 +40,7 @@ from utilities.types import (
     TCallable2,
     TSupportsRichComparison,
     TupleOrStrMapping,
+    TypeLike,
 )
 
 if TYPE_CHECKING:
@@ -181,9 +182,7 @@ def ensure_class(
     *,
     nullable: Literal[False] = False,
 ) -> _T1 | _T2 | _T3 | _T4 | _T5: ...
-def ensure_class(
-    obj: Any, cls: type[_T] | tuple[type[_T], ...], /, *, nullable: bool = False
-) -> Any:
+def ensure_class(obj: Any, cls: TypeLike[_T], /, *, nullable: bool = False) -> Any:
     """Ensure an object is of the required class."""
     if isinstance(obj, cls) or ((obj is None) and nullable):
         return obj
@@ -193,7 +192,7 @@ def ensure_class(
 @dataclass(kw_only=True, slots=True)
 class EnsureClassError(Exception):
     obj: Any
-    cls: type[Any] | tuple[type[Any], ...]
+    cls: TypeLike[Any]
     nullable: bool
 
     @override
@@ -686,7 +685,9 @@ def is_iterable_of(
 def is_iterable_of(
     obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]], /
 ) -> TypeGuard[Iterable[_T1 | _T2 | _T3 | _T4 | _T5]]: ...
-def is_iterable_of(obj: Any, cls: Any, /) -> TypeGuard[Iterable[Any]]:
+@overload
+def is_iterable_of(obj: Any, cls: TypeLike[_T], /) -> TypeGuard[Iterable[_T]]: ...
+def is_iterable_of(obj: Any, cls: TypeLike[_T], /) -> TypeGuard[Iterable[_T]]:
     """Check if an object is a iterable of tuple or string mappings."""
     return isinstance(obj, Iterable) and all(map(make_isinstance(cls), obj))
 
@@ -730,7 +731,9 @@ def is_sequence_of(
 def is_sequence_of(
     obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]], /
 ) -> TypeGuard[Sequence[_T1 | _T2 | _T3 | _T4 | _T5]]: ...
-def is_sequence_of(obj: Any, cls: Any, /) -> TypeGuard[Sequence[Any]]:
+@overload
+def is_sequence_of(obj: Any, cls: TypeLike[_T], /) -> TypeGuard[Sequence[_T]]: ...
+def is_sequence_of(obj: Any, cls: TypeLike[_T], /) -> TypeGuard[Sequence[_T]]:
     """Check if an object is a sequence of tuple or string mappings."""
     return isinstance(obj, Sequence) and is_iterable_of(obj, cls)
 
@@ -820,19 +823,14 @@ def make_isinstance(
 def make_isinstance(
     cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]], /
 ) -> Callable[[Any], TypeGuard[_T1 | _T2 | _T3 | _T4 | _T5]]: ...
-def make_isinstance(
-    cls: type[_T] | tuple[type[_T], ...], /
-) -> Callable[[Any], TypeGuard[Any]]:
+@overload
+def make_isinstance(cls: TypeLike[_T], /) -> Callable[[Any], TypeGuard[_T]]: ...
+def make_isinstance(cls: TypeLike[_T], /) -> Callable[[Any], TypeGuard[_T]]:
     """Make a curried `isinstance` function."""
     return partial(_make_instance_core, cls=cls)
 
 
-##
-
-
-def _make_instance_core(
-    obj: Any, /, *, cls: type[_T] | tuple[type[_T], ...]
-) -> TypeGuard[_T]:
+def _make_instance_core(obj: Any, /, *, cls: TypeLike[_T]) -> TypeGuard[_T]:
     return isinstance(obj, cls)
 
 

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/utilities/modules.py

@@ -11,6 +11,8 @@ if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Iterator
     from types import ModuleType
 
+    from utilities.types import TypeLike
+
 
 def is_installed(module: str, /) -> bool:
     """Check if a module is installed."""
@@ -63,7 +65,7 @@ def yield_module_contents(
     *,
     missing_ok: Iterable[str] | None = None,
     recursive: bool = False,
-    type: type[Any] | tuple[type[Any], ...] | None = None,  # noqa: A002
+    type: TypeLike[Any] | None = None,  # noqa: A002
     predicate: Callable[[Any], bool] | None = None,
 ) -> Iterator[Any]:
     """Yield all the module contents under a package.

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/utilities/parse.py

@@ -539,7 +539,12 @@ def _serialize_object_dict(
 
 def _serialize_object_extra(obj: Any, extra: SerializeObjectExtra, /) -> str:
     try:
-        serializer = one(s for c, s in extra.items() if isinstance(obj, c))
+        serializer = one(
+            s
+            for c, s in extra.items()
+            if (isinstance(c, type) and isinstance(obj, c))
+            or isinstance(obj, get_args(c))
+        )
     except OneEmptyError:
         raise _SerializeObjectSerializeError(obj=obj) from None
     except OneNonUniqueError as error:

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/utilities/pyrsistent.py

@@ -15,6 +15,8 @@ from pyrsistent._field_common import (
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+    from utilities.types import TypeLike
+
 
 _T = TypeVar("_T")
 _U = TypeVar("_U")
@@ -62,7 +64,7 @@ def field(
 ) -> Any: ...
 def field(
     *,
-    type: type[_T] | tuple[type[_T], ...] = PFIELD_NO_TYPE,  # noqa: A002
+    type: TypeLike[_T] = PFIELD_NO_TYPE,  # noqa: A002
     invariant: Callable[[Any], tuple[bool, Any]] = PFIELD_NO_INVARIANT,
     default: Any = PFIELD_NO_INITIAL,
     mandatory: bool = False,

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/utilities/redis.py

@@ -42,7 +42,7 @@ if TYPE_CHECKING:
     from redis.typing import ResponseT
 
     from utilities.iterables import MaybeIterable
-    from utilities.types import Duration
+    from utilities.types import Duration, TypeLike
 
 
 _K = TypeVar("_K")
@@ -69,9 +69,9 @@ class RedisHashMapKey(Generic[_K, _V]):
     """A hashmap key in a redis store."""
 
     name: str
-    key: type[_K]
+    key: TypeLike[_K]
     key_serializer: Callable[[_K], bytes] | None = None
-    value: type[_V]
+    value: TypeLike[_V]
     value_serializer: Callable[[_V], bytes] | None = None
     value_deserializer: Callable[[bytes], _V] | None = None
     timeout: Duration | None = None
@@ -262,10 +262,24 @@ def redis_hash_map_key(
     error: type[Exception] = TimeoutError,
     ttl: Duration | None = None,
 ) -> RedisHashMapKey[_K1 | _K2 | _K3, _V1 | _V2 | _V3]: ...
+@overload
+def redis_hash_map_key(
+    name: str,
+    key: TypeLike[_K],
+    value: TypeLike[_V],
+    /,
+    *,
+    key_serializer: Callable[[_K1 | _K2 | _K3], bytes] | None = None,
+    value_serializer: Callable[[_V1 | _V2 | _V3], bytes] | None = None,
+    value_deserializer: Callable[[bytes], _V1 | _V2 | _V3] | None = None,
+    timeout: Duration | None = None,
+    error: type[Exception] = TimeoutError,
+    ttl: Duration | None = None,
+) -> RedisHashMapKey[_K, _V]: ...
 def redis_hash_map_key(
     name: str,
-    key: Any,
-    value: Any,
+    key: TypeLike[_K],
+    value: TypeLike[_V],
     /,
     *,
     key_serializer: Callable[[Any], bytes] | None = None,
@@ -274,7 +288,7 @@ def redis_hash_map_key(
     timeout: Duration | None = None,
     ttl: Duration | None = None,
     error: type[Exception] = TimeoutError,
-) -> RedisHashMapKey[Any, Any]:
+) -> RedisHashMapKey[_K, _V]:
     """Create a redis key."""
     return RedisHashMapKey(  # skipif-ci-and-not-linux
         name=name,
@@ -297,7 +311,7 @@ class RedisKey(Generic[_T]):
     """A key in a redis store."""
 
     name: str
-    type: type[_T]
+    type: TypeLike[_T]
     serializer: Callable[[_T], bytes] | None = None
     deserializer: Callable[[bytes], _T] | None = None
     timeout: Duration | None = None
@@ -420,9 +434,21 @@ def redis_key(
     error: type[Exception] = TimeoutError,
     ttl: Duration | None = None,
 ) -> RedisKey[_T1 | _T2 | _T3 | _T4 | _T5]: ...
+@overload
+def redis_key(
+    name: str,
+    type_: TypeLike[_T],
+    /,
+    *,
+    serializer: Callable[[_T1 | _T2 | _T3 | _T4 | _T5], bytes] | None = None,
+    deserializer: Callable[[bytes], _T1 | _T2 | _T3 | _T4 | _T5] | None = None,
+    timeout: Duration | None = None,
+    error: type[Exception] = TimeoutError,
+    ttl: Duration | None = None,
+) -> RedisKey[_T]: ...
 def redis_key(
     name: str,
-    type_: Any,
+    type_: TypeLike[_T],
     /,
     *,
     serializer: Callable[[Any], bytes] | None = None,
@@ -430,7 +456,7 @@ def redis_key(
     timeout: Duration | None = None,
     error: type[Exception] = TimeoutError,
     ttl: Duration | None = None,
-) -> RedisKey[Any]:
+) -> RedisKey[_T]:
     """Create a redis key."""
     return RedisKey(  # skipif-ci-and-not-linux
         name=name,

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/utilities/types.py

@@ -45,12 +45,13 @@ type OpenMode = Literal[
     "x+b",
     "a+b",
 ]
-type StrMapping = Mapping[str, Any]
-type StrStrMapping = Mapping[str, str]
-type TupleOrStrMapping = tuple[Any, ...] | StrMapping
 type MaybeCallable[_T] = _T | Callable[[], _T]
 type MaybeStr[_T] = _T | str
 type MaybeType[_T] = _T | type[_T]
+type StrMapping = Mapping[str, Any]
+type StrStrMapping = Mapping[str, str]
+type TypeLike[_T] = type[_T] | tuple[type[_T], ...]
+type TupleOrStrMapping = tuple[Any, ...] | StrMapping
 
 
 # asyncio
@@ -232,7 +233,7 @@ class SupportsRound(Protocol[_T_co]):
 
 # parse
 type ParseObjectExtra = Mapping[Any, Callable[[str], Any]]
-type SerializeObjectExtra = Mapping[type[Any], Callable[[Any], str]]
+type SerializeObjectExtra = Mapping[Any, Callable[[Any], str]]
 
 
 # pathlib
@@ -327,5 +328,6 @@ __all__ = [
     "TimeZone",
     "TimeZoneLike",
     "TupleOrStrMapping",
+    "TypeLike",
     "WeekDay",
 ]

{dycw_utilities-0.110.4 → dycw_utilities-0.110.6}/src/utilities/warnings.py

@@ -7,12 +7,12 @@ from warnings import catch_warnings, filterwarnings
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
+    from utilities.types import TypeLike
+
 
 @contextmanager
 def catch_warnings_as_errors(
-    *,
-    message: str = "",
-    category: type[Warning] | tuple[type[Warning], ...] | None = None,
+    *, message: str = "", category: TypeLike[Warning] | None = None
 ) -> Iterator[None]:
     """Catch warnings as errors."""
     with _handle_warnings("error", message=message, category=category):
@@ -21,9 +21,7 @@ def catch_warnings_as_errors(
 
 @contextmanager
 def suppress_warnings(
-    *,
-    message: str = "",
-    category: type[Warning] | tuple[type[Warning], ...] | None = None,
+    *, message: str = "", category: TypeLike[Warning] | None = None
 ) -> Iterator[None]:
     """Suppress warnings."""
     with _handle_warnings("ignore", message=message, category=category):
@@ -38,7 +36,7 @@ def _handle_warnings(
     /,
     *,
     message: str = "",
-    category: type[Warning] | tuple[type[Warning], ...] | None = None,
+    category: TypeLike[Warning] | None = None,
 ) -> ExitStack:
     """Handle a set of warnings."""
     stack = ExitStack()