jetpytools 1.2.5__py3-none-any.whl → 1.2.7__py3-none-any.whl

jetpytools/_metadata.py

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

jetpytools/enums/base.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from enum import Enum
 from typing import Any, TypeVar
 
+from typing_extensions import Self
+
 from ..exceptions import CustomValueError, NotFoundEnumValue
 from ..types import FuncExceptT
 
@@ -16,11 +18,11 @@ class CustomEnum(Enum):
     """Base class for custom enums."""
 
     @classmethod
-    def _missing_(cls: type[SelfEnum], value: Any) -> SelfEnum | None:
+    def _missing_(cls, value: Any) -> Self | None:
         return cls.from_param(value)
 
     @classmethod
-    def from_param(cls: type[SelfEnum], value: Any, func_except: FuncExceptT | None = None) -> SelfEnum | None:
+    def from_param(cls, value: Any, func_except: FuncExceptT | None = None) -> Self | None:
         """
         Return the enum value from a parameter.
 

jetpytools/enums/other.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import TypeVar, overload
+from typing import overload
+from typing_extensions import Self
 
 __all__ = [
     'Coordinate',
@@ -23,14 +24,14 @@ class Coordinate:
     """Vertical coordinate."""
 
     @overload
-    def __init__(self: SelfCoord, other: tuple[int, int] | SelfCoord, /) -> None:
+    def __init__(self, other: tuple[int, int] | Self, /) -> None:
         ...
 
     @overload
-    def __init__(self: SelfCoord, x: int, y: int, /) -> None:
+    def __init__(self, x: int, y: int, /) -> None:
         ...
 
-    def __init__(self: SelfCoord, x_or_self: int | tuple[int, int] | SelfCoord, y: int | None = None, /) -> 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):
@@ -48,9 +49,6 @@ class Coordinate:
         self.y = y
 
 
-SelfCoord = TypeVar('SelfCoord', bound=Coordinate)
-
-
 class Position(Coordinate):
     """Positive set of an (x,y) offset relative to the top left corner of an area."""
 

jetpytools/exceptions/base.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
 import sys
+
 from copy import deepcopy
 from typing import TYPE_CHECKING, Any, TypeVar
 
-from ..types import MISSING, FuncExceptT, SupportsString
+from typing_extensions import Self
+
+from ..types import MISSING, FuncExceptT, SupportsString, MissingT
 
 __all__ = [
     'CustomError',
@@ -112,10 +115,12 @@ class CustomError(ExceptionT, metaclass=CustomErrorMeta):
         return CustomErrorMeta.setup_exception(inner_exception, exception)  # type: ignore
 
     def __call__(
-        self: SelfError, message: SupportsString | None = MISSING,
-        func: FuncExceptT | None = MISSING, reason: SupportsString | FuncExceptT | None = MISSING,  # type: ignore
+        self,
+        message: SupportsString | None | MissingT = MISSING,
+        func: FuncExceptT | None | MissingT = MISSING,
+        reason: SupportsString | FuncExceptT | None | MissingT = MISSING,
         **kwargs: Any
-    ) -> SelfError:
+    ) -> Self:
         """
         Copy an existing exception with defaults and instantiate a new one.
 
@@ -129,7 +134,7 @@ class CustomError(ExceptionT, metaclass=CustomErrorMeta):
         if message is not MISSING:
             err.message = message
 
-        if func is not MISSING:  # type: ignore[comparison-overlap]
+        if func is not MISSING:
             err.func = func
 
         if reason is not MISSING:

jetpytools/exceptions/generic.py

@@ -18,8 +18,8 @@ class MismatchError(CustomValueError):
         return str(item)
 
     @classmethod
