jetpytools 1.3.0__tar.gz → 1.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetpytools
-Version: 1.3.0
+Version: 1.5.0
 Summary: Collection of stuff that's useful in general python programming
 Author: Jaded Encoding Thaumaturgy
 Author-email: jaded.encoding.thaumaturgy@gmail.com

{jetpytools-1.3.0 → jetpytools-1.5.0}/jetpytools/_metadata.py

@@ -1,6 +1,6 @@
 """Collection of stuff that's useful in general python programming"""
 
-__version__ = '1.3.0'
+__version__ = '1.5.0'
 
 __author_name__, __author_email__ = 'Jaded Encoding Thaumaturgy', 'jaded.encoding.thaumaturgy@gmail.com'
 __maintainer_name__, __maintainer_email__ = __author_name__, __author_email__

{jetpytools-1.3.0 → jetpytools-1.5.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.3.0 → jetpytools-1.5.0}/jetpytools/functions/funcs.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 from typing import Any, Callable, Concatenate, overload
+from inspect import signature
 
-from ..exceptions import CustomRuntimeError
+from ..exceptions import CustomRuntimeError, CustomValueError
 from ..types import MISSING, KwargsT, MissingT, P, R, T
 
 __all__ = [
-    'iterate', 'fallback', 'kwargs_fallback'
+    'iterate', 'fallback', 'kwargs_fallback', 'filter_kwargs'
 ]
 
 
@@ -150,3 +151,46 @@ def kwargs_fallback(  # type: ignore
     """Utility function to return a fallback value from kwargs if value was not found or is None."""
 
     return fallback(value, kwargs[0].get(kwargs[1], None), *fallbacks, default=default)
+
+
+@overload
+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: dict[str, Any] | None = None, **kw: Any) -> dict[str, Any]:
+    """
+    Filter kwargs to only include parameters that match the callable's signature, ignoring **kwargs.
+
+    Examples:
+
+        >>> 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).
+
+    :return:            A dictionary containing only the kwargs that match the callable's parameters.
+    """
+
+    if not (filtered_kwargs := fallback(kwargs, kw)):
+        return {}
+
+    try:
+        sig = signature(func)
+    except Exception as e:
+        raise CustomValueError(e.args[0], filter_kwargs, func) from e
+
+    param_names = {name for name, param in sig.parameters.items() if param.kind != param.VAR_KEYWORD}
+
+    return {name: value for name, value in filtered_kwargs.items() if name in param_names}

{jetpytools-1.3.0 → jetpytools-1.5.0}/jetpytools/functions/normalize.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 from fractions import Fraction
+import sys
 from typing import Any, Callable, Iterable, Iterator, Sequence, overload
 
 from ..types import SoftRange, SoftRangeN, SoftRangesN, StrictRange, SupportsString, T, is_soft_range_n
