anydi 0.33.1__tar.gz → 0.34.0__tar.gz

{anydi-0.33.1 → anydi-0.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anydi
-Version: 0.33.1
+Version: 0.34.0
 Summary: Dependency Injection library
 Home-page: https://github.com/antonrh/anydi
 License: MIT
@@ -28,9 +28,8 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Provides-Extra: async
 Provides-Extra: docs
-Requires-Dist: anyio (>=3.6.2,<4.0.0) ; extra == "async"
+Requires-Dist: anyio (>=3.6.2,<4.0.0)
 Requires-Dist: mkdocs (>=1.4.2,<2.0.0) ; extra == "docs"
 Requires-Dist: mkdocs-material (>=9.5.29,<10.0.0) ; extra == "docs"
 Requires-Dist: typing-extensions (>=4.12.1,<5.0.0)

{anydi-0.33.1 → anydi-0.34.0}/anydi/_container.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import contextlib
 import functools
 import inspect
+import threading
 import types
 from collections import defaultdict
 from collections.abc import AsyncIterator, Iterable, Iterator, Sequence
@@ -26,7 +27,7 @@ from ._module import Module, ModuleRegistry
 from ._provider import Provider
 from ._scanner import Scanner
 from ._types import AnyInterface, DependencyWrapper, Interface, Scope, is_marker
-from ._utils import get_full_qualname, get_typed_parameters, is_builtin_type
+from ._utils import AsyncRLock, get_full_qualname, get_typed_parameters, is_builtin_type
 
 T = TypeVar("T", bound=Any)
 P = ParamSpec("P")
@@ -54,6 +55,8 @@ class Container:
         self._providers: dict[type[Any], Provider] = {}
         self._resource_cache: dict[Scope, list[type[Any]]] = defaultdict(list)
         self._singleton_context = SingletonContext(self)
+        self._singleton_lock = threading.RLock()
+        self._singleton_async_lock = AsyncRLock()
         self._transient_context = TransientContext(self)
         self._request_context_var: ContextVar[RequestContext | None] = ContextVar(
             "request_context", default=None
@@ -366,7 +369,11 @@ class Container:
 
         provider = self._get_or_register_provider(interface)
         scoped_context = self._get_scoped_context(provider.scope)
-        instance, created = scoped_context.get_or_create(provider)
+        if provider.scope == "singleton":
+            with self._singleton_lock:
+                instance, created = scoped_context.get_or_create(provider)
+        else:
+            instance, created = scoped_context.get_or_create(provider)
         if self.testing and created:
             self._patch_test_resolver(instance)
         return cast(T, instance)
@@ -384,7 +391,11 @@ class Container:
 
         provider = self._get_or_register_provider(interface)
         scoped_context = self._get_scoped_context(provider.scope)
-        instance, created = await scoped_context.aget_or_create(provider)
+        if provider.scope == "singleton":
+            async with self._singleton_async_lock:
+                instance, created = await scoped_context.aget_or_create(provider)
+        else:
+            instance, created = await scoped_context.aget_or_create(provider)
         if self.testing and created:
             self._patch_test_resolver(instance)
         return cast(T, instance)

{anydi-0.33.1 → anydi-0.34.0}/anydi/_context.py

@@ -10,7 +10,12 @@ from typing_extensions import Self, final
 
 from ._provider import CallableKind, Provider
 from ._types import AnyInterface, DependencyWrapper, Scope, is_event_type
-from ._utils import get_full_qualname, run_async
+from ._utils import (
+    get_full_qualname,
+    is_async_context_manager,
+    is_context_manager,
+    run_async,
+)
 
 if TYPE_CHECKING:
     from ._container import Container
@@ -188,7 +193,7 @@ class ResourceScopedContext(ScopedContext):
         """Create an instance using the provider."""
         instance = super()._create_instance(provider)
         # Enter the context manager if the instance is closable.
-        if hasattr(instance, "__enter__") and hasattr(instance, "__exit__"):
+        if is_context_manager(instance):
             self._stack.enter_context(instance)
         return instance
 
@@ -202,7 +207,7 @@ class ResourceScopedContext(ScopedContext):
         """Create an instance asynchronously using the provider."""
         instance = await super()._acreate_instance(provider)
         # Enter the context manager if the instance is closable.
-        if hasattr(instance, "__aenter__") and hasattr(instance, "__aexit__"):
+        if is_async_context_manager(instance):
             await self._async_stack.enter_async_context(instance)
         return instance
 
@@ -233,8 +238,6 @@ class ResourceScopedContext(ScopedContext):
     @abc.abstractmethod
     def start(self) -> None:
         """Start the scoped context."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
-            self.container.resolve(interface)
 
     def close(self) -> None:
         """Close the scoped context."""

{anydi-0.33.1 → anydi-0.34.0}/anydi/_utils.py

@@ -8,15 +8,11 @@ import importlib
 import inspect
 import re
 import sys
+from types import TracebackType
 from typing import Any, Callable, ForwardRef, TypeVar
 
-from typing_extensions import ParamSpec, get_args, get_origin
-
-try:
-    import anyio  # noqa
-except ImportError:
-    anyio = None  # type: ignore[assignment]
-
+import anyio
+from typing_extensions import ParamSpec, Self, get_args, get_origin
 
 T = TypeVar("T")
 P = ParamSpec("P")
@@ -48,6 +44,16 @@ def is_builtin_type(tp: type[Any]) -> bool:
     return tp.__module__ == builtins.__name__
 
 
+def is_context_manager(obj: Any) -> bool:
+    """Check if the given object is a context manager."""
+    return hasattr(obj, "__enter__") and hasattr(obj, "__exit__")
+
+
+def is_async_context_manager(obj: Any) -> bool:
+    """Check if the given object is an async context manager."""
+    return hasattr(obj, "__aenter__") and hasattr(obj, "__aexit__")
+
+
 def get_typed_annotation(
     annotation: Any, globalns: dict[str, Any], module: Any = None
 ) -> Any:
@@ -82,11 +88,6 @@ async def run_async(
     **kwargs: P.kwargs,
 ) -> T:
     """Runs the given function asynchronously using the `anyio` library."""
-    if not anyio:
-        raise ImportError(
-            "`anyio` library is not currently installed. Please make sure to install "
-            "it first, or consider using `anydi[full]` instead."
-        )
     return await anyio.to_thread.run_sync(functools.partial(func, *args, **kwargs))
 
 
@@ -103,3 +104,39 @@ def import_string(dotted_path: str) -> Any:
             return importlib.import_module(attribute_name)
     except (ImportError, AttributeError) as exc:
         raise ImportError(f"Cannot import '{dotted_path}': {exc}") from exc
+
+
+class AsyncRLock:
+    def __init__(self) -> None:
+        self._lock = anyio.Lock()
+        self._owner: anyio.TaskInfo | None = None
+        self._count = 0
+
+    async def acquire(self) -> None:
+        current_task = anyio.get_current_task()
+        if self._owner == current_task:
+            self._count += 1
+        else:
+            await self._lock.acquire()
+            self._owner = current_task
+            self._count = 1
+
+    def release(self) -> None:
+        if self._owner != anyio.get_current_task():
+            raise RuntimeError("Lock can only be released by the owner")
+        self._count -= 1
+        if self._count == 0:
+            self._owner = None
+            self._lock.release()
+
+    async def __aenter__(self) -> Self:
+        await self.acquire()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> Any:
+        self.release()

{anydi-0.33.1 → anydi-0.34.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "anydi"
-version = "0.33.1"
+version = "0.34.0"
 description = "Dependency Injection library"
 authors = ["Anton Ruhlov <antonruhlov@gmail.com>"]
 license = "MIT"
@@ -36,19 +36,18 @@ packages = [
 [tool.poetry.dependencies]
 python = "^3.9"
 typing-extensions = "^4.12.1"
-anyio = { version = "^3.6.2", optional = true }
+anyio = "^3.6.2"
 mkdocs = { version = "^1.4.2", optional = true }
 mkdocs-material = { version = "^9.5.29", optional = true }
 
 [tool.poetry.extras]
 docs = ["mkdocs", "mkdocs-material"]
-async = ["anyio"]
 
 [tool.poetry.group.dev.dependencies]
-mypy = { version = "^1.14.0", extras = ["faster-cache"] }
-ruff = "^0.8.4"
+mypy = { version = "^1.14.1", extras = ["faster-cache"] }
+ruff = "^0.8.5"
 pytest = "^8.3.1"
-pytest-cov = "^5.0.0"
+pytest-cov = "^6.0.0"
 fastapi = "^0.100.0"
 httpx = "^0.26.0"
 django = "^4.2"