python-injection 0.25.13__tar.gz → 0.25.15__tar.gz

{python_injection-0.25.13 → python_injection-0.25.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.25.13
+Version: 0.25.15
 Summary: Dead-simple dependency injection framework for Python.
 Project-URL: Documentation, https://python-injection.remimd.dev
 Project-URL: Repository, https://github.com/100nm/python-injection

{python_injection-0.25.13 → python_injection-0.25.15}/injection/_core/common/type.py

@@ -28,14 +28,14 @@ type TypeInfo[T] = (
 )
 
 
-def get_return_hint[T](function: Callable[..., T]) -> InputType[T] | None:
+def get_return_type[T](function: Callable[..., T]) -> Any | None:
     return get_type_hints(function).get("return")
 
 
-def get_yield_hints[T](
+def get_yield_types[T](
     function: Callable[..., Iterator[T]] | Callable[..., AsyncIterator[T]],
-) -> tuple[InputType[T]] | tuple[()]:
-    return_type = get_return_hint(function)
+) -> tuple[Any] | tuple[()]:
+    return_type = get_return_type(function)
 
     if get_origin(return_type) in (
         AsyncGenerator,
@@ -62,8 +62,8 @@ def iter_flat_types(*args: Any) -> Iterator[Any]:
 
 def iter_return_types(*args: Any) -> Iterator[Any]:
     for arg in args:
-        if isfunction(arg) and (return_type := get_return_hint(arg)):
-            yield from iter_return_types(return_type)
+        if isfunction(arg) and (return_type := get_return_type(arg)):
+            yield return_type
 
         else:
             yield arg

{python_injection-0.25.13 → python_injection-0.25.15}/injection/_core/injectables.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
-from collections.abc import Awaitable, Callable, Iterator, MutableMapping
-from contextlib import contextmanager, suppress
+from collections.abc import Awaitable, Callable, MutableMapping
+from contextlib import suppress
 from dataclasses import dataclass, field
 from functools import partial
 from typing import (
@@ -53,13 +53,11 @@ class TransientInjectable[T](Injectable[T]):
 
 
 class CacheLogic[T]:
-    __slots__ = ("__is_instantiating", "__semaphore")
+    __slots__ = ("__semaphore",)
 
-    __is_instantiating: bool
     __semaphore: AsyncContextManager[Any]
 
     def __init__(self) -> None:
-        self.__is_instantiating = False
         self.__semaphore = AsyncSemaphore(1)
 
     async def aget_or_create[K](
@@ -68,14 +66,11 @@ class CacheLogic[T]:
         key: K,
         factory: Callable[..., Awaitable[T]],
     ) -> T:
-        self.__fail_if_instantiating()
         async with self.__semaphore:
             with suppress(KeyError):
                 return cache[key]
 
-            with self.__instantiating():
-                instance = await factory()
-
+            instance = await factory()
             cache[key] = instance
 
         return instance
@@ -86,29 +81,13 @@ class CacheLogic[T]:
         key: K,
         factory: Callable[..., T],
     ) -> T:
-        self.__fail_if_instantiating()
         with suppress(KeyError):
             return cache[key]
 
-        with self.__instantiating():
-            instance = factory()
-
+        instance = factory()
         cache[key] = instance
         return instance
 
-    def __fail_if_instantiating(self) -> None:
-        if self.__is_instantiating:
-            raise RecursionError("Recursive call detected during instantiation.")
-
-    @contextmanager
-    def __instantiating(self) -> Iterator[None]:
-        self.__is_instantiating = True
-
-        try:
-            yield
-        finally:
-            self.__is_instantiating = False
-
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class SingletonInjectable[T](Injectable[T]):

{python_injection-0.25.13 → python_injection-0.25.15}/injection/_core/module.py

@@ -52,7 +52,7 @@ from injection._core.common.threading import get_lock
 from injection._core.common.type import (
     InputType,
     TypeInfo,
-    get_yield_hints,
+    get_yield_types,
     iter_flat_types,
     iter_return_types,
 )
@@ -264,14 +264,14 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
             if isasyncgenfunction(wrapped):
                 ctx = _ScopedContext(
                     cls=AsyncCMScopedInjectable,
-                    hints=() if ignore_type_hint else get_yield_hints(wrapped),
+                    hints=() if ignore_type_hint else get_yield_types(wrapped),
                     wrapper=asynccontextmanager(wrapped),
                 )
 
             elif isgeneratorfunction(wrapped):
                 ctx = _ScopedContext(
                     cls=CMScopedInjectable,
-                    hints=() if ignore_type_hint else get_yield_hints(wrapped),
+                    hints=() if ignore_type_hint else get_yield_types(wrapped),
                     wrapper=contextmanager(wrapped),
                 )
 
@@ -713,19 +713,19 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         return cls.from_name("__default__")
 
     @staticmethod
-    def __build_key_types(input_cls: Any) -> frozenset[Any]:
+    def __build_key_types(input_class: Any) -> frozenset[Any]:
         config = MatchingTypesConfig(ignore_none=True)
         return frozenset(
             matching_type
-            for cls in iter_flat_types(input_cls)
+            for cls in iter_flat_types(input_class)
             for return_type in iter_return_types(cls)
             for matching_type in iter_matching_types(return_type, config)
         )
 
     @staticmethod
-    def __matching_key_types(input_cls: Any) -> tuple[Any, ...]:
+    def __matching_key_types(input_class: Any) -> tuple[Any, ...]:
         config = MatchingTypesConfig(with_origin=True, with_type_alias_value=True)
-        return matching_types(input_cls, config)
+        return matching_types(input_class, config)
 
 
 def mod(name: str | None = None, /) -> Module:

{python_injection-0.25.13 → python_injection-0.25.15}/injection/loaders.py

@@ -150,8 +150,11 @@ class ProfileLoader:
         return not self.module_subsets
 
     def required_module_names(self, name: str | None = None, /) -> frozenset[str]:
-        names = {n for n in (self.module.name, name) if n is not None}
-        subsets = (self.__walk_subsets_for(name) for name in names)
+        subsets = (
+            self.__walk_subsets_for(module_name)
+            for module_name in (self.module.name, name)
+            if module_name is not None
+        )
         return frozenset(itertools.chain.from_iterable(subsets))
 
     def init(self) -> Self:

{python_injection-0.25.13 → python_injection-0.25.15}/pyproject.toml

@@ -24,7 +24,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.25.13"
+version = "0.25.15"
 description = "Dead-simple dependency injection framework for Python."
 license = "MIT"
 license-files = ["LICENSE"]