python-injection 0.13.1__tar.gz → 0.14.0__tar.gz

{python_injection-0.13.1 → python_injection-0.14.0}/PKG-INFO

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

{python_injection-0.13.1 → python_injection-0.14.0}/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

{python_injection-0.13.1 → python_injection-0.14.0}/injection/_core/common/asynchronous.py

@@ -1,17 +1,7 @@
-import asyncio
 from abc import abstractmethod
-from collections.abc import Awaitable, Callable, Coroutine, Generator
+from collections.abc import Awaitable, Callable, Generator
 from dataclasses import dataclass
-from typing import Any, Protocol, runtime_checkable
-
-
-def run_sync[T](coroutine: Coroutine[Any, Any, T]) -> T:
-    loop = asyncio.get_event_loop()
-
-    try:
-        return loop.run_until_complete(coroutine)
-    finally:
-        coroutine.close()
+from typing import Any, NoReturn, Protocol, runtime_checkable
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
@@ -37,13 +27,13 @@ class Caller[**P, T](Protocol):
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class AsyncCaller[**P, T](Caller[P, T]):
-    callable: Callable[P, Coroutine[Any, Any, T]]
+    callable: Callable[P, Awaitable[T]]
 
     async def acall(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
         return await self.callable(*args, **kwargs)
 
-    def call(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
-        return run_sync(self.callable(*args, **kwargs))
+    def call(self, /, *args: P.args, **kwargs: P.kwargs) -> NoReturn:
+        raise RuntimeError("Can't call async callable synchronously.")
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)

python_injection-0.14.0/injection/_core/common/lazy.py

@@ -0,0 +1,55 @@
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
+from functools import partial
+
+from injection._core.common.asynchronous import SimpleAwaitable
+from injection._core.common.invertible import Invertible, SimpleInvertible
+
+
+def lazy[T](factory: Callable[..., T]) -> Invertible[T]:
+    def cache() -> Iterator[T]:
+        nonlocal factory
+        value = factory()
+        del factory
+
+        while True:
+            yield value
+
+    getter = partial(next, cache())
+    return SimpleInvertible(getter)
+
+
+def alazy[T](factory: Callable[..., Awaitable[T]]) -> Awaitable[T]:
+    async def cache() -> AsyncIterator[T]:
+        nonlocal factory
+        value = await factory()
+        del factory
+
+        while True:
+            yield value
+
+    getter = partial(anext, cache())
+    return SimpleAwaitable(getter)
+
+
+class Lazy[T](Invertible[T]):
+    __slots__ = ("__invertible", "__is_set")
+
+    __invertible: Invertible[T]
+    __is_set: bool
+
+    def __init__(self, factory: Callable[..., T]) -> None:
+        @lazy
+        def invertible() -> T:
+            value = factory()
+            self.__is_set = True
+            return value
+
+        self.__invertible = invertible
+        self.__is_set = False
+
+    def __invert__(self) -> T:
+        return ~self.__invertible
+
+    @property
+    def is_set(self) -> bool:
+        return self.__is_set

{python_injection-0.13.1 → python_injection-0.14.0}/injection/_core/injectables.py

@@ -12,7 +12,7 @@ from typing import (
     runtime_checkable,
 )
 
-from injection._core.common.asynchronous import Caller, run_sync
+from injection._core.common.asynchronous import Caller
 from injection._core.scope import Scope, get_active_scopes, get_scope
 from injection.exceptions import InjectionError
 
@@ -138,8 +138,8 @@ class AsyncCMScopedInjectable[T](ScopedInjectable[AsyncContextManager[T], T]):
         cm = await self.factory.acall()
         return await scope.aenter(cm)
 
-    def build(self, scope: Scope) -> T:
-        return run_sync(self.abuild(scope))
+    def build(self, scope: Scope) -> NoReturn:
+        raise RuntimeError("Can't use async context manager synchronously.")
 
 
 class CMScopedInjectable[T](ScopedInjectable[ContextManager[T], T]):

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

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
-import asyncio
 from abc import ABC, abstractmethod
-from collections import OrderedDict
+from collections import OrderedDict, deque
 from collections.abc import (
     AsyncIterator,
     Awaitable,
@@ -12,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
@@ -26,7 +25,7 @@ from inspect import (
 )
 from inspect import signature as inspect_signature
 from logging import Logger, getLogger
-from queue import Empty, Queue
+from threading import Lock
 from types import MethodType
 from typing import (
     Any,
@@ -50,7 +49,7 @@ from injection._core.common.asynchronous import (
 from injection._core.common.event import Event, EventChannel, EventListener
 from injection._core.common.invertible import Invertible, SimpleInvertible
 from injection._core.common.key import new_short_key
-from injection._core.common.lazy import Lazy, LazyMapping
+from injection._core.common.lazy import Lazy, alazy, lazy
 from injection._core.common.type import (
     InputType,
     TypeInfo,
@@ -296,6 +295,9 @@ class Locator(Broker):
 
     async def all_ready(self) -> None:
         for injectable in self.__injectables:
+            if injectable.is_locked:
+                continue
+
             await injectable.aget_instance()
 
     def add_listener(self, listener: EventListener) -> Self:
@@ -511,7 +513,7 @@ class Module(Broker, EventListener):
         mode: Mode | ModeStr = Mode.get_default(),
     ) -> Any:
         def decorator(wp: type[T]) -> type[T]:
-            lazy_instance = Lazy(wp)
+            lazy_instance = lazy(wp)
             self.injectable(
                 lambda: ~lazy_instance,
                 ignore_type_hint=True,
@@ -541,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
 
@@ -556,6 +564,7 @@ class Module(Broker, EventListener):
         self,
         wrapped: Callable[P, T],
         /,
+        threadsafe: bool = ...,
     ) -> SyncInjectedFunction[P, T]: ...
 
     @overload
@@ -563,12 +572,13 @@ 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.on_setup
+        @metadata.task
         def listen() -> None:
             metadata.update(self)
             self.add_listener(metadata)
@@ -646,12 +656,10 @@ class Module(Broker, EventListener):
 
     def aget_lazy_instance(self, cls, default=None, *, cache=False):  # type: ignore[no-untyped-def]
         if cache:
-            coroutine = self.aget_instance(cls, default)
-            return asyncio.ensure_future(coroutine)
+            return alazy(lambda: self.aget_instance(cls, default))
 
         function = self.make_injected_function(lambda instance=default: instance)
-        metadata = function.__inject_metadata__
-        metadata.set_owner(cls)
+        metadata = function.__inject_metadata__.set_owner(cls)
         return SimpleAwaitable(metadata.acall)
 
     @overload
@@ -674,11 +682,10 @@ class Module(Broker, EventListener):
 
     def get_lazy_instance(self, cls, default=None, *, cache=False):  # type: ignore[no-untyped-def]
         if cache:
-            return Lazy(lambda: self.get_instance(cls, default))
+            return lazy(lambda: self.get_instance(cls, default))
 
         function = self.make_injected_function(lambda instance=default: instance)
-        metadata = function.__inject_metadata__
-        metadata.set_owner(cls)
+        metadata = function.__inject_metadata__.set_owner(cls)
         return SimpleInvertible(metadata.call)
 
     def update[T](self, updater: Updater[T]) -> Self:
@@ -755,6 +762,23 @@ class Module(Broker, EventListener):
 
         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()
@@ -832,10 +856,7 @@ InjectedFunction
 
 @dataclass(repr=False, frozen=True, slots=True)
 class Dependencies:
-    mapping: Mapping[str, Injectable[Any]]
-
-    def __bool__(self) -> bool:
-        return bool(self.mapping)
+    lazy_mapping: Lazy[Mapping[str, Injectable[Any]]]
 
     def __iter__(self) -> Iterator[tuple[str, Any]]:
         for name, injectable in self.mapping.items():
@@ -849,10 +870,11 @@ class Dependencies:
 
     @property
     def are_resolved(self) -> bool:
-        if isinstance(self.mapping, LazyMapping) and not self.mapping.is_set:
-            return False
+        return self.lazy_mapping.is_set
 
-        return bool(self)
+    @property
+    def mapping(self) -> Mapping[str, Injectable[Any]]:
+        return ~self.lazy_mapping
 
     async def aget_arguments(self) -> dict[str, Any]:
         return {key: value async for key, value in self}
@@ -861,12 +883,13 @@ class Dependencies:
         return dict(self)
 
     @classmethod
-    def from_mapping(cls, mapping: Mapping[str, Injectable[Any]]) -> Self:
-        return cls(mapping)
+    def from_iterable(cls, iterable: Iterable[tuple[str, Injectable[Any]]]) -> Self:
+        lazy_mapping = Lazy(lambda: dict(iterable))
+        return cls(lazy_mapping)
 
     @classmethod
     def empty(cls) -> Self:
-        return cls.from_mapping({})
+        return cls.from_iterable(())
 
     @classmethod
     def resolve(
@@ -875,8 +898,8 @@ class Dependencies:
         module: Module,
         owner: type | None = None,
     ) -> Self:
-        dependencies = LazyMapping(cls.__resolver(signature, module, owner))
-        return cls.from_mapping(dependencies)
+        iterable = cls.__resolver(signature, module, owner)
+        return cls.from_iterable(iterable)
 
     @classmethod
     def __resolver(
@@ -916,22 +939,25 @@ class Arguments(NamedTuple):
 class InjectMetadata[**P, T](Caller[P, T], EventListener):
     __slots__ = (
         "__dependencies",
+        "__lock",
         "__owner",
-        "__setup_queue",
         "__signature",
+        "__tasks",
         "__wrapped",
     )
 
     __dependencies: Dependencies
+    __lock: ContextManager[Any]
     __owner: type | None
-    __setup_queue: Queue[Callable[..., Any]] | 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.__setup_queue = Queue()
+        self.__tasks = deque()
         self.__wrapped = wrapped
 
     @property
@@ -964,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.__setup()
-        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.__setup()
-        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:
@@ -989,14 +1019,9 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
         self.__dependencies = Dependencies.resolve(self.signature, module, self.__owner)
         return self
 
-    def on_setup[**_P, _T](self, wrapped: Callable[_P, _T] | None = None, /) -> Any:
+    def task[**_P, _T](self, wrapped: Callable[_P, _T] | None = None, /) -> Any:
         def decorator(wp: Callable[_P, _T]) -> Callable[_P, _T]:
-            queue = self.__setup_queue
-
-            if queue is None:
-                raise RuntimeError(f"`{self}` is already up.")
-
-            queue.put_nowait(wp)
+            self.__tasks.append(wp)
             return wp
 
         return decorator(wrapped) if wrapped else decorator
@@ -1027,24 +1052,10 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
         bound.arguments = bound.arguments | additional_arguments | bound.arguments
         return Arguments(bound.args, bound.kwargs)
 
-    def __close_setup_queue(self) -> None:
-        self.__setup_queue = None
-
-    def __setup(self) -> None:
-        if (queue := self.__setup_queue) is None:
-            return
-
-        while True:
-            try:
-                task = queue.get_nowait()
-            except Empty:
-                break
-
+    def __run_tasks(self) -> None:
+        while tasks := self.__tasks:
+            task = tasks.popleft()
             task()
-            queue.task_done()
-
-        queue.join()
-        self.__close_setup_queue()
 
 
 class InjectedFunction[**P, T](ABC):

{python_injection-0.13.1 → python_injection-0.14.0}/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)
@@ -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
@@ -201,9 +198,7 @@ class SyncScope(BaseScope[ExitStack]):
         return self.delegate.__exit__(exc_type, exc_value, traceback)
 
     async def aenter[T](self, context_manager: AsyncContextManager[T]) -> NoReturn:
-        raise ScopeError(
-            "Synchronous scope doesn't support asynchronous context manager."
-        )
+        raise ScopeError("Synchronous scope doesn't support async context manager.")
 
     def enter[T](self, context_manager: ContextManager[T]) -> T:
         return self.delegate.enter_context(context_manager)

{python_injection-0.13.1 → python_injection-0.14.0}/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
 

{python_injection-0.13.1 → python_injection-0.14.0}/pyproject.toml

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

python_injection-0.13.1/injection/_core/common/lazy.py

@@ -1,56 +0,0 @@
-from collections.abc import Callable, Iterator, Mapping
-from types import MappingProxyType
-
-from injection._core.common.invertible import Invertible
-
-
-class Lazy[T](Invertible[T]):
-    __slots__ = ("__iterator", "__is_set")
-
-    __iterator: Iterator[T]
-    __is_set: bool
-
-    def __init__(self, factory: Callable[..., T]) -> None:
-        self.__setup_cache(factory)
-
-    def __invert__(self) -> T:
-        return next(self.__iterator)
-
-    @property
-    def is_set(self) -> bool:
-        return self.__is_set
-
-    def __setup_cache(self, factory: Callable[..., T]) -> None:
-        def infinite_yield() -> Iterator[T]:
-            nonlocal factory
-            cached = factory()
-            self.__is_set = True
-            del factory
-
-            while True:
-                yield cached
-
-        self.__iterator = infinite_yield()
-        self.__is_set = False
-
-
-class LazyMapping[K, V](Mapping[K, V]):
-    __slots__ = ("__lazy",)
-
-    __lazy: Lazy[Mapping[K, V]]
-
-    def __init__(self, iterator: Iterator[tuple[K, V]]) -> None:
-        self.__lazy = Lazy(lambda: MappingProxyType(dict(iterator)))
-
-    def __getitem__(self, key: K, /) -> V:
-        return (~self.__lazy)[key]
-
-    def __iter__(self) -> Iterator[K]:
-        yield from ~self.__lazy
-
-    def __len__(self) -> int:
-        return len(~self.__lazy)
-
-    @property
-    def is_set(self) -> bool:
-        return self.__lazy.is_set