-    def _reduce(cls, items: Iterable[Any]) -> tuple[str]:
-        return tuple[str](dict.fromkeys(map(cls._item_to_name, items)).keys())  # type: ignore
+    def _reduce(cls, items: Iterable[Any]) -> tuple[str, ...]:
+        return tuple(dict.fromkeys(map(cls._item_to_name, items)).keys())
 
     def __init__(
         self, func: FuncExceptT, items: Iterable[Any], message: SupportsString = 'All items must be equal!',
@@ -28,7 +28,7 @@ class MismatchError(CustomValueError):
         super().__init__(message, func, reason, **kwargs, reduced_items=iter(self._reduce(items)))
 
     @classmethod
-    def check(cls, func: FuncExceptT, *items: Any, **kwargs: Any) -> None:
+    def check(cls, func: FuncExceptT, /, *items: Any, **kwargs: Any) -> None:
         if len(cls._reduce(items)) != 1:
             raise cls(func, items, **kwargs)
 
@@ -40,6 +40,6 @@ class MismatchRefError(MismatchError):
         super().__init__(func, [base, ref], message, **kwargs)
 
     @classmethod
-    def check(cls, func: FuncExceptT, *items: Any, **kwargs: Any) -> None:
+    def check(cls, func: FuncExceptT, /, *items: Any, **kwargs: Any) -> None:
         if len(cls._reduce(items)) != 1:
             raise cls(func, *items, **kwargs)

jetpytools/functions/normalize.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from fractions import Fraction
-from typing import Any, Iterable, Iterator, Sequence, overload
+from typing import Any, Callable, Iterable, Iterator, Sequence, overload
 
-from ..types import F, SupportsString, T, SoftRange, SoftRangeN, SoftRangesN, StrictRange
+from ..types import SoftRange, SoftRangeN, SoftRangesN, StrictRange, SupportsString, T, is_soft_range_n
 
 __all__ = [
     'normalize_seq',
@@ -19,12 +19,12 @@ __all__ = [
 
 
 @overload
-def normalize_seq(val: Sequence[T], length: int) -> list[T]:
+def normalize_seq(val: T | Sequence[T], length: int) -> list[T]:
     ...
 
 
 @overload
-def normalize_seq(val: T | Sequence[T], length: int) -> list[T]:
+def normalize_seq(val: Any, length: int) -> list[Any]:
     ...
 
 
@@ -47,45 +47,43 @@ def normalize_seq(val: T | Sequence[T], length: int) -> list[T]:
     return val[:length]
 
 
-_iterables_t = (list, tuple, range, zip, set, map, enumerate)
-
-
 @overload
-def to_arr(val: list[T], *, sub: bool = False) -> list[T]:
+def to_arr(val: T | Iterable[T]) -> list[T]:
     ...
 
 
 @overload
-def to_arr(val: T | Sequence[T], *, sub: bool = False) -> list[T]:
+def to_arr(val: Any) -> list[Any]:
     ...
 
 
-def to_arr(val: T | Sequence[T], *, sub: bool = False) -> list[T]:
-    """Normalize any value into an iterable."""
-
+def to_arr(val: Any, *, sub: Any = []) -> list[Any]:
+    """
+    Normalize any value to a list.
+    Bytes and str are not considered iterable and will not be flattened.
+    """
     if sub:
-        return list(val) if any(isinstance(val, x) for x in _iterables_t) else [val]  # type: ignore
+        import warnings
+        warnings.warn("sub is deprecated.", DeprecationWarning)
 
-    return list(val) if type(val) in _iterables_t else [val]  # type: ignore
+    return list(val) if (isinstance(val, Iterable) and not isinstance(val, (str, bytes))) else [val]
 
 
 @overload
-def flatten(items: T | Iterable[T | Iterable[T | Iterable[T]]]) -> Iterable[T]:
+def flatten(items: Iterable[Iterable[T]]) -> Iterator[T]:
     ...
 
 
 @overload
-def flatten(items: T | Iterable[T | Iterable[T]]) -> Iterable[T]:  # type: ignore
+def flatten(items: Iterable[Any]) -> Iterator[Any]:
     ...
 
 
-@overload
-def flatten(items: T | Iterable[T]) -> Iterable[T]:  # type: ignore
-    ...
-
-
-def flatten(items: Any) -> Any:
-    """Flatten an array of values."""
+def flatten(items: Any) -> Iterator[Any]:
+    """
+    Flatten an array of values.
+    Bytes and str are not considered iterable and will not be flattened..
+    """
 
     for val in items:
         if isinstance(val, Iterable) and not isinstance(val, (str, bytes)):
@@ -170,13 +168,13 @@ def normalize_ranges(ranges: SoftRangeN | SoftRangesN, end: int) -> list[StrictR
         [(24, 150)]
 
 
-    :param clip:        Input clip.
     :param franges:     Frame range or list of frame ranges.
+    :param end:         End number.
 
     :return:            List of positive frame ranges.
     """
 
-    ranges = ranges if isinstance(ranges, list) else [ranges]  # type:ignore
+    ranges = [ranges] if is_soft_range_n(ranges) else ranges
 
     out = []
 
@@ -215,7 +213,7 @@ def invert_ranges(ranges: SoftRangeN | SoftRangesN, enda: int, endb: int | None)
     return normalize_list_to_ranges({*range(enda)} - b_frames)
 
 
-def norm_func_name(func_name: SupportsString | F) -> str:
+def norm_func_name(func_name: SupportsString | Callable[..., Any]) -> str:
     """Normalize a class, function, or other object to obtain its name"""
 
     if isinstance(func_name, str):

jetpytools/types/__init__.py

@@ -1,4 +1,5 @@
 from .builtins import *  # noqa: F401, F403
+from .check import *  # noqa: F401, F403
 from .file import *  # noqa: F401, F403
 from .funcs import *  # noqa: F401, F403
 from .generic import *  # noqa: F401, F403

jetpytools/types/builtins.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-from typing import (
-    TYPE_CHECKING, Any, Callable, ParamSpec, Sequence, SupportsFloat, SupportsIndex, TypeAlias, TypeVar, Union
-)
+from typing import Any, Callable, ParamSpec, Sequence, SupportsFloat, SupportsIndex, TypeAlias, TypeVar, Union
 
 __all__ = [
     'T', 'T0', 'T1', 'T2', 'T_contra',
@@ -10,14 +8,12 @@ __all__ = [
     'F', 'F0', 'F1', 'F2',
 
     'P', 'P0', 'P1', 'P2',
-    'R', 'R0', 'R1', 'R2', 'R_contra',
+    'R', 'R0', 'R1', 'R2', 'R_co', 'R0_co', 'R_contra',
 
     'Nb',
 
     'StrictRange', 'SoftRange', 'SoftRangeN', 'SoftRangesN',
 
-    'Self',
-
     'SingleOrArr', 'SingleOrArrOpt',
     'SingleOrSeq', 'SingleOrSeqOpt',
 
@@ -49,20 +45,18 @@ R0 = TypeVar('R0')
 R1 = TypeVar('R1')
 R2 = TypeVar('R2')
 
+R_co = TypeVar('R_co', covariant=True)
+R0_co = TypeVar('R0_co', covariant=True)
+
 T_contra = TypeVar('T_contra', contravariant=True)
 R_contra = TypeVar('R_contra', contravariant=True)
 
-Self = TypeVar('Self')
-
 StrictRange: TypeAlias = tuple[int, int]
 SoftRange: TypeAlias = int | StrictRange | Sequence[int]
 
 SoftRangeN: TypeAlias = int | tuple[int | None, int | None] | None
 
-if TYPE_CHECKING:
-    SoftRangesN: TypeAlias = Sequence[SoftRangeN]
-else:
-    SoftRangesN: TypeAlias = list[SoftRangeN]
+SoftRangesN: TypeAlias = Sequence[SoftRangeN]
 
 SingleOrArr = Union[T, list[T]]
 SingleOrSeq = Union[T, Sequence[T]]

jetpytools/types/check.py

@@ -0,0 +1,34 @@
+from typing import Any, Sequence
+
+from typing_extensions import TypeIs
+
+from .builtins import SoftRange, SoftRangeN, SoftRangesN, StrictRange
+
+__all__ = [
+    "is_strict_range", "is_soft_range", "is_soft_range_n", "is_soft_ranges_n"
+]
+
+
+def is_strict_range(val: Any) -> TypeIs[StrictRange]:
+    return isinstance(val, tuple) and len(val) == 2 and all(isinstance(x, int) for x in val)
+
+
+def is_soft_range(val: Any) -> TypeIs[SoftRange]:
+    return isinstance(val, int) or is_strict_range(val) or (
+        isinstance(val, Sequence) and all(isinstance(x, int) for x in val)
+    )
+
+
+def is_soft_range_n(val: Any) -> TypeIs[SoftRangeN]:
+    return (
+        isinstance(val, int)
+        or (isinstance(val, tuple) and len(val) == 2 and all(isinstance(x, int) or x is None for x in val))
+        or val is None
+    )
+
+
+def is_soft_ranges_n(val: Any) -> TypeIs[SoftRangesN]:
+    return (
+        isinstance(val, Sequence)
+        and all(is_soft_range_n(x) for x in val)
+    )

jetpytools/types/file.py

@@ -121,7 +121,7 @@ class SPath(Path):
 
         from ..functions import to_arr
 
-        return self.with_stem(sep.join([self.stem, *to_arr(suffixes)]))  # type:ignore[list-item]
+        return self.with_stem(sep.join([self.stem, *to_arr(suffixes)]))
 
     def is_empty_dir(self) -> bool:
         """Check if the directory is empty."""
@@ -176,10 +176,12 @@ class SPath(Path):
 
         matching_files = self.get_folder().glob(pattern)
 
-        if not matching_files:
+        try:
+            next(matching_files)
+        except StopIteration:
             return None
 
-        return max(matching_files, key=lambda p: p.stat().st_mtime, default=None)  # type:ignore
+        return max(matching_files, key=lambda p: p.stat().st_mtime)
 
     def get_size(self) -> int:
         """Get the size of the file or directory in bytes."""
@@ -194,4 +196,4 @@ class SPath(Path):
         return sum(f.stat().st_size for f in self.rglob('*') if f.is_file())
 
 
-SPathLike = Union[str, Path, SPath]
+SPathLike = Union[str, PathLike[str], Path, SPath]

jetpytools/types/funcs.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
+
 from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, SupportsIndex, TypeAlias, overload
 
-from typing import TYPE_CHECKING, Any, Callable, Iterable, List, SupportsIndex, TypeAlias, TypeVar, overload
+from typing_extensions import Self, TypeIs
 
-from .builtins import T, P
+from .builtins import P, T
 from .supports import SupportsString
 
 __all__ = [
@@ -13,7 +15,7 @@ __all__ = [
 ]
 
 
-class StrList(List[SupportsString]):
+class StrList(list[SupportsString]):
     """Custom class for representing a recursively "stringable" list."""
 
     if TYPE_CHECKING:
@@ -41,7 +43,7 @@ class StrList(List[SupportsString]):
         return ' '.join(
             filter(
                 None,
-                (str(x).strip() for x in flatten(self) if x is not None)  # type: ignore[var-annotated,arg-type]
+                (str(x).strip() for x in flatten(self) if x is not None)
             )
         )
 
@@ -74,20 +76,22 @@ class SentinelDispatcher:
 
         return _wrap
 
-    def filter(self: SelfSentinel, items: Iterable[T | SelfSentinel]) -> Iterable[T]:
+    def filter(self, items: Iterable[T | Self]) -> Iterator[T]:
         for item in items:
-            if item is self:
+            if isinstance(item, SentinelDispatcher):
                 continue
-
-            yield item  # type: ignore
+            yield item
 
     @classmethod
-    def filter_multi(cls, items: Iterable[T | SelfSentinel], *sentinels: SelfSentinel) -> Iterable[T]:
+    def filter_multi(cls, items: Iterable[T | Self], *sentinels: Self) -> Iterator[T]:
+        def _in_sentinels(it: Any) -> TypeIs[SentinelDispatcher]:
+            return it in sentinels
+
         for item in items:
-            if item in sentinels:
+            if _in_sentinels(item):
                 continue
 
-            yield item  # type: ignore
+            yield item
 
     def __getattr__(self, name: str) -> SentinelDispatcher:
         if name not in _sentinels:
@@ -105,5 +109,3 @@ Sentinel = SentinelDispatcher()
 SentinelT: TypeAlias = SentinelDispatcher
 
 _sentinels = dict[str, SentinelDispatcher]()
-
-SelfSentinel = TypeVar('SelfSentinel', bound=SentinelDispatcher)

jetpytools/types/utils.py

@@ -8,8 +8,9 @@ from typing import (
     TYPE_CHECKING, Any, Callable, Concatenate, Generator, Generic, Iterable, Iterator, Mapping,
     NoReturn, Protocol, Sequence, TypeVar, cast, overload
 )
+from typing_extensions import Self
 
-from .builtins import F0, F1, P0, P1, R0, R1, T0, T1, T2, KwargsT, P, R, T
+from .builtins import F0, F1, P0, P1, R0, R1, T0, T1, T2, KwargsT, P, R, R_co, R0_co, T
 
 __all__ = [
     'copy_signature',
@@ -97,10 +98,15 @@ class injected_self_func(Generic[T, P, R], Protocol):  # type: ignore[misc]
         ...
 
 
-self_objects_cache = dict[type[T], T]()  # type: ignore
+self_objects_cache = dict[type, Any]()
 
 
 class inject_self_base(Generic[T, P, R]):
+    cache: bool | None
+    signature: Signature | None
+    init_kwargs: list[str] | None
+    first_key: str | None
+
     def __init__(self, function: Callable[Concatenate[T, P], R], /, *, cache: bool = False) -> None:
         """
         Wrap ``function`` to always have a self provided to it.
@@ -126,20 +132,20 @@ class inject_self_base(Generic[T, P, R]):
     def __get__(
         self, class_obj: type[T] | T | None, class_type: type[T] | type[type[T]]  # type: ignore
     ) -> injected_self_func[T, P, R]:
-        if not self.signature or not self.first_key:  # type: ignore
-            self.signature = Signature.from_callable(self.function, eval_str=True)  # type: ignore
-            self.first_key = next(iter(list(self.signature.parameters.keys())), None)  # type: ignore
+        if not self.signature or not self.first_key:
+            self.signature = Signature.from_callable(self.function, eval_str=True)
+            self.first_key = next(iter(list(self.signature.parameters.keys())), None)
 
             if isinstance(self, inject_self.init_kwargs):
                 from ..exceptions import CustomValueError
 
-                if 4 not in {x.kind for x in self.signature.parameters.values()}:  # type: ignore
+                if 4 not in {x.kind for x in self.signature.parameters.values()}:
                     raise CustomValueError(
                         'This function hasn\'t got any kwargs!', 'inject_self.init_kwargs', self.function
                     )
 
-                self.init_kwargs = list[str](  # type: ignore
-                    k for k, x in self.signature.parameters.items() if x.kind != 4  # type: ignore
+                self.init_kwargs = list[str](
+                    k for k, x in self.signature.parameters.items() if x.kind != 4
                 )
 
         @wraps(self.function)
@@ -151,15 +157,15 @@ class inject_self_base(Generic[T, P, R]):
             if (
                 first_arg and (
                     (is_obj := isinstance(first_arg, class_type))
-                    or isinstance(first_arg, type(class_type))  # noqa
-                    or first_arg is class_type  # noqa
+                    or isinstance(first_arg, type(class_type))
+                    or first_arg is class_type
                 )
             ):
                 obj = first_arg if is_obj else first_arg()
                 if args:
                     args = args[1:]
                 elif kwargs and self.first_key:
-                    kwargs.pop(self.first_key)  # type: ignore
+                    kwargs.pop(self.first_key)
             elif class_obj is None:
                 if self.cache:
                     if class_type not in self_objects_cache:
@@ -167,7 +173,7 @@ class inject_self_base(Generic[T, P, R]):
                     else:
                         obj = self_objects_cache[class_type]
                 elif self.init_kwargs:
-                    obj = class_type(  # type: ignore
+                    obj = class_type(
                         *self.args, **(self.kwargs | {k: v for k, v in kwargs.items() if k not in self.init_kwargs})
                     )
                     if self.clean_kwargs:
@@ -473,7 +479,7 @@ class classproperty(Generic[P, R, T, T0, P0]):
 
         return self.fget.__get__(__obj, __type)()  # type: ignore
 
-    def __set__(self, __obj: Any, __value: T1) -> None:
+    def __set__(self, __obj: Any, __value: Any) -> None:
         from ..exceptions import CustomError
 
         if not self.fset:
@@ -503,7 +509,7 @@ class classproperty(Generic[P, R, T, T0, P0]):
         return self.fget.__name__
 
 
-class cachedproperty(property, Generic[P, R, T, T0, P0]):
+class cachedproperty(property, Generic[P, R_co, T, T0, P0]):
     """
     Wrapper for a one-time get property, that will be cached.
 
@@ -532,21 +538,29 @@ class cachedproperty(property, Generic[P, R, T, T0, P0]):
 
     if TYPE_CHECKING:
         def __init__(
-            self, fget: Callable[P, R], fset: Callable[[T, T0], None] | None = None,
+            self, fget: Callable[P, R_co], fset: Callable[[T, T0], None] | None = None,
             fdel: Callable[P0, None] | None = None, doc: str | None = None,
         ) -> None:
             ...
 
-        def getter(self, __fget: Callable[P1, R1]) -> cachedproperty[P1, R1, T, T0, P0]:
+        def getter(self, __fget: Callable[P1, R0_co]) -> cachedproperty[P1, R0_co, T, T0, P0]:
             ...
 
-        def setter(self, __fset: Callable[[T1, T2], None]) -> cachedproperty[P, R, T1, T2, P0]:
+        def setter(self, __fset: Callable[[T1, T2], None]) -> cachedproperty[P, R_co, T1, T2, P0]:
             ...
 
-        def deleter(self, __fdel: Callable[P1, None]) -> cachedproperty[P, R, T, T0, P1]:
+        def deleter(self, __fdel: Callable[P1, None]) -> cachedproperty[P, R_co, T, T0, P1]:
             ...
 
-    def __get__(self, __obj: Any, __type: type | None = None) -> R:
+    @overload
+    def __get__(self, __obj: None, __type: type | None = None) -> Self:
+        ...
+
+    @overload
+    def __get__(self, __obj: object, __type: type | None = None) -> R_co:
+        ...
+
+    def __get__(self, __obj: Any, __type: type | None = None) -> Any:
         if isinstance(self.fget, classproperty):
             function = partial(self.fget.__get__, __obj, __type)  # type: ignore
             __obj = __type
@@ -557,14 +571,19 @@ class cachedproperty(property, Generic[P, R, T, T0, P0]):
             cache = getattr(__obj, cachedproperty.cache_key)
             name = self.fget.__name__
         else:
-            function = self.fget.__get__(__obj, __type)  # type: ignore
+            assert self.fget
+            function = self.fget.__get__(__obj, __type)
             cache = __obj.__dict__.get(cachedproperty.cache_key)
             name = function.__name__
 
         if name not in cache:
             cache[name] = function()
 
-        return cache[name]  # type: ignore
+        return cache[name]
+
+    if TYPE_CHECKING:
+        def __set__(self, obj: Any, value: R_co, /) -> None:  # type: ignore[misc]
+            ...
 
 
 class KwargsNotNone(KwargsT):

{jetpytools-1.2.5.dist-info → jetpytools-1.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jetpytools
-Version: 1.2.5
+Version: 1.2.7
 Summary: Collection of stuff that's useful in general python programming
 Author: Jaded Encoding Thaumaturgy
 Author-email: jaded.encoding.thaumaturgy@gmail.com

{jetpytools-1.2.5.dist-info → jetpytools-1.2.7.dist-info}/RECORD

@@ -1,33 +1,34 @@
 jetpytools/__init__.py,sha256=FSVZdj69oy4mBXd6OXiRHrUhaSc4Exo1pQHBlXycV98,214
-jetpytools/_metadata.py,sha256=EF2prSeiktlzSwZCzFXhHgnZPWOi41ij--oy_a9-7nk,414
+jetpytools/_metadata.py,sha256=y_dN8-DDeLCacriLV91BnQjH9vA5oZyzrnDV73-0YaU,414
 jetpytools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jetpytools/enums/__init__.py,sha256=5n6Cu8Yb9N6hIa_YTsyy_s0cCgCnh0vDb-NyXK2RwV0,81
-jetpytools/enums/base.py,sha256=q0HUCl8NN66b4VXYNjP_AMrYqjlcLVlRs0GQHXt17zU,2083
-jetpytools/enums/other.py,sha256=vQIouUJWRa039t8E1RQYc61MYS3uhe-o-5SBRlXs9x4,1416
+jetpytools/enums/base.py,sha256=BbePlmj__Vqc7gzhrbZBFnrQcC9WNBjtiBYoXpgVNOA,2079
+jetpytools/enums/other.py,sha256=DerFtmdjNK41ZxSYt601vHV5yzvZHPfTKNDlj-FjHm8,1346
 jetpytools/exceptions/__init__.py,sha256=g8GT0XqcNuHFHgQGSRj6a_X1kBiBQGP05soYNbEIN_Q,205
-jetpytools/exceptions/base.py,sha256=S3sqhT6yQSbPshmcy3XyVgfjDXic_xbpb8799TfD-cI,6342
+jetpytools/exceptions/base.py,sha256=ESwC7H8iCQW9DGMGmaoFwIiid98tE1e6sATjOH_7Duc,6370
 jetpytools/exceptions/enum.py,sha256=9YoWwEfyd9k7NwanAqtXbhJaJQAnjRKqsAO73cDvcpA,223
 jetpytools/exceptions/file.py,sha256=QwhUFAoG3NsFFYuPe5O_I6K969CzlrTCv3RTrfzx8B0,1107
-jetpytools/exceptions/generic.py,sha256=jWCJ6ato12rJBXLmZx4ReMVWG0iMuStR5Tz9CJlVevI,1492
+jetpytools/exceptions/generic.py,sha256=kMj5lR3ifHk3uNhpxN6Lu4Am0vi7E6TfQezkZulqhaQ,1482
 jetpytools/exceptions/module.py,sha256=drkcpa8hcE7Ee20N15j3qsX_grl8a3Jjv10XJ3xtDmE,1207
 jetpytools/functions/__init__.py,sha256=CeDfQrPCYqjiXyCoZ6jcbfM2d7KmRM11lBSxUK2wl4g,127
 jetpytools/functions/funcs.py,sha256=EMoJ_h2tl8Cgr1PXAsmRvgaOY5YL7AiEnGGo3-H76tk,3797
-jetpytools/functions/normalize.py,sha256=dyEuLVOZ2WSR_qDgyVGILn-0MURizCn5Nk1KuppgbG8,6381
+jetpytools/functions/normalize.py,sha256=2BACok7TAN5ldANyYrbGhUpOkj84siApAYy6ndlhUfI,6316
 jetpytools/functions/other.py,sha256=TRz91spvdYJUh9vKe3Kuw6xZfSEJvrQs1mZVg7SyYmY,413
-jetpytools/types/__init__.py,sha256=0veUJC8ioXsx1g3Nx-YQSKTnkenfyaD5y91qBDkyM8Q,253
-jetpytools/types/builtins.py,sha256=moET0CgjQnUkis2V1RViL53OMCVAIV4zBDcClsaKn5g,1807
-jetpytools/types/file.py,sha256=H9EJlb6K0cC634GqoaPtUJ2WoAhtP4WwS37egS0S3Ss,6200
-jetpytools/types/funcs.py,sha256=epmw4EVmZph2hOso9WxE9SL5RWm9oYtHICkTGSwDyv0,3129
+jetpytools/types/__init__.py,sha256=yDT-PYTTzH6DyHsQcKvOy1jrCPmUQRKrjCM3apd0kNw,294
+jetpytools/types/builtins.py,sha256=Em8vybY4wCxtK-6KkeKLVP55X1N9Z8OXji3_7W3wEH8,1771
+jetpytools/types/check.py,sha256=Ivf_JkVLG9OgiKXYjq-8azoROLjJvhNNqPq_KDIiOkI,971
+jetpytools/types/file.py,sha256=j46SCbdhus2wtxddAGSCn6V4nJdWWwpnAfW1K3P3ewg,6205
+jetpytools/types/funcs.py,sha256=9qONnDWdpqvRj7vL3W9BLwWeGyQipXQgxOaPjqpQ1M4,3119
 jetpytools/types/generic.py,sha256=sAyBwGVG5FZ-6HVpfRuczov_6zQ_Uyoi0QWnR2iMm9Q,1128
 jetpytools/types/supports.py,sha256=--VZ-iCUiv-a6K8n-H8-6hSxHjrvdYg9mCLhr_lRplo,3051
-jetpytools/types/utils.py,sha256=Bi-AKe40IVxK-eSMZC1y_32w3XfeeGj-o4ZmwX3WXEI,22227
+jetpytools/types/utils.py,sha256=3MaUnjezgTy4VjCstD4jNRMOoZX2Q_T1G6L55su5VhU,22570
 jetpytools/utils/__init__.py,sha256=v5Bkl43-OBWlXx9OWpZoGH-QMaYNsPIi4vfuhC13ZLI,163
 jetpytools/utils/file.py,sha256=9GhMGJ5D7CpvUFnvnwPFMloYTeIX-AJ7aKYKdoJQ374,10455
 jetpytools/utils/funcs.py,sha256=ZuLz63kveBY1CLlBexEqmrQiGC67dY4gaXdNU3CeBMw,898
 jetpytools/utils/math.py,sha256=lNTriLtTXgqN82DVSXJ5KUbhsWgxXoJ5eNGIZ0-_r_c,3335
 jetpytools/utils/ranges.py,sha256=dL3WG235Pz9sk5su8A0VdwVf_oSt6obR7R_JNwLyCjQ,2572
-jetpytools-1.2.5.dist-info/LICENSE,sha256=l0PN-qDtXcgOB5aXP_nSUsvCK5V3o9pQCGsTzyZhKL0,1071
-jetpytools-1.2.5.dist-info/METADATA,sha256=YfuNYSyncP1LrQ38qZNDP_d9qy9gyyqL2IzctrhxF5M,1399
-jetpytools-1.2.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-jetpytools-1.2.5.dist-info/top_level.txt,sha256=Iy4HjIta33ADJxN9Nyt5t5jRIfotEkZkQcOSw4eG8Cs,11
-jetpytools-1.2.5.dist-info/RECORD,,
+jetpytools-1.2.7.dist-info/LICENSE,sha256=l0PN-qDtXcgOB5aXP_nSUsvCK5V3o9pQCGsTzyZhKL0,1071
+jetpytools-1.2.7.dist-info/METADATA,sha256=FU7Mfh5s7nnARJMWSshl18-SoTcYYruA-fVy27y1p94,1399
+jetpytools-1.2.7.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+jetpytools-1.2.7.dist-info/top_level.txt,sha256=Iy4HjIta33ADJxN9Nyt5t5jRIfotEkZkQcOSw4eG8Cs,11
+jetpytools-1.2.7.dist-info/RECORD,,

{jetpytools-1.2.5.dist-info → jetpytools-1.2.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any