+from ..exceptions import CustomOverflowError
 
 __all__ = [
     'normalize_seq',
@@ -93,11 +95,13 @@ def flatten(items: Any) -> Iterator[Any]:
             yield val
 
 
-def normalize_range(ranges: SoftRange, /) -> Iterable[int]:
+def normalize_range(ranges: SoftRange, /, exclusive: bool = False) -> Sequence[int]:
     """
     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.
 
     :return:            List of positive frame ranges.
     """
@@ -109,12 +113,12 @@ def normalize_range(ranges: SoftRange, /) -> Iterable[int]:
         start, stop = ranges
         step = -1 if stop < start else 1
 
-        return range(start, stop + step, step)
+        return range(start, stop + (not exclusive * step), step)
 
     return ranges
 
 
-def normalize_list_to_ranges(flist: Iterable[int], min_length: int = 0) -> list[StrictRange]:
+def normalize_list_to_ranges(flist: Iterable[int], min_length: int = 0, exclusive: bool = False) -> list[StrictRange]:
     flist2 = list[list[int]]()
     flist3 = list[int]()
 
@@ -135,20 +139,26 @@ def normalize_list_to_ranges(flist: Iterable[int], min_length: int = 0) -> list[
 
     return list(zip(
         [i[0] for i in flist4],
-        [i[-1] for j, i in enumerate(flist4)]
+        [i[-1] + exclusive for i in flist4]
     ))
 
 
-def normalize_ranges_to_list(ranges: Iterable[SoftRange]) -> list[int]:
+def normalize_ranges_to_list(ranges: Iterable[SoftRange], exclusive: bool = False) -> list[int]:
     out = list[int]()
 
     for srange in ranges:
-        out.extend(normalize_range(srange))
+        out.extend(normalize_range(srange, exclusive))
 
     return out
 
 
-def normalize_ranges(ranges: SoftRangeN | SoftRangesN, end: int) -> list[StrictRange]:
+def normalize_ranges(
+    ranges: SoftRangeN | SoftRangesN,
+    length: int,
+    exclusive: bool = False,
+    *,
+    strict: bool = True
+) -> list[StrictRange]:
     """
     Normalize ranges to a list of positive ranges.
 
@@ -160,57 +170,104 @@ def normalize_ranges(ranges: SoftRangeN | SoftRangesN, end: int) -> list[StrictR
 
     .. code-block:: python
 
-        >>> normalize_ranges((None, None), end=1000)
+        >>> normalize_ranges((None, None), length=1000)
         [(0, 999)]
-        >>> normalize_ranges((24, -24), end=1000)
+        >>> normalize_ranges((24, -24), length=1000)
         [(24, 975)]
-        >>> normalize_ranges([(24, 100), (80, 150)], end=1000)
+        >>> normalize_ranges([(24, 100), (80, 150)], length=1000)
         [(24, 150)]
 
 
-    :param franges:     Frame range or list of frame ranges.
-    :param end:         End number.
+    :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.
     """
+    from ..utils import clamp
 
     ranges = [ranges] if is_soft_range_n(ranges) else ranges
 
-    out = []
+    out = list[tuple[int, int]]()
+    exceptions = list[Exception]()
 
     for r in ranges:
         if r is None:
             r = (None, None)
 
         if isinstance(r, tuple):
-            start, endd = r
+            start, end = r
             if start is None:
                 start = 0
-            if endd is None:
-                endd = end - 1
+            if end is None:
+                end = length - (not exclusive)
         else:
             start = r
-            endd = r
+            end = r + exclusive
 
         if start < 0:
-            start = end - 1 + start
+            start = length + start
+
+        if end < 0:
+            end = length + end - (not exclusive)
+
+        # Always throws an error if start and end are negative
+        # or higher than length
+        # or start is higher than end (likely mismatched)
+        if any([
+            start < 0 and end < 0,
+            start >= length and end - (not exclusive) > length,
+            start >= end + (not exclusive),
+        ]):
+            exception = CustomOverflowError(
+                f"Range `{r}` with length `{length}` could not be normalized!", normalize_ranges
+            )
+            exceptions.append(exception)
+            continue
+
+        if strict:
+            if start < 0:
+                exception = CustomOverflowError(
+                    f"Start frame `{start}` in range `{r}` with length `{length}` could not be normalized!",
+                    normalize_ranges
+                )
+                exceptions.append(exception)
+                continue
+            if end - (not exclusive) > length:
+                exception = CustomOverflowError(
+                    f"End frame `{end}` in range `{r}` with length `{length}` could not be normalized!",
+                    normalize_ranges
+                )
+                exceptions.append(exception)
+                continue
+        else:
+            start = clamp(start, 0, length - 1)
+            end = clamp(end, int(exclusive), length - (not exclusive))
+
+        out.append((start, end))
 
-        if endd < 0:
-            endd = end - 1 + endd
+    if exceptions:
+        if sys.version_info >= (3, 11):
+            raise ExceptionGroup("Multiple exceptions occurred!", exceptions)  # noqa: F821
 
-        out.append((start, endd))
+        raise Exception(exceptions)
 
-    return normalize_list_to_ranges([
-        x for start, endd in out for x in range(start, endd + 1)
-    ])
+    return normalize_list_to_ranges(
+        [x for start, end in out for x in range(start, end + (not exclusive))],
+        exclusive=exclusive
+    )
 
 
-def invert_ranges(ranges: SoftRangeN | SoftRangesN, enda: int, endb: int | None) -> list[StrictRange]:
-    norm_ranges = normalize_ranges(ranges, enda if endb is None else endb)
+def invert_ranges(
+    ranges: SoftRangeN | SoftRangesN, lengtha: int, lengthb: int | None, exclusive: bool = False
+) -> list[StrictRange]:
+    norm_ranges = normalize_ranges(ranges, lengtha if lengthb is None else lengthb, exclusive)
 
-    b_frames = {*normalize_ranges_to_list(norm_ranges)}
+    b_frames = {*normalize_ranges_to_list(norm_ranges, exclusive)}
 
-    return normalize_list_to_ranges({*range(enda)} - b_frames)
+    return normalize_list_to_ranges({*range(lengtha)} - b_frames, exclusive=exclusive)
 
 
 def norm_func_name(func_name: SupportsString | Callable[..., Any]) -> str:

{jetpytools-1.3.0 → jetpytools-1.5.0}/jetpytools/types/file.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 import fnmatch
 import shutil
-
-from os import PathLike, listdir, path, walk
+from os import X_OK, PathLike, access, listdir, path, walk
 from pathlib import Path
 from sys import version_info
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, TypeAlias, Union
@@ -26,6 +25,7 @@ __all__ = [
     'SPath', 'SPathLike'
 ]
 
+
 FileDescriptor: TypeAlias = int
 
 FilePathType: TypeAlias = str | bytes | PathLike[str] | PathLike[bytes]
@@ -60,6 +60,7 @@ OpenBinaryMode: TypeAlias = OpenBinaryModeUpdating | OpenBinaryModeReading | Ope
 
 class SPath(Path):
     """Modified version of pathlib.Path"""
+
     if version_info < (3, 12):
         _flavour = type(Path())._flavour  # type: ignore
 
@@ -195,5 +196,10 @@ class SPath(Path):
 
         return sum(f.stat().st_size for f in self.rglob('*') if f.is_file())
 
+    def is_executable(self) -> bool:
+        """Check if the path is executable."""
+
+        return access(self.to_str(), X_OK)
+
 
 SPathLike = Union[str, PathLike[str], Path, SPath]

{jetpytools-1.3.0 → jetpytools-1.5.0}/jetpytools/types/utils.py

@@ -3,7 +3,6 @@ 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
@@ -411,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] | Callable[..., 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)  # type: ignore[call-arg]
+            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.3.0 → jetpytools-1.5.0}/jetpytools/utils/math.py

