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

anydi/_context.py

@@ -7,7 +7,7 @@ from typing import Any
 
 from typing_extensions import Self
 
-from ._utils import AsyncRLock, run_async
+from ._async import AsyncRLock, run_sync
 
 
 class InstanceContext:
@@ -78,7 +78,7 @@ class InstanceContext:
         exc_tb: TracebackType | None,
     ) -> bool:
         """Exit the context asynchronously."""
-        sync_exit = await run_async(self.__exit__, exc_type, exc_val, exc_tb)
+        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)
         return bool(sync_exit) or bool(async_exit)
 

anydi/_decorators.py

@@ -0,0 +1,122 @@
+from collections.abc import Iterable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Concatenate,
+    ParamSpec,
+    Protocol,
+    TypedDict,
+    TypeGuard,
+    TypeVar,
+    overload,
+)
+
+if TYPE_CHECKING:
+    from ._module import Module
+
+
+from ._scope import Scope
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+ClassT = TypeVar("ClassT", bound=type)
+ModuleT = TypeVar("ModuleT", bound="Module")
+
+
+class ProvidedMetadata(TypedDict):
+    """Metadata for classes marked as provided by AnyDI."""
+
+    scope: Scope
+
+
+def provided(*, scope: Scope) -> Callable[[ClassT], ClassT]:
+    """Decorator for marking a class as provided by AnyDI with a specific scope."""
+
+    def decorator(cls: ClassT) -> ClassT:
+        cls.__provided__ = ProvidedMetadata(scope=scope)
+        return cls
+
+    return decorator
+
+
+# Scoped decorators for class-level providers
+transient = provided(scope="transient")
+request = provided(scope="request")
+singleton = provided(scope="singleton")
+
+
+class Provided(Protocol):
+    __provided__: ProvidedMetadata
+
+
+def is_provided(cls: Any) -> TypeGuard[type[Provided]]:
+    return hasattr(cls, "__provided__")
+
+
+class ProviderMetadata(TypedDict):
+    scope: Scope
+    override: bool
+
+
+def provider(
+    *, scope: Scope, override: bool = False
+) -> Callable[
+    [Callable[Concatenate[ModuleT, P], T]], Callable[Concatenate[ModuleT, P], T]
+]:
+    """Decorator for marking a function or method as a provider in a AnyDI module."""
+
+    def decorator(
+        target: Callable[Concatenate[ModuleT, P], T],
+    ) -> Callable[Concatenate[ModuleT, P], T]:
+        target.__provider__ = ProviderMetadata(scope=scope, override=override)  # type: ignore
+        return target
+
+    return decorator
+
+
+class Provider(Protocol):
+    __provider__: ProviderMetadata
+
+
+def is_provider(obj: Callable[..., Any]) -> TypeGuard[Provider]:
+    return hasattr(obj, "__provider__")
+
+
+class InjectableMetadata(TypedDict):
+    tags: Iterable[str] | None
+
+
+@overload
+def injectable(func: Callable[P, T]) -> Callable[P, T]: ...
+
+
+@overload
+def injectable(
+    *, tags: Iterable[str] | None = None
+) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
+
+
+def injectable(
+    func: Callable[P, T] | None = None,
+    tags: Iterable[str] | None = None,
+) -> Callable[[Callable[P, T]], Callable[P, T]] | Callable[P, T]:
+    """Decorator for marking a function or method as requiring dependency injection."""
+
+    def decorator(inner: Callable[P, T]) -> Callable[P, T]:
+        inner.__injectable__ = InjectableMetadata(tags=tags)  # type: ignore
+        return inner
+
+    if func is None:
+        return decorator
+
+    return decorator(func)
+
+
+class Injectable(Protocol):
+    __injectable__: InjectableMetadata
+
+
+def is_injectable(obj: Callable[..., Any]) -> TypeGuard[Injectable]:
+    return hasattr(obj, "__injectable__")

