jetpytools 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

jetpytools/_metadata.py

@@ -1,6 +1,6 @@
 """Collection of stuff that's useful in general python programming"""
 
-__version__ = '1.4.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/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/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/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/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.4.0.dist-info → jetpytools-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetpytools
-Version: 1.4.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.4.0.dist-info → jetpytools-1.5.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 jetpytools/__init__.py,sha256=FSVZdj69oy4mBXd6OXiRHrUhaSc4Exo1pQHBlXycV98,214
-jetpytools/_metadata.py,sha256=v1lmWTzb06HMM9cWuvZNc6UWkUsfNUm_rmuwcgdFavs,414
+jetpytools/_metadata.py,sha256=fESIm2gU509vtKESX3rl2qKEyN-tUKshySopOq_jWVc,414
 jetpytools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jetpytools/enums/__init__.py,sha256=5n6Cu8Yb9N6hIa_YTsyy_s0cCgCnh0vDb-NyXK2RwV0,81
 jetpytools/enums/base.py,sha256=m3jJ6rJwDm4vp2-qMsuRH-Ll2mQDXA-wkmhw4xaafTM,2003
@@ -11,13 +11,13 @@ jetpytools/exceptions/file.py,sha256=QwhUFAoG3NsFFYuPe5O_I6K969CzlrTCv3RTrfzx8B0
 jetpytools/exceptions/generic.py,sha256=kMj5lR3ifHk3uNhpxN6Lu4Am0vi7E6TfQezkZulqhaQ,1482
 jetpytools/exceptions/module.py,sha256=drkcpa8hcE7Ee20N15j3qsX_grl8a3Jjv10XJ3xtDmE,1207
 jetpytools/functions/__init__.py,sha256=CeDfQrPCYqjiXyCoZ6jcbfM2d7KmRM11lBSxUK2wl4g,127
-jetpytools/functions/funcs.py,sha256=EMoJ_h2tl8Cgr1PXAsmRvgaOY5YL7AiEnGGo3-H76tk,3797
-jetpytools/functions/normalize.py,sha256=2BACok7TAN5ldANyYrbGhUpOkj84siApAYy6ndlhUfI,6316
+jetpytools/functions/funcs.py,sha256=ZciVD2WbMo-21IzLkAjxv0WNnmikgIgTQ9O96JUzpa8,5359
+jetpytools/functions/normalize.py,sha256=acn13f_yt6zKhkSFNxiS_4ZQ6Dy4tm1iBhobLS2KpTY,8654
 jetpytools/functions/other.py,sha256=TRz91spvdYJUh9vKe3Kuw6xZfSEJvrQs1mZVg7SyYmY,413
 jetpytools/types/__init__.py,sha256=yDT-PYTTzH6DyHsQcKvOy1jrCPmUQRKrjCM3apd0kNw,294
 jetpytools/types/builtins.py,sha256=hndNUoxBeFx9kgSj-6Lm8rjQH0a9lkrqRqPDObr0pbk,1969
 jetpytools/types/check.py,sha256=Ivf_JkVLG9OgiKXYjq-8azoROLjJvhNNqPq_KDIiOkI,971
-jetpytools/types/file.py,sha256=j46SCbdhus2wtxddAGSCn6V4nJdWWwpnAfW1K3P3ewg,6205
+jetpytools/types/file.py,sha256=PpeKPVKu6NDZexmy-3UeCVIdaPPwMUkhhgtaezG20H4,6349
 jetpytools/types/funcs.py,sha256=9qONnDWdpqvRj7vL3W9BLwWeGyQipXQgxOaPjqpQ1M4,3119
 jetpytools/types/generic.py,sha256=sAyBwGVG5FZ-6HVpfRuczov_6zQ_Uyoi0QWnR2iMm9Q,1128
 jetpytools/types/supports.py,sha256=--VZ-iCUiv-a6K8n-H8-6hSxHjrvdYg9mCLhr_lRplo,3051
@@ -25,10 +25,10 @@ jetpytools/types/utils.py,sha256=eT3yoFUEQy4vKTyLDMp_6Ixy7woyF4afWgiLhS-Vr38,210
 jetpytools/utils/__init__.py,sha256=v5Bkl43-OBWlXx9OWpZoGH-QMaYNsPIi4vfuhC13ZLI,163
 jetpytools/utils/file.py,sha256=9GhMGJ5D7CpvUFnvnwPFMloYTeIX-AJ7aKYKdoJQ374,10455
 jetpytools/utils/funcs.py,sha256=ZuLz63kveBY1CLlBexEqmrQiGC67dY4gaXdNU3CeBMw,898
-jetpytools/utils/math.py,sha256=lNTriLtTXgqN82DVSXJ5KUbhsWgxXoJ5eNGIZ0-_r_c,3335
+jetpytools/utils/math.py,sha256=r60dD7tWx3cgMEdPQDfvRH48JMKhf_XK0xA1kpnfQi4,3353
 jetpytools/utils/ranges.py,sha256=dL3WG235Pz9sk5su8A0VdwVf_oSt6obR7R_JNwLyCjQ,2572
-jetpytools-1.4.0.dist-info/licenses/LICENSE,sha256=l0PN-qDtXcgOB5aXP_nSUsvCK5V3o9pQCGsTzyZhKL0,1071
-jetpytools-1.4.0.dist-info/METADATA,sha256=vNcju4cgq0KyWoml7dd6q6QWq8KCvUIQT-DciIXtYe8,1485
-jetpytools-1.4.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-jetpytools-1.4.0.dist-info/top_level.txt,sha256=Iy4HjIta33ADJxN9Nyt5t5jRIfotEkZkQcOSw4eG8Cs,11
-jetpytools-1.4.0.dist-info/RECORD,,
+jetpytools-1.5.0.dist-info/licenses/LICENSE,sha256=l0PN-qDtXcgOB5aXP_nSUsvCK5V3o9pQCGsTzyZhKL0,1071
+jetpytools-1.5.0.dist-info/METADATA,sha256=SvNo1h_KF5ng6ZkVQlaagXRiRmPVarF8l1OtQ80rvNM,1485
+jetpytools-1.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jetpytools-1.5.0.dist-info/top_level.txt,sha256=Iy4HjIta33ADJxN9Nyt5t5jRIfotEkZkQcOSw4eG8Cs,11
+jetpytools-1.5.0.dist-info/RECORD,,

{jetpytools-1.4.0.dist-info → jetpytools-1.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any