python-injection 0.25.10__tar.gz → 0.25.12__tar.gz

{python_injection-0.25.10 → python_injection-0.25.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.25.10
+Version: 0.25.12
 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.12/injection/_core/common/threading.py

@@ -0,0 +1,13 @@
+from contextlib import nullcontext
+from os import getenv
+from threading import RLock
+from typing import Any, ContextManager, Final
+
+_PYTHON_INJECTION_THREADSAFE: Final[bool] = bool(
+    int(getenv("PYTHON_INJECTION_THREADSAFE", 0))
+)
+
+
+def get_lock(threadsafe: bool | None = None) -> ContextManager[Any]:
+    threadsafe = _PYTHON_INJECTION_THREADSAFE if threadsafe is None else threadsafe
+    return RLock() if threadsafe else nullcontext()

{python_injection-0.25.10 → python_injection-0.25.12}/injection/_core/injectables.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
-from collections.abc import Awaitable, Callable, MutableMapping
-from contextlib import suppress
+from collections.abc import Awaitable, Callable, Iterator, MutableMapping
+from contextlib import contextmanager, suppress
 from dataclasses import dataclass, field
 from functools import partial
 from typing import (
@@ -16,12 +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,
-    remove_scoped_values,
-)
+from injection._core.scope import Scope, get_scope, in_scope_cache
 from injection._core.slots import SlotKey
 from injection.exceptions import EmptySlotError, InjectionError
 
@@ -58,11 +53,13 @@ class TransientInjectable[T](Injectable[T]):
 
 
 class CacheLogic[T]:
-    __slots__ = ("__semaphore",)
+    __slots__ = ("__is_instantiating", "__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](
@@ -71,11 +68,14 @@ class CacheLogic[T]:
         key: K,
         factory: Callable[..., Awaitable[T]],
     ) -> T:
+        self.__fail_if_instantiating()
         async with self.__semaphore:
             with suppress(KeyError):
                 return cache[key]
 
-            instance = await factory()
+            with self.__instantiating():
+                instance = await factory()
+
             cache[key] = instance
 
         return instance
@@ -86,13 +86,29 @@ class CacheLogic[T]:
         key: K,
         factory: Callable[..., T],
     ) -> T:
+        self.__fail_if_instantiating()
         with suppress(KeyError):
             return cache[key]
 
-        instance = factory()
+        with self.__instantiating():
+            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]):
@@ -204,9 +220,6 @@ class SimpleScopedInjectable[T](ScopedInjectable[T, T]):
     def build(self, scope: Scope) -> T:
         return self.factory.call()
 
-    def unlock(self) -> None:
-        remove_scoped_values(self.key, self.scope_name)
-
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class ScopedSlotInjectable[T](Injectable[T]):

{python_injection-0.25.10 → python_injection-0.25.12}/injection/_core/locator.py

@@ -61,6 +61,7 @@ class InjectionProvider(ABC):
         self,
         wrapped: Callable[P, T],
         /,
+        threadsafe: bool | None = ...,
     ) -> Callable[P, T]:
         raise NotImplementedError
 
@@ -108,7 +109,7 @@ class DynamicInjectableBroker[T](InjectableBroker[T]):
 
         injectable = _make_injectable(
             self.factory,
-            provider.make_injected_function(self.recipe),  # type: ignore[misc]
+            provider.make_injected_function(self.recipe, threadsafe=False),  # type: ignore[misc]
         )
         self.injectables[provider] = injectable
         return injectable
@@ -116,16 +117,16 @@ class DynamicInjectableBroker[T](InjectableBroker[T]):
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class StaticInjectableBroker[T](InjectableBroker[T]):
-    value: Injectable[T]
+    injectable: Injectable[T]
 
     def get(self, provider: InjectionProvider) -> Injectable[T] | None:
-        return self.value
+        return self.injectable
 
     def is_locked(self, provider: InjectionProvider) -> bool:
         return False
 
     def request(self, provider: InjectionProvider) -> Injectable[T]:
