dycw-utilities 0.133.7__py3-none-any.whl → 0.134.0__py3-none-any.whl

utilities/functions.py

@@ -14,19 +14,8 @@ from types import (
     MethodWrapperType,
     WrapperDescriptorType,
 )
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Generic,
-    Literal,
-    TypeGuard,
-    TypeVar,
-    cast,
-    overload,
-    override,
-)
+from typing import TYPE_CHECKING, Any, Literal, TypeGuard, cast, overload, override
 
-from typing_extensions import ParamSpec
 from whenever import Date, PlainDateTime, Time, TimeDelta, ZonedDateTime
 
 from utilities.reprlib import get_repr, get_repr_and_class
@@ -35,10 +24,7 @@ from utilities.types import (
     Dataclass,
     Number,
     StrMapping,
-    TCallable,
-    TCallable1,
-    TCallable2,
-    TSupportsRichComparison,
+    SupportsRichComparison,
     TupleOrStrMapping,
     TypeLike,
 )
@@ -47,27 +33,14 @@ if TYPE_CHECKING:
     from collections.abc import Container, Hashable, Sized
 
 
-_P = ParamSpec("_P")
-_T = TypeVar("_T")
-_T1 = TypeVar("_T1")
-_T2 = TypeVar("_T2")
-_T3 = TypeVar("_T3")
-_T4 = TypeVar("_T4")
-_T5 = TypeVar("_T5")
-_U = TypeVar("_U")
-
-
-##
-
-
-def apply_decorators(
-    func: TCallable1, /, *decorators: Callable[[TCallable2], TCallable2]
-) -> TCallable1:
+def apply_decorators[F1: Callable, F2: Callable](
+    func: F1, /, *decorators: Callable[[F2], F2]
+) -> F1:
     """Apply a set of decorators to a function."""
     return reduce(_apply_decorators_one, decorators, func)
 
 
-def _apply_decorators_one(acc: TCallable, el: Callable[[Any], Any], /) -> TCallable:
+def _apply_decorators_one[F: Callable](acc: F, el: Callable[[Any], Any], /) -> F:
     return el(acc)
 
 
@@ -125,66 +98,64 @@ class EnsureBytesError(Exception):
 
 
 @overload
-def ensure_class(obj: Any, cls: type[_T], /, *, nullable: bool) -> _T | None: ...
+def ensure_class[T](obj: Any, cls: type[T], /, *, nullable: bool) -> T | None: ...
 @overload
-def ensure_class(
-    obj: Any, cls: type[_T], /, *, nullable: Literal[False] = False
-) -> _T: ...
+def ensure_class[T](
+    obj: Any, cls: type[T], /, *, nullable: Literal[False] = False
+) -> T: ...
 @overload
-def ensure_class(
-    obj: Any, cls: tuple[type[_T1], type[_T2]], /, *, nullable: bool
-) -> _T1 | _T2 | None: ...
+def ensure_class[T1, T2](
+    obj: Any, cls: tuple[type[T1], type[T2]], /, *, nullable: bool
+) -> T1 | T2 | None: ...
 @overload
-def ensure_class(
-    obj: Any, cls: tuple[type[_T1], type[_T2]], /, *, nullable: Literal[False] = False
-) -> _T1 | _T2: ...
+def ensure_class[T1, T2](
+    obj: Any, cls: tuple[type[T1], type[T2]], /, *, nullable: Literal[False] = False
+) -> T1 | T2: ...
 @overload
-def ensure_class(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3]], /, *, nullable: bool
-) -> _T1 | _T2 | _T3 | None: ...
+def ensure_class[T1, T2, T3](
+    obj: Any, cls: tuple[type[T1], type[T2], type[T3]], /, *, nullable: bool
+) -> T1 | T2 | T3 | None: ...
 @overload
-def ensure_class(
+def ensure_class[T1, T2, T3](
     obj: Any,
-    cls: tuple[type[_T1], type[_T2], type[_T3]],
+    cls: tuple[type[T1], type[T2], type[T3]],
     /,
     *,
     nullable: Literal[False] = False,
-) -> _T1 | _T2 | _T3: ...
+) -> T1 | T2 | T3: ...
 @overload
-def ensure_class(
-    obj: Any,
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4]],
-    /,
-    *,
-    nullable: bool,
-) -> _T1 | _T2 | _T3 | _T4 | None: ...
+def ensure_class[T1, T2, T3, T4](
+    obj: Any, cls: tuple[type[T1], type[T2], type[T3], type[T4]], /, *, nullable: bool
+) -> T1 | T2 | T3 | T4 | None: ...
 @overload
