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

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

jetpytools/types/utils.py

@@ -4,8 +4,21 @@ from functools import partial, wraps
 from inspect import Signature
 from inspect import _empty as empty_param
 from typing import (
-    TYPE_CHECKING, Any, Callable, Concatenate, Generator, Generic, Iterable, Iterator, Mapping, NoReturn, Protocol,
-    Sequence, TypeVar, cast, overload
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Concatenate,
+    Generator,
+    Generic,
+    Iterable,
+    Iterator,
+    Mapping,
+    NoReturn,
+    Protocol,
+    Sequence,
+    cast,
+    overload,
 )
 
 from typing_extensions import Self
@@ -13,29 +26,25 @@ from typing_extensions import Self
 from .builtins import F0, F1, P0, P1, R0, R1, T0, T1, T2, KwargsT, P, R, R0_co, R1_co, R_co, T, T0_co, T1_co, T_co
 
 __all__ = [
-    'copy_signature',
-
-    'inject_self',
-
-    'inject_kwargs_params',
-
-    'complex_hash',
-
-    'get_subclasses',
-
-    'classproperty', 'cachedproperty',
-
-    'KwargsNotNone',
-
-    'Singleton', 'to_singleton',
-
-    'LinearRangeLut'
+    "KwargsNotNone",
+    "LinearRangeLut",
+    "Singleton",
+    "cachedproperty",
+    "classproperty",
+    "complex_hash",
+    "copy_signature",
+    "get_subclasses",
+    "inject_kwargs_params",
+    "inject_self",
+    "to_singleton",
 ]
