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

jetpytools/types/file.py

@@ -2,30 +2,30 @@ 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
 
-__all__ = [
-    'FilePathType', 'FileDescriptor',
-    'FileOpener',
-
-    'OpenTextModeUpdating',
-    'OpenTextModeWriting',
-    'OpenTextModeReading',
-
-    'OpenBinaryModeUpdating',
-    'OpenBinaryModeWriting',
-    'OpenBinaryModeReading',
-
-    'OpenTextMode',
-    'OpenBinaryMode',
+from typing_extensions import Self
 
-    'SPath', 'SPathLike'
+__all__ = [
+    "FileDescriptor",
+    "FileOpener",
+    "FilePathType",
+    "OpenBinaryMode",
+    "OpenBinaryModeReading",
+    "OpenBinaryModeUpdating",
+    "OpenBinaryModeWriting",
+    "OpenTextMode",
+    "OpenTextModeReading",
+    "OpenTextModeUpdating",
+    "OpenTextModeWriting",
+    "SPath",
+    "SPathLike",
 ]
 
+
 FileDescriptor: TypeAlias = int
 
 FilePathType: TypeAlias = str | bytes | PathLike[str] | PathLike[bytes]
@@ -33,26 +33,70 @@ FilePathType: TypeAlias = str | bytes | PathLike[str] | PathLike[bytes]
 FileOpener: TypeAlias = Callable[[str, int], int]
 
 OpenTextModeUpdating: TypeAlias = Literal[
-    'r+', '+r', 'rt+', 'r+t', '+rt', 'tr+', 't+r', '+tr', 'w+', '+w', 'wt+', 'w+t', '+wt', 'tw+', 't+w', '+tw',
-    'a+', '+a', 'at+', 'a+t', '+at', 'ta+', 't+a', '+ta', 'x+', '+x', 'xt+', 'x+t', '+xt', 'tx+', 't+x', '+tx',
-]
-OpenTextModeWriting: TypeAlias = Literal[
-    'w', 'wt', 'tw', 'a', 'at', 'ta', 'x', 'xt', 'tx'
-]
-OpenTextModeReading: TypeAlias = Literal[
-    'r', 'rt', 'tr', 'U', 'rU', 'Ur', 'rtU', 'rUt', 'Urt', 'trU', 'tUr', 'Utr'
+    "r+",
+    "+r",
+    "rt+",
+    "r+t",
+    "+rt",
+    "tr+",
+    "t+r",
+    "+tr",
+    "w+",
+    "+w",
+    "wt+",
+    "w+t",
+    "+wt",
+    "tw+",
+    "t+w",
+    "+tw",
+    "a+",
+    "+a",
+    "at+",
+    "a+t",
+    "+at",
+    "ta+",
+    "t+a",
+    "+ta",
+    "x+",
+    "+x",
+    "xt+",
+    "x+t",
+    "+xt",
+    "tx+",
+    "t+x",
+    "+tx",
 ]
+OpenTextModeWriting: TypeAlias = Literal["w", "wt", "tw", "a", "at", "ta", "x", "xt", "tx"]
+OpenTextModeReading: TypeAlias = Literal["r", "rt", "tr", "U", "rU", "Ur", "rtU", "rUt", "Urt", "trU", "tUr", "Utr"]
 
 OpenBinaryModeUpdating: TypeAlias = Literal[
-    'rb+', 'r+b', '+rb', 'br+', 'b+r', '+br', 'wb+', 'w+b', '+wb', 'bw+', 'b+w', '+bw',
-    'ab+', 'a+b', '+ab', 'ba+', 'b+a', '+ba', 'xb+', 'x+b', '+xb', 'bx+', 'b+x', '+bx'
-]
-OpenBinaryModeWriting: TypeAlias = Literal[
-    'wb', 'bw', 'ab', 'ba', 'xb', 'bx'
-]
-OpenBinaryModeReading: TypeAlias = Literal[
-    'rb', 'br', 'rbU', 'rUb', 'Urb', 'brU', 'bUr', 'Ubr'
+    "rb+",
+    "r+b",
+    "+rb",
+    "br+",
+    "b+r",
+    "+br",
+    "wb+",
+    "w+b",
+    "+wb",
+    "bw+",
+    "b+w",
+    "+bw",
+    "ab+",
+    "a+b",
+    "+ab",
+    "ba+",
+    "b+a",
+    "+ba",
+    "xb+",
+    "x+b",
+    "+xb",
+    "bx+",
+    "b+x",
+    "+bx",
 ]
+OpenBinaryModeWriting: TypeAlias = Literal["wb", "bw", "ab", "ba", "xb", "bx"]
+OpenBinaryModeReading: TypeAlias = Literal["rb", "br", "rbU", "rUb", "Urb", "brU", "bUr", "Ubr"]
 
 OpenTextMode: TypeAlias = OpenTextModeUpdating | OpenTextModeWriting | OpenTextModeReading
 OpenBinaryMode: TypeAlias = OpenBinaryModeUpdating | OpenBinaryModeReading | OpenBinaryModeWriting
@@ -60,12 +104,13 @@ OpenBinaryMode: TypeAlias = OpenBinaryModeUpdating | OpenBinaryModeReading | Ope
 
 class SPath(Path):
     """Modified version of pathlib.Path"""
+
     if version_info < (3, 12):
         _flavour = type(Path())._flavour  # type: ignore
 
     if TYPE_CHECKING:
-        def __new__(cls, *args: SPathLike, **kwargs: Any) -> SPath:
-            ...
+
+        def __new__(cls, *args: SPathLike, **kwargs: Any) -> Self: ...
 
     def format(self, *args: Any, **kwargs: Any) -> SPath:
         """Format the path with the given arguments."""
@@ -101,22 +146,19 @@ class SPath(Path):
             if not missing_ok:
                 raise
 
-    def read_lines(
-        self, encoding: str | None = None, errors: str | None = None, keepends: bool = False
-    ) -> list[str]:
+    def read_lines(self, encoding: str | None = None, errors: str | None = None, keepends: bool = False) -> list[str]:
         """Read the file and return its lines."""
 
         return super().read_text(encoding, errors).splitlines(keepends)
 
     def write_lines(
-        self, data: Iterable[str], encoding: str | None = None,
-        errors: str | None = None, newline: str | None = None
+        self, data: Iterable[str], encoding: str | None = None, errors: str | None = None, newline: str | None = None
     ) -> int:
         """Open the file and write the given lines."""
 
-        return super().write_text('\n'.join(data), encoding, errors, newline)
+        return super().write_text("\n".join(data), encoding, errors, newline)
 
-    def append_to_stem(self, suffixes: str | Iterable[str], sep: str = '_') -> SPath:
+    def append_to_stem(self, suffixes: str | Iterable[str], sep: str = "_") -> SPath:
         """Append a suffix to the stem of the path"""
 
         from ..functions import to_arr
@@ -149,19 +191,20 @@ class SPath(Path):
 
         if not self.is_dir():
             from ..exceptions import PathIsNotADirectoryError
-            raise PathIsNotADirectoryError('The given path, \"{self}\" is not a directory!', self.copy_dir)
+
+            raise PathIsNotADirectoryError('The given path, "{self}" is not a directory!', self.copy_dir)
 
         dst.mkdirp()
         shutil.copytree(self, dst, dirs_exist_ok=True)
 
         return SPath(dst)
 
-    def lglob(self, pattern: str = '*') -> list[SPath]:
+    def lglob(self, pattern: str = "*") -> list[SPath]:
         """Glob the path and return the list of paths."""
 
         return list(map(SPath, self.glob(pattern)))
 
-    def fglob(self, pattern: str = '*') -> SPath | None:
+    def fglob(self, pattern: str = "*") -> SPath | None:
         """Glob the path and return the first match."""
 
         for root, dirs, files in walk(self):
@@ -171,7 +214,7 @@ class SPath(Path):
 
         return None
 
-    def find_newest_file(self, pattern: str = '*') -> SPath | None:
+    def find_newest_file(self, pattern: str = "*") -> SPath | None:
         """Find the most recently modified file matching the given pattern in the directory."""
 
         matching_files = self.get_folder().glob(pattern)
@@ -188,12 +231,18 @@ class SPath(Path):
 
         if not self.exists():
             from ..exceptions import FileNotExistsError
-            raise FileNotExistsError('The given path, \"{self}\" is not a file or directory!', self.get_size)
+
+            raise FileNotExistsError('The given path, "{self}" is not a file or directory!', self.get_size)
 
         if self.is_file():
             return self.stat().st_size
 
-        return sum(f.stat().st_size for f in self.rglob('*') if f.is_file())
+        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/types/funcs.py

@@ -1,34 +1,22 @@
 from __future__ import annotations
 
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, SupportsIndex, TypeAlias, overload
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, SupportsIndex, TypeAlias
 
 from typing_extensions import Self, TypeIs
 
 from .builtins import P, T
 from .supports import SupportsString
 
-__all__ = [
-    'StrList',
-    'Sentinel',
-    'SentinelT'
-]
+__all__ = ["Sentinel", "SentinelT", "StrList"]
 
 
 class StrList(list[SupportsString]):
     """Custom class for representing a recursively "stringable" list."""
 
     if TYPE_CHECKING:
-        @overload
-        def __init__(self, __iterable: Iterable[SupportsString | None] = []) -> None:
-            ...
 
-        @overload
-        def __init__(self, __iterable: Iterable[Iterable[SupportsString | None] | None] = []) -> None:
-            ...
-
-        def __init__(self, __iterable: Any = []) -> None:
-            ...
+        def __init__(self, iterable: Iterable[SupportsString | None] | None = ..., /) -> None: ...
 
     @property
     def string(self) -> str:
@@ -40,21 +28,16 @@ class StrList(list[SupportsString]):
     def __str__(self) -> str:
         from ..functions import flatten
 
-        return ' '.join(
-            filter(
-                None,
-                (str(x).strip() for x in flatten(self) if x is not None)
-            )
-        )
+        return " ".join(filter(None, (str(x).strip() for x in flatten(self) if x is not None)))
 
-    def __add__(self, __x: list[SupportsString]) -> StrList:  # type: ignore[override]
-        return StrList(super().__add__(__x))
+    def __add__(self, x: list[SupportsString]) -> StrList:  # type: ignore[override]
+        return StrList(super().__add__(x))
 
-    def __mul__(self, __n: SupportsIndex) -> StrList:
-        return StrList(super().__mul__(__n))
+    def __mul__(self, n: SupportsIndex) -> StrList:
+        return StrList(super().__mul__(n))
 
-    def __rmul__(self, __n: SupportsIndex) -> StrList:
-        return StrList(super().__rmul__(__n))
+    def __rmul__(self, n: SupportsIndex) -> StrList:
+        return StrList(super().__rmul__(n))
 
     @property
     def mlength(self) -> int:
@@ -98,7 +81,7 @@ class SentinelDispatcher:
             _sentinels[name] = SentinelDispatcher()
         return _sentinels[name]
 
-    def __setattr__(self, __name: str, __value: Any) -> None:
+    def __setattr__(self, name: str, value: Any) -> None:
         raise NameError
 
     def __call__(self) -> SentinelDispatcher:

jetpytools/types/generic.py

@@ -6,17 +6,7 @@ from typing import Any, Callable, Literal, TypeAlias, Union
 from .builtins import F, SingleOrArr, SingleOrArrOpt
 from .supports import SupportsString
 
-__all__ = [
-    'MissingT', 'MISSING',
-
-    'FuncExceptT',
-
-    'DataType',
-
-    'StrArr', 'StrArrOpt',
-
-    'PassthroughC'
-]
+__all__ = ["MISSING", "DataType", "FuncExceptT", "MissingT", "PassthroughC", "StrArr", "StrArrOpt"]
 
 
 class MissingTBase(Enum):

jetpytools/types/supports.py

@@ -2,126 +2,142 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from typing import (
-    Any, Callable, Iterable, Protocol, SupportsFloat, SupportsIndex, TypeAlias, TypeVar, overload, runtime_checkable
+    Any,
+    Callable,
+    Iterable,
+    Protocol,
+    SupportsFloat,
+    SupportsIndex,
+    TypeAlias,
+    TypeVar,
+    overload,
+    runtime_checkable,
 )
 
-from .builtins import T0, T1, T2, T_contra
+from .builtins import T0, T1, T2, T_co, T_contra
 
 __all__ = [
-    'SupportsTrunc',
+    "ComparatorFunc",
+    "SupportsAdd",
+    "SupportsAllComparisons",
+    "SupportsDunderGE",
+    "SupportsDunderGT",
+    "SupportsDunderLE",
+    "SupportsDunderLT",
+    "SupportsFloatOrIndex",
+    "SupportsIndexing",
+    "SupportsKeysAndGetItem",
+    "SupportsRAdd",
+    "SupportsRichComparison",
+    "SupportsRichComparisonT",
+    "SupportsString",
+    "SupportsSumNoDefaultT",
+    "SupportsTrunc",
+]
+
 
-    'SupportsString',
+_KT = TypeVar("_KT")
+_VT_co = TypeVar("_VT_co", covariant=True)
 
-    'SupportsDunderLT', 'SupportsDunderGT',
-    'SupportsDunderLE', 'SupportsDunderGE',
 
-    'SupportsFloatOrIndex',
+@runtime_checkable
+class SupportsAdd(Protocol[T_contra, T_co]):
+    def __add__(self, x: T_contra, /) -> T_co: ...
 
-    'SupportsIndexing',
-    'SupportsKeysAndGetItem',
 
-    'SupportsAllComparisons',
-    'SupportsRichComparison', 'SupportsRichComparisonT',
-    'ComparatorFunc'
-]
+@runtime_checkable
+class SupportsRAdd(Protocol[T_contra, T_co]):
+    def __radd__(self, x: T_contra, /) -> T_co: ...
+
 
