python-injection 0.26.2__tar.gz → 0.26.4__tar.gz

{python_injection-0.26.2 → python_injection-0.26.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: python-injection
-Version: 0.26.2
+Version: 0.26.4
 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
@@ -31,8 +32,8 @@ Description-Content-Type: text/markdown
 
 # python-injection
 
-[![PyPI - Version](https://img.shields.io/pypi/v/python-injection.svg?color=546d78&style=for-the-badge)](https://pypi.org/project/python-injection)
-[![PyPI - Downloads](https://img.shields.io/pypi/dm/python-injection.svg?color=546d78&style=for-the-badge)](https://pypistats.org/packages/python-injection)
+[![PyPI - Version](https://shieldcn.dev/pypi/v/python-injection.svg?variant=secondary)](https://pypi.org/project/python-injection)
+[![PyPI - Downloads](https://shieldcn.dev/pypi/dm/python-injection.svg?variant=secondary)](https://pypistats.org/packages/python-injection)
 
 ## Project motivations
 
@@ -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 → python_injection-0.26.4}/docs/index.md

@@ -1,7 +1,7 @@
 # python-injection
 
-[![PyPI - Version](https://img.shields.io/pypi/v/python-injection.svg?color=546d78&style=for-the-badge)](https://pypi.org/project/python-injection)
-[![PyPI - Downloads](https://img.shields.io/pypi/dm/python-injection.svg?color=546d78&style=for-the-badge)](https://pypistats.org/packages/python-injection)
+[![PyPI - Version](https://shieldcn.dev/pypi/v/python-injection.svg?variant=secondary)](https://pypi.org/project/python-injection)
+[![PyPI - Downloads](https://shieldcn.dev/pypi/dm/python-injection.svg?variant=secondary)](https://pypistats.org/packages/python-injection)
 
 ## Project motivations
 
@@ -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.2 → python_injection-0.26.4}/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,
-)
+from typing import Any, NoReturn, Protocol, runtime_checkable
 
-AsyncSemaphore: Callable[[int], AsyncContextManager[Any]]
+AsyncLock: Callable[[], AbstractAsyncContextManager[Any]]
 
 try:
     import anyio
@@ -17,10 +12,10 @@ try:
 except ImportError:  # pragma: no cover
     import asyncio
 
-    AsyncSemaphore = asyncio.Semaphore
+    AsyncLock = asyncio.Lock
 
 else:
-    AsyncSemaphore = anyio.Semaphore
+    AsyncLock = anyio.Lock
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)

{python_injection-0.26.2 → python_injection-0.26.4}/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.2 → python_injection-0.26.4}/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.4/injection/_core/common/threading.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from contextlib import AbstractContextManager, nullcontext
+from os import getenv
+from threading import Lock
+from typing import Any, Final
+
+_PYTHON_INJECTION_THREADSAFE: Final[bool] = bool(
+    int(getenv("PYTHON_INJECTION_THREADSAFE", "0"))
+)
+
+
+def lock_if_threadsafe(
+    lock: AbstractContextManager[Any] | None = None,
+    threadsafe: bool | None = None,
+) -> AbstractContextManager[Any]:
+    threadsafe = _PYTHON_INJECTION_THREADSAFE if threadsafe is None else threadsafe
+
+    if not threadsafe:
+        return nullcontext()
+
+    return lock or Lock()

{python_injection-0.26.2 → python_injection-0.26.4}/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.2 → python_injection-0.26.4}/injection/_core/injectables.py

@@ -1,20 +1,18 @@
 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,
     runtime_checkable,
 )
 
-from injection._core.common.asynchronous import AsyncSemaphore, Caller
+from injection._core.common.asynchronous import AsyncLock, Caller
 from injection._core.common.type import InputType
 from injection._core.scope import Scope, get_first_scope, in_scope_cache
 from injection._core.slots import SlotKey
@@ -53,12 +51,12 @@ class TransientInjectable[T](Injectable[T]):
 
 
 class CacheLogic[T]:
-    __slots__ = ("__semaphore",)
+    __slots__ = ("__lock",)
 
-    __semaphore: AsyncContextManager[Any]
+    __lock: AbstractAsyncContextManager[Any]
 
     def __init__(self) -> None:
-        self.__semaphore = AsyncSemaphore(1)
+        self.__lock = AsyncLock()
 
     async def aget_or_create[K](
         self,
@@ -66,7 +64,7 @@ class CacheLogic[T]:
         key: K,
         factory: Callable[..., Awaitable[T]],
     ) -> T:
-        async with self.__semaphore:
+        async with self.__lock:
             with suppress(KeyError):
                 return cache[key]
 
@@ -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.2 → python_injection-0.26.4}/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.2 → python_injection-0.26.4}/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
@@ -29,18 +35,9 @@ from inspect import (
 )
 from inspect import signature as inspect_signature
 from logging import Logger, getLogger
+from threading import RLock
 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
 
@@ -48,7 +45,7 @@ from injection._core.common.asynchronous import Caller, SimpleAwaitable
 from injection._core.common.event import Event, EventChannel, EventListener
 from injection._core.common.invertible import Invertible, SimpleInvertible
 from injection._core.common.lazy import Lazy
-from injection._core.common.threading import get_lock
+from injection._core.common.threading import lock_if_threadsafe
 from injection._core.common.type import (
     InputType,
     TypeInfo,
@@ -157,7 +154,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]]
@@ -184,6 +181,11 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         init=False,
         repr=False,
     )
+    __lock: RLock = field(
+        default_factory=RLock,
+        init=False,
+        repr=False,
+    )
     __loggers: list[Logger] = field(
         default_factory=lambda: [getLogger("python-injection")],
         init=False,
@@ -231,7 +233,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 +257,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 +309,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 +327,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 +343,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)
 
@@ -354,7 +356,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         /,
         threadsafe: bool | None = None,
     ) -> InjectMetadata[P, T]:
-        return InjectMetadata(wrapped, threadsafe).listen(self)
+        return InjectMetadata(wrapped, self.__lock, threadsafe).listen(self)
 
     if TYPE_CHECKING:  # pragma: no cover
 
@@ -401,7 +403,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         *,
         threadsafe: bool | None = None,
     ) -> T:
-        with get_lock(threadsafe):
+        with lock_if_threadsafe(self.__lock, threadsafe):
             injectable = self[cls]
             return await injectable.aget_instance()
 
@@ -411,7 +413,7 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         *,
         threadsafe: bool | None = None,
     ) -> T:
-        with get_lock(threadsafe):
+        with lock_if_threadsafe(self.__lock, threadsafe):
             injectable = self[cls]
             return injectable.get_instance()
 
@@ -583,7 +585,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.")
@@ -602,9 +604,9 @@ class Module(EventListener, InjectionProvider):  # type: ignore[misc]
         return self
 
     def stop_using(self, module: Module) -> Self:
-        event = ModuleRemoved(self, module)
+        if module in self.__modules:
+            event = ModuleRemoved(self, module)
 
-        with suppress(KeyError):
             with self.dispatch(event):
                 self.__modules.pop(module)
                 module.remove_listener(self)
@@ -616,7 +618,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 +662,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 +831,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]]
@@ -838,11 +840,12 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
     def __init__(
         self,
         wrapped: Callable[P, T],
+        lock: RLock,
         /,
         threadsafe: bool | None = None,
     ) -> None:
         self.__dependencies = Dependencies.empty()
-        self.__lock = get_lock(threadsafe)
+        self.__lock = lock_if_threadsafe(lock, threadsafe)
         self.__owner = None
         self.__tasks = deque()
         self.__wrapped = wrapped
@@ -904,8 +907,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 +927,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 +948,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.2 → python_injection-0.26.4}/injection/_core/scope.py