-def ensure_class(
+def ensure_class[T1, T2, T3, T4](
     obj: Any,
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4]],
+    cls: tuple[type[T1], type[T2], type[T3], type[T4]],
     /,
     *,
     nullable: Literal[False] = False,
-) -> _T1 | _T2 | _T3 | _T4: ...
+) -> T1 | T2 | T3 | T4: ...
 @overload
-def ensure_class(
+def ensure_class[T1, T2, T3, T4, T5](
     obj: Any,
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]],
+    cls: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]],
     /,
     *,
     nullable: bool,
-) -> _T1 | _T2 | _T3 | _T4 | _T5 | None: ...
+) -> T1 | T2 | T3 | T4 | T5 | None: ...
 @overload
-def ensure_class(
+def ensure_class[T1, T2, T3, T4, T5](
     obj: Any,
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4], type[_T5]],
+    cls: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]],
     /,
     *,
     nullable: Literal[False] = False,
-) -> _T1 | _T2 | _T3 | _T4 | _T5: ...
+) -> T1 | T2 | T3 | T4 | T5: ...
 @overload
-def ensure_class(obj: Any, cls: TypeLike[_T], /, *, nullable: bool = False) -> Any: ...
-def ensure_class(obj: Any, cls: TypeLike[_T], /, *, nullable: bool = False) -> Any:
+def ensure_class[T](
+    obj: Any, cls: TypeLike[T], /, *, nullable: bool = False
+) -> Any: ...
+def ensure_class[T](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
@@ -304,16 +275,16 @@ class EnsureIntError(Exception):
 
 
 @overload
-def ensure_member(
-    obj: Any, container: Container[_T], /, *, nullable: bool
-) -> _T | None: ...
+def ensure_member[T](
+    obj: Any, container: Container[T], /, *, nullable: bool
+) -> T | None: ...
 @overload
-def ensure_member(
-    obj: Any, container: Container[_T], /, *, nullable: Literal[False] = False
-) -> _T: ...
-def ensure_member(
-    obj: Any, container: Container[_T], /, *, nullable: bool = False
-) -> _T | None:
+def ensure_member[T](
+    obj: Any, container: Container[T], /, *, nullable: Literal[False] = False
+) -> T: ...
+def ensure_member[T](
+    obj: Any, container: Container[T], /, *, nullable: bool = False
+) -> T | None:
     """Ensure an object is a member of the container."""
     if (obj in container) or ((obj is None) and nullable):
         return obj
@@ -336,7 +307,7 @@ class EnsureMemberError(Exception):
 ##
 
 
-def ensure_not_none(obj: _T | None, /, *, desc: str = "Object") -> _T:
+def ensure_not_none[T](obj: T | None, /, *, desc: str = "Object") -> T:
     """Ensure an object is not None."""
     if obj is None:
         raise EnsureNotNoneError(desc=desc)
@@ -578,7 +549,7 @@ class EnsureZonedDateTimeError(Exception):
 ##
 
 
-def first(pair: tuple[_T, Any], /) -> _T:
+def first[T](pair: tuple[T, Any], /) -> T:
     """Get the first element in a pair."""
     return pair[0]
 
@@ -587,10 +558,10 @@ def first(pair: tuple[_T, Any], /) -> _T:
 
 
 @overload
-def get_class(obj: type[_T], /) -> type[_T]: ...
+def get_class[T](obj: type[T], /) -> type[T]: ...
 @overload
-def get_class(obj: _T, /) -> type[_T]: ...
-def get_class(obj: _T | type[_T], /) -> type[_T]:
+def get_class[T](obj: T, /) -> type[T]: ...
+def get_class[T](obj: T | type[T], /) -> type[T]:
     """Get the class of an object, unless it is already a class."""
     return obj if isinstance(obj, type) else type(obj)
 
@@ -654,7 +625,7 @@ def get_func_qualname(obj: Callable[..., Any], /) -> str:
 ##
 
 
-def identity(obj: _T, /) -> _T:
+def identity[T](obj: T, /) -> T:
     """Return the object itself."""
     return obj
 
@@ -691,28 +662,30 @@ def is_hashable(obj: Any, /) -> TypeGuard[Hashable]:
 
 
 @overload
-def is_iterable_of(obj: Any, cls: type[_T], /) -> TypeGuard[Iterable[_T]]: ...
+def is_iterable_of[T](obj: Any, cls: type[T], /) -> TypeGuard[Iterable[T]]: ...
 @overload
-def is_iterable_of(obj: Any, cls: tuple[type[_T1]], /) -> TypeGuard[Iterable[_T1]]: ...
+def is_iterable_of[T1](
+    obj: Any, cls: tuple[type[T1]], /
+) -> TypeGuard[Iterable[T1]]: ...
 @overload
-def is_iterable_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2]], /
-) -> TypeGuard[Iterable[_T1 | _T2]]: ...
+def is_iterable_of[T1, T2](
+    obj: Any, cls: tuple[type[T1], type[T2]], /
+) -> TypeGuard[Iterable[T1 | T2]]: ...
 @overload
