jetpytools 1.2.8__py3-none-any.whl → 1.4.0__py3-none-any.whl

jetpytools/_metadata.py

@@ -1,6 +1,6 @@
 """Collection of stuff that's useful in general python programming"""
 
-__version__ = '1.2.8'
+__version__ = '1.4.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,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any, TypeVar
+from typing import Any
 
 from typing_extensions import Self
 
@@ -9,7 +9,6 @@ from ..exceptions import CustomValueError, NotFoundEnumValue
 from ..types import FuncExceptT
 
 __all__ = [
-    'SelfEnum',
     'CustomEnum', 'CustomIntEnum', 'CustomStrEnum'
 ]
 
@@ -75,6 +74,3 @@ class CustomStrEnum(str, CustomEnum):
     """Base class for custom str enums."""
 
     value: str
-
-
-SelfEnum = TypeVar('SelfEnum', bound=CustomEnum)

jetpytools/exceptions/base.py

@@ -72,10 +72,6 @@ class CustomErrorMeta(type):
 
         return exception
 
-    if TYPE_CHECKING:
-        def __getitem__(self, exception: type[Exception]) -> CustomError:
-            ...
-
 
 SelfCErrorMeta = TypeVar('SelfCErrorMeta', bound=CustomErrorMeta)
 
@@ -102,17 +98,11 @@ class CustomError(ExceptionT, metaclass=CustomErrorMeta):
         super().__init__(message)
 
     def __class_getitem__(cls, exception: str | type[ExceptionT] | ExceptionT) -> CustomError:
-        if isinstance(exception, str):
-            class inner_exception(cls):  # type: ignore
-                ...
-        else:
-            if not issubclass(exception, type):  # type: ignore
-                exception = exception.__class__  # type: ignore
+        from warnings import warn
 
-            class inner_exception(cls, exception):  # type: ignore
-                ...
+        warn("Custom error is not subscriptable anymore. Don't use it", DeprecationWarning)
 
