python-injection 0.25.14__tar.gz → 0.26.0__tar.gz

{python_injection-0.25.14 → python_injection-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.25.14
+Version: 0.26.0
 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.14 → python_injection-0.26.0}/injection/__init__.pyi

@@ -68,6 +68,7 @@ def mod(name: str = ..., /) -> Module:
     """
     Short syntax for `Module.from_name`.
     """
+
 @runtime_checkable
 class Injectable[T](Protocol):
     @property
@@ -234,9 +235,8 @@ class Module:
     ) -> _Decorator: ...
     def scoped(
         self,
-        scope_name: str,
         /,
-        *,
+        *scope_names: str,
         ignore_type_hint: bool = ...,
         inject: bool = ...,
         on: _TypeInfo[Any] = ...,

{python_injection-0.25.14 → python_injection-0.26.0}/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, Sequence
+from contextlib import suppress
 from dataclasses import dataclass, field
 from functools import partial
 from typing import (
@@ -16,7 +16,7 @@ from typing import (
 
 from injection._core.common.asynchronous import AsyncSemaphore, Caller
 from injection._core.common.type import InputType
-from injection._core.scope import Scope, get_scope, in_scope_cache
+from injection._core.scope import Scope, get_first_scope, in_scope_cache
 from injection._core.slots import SlotKey
 from injection.exceptions import EmptySlotError, InjectionError
 
@@ -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]):
@@ -150,13 +129,13 @@ class ConstantInjectable[T](Injectable[T]):
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class ScopedInjectable[R, T](Injectable[T], ABC):
     factory: Caller[..., R]
-    scope_name: str
+    scope_names: Sequence[str]
     key: SlotKey[T] = field(default_factory=SlotKey)
     logic: CacheLogic[T] = field(default_factory=CacheLogic)
 
     @property
     def is_locked(self) -> bool:
-        return in_scope_cache(self.key, self.scope_name)
+        return in_scope_cache(self.key, *self.scope_names)
 
     @abstractmethod
     async def abuild(self, scope: Scope) -> T:
@@ -178,14 +157,16 @@ class ScopedInjectable[R, T](Injectable[T], ABC):
 
     def unlock(self) -> None:
         if self.is_locked:
-            raise RuntimeError(f"To unlock, close the `{self.scope_name}` scope.")
+            raise RuntimeError(
+                f"To unlock, close all open scopes in [{', '.join(f'`{name}`' for name in self.scope_names)}]."
+            )
 
     def __get_scope(self) -> Scope:
-        return get_scope(self.scope_name)
+        return get_first_scope(*self.scope_names)
 
     @classmethod
-    def bind_scope_name(cls, name: str) -> Callable[[Caller[..., R]], Self]:
-        return partial(cls, scope_name=name)
+    def bind_scope_names(cls, names: Sequence[str]) -> Callable[[Caller[..., R]], Self]:
+        return partial(cls, scope_names=names)
 
 
 class AsyncCMScopedInjectable[T](ScopedInjectable[AsyncContextManager[T], T]):
@@ -232,7 +213,7 @@ class ScopedSlotInjectable[T](Injectable[T]):
 
     def get_instance(self) -> T:
         scope_name = self.scope_name
-        scope = get_scope(scope_name)
+        scope = get_first_scope(scope_name)
 
         try:
             return scope.cache[self.key]

{python_injection-0.25.14 → python_injection-0.26.0}/injection/_core/module.py

@@ -250,9 +250,8 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
 
     def scoped[**P, T](
         self,
-        scope_name: str,
         /,
-        *,
+        *scope_names: str,
         ignore_type_hint: bool = False,
         inject: bool = True,
         on: TypeInfo[T] = (),
@@ -284,7 +283,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
 
             self.injectable(
                 ctx.wrapper,
-                cls=ctx.cls.bind_scope_name(scope_name),
+                cls=ctx.cls.bind_scope_names(scope_names),
                 ignore_type_hint=True,
                 inject=inject,
                 on=(*ctx.hints, on),

{python_injection-0.25.14 → python_injection-0.26.0}/injection/_core/scope.py

@@ -151,34 +151,36 @@ def define_scope(
 if TYPE_CHECKING:  # pragma: no cover
 
     @overload
-    def get_scope(name: str, default: EllipsisType = ...) -> Scope: ...
+    def get_first_scope(*names: str, default: EllipsisType = ...) -> Scope: ...
 
     @overload
-    def get_scope[T](name: str, default: T) -> Scope | T: ...
+    def get_first_scope[T](*names: str, default: T) -> Scope | T: ...
 
 
-def get_scope[T](name: str, default: T | EllipsisType = ...) -> Scope | T:
+def get_first_scope[T](*names: str, default: T | EllipsisType = ...) -> Scope | T:
     for resolvers in __scope_resolvers.values():
-        resolver = resolvers.get(name)
-        if resolver and (scope := resolver.get_scope()):
-            return scope
+        for name in names:
+            resolver = resolvers.get(name)
+            if resolver and (scope := resolver.get_scope()):
+                return scope
 
     if default is ...:
         raise ScopeUndefinedError(
-            f"Scope `{name}` isn't defined in the current context."
+            f"No scope in [{', '.join(f'`{name}`' for name in names)}] is defined in the current context."
         )
 
     return default
 
 
-def in_scope_cache(key: SlotKey[Any], scope_name: str) -> bool:
-    return any(key in scope.cache for scope in iter_active_scopes(scope_name))
+def in_scope_cache(key: SlotKey[Any], *scope_names: str) -> bool:
+    return any(key in scope.cache for scope in iter_active_scopes(*scope_names))
 
 
-def iter_active_scopes(name: str) -> Iterator[Scope]:
+def iter_active_scopes(*names: str) -> Iterator[Scope]:
     active_scopes = (
         resolver.active_scopes
         for resolvers in __scope_resolvers.values()
+        for name in names
         if (resolver := resolvers.get(name))
     )
     return itertools.chain.from_iterable(active_scopes)
@@ -194,7 +196,7 @@ def _bind_scope(
     lock = get_lock(threadsafe)
 
     with lock:
-        if get_scope(name, None):
+        if get_first_scope(name, default=None):
             raise ScopeAlreadyDefinedError(
                 f"Scope `{name}` is already defined in the current context."
             )

{python_injection-0.25.14 → python_injection-0.26.0}/pyproject.toml

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