jetpytools 1.5.0__tar.gz → 1.6.0__tar.gz

jetpytools-1.6.0/.gitignore

@@ -0,0 +1,12 @@
+.eggs/
+.mypy_cache/
+.vscode/
+*.glsl
+*.pyc
+*.vpy
+*.egg-info/*
+/tests/dependencies/*
+/tests/output/*
+build/
+dist/
+stgpytools.egg-info/

{jetpytools-1.5.0 → jetpytools-1.6.0}/PKG-INFO

@@ -1,36 +1,23 @@
 Metadata-Version: 2.4
 Name: jetpytools
-Version: 1.5.0
+Version: 1.6.0
 Summary: Collection of stuff that's useful in general python programming
-Author: Jaded Encoding Thaumaturgy
-Author-email: jaded.encoding.thaumaturgy@gmail.com
-Maintainer: Jaded Encoding Thaumaturgy
-Maintainer-email: jaded.encoding.thaumaturgy@gmail.com
 Project-URL: Source Code, https://github.com/Jaded-Encoding-Thaumaturgy/jetpytools
 Project-URL: Contact, https://discord.gg/XTpc6Fa9eB
-Classifier: Natural Language :: English
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Other Audience
-Classifier: Programming Language :: Python :: 3.10
+Author: Jaded Encoding Thaumaturgy
+Maintainer-email: Jaded Encoding Thaumaturgy <jaded.encoding.thaumaturgy@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
+Requires-Dist: typing-extensions>=4.12.2
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: typing_extensions>=4.12.2
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: license-file
-Dynamic: maintainer
-Dynamic: maintainer-email
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # jetpytools
 

jetpytools-1.6.0/jetpytools/__init__.py

@@ -0,0 +1,5 @@
+from .enums import *
+from .exceptions import *
+from .functions import *
+from .types import *
+from .utils import *

jetpytools-1.6.0/jetpytools/_metadata.py

@@ -0,0 +1,12 @@
+"""Collection of stuff that's useful in general python programming"""
+
+__version__ = "1.6.0"
+
+__author_name__, __author_email__ = "Jaded Encoding Thaumaturgy", "jaded.encoding.thaumaturgy@gmail.com"
+__maintainer_name__, __maintainer_email__ = __author_name__, __author_email__
+
+__author__ = f"{__author_name__} <{__author_email__}>"
+__maintainer__ = __author__
+
+if __name__ == "__github__":
+    print(__version__)

jetpytools-1.6.0/jetpytools/enums/__init__.py

@@ -0,0 +1,2 @@
+from .base import *
+from .other import *

{jetpytools-1.5.0 → jetpytools-1.6.0}/jetpytools/enums/base.py

@@ -8,9 +8,7 @@ from typing_extensions import Self
 from ..exceptions import CustomValueError, NotFoundEnumValue
 from ..types import FuncExceptT
 
-__all__ = [
-    'CustomEnum', 'CustomIntEnum', 'CustomStrEnum'
-]
+__all__ = ["CustomEnum", "CustomIntEnum", "CustomStrEnum"]
 
 
 class CustomEnum(Enum):
@@ -43,7 +41,7 @@ class CustomEnum(Enum):
             return value
 
         if value is cls:
-            raise CustomValueError('You must select a member, not pass the enum!', func_except)
+            raise CustomValueError("You must select a member, not pass the enum!", func_except)
 
         try:
             return cls(value)
@@ -57,10 +55,13 @@ class CustomEnum(Enum):
 
         raise NotFoundEnumValue(
             'The given value for "{var_name}" argument must be a valid {enum_name}, not "{value}"!\n'
-            'Valid values are: [{readable_enum}].', func_name,
-            var_name=var_name, enum_name=cls, value=value,
-            readable_enum=iter([f'{x.name} ({x.value})' for x in cls]),
-            reason=value
+            "Valid values are: [{readable_enum}].",
+            func_name,
+            var_name=var_name,
+            enum_name=cls,
+            value=value,
+            readable_enum=iter([f"{x.name} ({x.value})" for x in cls]),
+            reason=value,
         )
 
 

{jetpytools-1.5.0 → jetpytools-1.6.0}/jetpytools/enums/other.py

@@ -1,13 +1,10 @@
 from __future__ import annotations
 
 from typing import overload
+
 from typing_extensions import Self
 
-__all__ = [
-    'Coordinate',
-    'Position',
-    'Size'
-]
+__all__ = ["Coordinate", "Position", "Size"]
 
 
 class Coordinate:
@@ -24,12 +21,10 @@ class Coordinate:
     """Vertical coordinate."""
 
     @overload
-    def __init__(self, other: tuple[int, int] | Self, /) -> None:
-        ...
+    def __init__(self, other: tuple[int, int] | Self, /) -> None: ...
 
     @overload
-    def __init__(self, x: int, y: int, /) -> None:
-        ...
+    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

jetpytools-1.6.0/jetpytools/exceptions/__init__.py

@@ -0,0 +1,5 @@
+from .base import *
+from .enum import *
+from .file import *
+from .generic import *
+from .module import *

{jetpytools-1.5.0 → jetpytools-1.6.0}/jetpytools/exceptions/base.py

@@ -1,45 +1,43 @@
 from __future__ import annotations
 
 import sys
-
 from copy import deepcopy
 from typing import TYPE_CHECKING, Any, TypeVar
 
 from typing_extensions import Self
 
-from ..types import MISSING, FuncExceptT, SupportsString, MissingT
+from ..types import MISSING, FuncExceptT, MissingT, SupportsString
 
 __all__ = [
-    'CustomError',
-
-    'CustomValueError',
-    'CustomIndexError',
-    'CustomOverflowError',
-    'CustomKeyError',
-    'CustomTypeError',
-    'CustomRuntimeError',
-    'CustomNotImplementedError',
-    'CustomPermissionError'
+    "CustomError",
+    "CustomIndexError",
+    "CustomKeyError",
+    "CustomNotImplementedError",
+    "CustomOverflowError",
+    "CustomPermissionError",
+    "CustomRuntimeError",
+    "CustomTypeError",
+    "CustomValueError",
 ]
 
 
 if TYPE_CHECKING:
-    class ExceptionT(Exception):
+
+    class ExceptionError(Exception):
         __name__: str
         __qualname__: str
-        ...
 else:
-    ExceptionT = Exception
+    ExceptionError = Exception
 
 
 class CustomErrorMeta(type):
     """Custom base exception meta class."""
 
     def __new__(cls: type[SelfCErrorMeta], *args: Any) -> SelfCErrorMeta:
-        return CustomErrorMeta.setup_exception(type.__new__(cls, *args))  # type: ignore
+        return CustomErrorMeta.setup_exception(type.__new__(cls, *args))  # pyright: ignore[reportReturnType]
 
     @staticmethod
-    def setup_exception(exception: SelfCErrorMeta, override: str | ExceptionT | None = None) -> SelfCErrorMeta:
+    def setup_exception(exception: SelfCErrorMeta, override: str | ExceptionError | None = None) -> SelfCErrorMeta:
         """
         Setup an exception for later use in CustomError.
 
@@ -55,28 +53,28 @@ class CustomErrorMeta(type):
             else:
                 over_name, over_qual = override.__name__, override.__qualname__
 
-            if over_name.startswith('Custom'):
+            if over_name.startswith("Custom"):
                 exception.__name__ = over_name
             else:
-                exception.__name__ = f'Custom{over_name}'
+                exception.__name__ = f"Custom{over_name}"
 
             exception.__qualname__ = over_qual
 
-        if exception.__qualname__.startswith('Custom'):
+        if exception.__qualname__.startswith("Custom"):
             exception.__qualname__ = exception.__qualname__[6:]
 
         if sys.stdout and sys.stdout.isatty():
-            exception.__qualname__ = f'\033[0;31;1m{exception.__qualname__}\033[0m'
+            exception.__qualname__ = f"\033[0;31;1m{exception.__qualname__}\033[0m"
 
         exception.__module__ = Exception.__module__
 
         return exception
 
 
-SelfCErrorMeta = TypeVar('SelfCErrorMeta', bound=CustomErrorMeta)
+SelfCErrorMeta = TypeVar("SelfCErrorMeta", bound=CustomErrorMeta)
 
 
-class CustomError(ExceptionT, metaclass=CustomErrorMeta):
+class CustomError(ExceptionError, metaclass=CustomErrorMeta):
     """Custom base exception class."""
 
     def __init__(
@@ -97,7 +95,7 @@ class CustomError(ExceptionT, metaclass=CustomErrorMeta):
 
         super().__init__(message)
 
-    def __class_getitem__(cls, exception: str | type[ExceptionT] | ExceptionT) -> CustomError:
+    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)
@@ -109,7 +107,7 @@ class CustomError(ExceptionT, metaclass=CustomErrorMeta):
         message: SupportsString | None | MissingT = MISSING,
         func: FuncExceptT | None | MissingT = MISSING,
         reason: SupportsString | FuncExceptT | None | MissingT = MISSING,
-        **kwargs: Any
+        **kwargs: Any,
     ) -> Self:
         """
         Copy an existing exception with defaults and instantiate a new one.
@@ -140,40 +138,38 @@ class CustomError(ExceptionT, metaclass=CustomErrorMeta):
         message = self.message
 
         if not message:
-            message = 'An error occurred!'
+            message = "An error occurred!"
 
         if self.func:
             func_header = norm_func_name(self.func).strip()
 
             if sys.stdout and sys.stdout.isatty():
-                func_header = f'\033[0;36m{func_header}\033[0m'
+                func_header = f"\033[0;36m{func_header}\033[0m"
 
-            func_header = f'({func_header}) '
+            func_header = f"({func_header}) "
         else:
-            func_header = ''
+            func_header = ""
 
         if self.kwargs:
-            self.kwargs = {
-                key: norm_display_name(value) for key, value in self.kwargs.items()
-            }
+            self.kwargs = {key: norm_display_name(value) for key, value in self.kwargs.items()}
 
         if self.reason:
             reason = self.reason = norm_display_name(self.reason)
 
             if reason:
                 if not isinstance(self.reason, dict):
-                    reason = f'({reason})'
+                    reason = f"({reason})"
 
                 if sys.stdout and sys.stdout.isatty():
-                    reason = f'\033[0;33m{reason}\033[0m'
-                reason = f' {reason}'
+                    reason = f"\033[0;33m{reason}\033[0m"
+                reason = f" {reason}"
         else:
-            reason = ''
+            reason = ""
 
-        return f'{func_header}{self.message!s}{reason}'.format(**self.kwargs).strip()
+        return f"{func_header}{self.message!s}{reason}".format(**self.kwargs).strip()
 
 
-SelfError = TypeVar('SelfError', bound=CustomError)
+SelfError = TypeVar("SelfError", bound=CustomError)
 
 
 class CustomValueError(CustomError, ValueError):

jetpytools-1.6.0/jetpytools/exceptions/enum.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .base import CustomKeyError
+
+__all__ = ["NotFoundEnumValue", "NotFoundEnumValueError"]
+
+
+class NotFoundEnumValueError(CustomKeyError):
+    """Raised when you try to instantiate an Enum with unknown value"""
+
+
+NotFoundEnumValue = NotFoundEnumValueError

{jetpytools-1.5.0 → jetpytools-1.6.0}/jetpytools/exceptions/file.py

@@ -2,15 +2,13 @@ from __future__ import annotations
 
 from .base import CustomError, CustomPermissionError
 
-
 __all__ = [
-    'FileNotExistsError',
-    'FileWasNotFoundError',
-    'FilePermissionError',
-    'FileTypeMismatchError',
-    'FileIsADirectoryError',
-
-    'PathIsNotADirectoryError',
+    "FileIsADirectoryError",
+    "FileNotExistsError",
+    "FilePermissionError",
+    "FileTypeMismatchError",
+    "FileWasNotFoundError",
+    "PathIsNotADirectoryError",
 ]
 
 

{jetpytools-1.5.0 → jetpytools-1.6.0}/jetpytools/exceptions/generic.py

@@ -5,9 +5,7 @@ from typing import Any, Iterable
 from ..types import FuncExceptT, SupportsString, T
 from .base import CustomValueError
 
-__all__ = [
-    'MismatchError', 'MismatchRefError'
-]
+__all__ = ["MismatchError", "MismatchRefError"]
 
 
 class MismatchError(CustomValueError):
@@ -22,8 +20,12 @@ class MismatchError(CustomValueError):
         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!',
-        reason: Any = '{reduced_items}', **kwargs: Any
+        self,
+        func: FuncExceptT,
+        items: Iterable[Any],
+        message: SupportsString = "All items must be equal!",
+        reason: Any = "{reduced_items}",
+        **kwargs: Any,
     ) -> None:
         super().__init__(message, func, reason, **kwargs, reduced_items=iter(self._reduce(items)))
 
@@ -35,7 +37,7 @@ class MismatchError(CustomValueError):
 
 class MismatchRefError(MismatchError):
     def __init__(
-        self, func: FuncExceptT, base: T, ref: T, message: SupportsString = 'All items must be equal!', **kwargs: Any
+        self, func: FuncExceptT, base: T, ref: T, message: SupportsString = "All items must be equal!", **kwargs: Any
     ) -> None:
         super().__init__(func, [base, ref], message, **kwargs)
 

{jetpytools-1.5.0 → jetpytools-1.6.0}/jetpytools/exceptions/module.py

@@ -5,19 +5,18 @@ from typing import Any
 from ..types import FuncExceptT, SupportsString
 from .base import CustomError
 
-__all__ = [
-    'CustomImportError',
-    'DependencyNotFoundError'
-]
+__all__ = ["CustomImportError", "DependencyNotFoundError"]
 
 
 class CustomImportError(CustomError, ImportError):
     """Raised when there's a general import error."""
 
     def __init__(
-        self, func: FuncExceptT, package: str | ImportError,
+        self,
+        func: FuncExceptT,
+        package: str | ImportError,
         message: SupportsString = "Import failed for package '{package}'!",
-        **kwargs: Any
+        **kwargs: Any,
     ) -> None:
         """
         :param func:        Function this error was raised from.
@@ -32,8 +31,10 @@ class DependencyNotFoundError(CustomImportError):
     """Raised when there's a missing optional dependency."""
 
     def __init__(
-        self, func: FuncExceptT, package: str | ImportError,
+        self,
+        func: FuncExceptT,
+        package: str | ImportError,
         message: SupportsString = "Missing dependency '{package}'!",
-        **kwargs: Any
+        **kwargs: Any,
     ) -> None:
         super().__init__(func, package, message, **kwargs)

jetpytools-1.6.0/jetpytools/functions/__init__.py

@@ -0,0 +1,3 @@
+from .funcs import *
+from .normalize import *
+from .other import *

{jetpytools-1.5.0 → jetpytools-1.6.0}/jetpytools/functions/funcs.py

@@ -1,19 +1,16 @@
 from __future__ import annotations
 
-from typing import Any, Callable, Concatenate, overload
 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
 
-__all__ = [
-    'iterate', 'fallback', 'kwargs_fallback', 'filter_kwargs'
-]
+__all__ = ["fallback", "filter_kwargs", "iterate", "kwargs_fallback"]
 
 
 def iterate(
-    base: T, function: Callable[Concatenate[T | R, P], R],
-    count: int, *args: P.args, **kwargs: P.kwargs
+    base: T, function: Callable[Concatenate[T | R, P], R], count: int, *args: P.args, **kwargs: P.kwargs
 ) -> T | R:
     """
     Execute a given function over the base value multiple times.
@@ -51,28 +48,23 @@ fallback_missing = object()
 
 
 @overload
-def fallback(value: T | None, fallback: T, /) -> T:
-    ...
+def fallback(value: T | None, fallback: T, /) -> T: ...
 
 
 @overload
-def fallback(value: T | None, fallback0: T | None, default: T, /) -> T:
-    ...
+def fallback(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(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(value: T | None, *fallbacks: T | None) -> T | MissingT: ...
 
 
 @overload
-def fallback(value: T | None, *fallbacks: T | None, default: T) -> T:
-    ...
+def fallback(value: T | None, *fallbacks: T | None, default: T) -> T: ...
 
 
 def fallback(value: T | None, *fallbacks: T | None, default: Any | T = fallback_missing) -> T | MissingT:
@@ -106,47 +98,36 @@ def fallback(value: T | None, *fallbacks: T | None, default: Any | T = fallback_
     elif len(fallbacks) > 3:
         return MISSING
 
-    raise CustomRuntimeError('You need to specify a default/fallback value!')
+    raise CustomRuntimeError("You need to specify a default/fallback value!")
 
 
 @overload
-def kwargs_fallback(
-    input_value: T | None, kwargs: tuple[KwargsT, str], fallback: T
-) -> T:
-    ...
+def kwargs_fallback(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(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
-) -> 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(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(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
+    value: T | None,
+    kwargs: tuple[KwargsT, str],
+    *fallbacks: T | None,
+    default: T = fallback_missing,  # type: ignore
 ) -> T | MissingT:
     """Utility function to return a fallback value from kwargs if value was not found or is None."""
 
@@ -154,13 +135,11 @@ def kwargs_fallback(  # type: ignore
 
 
 @overload
-def filter_kwargs(func: Callable[..., Any], kwargs: dict[str, Any]) -> dict[str, Any]:
-    ...
+def filter_kwargs(func: Callable[..., Any], kwargs: dict[str, Any]) -> dict[str, Any]: ...
 
 
 @overload
-def filter_kwargs(func: Callable[..., Any], **kwargs: Any) -> dict[str, Any]:
-    ...
+def filter_kwargs(func: Callable[..., Any], **kwargs: Any) -> dict[str, Any]: ...
 
 
 def filter_kwargs(func: Callable[..., Any], kwargs: dict[str, Any] | None = None, **kw: Any) -> dict[str, Any]: