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

jetpytools/functions/normalize.py

@@ -1,33 +1,32 @@
 from __future__ import annotations
 
-from fractions import Fraction
 import sys
+from fractions import Fraction
 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
+from ..types import SoftRange, SoftRangeN, SoftRangesN, StrictRange, SupportsString, T, is_soft_range_n
 
 __all__ = [
-    'normalize_seq',
-    'to_arr',
-    'flatten',
-    'normalize_list_to_ranges',
-    'normalize_ranges_to_list',
-    'normalize_range',
-    'normalize_ranges',
-    'invert_ranges',
-    'norm_func_name', 'norm_display_name'
+    "flatten",
+    "invert_ranges",
+    "norm_display_name",
+    "norm_func_name",
+    "normalize_list_to_ranges",
+    "normalize_range",
+    "normalize_ranges",
+    "normalize_ranges_to_list",
+    "normalize_seq",
+    "to_arr",
 ]
 
 
 @overload
-def normalize_seq(val: T | Sequence[T], length: int) -> list[T]:
-    ...
+def normalize_seq(val: T | Sequence[T], length: int) -> list[T]: ...
 
 
 @overload
-def normalize_seq(val: Any, length: int) -> list[Any]:
-    ...
+def normalize_seq(val: Any, length: int) -> list[Any]: ...
 
 
 def normalize_seq(val: T | Sequence[T], length: int) -> list[T]:
@@ -50,13 +49,11 @@ def normalize_seq(val: T | Sequence[T], length: int) -> list[T]:
 
 
 @overload
-def to_arr(val: T | Iterable[T]) -> list[T]:
-    ...
+def to_arr(val: T | Iterable[T]) -> list[T]: ...
 
 
 @overload
-def to_arr(val: Any) -> list[Any]:
-    ...
+def to_arr(val: Any) -> list[Any]: ...
 
 
 def to_arr(val: Any, *, sub: Any = []) -> list[Any]:
@@ -66,19 +63,18 @@ def to_arr(val: Any, *, sub: Any = []) -> list[Any]:
     """
     if sub:
         import warnings
+
         warnings.warn("sub is deprecated.", DeprecationWarning)
 
     return list(val) if (isinstance(val, Iterable) and not isinstance(val, (str, bytes))) else [val]
 
 
 @overload
-def flatten(items: Iterable[Iterable[T]]) -> Iterator[T]:
-    ...
+def flatten(items: Iterable[Iterable[T]]) -> Iterator[T]: ...
 
 
 @overload
-def flatten(items: Iterable[Any]) -> Iterator[Any]:
-    ...
+def flatten(items: Iterable[Any]) -> Iterator[Any]: ...
 
 
 def flatten(items: Any) -> Iterator[Any]:
@@ -125,10 +121,9 @@ def normalize_list_to_ranges(flist: Iterable[int], min_length: int = 0, exclusiv
     prev_n = -1
 
     for n in sorted(set(flist)):
-        if prev_n + 1 != n:
-            if flist3:
-                flist2.append(flist3)
-                flist3 = []
+        if prev_n + 1 != n and flist3:
+            flist2.append(flist3)
+            flist3.clear()
         flist3.append(n)
         prev_n = n
 
@@ -137,10 +132,7 @@ def normalize_list_to_ranges(flist: Iterable[int], min_length: int = 0, exclusiv
 
     flist4 = [i for i in flist2 if len(i) > min_length]
 
-    return list(zip(
-        [i[0] for i in flist4],
-        [i[-1] + exclusive for i in flist4]
-    ))
+    return list(zip([i[0] for i in flist4], [i[-1] + exclusive for i in flist4]))
 
 
 def normalize_ranges_to_list(ranges: Iterable[SoftRange], exclusive: bool = False) -> list[int]:
@@ -153,11 +145,7 @@ def normalize_ranges_to_list(ranges: Iterable[SoftRange], exclusive: bool = Fals
 
 
 def normalize_ranges(
-    ranges: SoftRangeN | SoftRangesN,
-    length: int,
-    exclusive: bool = False,
-    *,
-    strict: bool = True
+    ranges: SoftRangeN | SoftRangesN, length: int, exclusive: bool = False, *, strict: bool = True
 ) -> list[StrictRange]:
     """
     Normalize ranges to a list of positive ranges.
@@ -216,11 +204,13 @@ def normalize_ranges(
         # 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),
-        ]):
+        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
             )
