python-injection 0.18.13__tar.gz → 0.19.0__tar.gz

{python_injection-0.18.13 → python_injection-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.18.13
+Version: 0.19.0
 Summary: Fast and easy dependency injection framework.
 Project-URL: Repository, https://github.com/100nm/python-injection
 Author: remimd
@@ -14,6 +14,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
@@ -27,11 +29,10 @@ Description-Content-Type: text/markdown
 # python-injection
 
 [![CI](https://github.com/100nm/python-injection/actions/workflows/ci.yml/badge.svg)](https://github.com/100nm/python-injection)
-[![PyPI](https://img.shields.io/pypi/v/python-injection.svg?color=blue)](https://pypi.org/project/python-injection)
+[![PyPI - Version](https://img.shields.io/pypi/v/python-injection.svg?color=blue)](https://pypi.org/project/python-injection)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/python-injection.svg?color=blue)](https://pypistats.org/packages/python-injection)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
-Fast and easy dependency injection framework.
-
 ## Installation
 
 ⚠️ _Requires Python 3.12 or higher_
@@ -40,12 +41,22 @@ Fast and easy dependency injection framework.
 pip install python-injection
 ```
 
+## Features
+
+* Automatic dependency resolution based on type hints.
+* Support for multiple dependency lifetimes: `transient`, `singleton`, `constant`, and `scoped`.
+* Works seamlessly in both `async` and `sync` environments.
+* Separation of dependency sets using modules.
+* Runtime switching between different sets of dependencies.
+* Centralized setup logic using entrypoints.
+* Built-in type annotation for easy integration with [`FastAPI`](https://github.com/fastapi/fastapi).
+* Lazy dependency resolution for optimized performance.
+
 ## Motivations
 
 1. Easy to use
 2. No impact on class and function definitions
-3. Easily interchangeable dependencies _(depending on the runtime environment, for example)_
-4. No prerequisites
+3. No tedious configuration
 
 ## Quick start
 
@@ -90,5 +101,7 @@ if __name__ == "__main__":
 * [**Advanced usage**](https://github.com/100nm/python-injection/tree/prod/documentation/advanced-usage.md)
 * [**Loaders**](https://github.com/100nm/python-injection/tree/prod/documentation/loaders.md)
 * [**Entrypoint**](https://github.com/100nm/python-injection/tree/prod/documentation/entrypoint.md)
-* [**Integrations**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations.md)
+* [**Integrations**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations)
+  * [**FastAPI**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations/fastapi.md)
+  * [**What if my framework isn't listed?**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations/unlisted-framework.md)
 * [**Concrete example**](https://github.com/100nm/python-injection-example)

{python_injection-0.18.13 → python_injection-0.19.0}/README.md

@@ -1,11 +1,10 @@
 # python-injection
 
 [![CI](https://github.com/100nm/python-injection/actions/workflows/ci.yml/badge.svg)](https://github.com/100nm/python-injection)
-[![PyPI](https://img.shields.io/pypi/v/python-injection.svg?color=blue)](https://pypi.org/project/python-injection)
+[![PyPI - Version](https://img.shields.io/pypi/v/python-injection.svg?color=blue)](https://pypi.org/project/python-injection)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/python-injection.svg?color=blue)](https://pypistats.org/packages/python-injection)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
-Fast and easy dependency injection framework.
-
 ## Installation
 
 ⚠️ _Requires Python 3.12 or higher_
@@ -14,12 +13,22 @@ Fast and easy dependency injection framework.
 pip install python-injection
 ```
 
+## Features
+
+* Automatic dependency resolution based on type hints.
+* Support for multiple dependency lifetimes: `transient`, `singleton`, `constant`, and `scoped`.
+* Works seamlessly in both `async` and `sync` environments.
+* Separation of dependency sets using modules.
+* Runtime switching between different sets of dependencies.
+* Centralized setup logic using entrypoints.
+* Built-in type annotation for easy integration with [`FastAPI`](https://github.com/fastapi/fastapi).
+* Lazy dependency resolution for optimized performance.
+
 ## Motivations
 
 1. Easy to use
 2. No impact on class and function definitions
-3. Easily interchangeable dependencies _(depending on the runtime environment, for example)_
-4. No prerequisites
+3. No tedious configuration
 
 ## Quick start
 
@@ -64,5 +73,7 @@ if __name__ == "__main__":
 * [**Advanced usage**](https://github.com/100nm/python-injection/tree/prod/documentation/advanced-usage.md)
 * [**Loaders**](https://github.com/100nm/python-injection/tree/prod/documentation/loaders.md)
 * [**Entrypoint**](https://github.com/100nm/python-injection/tree/prod/documentation/entrypoint.md)
-* [**Integrations**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations.md)
+* [**Integrations**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations)
+  * [**FastAPI**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations/fastapi.md)
+  * [**What if my framework isn't listed?**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations/unlisted-framework.md)
 * [**Concrete example**](https://github.com/100nm/python-injection-example)

{python_injection-0.18.13 → python_injection-0.19.0}/injection/__init__.py

@@ -1,3 +1,4 @@
+from ._core.asfunction import asfunction
 from ._core.descriptors import LazyInstance
 from ._core.injectables import Injectable
 from ._core.module import Mode, Module, Priority, mod
@@ -18,6 +19,7 @@ __all__ = (
     "afind_instance",
     "aget_instance",
     "aget_lazy_instance",
+    "asfunction",
     "constant",
     "define_scope",
     "find_instance",

{python_injection-0.18.13 → python_injection-0.19.0}/injection/__init__.pyi

@@ -30,19 +30,35 @@ set_constant = __MODULE.set_constant
 should_be_injectable = __MODULE.should_be_injectable
 singleton = __MODULE.singleton
 
+@overload
+def asfunction[**P, T](
+    wrapped: type[Callable[P, T]],
+    /,
+    *,
+    module: Module = ...,
+    threadsafe: bool | None = ...,
+) -> Callable[P, T]: ...
+@overload
+def asfunction[**P, T](
+    wrapped: None = ...,
+    /,
+    *,
+    module: Module = ...,
+    threadsafe: bool | None = ...,
+) -> Callable[[type[Callable[P, T]]], Callable[P, T]]: ...
 @asynccontextmanager
 def adefine_scope(
     name: str,
     /,
     kind: ScopeKind | ScopeKindStr = ...,
-    threadsafe: bool = ...,
+    threadsafe: bool | None = ...,
 ) -> AsyncIterator[Scope]: ...
 @contextmanager
 def define_scope(
     name: str,
     /,
     kind: ScopeKind | ScopeKindStr = ...,
-    threadsafe: bool = ...,
+    threadsafe: bool | None = ...,
 ) -> Iterator[Scope]: ...
 def mod(name: str = ..., /) -> Module:
     """
@@ -80,7 +96,7 @@ class LazyInstance[T]:
         default: T = ...,
         *,
         module: Module = ...,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> None: ...
     @overload
     def __get__(self, instance: object, owner: type | None = ...) -> T: ...
@@ -108,14 +124,14 @@ class Module:
         wrapped: Callable[P, T] = ...,
         /,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> 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`.
+        With `threadsafe=True`, the injection logic is wrapped in a `threading.RLock`.
         """
 
     def injectable[**P, T](
@@ -149,7 +165,7 @@ class Module:
         always be the same.
         """
 
-    def scoped[**P, T](
+    def scoped[T](
         self,
         scope_name: str,
         /,
@@ -171,18 +187,18 @@ class Module:
         registered.
         """
 
-    def constant[T](
+    def constant[**P, T](
         self,
-        wrapped: type[T] = ...,
+        wrapped: _Recipe[P, T] = ...,
         /,
         *,
         on: _TypeInfo[T] = ...,
         mode: Mode | ModeStr = ...,
     ) -> Any:
         """
-        Decorator applicable to a class. It is used to indicate how the constant is
-        constructed. At injection time, the injected instance will always be the same.
-        Unlike `@singleton`, dependencies will not be resolved.
+        Decorator applicable to a class or function. It is used to indicate how the
+        constant is constructed. At injection time, the injected instance will always
+        be the same. Unlike `@singleton`, dependencies will not be resolved.
         """
 
     def set_constant[T](
@@ -211,21 +227,26 @@ class Module:
         self,
         wrapped: Callable[P, T],
         /,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> Callable[P, T]: ...
     def make_async_factory[T](
         self,
         wrapped: type[T],
         /,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> Callable[..., Awaitable[T]]: ...
     async def afind_instance[T](
         self,
         cls: _InputType[T],
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> T: ...
-    def find_instance[T](self, cls: _InputType[T], *, threadsafe: bool = ...) -> T:
+    def find_instance[T](
+        self,
+        cls: _InputType[T],
+        *,
+        threadsafe: bool | None = ...,
+    ) -> T:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or an exception will be raised.
@@ -237,7 +258,7 @@ class Module:
         cls: _InputType[T],
         default: Default,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> T | Default: ...
     @overload
     async def aget_instance[T](
@@ -245,7 +266,7 @@ class Module:
         cls: _InputType[T],
         default: T = ...,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> T: ...
     @overload
     def get_instance[T, Default](
@@ -253,7 +274,7 @@ class Module:
         cls: _InputType[T],
         default: Default,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> T | Default:
         """
         Function used to retrieve an instance associated with the type passed in
@@ -266,7 +287,7 @@ class Module:
         cls: _InputType[T],
         default: T = ...,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> T: ...
     @overload
     def aget_lazy_instance[T, Default](
@@ -274,7 +295,7 @@ class Module:
         cls: _InputType[T],
         default: Default,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> Awaitable[T | Default]: ...
     @overload
     def aget_lazy_instance[T](
@@ -282,7 +303,7 @@ class Module:
         cls: _InputType[T],
         default: T = ...,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> Awaitable[T]: ...
     @overload
     def get_lazy_instance[T, Default](
@@ -290,7 +311,7 @@ class Module:
         cls: _InputType[T],
         default: Default,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> _Invertible[T | Default]:
         """
         Function used to retrieve an instance associated with the type passed in
@@ -306,7 +327,7 @@ class Module:
         cls: _InputType[T],
         default: T = ...,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> _Invertible[T]: ...
     def init_modules(self, *modules: Module) -> Self:
         """

python_injection-0.19.0/injection/_core/asfunction.py

@@ -0,0 +1,47 @@
+from collections.abc import Callable
+from functools import wraps
+from inspect import iscoroutinefunction
+from typing import Any
+
+from injection._core.common.asynchronous import Caller
+from injection._core.module import Module, mod
+
+
+def asfunction[**P, T](
+    wrapped: type[Callable[P, T]] | None = None,
+    /,
+    *,
+    module: Module | None = None,
+    threadsafe: bool | None = None,
+) -> Any:
+    module = module or mod()
+
+    def decorator(wp: type[Callable[P, T]]) -> Callable[P, T]:
+        get_method = wp.__call__.__get__
+        method = get_method(NotImplemented)
+        factory: Caller[..., Callable[P, T]] = module.make_injected_function(
+            wp,
+            threadsafe=threadsafe,
+        ).__inject_metadata__
+
+        wrapper: Callable[P, T]
+
+        if iscoroutinefunction(method):
+
+            @wraps(method)
+            async def wrapper(*args: P.args, **kwargs: P.kwargs) -> Any:
+                self = await factory.acall()
+                return await get_method(self)(*args, **kwargs)
+
+        else:
+
+            @wraps(method)
+            def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+                self = factory.call()
+                return get_method(self)(*args, **kwargs)
+
+        wrapper.__name__ = wp.__name__
+        wrapper.__qualname__ = wp.__qualname__
+        return wrapper
+
+    return decorator(wrapped) if wrapped else decorator

{python_injection-0.18.13 → python_injection-0.19.0}/injection/_core/common/asynchronous.py

@@ -1,7 +1,26 @@
 from abc import abstractmethod
 from collections.abc import Awaitable, Callable, Generator
 from dataclasses import dataclass
-from typing import Any, AsyncContextManager, NoReturn, Protocol, runtime_checkable
+from typing import (
+    Any,
+    AsyncContextManager,
+    NoReturn,
+    Protocol,
+    runtime_checkable,
+)
+
+AsyncSemaphore: Callable[[int], AsyncContextManager[Any]]
+
+try:
+    import anyio
+
+except ImportError:  # pragma: no cover
+    import asyncio
+
+    AsyncSemaphore = asyncio.Semaphore
+
+else:
+    AsyncSemaphore = anyio.Semaphore
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
@@ -45,16 +64,3 @@ class SyncCaller[**P, T](Caller[P, T]):
 
     def call(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
         return self.callable(*args, **kwargs)
-
-
-try:
-    import anyio
-
-    def create_semaphore(value: int) -> AsyncContextManager[Any]:
-        return anyio.Semaphore(value)
-
-except ImportError:  # pragma: no cover
-    import asyncio
-
-    def create_semaphore(value: int) -> AsyncContextManager[Any]:
-        return asyncio.Semaphore(value)

{python_injection-0.18.13 → python_injection-0.19.0}/injection/_core/common/threading.py

@@ -3,5 +3,5 @@ from threading import RLock
 from typing import Any, ContextManager
 
 
-def get_lock(threadsafe: bool) -> ContextManager[Any]:
+def get_lock(threadsafe: bool | None = None) -> ContextManager[Any]:
     return RLock() if threadsafe else nullcontext()

{python_injection-0.18.13 → python_injection-0.19.0}/injection/_core/descriptors.py

@@ -17,7 +17,7 @@ class LazyInstance[T]:
         default: T = NotImplemented,
         *,
         module: Module | None = None,
-        threadsafe: bool = False,
+        threadsafe: bool | None = None,
     ) -> None:
         module = module or mod()
         self.__value = module.get_lazy_instance(cls, default, threadsafe=threadsafe)

{python_injection-0.18.13 → python_injection-0.19.0}/injection/_core/injectables.py

@@ -13,10 +13,7 @@ from typing import (
     runtime_checkable,
 )
 
-from injection._core.common.asynchronous import Caller
-from injection._core.common.asynchronous import (
-    create_semaphore as _create_async_semaphore,
-)
+from injection._core.common.asynchronous import AsyncSemaphore, Caller
 from injection._core.scope import (
     Scope,
     get_scope,
@@ -64,7 +61,7 @@ class CacheLogic[T]:
     __semaphore: AsyncContextManager[Any]
 
     def __init__(self) -> None:
-        self.__semaphore = _create_async_semaphore(1)
+        self.__semaphore = AsyncSemaphore(1)
 
     async def aget_or_create[K](
         self,

{python_injection-0.18.13 → python_injection-0.19.0}/injection/_core/module.py

@@ -503,15 +503,15 @@ class Module(Broker, EventListener):
 
         return decorator(wrapped) if wrapped else decorator
 
-    def constant[T](
+    def constant[**P, T](
         self,
-        wrapped: type[T] | None = None,
+        wrapped: Recipe[P, T] | None = None,
         /,
         *,
         on: TypeInfo[T] = (),
         mode: Mode | ModeStr = Mode.get_default(),
     ) -> Any:
-        def decorator(wp: type[T]) -> type[T]:
+        def decorator(wp: Recipe[P, T]) -> Recipe[P, T]:
             lazy_instance = lazy(wp)
             self.injectable(
                 lambda: ~lazy_instance,
@@ -560,7 +560,7 @@ class Module(Broker, EventListener):
         wrapped: Callable[P, T] | None = None,
         /,
         *,
-        threadsafe: bool = False,
+        threadsafe: bool | None = None,
     ) -> Any:
         def decorator(wp: Callable[P, T]) -> Callable[P, T]:
             if isclass(wp):
@@ -576,7 +576,7 @@ class Module(Broker, EventListener):
         self,
         wrapped: Callable[P, T],
         /,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> SyncInjectedFunction[P, T]: ...
 
     @overload
@@ -584,14 +584,14 @@ class Module(Broker, EventListener):
         self,
         wrapped: Callable[P, Awaitable[T]],
         /,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> AsyncInjectedFunction[P, T]: ...
 
     def make_injected_function[**P, T](
         self,
         wrapped: Callable[P, T],
         /,
-        threadsafe: bool = False,
+        threadsafe: bool | None = None,
     ) -> InjectedFunction[P, T]:
         metadata = InjectMetadata(wrapped, threadsafe)
 
@@ -609,7 +609,7 @@ class Module(Broker, EventListener):
         self,
         wrapped: type[T],
         /,
-        threadsafe: bool = False,
+        threadsafe: bool | None = None,
     ) -> Callable[..., Awaitable[T]]:
         factory: InjectedFunction[..., T] = self.make_injected_function(
             wrapped,
@@ -621,13 +621,18 @@ class Module(Broker, EventListener):
         self,
         cls: InputType[T],
         *,
-        threadsafe: bool = False,
+        threadsafe: bool | None = None,
     ) -> T:
         with get_lock(threadsafe):
             injectable = self[cls]
             return await injectable.aget_instance()
 
-    def find_instance[T](self, cls: InputType[T], *, threadsafe: bool = False) -> T:
+    def find_instance[T](
+        self,
+        cls: InputType[T],
+        *,
+        threadsafe: bool | None = None,
+    ) -> T:
         with get_lock(threadsafe):
             injectable = self[cls]
             return injectable.get_instance()
@@ -638,7 +643,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: Default,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> T | Default: ...
 
     @overload
@@ -647,7 +652,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: T = ...,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> T: ...
 
     async def aget_instance[T, Default](
@@ -655,7 +660,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: Default = NotImplemented,
         *,
-        threadsafe: bool = False,
+        threadsafe: bool | None = None,
     ) -> T | Default:
         try:
             return await self.afind_instance(cls, threadsafe=threadsafe)
@@ -668,7 +673,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: Default,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> T | Default: ...
 
     @overload
@@ -677,7 +682,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: T = ...,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> T: ...
 
     def get_instance[T, Default](
@@ -685,7 +690,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: Default = NotImplemented,
         *,
-        threadsafe: bool = False,
+        threadsafe: bool | None = None,
     ) -> T | Default:
         try:
             return self.find_instance(cls, threadsafe=threadsafe)
@@ -698,7 +703,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: Default,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> Awaitable[T | Default]: ...
 
     @overload
@@ -707,7 +712,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: T = ...,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> Awaitable[T]: ...
 
     def aget_lazy_instance[T, Default](
@@ -715,7 +720,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: Default = NotImplemented,
         *,
-        threadsafe: bool = False,
+        threadsafe: bool | None = None,
     ) -> Awaitable[T | Default]:
         function = self.make_injected_function(
             lambda instance=default: instance,
@@ -730,7 +735,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: Default,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> Invertible[T | Default]: ...
 
     @overload
@@ -739,7 +744,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: T = ...,
         *,
-        threadsafe: bool = ...,
+        threadsafe: bool | None = ...,
     ) -> Invertible[T]: ...
 
     def get_lazy_instance[T, Default](
@@ -747,7 +752,7 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: Default = NotImplemented,
         *,
-        threadsafe: bool = False,
+        threadsafe: bool | None = None,
     ) -> Invertible[T | Default]:
         function = self.make_injected_function(
             lambda instance=default: instance,
@@ -1013,7 +1018,12 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
     __tasks: deque[Callable[..., Any]]
     __wrapped: Callable[P, T]
 
-    def __init__(self, wrapped: Callable[P, T], /, threadsafe: bool) -> None:
+    def __init__(
+        self,
+        wrapped: Callable[P, T],
+        /,
+        threadsafe: bool | None = None,
+    ) -> None:
         self.__dependencies = Dependencies.empty()
         self.__lock = get_lock(threadsafe)
         self.__owner = None
@@ -1087,7 +1097,7 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
         return decorator(wrapped) if wrapped else decorator
 
     @singledispatchmethod
-    def on_event(self, event: Event, /) -> ContextManager[None] | None:  # type: ignore[override]
+    def on_event(self, event: Event, /) -> ContextManager[None] | None:
         return None
 
     @on_event.register

{python_injection-0.18.13 → python_injection-0.19.0}/injection/_core/scope.py

@@ -130,7 +130,7 @@ async def adefine_scope(
     name: str,
     /,
     kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
-    threadsafe: bool = False,
+    threadsafe: bool | None = None,
 ) -> AsyncIterator[ScopeFacade]:
     async with AsyncScope() as scope:
         with _bind_scope(name, scope, kind, threadsafe) as facade:
@@ -142,7 +142,7 @@ def define_scope(
     name: str,
     /,
     kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
-    threadsafe: bool = False,
+    threadsafe: bool | None = None,
 ) -> Iterator[ScopeFacade]:
     with SyncScope() as scope:
         with _bind_scope(name, scope, kind, threadsafe) as facade:
@@ -194,7 +194,7 @@ def _bind_scope(
     name: str,
     scope: Scope,
     kind: ScopeKind | ScopeKindStr,
-    threadsafe: bool,
+    threadsafe: bool | None,
 ) -> Iterator[ScopeFacade]:
     lock = get_lock(threadsafe)
 

{python_injection-0.18.13 → python_injection-0.19.0}/injection/entrypoint.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass, field
 from functools import wraps
 from types import MethodType
 from types import ModuleType as PythonModule
-from typing import Any, Self, final, overload
+from typing import Any, Concatenate, Self, final, overload
 
 from injection import Module
 from injection.loaders import ProfileLoader, PythonModuleLoader
@@ -16,9 +16,9 @@ __all__ = ("AsyncEntrypoint", "Entrypoint", "autocall", "entrypointmaker")
 
 type AsyncEntrypoint[**P, T] = Entrypoint[P, Coroutine[Any, Any, T]]
 type EntrypointDecorator[**P, T1, T2] = Callable[[Callable[P, T1]], Callable[P, T2]]
-type EntrypointSetupMethod[*Ts, **P, T1, T2] = Callable[
-    [Entrypoint[P, T1], *Ts],
-    Entrypoint[P, T2],
+type EntrypointSetupMethod[**P, **EPP, T1, T2] = Callable[
+    Concatenate[Entrypoint[EPP, T1], P],
+    Entrypoint[EPP, T2],
 ]
 
 
@@ -31,35 +31,35 @@ def autocall[**P, T](wrapped: Callable[P, T] | None = None, /) -> Any:
 
 
 @overload
-def entrypointmaker[*Ts, **P, T1, T2](
-    wrapped: EntrypointSetupMethod[*Ts, P, T1, T2],
+def entrypointmaker[**SMP, **EPP, T1, T2](
+    wrapped: EntrypointSetupMethod[SMP, EPP, T1, T2],
     /,
     *,
     profile_loader: ProfileLoader = ...,
-) -> EntrypointDecorator[P, T1, T2]: ...
+) -> EntrypointDecorator[EPP, T1, T2]: ...
 
 
 @overload
-def entrypointmaker[*Ts, **P, T1, T2](
+def entrypointmaker[**SMP, **EPP, T1, T2](
     wrapped: None = ...,
     /,
     *,
     profile_loader: ProfileLoader = ...,
 ) -> Callable[
-    [EntrypointSetupMethod[*Ts, P, T1, T2]],
-    EntrypointDecorator[P, T1, T2],
+    [EntrypointSetupMethod[SMP, EPP, T1, T2]],
+    EntrypointDecorator[EPP, T1, T2],
 ]: ...
 
 
-def entrypointmaker[*Ts, **P, T1, T2](
-    wrapped: EntrypointSetupMethod[*Ts, P, T1, T2] | None = None,
+def entrypointmaker[**SMP, **EPP, T1, T2](
+    wrapped: EntrypointSetupMethod[SMP, EPP, T1, T2] | None = None,
     /,
     *,
     profile_loader: ProfileLoader | None = None,
 ) -> Any:
     def decorator(
-        wp: EntrypointSetupMethod[*Ts, P, T1, T2],
-    ) -> EntrypointDecorator[P, T1, T2]:
+        wp: EntrypointSetupMethod[SMP, EPP, T1, T2],
+    ) -> EntrypointDecorator[EPP, T1, T2]:
         return Entrypoint._make_decorator(wp, profile_loader)
 
     return decorator(wrapped) if wrapped else decorator
@@ -143,9 +143,9 @@ class Entrypoint[**P, T]:
         return type(self)(function, self.profile_loader)
 
     @classmethod
-    def _make_decorator[*Ts, _T](
+    def _make_decorator[**_P, _T](
         cls,
-        setup_method: EntrypointSetupMethod[*Ts, P, T, _T],
+        setup_method: EntrypointSetupMethod[_P, P, T, _T],
         /,
         profile_loader: ProfileLoader | None = None,
     ) -> EntrypointDecorator[P, T, _T]:

{python_injection-0.18.13 → python_injection-0.19.0}/injection/ext/fastapi.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from types import GenericAlias
-from typing import Annotated, Any, TypeAliasType
+from typing import Annotated, Any, TypeAlias, TypeAliasType
 
 from fastapi import Depends
 
@@ -12,7 +12,7 @@ __all__ = ("Inject", "InjectThreadSafe")
 @dataclass(eq=False, frozen=True, slots=True)
 class FastAPIInject:
     module: Module = field(default_factory=mod)
-    threadsafe: bool = field(default=False, kw_only=True)
+    threadsafe: bool | None = field(default=None, kw_only=True)
 
     def __call__[T](
         self,
@@ -25,16 +25,16 @@ class FastAPIInject:
     ) -> Any:
         module = module or self.module
         threadsafe = self.threadsafe if threadsafe is None else threadsafe
-        ainstance = module.aget_lazy_instance(cls, default, threadsafe=threadsafe)
+        lazy_instance = module.aget_lazy_instance(cls, default, threadsafe=threadsafe)
 
         async def dependency() -> T:
-            return await ainstance
+            return await lazy_instance
 
         class_name = getattr(cls, "__name__", str(cls))
         dependency.__name__ = f"inject({class_name})"
         return Depends(dependency, use_cache=False)
 
-    def __getitem__(self, params: Any, /) -> Any:
+    def __getitem__[T, *Ts](self, params: T | tuple[T, *Ts], /) -> TypeAlias:
         iter_params = iter(params if isinstance(params, tuple) else (params,))
         cls = next(iter_params)
         return Annotated[cls, self(cls), *iter_params]

{python_injection-0.18.13 → python_injection-0.19.0}/injection/loaders.py

@@ -164,8 +164,11 @@ class ProfileLoader:
 
     def load(self, name: str, /) -> LoadedProfile:
         self.init()
-        target_module = self.__init_subsets_for(mod(name))
-        self.module.use(target_module, priority=Priority.HIGH)
+
+        if not self.__is_default_module(name):
+            target_module = self.__init_subsets_for(mod(name))
+            self.module.use(target_module, priority=Priority.HIGH)
+
         return _UserLoadedProfile(self, name)
 
     def _unload(self, name: str, /) -> None:
@@ -182,6 +185,9 @@ class ProfileLoader:
 
         return module
 
+    def __is_default_module(self, module_name: str) -> bool:
+        return module_name == self.module.name
+
     def __is_initialized(self, module: Module) -> bool:
         return module.name in self.__initialized_modules
 

{python_injection-0.18.13 → python_injection-0.19.0}/pyproject.toml

@@ -15,6 +15,7 @@ dev = [
 ]
 doc = [
     "fastapi",
+    "pydantic-settings",
     "typer",
     "uvloop",
 ]
@@ -29,7 +30,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.18.13"
+version = "0.19.0"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
 license-files = ["LICENSE"]
@@ -46,6 +47,8 @@ classifiers = [
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: OS Independent",
     "Intended Audience :: Developers",
     "Natural Language :: English",