python-injection 0.13.2__tar.gz → 0.14.0.post0__tar.gz

{python_injection-0.13.2 → python_injection-0.14.0.post0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.13.2
+Version: 0.14.0.post0
 Summary: Fast and easy dependency injection framework.
 Project-URL: Repository, https://github.com/100nm/python-injection
 Author: remimd
@@ -78,6 +78,9 @@ if __name__ == "__main__":
 
 ## Resources
 
+> ⚠️ The package isn't threadsafe, for better performance in single-threaded applications and those using `asyncio`.
+> So remember to use `threading.Lock` if you're writing a multithreaded program.
+
 * [**Basic usage**](https://github.com/100nm/python-injection/tree/prod/documentation/basic-usage.md)
 * [**Scoped dependencies**](https://github.com/100nm/python-injection/tree/prod/documentation/scoped-dependencies.md)
 * [**Testing**](https://github.com/100nm/python-injection/tree/prod/documentation/testing.md)

{python_injection-0.13.2 → python_injection-0.14.0.post0}/README.md

@@ -55,6 +55,9 @@ if __name__ == "__main__":
 
 ## Resources
 
+> ⚠️ The package isn't threadsafe, for better performance in single-threaded applications and those using `asyncio`.
+> So remember to use `threading.Lock` if you're writing a multithreaded program.
+
 * [**Basic usage**](https://github.com/100nm/python-injection/tree/prod/documentation/basic-usage.md)
 * [**Scoped dependencies**](https://github.com/100nm/python-injection/tree/prod/documentation/scoped-dependencies.md)
 * [**Testing**](https://github.com/100nm/python-injection/tree/prod/documentation/testing.md)

{python_injection-0.13.2 → python_injection-0.14.0.post0}/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:
@@ -272,7 +281,7 @@ class Module:
         module: Module,
         *,
         priority: Priority | PriorityStr = ...,
-    ) -> Iterator[None]:
+    ) -> Iterator[Self]:
         """
         Context manager or decorator for temporary use of a module.
         """
@@ -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[Self]: ...
     async def all_ready(self) -> None: ...
     def add_logger(self, logger: Logger) -> Self: ...
     @classmethod

{python_injection-0.13.2 → python_injection-0.14.0.post0}/injection/_core/hook.py

@@ -1,4 +1,5 @@
 import itertools
+from collections import deque
 from collections.abc import Callable, Generator, Iterator
 from dataclasses import dataclass, field
 from inspect import isclass, isgeneratorfunction
@@ -13,8 +14,8 @@ type HookFunction[**P, T] = Callable[P, T] | HookGeneratorFunction[P, T]
 
 @dataclass(eq=False, frozen=True, slots=True)
 class Hook[**P, T]:
-    __functions: list[HookFunction[P, T]] = field(
-        default_factory=list,
+    __functions: deque[HookFunction[P, T]] = field(
+        default_factory=deque,
         init=False,
         repr=False,
     )
@@ -35,7 +36,7 @@ class Hook[**P, T]:
         return iter(self.__functions)
 
     def add(self, *functions: HookFunction[P, T]) -> Self:
-        self.__functions.extend(reversed(functions))
+        self.__functions.extendleft(functions)
         return self
 
     @classmethod

{python_injection-0.13.2 → python_injection-0.14.0.post0}/injection/_core/module.py

@@ -11,7 +11,7 @@ from collections.abc import (
     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 (
 )
 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 @@ class Module(Broker, EventListener):
         )
         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,6 +564,7 @@ class Module(Broker, EventListener):
         self,
         wrapped: Callable[P, T],
         /,
+        threadsafe: bool = ...,
     ) -> SyncInjectedFunction[P, T]: ...
 
     @overload
@@ -564,10 +572,11 @@ class Module(Broker, EventListener):
         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:
@@ -730,11 +739,11 @@ class Module(Broker, EventListener):
         module: Module,
         *,
         priority: Priority | PriorityStr = Priority.get_default(),
-    ) -> Iterator[None]:
+    ) -> Iterator[Self]:
         self.use(module, priority=priority)
 
         try:
-            yield
+            yield self
         finally:
             self.stop_using(module)
 
@@ -753,6 +762,23 @@ class Module(Broker, EventListener):
 
         return self
 
+    def load_profile(self, *names: str) -> ContextManager[Self]:
+        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[Self]:
+            yield self
+            self.unlock().init_modules()
+
+        return cleaner()
+
     async def all_ready(self) -> None:
         for broker in self.__brokers:
             await broker.all_ready()
@@ -913,6 +939,7 @@ class Arguments(NamedTuple):
 class InjectMetadata[**P, T](Caller[P, T], EventListener):
     __slots__ = (
         "__dependencies",
+        "__lock",
         "__owner",
         "__signature",
         "__tasks",
@@ -920,13 +947,15 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
     )
 
     __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 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
         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:

{python_injection-0.13.2 → python_injection-0.14.0.post0}/injection/_core/scope.py

@@ -34,12 +34,12 @@ 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,
     )
 
@@ -47,8 +47,8 @@ class _ScopeState:
     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 @@ class _ScopeState:
                 "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)
@@ -121,15 +121,9 @@ def _bind_scope(name: str, scope: Scope, shared: bool) -> Iterator[None]:
             f"Scope `{name}` is already defined in the current context."
         )
 
-    strategy = (
-        state.bind_shared_scope(scope) if shared else state.bind_contextual_scope(scope)
-    )
-
-    try:
-        with strategy:
-            yield
-    finally:
-        scope.cache.clear()
+    strategy = state.bind_shared_scope if shared else state.bind_contextual_scope
+    with strategy(scope):
+        yield
 
 
 @runtime_checkable

{python_injection-0.13.2 → python_injection-0.14.0.post0}/injection/testing/__init__.py

@@ -1,6 +1,6 @@
 from typing import ContextManager, Final
 
-from injection import mod
+from injection import Module, mod
 from injection.utils import load_profile
 
 __all__ = (
@@ -23,5 +23,5 @@ test_scoped = mod(_TEST_PROFILE_NAME).scoped
 test_singleton = mod(_TEST_PROFILE_NAME).singleton
 
 
-def load_test_profile(*names: str) -> ContextManager[None]:
+def load_test_profile(*names: str) -> ContextManager[Module]:
     return load_profile(_TEST_PROFILE_NAME, *names)

{python_injection-0.13.2 → python_injection-0.14.0.post0}/injection/testing/__init__.pyi

@@ -11,7 +11,7 @@ test_injectable = __MODULE.injectable
 test_scoped = __MODULE.scoped
 test_singleton = __MODULE.singleton
 
-def load_test_profile(*names: str) -> ContextManager[None]:
+def load_test_profile(*names: str) -> ContextManager[Module]:
     """
     Context manager or decorator for temporary use test module.
     """

{python_injection-0.13.2 → python_injection-0.14.0.post0}/injection/utils.py

@@ -1,43 +1,28 @@
-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
 from types import ModuleType as PythonModule
 from typing import ContextManager
 
+from injection import Module, mod
 from injection import __name__ as injection_package_name
-from injection import mod
 
 __all__ = ("load_modules_with_keywords", "load_packages", "load_profile")
 
 
-def load_profile(*names: str) -> ContextManager[None]:
+def load_profile(*names: str) -> ContextManager[Module]:
     """
     Injection module initialization function based on profile name.
     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
 

{python_injection-0.13.2 → python_injection-0.14.0.post0}/pyproject.toml

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