@@ -231,14 +221,14 @@ def normalize_ranges(
             if start < 0:
                 exception = CustomOverflowError(
                     f"Start frame `{start}` in range `{r}` with length `{length}` could not be normalized!",
-                    normalize_ranges
+                    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
+                    normalize_ranges,
                 )
                 exceptions.append(exception)
                 continue
@@ -255,8 +245,7 @@ def normalize_ranges(
         raise Exception(exceptions)
 
     return normalize_list_to_ranges(
-        [x for start, end in out for x in range(start, end + (not exclusive))],
-        exclusive=exclusive
+        [x for start, end in out for x in range(start, end + (not exclusive))], exclusive=exclusive
     )
 
 
@@ -281,15 +270,14 @@ def norm_func_name(func_name: SupportsString | Callable[..., Any]) -> str:
 
     func = func_name
 
-    if hasattr(func_name, '__name__'):
+    if hasattr(func_name, "__name__"):
         func_name = func.__name__
-    elif hasattr(func_name, '__qualname__'):
+    elif hasattr(func_name, "__qualname__"):
         func_name = func.__qualname__
 
-    if callable(func):
-        if hasattr(func, '__self__'):
-            func = func.__self__ if isinstance(func.__self__, type) else func.__self__.__class__
-            func_name = f'{func.__name__}.{func_name}'
+    if callable(func) and hasattr(func, "__self__"):
+        func = func.__self__ if isinstance(func.__self__, type) else func.__self__.__class__
+        func_name = f"{func.__name__}.{func_name}"
 
     return str(func_name).strip()
 
@@ -298,12 +286,12 @@ def norm_display_name(obj: object) -> str:
     """Get a fancy name from any object."""
 
     if isinstance(obj, Iterator):
-        return ', '.join(norm_display_name(v) for v in obj).strip()
+        return ", ".join(norm_display_name(v) for v in obj).strip()
 
     if isinstance(obj, Fraction):
-        return f'{obj.numerator}/{obj.denominator}'
+        return f"{obj.numerator}/{obj.denominator}"
 
     if isinstance(obj, dict):
-        return '(' + ', '.join(f'{k}={v}' for k, v in obj.items()) + ')'
+        return "(" + ", ".join(f"{k}={v}" for k, v in obj.items()) + ")"
 
     return norm_func_name(obj)

jetpytools/functions/other.py

@@ -2,9 +2,7 @@ from __future__ import annotations
 
 from typing import Any
 
-__all__ = [
-    'deepmerge'
-]
+__all__ = ["deepmerge"]
 
 
 def deepmerge(source: dict[Any, Any], destination: dict[Any, Any]) -> dict[Any, Any]:

jetpytools/types/__init__.py

@@ -1,7 +1,7 @@
-from .builtins import *  # noqa: F401, F403
-from .check import *  # noqa: F401, F403
-from .file import *  # noqa: F401, F403
-from .funcs import *  # noqa: F401, F403
-from .generic import *  # noqa: F401, F403
-from .supports import *  # noqa: F401, F403
-from .utils import *  # noqa: F401, F403
+from .builtins import *
+from .check import *
+from .file import *
+from .funcs import *
+from .generic import *
+from .supports import *
+from .utils import *

jetpytools/types/builtins.py

@@ -3,58 +3,77 @@ from __future__ import annotations
 from typing import Any, Callable, ParamSpec, Sequence, SupportsFloat, SupportsIndex, TypeAlias, TypeVar, Union
 
 __all__ = [
-    'T', 'T0', 'T1', 'T2', 'T_co', 'T0_co', 'T1_co', 'T_contra',
-
-    'F', 'F0', 'F1', 'F2',
-
-    'P', 'P0', 'P1', 'P2',
-    'R', 'R0', 'R1', 'R2', 'R_co', 'R0_co', 'R1_co', 'R_contra',
-
-    'Nb',
-
-    'StrictRange', 'SoftRange', 'SoftRangeN', 'SoftRangesN',
-
-    'SingleOrArr', 'SingleOrArrOpt',
-    'SingleOrSeq', 'SingleOrSeqOpt',
-
-    'SimpleByteData', 'SimpleByteDataArray',
-    'ByteData',
-
-    'KwargsT'
+    "F0",
+    "F1",
+    "F2",
+    "P0",
+    "P1",
+    "P2",
+    "R0",
+    "R1",
+    "R2",
+    "T0",
+    "T1",
+    "T2",
+    "ByteData",
+    "F",
+    "KwargsT",
+    "Nb",
+    "P",
+    "R",
+    "R0_co",
+    "R1_co",
+    "R_co",
+    "R_contra",
+    "SimpleByteData",
+    "SimpleByteDataArray",
+    "SingleOrArr",
+    "SingleOrArrOpt",
+    "SingleOrSeq",
+    "SingleOrSeqOpt",
+    "SoftRange",
+    "SoftRangeN",
+    "SoftRangesN",
+    "StrictRange",
+    "T",
+    "T0_co",
+    "T1_co",
+    "T_co",
+    "T_contra",
 ]
 
-Nb = TypeVar('Nb', float, int)
+Nb = TypeVar("Nb", float, int)
 
-T = TypeVar('T')
-T0 = TypeVar('T0')
-T1 = TypeVar('T1')
-T2 = TypeVar('T2')
+T = TypeVar("T")
+T0 = TypeVar("T0")
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
 
-F = TypeVar('F', bound=Callable[..., Any])
-F0 = TypeVar('F0', bound=Callable[..., Any])
-F1 = TypeVar('F1', bound=Callable[..., Any])
-F2 = TypeVar('F2', bound=Callable[..., Any])
+F = TypeVar("F", bound=Callable[..., Any])
+F0 = TypeVar("F0", bound=Callable[..., Any])
+F1 = TypeVar("F1", bound=Callable[..., Any])
+F2 = TypeVar("F2", bound=Callable[..., Any])
 
-P = ParamSpec('P')
-P0 = ParamSpec('P0')
-P1 = ParamSpec('P1')
-P2 = ParamSpec('P2')
+P = ParamSpec("P")
+P0 = ParamSpec("P0")
+P1 = ParamSpec("P1")
+P2 = ParamSpec("P2")
 
-R = TypeVar('R')
-R0 = TypeVar('R0')
-R1 = TypeVar('R1')
-R2 = TypeVar('R2')
+R = TypeVar("R")
+R0 = TypeVar("R0")
+R1 = TypeVar("R1")
+R2 = TypeVar("R2")
 
-T_co = TypeVar('T_co', covariant=True)
-T0_co = TypeVar('T0_co', covariant=True)
-T1_co = TypeVar('T1_co', covariant=True)
+T_co = TypeVar("T_co", covariant=True)
+T0_co = TypeVar("T0_co", covariant=True)
+T1_co = TypeVar("T1_co", covariant=True)
 
-R_co = TypeVar('R_co', covariant=True)
-R0_co = TypeVar('R0_co', covariant=True)
-R1_co = TypeVar('R1_co', covariant=True)
+R_co = TypeVar("R_co", covariant=True)
+R0_co = TypeVar("R0_co", covariant=True)
+R1_co = TypeVar("R1_co", covariant=True)
 
-T_contra = TypeVar('T_contra', contravariant=True)
-R_contra = TypeVar('R_contra', contravariant=True)
+T_contra = TypeVar("T_contra", contravariant=True)
+R_contra = TypeVar("R_contra", contravariant=True)
 
 StrictRange: TypeAlias = tuple[int, int]
 SoftRange: TypeAlias = int | StrictRange | Sequence[int]

jetpytools/types/check.py

@@ -4,9 +4,7 @@ from typing_extensions import TypeIs
 
 from .builtins import SoftRange, SoftRangeN, SoftRangesN, StrictRange
 
-__all__ = [
-    "is_strict_range", "is_soft_range", "is_soft_range_n", "is_soft_ranges_n"
-]
+__all__ = ["is_soft_range", "is_soft_range_n", "is_soft_ranges_n", "is_strict_range"]
 
 
 def is_strict_range(val: Any) -> TypeIs[StrictRange]:
@@ -14,8 +12,10 @@ def is_strict_range(val: Any) -> TypeIs[StrictRange]:
 
 
 def is_soft_range(val: Any) -> TypeIs[SoftRange]:
-    return isinstance(val, int) or is_strict_range(val) or (
-        isinstance(val, Sequence) and all(isinstance(x, int) for x in val)
+    return (
+        isinstance(val, int)
+        or is_strict_range(val)
+        or (isinstance(val, Sequence) and all(isinstance(x, int) for x in val))
     )
 
 
@@ -28,7 +28,4 @@ def is_soft_range_n(val: Any) -> TypeIs[SoftRangeN]:
 
 
 def is_soft_ranges_n(val: Any) -> TypeIs[SoftRangesN]:
-    return (
-        isinstance(val, Sequence)
-        and all(is_soft_range_n(x) for x in val)
-    )
+    return isinstance(val, Sequence) and all(is_soft_range_n(x) for x in val)

jetpytools/types/file.py

@@ -7,22 +7,22 @@ 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',
+from typing_extensions import Self
 
-    'OpenTextMode',
-    'OpenBinaryMode',
-
-    'SPath', 'SPathLike'
+__all__ = [
+    "FileDescriptor",
+    "FileOpener",
+    "FilePathType",
+    "OpenBinaryMode",
+    "OpenBinaryModeReading",
+    "OpenBinaryModeUpdating",
+    "OpenBinaryModeWriting",
+    "OpenTextMode",
+    "OpenTextModeReading",
+    "OpenTextModeUpdating",
+    "OpenTextModeWriting",
+    "SPath",
+    "SPathLike",
 ]
 
 
@@ -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
@@ -65,8 +109,8 @@ class SPath(Path):
         _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."""
@@ -102,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
@@ -150,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):
@@ -172,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)
@@ -189,12 +231,13 @@ 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."""

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: