python-injection 0.14.6__tar.gz → 0.14.6.post1__tar.gz

{python_injection-0.14.6 → python_injection-0.14.6.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.14.6
+Version: 0.14.6.post1
 Summary: Fast and easy dependency injection framework.
 Project-URL: Repository, https://github.com/100nm/python-injection
 Author: remimd

{python_injection-0.14.6 → python_injection-0.14.6.post1}/injection/_core/injectables.py

@@ -13,7 +13,10 @@ from typing import (
     runtime_checkable,
 )
 
-from injection._core.common.asynchronous import Caller, create_semaphore
+from injection._core.common.asynchronous import Caller
+from injection._core.common.asynchronous import (
+    create_semaphore as _create_async_semaphore,
+)
 from injection._core.scope import Scope, get_active_scopes, get_scope
 from injection.exceptions import InjectionError
 
@@ -39,12 +42,8 @@ class Injectable[T](Protocol):
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
-class BaseInjectable[R, T](Injectable[T], ABC):
-    factory: Caller[..., R]
-
-
-class SimpleInjectable[T](BaseInjectable[T, T]):
-    __slots__ = ()
+class SimpleInjectable[T](Injectable[T]):
+    factory: Caller[..., T]
 
     async def aget_instance(self) -> T:
         return await self.factory.acall()
@@ -53,13 +52,13 @@ class SimpleInjectable[T](BaseInjectable[T, T]):
         return self.factory.call()
 
 
-@dataclass(repr=False, eq=False, frozen=True, slots=True)
-class CachedInjectable[R, T](BaseInjectable[R, T], ABC):
-    __semaphore: AsyncContextManager[Any] = field(
-        default_factory=partial(create_semaphore, 1),
-        init=False,
-        hash=False,
-    )
+class CacheLogic[T]:
+    __slots__ = ("__semaphore",)
+
+    __semaphore: AsyncContextManager[Any]
+
+    def __init__(self) -> None:
+        self.__semaphore = _create_async_semaphore(1)
 
     async def aget_or_create[K](
         self,
@@ -90,32 +89,37 @@ class CachedInjectable[R, T](BaseInjectable[R, T], ABC):
         return instance
 
 
-class SingletonInjectable[T](CachedInjectable[T, T]):
-    __slots__ = ("__dict__",)
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class SingletonInjectable[T](Injectable[T]):
+    factory: Caller[..., T]
+    cache: MutableMapping[str, T] = field(default_factory=dict)
+    logic: CacheLogic[T] = field(default_factory=CacheLogic)
 
     __key: ClassVar[str] = "$instance"
 
     @property
     def is_locked(self) -> bool:
-        return self.__key in self.__cache
-
-    @property
-    def __cache(self) -> MutableMapping[str, Any]:
-        return self.__dict__
+        return self.__key in self.cache
 
     async def aget_instance(self) -> T:
-        return await self.aget_or_create(self.__cache, self.__key, self.factory.acall)
+        return await self.logic.aget_or_create(
+            self.cache,
+            self.__key,
+            self.factory.acall,
+        )
 
     def get_instance(self) -> T:
-        return self.get_or_create(self.__cache, self.__key, self.factory.call)
+        return self.logic.get_or_create(self.cache, self.__key, self.factory.call)
 
     def unlock(self) -> None:
-        self.__cache.pop(self.__key, None)
+        self.cache.pop(self.__key, None)
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
-class ScopedInjectable[R, T](CachedInjectable[R, T], ABC):
+class ScopedInjectable[R, T](Injectable[T], ABC):
+    factory: Caller[..., R]
     scope_name: str
+    logic: CacheLogic[T] = field(default_factory=CacheLogic)
 
     @property
     def is_locked(self) -> bool:
@@ -130,26 +134,26 @@ class ScopedInjectable[R, T](CachedInjectable[R, T], ABC):
         raise NotImplementedError
 
     async def aget_instance(self) -> T:
-        scope = self.get_scope()
+        scope = self.__get_scope()
         factory = partial(self.abuild, scope)
-        return await self.aget_or_create(scope.cache, self, factory)
+        return await self.logic.aget_or_create(scope.cache, self, factory)
 
     def get_instance(self) -> T:
-        scope = self.get_scope()
+        scope = self.__get_scope()
         factory = partial(self.build, scope)
-        return self.get_or_create(scope.cache, self, factory)
-
-    def get_scope(self) -> Scope:
-        return get_scope(self.scope_name)
+        return self.logic.get_or_create(scope.cache, self, factory)
 
     def setdefault(self, instance: T) -> T:
-        scope = self.get_scope()
-        return self.get_or_create(scope.cache, self, lambda: instance)
+        scope = self.__get_scope()
+        return self.logic.get_or_create(scope.cache, self, lambda: instance)
 
     def unlock(self) -> None:
         if self.is_locked:
             raise RuntimeError(f"To unlock, close the `{self.scope_name}` scope.")
 
+    def __get_scope(self) -> Scope:
+        return get_scope(self.scope_name)
+
 
 class AsyncCMScopedInjectable[T](ScopedInjectable[AsyncContextManager[T], T]):
     __slots__ = ()

{python_injection-0.14.6 → python_injection-0.14.6.post1}/injection/_core/scope.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
+import itertools
 from abc import ABC, abstractmethod
 from collections import defaultdict
-from collections.abc import AsyncIterator, Iterator, MutableMapping
+from collections.abc import AsyncIterator, Iterator, Mapping, MutableMapping
 from contextlib import AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass, field
-from types import TracebackType
+from types import EllipsisType, TracebackType
 from typing import (
     Any,
     AsyncContextManager,
@@ -15,6 +16,7 @@ from typing import (
     NoReturn,
     Protocol,
     Self,
+    overload,
     runtime_checkable,
 )
 
@@ -26,18 +28,32 @@ from injection.exceptions import (
 )
 
 
-@dataclass(repr=False, slots=True)
-class _ScopeState:
-    # Shouldn't be instantiated outside `__SCOPES`.
+@runtime_checkable
+class ScopeState(Protocol):
+    __slots__ = ()
+
+    @property
+    @abstractmethod
+    def active_scopes(self) -> Iterator[Scope]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def bind(self, scope: Scope) -> ContextManager[None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_scope(self) -> Scope | None:
+        raise NotImplementedError
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+class _ContextualScopeState(ScopeState):
+    # Shouldn't be instantiated outside `__CONTEXTUAL_SCOPES`.
 
     __context_var: ContextVar[Scope] = field(
         default_factory=lambda: ContextVar(f"scope@{new_short_key()}"),
         init=False,
     )
-    __default: Scope | None = field(
-        default=None,
-        init=False,
-    )
     __references: set[Scope] = field(
         default_factory=set,
         init=False,
@@ -45,13 +61,10 @@ class _ScopeState:
 
     @property
     def active_scopes(self) -> Iterator[Scope]:
-        yield from self.__references
-
-        if default := self.__default:
-            yield default
+        return iter(self.__references)
 
     @contextmanager
-    def bind_contextual_scope(self, scope: Scope) -> Iterator[None]:
+    def bind(self, scope: Scope) -> Iterator[None]:
         self.__references.add(scope)
         token = self.__context_var.set(scope)
 
@@ -61,26 +74,38 @@ class _ScopeState:
             self.__context_var.reset(token)
             self.__references.remove(scope)
 
-    @contextmanager
-    def bind_shared_scope(self, scope: Scope) -> Iterator[None]:
-        if next(self.active_scopes, None):
-            raise ScopeError(
-                "A shared scope can't be defined when one or more contextual scopes "
-                "are defined on the same name."
-            )
+    def get_scope(self) -> Scope | None:
+        return self.__context_var.get(None)
+
+
+@dataclass(repr=False, slots=True)
+class _SharedScopeState(ScopeState):
+    __scope: Scope | None = field(default=None)
+
+    @property
+    def active_scopes(self) -> Iterator[Scope]:
+        if scope := self.__scope:
+            yield scope
 
-        self.__default = scope
+    @contextmanager
+    def bind(self, scope: Scope) -> Iterator[None]:
+        self.__scope = scope
 
         try:
             yield
         finally:
-            self.__default = None
+            self.__scope = None
 
     def get_scope(self) -> Scope | None:
-        return self.__context_var.get(self.__default)
+        return self.__scope
 
 
-__SCOPES: Final[defaultdict[str, _ScopeState]] = defaultdict(_ScopeState)
+__CONTEXTUAL_SCOPES: Final[Mapping[str, ScopeState]] = defaultdict(
+    _ContextualScopeState,
+)
+__SHARED_SCOPES: Final[Mapping[str, ScopeState]] = defaultdict(
+    _SharedScopeState,
+)
 
 
 @asynccontextmanager
@@ -98,36 +123,52 @@ def define_scope(name: str, *, shared: bool = False) -> Iterator[None]:
 
 
 def get_active_scopes(name: str) -> tuple[Scope, ...]:
-    state = __SCOPES.get(name)
+    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 state is None:
-        return ()
+@overload
+def get_scope(name: str, default: EllipsisType = ...) -> Scope: ...
 
-    return tuple(state.active_scopes)
 
+@overload
+def get_scope[T](name: str, default: T) -> Scope | T: ...
 
-def get_scope(name: str) -> Scope:
-    state = __SCOPES.get(name)
 
-    if state is None or (scope := state.get_scope()) is None:
+def get_scope(name, default=...):  # type: ignore[no-untyped-def]
+    for states in (__CONTEXTUAL_SCOPES, __SHARED_SCOPES):
+        state = states.get(name)
+        if state and (scope := state.get_scope()):
+            return scope
+
+    if default is Ellipsis:
         raise ScopeUndefinedError(
             f"Scope `{name}` isn't defined in the current context."
         )
 
-    return scope
+    return default
 
 
 @contextmanager
 def _bind_scope(name: str, scope: Scope, shared: bool) -> Iterator[None]:
-    state = __SCOPES[name]
+    if shared:
+        is_already_defined = bool(get_active_scopes(name))
+        state = __SHARED_SCOPES[name]
+
+    else:
+        is_already_defined = bool(get_scope(name, default=None))
+        state = __CONTEXTUAL_SCOPES[name]
 
-    if state.get_scope():
+    if is_already_defined:
         raise ScopeAlreadyDefinedError(
             f"Scope `{name}` is already defined in the current context."
         )
 
-    strategy = state.bind_shared_scope if shared else state.bind_contextual_scope
-    with strategy(scope):
+    with state.bind(scope):
         yield
 
 

{python_injection-0.14.6 → python_injection-0.14.6.post1}/pyproject.toml

@@ -25,7 +25,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.14.6"
+version = "0.14.6.post1"
 description = "Fast and easy dependency injection framework."
 license = { text = "MIT" }
 readme = "README.md"