-def is_iterable_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3]], /
-) -> TypeGuard[Iterable[_T1 | _T2 | _T3]]: ...
+def is_iterable_of[T1, T2, T3](
+    obj: Any, cls: tuple[type[T1], type[T2], type[T3]], /
+) -> TypeGuard[Iterable[T1 | T2 | T3]]: ...
 @overload
-def is_iterable_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4]], /
-) -> TypeGuard[Iterable[_T1 | _T2 | _T3 | _T4]]: ...
+def is_iterable_of[T1, T2, T3, T4](
+    obj: Any, cls: tuple[type[T1], type[T2], type[T3], type[T4]], /
+) -> TypeGuard[Iterable[T1 | T2 | T3 | T4]]: ...
 @overload
-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[T1, T2, T3, T4, T5](
+    obj: Any, cls: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]], /
+) -> TypeGuard[Iterable[T1 | T2 | T3 | T4 | T5]]: ...
 @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]]:
+def is_iterable_of[T](obj: Any, cls: TypeLike[T], /) -> TypeGuard[Iterable[T]]: ...
+def is_iterable_of[T](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))
 
@@ -737,28 +710,30 @@ def is_not_none(obj: Any, /) -> bool:
 
 
 @overload
-def is_sequence_of(obj: Any, cls: type[_T], /) -> TypeGuard[Sequence[_T]]: ...
+def is_sequence_of[T](obj: Any, cls: type[T], /) -> TypeGuard[Sequence[T]]: ...
 @overload
-def is_sequence_of(obj: Any, cls: tuple[type[_T1]], /) -> TypeGuard[Sequence[_T1]]: ...
+def is_sequence_of[T1](
+    obj: Any, cls: tuple[type[T1]], /
+) -> TypeGuard[Sequence[T1]]: ...
 @overload
-def is_sequence_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2]], /
-) -> TypeGuard[Sequence[_T1 | _T2]]: ...
+def is_sequence_of[T1, T2](
+    obj: Any, cls: tuple[type[T1], type[T2]], /
+) -> TypeGuard[Sequence[T1 | T2]]: ...
 @overload
-def is_sequence_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3]], /
-) -> TypeGuard[Sequence[_T1 | _T2 | _T3]]: ...
+def is_sequence_of[T1, T2, T3](
+    obj: Any, cls: tuple[type[T1], type[T2], type[T3]], /
+) -> TypeGuard[Sequence[T1 | T2 | T3]]: ...
 @overload
-def is_sequence_of(
-    obj: Any, cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4]], /
-) -> TypeGuard[Sequence[_T1 | _T2 | _T3 | _T4]]: ...
+def is_sequence_of[T1, T2, T3, T4](
+    obj: Any, cls: tuple[type[T1], type[T2], type[T3], type[T4]], /
+) -> TypeGuard[Sequence[T1 | T2 | T3 | T4]]: ...
 @overload
-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[T1, T2, T3, T4, T5](
+    obj: Any, cls: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]], /
+) -> TypeGuard[Sequence[T1 | T2 | T3 | T4 | T5]]: ...
 @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]]:
+def is_sequence_of[T](obj: Any, cls: TypeLike[T], /) -> TypeGuard[Sequence[T]]: ...
+def is_sequence_of[T](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)
 
@@ -821,46 +796,42 @@ def is_tuple_or_str_mapping(obj: Any, /) -> TypeGuard[TupleOrStrMapping]:
 
 
 @overload
-def make_isinstance(cls: type[_T], /) -> Callable[[Any], TypeGuard[_T]]: ...
+def make_isinstance[T](cls: type[T], /) -> Callable[[Any], TypeGuard[T]]: ...
 @overload
-def make_isinstance(cls: tuple[type[_T1]], /) -> Callable[[Any], TypeGuard[_T1]]: ...
+def make_isinstance[T1](cls: tuple[type[T1]], /) -> Callable[[Any], TypeGuard[T1]]: ...
 @overload
-def make_isinstance(
-    cls: tuple[type[_T1], type[_T2]], /
-) -> Callable[[Any], TypeGuard[_T1 | _T2]]: ...
+def make_isinstance[T1, T2](
+    cls: tuple[type[T1], type[T2]], /
+) -> Callable[[Any], TypeGuard[T1 | T2]]: ...
 @overload
