anydi 0.54.1__py3-none-any.whl → 0.55.0__py3-none-any.whl

anydi/_context.py

@@ -5,10 +5,11 @@ import threading
 from types import TracebackType
 from typing import Any
 
+import anyio.to_thread
 from typing_extensions import Self
 
-from ._async import AsyncRLock, run_sync
-from ._typing import NOT_SET
+from ._async_lock import AsyncRLock
+from ._types import NOT_SET
 
 
 class InstanceContext:
@@ -18,10 +19,10 @@ class InstanceContext:
 
     def __init__(self) -> None:
         self._instances: dict[Any, Any] = {}
-        self._stack = contextlib.ExitStack()
-        self._async_stack = contextlib.AsyncExitStack()
-        self._lock = threading.RLock()
-        self._async_lock = AsyncRLock()
+        self._stack: contextlib.ExitStack | None = None
+        self._async_stack: contextlib.AsyncExitStack | None = None
+        self._lock: threading.RLock | None = None
+        self._async_lock: AsyncRLock | None = None
 
     def get(self, interface: Any, default: Any = NOT_SET) -> Any:
         """Get an instance from the context."""
@@ -33,10 +34,14 @@ class InstanceContext:
 
     def enter(self, cm: contextlib.AbstractContextManager[Any]) -> Any:
         """Enter the context."""
+        if self._stack is None:
+            self._stack = contextlib.ExitStack()
         return self._stack.enter_context(cm)
 
     async def aenter(self, cm: contextlib.AbstractAsyncContextManager[Any]) -> Any:
         """Enter the context asynchronously."""
+        if self._async_stack is None:
+            self._async_stack = contextlib.AsyncExitStack()
         return await self._async_stack.enter_async_context(cm)
 
     def __setitem__(self, interface: Any, value: Any) -> None:
@@ -62,11 +67,14 @@ class InstanceContext:
         exc_tb: TracebackType | None,
     ) -> Any:
         """Exit the context."""
+        if self._stack is None:
+            return False
         return self._stack.__exit__(exc_type, exc_val, exc_tb)
 
     def close(self) -> None:
         """Close the scoped context."""
-        self._stack.__exit__(None, None, None)
+        if self._stack is not None:
+            self._stack.__exit__(None, None, None)
 
     async def __aenter__(self) -> Self:
         """Enter the context asynchronously."""
@@ -79,8 +87,14 @@ class InstanceContext:
         exc_tb: TracebackType | None,
     ) -> bool:
         """Exit the context asynchronously."""
-        sync_exit = await run_sync(self.__exit__, exc_type, exc_val, exc_tb)
-        async_exit = await self._async_stack.__aexit__(exc_type, exc_val, exc_tb)
+        sync_exit = False
+        async_exit = False
+        if self._stack is not None:
+            sync_exit = await anyio.to_thread.run_sync(
+                self.__exit__, exc_type, exc_val, exc_tb
+            )
+        if self._async_stack is not None:
+            async_exit = await self._async_stack.__aexit__(exc_type, exc_val, exc_tb)
         return bool(sync_exit) or bool(async_exit)
 
     async def aclose(self) -> None:
@@ -89,8 +103,12 @@ class InstanceContext:
 
     def lock(self) -> threading.RLock:
         """Acquire the context lock."""
+        if self._lock is None:
+            self._lock = threading.RLock()
         return self._lock
 
     def alock(self) -> AsyncRLock:
         """Acquire the context lock asynchronously."""
+        if self._async_lock is None:
+            self._async_lock = AsyncRLock()
         return self._async_lock

anydi/_decorators.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from ._module import Module
 
 
-from ._scope import Scope
+from ._types import Scope
 
 T = TypeVar("T")
 P = ParamSpec("P")

anydi/_provider.py

@@ -4,11 +4,9 @@ import enum
 import inspect
 from collections.abc import Callable
 from dataclasses import dataclass
-from functools import cached_property
 from typing import Any
 
-from ._scope import Scope
-from ._typing import NOT_SET
+from ._types import NOT_SET, Scope
 
 
 class ProviderKind(enum.IntEnum):
@@ -34,56 +32,29 @@ class ProviderKind(enum.IntEnum):
             f"The provider `{call}` is invalid because it is not a callable object."
         )
 
-    @classmethod
-    def is_resource(cls, kind: ProviderKind) -> bool:
-        return kind in (cls.GENERATOR, cls.ASYNC_GENERATOR)
-
 
-@dataclass(kw_only=True, frozen=True, slots=True)
+@dataclass(frozen=True, slots=True)
 class ProviderParameter:
     name: str
     annotation: Any
     default: Any
     has_default: bool
     provider: Provider | None = None
-    shared_scope: bool = False
 
 
-@dataclass(kw_only=True, frozen=True)
+@dataclass(frozen=True, slots=True)
 class Provider:
     call: Callable[..., Any]
     scope: Scope
     interface: Any
     name: str
     parameters: tuple[ProviderParameter, ...]
-    kind: ProviderKind
-
-    def __str__(self) -> str:
-        return self.name
-
-    @cached_property
-    def is_class(self) -> bool:
-        return self.kind == ProviderKind.CLASS
-
-    @cached_property
-    def is_coroutine(self) -> bool:
-        return self.kind == ProviderKind.COROUTINE
-
-    @cached_property
-    def is_generator(self) -> bool:
-        return self.kind == ProviderKind.GENERATOR
-
-    @cached_property
-    def is_async_generator(self) -> bool:
-        return self.kind == ProviderKind.ASYNC_GENERATOR
-
-    @cached_property
-    def is_async(self) -> bool:
-        return self.is_coroutine or self.is_async_generator
-
-    @cached_property
-    def is_resource(self) -> bool:
-        return ProviderKind.is_resource(self.kind)
+    is_class: bool
+    is_coroutine: bool
+    is_generator: bool
+    is_async_generator: bool
+    is_async: bool
+    is_resource: bool
 
 
 @dataclass(frozen=True, slots=True)