jetpytools 1.7.4__tar.gz → 2.0.0__tar.gz

{jetpytools-1.7.4 → jetpytools-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetpytools
-Version: 1.7.4
+Version: 2.0.0
 Summary: Collection of stuff that's useful in general python programming
 Project-URL: Source Code, https://github.com/Jaded-Encoding-Thaumaturgy/jetpytools
 Project-URL: Contact, https://discord.gg/XTpc6Fa9eB
@@ -15,8 +15,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Requires-Dist: typing-extensions>=4.12.2
+Requires-Python: >=3.12
+Requires-Dist: typing-extensions>=4.15.0
 Description-Content-Type: text/markdown
 
 # jetpytools

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/_metadata.py

@@ -1,6 +1,6 @@
 """Collection of stuff that's useful in general python programming"""
 
-__version__ = "1.7.4"
+__version__ = "2.0.0"
 
 __author_name__, __author_email__ = "Jaded Encoding Thaumaturgy", "jaded.encoding.thaumaturgy@gmail.com"
 __maintainer_name__, __maintainer_email__ = __author_name__, __author_email__

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/enums/base.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any
-
-from typing_extensions import Self
+from typing import Any, Self
 
 from ..exceptions import CustomValueError, NotFoundEnumValue
 from ..types import FuncExcept
@@ -68,10 +66,6 @@ class CustomEnum(Enum):
 class CustomIntEnum(int, CustomEnum):
     """Base class for custom int enums."""
 
-    value: int
-
 
 class CustomStrEnum(str, CustomEnum):
     """Base class for custom str enums."""
-
-    value: str

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/enums/other.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-from typing import overload
-
-from typing_extensions import Self
+from typing import Self, overload
 
 __all__ = ["Coordinate", "Position", "Size"]
 
@@ -27,17 +25,19 @@ class Coordinate:
     def __init__(self, x: int, y: int, /) -> None: ...
 
     def __init__(self, x_or_self: int | tuple[int, int] | Self, y: int | None = None, /) -> None:
-        from ..exceptions import CustomValueError
-
         if isinstance(x_or_self, int):
             x = x_or_self
         else:
             x, y = x_or_self if isinstance(x_or_self, tuple) else (x_or_self.x, x_or_self.y)
 
         if y is None:
+            from ..exceptions import CustomValueError
+
             raise CustomValueError("y coordinate must be defined!", self.__class__)
 
         if x < 0 or y < 0:
+            from ..exceptions import CustomValueError
+
             raise CustomValueError("Values can't be negative!", self.__class__)
 
         self.x = x

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/exceptions/base.py

@@ -4,7 +4,7 @@ import sys
 from contextlib import AbstractContextManager
 from copy import deepcopy
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Generic, TypeVar
+from typing import TYPE_CHECKING, Any
 
 from typing_extensions import Self
 
@@ -35,11 +35,13 @@ else:
 class CustomErrorMeta(type):
     """Custom base exception meta class."""
 
-    def __new__(cls: type[SelfCErrorMeta], *args: Any) -> SelfCErrorMeta:
+    def __new__[MetaSelf: CustomErrorMeta](cls: type[MetaSelf], *args: Any) -> MetaSelf:
         return CustomErrorMeta.setup_exception(super().__new__(cls, *args))
 
     @staticmethod
-    def setup_exception(exception: SelfCErrorMeta, override: str | ExceptionError | None = None) -> SelfCErrorMeta:
+    def setup_exception[MetaSelf: CustomErrorMeta](
+        exception: MetaSelf, override: str | ExceptionError | None = None
+    ) -> MetaSelf:
         """
         Setup an exception for later use in CustomError.
 
@@ -73,9 +75,6 @@ class CustomErrorMeta(type):
         return exception
 
 
-SelfCErrorMeta = TypeVar("SelfCErrorMeta", bound=CustomErrorMeta)
-
-
 class CustomError(ExceptionError, metaclass=CustomErrorMeta):
     """Custom base exception class."""
 
@@ -97,13 +96,6 @@ class CustomError(ExceptionError, metaclass=CustomErrorMeta):
 
         super().__init__(message)
 
-    def __class_getitem__(cls, exception: str | type[ExceptionError] | ExceptionError) -> CustomError:
-        from warnings import warn
-
-        warn("Custom error is not subscriptable anymore. Don't use it", DeprecationWarning)
-
-        return cls()
-
     def __call__(
         self,
         message: SupportsString | None | MissingT = MISSING,
@@ -170,20 +162,8 @@ class CustomError(ExceptionError, metaclass=CustomErrorMeta):
 
         out = f"{func_header}{self.message!s}{reason}".format(**self.kwargs).strip()
 
-        if sys.version_info < (3, 13) and hasattr(self, "__notes__"):
-            out += "\n" + "\n".join(self.__notes__)
-
         return out
 
-    if sys.version_info < (3, 11):
-        __notes__: list[str]
-
-        def add_note(self, note: str, /) -> None:
-            if not hasattr(self, "__notes__"):
-                self.__notes__ = []
-
-            self.__notes__.append(note)
-
     @classmethod
     def catch(cls) -> CatchError[Self]:
         """
@@ -196,20 +176,17 @@ class CustomError(ExceptionError, metaclass=CustomErrorMeta):
         return CatchError(cls)
 
 
-SelfError = TypeVar("SelfError", bound=CustomError)
-
-
-class CatchError(AbstractContextManager["CatchError[SelfError]"], Generic[SelfError]):
+class CatchError[CustomErrorT: CustomError](AbstractContextManager["CatchError[CustomErrorT]"]):
     """
     Context manager for catching a specific exception type.
     """
 
-    error: SelfError | None
+    error: CustomErrorT | None
     """The caught exception instance, if any."""
     tb: TracebackType | None
     """The traceback object associated with the caught exception."""
 
-    def __init__(self, error: type[SelfError]) -> None:
+    def __init__(self, error: type[CustomErrorT]) -> None:
         self.error = None
         self.tb = None
         self._to_catch_error = error

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/exceptions/generic.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any, Iterable
 
-from ..types import FuncExcept, SupportsString, T
+from ..types import FuncExcept, SupportsString
 from .base import CustomValueError
 
 __all__ = ["MismatchError", "MismatchRefError"]
@@ -36,7 +36,7 @@ class MismatchError(CustomValueError):
 
 
 class MismatchRefError(MismatchError):
-    def __init__(
+    def __init__[T](
         self, func: FuncExcept, base: T, ref: T, message: SupportsString = "All items must be equal!", **kwargs: Any
     ) -> None:
         super().__init__(func, [base, ref], message, **kwargs)

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/functions/funcs.py

@@ -4,12 +4,12 @@ from inspect import signature
 from typing import Any, Callable, Concatenate, overload
 
 from ..exceptions import CustomRuntimeError, CustomValueError
-from ..types import MISSING, KwargsT, MissingT, P, R, T
+from ..types import MISSING, KwargsT, MissingT
 
 __all__ = ["fallback", "filter_kwargs", "iterate", "kwargs_fallback"]
 
 
-def iterate(
+def iterate[T, **P, R](
     base: T, function: Callable[Concatenate[T | R, P], R], count: int, *args: P.args, **kwargs: P.kwargs
 ) -> T | R:
     """
@@ -48,26 +48,26 @@ fallback_missing = object()
 
 
 @overload
-def fallback(value: T | None, fallback: T, /) -> T: ...
+def fallback[T](value: T | None, fallback: T, /) -> T: ...
 
 
 @overload
-def fallback(value: T | None, fallback0: T | None, default: T, /) -> T: ...
+def fallback[T](value: T | None, fallback0: T | None, default: T, /) -> T: ...
 
 
 @overload
-def fallback(value: T | None, fallback0: T | None, fallback1: T | None, default: T, /) -> T: ...
+def fallback[T](value: T | None, fallback0: T | None, fallback1: T | None, default: T, /) -> T: ...
 
 
 @overload
-def fallback(value: T | None, *fallbacks: T | None) -> T | MissingT: ...
+def fallback[T](value: T | None, *fallbacks: T | None) -> T | MissingT: ...
 
 
 @overload
-def fallback(value: T | None, *fallbacks: T | None, default: T) -> T: ...
+def fallback[T](value: T | None, *fallbacks: T | None, default: T) -> T: ...
 
 
-def fallback(value: T | None, *fallbacks: T | None, default: Any | T = fallback_missing) -> T | MissingT:
+def fallback[T](value: T | None, *fallbacks: T | None, default: Any | T = fallback_missing) -> T | MissingT:
     """
     Utility function that returns a value or a fallback if the value is None.
 
@@ -102,32 +102,31 @@ def fallback(value: T | None, *fallbacks: T | None, default: Any | T = fallback_
 
 
 @overload
-def kwargs_fallback(input_value: T | None, kwargs: tuple[KwargsT, str], fallback: T) -> T: ...
+def kwargs_fallback[T](input_value: T | None, kwargs: tuple[KwargsT, str], fallback: T, /) -> T: ...
 
 
 @overload
-def kwargs_fallback(input_value: T | None, kwargs: tuple[KwargsT, str], fallback0: T | None, default: T) -> T: ...
+def kwargs_fallback[T](input_value: T | None, kwargs: tuple[KwargsT, str], fallback0: T | None, default: T, /) -> T: ...
 
 
 @overload
-def kwargs_fallback(
-    input_value: T | None, kwargs: tuple[KwargsT, str], fallback0: T | None, fallback1: T | None, default: T
+def kwargs_fallback[T](
+    input_value: T | None, kwargs: tuple[KwargsT, str], fallback0: T | None, fallback1: T | None, default: T, /
 ) -> T: ...
 
 
 @overload
-def kwargs_fallback(input_value: T | None, kwargs: tuple[KwargsT, str], *fallbacks: T | None) -> T | MissingT: ...
+def kwargs_fallback[T](input_value: T | None, kwargs: tuple[KwargsT, str], /, *fallbacks: T | None) -> T | MissingT: ...
 
 
 @overload
-def kwargs_fallback(input_value: T | None, kwargs: tuple[KwargsT, str], *fallbacks: T | None, default: T) -> T: ...
+def kwargs_fallback[T](
+    input_value: T | None, kwargs: tuple[KwargsT, str], /, *fallbacks: T | None, default: T
+) -> T: ...
 
 
-def kwargs_fallback(  # type: ignore
-    value: T | None,
-    kwargs: tuple[KwargsT, str],
-    *fallbacks: T | None,
-    default: T = fallback_missing,  # type: ignore
+def kwargs_fallback[T](
+    value: T | None, kwargs: tuple[KwargsT, str], *fallbacks: T | None, default: Any | T = fallback_missing
 ) -> T | MissingT:
     """Utility function to return a fallback value from kwargs if value was not found or is None."""
 

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/functions/normalize.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-import sys
 from fractions import Fraction
-from typing import Any, Callable, Iterable, Iterator, Sequence, overload
+from typing import Any, Callable, Iterable, Iterator, Protocol, Sequence, overload, runtime_checkable
 
 from ..exceptions import CustomOverflowError
-from ..types import SoftRange, SoftRangeN, SoftRangesN, StrictRange, SupportsString, T, is_soft_range_n
+from ..types import SoftRange, SoftRangeN, SoftRangesN, StrictRange, SupportsString, is_soft_range_n
 
 __all__ = [
     "flatten",
@@ -22,14 +21,14 @@ __all__ = [
 
 
 @overload
-def normalize_seq(val: T | Sequence[T], length: int) -> list[T]: ...
+def normalize_seq[T](val: T | Sequence[T], length: int) -> list[T]: ...
 
 
 @overload
 def normalize_seq(val: Any, length: int) -> list[Any]: ...
 
 
-def normalize_seq(val: T | Sequence[T], length: int) -> list[T]:
+def normalize_seq[T](val: T | Sequence[T], length: int) -> list[T]:
     """
     Normalize a sequence of values.
 
@@ -49,28 +48,23 @@ def normalize_seq(val: T | Sequence[T], length: int) -> list[T]:
 
 
 @overload
-def to_arr(val: T | Iterable[T]) -> list[T]: ...
+def to_arr[T](val: T | Iterable[T]) -> list[T]: ...
 
 
 @overload
 def to_arr(val: Any) -> list[Any]: ...
 
 
-def to_arr(val: Any, *, sub: Any = []) -> list[Any]:
+def to_arr(val: Any) -> list[Any]:
     """
     Normalize any value to a list.
     Bytes and str are not considered iterable and will not be flattened.
     """
-    if sub:
-        import warnings
-
-        warnings.warn("sub is deprecated.", DeprecationWarning)
-
     return list(val) if (isinstance(val, Iterable) and not isinstance(val, (str, bytes))) else [val]
 
 
 @overload
-def flatten(items: Iterable[Iterable[T]]) -> Iterator[T]: ...
+def flatten[T](items: Iterable[Iterable[T]]) -> Iterator[T]: ...
 
 
 @overload
@@ -239,10 +233,7 @@ def normalize_ranges(
         out.append((start, end))
 
     if exceptions:
-        if sys.version_info >= (3, 11):
-            raise ExceptionGroup("Multiple exceptions occurred!", exceptions)  # noqa: F821
-
-        raise Exception(exceptions)
+        raise ExceptionGroup("Multiple exceptions occurred!", exceptions)
 
     return normalize_list_to_ranges(
         [x for start, end in out for x in range(start, end + (not exclusive))], exclusive=exclusive
@@ -259,6 +250,13 @@ def invert_ranges(
     return normalize_list_to_ranges({*range(lengtha)} - b_frames, exclusive=exclusive)
 
 
+@runtime_checkable
+class _HasSelfAttr(Protocol):
+    __self__: type | object
+
+    def __call__(self, *args: Any, **kwds: Any) -> Any: ...
+
+
 def norm_func_name(func_name: SupportsString | Callable[..., Any]) -> str:
     """Normalize a class, function, or other object to obtain its name"""
 
@@ -275,7 +273,7 @@ def norm_func_name(func_name: SupportsString | Callable[..., Any]) -> str:
     elif hasattr(func_name, "__qualname__"):
         func_name = func.__qualname__
 
-    if callable(func) and hasattr(func, "__self__"):
+    if isinstance(func, _HasSelfAttr):
         func = func.__self__ if isinstance(func.__self__, type) else func.__self__.__class__
         func_name = f"{func.__name__}.{func_name}"
 

jetpytools-2.0.0/jetpytools/types/builtins.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any, Sequence, SupportsFloat, SupportsIndex
+
+__all__ = [
+    "ByteData",
+    "KwargsT",
+    "SimpleByteData",
+    "SimpleByteDataArray",
+    "SingleOrArr",
+    "SingleOrArrOpt",
+    "SingleOrSeq",
+    "SingleOrSeqOpt",
+    "SoftRange",
+    "SoftRangeN",
+    "SoftRangesN",
+    "StrictRange",
+]
+
+type StrictRange = tuple[int, int]
+type SoftRange = int | StrictRange | Sequence[int]
+
+type SoftRangeN = int | tuple[int | None, int | None] | None
+
+type SoftRangesN = Sequence[SoftRangeN]
+
+type SingleOrArr[T] = T | list[T]
+type SingleOrSeq[T] = T | Sequence[T]
+type SingleOrArrOpt[T] = SingleOrArr[T] | None
+type SingleOrSeqOpt[T] = SingleOrSeq[T] | None
+
+type SimpleByteData = str | bytes | bytearray
+type SimpleByteDataArray = SimpleByteData | Sequence[SimpleByteData]
+
+type ByteData = SupportsFloat | SupportsIndex | SimpleByteData | memoryview
+
+KwargsT = dict[str, Any]

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/types/file.py

@@ -4,8 +4,7 @@ import fnmatch
 import shutil
 from os import X_OK, PathLike, access, listdir, path, walk
 from pathlib import Path
-from sys import version_info
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, TypeAlias, Union
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, TypeAlias
 
 from typing_extensions import Self
 
@@ -105,9 +104,6 @@ OpenBinaryMode: TypeAlias = OpenBinaryModeUpdating | OpenBinaryModeReading | Ope
 class SPath(Path):
     """Modified version of pathlib.Path"""
 
-    if version_info < (3, 12):
-        _flavour = type(Path())._flavour  # type: ignore
-
     if TYPE_CHECKING:
 
         def __new__(cls, *args: SPathLike, **kwargs: Any) -> Self: ...
@@ -245,4 +241,4 @@ class SPath(Path):
         return access(self.to_str(), X_OK)
 
 
-SPathLike = Union[str, PathLike[str], Path, SPath]
+type SPathLike = str | PathLike[str]

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/types/funcs.py

@@ -3,9 +3,8 @@ from __future__ import annotations
 from functools import wraps
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, SupportsIndex, TypeAlias
 
-from typing_extensions import Self, TypeIs
+from typing_extensions import TypeIs
 
-from .builtins import P, T
 from .supports import SupportsString
 
 __all__ = ["Sentinel", "SentinelT", "StrList"]
@@ -49,24 +48,24 @@ class StrList(list[SupportsString]):
 
 
 class SentinelDispatcher:
-    def check(self, ret_value: T, cond: bool) -> T | SentinelDispatcher:
+    def check[T](self, ret_value: T, cond: bool) -> T | SentinelDispatcher:
         return ret_value if cond else self
 
-    def check_cb(self, callback: Callable[P, tuple[T, bool]]) -> Callable[P, T | SentinelDispatcher]:
+    def check_cb[T, **P](self, callback: Callable[P, tuple[T, bool]]) -> Callable[P, T | SentinelDispatcher]:
         @wraps(callback)
         def _wrap(*args: P.args, **kwargs: P.kwargs) -> T | SentinelDispatcher:
             return self.check(*callback(*args, **kwargs))
 
         return _wrap
 
-    def filter(self, items: Iterable[T | Self]) -> Iterator[T]:
+    def filter[T](self, items: Iterable[T | SentinelDispatcher]) -> Iterator[T]:
         for item in items:
             if isinstance(item, SentinelDispatcher):
                 continue
             yield item
 
     @classmethod
-    def filter_multi(cls, items: Iterable[T | Self], *sentinels: Self) -> Iterator[T]:
+    def filter_multi[T](cls, items: Iterable[T | SentinelDispatcher], *sentinels: SentinelDispatcher) -> Iterator[T]:
         def _in_sentinels(it: Any) -> TypeIs[SentinelDispatcher]:
             return it in sentinels
 

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/types/generic.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from enum import Enum, auto
-from typing import Any, Callable, Literal, TypeAlias, Union
+from typing import Any, Callable, Literal
 
-from .builtins import F, SingleOrArr, SingleOrArrOpt
+from .builtins import SingleOrArr, SingleOrArrOpt
 from .supports import SupportsString
 
 __all__ = ["MISSING", "DataType", "FuncExcept", "FuncExceptT", "MissingT", "PassthroughC", "StrArr", "StrArrOpt"]
@@ -13,10 +13,10 @@ class _MissingType(Enum):
     MISSING = auto()
 
 
-MissingT: TypeAlias = Literal[_MissingType.MISSING]
+type MissingT = Literal[_MissingType.MISSING]
 MISSING = _MissingType.MISSING
 
-DataType = Union[str, bytes, bytearray, SupportsString]
+type DataType = str | bytes | bytearray | SupportsString
 
 FuncExcept = str | Callable[..., Any] | tuple[Callable[..., Any] | str, str]
 """
@@ -40,4 +40,4 @@ FuncExceptT = FuncExcept
 StrArr = SingleOrArr[SupportsString]
 StrArrOpt = SingleOrArrOpt[SupportsString]
 
-PassthroughC = Callable[[F], F]
+type PassthroughC[F: Callable[..., Any]] = Callable[[F], F]

{jetpytools-1.7.4 → jetpytools-2.0.0}/jetpytools/types/supports.py

@@ -1,20 +1,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import (
-    Any,
-    Callable,
-    Iterable,
-    Protocol,
-    SupportsFloat,
-    SupportsIndex,
-    TypeAlias,
-    TypeVar,
-    overload,
-    runtime_checkable,
-)
-
-from .builtins import T0, T1, T2, T_co, T_contra
+from typing import Any, Callable, Iterable, Protocol, SupportsFloat, SupportsIndex, TypeVar, overload, runtime_checkable
 
 __all__ = [
     "ComparatorFunc",
@@ -36,17 +23,13 @@ __all__ = [
 ]
 
 
-_KT = TypeVar("_KT")
-_VT_co = TypeVar("_VT_co", covariant=True)
-
-
 @runtime_checkable
-class SupportsAdd(Protocol[T_contra, T_co]):
+class SupportsAdd[T_contra, T_co](Protocol):
     def __add__(self, x: T_contra, /) -> T_co: ...
 
 
 @runtime_checkable
-class SupportsRAdd(Protocol[T_contra, T_co]):
+class SupportsRAdd[T_contra, T_co](Protocol):
     def __radd__(self, x: T_contra, /) -> T_co: ...
 
 
@@ -68,22 +51,22 @@ class SupportsString(Protocol):
 
 
 @runtime_checkable
-class SupportsDunderLT(Protocol[T_contra]):
+class SupportsDunderLT[T_contra](Protocol):
     def __lt__(self, other: T_contra) -> bool: ...
 
 
 @runtime_checkable
-class SupportsDunderGT(Protocol[T_contra]):
+class SupportsDunderGT[T_contra](Protocol):
     def __gt__(self, other: T_contra) -> bool: ...
 
 
 @runtime_checkable
-class SupportsDunderLE(Protocol[T_contra]):
+class SupportsDunderLE[T_contra](Protocol):
     def __le__(self, other: T_contra) -> bool: ...
 
 
 @runtime_checkable
-class SupportsDunderGE(Protocol[T_contra]):
+class SupportsDunderGE[T_contra](Protocol):
     def __ge__(self, other: T_contra) -> bool: ...
 
 
@@ -93,7 +76,7 @@ class SupportsAllComparisons(
 ): ...
 
 
-SupportsRichComparison: TypeAlias = SupportsDunderLT[Any] | SupportsDunderGT[Any]
+type SupportsRichComparison = SupportsDunderLT[Any] | SupportsDunderGT[Any]
 SupportsRichComparisonT = TypeVar("SupportsRichComparisonT", bound=SupportsRichComparison)
 
 
@@ -109,7 +92,7 @@ class ComparatorFunc(Protocol):
     ) -> SupportsRichComparisonT: ...
 
     @overload
-    def __call__(self, arg1: T0, arg2: T0, /, *_args: T0, key: Callable[[T0], SupportsRichComparison]) -> T0: ...
+    def __call__[T](self, arg1: T, arg2: T, /, *_args: T, key: Callable[[T], SupportsRichComparison]) -> T: ...
 
     @overload
     def __call__(
@@ -117,27 +100,27 @@ class ComparatorFunc(Protocol):
     ) -> SupportsRichComparisonT: ...
 
     @overload
-    def __call__(self, iterable: Iterable[T0], /, *, key: Callable[[T0], SupportsRichComparison]) -> T0: ...
+    def __call__[T](self, iterable: Iterable[T], /, *, key: Callable[[T], SupportsRichComparison]) -> T: ...
 
     @overload
-    def __call__(
-        self, iterable: Iterable[SupportsRichComparisonT], /, *, key: None = ..., default: T0
-    ) -> SupportsRichComparisonT | T0: ...
+    def __call__[T, SupportsRichComparisonT: SupportsRichComparison](
+        self, iterable: Iterable[SupportsRichComparisonT], /, *, key: None = ..., default: T
+    ) -> SupportsRichComparisonT | T: ...
 
     @overload
-    def __call__(
-        self, iterable: Iterable[T1], /, *, key: Callable[[T1], SupportsRichComparison], default: T2
-    ) -> T1 | T2: ...
+    def __call__[T0, T1](
+        self, iterable: Iterable[T0], /, *, key: Callable[[T0], SupportsRichComparison], default: T1
+    ) -> T0 | T1: ...
 
 
-class SupportsIndexing(Protocol[_VT_co]):
-    def __getitem__(self, k: int) -> _VT_co: ...
+class SupportsIndexing[T](Protocol):
+    def __getitem__(self, k: int) -> T: ...
 
 
-class SupportsKeysAndGetItem(Protocol[_KT, _VT_co]):
-    def keys(self) -> Iterable[_KT]: ...
+class SupportsKeysAndGetItem[KT, VT](Protocol):
+    def keys(self) -> Iterable[KT]: ...
 
-    def __getitem__(self, k: _KT) -> _VT_co: ...
+    def __getitem__(self, k: KT) -> VT: ...
 
 
-SupportsFloatOrIndex: TypeAlias = SupportsFloat | SupportsIndex
+type SupportsFloatOrIndex = SupportsFloat | SupportsIndex