-        return CustomErrorMeta.setup_exception(inner_exception, exception)  # type: ignore
+        return cls()
 
     def __call__(
         self,

jetpytools/types/builtins.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 from typing import Any, Callable, ParamSpec, Sequence, SupportsFloat, SupportsIndex, TypeAlias, TypeVar, Union
 
 __all__ = [
-    'T', 'T0', 'T1', 'T2', 'T_contra',
+    'T', 'T0', 'T1', 'T2', 'T_co', 'T0_co', 'T1_co', 'T_contra',
 
     'F', 'F0', 'F1', 'F2',
 
     'P', 'P0', 'P1', 'P2',
-    'R', 'R0', 'R1', 'R2', 'R_co', 'R0_co', 'R_contra',
+    'R', 'R0', 'R1', 'R2', 'R_co', 'R0_co', 'R1_co', 'R_contra',
 
     'Nb',
 
@@ -20,13 +20,9 @@ __all__ = [
     'SimpleByteData', 'SimpleByteDataArray',
     'ByteData',
 
-    'KwargsT',
-
-    'Self'
+    'KwargsT'
 ]
 
-Self = TypeVar('Self')
-
 Nb = TypeVar('Nb', float, int)
 
 T = TypeVar('T')
@@ -49,8 +45,13 @@ R0 = TypeVar('R0')
 R1 = TypeVar('R1')
 R2 = TypeVar('R2')
 
+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)

jetpytools/types/utils.py

@@ -3,14 +3,14 @@ from __future__ import annotations
 from functools import partial, wraps
 from inspect import Signature
 from inspect import _empty as empty_param
-from inspect import isclass
 from typing import (
-    TYPE_CHECKING, Any, Callable, Concatenate, Generator, Generic, Iterable, Iterator, Mapping,
-    NoReturn, Protocol, Sequence, TypeVar, cast, overload
+    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, R_co, R0_co, T
+from .builtins import F0, F1, P0, P1, R0, R1, T0, T1, T2, KwargsT, P, R, R0_co, R1_co, R_co, T, T0_co, T1_co, T_co
 
 __all__ = [
     'copy_signature',
@@ -67,47 +67,33 @@ class copy_signature(Generic[F0]):
         return cast(F0, wrapped)
 
 
-class injected_self_func(Generic[T, P, R], Protocol):  # type: ignore[misc]
+class injected_self_func(Protocol[T_co, P, R_co]):
     @overload
     @staticmethod
-    def __call__(*args: P.args, **kwargs: P.kwargs) -> R:
+    def __call__(*args: P.args, **kwargs: P.kwargs) -> R_co:
         ...
 
     @overload
     @staticmethod
-    def __call__(self: T, *args: P.args, **kwargs: P.kwargs) -> R:
+    def __call__(self: T_co, *args: P.args, **kwargs: P.kwargs) -> R_co:  # type: ignore[misc]
         ...
 
     @overload
     @staticmethod
-    def __call__(self: T, _self: T, *args: P.args, **kwargs: P.kwargs) -> R:
+    def __call__(cls: type[T_co], *args: P.args, **kwargs: P.kwargs) -> R_co:
         ...
 
-    @overload
-    @staticmethod
-    def __call__(cls: type[T], *args: P.args, **kwargs: P.kwargs) -> R:
-        ...
 
-    @overload
-    @staticmethod
-    def __call__(cls: type[T], _cls: type[T], *args: P.args, **kwargs: P.kwargs) -> R:
-        ...
+self_objects_cache = dict[Any, Any]()
 
-    @staticmethod
-    def __call__(*args: Any, **kwds: Any) -> Any:
-        ...
 
-
-self_objects_cache = dict[type, Any]()
-
-
-class inject_self_base(Generic[T, P, R]):
+class inject_self_base(Generic[T_co, P, R_co]):
     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:
+    def __init__(self, function: Callable[Concatenate[T_co, P], R_co], /, *, cache: bool = False) -> None:
         """
         Wrap ``function`` to always have a self provided to it.
 
@@ -130,8 +116,8 @@ class inject_self_base(Generic[T, P, R]):
         self.clean_kwargs = False
 
     def __get__(
-        self, class_obj: type[T] | T | None, class_type: type[T] | type[type[T]]  # type: ignore
-    ) -> injected_self_func[T, P, R]:
+        self, class_obj: type[T] | T | None, class_type: type[T] | type[type[T]] | Any  # type: ignore[valid-type]
+    ) -> injected_self_func[T_co, P, R_co]:
         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)
@@ -187,8 +173,8 @@ class inject_self_base(Generic[T, P, R]):
 
         return _wrapper
 
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
-        return self.__get__(None, self)(*args, **kwargs)  # type: ignore
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R_co:
+        return self.__get__(None, self)(*args, **kwargs)
 
     @property
     def __signature__(self) -> Signature:
@@ -197,7 +183,7 @@ class inject_self_base(Generic[T, P, R]):
     @classmethod
     def with_args(
         cls, *args: Any, **kwargs: Any
-    ) -> Callable[[Callable[Concatenate[T0, P0], R0]], inject_self[T0, P0, R0]]:
+    ) -> Callable[[Callable[Concatenate[T0_co, P0], R0_co]], inject_self[T0_co, P0, R0_co]]:
         """Provide custom args to instantiate the ``self`` object with."""
 
         def _wrapper(function: Callable[Concatenate[T0, P0], R0]) -> inject_self[T0, P0, R0]:
@@ -208,69 +194,71 @@ class inject_self_base(Generic[T, P, R]):
         return _wrapper
 
 
-class inject_self(Generic[T, P, R], inject_self_base[T, P, R]):
+class inject_self(inject_self_base[T_co, P, R_co]):
     """Wrap a method so it always has a constructed ``self`` provided to it."""
 
-    class cached(Generic[T0, P0, R0], inject_self_base[T0, P0, R0]):
+    class cached(inject_self_base[T0_co, P0, R0_co]):
         """
         Wrap a method so it always has a constructed ``self`` provided to it.
         Once ``self`` is constructed, it will be reused.
         """
 
-        class property(Generic[T1, R1]):
-            def __init__(self, function: Callable[[T1], R1]) -> None:
+        class property(Generic[T1_co, R1_co]):
+            def __init__(self, function: Callable[[T1_co], R1_co]) -> None:
                 self.function = inject_self(function)
 
             def __get__(
-                self, class_obj: type[T1] | T1 | None, class_type: type[T1] | type[type[T1]]  # type: ignore
-            ) -> R1:
+                self, class_obj: type[T1_co] | T1_co | None, class_type: type[T1_co] | T1_co
+            ) -> R1_co:
                 return self.function.__get__(class_obj, class_type)()
 
-    class init_kwargs(Generic[T0, P0, R0], inject_self_base[T0, P0, R0]):
+    class init_kwargs(inject_self_base[T0_co, P0, R0_co]):
         """
         Wrap a method so it always has a constructed ``self`` provided to it.
         When constructed, kwargs to the function will be passed to the constructor.
         """
 
         @classmethod
-        def clean(cls, function: Callable[Concatenate[T1, P1], R1]) -> inject_self[T1, P1, R1]:
+        def clean(cls, function: Callable[Concatenate[T1_co, P1], R1_co]) -> inject_self[T1_co, P1, R1_co]:
             """Wrap a method, pass kwargs to the constructor and remove them from actual **kwargs."""
             inj = cls(function)  # type: ignore
             inj.clean_kwargs = True
             return inj  # type: ignore
 
-    class property(Generic[T0, R0]):
-        def __init__(self, function: Callable[[T0], R0]) -> None:
+    class property(Generic[T0_co, R0_co]):
+        def __init__(self, function: Callable[[T0_co], R0_co]) -> None:
             self.function = inject_self(function)
 
         def __get__(
-            self, class_obj: type[T0] | T0 | None, class_type: type[T0] | type[type[T0]]  # type: ignore
-        ) -> R0:
+            self, class_obj: type[T0_co] | T0_co | None, class_type: type[T0_co] | T0_co
+        ) -> R0_co:
             return self.function.__get__(class_obj, class_type)()
 
 
-class inject_kwargs_params_base_func(Generic[T, P, R], Callable[Concatenate[T, P], R]):  # type: ignore[misc]
-    def __call__(self: T, *args: P.args, **kwargs: P.kwargs) -> R:  # type: ignore
-        ...
+class inject_kwargs_params_base_func(Generic[T_co, P, R_co]):
+    def __call__(self: T_co, *args: P.args, **kwargs: P.kwargs) -> R_co:
+        raise NotImplementedError
 
 
-class inject_kwargs_params_base(Generic[T, P, R]):
+class inject_kwargs_params_base(Generic[T_co, P, R_co]):
+    signature: Signature | None
+
     _kwargs_name = 'kwargs'
 
-    def __init__(self, function: Callable[Concatenate[T, P], R]) -> None:
+    def __init__(self, function: Callable[Concatenate[T_co, P], R_co]) -> None:
         self.function = function
 
         self.signature = None
 
     def __get__(
         self, class_obj: T, class_type: type[T]
-    ) -> inject_kwargs_params_base_func[T, P, R]:
+    ) -> inject_kwargs_params_base_func[T_co, P, R_co]:
         if not self.signature:
-            self.signature = Signature.from_callable(self.function, eval_str=True)  # type: ignore
+            self.signature = Signature.from_callable(self.function, eval_str=True)
 
             if (
-                isinstance(self, inject_kwargs_params.add_to_kwargs)  # type: ignore
-                and (4 not in {x.kind for x in self.signature.parameters.values()})  # type: ignore
+                isinstance(self, inject_kwargs_params.add_to_kwargs)  # type: ignore[arg-type]
+                and (4 not in {x.kind for x in self.signature.parameters.values()})
             ):
                 from ..exceptions import CustomValueError
 
@@ -281,10 +269,10 @@ class inject_kwargs_params_base(Generic[T, P, R]):
         this = self
 
         @wraps(self.function)
-        def _wrapper(self: T, *_args: P.args, **kwargs: P.kwargs) -> R:
+        def _wrapper(self: Any, *_args: Any, **kwargs: Any) -> R_co:
             assert this.signature
 
-            if class_obj and not isinstance(self, class_type):  # type: ignore
+            if class_obj and not isinstance(self, class_type):
                 _args = (self, *_args)
                 self = class_obj
 
@@ -318,14 +306,14 @@ class inject_kwargs_params_base(Generic[T, P, R]):
 
                     kwargs[key] = kw_value
 
-            if isinstance(this, inject_kwargs_params.add_to_kwargs):
+            if isinstance(this, inject_kwargs_params.add_to_kwargs):  # type: ignore[arg-type]
                 kwargs |= this_kwargs
 
             return this.function(self, *args, **kwargs)
 
         return _wrapper  # type: ignore
 
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R_co:
         return self.__get__(None, self)(*args, **kwargs)  # type: ignore
 
     @property
@@ -422,89 +410,55 @@ def get_subclasses(family: type[T], exclude: Sequence[type[T]] = []) -> list[typ
     return list(set(_subclasses(family)))
 
 
-class classproperty(Generic[P, R, T, T0, P0]):
+class classproperty(Generic[T, R]):
     """
     Make a class property. A combination between classmethod and property.
     """
 
     __isabstractmethod__: bool = False
 
-    class metaclass(type):
-        """This must be set for the decorator to work."""
-
-        def __setattr__(self, key: str, value: Any) -> None:
-            if key in self.__dict__:
-                obj = self.__dict__.get(key)
-
-                if obj and isinstance(obj, classproperty):
-                    obj.__set__(self, value)
-                    return
-
-            super(classproperty.metaclass, self).__setattr__(key, value)
-
     def __init__(
         self,
-        fget: classmethod[T, P, R] | Callable[P, R],
-        fset: classmethod[T, P, None] | Callable[[T, T0], None] | None = None,
-        fdel: classmethod[T, P1, None] | Callable[P1, None] | None = None,
+        fget: Callable[[type[T]], R] | classmethod[T, ..., R],
+        fset: Callable[[type[T], R], None] | classmethod[T, Concatenate[R, ...], None] | None = None,
+        fdel: Callable[[type[T]], None] | classmethod[T, ..., None] | None = None,
         doc: str | None = None,
     ) -> None:
         self.fget = self._wrap(fget)
         self.fset = self._wrap(fset) if fset is not None else fset
         self.fdel = self._wrap(fdel) if fdel is not None else fdel
 
-        self.doc = doc
+        self.__doc__ = doc
 
-    def _wrap(self, func: classmethod[T1, P1, R1] | Callable[P1, R1]) -> classmethod[T1, P1, R1]:
-        if not isinstance(func, (classmethod, staticmethod)):
-            func = classmethod(func)  # type: ignore
+    def _wrap(self, func: Callable[..., R1] | classmethod[T, P1, R1]) -> classmethod[T, P1, R1]:
+        if not isinstance(func, classmethod):
+            func = classmethod(func)
 
-        return func  # type: ignore
+        return func
 
-    def getter(self, __fget: classmethod[T, P, R] | Callable[P1, R1]) -> classproperty[P1, R1, T, T0, P0]:
-        self.fget = self._wrap(__fget)  # type: ignore
-        return self  # type: ignore
-
-    def setter(self, __fset: classmethod[T1, P, None] | Callable[[T1, T2], None]) -> classproperty[P, R, T1, T2, P0]:
-        self.fset = self._wrap(__fset)  # type: ignore
-        return self  # type: ignore
-
-    def deleter(self, __fdel: classmethod[T1, P1, None] | Callable[P1, None]) -> classproperty[P, R, T, T0, P1]:
-        self.fdel = self._wrap(__fdel)  # type: ignore
-        return self  # type: ignore
-
-    def __get__(self, __obj: Any, __type: type | None = None) -> R:
+    def __get__(self, __obj: T | None, __type: type | None = None) -> R:
         if __type is None:
             __type = type(__obj)
 
-        return self.fget.__get__(__obj, __type)()  # type: ignore
-
-    def __set__(self, __obj: Any, __value: Any) -> None:
-        from ..exceptions import CustomError
+        return self.fget.__get__(__obj, __type)()
 
+    def __set__(self, __obj: T, __value: Any) -> None:
         if not self.fset:
-            raise CustomError[AttributeError]("Can't set attribute")
-
-        if isclass(__obj):
-            type_, __obj = __obj, None
-        else:
-            type_ = type(__obj)
-
-        return self.fset.__get__(__obj, type_)(__value)
+            raise AttributeError(
+                f'classproperty with getter "{self.__name__}" of "{__obj.__class__.__name__}" object has no setter.'
+            )
 
-    def __delete__(self, __obj: Any) -> None:
-        from ..exceptions import CustomError
+        self.fset.__get__(None, type(__obj))(__value)
 
+    def __delete__(self, __obj: T) -> None:
         if not self.fdel:
-            raise CustomError[AttributeError]("Can't delete attribute")
-
-        if isclass(__obj):
-            type_, __obj = __obj, None
-        else:
-            type_ = type(__obj)
+            raise AttributeError(
+                f'classproperty with getter "{self.__name__}" of "{__obj.__class__.__name__}" object has no deleter.'
+            )
 
-        return self.fdel.__delete__(__obj, type_)(__obj)  # type: ignore
+        self.fdel.__get__(None, type(__obj))()
 
+    @property
     def __name__(self) -> str:
         return self.fget.__name__
 

{jetpytools-1.2.8.dist-info → jetpytools-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetpytools
-Version: 1.2.8
+Version: 1.4.0
 Summary: Collection of stuff that's useful in general python programming
 Author: Jaded Encoding Thaumaturgy
 Author-email: jaded.encoding.thaumaturgy@gmail.com
@@ -18,6 +18,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: typing_extensions>=4.12.2
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -27,6 +28,7 @@ Dynamic: license-file
 Dynamic: maintainer
 Dynamic: maintainer-email
 Dynamic: project-url
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

{jetpytools-1.2.8.dist-info → jetpytools-1.4.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 jetpytools/__init__.py,sha256=FSVZdj69oy4mBXd6OXiRHrUhaSc4Exo1pQHBlXycV98,214
-jetpytools/_metadata.py,sha256=dHrH7etfneDpwolPNtKsiYRP2pispFzW4GiV141azFs,414
+jetpytools/_metadata.py,sha256=v1lmWTzb06HMM9cWuvZNc6UWkUsfNUm_rmuwcgdFavs,414
 jetpytools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jetpytools/enums/__init__.py,sha256=5n6Cu8Yb9N6hIa_YTsyy_s0cCgCnh0vDb-NyXK2RwV0,81
-jetpytools/enums/base.py,sha256=BbePlmj__Vqc7gzhrbZBFnrQcC9WNBjtiBYoXpgVNOA,2079
+jetpytools/enums/base.py,sha256=m3jJ6rJwDm4vp2-qMsuRH-Ll2mQDXA-wkmhw4xaafTM,2003
 jetpytools/enums/other.py,sha256=DerFtmdjNK41ZxSYt601vHV5yzvZHPfTKNDlj-FjHm8,1346
 jetpytools/exceptions/__init__.py,sha256=g8GT0XqcNuHFHgQGSRj6a_X1kBiBQGP05soYNbEIN_Q,205
-jetpytools/exceptions/base.py,sha256=ESwC7H8iCQW9DGMGmaoFwIiid98tE1e6sATjOH_7Duc,6370
+jetpytools/exceptions/base.py,sha256=OZS5sJlNCh4Qy-2flvZugYpyJuXoRrxXa7RFqdDAktw,5969
 jetpytools/exceptions/enum.py,sha256=9YoWwEfyd9k7NwanAqtXbhJaJQAnjRKqsAO73cDvcpA,223
 jetpytools/exceptions/file.py,sha256=QwhUFAoG3NsFFYuPe5O_I6K969CzlrTCv3RTrfzx8B0,1107
 jetpytools/exceptions/generic.py,sha256=kMj5lR3ifHk3uNhpxN6Lu4Am0vi7E6TfQezkZulqhaQ,1482
@@ -15,20 +15,20 @@ jetpytools/functions/funcs.py,sha256=EMoJ_h2tl8Cgr1PXAsmRvgaOY5YL7AiEnGGo3-H76tk
 jetpytools/functions/normalize.py,sha256=2BACok7TAN5ldANyYrbGhUpOkj84siApAYy6ndlhUfI,6316
 jetpytools/functions/other.py,sha256=TRz91spvdYJUh9vKe3Kuw6xZfSEJvrQs1mZVg7SyYmY,413
 jetpytools/types/__init__.py,sha256=yDT-PYTTzH6DyHsQcKvOy1jrCPmUQRKrjCM3apd0kNw,294
-jetpytools/types/builtins.py,sha256=1Z_NF9InJ2IngI7ljvjRKz5xEyi4mseH6hj1BPRFCio,1808
+jetpytools/types/builtins.py,sha256=hndNUoxBeFx9kgSj-6Lm8rjQH0a9lkrqRqPDObr0pbk,1969
 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=3MaUnjezgTy4VjCstD4jNRMOoZX2Q_T1G6L55su5VhU,22570
+jetpytools/types/utils.py,sha256=eT3yoFUEQy4vKTyLDMp_6Ixy7woyF4afWgiLhS-Vr38,21030
 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.8.dist-info/licenses/LICENSE,sha256=l0PN-qDtXcgOB5aXP_nSUsvCK5V3o9pQCGsTzyZhKL0,1071
-jetpytools-1.2.8.dist-info/METADATA,sha256=0gAb1-G5YYAXQSSU2glTyAIFc68PNhaHN3U6RQXiIMo,1421
-jetpytools-1.2.8.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-jetpytools-1.2.8.dist-info/top_level.txt,sha256=Iy4HjIta33ADJxN9Nyt5t5jRIfotEkZkQcOSw4eG8Cs,11
-jetpytools-1.2.8.dist-info/RECORD,,
+jetpytools-1.4.0.dist-info/licenses/LICENSE,sha256=l0PN-qDtXcgOB5aXP_nSUsvCK5V3o9pQCGsTzyZhKL0,1071
+jetpytools-1.4.0.dist-info/METADATA,sha256=vNcju4cgq0KyWoml7dd6q6QWq8KCvUIQT-DciIXtYe8,1485
+jetpytools-1.4.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+jetpytools-1.4.0.dist-info/top_level.txt,sha256=Iy4HjIta33ADJxN9Nyt5t5jRIfotEkZkQcOSw4eG8Cs,11
+jetpytools-1.4.0.dist-info/RECORD,,

{jetpytools-1.2.8.dist-info → jetpytools-1.4.0.dist-info}/WHEEL

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