feat: ✨️ Add threadsafe parameter to @inject

Author: remimd

injection/__init__.pyi

@@ -74,11 +74,19 @@ class Module:
     def __contains__(self, cls: _InputType[Any], /) -> bool: ...
     @property
     def is_locked(self) -> bool: ...
-    def inject[**P, T](self, wrapped: Callable[P, T] = ..., /) -> Any:
+    def inject[**P, T](
+        self,
+        wrapped: Callable[P, T] = ...,
+        /,
+        *,
+        threadsafe: bool = ...,
+    ) -> Any:
         """
         Decorator applicable to a class or function. Inject function dependencies using
         parameter type annotations. If applied to a class, the dependencies resolved
         will be those of the `__init__` method.
+
+        With `threadsafe=True`, the injection logic is wrapped in a `threading.Lock`.
         """
 
     def injectable[**P, T](
@@ -166,6 +174,7 @@ class Module:
         self,
         wrapped: Callable[P, T],
         /,
+        threadsafe: bool = ...,
     ) -> Callable[P, T]: ...
     async def afind_instance[T](self, cls: _InputType[T]) -> T: ...
     def find_instance[T](self, cls: _InputType[T]) -> T:
@@ -295,6 +304,8 @@ class Module:
         Function to unlock the module by deleting cached instances of singletons.
         """
 
+    @contextmanager
+    def load_profile(self, *names: str) -> Iterator[None]: ...
     async def all_ready(self) -> None: ...
     def add_logger(self, logger: Logger) -> Self: ...
     @classmethod

injection/_core/module.py

@@ -11,7 +11,7 @@
     Iterator,
     Mapping,
 )
-from contextlib import asynccontextmanager, contextmanager, suppress
+from contextlib import asynccontextmanager, contextmanager, nullcontext, suppress
 from dataclasses import dataclass, field
 from enum import StrEnum
 from functools import partialmethod, singledispatchmethod, update_wrapper
@@ -25,6 +25,7 @@
 )
 from inspect import signature as inspect_signature
 from logging import Logger, getLogger
+from threading import Lock
 from types import MethodType
 from typing import (
     Any,
@@ -542,13 +543,19 @@ def set_constant[T](
         )
         return self
 
-    def inject[**P, T](self, wrapped: Callable[P, T] | None = None, /) -> Any:
+    def inject[**P, T](
+        self,
+        wrapped: Callable[P, T] | None = None,
+        /,
+        *,
+        threadsafe: bool = False,
+    ) -> Any:
         def decorator(wp: Callable[P, T]) -> Callable[P, T]:
             if isclass(wp):
-                wp.__init__ = self.inject(wp.__init__)
+                wp.__init__ = self.inject(wp.__init__, threadsafe=threadsafe)
                 return wp
 
-            return self.make_injected_function(wp)
+            return self.make_injected_function(wp, threadsafe)
 
         return decorator(wrapped) if wrapped else decorator
 
@@ -557,17 +564,19 @@ def make_injected_function[**P, T](
         self,
         wrapped: Callable[P, T],
         /,
+        threadsafe: bool = ...,
     ) -> SyncInjectedFunction[P, T]: ...
 
     @overload
     def make_injected_function[**P, T](
         self,
         wrapped: Callable[P, Awaitable[T]],
         /,
+        threadsafe: bool = ...,
     ) -> AsyncInjectedFunction[P, T]: ...
 
-    def make_injected_function(self, wrapped, /):  # type: ignore[no-untyped-def]
-        metadata = InjectMetadata(wrapped)
+    def make_injected_function(self, wrapped, /, threadsafe=False):  # type: ignore[no-untyped-def]
+        metadata = InjectMetadata(wrapped, threadsafe)
 
         @metadata.task
         def listen() -> None:
@@ -753,6 +762,23 @@ def unlock(self) -> Self:
 
         return self
 
+    def load_profile(self, *names: str) -> ContextManager[None]:
+        modules = tuple(self.from_name(name) for name in names)
+
+        for module in modules:
+            module.unlock()
+
+        self.unlock().init_modules(*modules)
+
+        del module, modules
+
+        @contextmanager
+        def cleaner() -> Iterator[None]:
+            yield
+            self.unlock().init_modules()
+
+        return cleaner()
+
     async def all_ready(self) -> None:
         for broker in self.__brokers:
             await broker.all_ready()
@@ -913,20 +939,23 @@ class Arguments(NamedTuple):
 class InjectMetadata[**P, T](Caller[P, T], EventListener):
     __slots__ = (
         "__dependencies",
+        "__lock",
         "__owner",
         "__signature",
         "__tasks",
         "__wrapped",
     )
 
     __dependencies: Dependencies
+    __lock: ContextManager[Any]
     __owner: type | None
     __signature: Signature
     __tasks: deque[Callable[..., Any]]
     __wrapped: Callable[P, T]
 
-    def __init__(self, wrapped: Callable[P, T], /) -> None:
+    def __init__(self, wrapped: Callable[P, T], /, threadsafe: bool) -> None:
         self.__dependencies = Dependencies.empty()
+        self.__lock = Lock() if threadsafe else nullcontext()
         self.__owner = None
         self.__tasks = deque()
         self.__wrapped = wrapped
@@ -961,13 +990,17 @@ def bind(
         return self.__bind(args, kwargs, additional_arguments)
 
     async def acall(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
-        self.__run_tasks()
-        arguments = await self.abind(args, kwargs)
+        with self.__lock:
+            self.__run_tasks()
+            arguments = await self.abind(args, kwargs)
+
         return self.wrapped(*arguments.args, **arguments.kwargs)
 
     def call(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
-        self.__run_tasks()
-        arguments = self.bind(args, kwargs)
+        with self.__lock:
+            self.__run_tasks()
+            arguments = self.bind(args, kwargs)
+
         return self.wrapped(*arguments.args, **arguments.kwargs)
 
     def set_owner(self, owner: type) -> Self:

injection/_core/scope.py

@@ -34,21 +34,21 @@ class _ScopeState:
         default_factory=lambda: ContextVar(f"scope@{new_short_key()}"),
         init=False,
     )
-    __references: set[Scope] = field(
-        default_factory=set,
+    __default: Scope | None = field(
+        default=None,
         init=False,
     )
-    __shared_value: Scope | None = field(
-        default=None,
+    __references: set[Scope] = field(
+        default_factory=set,
         init=False,
     )
 
     @property
     def active_scopes(self) -> Iterator[Scope]:
         yield from self.__references
 
-        if shared_value := self.__shared_value:
-            yield shared_value
+        if default := self.__default:
+            yield default
 
     @contextmanager
     def bind_contextual_scope(self, scope: Scope) -> Iterator[None]:
@@ -69,15 +69,15 @@ def bind_shared_scope(self, scope: Scope) -> Iterator[None]:
                 "are defined on the same name."
             )
 
-        self.__shared_value = scope
+        self.__default = scope
 
         try:
             yield
         finally:
-            self.__shared_value = None
+            self.__default = None
 
     def get_scope(self) -> Scope | None:
-        return self.__context_var.get(self.__shared_value)
+        return self.__context_var.get(self.__default)
 
 
 __SCOPES: Final[defaultdict[str, _ScopeState]] = defaultdict(_ScopeState)
@@ -125,11 +125,8 @@ def _bind_scope(name: str, scope: Scope, shared: bool) -> Iterator[None]:
         state.bind_shared_scope(scope) if shared else state.bind_contextual_scope(scope)
     )
 
-    try:
-        with strategy:
-            yield
-    finally:
-        scope.cache.clear()
+    with strategy:
+        yield
 
 
 @runtime_checkable

injection/utils.py

@@ -1,5 +1,4 @@
-from collections.abc import Callable, Iterable, Iterator
-from contextlib import contextmanager
+from collections.abc import Callable, Collection, Iterator
 from importlib import import_module
 from importlib.util import find_spec
 from pkgutil import walk_packages
@@ -18,26 +17,12 @@ def load_profile(*names: str) -> ContextManager[None]:
     A profile name is equivalent to an injection module name.
     """
 