-        return self.value
+        return self.injectable
 
     @classmethod
     def from_factory(

{python_injection-0.25.10 → python_injection-0.25.12}/injection/_core/scope.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import itertools
 from abc import ABC, abstractmethod
 from collections import defaultdict
-from collections.abc import AsyncIterator, Iterator, Mapping, MutableMapping
+from collections.abc import AsyncIterator, Collection, Iterator, Mapping, MutableMapping
 from contextlib import AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass, field
@@ -47,12 +47,12 @@ type ScopeKindStr = Literal["contextual", "shared"]
 
 
 @runtime_checkable
-class ScopeState(Protocol):
+class ScopeResolver(Protocol):
     __slots__ = ()
 
     @property
     @abstractmethod
-    def active_scopes(self) -> Iterator[Scope]:
+    def active_scopes(self) -> Collection[Scope]:
         raise NotImplementedError
 
     @abstractmethod
@@ -65,8 +65,8 @@ class ScopeState(Protocol):
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class _ContextualScopeState(ScopeState):
-    # Shouldn't be instantiated outside `__CONTEXTUAL_SCOPES`.
+class _ContextualScopeResolver(ScopeResolver):
+    # Shouldn't be instantiated outside `__scope_resolvers`.
 
     __context_var: ContextVar[Scope] = field(
         default_factory=lambda: ContextVar(f"scope@{new_short_key()}"),
@@ -78,8 +78,8 @@ class _ContextualScopeState(ScopeState):
     )
 
     @property
-    def active_scopes(self) -> Iterator[Scope]:
-        return iter(self.__references)
+    def active_scopes(self) -> Collection[Scope]:
+        return self.__references
 
     @contextmanager
     def bind(self, scope: Scope) -> Iterator[None]:
@@ -97,13 +97,13 @@ class _ContextualScopeState(ScopeState):
 
 
 @dataclass(repr=False, slots=True)
-class _SharedScopeState(ScopeState):
+class _SharedScopeResolver(ScopeResolver):
     __scope: Scope | None = field(default=None)
 
     @property
-    def active_scopes(self) -> Iterator[Scope]:
-        if scope := self.__scope:
-            yield scope
+    def active_scopes(self) -> Collection[Scope]:
+        scope = self.__scope
+        return () if scope is None else (scope,)
 
     @contextmanager
     def bind(self, scope: Scope) -> Iterator[None]:
@@ -118,12 +118,10 @@ class _SharedScopeState(ScopeState):
         return self.__scope
 
 
-__CONTEXTUAL_SCOPES: Final[Mapping[str, ScopeState]] = defaultdict(
-    _ContextualScopeState,
-)
-__SHARED_SCOPES: Final[Mapping[str, ScopeState]] = defaultdict(
-    _SharedScopeState,
-)
+__scope_resolvers: Final[Mapping[str, Mapping[str, ScopeResolver]]] = {
+    ScopeKind.CONTEXTUAL: defaultdict(_ContextualScopeResolver),
+    ScopeKind.SHARED: defaultdict(_SharedScopeResolver),
+}
 
 
 @asynccontextmanager
@@ -150,15 +148,6 @@ def define_scope(
             yield facade
 
 
-def get_active_scopes(name: str) -> tuple[Scope, ...]:
-    active_scopes = (
-        state.active_scopes
-        for states in (__CONTEXTUAL_SCOPES, __SHARED_SCOPES)
-        if (state := states.get(name))
-    )
-    return tuple(itertools.chain.from_iterable(active_scopes))
-
-
 if TYPE_CHECKING:  # pragma: no cover
 
     @overload
@@ -169,9 +158,9 @@ if TYPE_CHECKING:  # pragma: no cover
 
 
 def get_scope[T](name: str, default: T | EllipsisType = ...) -> Scope | T:
-    for states in (__CONTEXTUAL_SCOPES, __SHARED_SCOPES):
-        state = states.get(name)
-        if state and (scope := state.get_scope()):
+    for resolvers in __scope_resolvers.values():
+        resolver = resolvers.get(name)
+        if resolver and (scope := resolver.get_scope()):
             return scope
 
     if default is Ellipsis:
@@ -183,12 +172,16 @@ def get_scope[T](name: str, default: T | EllipsisType = ...) -> Scope | T:
 
 
 def in_scope_cache(key: SlotKey[Any], scope_name: str) -> bool:
-    return any(key in scope.cache for scope in get_active_scopes(scope_name))
+    return any(key in scope.cache for scope in iter_active_scopes(scope_name))
 
 
-def remove_scoped_values(key: SlotKey[Any], scope_name: str) -> None:
-    for scope in get_active_scopes(scope_name):
-        scope.cache.pop(key, None)
+def iter_active_scopes(name: str) -> Iterator[Scope]:
+    active_scopes = (
+        resolver.active_scopes
+        for resolvers in __scope_resolvers.values()
+        if (resolver := resolvers.get(name))
+    )
+    return itertools.chain.from_iterable(active_scopes)
 
 
 @contextmanager
@@ -201,25 +194,13 @@ def _bind_scope(
     lock = get_lock(threadsafe)
 
     with lock:
-        match ScopeKind(kind):
-            case ScopeKind.CONTEXTUAL:
-                is_already_defined = bool(get_scope(name, default=None))
-                states = __CONTEXTUAL_SCOPES
-
-            case ScopeKind.SHARED:
-                is_already_defined = bool(get_active_scopes(name))
-                states = __SHARED_SCOPES
-
-            case _:
-                raise NotImplementedError
-
-        if is_already_defined:
+        if get_scope(name, default=None):
             raise ScopeAlreadyDefinedError(
                 f"Scope `{name}` is already defined in the current context."
             )
 
         stack = ExitStack()
-        stack.enter_context(states[name].bind(scope))
+        stack.enter_context(__scope_resolvers[kind][name].bind(scope))
 
     try:
         yield _UserScope(scope, lock)

{python_injection-0.25.10 → python_injection-0.25.12}/pyproject.toml

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

python_injection-0.25.10/injection/_core/common/threading.py

@@ -1,11 +0,0 @@
-from contextlib import nullcontext
-from os import getenv
-from threading import RLock
-from typing import Any, ContextManager, Final
-
-_PYTHON_INJECTION_THREADSAFE: Final[bool] = bool(getenv("PYTHON_INJECTION_THREADSAFE"))
-
-
-def get_lock(threadsafe: bool | None = None) -> ContextManager[Any]:
-    cond = _PYTHON_INJECTION_THREADSAFE if threadsafe is None else threadsafe
-    return RLock() if cond else nullcontext()