python-injection 0.26.1__tar.gz → 0.26.3__tar.gz

{python_injection-0.26.1 → python_injection-0.26.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.26.1
+Version: 0.26.3
 Summary: Dead-simple dependency injection framework for Python.
 Project-URL: Documentation, https://python-injection.remimd.dev
 Project-URL: Repository, https://github.com/100nm/python-injection
@@ -18,12 +18,13 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Testing
 Classifier: Typing :: Typed
-Requires-Python: <3.15,>=3.12
+Requires-Python: <3.16,>=3.12
 Requires-Dist: type-analyzer
 Provides-Extra: async
 Requires-Dist: anyio; extra == 'async'
@@ -68,6 +69,7 @@ Simply apply the decorators and the package takes care of the rest.
 ```python
 from injection import injectable, inject, singleton
 
+
 @singleton
 class Printer:
     def __init__(self):
@@ -77,6 +79,7 @@ class Printer:
         self.history.append(message)
         print(message)
 
+
 @injectable
 class Service:
     def __init__(self, printer: Printer):
@@ -85,10 +88,12 @@ class Service:
     def hello(self):
         self.printer.print("Hello world!")
 
+
 @inject
 def main(service: Service):
     service.hello()
 
+
 if __name__ == "__main__":
     main()
 ```

{python_injection-0.26.1 → python_injection-0.26.3}/docs/index.md

@@ -37,6 +37,7 @@ Simply apply the decorators and the package takes care of the rest.
 ```python
 from injection import injectable, inject, singleton
 
+
 @singleton
 class Printer:
     def __init__(self):
@@ -46,6 +47,7 @@ class Printer:
         self.history.append(message)
         print(message)
 
+
 @injectable
 class Service:
     def __init__(self, printer: Printer):
@@ -54,10 +56,12 @@ class Service:
     def hello(self):
         self.printer.print("Hello world!")
 
+
 @inject
 def main(service: Service):
     service.hello()
 
+
 if __name__ == "__main__":
     main()
 ```

{python_injection-0.26.1 → python_injection-0.26.3}/injection/_core/common/asynchronous.py

@@ -1,15 +1,10 @@
 from abc import abstractmethod
 from collections.abc import Awaitable, Callable, Generator
+from contextlib import AbstractAsyncContextManager
 from dataclasses import dataclass
-from typing import (
-    Any,
-    AsyncContextManager,
-    NoReturn,
-    Protocol,
-    runtime_checkable,
-)
-
-AsyncSemaphore: Callable[[int], AsyncContextManager[Any]]
+from typing import Any, NoReturn, Protocol, runtime_checkable
+
+AsyncSemaphore: Callable[[int], AbstractAsyncContextManager[Any]]
 
 try:
     import anyio

{python_injection-0.26.1 → python_injection-0.26.3}/injection/_core/common/event.py

@@ -1,8 +1,8 @@
 from abc import ABC, abstractmethod
 from collections.abc import Iterator
-from contextlib import ExitStack, contextmanager
+from contextlib import AbstractContextManager, ExitStack, contextmanager
 from dataclasses import dataclass, field
-from typing import ContextManager, Self
+from typing import Self
 from weakref import WeakSet
 
 
@@ -14,7 +14,7 @@ class EventListener(ABC):
     __slots__ = ("__weakref__",)
 
     @abstractmethod
-    def on_event(self, event: Event, /) -> ContextManager[None] | None:
+    def on_event(self, event: Event, /) -> AbstractContextManager[None] | None:
         raise NotImplementedError
 
 

{python_injection-0.26.1 → python_injection-0.26.3}/injection/_core/common/lazy.py

@@ -19,7 +19,7 @@ class Lazy[T](Invertible[T]):
     @property
     def is_set(self) -> bool:
         try:
-            self.__value
+            self.__value  # noqa: B018
         except AttributeError:
             return False
 

{python_injection-0.26.1 → python_injection-0.26.3}/injection/_core/common/threading.py

@@ -1,13 +1,13 @@
-from contextlib import nullcontext
+from contextlib import AbstractContextManager, nullcontext
 from os import getenv
 from threading import RLock
-from typing import Any, ContextManager, Final
+from typing import Any, Final
 
 _PYTHON_INJECTION_THREADSAFE: Final[bool] = bool(
-    int(getenv("PYTHON_INJECTION_THREADSAFE", 0))
+    int(getenv("PYTHON_INJECTION_THREADSAFE", "0"))
 )
 
 
-def get_lock(threadsafe: bool | None = None) -> ContextManager[Any]:
+def get_lock(threadsafe: bool | None = None) -> AbstractContextManager[Any]:
     threadsafe = _PYTHON_INJECTION_THREADSAFE if threadsafe is None else threadsafe
     return RLock() if threadsafe else nullcontext()

{python_injection-0.26.1 → python_injection-0.26.3}/injection/_core/descriptors.py

@@ -73,7 +73,7 @@ class BoundMappedScope:
     async def adefine(
         self,
         /,
-        kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
+        kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),  # noqa: B008
         threadsafe: bool | None = None,
     ) -> AsyncIterator[None]:
         async with adefine_scope(self.name, kind, threadsafe) as scope:
