anydi 0.22.1__py3-none-any.whl → 0.37.4__py3-none-any.whl

anydi/_types.py

@@ -1,17 +1,16 @@
-import inspect
-from dataclasses import dataclass
-from functools import cached_property
-from typing import Any, Callable, Type, TypeVar, Union
+from __future__ import annotations
 
-from typing_extensions import Annotated, Literal, Mapping, TypeAlias
+import inspect
+from collections.abc import Iterable
+from types import ModuleType
+from typing import Annotated, Any, NamedTuple, Union
 
-from ._utils import get_full_qualname, get_signature
+import wrapt
+from typing_extensions import Literal, Self, TypeAlias
 
 Scope = Literal["transient", "singleton", "request"]
 
-T = TypeVar("T")
-AnyInterface: TypeAlias = Union[Type[Any], Annotated[Any, ...]]
-Interface: TypeAlias = Type[T]
+AnyInterface: TypeAlias = Union[type[Any], Annotated[Any, ...]]
 
 
 class Marker:
@@ -19,97 +18,51 @@ class Marker:
 
     __slots__ = ()
 
+    def __call__(self) -> Self:
+        return self
 
-@dataclass(frozen=True)
-class Provider:
-    """Represents a provider object.
 
-    Attributes:
-        obj: The callable object that serves as the provider.
-        scope: The scope of the provider.
-    """
+def is_marker(obj: Any) -> bool:
+    """Checks if an object is a marker."""
+    return isinstance(obj, Marker)
 
-    obj: Callable[..., Any]
-    scope: Scope
 
-    def __str__(self) -> str:
-        """Returns a string representation of the provider.
-
-        Returns:
-            The string representation of the provider.
-        """
-        return self.name
-
-    @cached_property
-    def name(self) -> str:
-        """Returns the full qualified name of the provider object.
-
-        Returns:
-            The full qualified name of the provider object.
-        """
-        return get_full_qualname(self.obj)
-
-    @cached_property
-    def parameters(self) -> Mapping[str, inspect.Parameter]:
-        """Returns the parameters of the provider as a mapping.
-
-        Returns:
-            The parameters of the provider.
-        """
-        return get_signature(self.obj).parameters
-
-    @cached_property
-    def is_class(self) -> bool:
-        """Checks if the provider object is a class.
-
-        Returns:
-            True if the provider object is a class, False otherwise.
-        """
-        return inspect.isclass(self.obj)
-
-    @cached_property
-    def is_function(self) -> bool:
-        """Checks if the provider object is a function.
-
-        Returns:
-            True if the provider object is a function, False otherwise.
-        """
-        return (inspect.isfunction(self.obj) or inspect.ismethod(self.obj)) and not (
-            self.is_resource
-        )
-
-    @cached_property
-    def is_coroutine(self) -> bool:
-        """Checks if the provider object is a coroutine function.
-
-        Returns:
-            True if the provider object is a coroutine function, False otherwise.
-        """
-        return inspect.iscoroutinefunction(self.obj)
-
-    @cached_property
-    def is_generator(self) -> bool:
-        """Checks if the provider object is a generator function.
-
-        Returns:
-            True if the provider object is a resource, False otherwise.
-        """
-        return inspect.isgeneratorfunction(self.obj)
-
-    @cached_property
-    def is_async_generator(self) -> bool:
-        """Checks if the provider object is an async generator function.
-
-        Returns:
-            True if the provider object is an async resource, False otherwise.
-        """
-        return inspect.isasyncgenfunction(self.obj)
+class Event:
+    """Represents an event object."""
+
+    __slots__ = ()
+
+
+def is_event_type(obj: Any) -> bool:
+    """Checks if an object is an event type."""
+    return inspect.isclass(obj) and issubclass(obj, Event)
+
+
+class InstanceProxy(wrapt.ObjectProxy):  # type: ignore[misc]
+    def __init__(self, wrapped: Any, *, interface: type[Any]) -> None:
+        super().__init__(wrapped)
+        self._self_interface = interface
 
     @property
