python-injection 0.10.12__tar.gz → 0.11.0__tar.gz

{python_injection-0.10.12 → python_injection-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.10.12
+Version: 0.11.0
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT

{python_injection-0.10.12 → python_injection-0.11.0}/injection/__init__.py

@@ -1,7 +1,9 @@
+from ._core.descriptors import LazyInstance
 from ._core.module import Injectable, Mode, Module, Priority
 
 __all__ = (
     "Injectable",
+    "LazyInstance",
     "Mode",
     "Module",
     "Priority",

{python_injection-0.10.12 → python_injection-0.11.0}/injection/__init__.pyi

@@ -9,6 +9,7 @@ from typing import (
     Protocol,
     Self,
     final,
+    overload,
     runtime_checkable,
 )
 
@@ -136,23 +137,31 @@ class Module:
         parameter or an exception will be raised.
         """
 
+    @overload
     def get_instance[T, Default](
         self,
         cls: _InputType[T],
-        default: Default | None = ...,
-    ) -> T | Default | None:
+        default: Default,
+    ) -> T | Default:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or return `None`.
         """
 
+    @overload
+    def get_instance[T, _](
+        self,
+        cls: _InputType[T],
+        default: None = ...,
+    ) -> T | None: ...
+    @overload
     def get_lazy_instance[T, Default](
         self,
         cls: _InputType[T],
-        default: Default | None = ...,
+        default: Default,
         *,
         cache: bool = ...,
-    ) -> _Invertible[T | Default | None]:
+    ) -> _Invertible[T | Default]:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or `None`. Return a `Invertible` object. To access the instance
@@ -162,6 +171,14 @@ class Module:
         Example: instance = ~lazy_instance
         """
 
+    @overload
+    def get_lazy_instance[T, _](
+        self,
+        cls: _InputType[T],
+        default: None = ...,
+        *,
+        cache: bool = ...,
+    ) -> _Invertible[T | None]: ...
     def init_modules(self, *modules: Module) -> Self:
         """
         Function to clean modules in use and to use those passed as parameters.
@@ -243,3 +260,10 @@ class Mode(Enum):
     FALLBACK = ...
     NORMAL = ...
     OVERRIDE = ...
+
+class LazyInstance[T]:
+    def __init__(self, cls: _InputType[T], module: Module = ...) -> None: ...
+    @overload
+    def __get__(self, instance: object, owner: type | None = ...) -> T: ...
+    @overload
+    def __get__(self, instance: None = ..., owner: type | None = ...) -> Self: ...

{python_injection-0.10.12 → python_injection-0.11.0}/injection/_core/common/event.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Iterator
-from contextlib import ExitStack, contextmanager, suppress
+from contextlib import ExitStack, contextmanager
 from dataclasses import dataclass, field
 from typing import ContextManager, Self
 from weakref import WeakSet
@@ -40,7 +40,5 @@ class EventChannel:
         return self
 
     def remove_listener(self, listener: EventListener) -> Self:
-        with suppress(KeyError):
-            self.__listeners.remove(listener)
-
+        self.__listeners.discard(listener)
         return self

python_injection-0.11.0/injection/_core/descriptors.py

@@ -0,0 +1,25 @@
+from typing import Self
+
+from injection._core.common.invertible import Invertible
+from injection._core.common.type import InputType
+from injection._core.module import Module
+
+
+class LazyInstance[T]:
+    __slots__ = ("__value",)
+
+    __value: Invertible[T]
+
+    def __init__(self, cls: InputType[T], module: Module | None = None) -> None:
+        module = module or Module.default()
+        self.__value = module.get_lazy_instance(cls, default=NotImplemented)  # type: ignore[assignment]
+
+    def __get__(
+        self,
+        instance: object | None = None,
+        owner: type | None = None,
+    ) -> Self | T:
+        if instance is None:
+            return self
+
+        return ~self.__value

{python_injection-0.10.12 → python_injection-0.11.0}/injection/integrations/fastapi.py

@@ -1,6 +1,6 @@
 from collections.abc import Callable
 from types import GenericAlias
-from typing import Any, ClassVar, TypeAliasType
+from typing import Any, TypeAliasType
 
 from injection import Module, mod
 from injection.exceptions import InjectionError
@@ -34,10 +34,8 @@ class InjectionDependency[T]:
     __class: type[T] | TypeAliasType | GenericAlias
     __module: Module
 
-    __sentinel: ClassVar[object] = object()
-
     def __init__(self, cls: type[T] | TypeAliasType | GenericAlias, module: Module):
-        lazy_instance = module.get_lazy_instance(cls, default=self.__sentinel)
+        lazy_instance = module.get_lazy_instance(cls, default=NotImplemented)
         self.__call__ = lambda: self.__ensure(~lazy_instance)
         self.__class = cls
         self.__module = module
@@ -55,8 +53,8 @@ class InjectionDependency[T]:
     def __key(self) -> tuple[type[T] | TypeAliasType | GenericAlias, Module]:
         return self.__class, self.__module
 
-    def __ensure(self, instance: T | Any) -> T:
-        if instance is self.__sentinel:
+    def __ensure(self, instance: T) -> T:
+        if instance is NotImplemented:
             raise InjectionError(f"`{self.__class}` is an unknown dependency.")
 
         return instance

{python_injection-0.10.12 → python_injection-0.11.0}/injection/testing/__init__.py

@@ -21,5 +21,5 @@ test_injectable = mod(_TEST_PROFILE_NAME).injectable
 test_singleton = mod(_TEST_PROFILE_NAME).singleton
 
 
-def load_test_profile(*other_profile_names: str) -> ContextManager[None]:
-    return load_profile(_TEST_PROFILE_NAME, *other_profile_names)
+def load_test_profile(*names: str) -> ContextManager[None]:
+    return load_profile(_TEST_PROFILE_NAME, *names)

{python_injection-0.10.12 → python_injection-0.11.0}/injection/utils.py

@@ -10,13 +10,13 @@ from injection import mod
 __all__ = ("load_packages", "load_profile")
 
 
-def load_profile(name: str, /, *other_profile_names: str) -> ContextManager[None]:
+def load_profile(*names: str) -> ContextManager[None]:
     """
     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 (name, *other_profile_names))
+    modules = tuple(mod(module_name) for module_name in names)
 
     for module in modules:
         module.unlock()

{python_injection-0.10.12 → python_injection-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.10.12"
+version = "0.11.0"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
 authors = ["remimd"]