python-injection 0.18.8__tar.gz → 0.18.10__tar.gz

{python_injection-0.18.8 → python_injection-0.18.10}/PKG-INFO

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

{python_injection-0.18.8 → python_injection-0.18.10}/injection/__init__.pyi

@@ -35,12 +35,14 @@ def adefine_scope(
     name: str,
     /,
     kind: ScopeKind | ScopeKindStr = ...,
+    threadsafe: bool = ...,
 ) -> AsyncIterator[Scope]: ...
 @contextmanager
 def define_scope(
     name: str,
     /,
     kind: ScopeKind | ScopeKindStr = ...,
+    threadsafe: bool = ...,
 ) -> Iterator[Scope]: ...
 def mod(name: str = ..., /) -> Module:
     """

{python_injection-0.18.8 → python_injection-0.18.10}/injection/_core/module.py

@@ -996,7 +996,7 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
 
     def __init__(self, wrapped: Callable[P, T], /, threadsafe: bool) -> None:
         self.__dependencies = Dependencies.empty()
-        self.__lock = threading.Lock() if threadsafe else nullcontext()
+        self.__lock = threading.RLock() if threadsafe else nullcontext()
         self.__owner = None
         self.__tasks = deque()
         self.__wrapped = wrapped

{python_injection-0.18.8 → python_injection-0.18.10}/injection/_core/scope.py

@@ -1,10 +1,17 @@
 from __future__ import annotations
 
 import itertools
+import threading
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import AsyncIterator, Iterator, Mapping, MutableMapping
-from contextlib import AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
+from contextlib import (
+    AsyncExitStack,
+    ExitStack,
+    asynccontextmanager,
+    contextmanager,
+    nullcontext,
+)
 from contextvars import ContextVar
 from dataclasses import dataclass, field
 from enum import StrEnum
@@ -129,9 +136,10 @@ async def adefine_scope(
     name: str,
     /,
     kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
+    threadsafe: bool = False,
 ) -> AsyncIterator[ScopeFacade]:
     async with AsyncScope() as scope:
-        with _bind_scope(name, scope, kind) as facade:
+        with _bind_scope(name, scope, kind, threadsafe) as facade:
             yield facade
 
 
@@ -140,9 +148,10 @@ def define_scope(
     name: str,
     /,
     kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
+    threadsafe: bool = False,
 ) -> Iterator[ScopeFacade]:
     with SyncScope() as scope:
-        with _bind_scope(name, scope, kind) as facade:
+        with _bind_scope(name, scope, kind, threadsafe) as facade:
             yield facade
 
 
@@ -191,26 +200,37 @@ def _bind_scope(
     name: str,
     scope: Scope,
     kind: ScopeKind | ScopeKindStr,
+    threadsafe: bool,
 ) -> Iterator[ScopeFacade]:
-    match ScopeKind(kind):
-        case ScopeKind.CONTEXTUAL:
-            is_already_defined = bool(get_scope(name, default=None))
-            states = __CONTEXTUAL_SCOPES
+    lock = threading.RLock() if threadsafe else nullcontext()
 
-        case ScopeKind.SHARED:
-            is_already_defined = bool(get_active_scopes(name))
-            states = __SHARED_SCOPES
+    with lock:
+        match ScopeKind(kind):
+            case ScopeKind.CONTEXTUAL:
+                is_already_defined = bool(get_scope(name, default=None))
+                states = __CONTEXTUAL_SCOPES
 
-        case _:
-            raise NotImplementedError
+            case ScopeKind.SHARED:
+                is_already_defined = bool(get_active_scopes(name))
+                states = __SHARED_SCOPES
 
-    if is_already_defined:
-        raise ScopeAlreadyDefinedError(
-            f"Scope `{name}` is already defined in the current context."
-        )
+            case _:
+                raise NotImplementedError
+
+        if is_already_defined:
+            raise ScopeAlreadyDefinedError(
+                f"Scope `{name}` is already defined in the current context."
+            )
 
-    with states[name].bind(scope):
-        yield _UserScope(scope)
+        stack = ExitStack()
+        stack.enter_context(states[name].bind(scope))
+
+    try:
+        yield _UserScope(scope, lock)
+
+    finally:
+        with lock:
+            stack.close()
 
 
 @runtime_checkable
@@ -304,6 +324,7 @@ class ScopeFacade(Protocol):
 @dataclass(repr=False, frozen=True, slots=True)
 class _UserScope(ScopeFacade):
     scope: Scope
+    lock: ContextManager[Any]
 
     def set_slot[T](self, key: SlotKey[T], value: T) -> Self:
         return self.slot_map({key: value})
@@ -311,9 +332,11 @@ class _UserScope(ScopeFacade):
     def slot_map(self, mapping: Mapping[SlotKey[Any], Any], /) -> Self:
         cache = self.scope.cache
 
-        for slot_key in mapping:
-            if slot_key in cache:
-                raise InjectionError("Slot already set.")
+        with self.lock:
+            for slot_key in mapping:
+                if slot_key in cache:
+                    raise InjectionError("Slot already set.")
+
+            cache.update(mapping)
 
-        cache.update(mapping)
         return self

{python_injection-0.18.8 → python_injection-0.18.10}/pyproject.toml

@@ -29,7 +29,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.18.8"
+version = "0.18.10"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
 license-files = ["LICENSE"]