-    def is_resource(self) -> bool:
-        """Checks if the provider object is a sync or async generator function.
+    def interface(self) -> type[Any]:
+        return self._self_interface
+
+    def __getattribute__(self, item: str) -> Any:
+        if item in "interface":
+            return object.__getattribute__(self, item)
+        return object.__getattribute__(self, item)
+
+
+class ProviderDecoratorArgs(NamedTuple):
+    scope: Scope
+    override: bool
+
+
+class Dependency(NamedTuple):
+    member: Any
+    module: ModuleType
+
 
-        Returns:
-            True if the provider object is a resource, False otherwise.
-        """
-        return self.is_generator or self.is_async_generator
+class InjectableDecoratorArgs(NamedTuple):
+    wrapped: bool
+    tags: Iterable[str] | None

anydi/_utils.py

@@ -1,87 +1,84 @@
 """Shared AnyDI utils module."""
 
+from __future__ import annotations
+
 import builtins
 import functools
+import importlib
 import inspect
+import re
 import sys
-from typing import Any, Callable, Dict, Type, TypeVar
-
-from typing_extensions import Annotated, ParamSpec, get_origin
-
-try:
-    import anyio  # noqa
-except ImportError:
-    anyio = None  # type: ignore[assignment]
+from types import TracebackType
+from typing import Any, Callable, ForwardRef, TypeVar
 
+import anyio
+from typing_extensions import ParamSpec, Self, get_args, get_origin
 
 T = TypeVar("T")
 P = ParamSpec("P")
 
 
 def get_full_qualname(obj: Any) -> str:
-    """Get the fully qualified name of an object.
-
-    This function returns the fully qualified name of the given object,
-    which includes both the module name and the object's qualname.
-
-    Args:
-        obj: The object for which to retrieve the fully qualified name.
+    """Get the fully qualified name of an object."""
+    # Get module and qualname with defaults to handle non-types directly
+    module = getattr(obj, "__module__", type(obj).__module__)
+    qualname = getattr(obj, "__qualname__", type(obj).__qualname__)
 
-    Returns:
-        The fully qualified name of the object.
-    """
     origin = get_origin(obj)
-    if origin is Annotated:
-        metadata = ", ".join(
-            [
-                f'"{arg}"' if isinstance(arg, str) else str(arg)
-                for arg in obj.__metadata__
-            ]
-        )
-        return f"Annotated[{get_full_qualname(obj.__args__[0])}, {metadata}]]"
-
-    qualname = getattr(obj, "__qualname__", None)
-    module_name = getattr(obj, "__module__", None)
-    if qualname is None:
-        qualname = type(obj).__qualname__
-
-    if module_name is None:
-        module_name = type(obj).__module__
+    # If origin exists, handle generics recursively
+    if origin:
+        args = ", ".join(get_full_qualname(arg) for arg in get_args(obj))
+        return f"{get_full_qualname(origin)}[{args}]"
+
+    # Substitute standard library prefixes for clarity
+    full_qualname = f"{module}.{qualname}"
+    return re.sub(
+        r"\b(builtins|typing|typing_extensions|collections\.abc|types)\.",
+        "",
+        full_qualname,
+    )
+
+
+def is_builtin_type(tp: type[Any]) -> bool:
+    """Check if the given type is a built-in type."""
+    return tp.__module__ == builtins.__name__
 
-    if module_name == builtins.__name__:
-        return qualname
-    return f"{module_name}.{qualname}"
 
+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_builtin_type(tp: Type[Any]) -> bool:
-    """
-    Check if the given type is a built-in type.
-    Args:
-        tp (type): The type to check.
-    Returns:
-        bool: True if the type is a built-in type, False otherwise.
-    """
-    return tp.__module__ == builtins.__name__
 
+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__")
 