@@ -86,7 +86,7 @@ class BoundMappedScope:
     def define(
         self,
         /,
-        kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
+        kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),  # noqa: B008
         threadsafe: bool | None = None,
     ) -> Iterator[None]:
         with define_scope(self.name, kind, threadsafe) as scope:

{python_injection-0.26.1 → python_injection-0.26.3}/injection/_core/injectables.py

@@ -1,13 +1,11 @@
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable, MutableMapping, Sequence
-from contextlib import suppress
+from contextlib import AbstractAsyncContextManager, AbstractContextManager, suppress
 from dataclasses import dataclass, field
 from functools import partial
 from typing import (
     Any,
-    AsyncContextManager,
     ClassVar,
-    ContextManager,
     NoReturn,
     Protocol,
     Self,
@@ -55,7 +53,7 @@ class TransientInjectable[T](Injectable[T]):
 class CacheLogic[T]:
     __slots__ = ("__semaphore",)
 
-    __semaphore: AsyncContextManager[Any]
+    __semaphore: AbstractAsyncContextManager[Any]
 
     def __init__(self) -> None:
         self.__semaphore = AsyncSemaphore(1)
@@ -169,7 +167,7 @@ class ScopedInjectable[R, T](Injectable[T], ABC):
         return partial(cls, scope_names=names)
 
 
-class AsyncCMScopedInjectable[T](ScopedInjectable[AsyncContextManager[T], T]):
+class AsyncCMScopedInjectable[T](ScopedInjectable[AbstractAsyncContextManager[T], T]):
     __slots__ = ()
 
     async def abuild(self, scope: Scope) -> T:
@@ -180,7 +178,7 @@ class AsyncCMScopedInjectable[T](ScopedInjectable[AsyncContextManager[T], T]):
         raise RuntimeError("Can't use async context manager synchronously.")
 
 
-class CMScopedInjectable[T](ScopedInjectable[ContextManager[T], T]):
+class CMScopedInjectable[T](ScopedInjectable[AbstractContextManager[T], T]):
     __slots__ = ()
 
     async def abuild(self, scope: Scope) -> T:

{python_injection-0.26.1 → python_injection-0.26.3}/injection/_core/locator.py

@@ -2,13 +2,12 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable, Collection, Iterable, Iterator
-from contextlib import suppress
+from contextlib import AbstractContextManager, suppress
 from dataclasses import dataclass, field
 from enum import StrEnum
 from inspect import iscoroutinefunction
 from typing import (
     Any,
-    ContextManager,
     Literal,
     NamedTuple,
     Protocol,
@@ -226,7 +225,7 @@ class Locator:
         self.__channel.add_listener(listener)
         return self
 
-    def dispatch(self, event: Event) -> ContextManager[None]:
+    def dispatch(self, event: Event) -> AbstractContextManager[None]:
         return self.__channel.dispatch(event)
 
     def __iter_injectables(

{python_injection-0.26.1 → python_injection-0.26.3}/injection/_core/module.py

@@ -14,7 +14,13 @@ from collections.abc import (
     Iterator,
     Mapping,
 )
-from contextlib import asynccontextmanager, contextmanager, suppress
+from contextlib import (
+    AbstractAsyncContextManager,
+    AbstractContextManager,
+    asynccontextmanager,
+    contextmanager,
+    suppress,
+)
 from dataclasses import dataclass, field
 from enum import StrEnum
 from functools import partialmethod, singledispatchmethod, update_wrapper
@@ -30,17 +36,7 @@ from inspect import (
 from inspect import signature as inspect_signature
 from logging import Logger, getLogger
 from types import MethodType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncContextManager,
-    ClassVar,
-    ContextManager,
-    Literal,
-    NamedTuple,
-    Self,
-    overload,
-)
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, NamedTuple, Self, overload
 
 from type_analyzer import MatchingTypesConfig, iter_matching_types, matching_types
 
@@ -157,7 +153,7 @@ class Priority(StrEnum):
 type PriorityStr = Literal["low", "high"]
 
 type ContextManagerRecipe[**P, T] = (
-    Callable[P, ContextManager[T]] | Callable[P, AsyncContextManager[T]]
+    Callable[P, AbstractContextManager[T]] | Callable[P, AbstractAsyncContextManager[T]]
 )
 type GeneratorRecipe[**P, T] = (
     Callable[P, Generator[T, Any, Any]] | Callable[P, AsyncGenerator[T, Any]]
@@ -231,7 +227,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         ignore_type_hint: bool = False,
         inject: bool = True,
         on: TypeInfo[T] = (),
-        mode: Mode | ModeStr = Mode.get_default(),
+        mode: Mode | ModeStr = Mode.get_default(),  # noqa: B008
     ) -> Any:
         def decorator(wp: Recipe[P, T]) -> Recipe[P, T]:
             hints = on if ignore_type_hint else (wp, on)
@@ -255,7 +251,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         ignore_type_hint: bool = False,
         inject: bool = True,
         on: TypeInfo[T] = (),
-        mode: Mode | ModeStr = Mode.get_default(),
+        mode: Mode | ModeStr = Mode.get_default(),  # noqa: B008
     ) -> Any:
         def decorator(
             wrapped: Recipe[P, T] | GeneratorRecipe[P, T],
@@ -307,7 +303,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         on: TypeInfo[T] = (),
         *,
         alias: bool = False,
-        mode: Mode | ModeStr = Mode.get_default(),
+        mode: Mode | ModeStr = Mode.get_default(),  # noqa: B008
     ) -> T:
         if not alias:
             on = (type(instance), on)
@@ -325,7 +321,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         /,
         scope_name: str,
         *,
-        mode: Mode | ModeStr = Mode.get_default(),
+        mode: Mode | ModeStr = Mode.get_default(),  # noqa: B008
     ) -> SlotKey[T]:
         injectable = ScopedSlotInjectable(cls, scope_name)
         broker = StaticInjectableBroker(injectable)
@@ -341,8 +337,8 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
     ) -> Any:
         def decorator(wp: Callable[P, T]) -> Callable[P, T]:
             if isclass(wp):