-def make_isinstance(
-    cls: tuple[type[_T1], type[_T2], type[_T3]], /
-) -> Callable[[Any], TypeGuard[_T1 | _T2 | _T3]]: ...
+def make_isinstance[T1, T2, T3](
+    cls: tuple[type[T1], type[T2], type[T3]], /
+) -> Callable[[Any], TypeGuard[T1 | T2 | T3]]: ...
 @overload
-def make_isinstance(
-    cls: tuple[type[_T1], type[_T2], type[_T3], type[_T4]], /
-) -> Callable[[Any], TypeGuard[_T1 | _T2 | _T3 | _T4]]: ...
+def make_isinstance[T1, T2, T3, T4](
+    cls: tuple[type[T1], type[T2], type[T3], type[T4]], /
+) -> Callable[[Any], TypeGuard[T1 | T2 | T3 | T4]]: ...
 @overload
-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[T1, T2, T3, T4, T5](
+    cls: tuple[type[T1], type[T2], type[T3], type[T4], type[T5]], /
+) -> Callable[[Any], TypeGuard[T1 | T2 | T3 | T4 | T5]]: ...
 @overload
-def make_isinstance(cls: TypeLike[_T], /) -> Callable[[Any], TypeGuard[_T]]: ...
-def make_isinstance(cls: TypeLike[_T], /) -> Callable[[Any], TypeGuard[_T]]:
+def make_isinstance[T](cls: TypeLike[T], /) -> Callable[[Any], TypeGuard[T]]: ...
+def make_isinstance[T](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: TypeLike[_T]) -> TypeGuard[_T]:
+def _make_instance_core[T](obj: Any, /, *, cls: TypeLike[T]) -> TypeGuard[T]:
     return isinstance(obj, cls)
 
 
 ##
 
 
-def map_object(
-    func: Callable[[Any], Any],
-    obj: _T,
-    /,
-    *,
-    before: Callable[[Any], Any] | None = None,
-) -> _T:
+def map_object[T](
+    func: Callable[[Any], Any], obj: T, /, *, before: Callable[[Any], Any] | None = None
+) -> T:
     """Map a function over an object, across a variety of structures."""
     if before is not None:
         obj = before(obj)
