jetpytools 2.0.0__tar.gz → 2.0.2__tar.gz

{jetpytools-2.0.0 → jetpytools-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jetpytools
-Version: 2.0.0
+Version: 2.0.2
 Summary: Collection of stuff that's useful in general python programming
 Project-URL: Source Code, https://github.com/Jaded-Encoding-Thaumaturgy/jetpytools
 Project-URL: Contact, https://discord.gg/XTpc6Fa9eB

{jetpytools-2.0.0 → jetpytools-2.0.2}/jetpytools/_metadata.py

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

{jetpytools-2.0.0 → jetpytools-2.0.2}/jetpytools/types/supports.py

@@ -113,14 +113,16 @@ class ComparatorFunc(Protocol):
     ) -> T0 | T1: ...
 
 
+@runtime_checkable
 class SupportsIndexing[T](Protocol):
     def __getitem__(self, k: int) -> T: ...
 
 
+@runtime_checkable
 class SupportsKeysAndGetItem[KT, VT](Protocol):
     def keys(self) -> Iterable[KT]: ...
 
     def __getitem__(self, k: KT) -> VT: ...
 
 
-type SupportsFloatOrIndex = SupportsFloat | SupportsIndex
+SupportsFloatOrIndex = SupportsFloat | SupportsIndex

{jetpytools-2.0.0 → jetpytools-2.0.2}/jetpytools/types/utils.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import sys
 from contextlib import suppress
 from functools import wraps
-from inspect import Signature
+from inspect import Signature, get_annotations
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -192,10 +192,12 @@ class _InjectSelfBase(Generic[_T_co, _P, _R_co]):
         self.args = args
         self.kwargs = kwargs
 
-    def __get__[T](self, instance: T | None, owner: type[T]) -> _InjectedSelfFunc[T, _P, _R_co]:  # pyright: ignore[reportGeneralTypeIssues]
+    def __get__(self, instance: Any | None, owner: type | None = None) -> _InjectedSelfFunc[_T_co, _P, _R_co]:  # pyright: ignore[reportGeneralTypeIssues]
         """
         Return a wrapped callable that automatically injects an instance as the first argument when called.
         """
+        if owner is None:
+            owner = type(instance)
 
         @wraps(self._function)
         def _wrapper(*args: Any, **kwargs: Any) -> _R_co:
@@ -263,6 +265,9 @@ class _InjectSelfBase(Generic[_T_co, _P, _R_co]):
 
         return owner(*self.args, **self.kwargs), kwargs
 
+    def __call__(self_, self: _T_co, *args: _P.args, **kwargs: _P.kwargs) -> _R_co:  # type: ignore[misc]  # noqa: N805
+        return self_.__get__(self, type(self))(*args, **kwargs)
+
     @property
     def __func__(self) -> Callable[Concatenate[_T_co, _P], _R_co]:
         """Return the original wrapped function."""
@@ -377,10 +382,10 @@ class _InjectKwargsParamsBase(Generic[_T_co, _P, _R_co]):
         self._signature = None
 
     @overload
-    def __get__(self, instance: None, owner: type[Any]) -> Self: ...
+    def __get__(self, instance: None, owner: type) -> Self: ...
     @overload
-    def __get__(self, instance: Any, owner: type[Any]) -> Callable[_P, _R_co]: ...
-    def __get__(self, instance: Any | None, owner: type[Any]) -> Self | Callable[_P, _R_co]:
+    def __get__(self, instance: Any, owner: type | None = None) -> Callable[_P, _R_co]: ...
+    def __get__(self, instance: Any | None, owner: type | None = None) -> Any:
         """
         Descriptor binding logic.
 
@@ -435,6 +440,9 @@ class _InjectKwargsParamsBase(Generic[_T_co, _P, _R_co]):
 
         return wrapper
 
+    def __call__(self_, self: _T_co, *args: _P.args, **kwargs: _P.kwargs) -> _R_co:  # type: ignore[misc]  # noqa: N805
+        return self_.__get__(self, type(self))(*args, **kwargs)
+
     @property
     def __func__(self) -> Callable[Concatenate[_T_co, _P], _R_co]:
         """Return the original wrapped function."""
@@ -467,7 +475,7 @@ class _InjectKwargsParamsBase(Generic[_T_co, _P, _R_co]):
         return _wrapper
 
 
-class inject_kwargs_params[T, **P, R](_InjectKwargsParamsBase[T, P, R]):
+class inject_kwargs_params(_InjectKwargsParamsBase[_T_co, _P, _R_co]):
     """
     Descriptor that injects parameters into functions based on an instance's keyword mapping.
 
@@ -478,7 +486,7 @@ class inject_kwargs_params[T, **P, R](_InjectKwargsParamsBase[T, P, R]):
 
     __slots__ = ()
 
-    class add_to_kwargs[T0, **P0, R0](_InjectKwargsParamsBase[T0, P0, R0]):
+    class add_to_kwargs(_InjectKwargsParamsBase[_T0_co, _P0, _R0_co]):
         """
         Variant of `inject_kwargs_params` that merges unused entries from `self.kwargs` into the keyword arguments
         passed to the target function.
@@ -490,13 +498,13 @@ class inject_kwargs_params[T, **P, R](_InjectKwargsParamsBase[T, P, R]):
 
 
 class _ComplexHash[**P, R]:
-    __slots__ = "func"
+    __slots__ = "_func"
 
     def __init__(self, func: Callable[P, R]) -> None:
-        self.func = func
+        self._func = func
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
-        return self.func(*args, **kwargs)
+        return self._func(*args, **kwargs)
 
     @staticmethod
     def hash(*args: Any) -> int:
@@ -507,8 +515,8 @@ class _ComplexHash[**P, R]:
 
         :return:        Hash of all the combined objects' hashes.
         """
