python-injection 0.18.4__py3-none-any.whl → 0.18.6__py3-none-any.whl

injection/__init__.pyi

@@ -343,8 +343,6 @@ 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

injection/_core/module.py

@@ -156,6 +156,12 @@ class ModulePriorityUpdated(ModuleEvent):
         )
 
 
+@dataclass(frozen=True, slots=True)
+class UnlockCalled(Event):
+    def __str__(self) -> str:
+        return "An `unlock` method has been called."
+
+
 """
 Broker
 """
@@ -179,7 +185,7 @@ class Broker(Protocol):
         raise NotImplementedError
 
     @abstractmethod
-    def unlock(self) -> Self:
+    def unsafe_unlocking(self) -> None:
         raise NotImplementedError
 
     @abstractmethod
@@ -289,12 +295,10 @@ class Locator(Broker):
 
         return self
 
-    def unlock(self) -> Self:
+    def unsafe_unlocking(self) -> None:
         for injectable in self.__injectables:
             injectable.unlock()
 
-        return self
-
     async def all_ready(self) -> None:
         for injectable in self.__injectables:
             if injectable.is_locked:
@@ -802,21 +806,16 @@ class Module(Broker, EventListener):
         return self
 
     def unlock(self) -> Self:
-        for broker in self.__brokers:
-            broker.unlock()
-
-        return self
+        event = UnlockCalled()
 
-    def load_profile(self, *names: str) -> ContextManager[Self]:
-        modules = (self.from_name(name) for name in names)
-        self.unlock().init_modules(*modules)
+        with self.dispatch(event, lock_bypass=True):
+            self.unsafe_unlocking()
 
-        @contextmanager
-        def unload() -> Iterator[Self]:
-            yield self
-            self.unlock().init_modules()
+        return self
 
-        return unload()
+    def unsafe_unlocking(self) -> None:
+        for broker in self.__brokers:
+            broker.unsafe_unlocking()
 
     async def all_ready(self) -> None:
         for broker in self.__brokers:
@@ -839,8 +838,9 @@ class Module(Broker, EventListener):
         return self.dispatch(self_event)
 
     @contextmanager
-    def dispatch(self, event: Event) -> Iterator[None]:
-        self.__check_locking()
+    def dispatch(self, event: Event, *, lock_bypass: bool = False) -> Iterator[None]:
+        if not lock_bypass:
+            self.__check_locking()
 
         with self.__channel.dispatch(event):
             try:

injection/entrypoint.py

@@ -9,8 +9,8 @@ from types import MethodType
 from types import ModuleType as PythonModule
 from typing import Any, Self, final, overload
 
-from injection import Module, mod
-from injection.loaders import PythonModuleLoader
+from injection import Module
+from injection.loaders import ProfileLoader, PythonModuleLoader
 
 __all__ = ("AsyncEntrypoint", "Entrypoint", "autocall", "entrypointmaker")
 
@@ -35,7 +35,7 @@ def entrypointmaker[*Ts, **P, T1, T2](
     wrapped: EntrypointSetupMethod[*Ts, P, T1, T2],
     /,
     *,
-    module: Module = ...,
+    profile_loader: ProfileLoader = ...,
 ) -> EntrypointDecorator[P, T1, T2]: ...
 
 