+# ruff: noqa: N801
 
 
 class copy_signature(Generic[F0]):
     """
-    Type util to copy the signature of one function to another function.\n
+    Type util to copy the signature of one function to another function.
+
     Especially useful for passthrough functions.
 
     .. code-block::
@@ -70,8 +79,7 @@ class copy_signature(Generic[F0]):
 class injected_self_func(Protocol[T_co, P, R_co]):
     @overload
     @staticmethod
-    def __call__(*args: P.args, **kwargs: P.kwargs) -> R_co:
-        ...
+    def __call__(*args: P.args, **kwargs: P.kwargs) -> R_co: ...
 
     @overload
     @staticmethod
@@ -80,8 +88,7 @@ class injected_self_func(Protocol[T_co, P, R_co]):
 
     @overload
     @staticmethod
-    def __call__(cls: type[T_co], *args: P.args, **kwargs: P.kwargs) -> R_co:
-        ...
+    def __call__(cls: type[T_co], *args: P.args, **kwargs: P.kwargs) -> R_co: ...
 
 
 self_objects_cache = dict[Any, Any]()
@@ -116,7 +123,9 @@ class inject_self_base(Generic[T_co, P, R_co]):
         self.clean_kwargs = False
 
     def __get__(
-        self, class_obj: type[T] | T | None, class_type: type[T] | type[type[T]] | Any  # type: ignore[valid-type]
+        self,
+        class_obj: type[T] | T | None,
+        class_type: type[T | type[T]] | Any,  # type: ignore[valid-type]
     ) -> injected_self_func[T_co, P, R_co]:
         if not self.signature or not self.first_key:
             self.signature = Signature.from_callable(self.function, eval_str=True)
@@ -127,25 +136,19 @@ class inject_self_base(Generic[T_co, P, R_co]):
 
                 if 4 not in {x.kind for x in self.signature.parameters.values()}:
                     raise CustomValueError(
-                        'This function hasn\'t got any kwargs!', 'inject_self.init_kwargs', self.function
+                        "This function hasn't got any kwargs!", "inject_self.init_kwargs", self.function
                     )
 
-                self.init_kwargs = list[str](
-                    k for k, x in self.signature.parameters.items() if x.kind != 4
-                )
+                self.init_kwargs = list[str](k for k, x in self.signature.parameters.items() if x.kind != 4)
 
         @wraps(self.function)
         def _wrapper(*args: Any, **kwargs: Any) -> Any:
-            first_arg = (args[0] if args else None) or (
-                kwargs.get(self.first_key, None) if self.first_key else None
-            )
+            first_arg = (args[0] if args else None) or (kwargs.get(self.first_key, None) if self.first_key else None)
 
-            if (
-                first_arg and (
-                    (is_obj := isinstance(first_arg, class_type))
-                    or isinstance(first_arg, type(class_type))
-                    or first_arg is class_type
-                )
+            if first_arg and (
+                (is_obj := isinstance(first_arg, class_type))
+                or isinstance(first_arg, type(class_type))
+                or first_arg is class_type
             ):
                 obj = first_arg if is_obj else first_arg()
                 if args:
@@ -169,7 +172,7 @@ class inject_self_base(Generic[T_co, P, R_co]):
             else:
                 obj = class_obj
 
-            return self.function(obj, *args, **kwargs)
+            return self.function(obj, *args, **kwargs)  # type: ignore
 
         return _wrapper
 
@@ -191,6 +194,7 @@ class inject_self_base(Generic[T_co, P, R_co]):
             inj.args = args
             inj.kwargs = kwargs
             return inj  # type: ignore
+
         return _wrapper
 
 
@@ -207,9 +211,7 @@ class inject_self(inject_self_base[T_co, P, R_co]):
             def __init__(self, function: Callable[[T1_co], R1_co]) -> None:
                 self.function = inject_self(function)
 
-            def __get__(
-                self, class_obj: type[T1_co] | T1_co | None, class_type: type[T1_co] | T1_co
-            ) -> R1_co:
+            def __get__(self, class_obj: type[T1_co] | T1_co | None, class_type: type[T1_co] | T1_co) -> R1_co:
                 return self.function.__get__(class_obj, class_type)()
 
     class init_kwargs(inject_self_base[T0_co, P0, R0_co]):
@@ -229,9 +231,7 @@ class inject_self(inject_self_base[T_co, P, R_co]):
         def __init__(self, function: Callable[[T0_co], R0_co]) -> None:
             self.function = inject_self(function)
 
-        def __get__(
-            self, class_obj: type[T0_co] | T0_co | None, class_type: type[T0_co] | T0_co
-        ) -> R0_co:
+        def __get__(self, class_obj: type[T0_co] | T0_co | None, class_type: type[T0_co] | T0_co) -> R0_co:
             return self.function.__get__(class_obj, class_type)()
 
 
@@ -243,16 +243,14 @@ class inject_kwargs_params_base_func(Generic[T_co, P, R_co]):
 class inject_kwargs_params_base(Generic[T_co, P, R_co]):
     signature: Signature | None
 
-    _kwargs_name = 'kwargs'
+    _kwargs_name = "kwargs"
 
     def __init__(self, function: Callable[Concatenate[T_co, P], R_co]) -> None:
         self.function = function
 
         self.signature = None
 
-    def __get__(
-        self, class_obj: T, class_type: type[T]
-    ) -> inject_kwargs_params_base_func[T_co, P, R_co]:
+    def __get__(self, class_obj: T, class_type: type[T]) -> inject_kwargs_params_base_func[T_co, P, R_co]:
         if not self.signature:
             self.signature = Signature.from_callable(self.function, eval_str=True)
 
@@ -263,7 +261,7 @@ class inject_kwargs_params_base(Generic[T_co, P, R_co]):
                 from ..exceptions import CustomValueError
 
                 raise CustomValueError(
-                    'This function hasn\'t got any kwargs!', 'inject_kwargs_params.add_to_kwargs', self.function
+                    "This function hasn't got any kwargs!", "inject_kwargs_params.add_to_kwargs", self.function
                 )
 
         this = self
@@ -329,21 +327,20 @@ class inject_kwargs_params_base(Generic[T_co, P, R_co]):
 
 
 if TYPE_CHECKING:  # love you mypy...
+
     class _add_to_kwargs:
-        def __call__(self, func: F1) -> F1:
-            ...
+        def __call__(self, func: F1) -> F1: ...
 
     class _inject_kwargs_params:
-        def __call__(self, func: F0) -> F0:
-            ...
+        def __call__(self, func: F0) -> F0: ...
 
         add_to_kwargs = _add_to_kwargs()
 
     inject_kwargs_params = _inject_kwargs_params()
 else:
+
     class inject_kwargs_params(Generic[T, P, R], inject_kwargs_params_base[T, P, R]):
-        class add_to_kwargs(Generic[T0, P0, R0], inject_kwargs_params_base[T0, P0, R0]):
-            ...
+        class add_to_kwargs(Generic[T0, P0, R0], inject_kwargs_params_base[T0, P0, R0]): ...
 
 
 class complex_hash(Generic[T]):
@@ -356,11 +353,7 @@ class complex_hash(Generic[T]):
     def __new__(cls, class_type: T) -> T:  # type: ignore
         class inner_class_type(class_type):  # type: ignore
             def __hash__(self) -> int:
-                return complex_hash.hash(
-                    self.__class__.__name__, *(
-                        getattr(self, key) for key in self.__annotations__.keys()
-                    )
-                )
+                return complex_hash.hash(self.__class__.__name__, *(getattr(self, key) for key in self.__annotations__))
 
         return inner_class_type  # type: ignore
 
@@ -379,14 +372,11 @@ class complex_hash(Generic[T]):
             try:
                 new_hash = hash(value)
             except TypeError:
-                if isinstance(value, Iterable):
-                    new_hash = complex_hash.hash(*value)
-                else:
-                    new_hash = hash(str(value))
+                new_hash = complex_hash.hash(*value) if isinstance(value, Iterable) else hash(str(value))
 
             values.append(str(new_hash))
 
-        return hash('_'.join(values))
+        return hash("_".join(values))
 
 
 def get_subclasses(family: type[T], exclude: Sequence[type[T]] = []) -> list[type[T]]:
@@ -436,27 +426,27 @@ class classproperty(Generic[T, R]):
 
         return func
 
-    def __get__(self, __obj: T | None, __type: type | None = None) -> R:
-        if __type is None:
-            __type = type(__obj)
+    def __get__(self, obj: T | None, type_: type | None = None) -> R:
+        if type_ is None:
+            type_ = type(obj)
 
-        return self.fget.__get__(__obj, __type)()
+        return self.fget.__get__(obj, type_)()
 
-    def __set__(self, __obj: T, __value: Any) -> None:
+    def __set__(self, obj: T, value: Any) -> None:
         if not self.fset:
             raise AttributeError(
-                f'classproperty with getter "{self.__name__}" of "{__obj.__class__.__name__}" object has no setter.'
+                f'classproperty with getter "{self.__name__}" of "{obj.__class__.__name__}" object has no setter.'
             )
 
-        self.fset.__get__(None, type(__obj))(__value)
+        self.fset.__get__(None, type(obj))(value)
 
-    def __delete__(self, __obj: T) -> None:
+    def __delete__(self, obj: T) -> None:
         if not self.fdel:
             raise AttributeError(
-                f'classproperty with getter "{self.__name__}" of "{__obj.__class__.__name__}" object has no deleter.'
+                f'classproperty with getter "{self.__name__}" of "{obj.__class__.__name__}" object has no deleter.'
             )
 
-        self.fdel.__get__(None, type(__obj))()
+        self.fdel.__get__(None, type(obj))()
 
     @property
     def __name__(self) -> str:
@@ -476,12 +466,13 @@ class cachedproperty(property, Generic[P, R_co, T, T0, P0]):
 
     __isabstractmethod__: bool = False
 
-    cache_key = '_jetpt_cachedproperty_cache'
+    cache_key = "_jetpt_cachedproperty_cache"
 
     class baseclass:
         """Inherit from this class to automatically set the cache dict."""
 
         if not TYPE_CHECKING:
+
             def __new__(cls, *args: Any, **kwargs: Any) -> None:
                 try:
                     self = super().__new__(cls, *args, **kwargs)
@@ -491,43 +482,41 @@ class cachedproperty(property, Generic[P, R_co, T, T0, P0]):
                 return self
 
     if TYPE_CHECKING:
+
         def __init__(
-            self, fget: Callable[P, R_co], fset: Callable[[T, T0], None] | None = None,
-            fdel: Callable[P0, None] | None = None, doc: str | None = None,
-        ) -> None:
-            ...
+            self,
+            fget: Callable[P, R_co],
+            fset: Callable[[T, T0], None] | None = None,
+            fdel: Callable[P0, None] | None = None,
+            doc: str | None = None,
+        ) -> None: ...
 
-        def getter(self, __fget: Callable[P1, R0_co]) -> cachedproperty[P1, R0_co, T, T0, P0]:
-            ...
+        def getter(self, fget: Callable[P1, R0_co]) -> cachedproperty[P1, R0_co, T, T0, P0]: ...
 
-        def setter(self, __fset: Callable[[T1, T2], None]) -> cachedproperty[P, R_co, T1, T2, P0]:
-            ...
+        def setter(self, fset: Callable[[T1, T2], None]) -> cachedproperty[P, R_co, T1, T2, P0]: ...
 
-        def deleter(self, __fdel: Callable[P1, None]) -> cachedproperty[P, R_co, T, T0, P1]:
-            ...
+        def deleter(self, fdel: Callable[P1, None]) -> cachedproperty[P, R_co, T, T0, P1]: ...
 
     @overload
-    def __get__(self, __obj: None, __type: type | None = None) -> Self:
-        ...
+    def __get__(self, obj: None, type_: type | None = None) -> Self: ...
 
     @overload
-    def __get__(self, __obj: object, __type: type | None = None) -> R_co:
-        ...
+    def __get__(self, obj: object, type_: type | None = None) -> R_co: ...
 
-    def __get__(self, __obj: Any, __type: type | None = None) -> Any:
+    def __get__(self, obj: Any, type_: type | None = None) -> Any:
         if isinstance(self.fget, classproperty):
-            function = partial(self.fget.__get__, __obj, __type)  # type: ignore
-            __obj = __type
+            function = partial(self.fget.__get__, obj, type_)  # type: ignore
+            obj = type_
 
-            if not hasattr(__obj, cachedproperty.cache_key):
-                setattr(__obj, cachedproperty.cache_key, dict[str, Any]())
+            if not hasattr(obj, cachedproperty.cache_key):
+                setattr(obj, cachedproperty.cache_key, dict[str, Any]())
 
-            cache = getattr(__obj, cachedproperty.cache_key)
+            cache = getattr(obj, cachedproperty.cache_key)
             name = self.fget.__name__
         else:
             assert self.fget
-            function = self.fget.__get__(__obj, __type)
-            cache = __obj.__dict__.get(cachedproperty.cache_key)
+            function = self.fget.__get__(obj, type_)
+            cache = obj.__dict__.get(cachedproperty.cache_key)
             name = function.__name__
 
         if name not in cache:
@@ -536,6 +525,7 @@ class cachedproperty(property, Generic[P, R_co, T, T0, P0]):
         return cache[name]
 
     if TYPE_CHECKING:
+
         def __set__(self, obj: Any, value: R_co, /) -> None:  # type: ignore[misc]
             ...
 
@@ -544,48 +534,39 @@ class KwargsNotNone(KwargsT):
     """Remove all None objects from this kwargs dict."""
 
     if not TYPE_CHECKING:
-        def __new__(cls, *args: Any, **kwargs: Any) -> KwargsNotNone:
-            return KwargsT(**{
-                key: value for key, value in KwargsT(*args, **kwargs).items()
-                if value is not None
-            })
 
-
-SingleMeta = TypeVar('SingleMeta', bound=type)
+        def __new__(cls, *args: Any, **kwargs: Any) -> Self:
+            return KwargsT(**{key: value for key, value in KwargsT(*args, **kwargs).items() if value is not None})
 
 
 class SingletonMeta(type):
-    _instances = dict[type[SingleMeta], SingleMeta]()  # type: ignore
+    _instances: ClassVar[dict[type[Any], Any]] = {}
     _singleton_init: bool
 
-    def __new__(
-        cls: type[SingletonSelf], name: str, bases: tuple[type, ...], namespace: dict[str, Any], **kwargs: Any
-    ) -> SingletonSelf:
-        return type.__new__(cls, name, bases, namespace | {'_singleton_init': kwargs.pop('init', False)})
+    def __new__(cls, name: str, bases: tuple[type, ...], namespace: dict[str, Any], **kwargs: Any) -> SingletonMeta:
+        return type.__new__(cls, name, bases, namespace | {"_singleton_init": kwargs.pop("init", False)})
 
-    def __call__(cls: type[SingletonSelf], *args: Any, **kwargs: Any) -> SingletonSelf:  # type: ignore
+    def __call__(cls, *args: Any, **kwargs: Any) -> SingletonMeta:
         if cls not in cls._instances:
             cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
         elif cls._singleton_init:
-            cls._instances[cls].__init__(*args, **kwargs)  # type: ignore
+            cls._instances[cls].__init__(*args, **kwargs)
 
         return cls._instances[cls]
 
 
-SingletonSelf = TypeVar('SingletonSelf', bound=SingletonMeta)
-
-
 class Singleton(metaclass=SingletonMeta):
     """Handy class to inherit to have the SingletonMeta metaclass."""
 
 
 class to_singleton_impl:
     _ts_args = tuple[str, ...]()
-    _ts_kwargs = dict[str, Any]()
+    _ts_kwargs: Mapping[str, Any] = {}
     _add_classes = tuple[type, ...]()
 
     def __new__(_cls, cls: type[T]) -> T:  # type: ignore
         if _cls._add_classes:
+
             class rcls(cls, *_cls._add_classes):  # type: ignore
                 ...
         else:
@@ -604,11 +585,11 @@ class to_singleton_impl:
 
 class to_singleton(to_singleton_impl):
     class as_property(to_singleton_impl):
-        _add_classes = (property, )
+        _add_classes = (property,)
 
 
 class LinearRangeLut(Mapping[int, int]):
-    __slots__ = ('ranges', '_ranges_idx_lut', '_misses_n')
+    __slots__ = ("_misses_n", "_ranges_idx_lut", "ranges")
 
     def __init__(self, ranges: Mapping[int, range]) -> None:
         self.ranges = ranges
@@ -617,6 +598,8 @@ class LinearRangeLut(Mapping[int, int]):
         self._misses_n = 0
 
     def __getitem__(self, n: int) -> int:
+        missed_hit = 0
+
         for missed_hit, (idx, k) in enumerate(self._ranges_idx_lut):
             if n in k:
                 break

jetpytools/utils/__init__.py

@@ -1,4 +1,4 @@
-from .file import *  # noqa: F401, F403
-from .funcs import *  # noqa: F401, F403
-from .math import *  # noqa: F401, F403
-from .ranges import *  # noqa: F401, F403
+from .file import *
+from .funcs import *
+from .math import *
+from .ranges import *