jetpytools 2.2.0__tar.gz → 2.2.1__tar.gz

{jetpytools-2.2.0 → jetpytools-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetpytools
-Version: 2.2.0
+Version: 2.2.1
 Summary: Collection of stuff that's useful in general python programming
 Project-URL: Source Code, https://github.com/Jaded-Encoding-Thaumaturgy/jetpytools
 Project-URL: Contact, https://discord.gg/XTpc6Fa9eB
@@ -30,5 +30,5 @@ A collection of utilities useful for general Python programming.
 `jetpytools` is distributed via **PyPI**, and the latest stable release can be installed using:
 
 ```sh
-pip install vsjetpack
+pip install jetpytools
 ```

{jetpytools-2.2.0 → jetpytools-2.2.1}/README.md

@@ -9,5 +9,5 @@ A collection of utilities useful for general Python programming.
 `jetpytools` is distributed via **PyPI**, and the latest stable release can be installed using:
 
 ```sh
-pip install vsjetpack
+pip install jetpytools
 ```

jetpytools-2.2.1/jetpytools/_version.py

@@ -0,0 +1,2 @@
+__version__ = "2.2.1"
+__version_tuple__ = (2, 2, 1)

{jetpytools-2.2.0 → jetpytools-2.2.1}/jetpytools/enums/base.py

@@ -42,12 +42,15 @@ class CustomEnum(Enum):
         """
         Return the enum value from a parameter.
 
-        :param value:               Value to instantiate the enum class.
-        :param func_except:         Exception function.
+        Args:
+            value: Value to instantiate the enum class.
+            func_except: Exception function.
 
-        :return:                    Enum value.
+        Returns:
+            Enum value.
 
-        :raises NotFoundEnumValue:   Variable not found in the given enum.
+        Raises:
+            NotFoundEnumValue: Variable not found in the given enum.
         """
         func_except = func_except or cls.from_param
 

{jetpytools-2.2.0 → jetpytools-2.2.1}/jetpytools/enums/other.py

@@ -9,7 +9,8 @@ class Coordinate:
     """
     Positive set of (x, y) coordinates.
 
-    :raises ValueError:     Negative values were passed.
+    Raises:
+        ValueError: Negative values were passed.
     """
 
     x: int

{jetpytools-2.2.0 → jetpytools-2.2.1}/jetpytools/exceptions/base.py

@@ -48,9 +48,10 @@ class CustomError(Exception, metaclass=CustomErrorMeta):
         """
         Instantiate a new exception with pretty printing and more.
 
-        :param message: Message of the error.
-        :param func:    Function this exception was raised from.
-        :param reason:  Reason of the exception. For example, an optional parameter.
+        Args:
+            message: Message of the error.
+            func: Function this exception was raised from.
+            reason: Reason of the exception. For example, an optional parameter.
         """
 
         self.message = message
@@ -70,9 +71,10 @@ class CustomError(Exception, metaclass=CustomErrorMeta):
         """
         Copy an existing exception with defaults and instantiate a new one.
 
-        :param message: Message of the error.
-        :param func:    Function this exception was raised from.
-        :param reason:  Reason of the exception. For example, an optional parameter.
+        Args:
+            message: Message of the error.
+            func: Function this exception was raised from.
+            reason: Reason of the exception. For example, an optional parameter.
         """
         from copy import deepcopy
 

{jetpytools-2.2.0 → jetpytools-2.2.1}/jetpytools/exceptions/file.py

@@ -1,7 +1,14 @@
 from __future__ import annotations
 
+import sys
+
 from .base import CustomError, CustomPermissionError
 
+if sys.version_info < (3, 13):
+    from typing_extensions import deprecated
+else:
+    from warnings import deprecated
+
 __all__ = [
     "FileIsADirectoryError",
     "FileNotExistsError",
@@ -24,6 +31,7 @@ class FilePermissionError(CustomPermissionError):
     """Raised when you try to access a file but haven't got permissions to do so"""
 
 
+@deprecated("FileTypeMismatchError is deprecated and will be removed in a future version.", category=DeprecationWarning)
 class FileTypeMismatchError(CustomError, OSError):
     """Raised when you try to access a file with a FileType != AUTO and it's another file type"""
 

{jetpytools-2.2.0 → jetpytools-2.2.1}/jetpytools/exceptions/module.py

@@ -19,9 +19,10 @@ class CustomImportError(CustomError, ImportError):
         **kwargs: Any,
     ) -> None:
         """
-        :param func:        Function this error was raised from.
-        :param package:     Either the raised error or the name of the missing package.
-        :param message:     Custom error message.
+        Args:
+            func: Function this error was raised from.
+            package: Either the raised error or the name of the missing package.
+            message: Custom error message.
         """
 
         super().__init__(message, func, package=package if isinstance(package, str) else package.name, **kwargs)

{jetpytools-2.2.0 → jetpytools-2.2.1}/jetpytools/functions/funcs.py

@@ -17,19 +17,21 @@ def iterate[T, **P, R](
     Different from regular iteration functions is that you do not need to pass a partial object.
     This function accepts *args and **kwargs. These will be passed on to the given function.
 
-    Examples:
-
-    >>> iterate(5, lambda x: x * 2, 2)
+    - Example:
+        ```python
+        >>> iterate(5, lambda x: x * 2, 2)
         20
+        ```
 
-    :param base:        Base value, etc. to iterate over.
-    :param function:    Function to iterate over the base.
-    :param count:       Number of times to execute function.
-    :param *args:       Positional arguments to pass to the given function.
-    :param **kwargs:    Keyword arguments to pass to the given function.
+    Args:
+        base: Base value, etc. to iterate over.
+        function: Function to iterate over the base.
+        count: Number of times to execute function.
+        *args: Positional arguments to pass to the given function.
+        **kwargs: Keyword arguments to pass to the given function.
 
-    :return:            Value, etc. with the given function run over it
-                        *n* amount of times based on the given count.
+    Returns:
+        Value, etc. with the given function run over it *n* amount of times based on the given count.
     """
 
     if count <= 0:
@@ -54,19 +56,20 @@ def fallback[T](value: T | None, *fallbacks: T | None, default: Any = _fallback_
     """
     Utility function that returns a value or a fallback if the value is None.
 
-    Example:
-
-    .. code-block:: python
-
+    - Example:
+        ```python
         >>> fallback(5, 6)
         5
         >>> fallback(None, 6)
         6
+        ```
 
-    :param value:               Input value to evaluate. Can be None.
-    :param fallbacks:           Value to return if the input value is None.
+    Args:
+        value: Input value to evaluate. Can be None.
+        *fallbacks: Value to return if the input value is None.
 
-    :return:                    Input value or fallback value if input value is None.
+    Returns:
+        Input value or fallback value if input value is None.
     """
     for v in (value, *fallbacks):
         if v is not None:
@@ -102,20 +105,23 @@ def filter_kwargs(func: Callable[..., Any], kwargs: dict[str, Any] | None = None
     """
     Filter kwargs to only include parameters that match the callable's signature, ignoring **kwargs.
 
-    Examples:
-
+    - Examples:
+        ```python
         >>> def my_func(a: int, b: str, c: bool = True):
         ...     return a, b, c
         >>> filter_kwargs(my_func, a=1, b="hello", c=False, d="extra")
         {'a': 1, 'b': 'hello', 'c': False}
         >>> filter_kwargs(my_func, {"a": 1, "b": "hello", "c": False, "d": "extra"})
         {'a': 1, 'b': 'hello', 'c': False}
+        ```
 
-    :param func:        The callable to filter kwargs for.
-    :param kwargs:      Dictionary of keyword arguments to filter.
-    :param **kw:        Keyword arguments to filter (used when kwargs is None).
+    Args:
+        func: The callable to filter kwargs for.
+        kwargs: Dictionary of keyword arguments to filter.
+        **kw: Keyword arguments to filter (used when kwargs is None).
 
-    :return:            A dictionary containing only the kwargs that match the callable's parameters.
+    Returns:
+        A dictionary containing only the kwargs that match the callable's parameters.
     """
 
     if not (filtered_kwargs := fallback(kwargs, kw)):

{jetpytools-2.2.0 → jetpytools-2.2.1}/jetpytools/functions/normalize.py

@@ -31,12 +31,13 @@ def normalize_seq[T](val: T | Sequence[T], length: int) -> list[T]:
     """
     Normalize a sequence of values.
 
-    :param val:     Input value.
-    :param length:  Amount of items in the output.
-                    If original sequence length is less that this,
-                    the last item will be repeated.
+    Args:
+        val: Input value.
+        length: Amount of items in the output. If original sequence length is less that this, the last item will be
+            repeated.
 
-    :return:        List of normalized values with a set amount of items.
+    Returns:
+        List of normalized values with a set amount of items.
     """
 
     val = to_arr(val)
@@ -88,11 +89,12 @@ def normalize_range(ranges: SoftRange, /, exclusive: bool = False) -> Sequence[i
     """
     Normalize ranges represented by a tuple to an iterable of frame numbers.
 
-    :param ranges:      Ranges to normalize.
-    :param exclusive:   Whether to use exclusive (Python-style) ranges.
-                        Defaults to False.
+    Args:
+        ranges: Ranges to normalize.
+        exclusive: Whether to use exclusive (Python-style) ranges. Defaults to False.
 
-    :return:            List of positive frame ranges.
+    Returns:
+        List of positive frame ranges.
     """
 
     if isinstance(ranges, int):
@@ -147,25 +149,24 @@ def normalize_ranges(
     None will be converted to either 0 if it's the first value in a SoftRange, or the end if it's the second item.
     Negative values will be subtracted from the end.
 
-    Examples:
-
-    .. code-block:: python
-
+    - Examples:
+        ```python
         >>> normalize_ranges((None, None), length=1000)
         [(0, 999)]
         >>> normalize_ranges((24, -24), length=1000)
         [(24, 975)]
         >>> normalize_ranges([(24, 100), (80, 150)], length=1000)
         [(24, 150)]
+        ```
 
+    Args:
+        ranges: Frame range or list of frame ranges.
+        length: Number of frames.
+        exclusive: Whether to use exclusive (Python-style) ranges. Defaults to False.
+        strict: Whether to enforce strict checking for out-of-range values.
 
-    :param ranges:      Frame range or list of frame ranges.
-    :param length:      Number of frames.
-    :param exclusive:   Whether to use exclusive (Python-style) ranges.
-                        Defaults to False.
-    :param strict:      Whether to enforce strict checking for out-of-range values.
-
-    :return:            List of positive frame ranges.
+    Returns:
+        List of positive frame ranges.
     """
     from ..utils import clamp
 

{jetpytools-2.2.0 → jetpytools-2.2.1}/jetpytools/types/utils.py

@@ -114,9 +114,13 @@ class _InjectSelfMeta(type):
         """
         Recursively flatten and yield all nested inject_self metaclass relationships.
 
-        :param d:   Optional inner dictionary representing the hierarchy level.
-        :yield:     Each `_InjectSelfMeta` subclass found in the hierarchy.
+        Args:
+            d: Optional inner dictionary representing the hierarchy level.
+
+        Yields:
+            Each `_InjectSelfMeta` subclass found in the hierarchy.
         """
+
         if d is None:
             d = _inject_self_cls[cls]
 
@@ -188,9 +192,10 @@ class _InjectSelfBase(Generic[_T_co, _P, _R_co]):
         """
         Initialize the inject_self descriptor.
 
-        :param function:    The function or method to wrap.
-        :param *args:       Positional arguments to pass when instantiating the target class.
-        :param **kwargs:    Keyword arguments to pass when instantiating the target class.
+        Args:
+            function: The function or method to wrap.
+            *args: Positional arguments to pass when instantiating the target class.
+            **kwargs: Keyword arguments to pass when instantiating the target class.
         """
         self._function = function
 
@@ -247,9 +252,12 @@ class _InjectSelfBase(Generic[_T_co, _P, _R_co]):
         """
         Handle logic when the descriptor is accessed from the class level.
 
-        :param owner:   The class object owning the descriptor.
-        :param kwargs:  Keyword arguments passed to the wrapped function.
-        :return:        A tuple of `(self_object, updated_kwargs)`.
+        Args:
+            owner: The class object owning the descriptor.
+            kwargs: Keyword arguments passed to the wrapped function.
+
+        Returns:
+            A tuple of `(self_object, updated_kwargs)`.
         """
         if isinstance(self, inject_self.cached):
             # Cached instance creation
@@ -403,8 +411,9 @@ class _InjectKwargsParamsBase(Generic[_T_co, _P, _R_co]):
         """
         Initialize the inject_kwargs_params descriptor.
 
-        :param function:    The target function or method whose parameters will be injected
-                            from the instance's `self.kwargs` mapping.
+        Args:
+            func: The target function or method whose parameters will be injected
+                from the instance's `self.kwargs` mapping.
         """
         self._function = func
         self._signature = None
@@ -541,9 +550,11 @@ class _ComplexHash[**P, R]:
         """
         Recursively hash every unhashable object in ``*args``.
 
-        :param *args:   Objects to be hashed.
+        Args:
+            *args: Objects to be hashed.
 
-        :return:        Hash of all the combined objects' hashes.
+        Returns:
+            Hash of all the combined objects' hashes.
         """
         values = list[str]()
 
@@ -587,11 +598,13 @@ def get_subclasses[T](family: type[T], exclude: Sequence[type[T]] = []) -> list[
     """
     Get all subclasses of a given type.
 
-    :param family:  "Main" type all other classes inherit from.
-    :param exclude: Excluded types from the yield. Note that they won't be excluded from search.
-                    For examples, subclasses of these excluded classes will be yield.
+    Args:
+        family: "Main" type all other classes inherit from.
+        exclude: Excluded types from the yield. Note that they won't be excluded from search. For examples, subclasses
+            of these excluded classes will be yield.
 
-    :return:        List of all subclasses of "family".
+    Returns:
+        List of all subclasses of "family".
     """
 
     def _subclasses(cls: type[T]) -> Iterator[type[T]]:
@@ -706,8 +719,9 @@ class classproperty(classproperty_base[_T, _R_co, _T_Any]):
             """
             Clear cached properties of an type instance.
 
-            :param type_:   The type whose cache should be cleared.
-            :param names:   Specific property names to clear. If None, all cached properties are cleared.
+            Args:
+                type_: The type whose cache should be cleared.
+                names: Specific property names to clear. If None, all cached properties are cleared.
             """
             if names is None:
                 with suppress(AttributeError):
@@ -805,8 +819,9 @@ class cachedproperty(property, Generic[_R_co, _T_Any]):
         """
         Clear cached properties of an object instance.
 
-        :param obj:   The object whose cache should be cleared.
-        :param names: Specific property names to clear. If None, all cached properties are cleared.
+        Args:
+            obj: The object whose cache should be cleared.
+            names: Specific property names to clear. If None, all cached properties are cleared.
         """
         if names is None:
             obj.__dict__.get(cls.cache_key, {}).clear()
@@ -825,9 +840,10 @@ class cachedproperty(property, Generic[_R_co, _T_Any]):
         """
         Update cached property of an object instance.
 
-        :param obj:   The object whose cache should be updated.
-        :param names: Property name to update.
-        :param value: The value to assign.
+        Args:
+            obj: The object whose cache should be updated.
+            name: Property name to update.
+            value: The value to assign.
         """
         obj.__dict__.setdefault(cls.cache_key, {})[name] = value
 

{jetpytools-2.2.0 → jetpytools-2.2.1}/jetpytools/utils/file.py

@@ -68,16 +68,18 @@ def check_perms(
     """
     Confirm whether the user has write/read access to a file.
 
-    :param file:                    Path to file.
-    :param mode:                    Read/Write mode.
-    :param func:                    Function that this was called from, only useful to *func writers.
+    Args:
+        file: Path to file.
+        mode: Read/Write mode.
+        func: Function that this was called from, only useful to *func writers.
 
     :param:                         True if the user has write/read access, else False.
 
-    :raises FileNotExistsError:     File could not be found.
-    :raises FilePermissionError:    User does not have access to the file.
-    :raises FileIsADirectoryError:  Given path is a directory, not a file.
-    :raises FileWasNotFoundError:   Parent directories exist, but the given file could not be found.
+    Raises:
+        FileNotExistsError: File could not be found.
+        FilePermissionError: User does not have access to the file.
+        FileIsADirectoryError: Given path is a directory, not a file.
+        FileWasNotFoundError: Parent directories exist, but the given file could not be found.
     """
 
     file = Path(str(file))

{jetpytools-2.2.0 → jetpytools-2.2.1}/jetpytools/utils/ranges.py

@@ -10,13 +10,15 @@ def interleave_arr[T0, T1](arr0: Iterable[T0], arr1: Iterable[T1], n: int = 2) -
     """
     Interleave two arrays of variable length.
 
-    :param arr0:    First array to be interleaved.
-    :param arr1:    Second array to be interleaved.
-    :param n:       The number of elements from arr0 to include in the interleaved sequence
-                    before including an element from arr1.
-
-    :yield:         Elements from either arr0 or arr01.
+    Args:
+        arr0: First array to be interleaved.
+        arr1: Second array to be interleaved.
+        n: The number of elements from arr0 to include in the interleaved sequence before including an element from
+            arr1.
+    Yields:
+        Elements from either arr0 or arr01.
     """
+
     if n <= 0:
         raise ValueError("n must be a positive integer")
 

{jetpytools-2.2.0 → jetpytools-2.2.1}/pyproject.toml

@@ -34,7 +34,7 @@ build-backend = "hatchling.build"
 [tool.hatch.version]
 source = "versioningit"
 default-version = "0.0.0+unknown"
-next-version = "minor-release"
+next-version = "minor"
 write = { file = "jetpytools/_version.py", template = "__version__ = \"{normalized_version}\"\n__version_tuple__ = {version_tuple}" }
 
 [tool.hatch.version.format]

jetpytools-2.2.0/jetpytools/_version.py

@@ -1,2 +0,0 @@
-__version__ = "2.2.0"
-__version_tuple__ = (2, 2, 0)