+class _SupportsSumWithNoDefaultGiven(SupportsAdd[Any, Any], SupportsRAdd[int, Any], Protocol): ...
 
-_KT = TypeVar('_KT')
-_VT_co = TypeVar('_VT_co', covariant=True)
+
+SupportsSumNoDefaultT = TypeVar("SupportsSumNoDefaultT", bound=_SupportsSumWithNoDefaultGiven)
 
 
 @runtime_checkable
 class SupportsTrunc(Protocol):
-    def __trunc__(self) -> int:
-        ...
+    def __trunc__(self) -> int: ...
 
 
 @runtime_checkable
 class SupportsString(Protocol):
     @abstractmethod
-    def __str__(self) -> str:
-        ...
+    def __str__(self) -> str: ...
 
 
 @runtime_checkable
 class SupportsDunderLT(Protocol[T_contra]):
-    def __lt__(self, __other: T_contra) -> bool:
-        ...
+    def __lt__(self, other: T_contra) -> bool: ...
 
 
 @runtime_checkable
 class SupportsDunderGT(Protocol[T_contra]):
-    def __gt__(self, __other: T_contra) -> bool:
-        ...
+    def __gt__(self, other: T_contra) -> bool: ...
 
 
 @runtime_checkable
 class SupportsDunderLE(Protocol[T_contra]):