-                wp.__init__ = self.inject(wp.__init__, threadsafe=threadsafe)
-                return wp
+                wp.__init__ = self.inject(wp.__init__, threadsafe=threadsafe)  # type: ignore[method-assign]
+                return wp  # type: ignore[return-value]
 
             return self.make_injected_function(wp, threadsafe)
 
@@ -583,7 +579,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         self,
         module: Module,
         *,
-        priority: Priority | PriorityStr = Priority.get_default(),
+        priority: Priority | PriorityStr = Priority.get_default(),  # noqa: B008
     ) -> Self:
         if module is self:
             raise ModuleError("Module can't be used by itself.")
@@ -604,10 +600,9 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
     def stop_using(self, module: Module) -> Self:
         event = ModuleRemoved(self, module)
 
-        with suppress(KeyError):
-            with self.dispatch(event):
-                self.__modules.pop(module)
-                module.remove_listener(self)
+        with suppress(KeyError), self.dispatch(event):
+            self.__modules.pop(module)
+            module.remove_listener(self)
 
         return self
 
@@ -616,7 +611,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         self,
         module: Module,
         *,
-        priority: Priority | PriorityStr = Priority.get_default(),
+        priority: Priority | PriorityStr = Priority.get_default(),  # noqa: B008
         unlock: bool = False,
     ) -> Iterator[Self]:
         self.use(module, priority=priority)
@@ -660,7 +655,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         self.__channel.remove_listener(listener)
         return self
 
-    def on_event(self, event: Event, /) -> ContextManager[None]:
+    def on_event(self, event: Event, /) -> AbstractContextManager[None]:
         self_event = ModuleEventProxy(self, event)
         return self.dispatch(self_event)
 