anydi/_module.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+from typing import TYPE_CHECKING, Any, Callable
+
+from ._decorators import ProviderMetadata, is_provider
+
+if TYPE_CHECKING:
+    from ._container import Container
+
+
+class ModuleMeta(type):
+    """A metaclass used for the Module base class."""
+
+    def __new__(cls, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> Any:
+        attrs["providers"] = [
+            (name, value.__provider__)
+            for name, value in attrs.items()
+            if is_provider(value)
+        ]
+        return super().__new__(cls, name, bases, attrs)
+
+
+class Module(metaclass=ModuleMeta):
+    """A base class for defining AnyDI modules."""
+
+    providers: list[tuple[str, ProviderMetadata]]
+
+    def configure(self, container: Container) -> None:
+        """Configure the AnyDI container with providers and their dependencies."""
+
+
+ModuleDef = Module | type[Module] | Callable[["Container"], None] | str
+
+
+class ModuleRegistrar:
+    def __init__(self, container: Container) -> None:
+        self._container = container
+
+    def register(self, module: ModuleDef) -> None:
+        """Register a module as a callable, module type, or module instance."""
+        # Callable Module
+        if inspect.isfunction(module):
+            module(self._container)
+            return
+
+        # Module path
+        if isinstance(module, str):
+            module = self.import_module_from_string(module)
+
+        # Class based Module or Module type
+        if inspect.isclass(module) and issubclass(module, Module):
+            module = module()
+
+        if isinstance(module, Module):
+            module.configure(self._container)
+            for provider_name, metadata in module.providers:
+                obj = getattr(module, provider_name)
+                self._container.provider(**metadata)(obj)
+        else:
+            raise TypeError(
+                "The module must be a callable, a module type, or a module instance."
+            )
+
+    @staticmethod
+    def import_module_from_string(dotted_path: str) -> Any:
+        """Import a module or attribute from a dotted 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

anydi/_provider.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import enum
+import inspect
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any, Callable, NamedTuple
+
+from ._scope import Scope
+from ._typing import NOT_SET
+
+
+class ProviderKind(enum.IntEnum):
+    CLASS = 1
+    FUNCTION = 2
+    COROUTINE = 3
+    GENERATOR = 4
+    ASYNC_GENERATOR = 5
+
+    @classmethod
+    def from_call(cls, call: Callable[..., Any]) -> ProviderKind:
+        if inspect.isclass(call):
+            return cls.CLASS
+        if inspect.iscoroutinefunction(call):
+            return cls.COROUTINE
+        if inspect.isasyncgenfunction(call):
+            return cls.ASYNC_GENERATOR
+        if inspect.isgeneratorfunction(call):
+            return cls.GENERATOR
+        if inspect.isfunction(call) or inspect.ismethod(call):
+            return cls.FUNCTION
+        raise TypeError(
+            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)
+class Provider:
+    call: Callable[..., Any]
+    scope: Scope
+    interface: Any
+    name: str
+    parameters: list[inspect.Parameter]
+    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)
+
+
+class ProviderDef(NamedTuple):
+    call: Callable[..., Any]
+    scope: Scope
+    interface: Any = NOT_SET

anydi/_scan.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import pkgutil
+from collections.abc import Iterable
+from dataclasses import dataclass
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Callable, Union
+
+from ._decorators import is_injectable
+from ._typing import get_typed_parameters, is_marker
+
+if TYPE_CHECKING:
+    from ._container import Container
+
+Package = Union[ModuleType, str]
+PackageOrIterable = Union[Package, Iterable[Package]]
+
+
+@dataclass(kw_only=True)
+class ScannedDependency:
+    member: Any
+    module: ModuleType
+
+    def __post_init__(self) -> None:
+        # Unwrap decorated functions if necessary
+        if hasattr(self.member, "__wrapped__"):
+            self.member = self.member.__wrapped__
+
+
+class Scanner:
+    def __init__(self, container: Container) -> None:
+        self._container = container
+
+    def scan(
+        self, /, packages: PackageOrIterable, *, tags: Iterable[str] | None = None
+    ) -> None:
+        """Scan packages or modules for decorated members and inject dependencies."""
+        if isinstance(packages, (ModuleType, str)):
+            scan_packages: Iterable[Package] = [packages]
+        else:
+            scan_packages = packages
+
+        dependencies = [
+            dependency
+            for package in scan_packages
+            for dependency in self._scan_package(package, tags=tags)
+        ]
+
+        for dependency in dependencies:
+            decorated = self._container.inject()(dependency.member)
+            setattr(dependency.module, dependency.member.__name__, decorated)
+
+    def _scan_package(
+        self, package: Package, *, tags: Iterable[str] | None = None
+    ) -> list[ScannedDependency]:
+        """Scan a package or module for decorated members."""
+        tags = list(tags) if tags else []
+
+        if isinstance(package, str):
+            package = importlib.import_module(package)
+
+        if not hasattr(package, "__path__"):
+            return self._scan_module(package, tags=tags)
+
+        dependencies: list[ScannedDependency] = []
+        for module_info in pkgutil.walk_packages(
+            package.__path__, prefix=package.__name__ + "."
+        ):
+            module = importlib.import_module(module_info.name)
+            dependencies.extend(self._scan_module(module, tags=tags))
+
+        return dependencies
+
+    def _scan_module(
+        self, module: ModuleType, *, tags: Iterable[str]
+    ) -> list[ScannedDependency]:
+        """Scan a module for decorated members."""
+        dependencies: list[ScannedDependency] = []
+
+        for _, member in inspect.getmembers(module, predicate=callable):
+            if getattr(member, "__module__", None) != module.__name__:
+                continue
+
+            if self._should_include_member(member, tags=tags):
+                dependencies.append(ScannedDependency(member=member, module=module))
+
+        return dependencies
+
+    @staticmethod
+    def _should_include_member(
+        member: Callable[..., Any], *, tags: Iterable[str]
+    ) -> bool:
+        """Determine if a member should be included based on tags or marker defaults."""
+
+        if is_injectable(member):
+            member_tags = set(member.__injectable__["tags"] or [])
+            if tags:
+                return bool(set(tags) & member_tags)
+            return True  # No tags passed → include all injectables
+
+        # If no tags are passed and not explicitly injectable,
+        # check for parameter markers
+        if not tags:
+            for param in get_typed_parameters(member):
+                if is_marker(param.default):
+                    return True
+
+        return False

anydi/_scope.py

@@ -0,0 +1,9 @@
+from typing import Literal
+
+Scope = Literal["transient", "singleton", "request"]
+
+ALLOWED_SCOPES: dict[Scope, list[Scope]] = {
+    "singleton": ["singleton"],
+    "request": ["request", "singleton"],
+    "transient": ["transient", "request", "singleton"],
+}

anydi/{_utils.py → _typing.py}

@@ -3,29 +3,22 @@
 from __future__ import annotations
 
 import builtins
-import functools
-import importlib
 import inspect
 import re
 import sys
 from collections.abc import AsyncIterator, Iterator
-from types import TracebackType
-from typing import Any, Callable, ForwardRef, TypeVar
+from typing import Any, Callable, ForwardRef
 
-import anyio.to_thread
-from typing_extensions import ParamSpec, Self, get_args, get_origin
+from typing_extensions import Self, get_args, get_origin
 
 try:
     from types import NoneType
 except ImportError:
-    NoneType = type(None)  # type: ignore[misc]
+    NoneType = type(None)
 
-T = TypeVar("T")
-P = ParamSpec("P")
 
-
-def get_full_qualname(obj: Any) -> str:
-    """Get the fully qualified name of an object."""
+def type_repr(obj: Any) -> str:
+    """Get a string representation of a type or object."""
     if isinstance(obj, str):
         return obj
 
@@ -36,8 +29,8 @@ def get_full_qualname(obj: Any) -> str:
     origin = get_origin(obj)
     # 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}]"
+        args = ", ".join(type_repr(arg) for arg in get_args(obj))
+        return f"{type_repr(origin)}[{args}]"
 
     # Substitute standard library prefixes for clarity
     full_qualname = f"{module}.{qualname}"
@@ -100,62 +93,49 @@ def get_typed_parameters(obj: Callable[..., Any]) -> list[inspect.Parameter]:
     ]
 
 
-async def run_async(
-    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))
-
-
-def import_string(dotted_path: str) -> Any:
-    """
-    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 _Marker:
+    """A marker class for marking dependencies."""
 
-class AsyncRLock:
-    def __init__(self) -> None:
-        self._lock = anyio.Lock()
-        self._owner: anyio.TaskInfo | None = None
-        self._count = 0
+    __slots__ = ()
 
-    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()
+    def __call__(self) -> Self:
         return self
 
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: TracebackType | None,
-    ) -> Any:
-        self.release()
+
+def Marker() -> Any:
+    return _Marker()
+
+
+def is_marker(obj: Any) -> bool:
+    """Checks if an object is a marker."""
+    return isinstance(obj, _Marker)
+
+
+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 _Sentinel:
+    __slots__ = ("_name",)
+
+    def __init__(self, name: str) -> None:
+        self._name = name
+
+    def __repr__(self) -> str:
+        return f"<{self._name}>"
+
+    def __eq__(self, other: object) -> bool:
+        return self is other
+
+    def __hash__(self) -> int:
+        return id(self)
+
+
+NOT_SET = _Sentinel("NOT_SET")