-
         values = list[str]()
+
         for value in args:
             try:
                 new_hash = hash(value)
@@ -523,18 +531,21 @@ class _ComplexHash[**P, R]:
 @_ComplexHash
 def complex_hash[T](cls: type[T]) -> type[T]:
     """
-    Decorator for classes to add a ``__hash__`` method to them.
+    Class decorator that automatically adds a ``__hash__`` method to the target class.
+
+    The generated ``__hash__`` method computes a hash value derived from:
+    - the class's name
+    - the values of all attributes listed in its type annotations.
 
-    Especially useful for NamedTuples.
+    This is particularly useful for immutable data structures (e.g., NamedTuples or dataclasses).
     """
 
     def __hash__(self: T) -> int:  # noqa: N807
-        return complex_hash.hash(self.__class__.__name__, *(getattr(self, key) for key in self.__annotations__))
+        return complex_hash.hash(self.__class__.__name__, *(getattr(self, key) for key in get_annotations(cls)))
 
-    ns = cls.__dict__.copy()
-    ns["__hash__"] = __hash__
+    setattr(cls, __hash__.__name__, __hash__)
 
-    return type(cls.__name__, (cls,), ns)  # pyright: ignore[reportReturnType]
+    return cls
 
 
 def get_subclasses[T](family: type[T], exclude: Sequence[type[T]] = []) -> list[type[T]]:
@@ -584,61 +595,59 @@ class classproperty_base(Generic[_T, _R_co, _T_Any]):
     def __set_name__(self, owner: object, name: str) -> None:
         self.__name__ = name
 
-    def _get_cache(self, type_: type[_T]) -> dict[str, Any]:
+    def _get_cache(self, owner: type[_T]) -> dict[str, Any]:
         cache_key = getattr(self, "cache_key")
 
-        if not hasattr(type_, cache_key):
-            setattr(type_, cache_key, {})
+        if not hasattr(owner, cache_key):
+            setattr(owner, cache_key, {})
 
-        return getattr(type_, cache_key)
+        return getattr(owner, cache_key)
 
-    def __get__(self, obj: _T | None, type_: type[_T] | None = None) -> _R_co:
-        if type_ is None and obj is not None:
-            type_ = type(obj)
-        elif type_ is None:
-            raise NotImplementedError("Both obj and type_ are None")
+    def __get__(self, instance: Any | None, owner: type | None = None) -> _R_co:
+        if owner is None:
+            owner = type(instance)
 
         if not isinstance(self, classproperty.cached):
-            return self.fget(type_)
+            return self.fget(owner)
 
-        if self.__name__ in (cache := self._get_cache(type_)):
+        if self.__name__ in (cache := self._get_cache(owner)):
             return cache[self.__name__]
 
-        value = self.fget(type_)
+        value = self.fget(owner)
         cache[self.__name__] = value
         return value
 
-    def __set__(self, obj: _T, value: _T_Any) -> None:
+    def __set__(self, instance: Any, value: _T_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 "{instance.__class__.__name__}" object has no setter.'
             )
 
-        type_ = type(obj)
+        owner = type(instance)
 
         if not isinstance(self, classproperty.cached):
-            return self.fset(type_, value)
+            return self.fset(owner, value)
 
-        if self.__name__ in (cache := self._get_cache(type_)):
+        if self.__name__ in (cache := self._get_cache(owner)):
             del cache[self.__name__]
 
-        self.fset(type_, value)
+        self.fset(owner, value)
 
-    def __delete__(self, obj: _T) -> None:
+    def __delete__(self, instance: Any) -> 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 "{instance.__class__.__name__}" object has no deleter.'
             )
 
-        type_ = type(obj)
+        owner = type(instance)
 
         if not isinstance(self, classproperty.cached):
-            return self.fdel(type_)
+            return self.fdel(owner)
 
-        if self.__name__ in (cache := self._get_cache(type_)):
+        if self.__name__ in (cache := self._get_cache(owner)):
             del cache[self.__name__]
 
-        self.fdel(type_)
+        self.fdel(owner)
 
 
 class classproperty(classproperty_base[_T, _R_co, _T_Any]):
@@ -788,22 +797,33 @@ class KwargsNotNone(KwargsT):
 
 
 class SingletonMeta(type):
-    _instances: ClassVar[dict[type[Any], Any]] = {}
+    _instances: ClassVar[dict[SingletonMeta, Any]] = {}
     _singleton_init: bool
 
     def __new__[MetaSelf: SingletonMeta](
-        mcls: type[MetaSelf], name: str, bases: tuple[type, ...], namespace: dict[str, Any], **kwargs: Any
+        mcls: type[MetaSelf],
+        name: str,
+        bases: tuple[type, ...],
+        namespace: dict[str, Any],
+        *,
+        init: bool = False,
+        **kwargs: Any,
     ) -> MetaSelf:
-        namespace["_singleton_init"] = kwargs.pop("init", False)
-        return super().__new__(mcls, name, bases, namespace, **kwargs)
+        cls = super().__new__(mcls, name, bases, namespace, **kwargs)
+        cls._singleton_init = init
+        return cls
+
+    if not TYPE_CHECKING:
+
+        def __call__(cls, *args: Any, **kwargs: Any) -> Any:
+            if cls not in cls._instances:
+                cls._instances[cls] = obj = super().__call__(*args, **kwargs)
+                return obj
 
-    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)
+            if cls._singleton_init:
+                cls._instances[cls].__init__(*args, **kwargs)
 
-        return cls._instances[cls]
+            return cls._instances[cls]
 
 
 class Singleton(metaclass=SingletonMeta):