@@ -829,7 +824,7 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
     )
 
     __dependencies: Dependencies
-    __lock: ContextManager[Any]
+    __lock: AbstractContextManager[Any]
     __owner: type | None
     __signature: Signature
     __tasks: deque[Callable[..., Any]]
@@ -904,8 +899,12 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
         self.__dependencies = Dependencies.resolve(self.signature, module, self.__owner)
         return self
 
-    def task[**_P, _T](self, wrapped: Callable[_P, _T] | None = None, /) -> Any:
-        def decorator(wp: Callable[_P, _T]) -> Callable[_P, _T]:
+    def task[**TaskP, TaskR](
+        self,
+        wrapped: Callable[TaskP, TaskR] | None = None,
+        /,
+    ) -> Any:
+        def decorator(wp: Callable[TaskP, TaskR]) -> Callable[TaskP, TaskR]:
             self.__tasks.append(wp)
             return wp
 
@@ -920,7 +919,7 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
         return self
 
     @singledispatchmethod
-    def on_event(self, event: Event, /) -> ContextManager[None] | None:
+    def on_event(self, event: Event, /) -> AbstractContextManager[None] | None:
         return None
 
     @on_event.register
@@ -941,7 +940,7 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
         arguments: dict[str, Any],
         additional_arguments: dict[str, Any],
     ) -> Arguments:
-        bound = BoundArguments(self.signature, additional_arguments | arguments)  # type: ignore[arg-type]
+        bound = BoundArguments(self.signature, additional_arguments | arguments)
         return Arguments(bound.args, bound.kwargs)
 
     def __run_tasks(self) -> None:

{python_injection-0.26.1 → python_injection-0.26.3}/injection/_core/scope.py

@@ -4,7 +4,14 @@ import itertools
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import AsyncIterator, Collection, Iterator, Mapping, MutableMapping
-from contextlib import AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
+from contextlib import (
+    AbstractAsyncContextManager,
+    AbstractContextManager,
+    AsyncExitStack,
+    ExitStack,
+    asynccontextmanager,
+    contextmanager,
+)
 from contextvars import ContextVar
 from dataclasses import dataclass, field
 from enum import StrEnum
@@ -13,8 +20,6 @@ from types import EllipsisType, TracebackType
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncContextManager,
-    ContextManager,
     Final,
     Literal,
     NoReturn,
@@ -56,7 +61,7 @@ class ScopeResolver(Protocol):
         raise NotImplementedError
 
     @abstractmethod
-    def bind(self, scope: Scope) -> ContextManager[None]:
+    def bind(self, scope: Scope) -> AbstractContextManager[None]:
         raise NotImplementedError
 
     @abstractmethod
@@ -128,7 +133,7 @@ __scope_resolvers: Final[Mapping[str, Mapping[str, ScopeResolver]]] = {
 async def adefine_scope(
     name: str,
     /,
-    kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
+    kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),  # noqa: B008
     threadsafe: bool | None = None,
 ) -> AsyncIterator[ScopeFacade]:
     async with AsyncScope() as scope:
@@ -140,12 +145,11 @@ async def adefine_scope(
 def define_scope(
     name: str,
     /,
-    kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
+    kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),  # noqa: B008
     threadsafe: bool | None = None,
 ) -> Iterator[ScopeFacade]:
-    with SyncScope() as scope:
-        with _bind_scope(name, scope, kind, threadsafe) as facade:
-            yield facade
+    with SyncScope() as scope, _bind_scope(name, scope, kind, threadsafe) as facade:
+        yield facade
 
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -234,11 +238,11 @@ class Scope(Protocol):
     cache: MutableMapping[SlotKey[Any], Any]
 
     @abstractmethod
-    async def aenter[T](self, context_manager: AsyncContextManager[T]) -> T:
+    async def aenter[T](self, context_manager: AbstractAsyncContextManager[T]) -> T:
         raise NotImplementedError
 
     @abstractmethod
-    def enter[T](self, context_manager: ContextManager[T]) -> T:
+    def enter[T](self, context_manager: AbstractContextManager[T]) -> T:
         raise NotImplementedError
 
 