@@ -44,7 +44,7 @@ def entrypointmaker[*Ts, **P, T1, T2](
     wrapped: None = ...,
     /,
     *,
-    module: Module = ...,
+    profile_loader: ProfileLoader = ...,
 ) -> Callable[
     [EntrypointSetupMethod[*Ts, P, T1, T2]],
     EntrypointDecorator[P, T1, T2],
@@ -55,12 +55,12 @@ def entrypointmaker[*Ts, **P, T1, T2](
     wrapped: EntrypointSetupMethod[*Ts, P, T1, T2] | None = None,
     /,
     *,
-    module: Module | None = None,
+    profile_loader: ProfileLoader | None = None,
 ) -> Any:
     def decorator(
         wp: EntrypointSetupMethod[*Ts, P, T1, T2],
     ) -> EntrypointDecorator[P, T1, T2]:
-        return Entrypoint._make_decorator(wp, module)
+        return Entrypoint._make_decorator(wp, profile_loader)
 
     return decorator(wrapped) if wrapped else decorator
 
@@ -69,11 +69,15 @@ def entrypointmaker[*Ts, **P, T1, T2](
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class Entrypoint[**P, T]:
     function: Callable[P, T]
-    module: Module = field(default_factory=mod)
+    profile_loader: ProfileLoader = field(default_factory=ProfileLoader)
 
     def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
         return self.function(*args, **kwargs)
 
+    @property
+    def __module(self) -> Module:
+        return self.profile_loader.module
+
     def async_to_sync[_T](
         self: AsyncEntrypoint[P, _T],
         run: Callable[[Coroutine[Any, Any, _T]], _T] = asyncio.run,
@@ -95,7 +99,7 @@ class Entrypoint[**P, T]:
         return self.__recreate(decorator(self.function))
 
     def inject(self) -> Self:
-        return self.decorate(self.module.make_injected_function)
+        return self.decorate(self.__module.make_injected_function)
 
     def load_modules(
         self,
@@ -105,13 +109,13 @@ class Entrypoint[**P, T]:
     ) -> Self:
         return self.setup(lambda: loader.load(*packages))
 
-    def load_profile(self, /, *names: str) -> Self:
+    def load_profile(self, name: str, /) -> Self:
         @contextmanager
-        def decorator(module: Module) -> Iterator[None]:
-            with module.load_profile(*names):
+        def decorator(loader: ProfileLoader) -> Iterator[None]:
+            with loader.load(name):
                 yield
 
-        return self.decorate(decorator(self.module))
+        return self.decorate(decorator(self.profile_loader))
 
     def setup(self, function: Callable[..., Any], /) -> Self:
         @contextmanager
@@ -136,20 +140,21 @@ class Entrypoint[**P, T]:
         function: Callable[_P, _T],
         /,
     ) -> Entrypoint[_P, _T]:
-        return type(self)(function, self.module)
+        return type(self)(function, self.profile_loader)
 
     @classmethod
     def _make_decorator[*Ts, _T](
         cls,
         setup_method: EntrypointSetupMethod[*Ts, P, T, _T],
         /,
-        module: Module | None = None,
+        profile_loader: ProfileLoader | None = None,
     ) -> EntrypointDecorator[P, T, _T]:
-        module = module or mod()
-        setup_method = module.make_injected_function(setup_method)
+        profile_loader = profile_loader or ProfileLoader()
+        setup_method = profile_loader.module.make_injected_function(setup_method)
 
         def decorator(function: Callable[P, T]) -> Callable[P, _T]:
-            self = cls(function, module)
+            profile_loader.init()
+            self = cls(function, profile_loader)
             return MethodType(setup_method, self)().function
 
         return decorator

injection/loaders.py

@@ -1,27 +1,27 @@
+from __future__ import annotations
+
 import itertools
 import sys
-from collections.abc import Callable, Iterator, Mapping
+from abc import abstractmethod
+from collections.abc import Callable, Iterator, Mapping, Sequence
 from dataclasses import dataclass, field
 from importlib import import_module
 from importlib.util import find_spec
 from os.path import isfile
 from pkgutil import walk_packages
-from types import MappingProxyType
+from types import MappingProxyType, TracebackType
 from types import ModuleType as PythonModule
-from typing import ClassVar, ContextManager, Self
-
-from injection import Module, mod
-
-__all__ = ("PythonModuleLoader", "load_packages", "load_profile")
+from typing import ClassVar, Protocol, Self, runtime_checkable
 
+from injection import Module, Priority, mod
 
-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.
-    """
-
-    return mod().load_profile(*names)
+__all__ = (
+    "LoadedProfile",
+    "ProfileLoader",
+    "PythonModuleLoader",
+    "load_packages",
+    "load_profile",
+)
 
 
 def load_packages(
@@ -36,6 +36,15 @@ def load_packages(
     return PythonModuleLoader(predicate).load(*packages).modules
 
 
+def load_profile(name: str, /, loader: ProfileLoader | None = None) -> LoadedProfile:
+    """
+    Injection module initialization function based on a profile name.
+    A profile name is equivalent to an injection module name.
+    """
+
+    return (loader or ProfileLoader()).load(name)
+
+
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class PythonModuleLoader:
     predicate: Callable[[str], bool]
@@ -128,3 +137,78 @@ class PythonModuleLoader:
             return any(script_name.endswith(suffix) for suffix in suffixes)
 
         return cls(predicate)
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class ProfileLoader:
+    dependencies: Mapping[str, Sequence[str]] = field(default=MappingProxyType({}))
+    module: Module = field(default_factory=mod, kw_only=True)
+    __initialized_modules: set[str] = field(default_factory=set, init=False)
+
+    def init(self) -> Self:
+        self.__init_module_dependencies(self.module)
+        return self
+
+    def load(self, name: str, /) -> LoadedProfile:
+        self.init()
+        target_module = self.__init_module_dependencies(mod(name))
+        self.module.use(target_module, priority=Priority.HIGH)
+        return _UserLoadedProfile(self, name)
+
+    def _unload(self, name: str, /) -> None:
+        self.module.unlock().stop_using(mod(name))
+
+    def __init_module_dependencies(self, module: Module) -> Module:
+        if not self.__is_initialized(module):
+            target_modules = tuple(
+                self.__init_module_dependencies(mod(profile_name))
+                for profile_name in self.dependencies.get(module.name, ())
+            )
+            module.unlock().init_modules(*target_modules)
+            self.__mark_initialized(module)
+
+        return module
+
+    def __is_initialized(self, module: Module) -> bool:
+        return module.name in self.__initialized_modules
+
+    def __mark_initialized(self, module: Module) -> None:
+        self.__initialized_modules.add(module.name)
+
+
+@runtime_checkable
+class LoadedProfile(Protocol):
+    __slots__ = ()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.unload()
+
+    @abstractmethod
+    def reload(self) -> Self:
+        raise NotImplementedError
+
+    @abstractmethod
+    def unload(self) -> Self:
+        raise NotImplementedError
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class _UserLoadedProfile(LoadedProfile):
+    loader: ProfileLoader
+    name: str
+
+    def reload(self) -> Self:
+        self.loader.load(self.name)
+        return self
+
+    def unload(self) -> Self:
+        self.loader._unload(self.name)
+        return self

injection/testing/__init__.py

@@ -1,7 +1,7 @@
-from typing import ContextManager, Final
+from typing import Final
 
-from injection import Module, mod
-from injection.loaders import load_profile
+from injection import mod
+from injection.loaders import LoadedProfile, ProfileLoader, load_profile
 
 __all__ = (
     "load_test_profile",
@@ -25,5 +25,5 @@ test_scoped = mod(_TEST_PROFILE_NAME).scoped
 test_singleton = mod(_TEST_PROFILE_NAME).singleton
 
 
-def load_test_profile(*names: str) -> ContextManager[Module]:
-    return load_profile(_TEST_PROFILE_NAME, *names)
+def load_test_profile(loader: ProfileLoader | None = None) -> LoadedProfile:
+    return load_profile(_TEST_PROFILE_NAME, loader)

injection/testing/__init__.pyi

@@ -1,6 +1,7 @@
-from typing import ContextManager, Final
+from typing import Final
 
 from injection import Module
+from injection.loaders import LoadedProfile, ProfileLoader
 
 __MODULE: Final[Module] = ...
 
@@ -12,7 +13,7 @@ test_injectable = __MODULE.injectable
 test_scoped = __MODULE.scoped
 test_singleton = __MODULE.singleton
 
-def load_test_profile(*names: str) -> ContextManager[Module]:
+def load_test_profile(loader: ProfileLoader = ...) -> LoadedProfile:
     """
-    Context manager or decorator for temporary use test module.
+    Context manager for temporary use test module.
     """

{python_injection-0.18.4.dist-info → python_injection-0.18.6.dist-info}/METADATA

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

{python_injection-0.18.4.dist-info → python_injection-0.18.6.dist-info}/RECORD

@@ -1,13 +1,13 @@
 injection/__init__.py,sha256=7ZRUlO5EEPWO7IlbYHD-8DOX-cg4Np4nYq5fpw-U56o,1259
-injection/__init__.pyi,sha256=O2W6ZWcwH58JnDmJNkJ6cdoaO0D2NE7PEVFgfJNTwB0,10717
-injection/entrypoint.py,sha256=oTOwU2MXAaATuawADQ4KOPp5Tet2gL4dJD0IdClZ8sY,4461
+injection/__init__.pyi,sha256=33A511o3QKQAiQOHL8OQtFPdF-ObM1BqWPmswXhxj7c,10634
+injection/entrypoint.py,sha256=12b0_zHAFxHCerAoJTIHkhqi3mLkgheECYAaCUZv_DU,4751
 injection/exceptions.py,sha256=v57yMujiq6H_zwwn30A8UYEZX9R9k-bY8FnsdaimPM4,1025
-injection/loaders.py,sha256=8tS3zVvmxKf5E1ZJBTBjZpHkXETxNCL1dq8rbh2vzy4,4075
+injection/loaders.py,sha256=_0V64d45WoT0OVWML8ZQts4gMXCbT7LkCS3KLl6STMI,6509
 injection/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/descriptors.py,sha256=jH0pyIlPurMmU4yXr-HKS_7BJ-9d0XUvEx4pQre3QeI,704
 injection/_core/injectables.py,sha256=Rg1nxDkbcpeX4ELohrNVMguPhN36SNQuD0JKfyfL6bI,6192
-injection/_core/module.py,sha256=mYc-x7hH-mbminiOFXJWxA7KkBpleuW84IOpzfeKQHc,31874
+injection/_core/module.py,sha256=zpYLLhtXPLb6hE1U_A5AJ-ffffT_aPrq4DuVmJoxz3A,31931
 injection/_core/scope.py,sha256=OBzVY1mUApryqIZKQtwHz7wiuY13MfouyaHp50DpWeQ,8300
 injection/_core/slots.py,sha256=g9TG6CbqRzCsjg01iPyfRtTTUCJnnJOwcj9mJabH0dc,37
 injection/_core/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -20,9 +20,9 @@ injection/_core/common/type.py,sha256=SCDtmBv9qFvEf5o5tTgCuwMDfuo1fgjSW0bUqA8ACi
 injection/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/ext/fastapi.py,sha256=layUUer5IWiZX6Mmx1_RCYDLNCtEHtpya5ZL6TTBOkY,968
 injection/ext/fastapi.pyi,sha256=8OZEUjHFB9n7QXv_dtXdDuXW-r2huQEFsJ03gJOOvwQ,125
-injection/testing/__init__.py,sha256=PsrvNxYvn11if8CJpEYxcTxniqMt2w_7fBaDkY9RA5o,898
-injection/testing/__init__.pyi,sha256=iOii0i9F5n7znltGeGQYI2KXC_if9SAogLh1h03yx-0,540
-python_injection-0.18.4.dist-info/METADATA,sha256=ZECngXj7kg_M2cFQd3uWHJKuRiDbOLY8m97kF8LrZtU,3397
-python_injection-0.18.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_injection-0.18.4.dist-info/licenses/LICENSE,sha256=oC77BOa9kaaQni5rW-Z-ytz3E5h4EVg248BHg9UFgyg,1063
-python_injection-0.18.4.dist-info/RECORD,,
+injection/testing/__init__.py,sha256=bJ7WXBXrw4rHc91AFVFnOwFLWOlpvX9Oh2SnRQ_NESo,919
+injection/testing/__init__.pyi,sha256=raGsGlxwbz3jkzJwA_5oCIE1emWINjT2UuwzbnqRb-0,577
+python_injection-0.18.6.dist-info/METADATA,sha256=J8D8DrVAJfAoGen7LNrtT303UXR5yUT5fYw6P6ufVsQ,3397
+python_injection-0.18.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_injection-0.18.6.dist-info/licenses/LICENSE,sha256=oC77BOa9kaaQni5rW-Z-ytz3E5h4EVg248BHg9UFgyg,1063
+python_injection-0.18.6.dist-info/RECORD,,