@@ -132,6 +132,8 @@ def spline_coeff(
                 for k in range(i, length + 1):
                     matrix[j][k] -= a * matrix[i][k]
 
+    i = 0
+
     for i in range(length + 1):
         if x >= px[i] and x <= px[i + 1]:
             break
@@ -148,7 +150,7 @@ def spline_coeff(
     s += (py[j] / h - h * matrix[j][length] / 6) * (x - px[i])
     s -= (py[i] / h - h * matrix[i][length] / 6) * (x - px[j])
 
-    return s
+    return float(s)
 
 
 def ndigits(num: Nb) -> int:

{jetpytools-1.3.0 → jetpytools-1.5.0}/jetpytools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetpytools
-Version: 1.3.0
+Version: 1.5.0
 Summary: Collection of stuff that's useful in general python programming
 Author: Jaded Encoding Thaumaturgy
 Author-email: jaded.encoding.thaumaturgy@gmail.com

{jetpytools-1.3.0 → jetpytools-1.5.0}/jetpytools.egg-info/SOURCES.txt

@@ -35,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.3.0 → jetpytools-1.5.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.5.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.5.0/tests/test_normalize.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+import sys
+
+import pytest
+
+from jetpytools import CustomOverflowError, normalize_ranges
+
+
+if sys.version_info < (3, 11):
+    ExceptionGroup = Exception
+
+
+def assert_excinfo_group_contains(
+    excinfo: pytest.ExceptionInfo, exception: type[Exception]  # type: ignore
+) -> None:
+    if sys.version_info < (3, 11):
+        assert isinstance(excinfo.value, Exception)
+    else:
+        assert excinfo.group_contains(exception)
+
+
+def test_normalize_ranges() -> None:
+    # Inclusive ranges
+    assert normalize_ranges((None, None), length=1000, exclusive=False) == [(0, 999)]
+    assert normalize_ranges((24, -24), length=1000, exclusive=False) == [(24, 975)]
+    assert normalize_ranges((-100, 950), length=1000, exclusive=False) == [(900, 950)]
+    assert normalize_ranges([(24, 100), (80, 150)], length=1000, exclusive=False) == [(24, 150)]
+    assert normalize_ranges([500], length=1000, exclusive=False) == [(500, 500)]
+
+    # Exclusive ranges
+    assert normalize_ranges((None, None), length=1000, exclusive=True) == [(0, 1000)]
+    assert normalize_ranges((24, -24), length=1000, exclusive=True) == [(24, 976)]
+    assert normalize_ranges((-100, 950), length=1000, exclusive=True) == [(900, 950)]
+    assert normalize_ranges([(24, 100), (80, 150)], length=1000, exclusive=True) == [(24, 150)]
+    assert normalize_ranges([500], length=1000, exclusive=True) == [(500, 501)]
+
+    # Overflow
+    with pytest.raises(ExceptionGroup) as excinfo:
+        normalize_ranges((500, 1500), length=1000)
+    assert_excinfo_group_contains(excinfo, CustomOverflowError)
+
+    with pytest.raises(ExceptionGroup) as excinfo:
+        normalize_ranges((-2000, 500), length=1000)
+    assert_excinfo_group_contains(excinfo, CustomOverflowError)
+
+    with pytest.raises(ExceptionGroup) as excinfo:
+        normalize_ranges((-2000, 2000), length=1000)
+    assert_excinfo_group_contains(excinfo, CustomOverflowError)
+
+    assert normalize_ranges((500, 1500), length=1000, exclusive=False, strict=False) == [(500, 999)]
+    assert normalize_ranges((500, 1500), length=1000, exclusive=True, strict=False) == [(500, 1000)]
+
+    assert normalize_ranges((-1500, 500), length=1000, exclusive=False, strict=False) == [(0, 500)]
+    assert normalize_ranges((-1500, 500), length=1000, exclusive=True, strict=False) == [(0, 500)]
+
+    assert normalize_ranges((-2000, 2000), length=1000, exclusive=False, strict=False) == [(0, 999)]
+    assert normalize_ranges((-2000, 2000), length=1000, exclusive=True, strict=False) == [(0, 1000)]
+
+    assert normalize_ranges((0, 0), length=1000, exclusive=False, strict=True) == [(0, 0)]
+
+    with pytest.raises(ExceptionGroup) as excinfo:
+        normalize_ranges((0, 0), length=1000, exclusive=True, strict=True)
+    assert_excinfo_group_contains(excinfo, CustomOverflowError)