-    def __le__(self, __other: T_contra) -> bool:
-        ...
+    def __le__(self, other: T_contra) -> bool: ...
 
 
 @runtime_checkable
 class SupportsDunderGE(Protocol[T_contra]):
-    def __ge__(self, __other: T_contra) -> bool:
-        ...
+    def __ge__(self, other: T_contra) -> bool: ...
 
 
 @runtime_checkable
 class SupportsAllComparisons(
     SupportsDunderLT[Any], SupportsDunderGT[Any], SupportsDunderLE[Any], SupportsDunderGE[Any], Protocol
-):
-    ...
+): ...
 
 
 SupportsRichComparison: TypeAlias = SupportsDunderLT[Any] | SupportsDunderGT[Any]
-SupportsRichComparisonT = TypeVar('SupportsRichComparisonT', bound=SupportsRichComparison)
+SupportsRichComparisonT = TypeVar("SupportsRichComparisonT", bound=SupportsRichComparison)
 
 
 class ComparatorFunc(Protocol):
     @overload
     def __call__(
-        self, __arg1: SupportsRichComparisonT, __arg2: SupportsRichComparisonT,
-        *_args: SupportsRichComparisonT, key: None = ...
-    ) -> SupportsRichComparisonT:
-        ...
+        self,
+        arg1: SupportsRichComparisonT,
+        arg2: SupportsRichComparisonT,
+        /,
+        *args: SupportsRichComparisonT,
+        key: None = ...,
+    ) -> SupportsRichComparisonT: ...
 
     @overload