@@ -4,17 +4,23 @@ 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
 from functools import partial
+from threading import Lock
 from types import EllipsisType, TracebackType
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncContextManager,
-    ContextManager,
     Final,
     Literal,
     NoReturn,
@@ -24,7 +30,7 @@ from typing import (
     runtime_checkable,
 )
 
-from injection._core.common.threading import get_lock
+from injection._core.common.threading import lock_if_threadsafe
 from injection._core.slots import SlotKey
 from injection.exceptions import (
     InjectionError,
@@ -33,6 +39,8 @@ from injection.exceptions import (
     ScopeUndefinedError,
 )
 
+__thread_lock: Final[Lock] = Lock()
+
 
 class ScopeKind(StrEnum):
     CONTEXTUAL = "contextual"
@@ -56,7 +64,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 +136,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 +148,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
@@ -193,7 +200,7 @@ def _bind_scope(
     kind: ScopeKind | ScopeKindStr,
     threadsafe: bool | None,
 ) -> Iterator[ScopeFacade]:
-    lock = get_lock(threadsafe)
+    lock = lock_if_threadsafe(__thread_lock, threadsafe)
 
     with lock:
         if get_first_scope(name, default=None):
@@ -205,7 +212,7 @@ def _bind_scope(
         stack.enter_context(__scope_resolvers[kind][name].bind(scope))
 
     try:
-        yield _UserScope(scope, lock)
+        yield _UserScope(scope, lock_if_threadsafe(threadsafe=threadsafe))
 
     finally:
         with lock:
@@ -234,11 +241,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 +277,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 +303,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 +329,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.2 → python_injection-0.26.4}/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 → python_injection-0.26.4}/pyproject.toml

@@ -10,12 +10,12 @@ dev = [
     "ruff",
 ]
 docs = [
-    "mkdocs",
-    "mkdocs-material",
+    "ghp-import",
+    "zensical",
 ]
 test = [
     "fastapi",
-    "httpx",
+    "httpx2",
     "pydantic",
     "pytest",
     "pytest-asyncio",
@@ -24,7 +24,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.26.2"
+version = "0.26.4"
 description = "Dead-simple dependency injection framework for Python."
 license = "MIT"
 license-files = ["LICENSE"]
@@ -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",

python_injection-0.26.2/injection/_core/common/threading.py

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