jetpytools 2.2.0__tar.gz → 2.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetpytools
-Version: 2.2.0
+Version: 2.2.2
 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.2}/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.2/jetpytools/_version.py

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

{jetpytools-2.2.0 → jetpytools-2.2.2}/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
 
@@ -68,7 +71,7 @@ class CustomEnum(Enum):
             var_name=var_name,
             enum_name=cls,
             value=value,
-            readable_enum=(f"{name} ({value!r})" for name, value in cls.__members__.items()),
+            readable_enum=(f"{name} ({value!s})" for name, value in cls.__members__.items()),
             reason=value,
         ) from None
 

{jetpytools-2.2.0 → jetpytools-2.2.2}/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.2}/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.2}/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.2}/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.2}/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.2}/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.2}/jetpytools/types/file.py

@@ -132,7 +132,7 @@ class SPath(Path):
         import shutil
 
         try:
-            return shutil.rmtree(str(self.get_folder()), ignore_errors)
+            return shutil.rmtree(self.get_folder(), ignore_errors)
         except FileNotFoundError:
             if not missing_ok:
                 raise
@@ -161,9 +161,11 @@ class SPath(Path):
 
         return self.is_dir() and not any(self.iterdir())
 
-    def move_dir(self, dst: SPath, *, mode: int = 0o777) -> None:
+    def move_dir(self, dst: SPathLike, *, mode: int = 0o777) -> None:
         """Move the directory to the specified destination."""
 
+        dst = SPath(dst)
+
         dst.mkdir(mode, True, True)
 
         for file in listdir(self):
@@ -177,21 +179,22 @@ class SPath(Path):
 
         self.rmdir()
 
-    def copy_dir(self, dst: SPath) -> SPath:
+    def copy_dir(self, dst: SPathLike) -> SPath:
         """Copy the directory to the specified destination."""
+        import shutil
 
         if not self.is_dir():
             from ..exceptions import PathIsNotADirectoryError
 
             raise PathIsNotADirectoryError('The given path, "{self}" is not a directory!', self.copy_dir)
 
-        dst.mkdirp()
+        dst = SPath(dst)
 
-        import shutil
+        dst.mkdirp()
 
         shutil.copytree(self, dst, dirs_exist_ok=True)
 
-        return SPath(dst)
+        return dst
 
     def lglob(self, pattern: str = "*") -> list[SPath]:
         """Glob the path and return the list of paths."""
@@ -209,17 +212,16 @@ class SPath(Path):
 
         return None
 
-    def find_newest_file(self, pattern: str = "*") -> SPath | None:
+    def find_newest_file(
+        self, pattern: str = "*", *, case_sensitive: bool | None = None, recurse_symlinks: bool = False
+    ) -> SPath | None:
         """Find the most recently modified file matching the given pattern in the directory."""
 
-        matching_files = self.get_folder().glob(pattern)
-
-        try:
-            next(matching_files)
-        except StopIteration:
-            return None
-
-        return max(matching_files, key=lambda p: p.stat().st_mtime)
+        return max(
+            self.get_folder().glob(pattern, case_sensitive=case_sensitive, recurse_symlinks=recurse_symlinks),
+            key=lambda p: p.stat().st_mtime,
+            default=None,
+        )
 
     def get_size(self) -> int:
         """Get the size of the file or directory in bytes."""

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

@@ -3,6 +3,7 @@ from __future__ import annotations
 import sys
 from contextlib import suppress
 from functools import wraps
+from threading import Lock
 from types import LambdaType
 from typing import (
     TYPE_CHECKING,
@@ -114,9 +115,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]
 
@@ -152,7 +157,7 @@ _P0 = ParamSpec("_P0")
 _P1 = ParamSpec("_P1")
 
 
-class _InjectedSelfFunc(Protocol[_T_co, _P, _R_co]):
+class _InjectedSelfFunc(Protocol[_T_co, _P, _R_co]):  # type: ignore[misc]
     """
     Protocol defining the callable interface for wrapped functions under `inject_self`.
 
@@ -188,9 +193,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 +253,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 +412,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 +551,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 +599,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 +720,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 +820,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 +841,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
 
@@ -842,6 +859,8 @@ class KwargsNotNone(KwargsT):
 
 class SingletonMeta(type):
     _instances: ClassVar[dict[SingletonMeta, Any]] = {}
+    _lock = Lock()
+
     _singleton_init: bool
 
     def __new__[MetaSelf: SingletonMeta](
@@ -860,12 +879,16 @@ class SingletonMeta(type):
     if not TYPE_CHECKING:
 
         def __call__(cls, *args: Any, **kwargs: Any) -> Any:
-            if cls not in cls._instances:
-                cls._instances[cls] = obj = super().__call__(*args, **kwargs)
-                return obj
+            if cls in cls._instances and not cls._singleton_init:
+                return cls._instances[cls]
+
+            with cls._lock:
+                if cls not in cls._instances:
+                    cls._instances[cls] = obj = super().__call__(*args, **kwargs)
+                    return obj
 
-            if cls._singleton_init:
-                cls._instances[cls].__init__(*args, **kwargs)
+                if cls._singleton_init:
+                    cls._instances[cls].__init__(*args, **kwargs)
 
             return cls._instances[cls]
 

{jetpytools-2.2.0 → jetpytools-2.2.2}/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.2}/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.2}/pyproject.toml

@@ -25,7 +25,7 @@ dependencies = ["typing_extensions>=4.15.0; python_version<'3.13'"]
 "Contact" = "https://discord.gg/XTpc6Fa9eB"
 
 [dependency-groups]
-dev = ["mypy~=1.18.0", "ruff~=0.14.0", "pytest>=9.0.0, <10.0.0", "twine>=6.2.0"]
+dev = ["mypy~=1.19.0", "ruff~=0.14.0", "pytest>=9.0.0, <10.0.0", "twine>=6.2.0"]
 
 [build-system]
 requires = ["hatchling>=1.27.0", "versioningit"]
@@ -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)