-    def __call__(self, __arg1: T0, __arg2: T0, *_args: T0, key: Callable[[T0], SupportsRichComparison]) -> T0:
-        ...
+    def __call__(self, arg1: T0, arg2: T0, /, *_args: T0, key: Callable[[T0], SupportsRichComparison]) -> T0: ...
 
     @overload
-    def __call__(self, __iterable: Iterable[SupportsRichComparisonT], *, key: None = ...) -> SupportsRichComparisonT:
-        ...
+    def __call__(
+        self, iterable: Iterable[SupportsRichComparisonT], /, *, key: None = ...
+    ) -> SupportsRichComparisonT: ...
 
     @overload
-    def __call__(self, __iterable: Iterable[T0], *, key: Callable[[T0], SupportsRichComparison]) -> T0:
-        ...
+    def __call__(self, iterable: Iterable[T0], /, *, key: Callable[[T0], SupportsRichComparison]) -> T0: ...
 
     @overload
     def __call__(
-        self, __iterable: Iterable[SupportsRichComparisonT], *, key: None = ..., default: T0
-    ) -> SupportsRichComparisonT | T0:
-        ...
+        self, iterable: Iterable[SupportsRichComparisonT], /, *, key: None = ..., default: T0
+    ) -> SupportsRichComparisonT | T0: ...
 
     @overload
     def __call__(
-        self, __iterable: Iterable[T1], *, key: Callable[[T1], SupportsRichComparison], default: T2
-    ) -> T1 | T2:
-        ...
+        self, iterable: Iterable[T1], /, *, key: Callable[[T1], SupportsRichComparison], default: T2
+    ) -> T1 | T2: ...
 
 
 class SupportsIndexing(Protocol[_VT_co]):
-    def __getitem__(self, __k: int) -> _VT_co:
-        ...
+    def __getitem__(self, k: int) -> _VT_co: ...
 
 
 class SupportsKeysAndGetItem(Protocol[_KT, _VT_co]):
-    def keys(self) -> Iterable[_KT]:
-        ...
+    def keys(self) -> Iterable[_KT]: ...
 
-    def __getitem__(self, __k: _KT) -> _VT_co:
-        ...
+    def __getitem__(self, k: _KT) -> _VT_co: ...
 
 
 SupportsFloatOrIndex: TypeAlias = SupportsFloat | SupportsIndex