anydi 0.41.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

anydi/__init__.py

@@ -1,20 +1,14 @@
 """AnyDI public objects and functions."""
 
-from typing import Any, cast
-
-from ._container import (
-    Container,
-    Module,
-    injectable,
-    provider,
-    request,
-    singleton,
-    transient,
-)
-from ._types import Marker, ProviderArgs as Provider, Scope
+from ._container import Container
+from ._decorators import injectable, provided, provider, request, singleton, transient
+from ._module import Module
+from ._provider import ProviderDef as Provider
+from ._scope import Scope
+from ._typing import Marker
 
 # Alias for dependency auto marker
-auto = cast(Any, Marker())
+auto = Marker()
 
 
 __all__ = [
@@ -28,4 +22,5 @@ __all__ = [
     "request",
     "singleton",
     "transient",
+    "provided",
 ]

anydi/_async.py

@@ -0,0 +1,50 @@
+import functools
+from types import TracebackType
+from typing import Any, Callable, TypeVar
+
+import anyio.to_thread
+from typing_extensions import ParamSpec, Self
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+async def run_sync(func: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs) -> T:
+    """Runs the given function asynchronously using the `anyio` library."""
+    return await anyio.to_thread.run_sync(functools.partial(func, *args, **kwargs))
+
+
+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()