-@functools.lru_cache(maxsize=None)
-def get_signature(obj: Callable[..., Any]) -> inspect.Signature:
-    """Get the signature of a callable object.
 
-    This function uses the `inspect.signature` function to retrieve the signature
-    of the given callable object. It applies an LRU cache decorator to improve
-    performance by caching the signatures of previously inspected objects.
+def get_typed_annotation(
+    annotation: Any, globalns: dict[str, Any], module: Any = None
+) -> Any:
+    """Get the typed annotation of a callable object."""
+    if isinstance(annotation, str):
+        if sys.version_info >= (3, 10):
+            ref = ForwardRef(annotation, module=module)
+        else:
+            ref = ForwardRef(annotation)
+        annotation = ref._evaluate(globalns, globalns, recursive_guard=frozenset())  # noqa
+    return annotation
 
-    Args:
-        obj: The callable object to inspect.
 
-    Returns:
-        The signature of the callable object.
-    """
-    signature_kwargs: Dict[str, Any] = {}
-    if sys.version_info >= (3, 10):
-        signature_kwargs["eval_str"] = True
-    return inspect.signature(obj, **signature_kwargs)
+def get_typed_parameters(obj: Callable[..., Any]) -> list[inspect.Parameter]:
+    """Get the typed parameters of a callable object."""
+    globalns = getattr(obj, "__globals__", {})
+    module = getattr(obj, "__module__", None)
+    return [
+        parameter.replace(
+            annotation=get_typed_annotation(
+                parameter.annotation, globalns, module=module
+            )
+        )
+        for parameter in inspect.signature(obj).parameters.values()
+    ]
 
 
 async def run_async(
@@ -90,22 +87,56 @@ async def run_async(
     *args: P.args,
     **kwargs: P.kwargs,
 ) -> T:
-    """Runs the given function asynchronously using the `anyio` library.
-
-    Args:
-        func: The function to run asynchronously.
-        args: The positional arguments to pass to the function.
-        kwargs: The keyword arguments to pass to the function.
+    """Runs the given function asynchronously using the `anyio` library."""
+    return await anyio.to_thread.run_sync(functools.partial(func, *args, **kwargs))
 
-    Returns:
-        The result of the function.
 
-    Raises:
-        ImportError: If the `anyio` library is not installed.
+def import_string(dotted_path: str) -> Any:
     """
-    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))
+    Import a module or a specific attribute from a module using its dotted string path.
+    """
+    try:
+        module_path, _, attribute_name = dotted_path.rpartition(".")
+        if module_path:
+            module = importlib.import_module(module_path)
+            return getattr(module, attribute_name)
+        else:
+            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/ext/_utils.py

@@ -1,16 +1,21 @@
+"""AnyDI FastAPI extension."""
+
+from __future__ import annotations
+
 import inspect
-from typing import Any, Callable
+import logging
+from typing import Annotated, Any, Callable
 
-from typing_extensions import Annotated, get_args, get_origin
+from typing_extensions import get_args, get_origin
 
 from anydi import Container
-from anydi._logger import logger
 from anydi._utils import get_full_qualname
 
+logger = logging.getLogger(__name__)
+
 
 class HasInterface:
-    def __init__(self) -> None:
-        self._interface: Any = None
+    _interface: Any = None
 
     @property
     def interface(self) -> Any:
@@ -23,36 +28,52 @@ class HasInterface:
         self._interface = interface
 
 
-def patch_parameter_interface(
-    call: Callable[..., Any], parameter: inspect.Parameter, container: Container
-) -> None:
-    """Patch a parameter to inject dependencies using AnyDI.
-
-    Args:
-        call:  The call function.
-        parameter: The parameter to patch.
-        container: The AnyDI container.
-    """
-    interface, default = parameter.annotation, parameter.default
-
-    if get_origin(interface) is Annotated:
-        args = get_args(interface)
-        if len(args) == 2:
-            interface, default = args
-        elif len(args) == 3:
-            interface, metadata, default = args
-            interface = Annotated[interface, metadata]
+def patch_annotated_parameter(parameter: inspect.Parameter) -> inspect.Parameter:
+    """Patch an annotated parameter to resolve the default value."""
+    if not (
+        get_origin(parameter.annotation) is Annotated
+        and parameter.default is inspect.Parameter.empty
+    ):
+        return parameter
+
+    tp_origin, *tp_metadata = get_args(parameter.annotation)
+    default = tp_metadata[-1]
 
     if not isinstance(default, HasInterface):
-        return None
+        return parameter
 
-    parameter = parameter.replace(annotation=interface, default=default)
+    if (num := len(tp_metadata[:-1])) == 0:
+        interface = tp_origin
+    elif num == 1:
+        interface = Annotated[tp_origin, tp_metadata[0]]
+    elif num == 2:
+        interface = Annotated[tp_origin, tp_metadata[0], tp_metadata[1]]
+    elif num == 3:
+        interface = Annotated[
+            tp_origin,
+            tp_metadata[0],
+            tp_metadata[1],
+            tp_metadata[2],
+        ]
+    else:
+        raise TypeError("Too many annotated arguments.")  # pragma: no cover
+    return parameter.replace(annotation=interface, default=default)
+
+
+def patch_call_parameter(
+    container: Container, call: Callable[..., Any], parameter: inspect.Parameter
+) -> None:
+    """Patch a parameter to inject dependencies using AnyDI."""
+    parameter = patch_annotated_parameter(parameter)
+
+    if not isinstance(parameter.default, HasInterface):
+        return None
 
-    if not container.strict and not container.is_registered(interface):
+    if not container.strict and not container.is_registered(parameter.annotation):
         logger.debug(
             f"Callable `{get_full_qualname(call)}` injected parameter "
             f"`{parameter.name}` with an annotation of "
-            f"`{get_full_qualname(interface)}` "
+            f"`{get_full_qualname(parameter.annotation)}` "
             "is not registered. It will be registered at runtime with the "
             "first call because it is running in non-strict mode."
         )

anydi/ext/django/__init__.py

@@ -0,0 +1,9 @@
+from ._container import container
+from ._utils import inject_urlpatterns, register_components, register_settings
+
+__all__ = [
+    "container",
+    "register_components",
+    "register_settings",
+    "inject_urlpatterns",
+]

anydi/ext/django/_container.py

@@ -0,0 +1,18 @@
+from typing import cast
+
+from django.apps.registry import apps
+from django.utils.functional import SimpleLazyObject
+
+import anydi
+
+from .apps import ContainerConfig
+
+__all__ = ["container"]
+
+
+def _get_container() -> anydi.Container:
+    app_config = cast(ContainerConfig, apps.get_app_config(ContainerConfig.label))
+    return app_config.container
+
+
+container = cast(anydi.Container, SimpleLazyObject(_get_container))

anydi/ext/django/_settings.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from django.conf import settings
+from typing_extensions import TypedDict
+
+
+class Settings(TypedDict):
+    CONTAINER_FACTORY: str | None
+    STRICT_MODE: bool
+    REGISTER_SETTINGS: bool
+    REGISTER_COMPONENTS: bool
+    INJECT_URLCONF: str | Sequence[str] | None
+    MODULES: Sequence[str]
+    SCAN_PACKAGES: Sequence[str]
+    PATCH_NINJA: bool
+
+
+DEFAULTS = Settings(
+    CONTAINER_FACTORY=None,
+    STRICT_MODE=False,
+    REGISTER_SETTINGS=False,
+    REGISTER_COMPONENTS=False,
+    MODULES=[],
+    PATCH_NINJA=False,
+    INJECT_URLCONF=None,
+    SCAN_PACKAGES=[],
+)
+
+
+def get_settings() -> Settings:
+    """Get the AnyDI settings from the Django settings."""
+    return Settings(
+        **{
+            **DEFAULTS,
+            **getattr(settings, "ANYDI", {}),
+        }
+    )

anydi/ext/django/_utils.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from functools import wraps
+from typing import Annotated, Any
+
+from django.conf import settings
+from django.core.cache import BaseCache, caches
+from django.db import connections
+from django.db.backends.base.base import BaseDatabaseWrapper
+from django.urls import URLPattern, URLResolver, get_resolver
+from typing_extensions import get_origin
+
+from anydi import Container
+
+
+def register_settings(
+    container: Container, prefix: str = "django.conf.settings."
+) -> None:
+    """Register Django settings into the container."""
+
+    # Ensure prefix ends with a dot
+    if prefix[-1] != ".":
+        prefix += "."
+
+    for setting_name in dir(settings):
+        setting_value = getattr(settings, setting_name)
+        if not setting_name.isupper():
+            continue
+
+        container.register(
+            Annotated[Any, f"{prefix}{setting_name}"],
+            _get_setting_value(setting_value),
+            scope="singleton",
+        )
+
+    # Patch AnyDI to resolve Any types for annotated settings
+    _patch_any_typed_annotated(container, prefix=prefix)
+
+
+def register_components(container: Container) -> None:
+    """Register Django components into the container."""
+
+    # Register caches
+    def _get_cache(cache_name: str) -> Any:
+        return lambda: caches[cache_name]
+
+    for cache_name in caches:
+        container.register(
+            Annotated[BaseCache, cache_name],
+            _get_cache(cache_name),
+            scope="singleton",
+        )
+
+    # Register database connections
+    def _get_connection(alias: str) -> Any:
+        return lambda: connections[alias]
+
+    for alias in connections:
+        container.register(
+            Annotated[BaseDatabaseWrapper, alias],
+            _get_connection(alias),
+            scope="singleton",
+        )
+
+
+def inject_urlpatterns(container: Container, *, urlconf: str) -> None:
+    """Auto-inject the container into views."""
+    resolver = get_resolver(urlconf)
+    for pattern in iter_urlpatterns(resolver.url_patterns):
+        # Skip already injected views
+        if hasattr(pattern.callback, "_injected"):
+            continue
+        # Skip django-ninja views
+        if pattern.lookup_str.startswith("ninja."):
+            continue  # pragma: no cover
+        pattern.callback = container.inject(pattern.callback)
+        pattern.callback._injected = True  # type: ignore[attr-defined]
+
+
+def iter_urlpatterns(
+    urlpatterns: list[URLPattern | URLResolver],
+) -> Iterator[URLPattern]:
+    """Iterate over all views in urlpatterns."""
+    for url_pattern in urlpatterns:
+        if isinstance(url_pattern, URLResolver):
+            yield from iter_urlpatterns(url_pattern.url_patterns)
+        else:
+            yield url_pattern
+
+
+def _get_setting_value(value: Any) -> Any:
+    return lambda: value
+
+
+def _any_typed_interface(interface: Any, prefix: str) -> Any:
+    origin = get_origin(interface)
+    if origin is not Annotated:
+        return interface  # pragma: no cover
+    named = interface.__metadata__[-1]
+
+    if isinstance(named, str) and named.startswith(prefix):
+        _, setting_name = named.rsplit(prefix, maxsplit=1)
+        return Annotated[Any, f"{prefix}{setting_name}"]
+    return interface
+
+
+def _patch_any_typed_annotated(container: Container, *, prefix: str) -> None:
+    def _patch_resolve(resolve: Any) -> Any:
+        @wraps(resolve)
+        def wrapper(interface: Any) -> Any:
+            return resolve(_any_typed_interface(interface, prefix))
+
+        return wrapper
+
+    def _patch_aresolve(resolve: Any) -> Any:
+        @wraps(resolve)
+        async def wrapper(interface: Any) -> Any:
+            return await resolve(_any_typed_interface(interface, prefix))
+
+        return wrapper
+
+    container.resolve = _patch_resolve(  # type: ignore[method-assign]
+        container.resolve
+    )
+    container.aresolve = _patch_aresolve(  # type: ignore[method-assign]
+        container.aresolve
+    )