anydi/ext/_utils.py

@@ -8,8 +8,8 @@ from typing import Annotated, Any, Callable
 
 from typing_extensions import get_args, get_origin
 
-from anydi import Container
-from anydi._utils import get_full_qualname
+from anydi._container import Container
+from anydi._typing import type_repr
 
 logger = logging.getLogger(__name__)
 
@@ -71,9 +71,9 @@ def patch_call_parameter(
 
     if not container.strict and not container.is_registered(parameter.annotation):
         logger.debug(
-            f"Callable `{get_full_qualname(call)}` injected parameter "
+            f"Callable `{type_repr(call)}` injected parameter "
             f"`{parameter.name}` with an annotation of "
-            f"`{get_full_qualname(parameter.annotation)}` "
+            f"`{type_repr(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/_utils.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from functools import wraps
 from typing import Annotated, Any
 
 from django.conf import settings
@@ -9,7 +8,6 @@ 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
 
@@ -29,14 +27,11 @@ def register_settings(
             continue
 
         container.register(
-            Annotated[Any, f"{prefix}{setting_name}"],
+            Annotated[type(setting_value), 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."""
@@ -75,7 +70,7 @@ def inject_urlpatterns(container: Container, *, urlconf: str) -> None:
         if pattern.lookup_str.startswith("ninja."):
             continue  # pragma: no cover
         pattern.callback = container.inject(pattern.callback)
-        pattern.callback._injected = True  # type: ignore[attr-defined]
+        pattern.callback._injected = True  # type: ignore
 
 
 def iter_urlpatterns(
@@ -91,38 +86,3 @@ def iter_urlpatterns(
 
 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
-    )

anydi/ext/django/apps.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import logging
 import types
 from typing import Callable, cast
 
@@ -14,8 +13,6 @@ import anydi
 from ._settings import get_settings
 from ._utils import inject_urlpatterns, register_components, register_settings
 
-logger = logging.getLogger(__name__)
-
 
 class ContainerConfig(AppConfig):
     name = "anydi.ext.django"

anydi/ext/django/ninja/__init__.py

@@ -11,6 +11,6 @@ from ._signature import ViewSignature
 
 
 def patch_ninja() -> None:
-    operation.ViewSignature = ViewSignature  # type: ignore[attr-defined]
-    operation.Operation = Operation  # type: ignore[misc]
-    operation.AsyncOperation = AsyncOperation  # type: ignore[misc]
+    operation.ViewSignature = ViewSignature  # type: ignore
+    operation.Operation = Operation  # type: ignore
+    operation.AsyncOperation = AsyncOperation  # type: ignore