jetpytools 1.2.8__tar.gz → 1.4.0__tar.gz

{jetpytools-1.2.8 → jetpytools-1.4.0}/PKG-INFO

@@ -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 → jetpytools-1.4.0}/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-1.2.8 → jetpytools-1.4.0}/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-1.2.8 → jetpytools-1.4.0}/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-1.2.8 → jetpytools-1.4.0}/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-1.2.8 → jetpytools-1.4.0}/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 → jetpytools-1.4.0}/jetpytools.egg-info/PKG-INFO

@@ -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 → jetpytools-1.4.0}/jetpytools.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ jetpytools/py.typed
 jetpytools.egg-info/PKG-INFO
 jetpytools.egg-info/SOURCES.txt
 jetpytools.egg-info/dependency_links.txt
+jetpytools.egg-info/requires.txt
 jetpytools.egg-info/top_level.txt
 jetpytools/enums/__init__.py
 jetpytools/enums/base.py
@@ -34,4 +35,6 @@ jetpytools/utils/__init__.py
 jetpytools/utils/file.py
 jetpytools/utils/funcs.py
 jetpytools/utils/math.py
-jetpytools/utils/ranges.py
+jetpytools/utils/ranges.py
+tests/test_funcs.py
+tests/test_normalize.py

jetpytools-1.4.0/jetpytools.egg-info/requires.txt

@@ -0,0 +1 @@
+typing_extensions>=4.12.2

{jetpytools-1.2.8 → jetpytools-1.4.0}/setup.cfg

@@ -7,6 +7,7 @@ show-source = True
 statistics = True
 
 [mypy]
+python_version = 3.10
 ignore_missing_imports = False
 disallow_any_generics = True
 disallow_untyped_defs = True

{jetpytools-1.2.8 → jetpytools-1.4.0}/setup.py

@@ -25,6 +25,7 @@ setuptools.setup(
         'Source Code': 'https://github.com/Jaded-Encoding-Thaumaturgy/jetpytools',
         'Contact': 'https://discord.gg/XTpc6Fa9eB',
     },
+    install_requires="typing_extensions>=4.12.2",
     python_requires='>=3.10',
     packages=[
         package_name,

jetpytools-1.4.0/tests/test_funcs.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from jetpytools import fallback, iterate
+
+
+def test_iterate() -> None:
+    assert iterate(5, lambda x: x * 2, 2) == 20
+
+
+def test_fallback() -> None:
+    assert fallback(5, 6) == 5
+    assert fallback(None, 6) == 6

jetpytools-1.4.0/tests/test_normalize.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from jetpytools import normalize_ranges
+
+
+def test_normalize_ranges() -> None:
+    assert normalize_ranges((None, None), end=1000) == [(0, 999)]
+    assert normalize_ranges((24, -24), end=1000) == [(24, 975)]
+    assert normalize_ranges([(24, 100), (80, 150)], end=1000) == [(24, 150)]