jetpytools 1.7.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

jetpytools/_metadata.py

@@ -1,6 +1,6 @@
 """Collection of stuff that's useful in general python programming"""
 
-__version__ = "1.7.3"
+__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/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/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/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/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/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/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/types/builtins.py

@@ -1,30 +1,10 @@
 from __future__ import annotations
 
-from typing import Any, Callable, ParamSpec, Sequence, SupportsFloat, SupportsIndex, TypeAlias, TypeVar, Union
+from typing import Any, Sequence, SupportsFloat, SupportsIndex
 
 __all__ = [
-    "F0",
-    "F1",
-    "F2",
-    "P0",
-    "P1",
-    "P2",
-    "R0",
-    "R1",
-    "R2",
-    "T0",
-    "T1",
-    "T2",
     "ByteData",
-    "F",
     "KwargsT",
-    "Nb",
-    "P",
-    "R",
-    "R0_co",
-    "R1_co",
-    "R_co",
-    "R_contra",
     "SimpleByteData",
     "SimpleByteDataArray",
     "SingleOrArr",
@@ -35,61 +15,23 @@ __all__ = [
     "SoftRangeN",
     "SoftRangesN",
     "StrictRange",
-    "T",
-    "T0_co",
-    "T1_co",
-    "T_co",
-    "T_contra",
 ]
 
-Nb = TypeVar("Nb", float, int)
+type StrictRange = tuple[int, int]
+type SoftRange = int | StrictRange | Sequence[int]
 
-T = TypeVar("T")
-T0 = TypeVar("T0")
-T1 = TypeVar("T1")
-T2 = TypeVar("T2")
+type SoftRangeN = int | tuple[int | None, int | None] | None
 
-F = TypeVar("F", bound=Callable[..., Any])
-F0 = TypeVar("F0", bound=Callable[..., Any])
-F1 = TypeVar("F1", bound=Callable[..., Any])
-F2 = TypeVar("F2", bound=Callable[..., Any])
+type SoftRangesN = Sequence[SoftRangeN]
 
-P = ParamSpec("P")
-P0 = ParamSpec("P0")
-P1 = ParamSpec("P1")
-P2 = ParamSpec("P2")
+type SingleOrArr[T] = T | list[T]
+type SingleOrSeq[T] = T | Sequence[T]
+type SingleOrArrOpt[T] = SingleOrArr[T] | None
+type SingleOrSeqOpt[T] = SingleOrSeq[T] | None
 
-R = TypeVar("R")
-R0 = TypeVar("R0")
-R1 = TypeVar("R1")
-R2 = TypeVar("R2")
+type SimpleByteData = str | bytes | bytearray
+type SimpleByteDataArray = SimpleByteData | Sequence[SimpleByteData]
 
-T_co = TypeVar("T_co", covariant=True)
-T0_co = TypeVar("T0_co", covariant=True)
-T1_co = TypeVar("T1_co", covariant=True)
-
-R_co = TypeVar("R_co", covariant=True)
-R0_co = TypeVar("R0_co", covariant=True)
-R1_co = TypeVar("R1_co", covariant=True)
-
-T_contra = TypeVar("T_contra", contravariant=True)
-R_contra = TypeVar("R_contra", contravariant=True)
-
-StrictRange: TypeAlias = tuple[int, int]
-SoftRange: TypeAlias = int | StrictRange | Sequence[int]
-
-SoftRangeN: TypeAlias = int | tuple[int | None, int | None] | None
-
-SoftRangesN: TypeAlias = Sequence[SoftRangeN]
-
-SingleOrArr = Union[T, list[T]]
-SingleOrSeq = Union[T, Sequence[T]]
-SingleOrArrOpt = Union[SingleOrArr[T], None]
-SingleOrSeqOpt = Union[SingleOrSeq[T], None]
-
-SimpleByteData: TypeAlias = str | bytes | bytearray
-SimpleByteDataArray = Union[SimpleByteData, Sequence[SimpleByteData]]
-
-ByteData: TypeAlias = SupportsFloat | SupportsIndex | SimpleByteData | memoryview
+type ByteData = SupportsFloat | SupportsIndex | SimpleByteData | memoryview
 
 KwargsT = dict[str, Any]

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/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/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]