anydi 0.40.0__py3-none-any.whl → 0.42.0__py3-none-any.whl

anydi/_decorators.py

@@ -0,0 +1,80 @@
+from collections.abc import Iterable
+from typing import Callable, Concatenate, ParamSpec, TypedDict, TypeVar, overload
+
+from ._module import Module
+from ._scope import Scope
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+ClassT = TypeVar("ClassT", bound=type)
+ModuleT = TypeVar("ModuleT", bound=Module)
+
+
+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__ = True
+        cls.__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 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 InjectableMetadata(TypedDict):
+    wrapped: bool
+    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(wrapped=True, tags=tags)  # type: ignore
+        return inner
+
+    if func is None:
+        return decorator
+
+    return decorator(func)

anydi/_module.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+from typing import TYPE_CHECKING, Any, Callable
+
+if TYPE_CHECKING:
+    from ._container import Container
+    from ._decorators import ProviderMetadata
+
+
+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, getattr(value, "__provider__"))
+            for name, value in attrs.items()
+            if hasattr(value, "__provider__")
+        ]
+        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, Union
+
+from ._decorators import InjectableMetadata
+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
+
+    @staticmethod
+    def _scan_module(
+        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
+
+            metadata: InjectableMetadata = getattr(
+                member,
+                "__injectable__",
+                InjectableMetadata(wrapped=False, tags=[]),
+            )
+
+            should_include = False
+            if metadata["wrapped"]:
+                should_include = True
+            elif tags and metadata["tags"]:
+                should_include = bool(set(metadata["tags"]) & set(tags))
+            elif tags and not metadata["tags"]:
+                continue  # tags are provided but member has none
+
+            if not should_include:
+                for param in get_typed_parameters(member):
+                    if is_marker(param.default):
+                        should_include = True
+                        break
+
+            if should_include:
+                dependencies.append(ScannedDependency(member=member, module=module))
+
+        return dependencies

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

@@ -75,7 +75,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(
@@ -120,9 +120,9 @@ def _patch_any_typed_annotated(container: Container, *, prefix: str) -> None:
 
         return wrapper
 
-    container.resolve = _patch_resolve(  # type: ignore[method-assign]
+    container.resolve = _patch_resolve(  # type: ignore
         container.resolve
     )
-    container.aresolve = _patch_aresolve(  # type: ignore[method-assign]
+    container.aresolve = _patch_aresolve(  # type: ignore
         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

anydi/ext/django/ninja/_operation.py

@@ -54,7 +54,7 @@ class AsyncOperation(BaseAsyncOperation):
         super().__init__(*args, **kwargs)
         self.dependencies = self.signature.dependencies
 
-    async def run(self, request: HttpRequest, **kw: Any) -> HttpResponseBase:  # type: ignore
+    async def run(self, request: HttpRequest, **kw: Any) -> HttpResponseBase:
         error = await self._run_checks(request)
         if error:
             return error

anydi/ext/django/ninja/_signature.py

@@ -11,7 +11,7 @@ from ninja.signature.details import (
 )
 from ninja.signature.utils import get_path_param_names, get_typed_signature
 
-from anydi._types import is_marker  # noqa
+from anydi._typing import is_marker  # noqa
 
 
 class ViewSignature(BaseViewSignature):

anydi/ext/fastapi.py

@@ -10,8 +10,8 @@ from fastapi.dependencies.models import Dependant
 from fastapi.routing import APIRoute
 from starlette.requests import Request
 
-from anydi import Container
-from anydi._utils import get_typed_parameters
+from anydi._container import Container
+from anydi._typing import get_typed_parameters
 
 from ._utils import HasInterface, patch_call_parameter
 from .starlette.middleware import RequestScopedMiddleware

anydi/ext/faststream.py

@@ -9,7 +9,7 @@ from faststream import ContextRepo
 from faststream.broker.core.usecase import BrokerUsecase
 
 from anydi import Container
-from anydi._utils import get_typed_parameters
+from anydi._typing import get_typed_parameters
 
 from ._utils import HasInterface, patch_call_parameter
 
@@ -21,7 +21,7 @@ def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
     it to the broker. It also patches the broker handlers to inject the required
     dependencies using AnyDI.
     """
-    broker._container = container  # type: ignore[attr-defined]
+    broker._container = container  # type: ignore
 
     for handler in _get_broken_handlers(broker):
         call = handler._original_call  # noqa

anydi/ext/pytest_plugin.py

@@ -6,11 +6,10 @@ from collections.abc import Iterator
 from typing import Any, Callable, cast
 
 import pytest
-from _pytest.python import async_warn_and_skip
 from anyio.pytest_plugin import extract_backend_and_options, get_runner
 
 from anydi import Container
-from anydi._utils import get_typed_parameters
+from anydi._typing import get_typed_parameters
 
 logger = logging.getLogger(__name__)
 
@@ -117,7 +116,12 @@ def _anydi_ainject(
 
     # Skip if the anyio backend is not available
     if "anyio_backend" not in request.fixturenames:
-        async_warn_and_skip(request.node.nodeid)
+        msg = (
+            "To run async test functions with `anyio`, "
+            "please configure the `anyio` pytest plugin.\n"
+            "See: https://anyio.readthedocs.io/en/stable/testing.html"
+        )
+        pytest.fail(msg, pytrace=False)
 
     async def _awrapper() -> None:
         # Setup the container

anydi/ext/starlette/middleware.py

@@ -5,7 +5,7 @@ from starlette.requests import Request
 from starlette.responses import Response
 from starlette.types import ASGIApp
 
-from anydi import Container
+from anydi._container import Container
 
 
 class RequestScopedMiddleware(BaseHTTPMiddleware):