@@ -270,10 +274,10 @@ class AsyncScope(BaseScope[AsyncExitStack]):
         self.close()
         return await self.delegate.__aexit__(exc_type, exc_value, traceback)
 
-    async def aenter[T](self, context_manager: AsyncContextManager[T]) -> T:
+    async def aenter[T](self, context_manager: AbstractAsyncContextManager[T]) -> T:
         return await self.delegate.enter_async_context(context_manager)
 
-    def enter[T](self, context_manager: ContextManager[T]) -> T:
+    def enter[T](self, context_manager: AbstractContextManager[T]) -> T:
         return self.delegate.enter_context(context_manager)
 
 
@@ -296,10 +300,13 @@ class SyncScope(BaseScope[ExitStack]):
         self.close()
         return self.delegate.__exit__(exc_type, exc_value, traceback)
 
-    async def aenter[T](self, context_manager: AsyncContextManager[T]) -> NoReturn:
+    async def aenter[T](
+        self,
+        context_manager: AbstractAsyncContextManager[T],
+    ) -> NoReturn:
         raise ScopeError("Synchronous scope doesn't support async context manager.")
 
-    def enter[T](self, context_manager: ContextManager[T]) -> T:
+    def enter[T](self, context_manager: AbstractContextManager[T]) -> T:
         return self.delegate.enter_context(context_manager)
 
 
@@ -319,7 +326,7 @@ class ScopeFacade(Protocol):
 @dataclass(repr=False, frozen=True, slots=True)
 class _UserScope(ScopeFacade):
     scope: Scope
-    lock: ContextManager[Any]
+    lock: AbstractContextManager[Any]
 
     def set_slot[T](self, key: SlotKey[T], value: T) -> Self:
         return self.slot_map({key: value})

{python_injection-0.26.1 → python_injection-0.26.3}/injection/entrypoint.py

@@ -194,18 +194,18 @@ class EntrypointBuilder[**P, T1, T2](_EntrypointDecorator[P, T1, T2]):
 
         return decorator(wrapped) if wrapped else decorator
 
-    def async_to_sync[_T](
-        self: EntrypointBuilder[P, T1, Awaitable[_T]],
-        run: Callable[[Coroutine[Any, Any, _T]], _T] = asyncio.run,
+    def async_to_sync[T](
+        self: EntrypointBuilder[P, T1, Awaitable[T]],
+        run: Callable[[Coroutine[Any, Any, T]], T] = asyncio.run,
         /,
-    ) -> EntrypointBuilder[P, T1, _T]:
+    ) -> EntrypointBuilder[P, T1, T]:
         return self._add_rule(_AsyncToSyncRule(run))  # type: ignore[arg-type]
 
-    def decorate[_T](
+    def decorate[T](
         self,
-        decorator: Callable[[Callable[P, T2]], Callable[P, _T]],
+        decorator: Callable[[Callable[P, T2]], Callable[P, T]],
         /,
-    ) -> EntrypointBuilder[P, T1, _T]:
+    ) -> EntrypointBuilder[P, T1, T]:
         return self._add_rule(_DecorateRule(decorator))
 
     def inject(self) -> Self:
@@ -224,10 +224,10 @@ class EntrypointBuilder[**P, T1, T2](_EntrypointDecorator[P, T1, T2]):
         self._add_rule(_LoadProfileRule(self.profile_loader, name))
         return self
 
-    def _add_rule[_T](
+    def _add_rule[T](
         self,
-        rule: Rule[P, T2, _T],
-    ) -> EntrypointBuilder[P, T1, _T]:
+        rule: Rule[P, T2, T],
+    ) -> EntrypointBuilder[P, T1, T]:
         self.__rules.append(rule)
         return self  # type: ignore[return-value]
 

{python_injection-0.26.1 → python_injection-0.26.3}/pyproject.toml

@@ -24,12 +24,12 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.26.1"
+version = "0.26.3"
 description = "Dead-simple dependency injection framework for Python."
 license = "MIT"
 license-files = ["LICENSE"]
 readme = "docs/index.md"
-requires-python = ">=3.12, <3.15"
+requires-python = ">=3.12, <3.16"
 authors = [{ name = "remimd" }]
 keywords = ["dependencies", "dependency", "inject", "injection"]
 classifiers = [
@@ -44,6 +44,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Operating System :: OS Independent",
     "Intended Audience :: Developers",
     "Natural Language :: English",