jetpytools 1.2.4__tar.gz → 1.2.6__tar.gz

{jetpytools-1.2.4 → jetpytools-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jetpytools
-Version: 1.2.4
+Version: 1.2.6
 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.4 → jetpytools-1.2.6}/jetpytools/_metadata.py

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

{jetpytools-1.2.4 → jetpytools-1.2.6}/jetpytools/enums/base.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any, TypeVar
+from typing import Any
+
+from typing_extensions import Self
 
 from ..exceptions import CustomValueError, NotFoundEnumValue
 from ..types import FuncExceptT
 
 __all__ = [
-    'SelfEnum',
     'CustomEnum', 'CustomIntEnum', 'CustomStrEnum'
 ]
 
@@ -16,11 +17,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.
 
@@ -73,6 +74,3 @@ class CustomStrEnum(str, CustomEnum):
     """Base class for custom str enums."""
 
     value: str
-
-
-SelfEnum = TypeVar('SelfEnum', bound=CustomEnum)

{jetpytools-1.2.4 → jetpytools-1.2.6}/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-1.2.4 → jetpytools-1.2.6}/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-1.2.4 → jetpytools-1.2.6}/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!',

{jetpytools-1.2.4 → jetpytools-1.2.6}/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-1.2.4 → jetpytools-1.2.6}/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-1.2.4 → jetpytools-1.2.6}/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',
@@ -16,8 +14,6 @@ __all__ = [
 
     'StrictRange', 'SoftRange', 'SoftRangeN', 'SoftRangesN',
 
-    'Self',
-
     'SingleOrArr', 'SingleOrArrOpt',
     'SingleOrSeq', 'SingleOrSeqOpt',
 
@@ -52,17 +48,12 @@ R2 = TypeVar('R2')
 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-1.2.6/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-1.2.4 → jetpytools-1.2.6}/jetpytools/types/file.py

@@ -2,8 +2,10 @@ from __future__ import annotations
 
 import fnmatch
 import shutil
+
 from os import PathLike, listdir, path, walk
 from pathlib import Path
+from sys import version_info
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, TypeAlias, Union
 
 __all__ = [
@@ -58,6 +60,8 @@ 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) -> SPath:
@@ -117,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."""
@@ -172,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."""
@@ -190,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-1.2.4 → jetpytools-1.2.6}/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-1.2.4 → jetpytools-1.2.6}/jetpytools/types/utils.py

@@ -97,10 +97,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 +131,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 +156,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 +172,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 +478,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:

{jetpytools-1.2.4 → jetpytools-1.2.6}/jetpytools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jetpytools
-Version: 1.2.4
+Version: 1.2.6
 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.4 → jetpytools-1.2.6}/jetpytools.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ jetpytools/functions/normalize.py
 jetpytools/functions/other.py
 jetpytools/types/__init__.py
 jetpytools/types/builtins.py
+jetpytools/types/check.py
 jetpytools/types/file.py
 jetpytools/types/funcs.py
 jetpytools/types/generic.py