-    modules = tuple(mod(module_name) for module_name in names)
-
-    for module in modules:
-        module.unlock()
-
-    target = mod().unlock().init_modules(*modules)
-
-    del module, modules
-
-    @contextmanager
-    def cleaner() -> Iterator[None]:
-        yield
-        target.unlock().init_modules()
-
-    return cleaner()
+    return mod().load_profile(*names)
 
 
 def load_modules_with_keywords(
     *packages: PythonModule | str,
-    keywords: Iterable[str] | None = None,
+    keywords: Collection[str] | None = None,
 ) -> dict[str, PythonModule]:
     """
     Function to import modules from a Python package if one of the keywords is contained in the Python script.
@@ -54,16 +39,16 @@ def load_modules_with_keywords(
             f"import {injection_package_name}",
         )
 
-    b_keywords = tuple(keyword.encode() for keyword in keywords)
-
     def predicate(module_name: str) -> bool:
-        if (spec := find_spec(module_name)) and (module_path := spec.origin):
-            with open(module_path, "rb") as script:
-                for line in script:
-                    line = b" ".join(line.split(b" ")).strip()
+        spec = find_spec(module_name)
+
+        if spec and (module_path := spec.origin):
+            with open(module_path, "r") as file:
+                python_script = file.read()
 
-                    if line and any(keyword in line for keyword in b_keywords):
-                        return True
+            return bool(python_script) and any(
+                keyword in python_script for keyword in keywords
+            )
 
         return False
 

tests/utils/test_load_profile.py

@@ -0,0 +1,36 @@
+from injection import find_instance, injectable, mod
+from injection.utils import load_profile
+
+
+class TestLoadProfile:
+    def test_load_profile_with_success(self):
+        profile_name = "test"
+
+        @injectable
+        class A: ...
+
+        @mod(profile_name).injectable(on=A)
+        class B(A): ...
+
+        assert type(find_instance(A)) is A
+        load_profile(profile_name)
+        assert type(find_instance(A)) is B
+
+        # Cleaning
+        mod().init_modules()
+
+    def test_load_profile_with_context_manager(self):
+        profile_name = "test"
+
+        @injectable
+        class A: ...
+
+        @mod(profile_name).injectable(on=A)
+        class B(A): ...
+
+        assert type(find_instance(A)) is A
+
+        with load_profile(profile_name):
+            assert type(find_instance(A)) is B
+
+        assert type(find_instance(A)) is A