python-injection 0.26.2__py3-none-any.whl → 0.26.3__py3-none-any.whl

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

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
 
 

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
 

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()

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:

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:

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(

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:

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})

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.2.dist-info → python_injection-0.26.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.26.2
+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,6 +18,7 @@ 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
@@ -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.2.dist-info → python_injection-0.26.3.dist-info}/RECORD

@@ -1,30 +1,30 @@
 injection/__init__.py,sha256=8nYCdToksoBIRTiJFrEbAUa_g8--dFL--4pfSGlGDP4,1350
 injection/__init__.pyi,sha256=XzOmrlk_6HNAiQVU4aUDoy3414enMaKTNPpKpXHLYyI,13659
-injection/entrypoint.py,sha256=SjviVj8ajEybGsZ_hmm_NkPIHrIOTmnt3Uhg_GAQJ-s,6709
+injection/entrypoint.py,sha256=-pQuu2pM6CIs-GBNYhlqRe2bPBvShbi_q-AKeOw0Iko,6698
 injection/exceptions.py,sha256=v57yMujiq6H_zwwn30A8UYEZX9R9k-bY8FnsdaimPM4,1025
 injection/loaders.py,sha256=gBwEfmR1ZHybD2hdtVr-ji6HZS7gCQvgajoiatmZpeM,7394
 injection/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/asfunction.py,sha256=GY228WHQWvA-9rg3unR8ttyIJlhwxy0bC3LUO5K8Erg,1864
-injection/_core/descriptors.py,sha256=wpW6lFz7ZDDOh1Vc7P86z49UkZ1lajBReWOagSotWDs,3574
-injection/_core/injectables.py,sha256=t_A-tP7kNmNgjXUX_TKwZj3NU65RDpMUTqkVtvXGVNw,6435
-injection/_core/locator.py,sha256=pff_amjMi0XNXdIcPG8fK3vefRPwVLiZVvFg0qwEvDg,8258
-injection/_core/module.py,sha256=AJgAtoYmAzpCXMiazk2mlyW1aAiGuHK5XcvC5Vf-Ibo,28729
-injection/_core/scope.py,sha256=bYwo_BU22fTIWrMEJHrQl_axWs0UV1pmrNwmQQaXzA4,8925
+injection/_core/descriptors.py,sha256=OBuGGPPn9b2dLTfFA1tdUD2zv11F4_1h1Vsm_cNaF-M,3602
+injection/_core/injectables.py,sha256=6PY_-DCfCd7eTZoHwBxvuPMX78XIYq128sAKOAjoiOQ,6467
+injection/_core/locator.py,sha256=zSzLN7WiEPlYyrWra8siVnqx78jEW7AZ0rn5hZSmF3o,8270
+injection/_core/module.py,sha256=W4HsK7OJ_wlKIkca4g6O4LT5v1nf2D6ow-303JasLQ0,28918
+injection/_core/scope.py,sha256=WIkv8PvmSZt4us3PKZA8KuM4Mtd7TzXVhi-V_zxt-kE,9060
 injection/_core/slots.py,sha256=g9TG6CbqRzCsjg01iPyfRtTTUCJnnJOwcj9mJabH0dc,37
 injection/_core/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-injection/_core/common/asynchronous.py,sha256=nKY2_PAMFF2haC75Fwp8O9Zd-SDuenE6n3B-KccwXlw,1772
-injection/_core/common/event.py,sha256=XjzV8gxtGlGvzZs_ykvoC60qmdpd3RN08Eiqz5QUwes,1236
+injection/_core/common/asynchronous.py,sha256=QldcR-QyrDD8u1T-P5gEm2Vb-2DbU64bdE7NZXf_AhU,1785
+injection/_core/common/event.py,sha256=oZj1Uw4-XAcdBFzy7xmn9CC6HoIMxbdVXkHICLSORqk,1252
 injection/_core/common/invertible.py,sha256=gA_vw5nBjgp_w9MrDK5jMO8lhuOQWON8BbPpKzEuIY0,502
-injection/_core/common/lazy.py,sha256=Zl19MSayvz-uhNePpzICTSwIaWAzYMYQqgEdskqAFEo,782
-injection/_core/common/threading.py,sha256=tTjGQK5YJQ9AgZkYQSB7wWp56suisK3VLIfqsfYo0RI,441
+injection/_core/common/lazy.py,sha256=jTv7mYChvRp6WLWILLbEejrHq24gFRKOkkUuZjnwYlE,796
+injection/_core/common/threading.py,sha256=-A1z7l363JZx8em88INpvV-DOQ7xO2y57u5I7Pta-Jw,459
 injection/_core/common/type.py,sha256=d1CtWyu--7Ru7vi9uqAQucO1oXFmAsuUhP2j-dCYkfM,1533
 injection/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/ext/fastapi.py,sha256=wpiNyHKEPwQ7sAJt30XpkgiCi4-gfmyqkQWw9BejXwg,1633
 injection/ext/fastapi.pyi,sha256=HLs7mfruIEFRrN_Xf8oCvSa4qwHWfwm6HHU_KMedXkE,185
 injection/testing/__init__.py,sha256=ZWMacZuGhK8Edq1L0Ng0PaRlgKXEunyFZkFvx7-IYIQ,935
 injection/testing/__init__.pyi,sha256=ZFQMUZmvBVkV6Ch7jiYE9zeJhnqHAQnt3vWQ1Th0zDk,646
-python_injection-0.26.2.dist-info/METADATA,sha256=l8eJqDhM_Zx_-D_FMZeRchOcW7zhKPPfzy676mGJJIA,3651
-python_injection-0.26.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-python_injection-0.26.2.dist-info/licenses/LICENSE,sha256=oC77BOa9kaaQni5rW-Z-ytz3E5h4EVg248BHg9UFgyg,1063
-python_injection-0.26.2.dist-info/RECORD,,
+python_injection-0.26.3.dist-info/METADATA,sha256=QhVKKiAbtQNT1Y68W0JPBo4nTU_yPPCMY-sAiEqgjRw,3706
+python_injection-0.26.3.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+python_injection-0.26.3.dist-info/licenses/LICENSE,sha256=oC77BOa9kaaQni5rW-Z-ytz3E5h4EVg248BHg9UFgyg,1063
+python_injection-0.26.3.dist-info/RECORD,,

{python_injection-0.26.2.dist-info → python_injection-0.26.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.31.0
 Root-Is-Purelib: true
 Tag: py3-none-any