@@ -881,19 +852,16 @@ def map_object(
 
 
 @overload
-def min_nullable(
-    iterable: Iterable[TSupportsRichComparison | None], /, *, default: Sentinel = ...
-) -> TSupportsRichComparison: ...
+def min_nullable[T: SupportsRichComparison](
+    iterable: Iterable[T | None], /, *, default: Sentinel = ...
+) -> T: ...
 @overload
-def min_nullable(
-    iterable: Iterable[TSupportsRichComparison | None], /, *, default: _U = ...
-) -> TSupportsRichComparison | _U: ...
-def min_nullable(
-    iterable: Iterable[TSupportsRichComparison | None],
-    /,
-    *,
-    default: _U | Sentinel = sentinel,
-) -> TSupportsRichComparison | _U:
+def min_nullable[T: SupportsRichComparison, U](
+    iterable: Iterable[T | None], /, *, default: U = ...
+) -> T | U: ...
+def min_nullable[T: SupportsRichComparison, U](
+    iterable: Iterable[T | None], /, *, default: U | Sentinel = sentinel
+) -> T | U:
     """Compute the minimum of a set of values; ignoring nulls."""
     values = (i for i in iterable if i is not None)
     if isinstance(default, Sentinel):
@@ -905,8 +873,8 @@ def min_nullable(
 
 
 @dataclass(kw_only=True, slots=True)
-class MinNullableError(Exception, Generic[TSupportsRichComparison]):
-    values: Iterable[TSupportsRichComparison]
+class MinNullableError[T: SupportsRichComparison](Exception):
+    values: Iterable[T]
 
     @override
     def __str__(self) -> str:
@@ -914,19 +882,16 @@ class MinNullableError(Exception, Generic[TSupportsRichComparison]):
 
 
 @overload
-def max_nullable(
-    iterable: Iterable[TSupportsRichComparison | None], /, *, default: Sentinel = ...
-) -> TSupportsRichComparison: ...
+def max_nullable[T: SupportsRichComparison](
+    iterable: Iterable[T | None], /, *, default: Sentinel = ...
+) -> T: ...
 @overload
-def max_nullable(
-    iterable: Iterable[TSupportsRichComparison | None], /, *, default: _U = ...
-) -> TSupportsRichComparison | _U: ...
-def max_nullable(
-    iterable: Iterable[TSupportsRichComparison | None],
-    /,
-    *,
-    default: _U | Sentinel = sentinel,
-) -> TSupportsRichComparison | _U:
+def max_nullable[T: SupportsRichComparison, U](
+    iterable: Iterable[T | None], /, *, default: U = ...
+) -> T | U: ...
+def max_nullable[T: SupportsRichComparison, U](
+    iterable: Iterable[T | None], /, *, default: U | Sentinel = sentinel
+) -> T | U:
     """Compute the maximum of a set of values; ignoring nulls."""
     values = (i for i in iterable if i is not None)
     if isinstance(default, Sentinel):
@@ -938,7 +903,7 @@ def max_nullable(
 
 
 @dataclass(kw_only=True, slots=True)
-class MaxNullableError(Exception, Generic[TSupportsRichComparison]):
+class MaxNullableError[TSupportsRichComparison](Exception):
     values: Iterable[TSupportsRichComparison]
 
     @override
@@ -949,11 +914,11 @@ class MaxNullableError(Exception, Generic[TSupportsRichComparison]):
 ##
 
 
-def not_func(func: Callable[_P, bool], /) -> Callable[_P, bool]:
+def not_func[**P](func: Callable[P, bool], /) -> Callable[P, bool]:
     """Lift a boolean-valued function to return its conjugation."""
 
     @wraps(func)
-    def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> bool:
+    def wrapped(*args: P.args, **kwargs: P.kwargs) -> bool:
         return not func(*args, **kwargs)
 
     return wrapped
@@ -962,7 +927,7 @@ def not_func(func: Callable[_P, bool], /) -> Callable[_P, bool]:
 ##
 
 
-def second(pair: tuple[Any, _U], /) -> _U:
+def second[U](pair: tuple[Any, U], /) -> U:
     """Get the second element in a pair."""
     return pair[1]
 

utilities/functools.py

@@ -3,19 +3,15 @@ from __future__ import annotations
 from functools import cache as _cache
 from functools import lru_cache as _lru_cache
 from functools import partial as _partial
-from typing import TYPE_CHECKING, Any, TypeVar, cast, overload, override
+from typing import TYPE_CHECKING, Any, cast, overload, override
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from utilities.types import TCallable
 
-_T = TypeVar("_T")
-
-
-def cache(func: TCallable, /) -> TCallable:
+def cache[F: Callable](func: F, /) -> F:
     """Typed version of `cache`."""
-    typed_cache = cast("Callable[[TCallable], TCallable]", _cache)
+    typed_cache = cast("Callable[[F], F]", _cache)
     return typed_cache(func)
 
 
@@ -23,20 +19,20 @@ def cache(func: TCallable, /) -> TCallable:
 
 
 @overload
-def lru_cache(
-    func: TCallable, /, *, max_size: int = ..., typed: bool = ...
-) -> TCallable: ...
+def lru_cache[F: Callable](
+    func: F, /, *, max_size: int = ..., typed: bool = ...
+) -> F: ...
 @overload
-def lru_cache(
+def lru_cache[F: Callable](
     func: None = None, /, *, max_size: int = ..., typed: bool = ...
-) -> Callable[[TCallable], TCallable]: ...
-def lru_cache(
-    func: TCallable | None = None, /, *, max_size: int = 128, typed: bool = False
-) -> TCallable | Callable[[TCallable], TCallable]:
+) -> Callable[[F], F]: ...
+def lru_cache[F: Callable](
+    func: F | None = None, /, *, max_size: int = 128, typed: bool = False
+) -> F | Callable[[F], F]:
     """Typed version of `lru_cache`."""
     if func is None:
         result = partial(lru_cache, max_size=max_size, typed=typed)
-        return cast("Callable[[TCallable], TCallable]", result)
+        return cast("Callable[[F], F]", result)
     wrapped = _lru_cache(maxsize=max_size, typed=typed)(func)
     return cast("Any", wrapped)
 
@@ -44,11 +40,11 @@ def lru_cache(
 ##
 
 
-class partial(_partial[_T]):  # noqa: N801
+class partial[T](_partial[T]):  # noqa: N801
     """Partial which accepts Ellipsis for positional arguments."""
 
     @override
-    def __call__(self, *args: Any, **kwargs: Any) -> _T:
+    def __call__(self, *args: Any, **kwargs: Any) -> T:
         iter_args = iter(args)
         head = (next(iter_args) if arg is ... else arg for arg in self.args)
         return self.func(*head, *iter_args, **{**self.keywords, **kwargs})