anydi 0.30.0__py3-none-any.whl → 0.32.0__py3-none-any.whl

anydi/_provider.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import inspect
+import uuid
+from collections.abc import AsyncIterator, Iterator
+from enum import IntEnum
+from typing import Any, Callable
+
+from typing_extensions import get_args, get_origin
+
+try:
+    from types import NoneType
+except ImportError:
+    NoneType = type(None)  # type: ignore[misc]
+
+
+from ._types import Event, Scope
+from ._utils import get_full_qualname, get_typed_annotation
+
+_sentinel = object()
+
+
+class CallableKind(IntEnum):
+    CLASS = 1
+    FUNCTION = 2
+    COROUTINE = 3
+    GENERATOR = 4
+    ASYNC_GENERATOR = 5
+
+
+class Provider:
+    __slots__ = (
+        "_call",
+        "_call_module",
+        "_call_globals",
+        "_scope",
+        "_qualname",
+        "_kind",
+        "_interface",
+        "_parameters",
+    )
+
+    def __init__(
+        self, *, call: Callable[..., Any], scope: Scope, interface: Any = _sentinel
+    ) -> None:
+        self._call = call
+        self._call_module = getattr(call, "__module__", None)
+        self._call_globals = getattr(call, "__globals__", {})
+        self._scope = scope
+        self._qualname = get_full_qualname(call)
+
+        # Detect the kind of callable provider
+        self._detect_kind()
+
+        # Validate the scope of the provider
+        self._validate_scope()
+
+        # Get the signature
+        signature = inspect.signature(call)
+
+        # Detect the interface
+        self._detect_interface(interface, signature)
+
+        # Detect the parameters
+        self._detect_parameters(signature)
+
+    def __str__(self) -> str:
+        return self._qualname
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Provider):
+            return NotImplemented
+        return (
+            self._call == other._call
+            and self._scope == other._scope
+            and self._interface == other._interface
+        )
+
+    @property
+    def call(self) -> Callable[..., Any]:
+        return self._call
+
+    @property
+    def kind(self) -> CallableKind:
+        return self._kind
+
+    @property
+    def scope(self) -> Scope:
+        return self._scope
+
+    @property
+    def interface(self) -> Any:
+        return self._interface
+
+    @property
+    def parameters(self) -> list[inspect.Parameter]:
+        return self._parameters
+
+    @property
+    def is_resource(self) -> bool:
+        """Check if the provider is a resource."""
+        return self._kind in {
+            CallableKind.GENERATOR,
+            CallableKind.ASYNC_GENERATOR,
+        }
+
+    def _validate_scope(self) -> None:
+        """Validate the scope of the provider."""
+        if self.is_resource and self.scope == "transient":
+            raise TypeError(
+                f"The resource provider `{self}` is attempting to register "
+                "with a transient scope, which is not allowed."
+            )
+
+    def _detect_kind(self) -> None:
+        """Detect the kind of callable provider."""
+        if inspect.isclass(self.call):
+            self._kind = CallableKind.CLASS
+        elif inspect.iscoroutinefunction(self.call):
+            self._kind = CallableKind.COROUTINE
+        elif inspect.isasyncgenfunction(self.call):
+            self._kind = CallableKind.ASYNC_GENERATOR
+        elif inspect.isgeneratorfunction(self.call):
+            self._kind = CallableKind.GENERATOR
+        elif inspect.isfunction(self.call) or inspect.ismethod(self.call):
+            self._kind = CallableKind.FUNCTION
+        else:
+            raise TypeError(
+                f"The provider `{self.call}` is invalid because it is not a callable "
+                "object. Only callable providers are allowed."
+            )
+
+    def _detect_interface(self, interface: Any, signature: inspect.Signature) -> None:
+        """Detect the interface of callable provider."""
+        # If the callable is a class, return the class itself
+        if self._kind == CallableKind.CLASS:
+            self._interface = self._call
+            return
+
+        if interface is _sentinel:
+            interface = self._resolve_interface(interface, signature)
+
+        # If the callable is an iterator, return the actual type
+        iterator_types = {Iterator, AsyncIterator}
+        if interface in iterator_types or get_origin(interface) in iterator_types:
+            if args := get_args(interface):
+                interface = args[0]
+                # If the callable is a generator, return the resource type
+                if interface is NoneType or interface is None:
+                    self._interface = type(f"Event_{uuid.uuid4().hex}", (Event,), {})
+                    return
+            else:
+                raise TypeError(
+                    f"Cannot use `{self}` resource type annotation "
+                    "without actual type argument."
+                )
+
+        # None interface is not allowed
+        if interface in {None, NoneType}:
+            raise TypeError(f"Missing `{self}` provider return annotation.")
+
+        # Set the interface
+        self._interface = interface
+
+    def _resolve_interface(self, interface: Any, signature: inspect.Signature) -> Any:
+        """Resolve the interface of the callable provider."""
+        interface = signature.return_annotation
+        if interface is inspect.Signature.empty:
+            return None
+        return get_typed_annotation(
+            interface,
+            self._call_globals,
+            module=self._call_module,
+        )
+
+    def _detect_parameters(self, signature: inspect.Signature) -> None:
+        """Detect the parameters of the callable provider."""
+        self._parameters = [
+            parameter.replace(
+                annotation=get_typed_annotation(
+                    parameter.annotation,
+                    self._call_globals,
+                    module=self._call_module,
+                )
+            )
+            for parameter in signature.parameters.values()
+        ]

anydi/_scanner.py

@@ -3,13 +3,13 @@ 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,
-    Iterable,
     TypeVar,
     Union,
     cast,
@@ -32,13 +32,6 @@ P = ParamSpec("P")
 
 @dataclass(frozen=True)
 class Dependency:
-    """Represents a scanned dependency.
-
-    Attributes:
-        member: The member object that represents the dependency.
-        module: The module where the dependency is defined.
-    """
-
     member: Any
     module: ModuleType
 
@@ -58,14 +51,7 @@ class Scanner:
         *,
         tags: Iterable[str] | None = None,
     ) -> None:
-        """Scan packages or modules for decorated members and inject dependencies.
-
-        Args:
-            packages: A single package or module to scan,
-                or an iterable of packages or modules to scan.
-            tags: Optional list of tags to filter the scanned members. Only members
-                with at least one matching tag will be scanned. Defaults to None.
-        """
+        """Scan packages or modules for decorated members and inject dependencies."""
         dependencies: list[Dependency] = []
 
         if isinstance(packages, Iterable) and not isinstance(packages, str):
@@ -86,16 +72,7 @@ class Scanner:
         *,
         tags: Iterable[str] | None = None,
     ) -> list[Dependency]:
-        """Scan a package or module for decorated members.
-
-        Args:
-            package: The package or module to scan.
-            tags: Optional list of tags to filter the scanned members. Only members
-                with at least one matching tag will be scanned. Defaults to None.
-
-        Returns:
-            A list of scanned dependencies.
-        """
+        """Scan a package or module for decorated members."""
         tags = tags or []
         if isinstance(package, str):
             package = importlib.import_module(package)
@@ -118,16 +95,7 @@ class Scanner:
     def _scan_module(
         self, module: ModuleType, *, tags: Iterable[str]
     ) -> list[Dependency]:
-        """Scan a module for decorated members.
-
-        Args:
-            module: The module to scan.
-            tags: List of tags to filter the scanned members. Only members with at
-                least one matching tag will be scanned.
-
-        Returns:
-            A list of scanned dependencies.
-        """
+        """Scan a module for decorated members."""
         dependencies: list[Dependency] = []
 
         for _, member in inspect.getmembers(module):
@@ -156,11 +124,7 @@ class Scanner:
                 continue
 
             # Get by Marker
-            if inspect.isclass(member):
-                parameters = get_typed_parameters(member.__init__)
-            else:
-                parameters = get_typed_parameters(member)
-            for parameter in parameters:
+            for parameter in get_typed_parameters(member):
                 if is_marker(parameter.default):
                     dependencies.append(
                         self._create_dependency(member=member, module=module)
@@ -170,15 +134,7 @@ class Scanner:
         return dependencies
 
     def _create_dependency(self, member: Any, module: ModuleType) -> Dependency:
-        """Create a `Dependency` object from the scanned member and module.
-
-        Args:
-            member: The scanned member.
-            module: The module containing the scanned member.
-
-        Returns:
-            A `ScannedDependency` object.
-        """
+        """Create a `Dependency` object from the scanned member and module."""
         if hasattr(member, "__wrapped__"):
             member = member.__wrapped__
         return Dependency(member=member, module=module)
@@ -190,7 +146,7 @@ class InjectDecoratorArgs(NamedTuple):
 
 
 @overload
-def injectable(obj: Callable[P, T]) -> Callable[P, T]: ...
+def injectable(func: Callable[P, T]) -> Callable[P, T]: ...
 
 
 @overload
@@ -200,26 +156,16 @@ def injectable(
 
 
 def injectable(
-    obj: Callable[P, T] | None = None,
+    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.
-
-    Args:
-        obj: The target function or method to be decorated.
-        tags: Optional tags to associate with the injection point.
-
-    Returns:
-        If `obj` is provided, returns the decorated target function or method.
-        If `obj` is not provided, returns a decorator that can be used to mark
-        a function or method as requiring dependency injection.
-    """
+    """Decorator for marking a function or method as requiring dependency injection."""
 
-    def decorator(obj: Callable[P, T]) -> Callable[P, T]:
-        setattr(obj, "__injectable__", InjectDecoratorArgs(wrapped=True, tags=tags))
-        return obj
+    def decorator(inner: Callable[P, T]) -> Callable[P, T]:
+        setattr(inner, "__injectable__", InjectDecoratorArgs(wrapped=True, tags=tags))
+        return inner
 
-    if obj is None:
+    if func is None:
         return decorator
 
-    return decorator(obj)
+    return decorator(func)

anydi/_types.py

@@ -1,19 +1,15 @@
 from __future__ import annotations
 
 import inspect
-from dataclasses import dataclass
-from functools import cached_property
-from typing import Any, Callable, Type, TypeVar, Union
+from typing import Annotated, Any, TypeVar, Union
 
-from typing_extensions import Annotated, Literal, Self, TypeAlias
-
-from ._utils import get_full_qualname, get_typed_parameters
+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, ...]]
+Interface: TypeAlias = type[T]
 
 
 class Marker:
@@ -39,98 +35,3 @@ class Event:
 def is_event_type(obj: Any) -> bool:
     """Checks if an object is an event type."""
     return inspect.isclass(obj) and issubclass(obj, Event)
-
-
-@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.
-    """
-
-    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) -> list[inspect.Parameter]:
-        """Returns the parameters of the provider as a mapping.
-
-        Returns:
-            The parameters of the provider.
-        """
-        return get_typed_parameters(self.obj)
-
-    @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)
-
-    @property
-    def is_resource(self) -> bool:
-        """Checks if the provider object is a sync or async generator function.
-
-        Returns:
-            True if the provider object is a resource, False otherwise.
-        """
-        return self.is_generator or self.is_async_generator

anydi/_utils.py

@@ -6,8 +6,9 @@ import builtins
 import functools
 import importlib
 import inspect
+import re
 import sys
-from typing import Any, AsyncIterator, Callable, ForwardRef, Iterator, TypeVar
+from typing import Any, Callable, ForwardRef, TypeVar
 
 from typing_extensions import ParamSpec, get_args, get_origin
 
@@ -23,28 +24,23 @@ P = ParamSpec("P")
 
 def get_full_qualname(obj: Any) -> str:
     """Get the fully qualified name of an object."""
-    qualname = getattr(obj, "__qualname__", None)
-    module = getattr(obj, "__module__", None)
-
-    if qualname is None:
-        qualname = type(obj).__qualname__
-
-    if module is None:
-        module = type(obj).__module__
-
-    if module == builtins.__name__:
-        return qualname
+    # 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__)
 
     origin = get_origin(obj)
-
+    # If origin exists, handle generics recursively
     if origin:
-        args = ", ".join(
-            get_full_qualname(arg) if not isinstance(arg, str) else f'"{arg}"'
-            for arg in get_args(obj)
-        )
+        args = ", ".join(get_full_qualname(arg) for arg in get_args(obj))
         return f"{get_full_qualname(origin)}[{args}]"
 
-    return f"{module}.{qualname}"
+    # 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:
@@ -52,71 +48,33 @@ def is_builtin_type(tp: type[Any]) -> bool:
     return tp.__module__ == builtins.__name__
 
 
-def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
-    if sys.version_info < (3, 9):
-        return type_._evaluate(globalns, localns)
-    return type_._evaluate(globalns, localns, recursive_guard=frozenset())
-
-
 def get_typed_annotation(
-    annotation: Any,
-    globalns: dict[str, Any],
-    module: Any = None,
-    is_class: bool = False,
+    annotation: Any, globalns: dict[str, Any], module: Any = None
 ) -> Any:
-    """Get the typed annotation of a parameter."""
+    """Get the typed annotation of a callable object."""
     if isinstance(annotation, str):
-        if sys.version_info >= (3, 10, 2):
-            annotation = ForwardRef(annotation, module=module, is_class=is_class)
-        elif sys.version_info >= (3, 10, 0):
-            annotation = ForwardRef(annotation, module=module)
+        if sys.version_info >= (3, 10):
+            ref = ForwardRef(annotation, module=module)
         else:
-            annotation = ForwardRef(annotation)
-        annotation = evaluate_forwardref(annotation, globalns, {})
+            ref = ForwardRef(annotation)
+        annotation = ref._evaluate(globalns, globalns, recursive_guard=frozenset())  # noqa
     return annotation
 
 
-def get_typed_return_annotation(obj: Callable[..., Any]) -> Any:
-    """Get the typed return annotation of a callable object."""
-    signature = inspect.signature(obj)
-    annotation = signature.return_annotation
-    if annotation is inspect.Signature.empty:
-        return None
-    globalns = getattr(obj, "__globals__", {})
-    module = getattr(obj, "__module__", None)
-    is_class = inspect.isclass(obj)
-    return get_typed_annotation(annotation, globalns, module=module, is_class=is_class)
-
-
 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)
-    is_class = inspect.isclass(obj)
     return [
         parameter.replace(
             annotation=get_typed_annotation(
-                parameter.annotation,
-                globalns,
-                module=module,
-                is_class=is_class,
+                parameter.annotation, globalns, module=module
             )
         )
-        for name, parameter in inspect.signature(obj).parameters.items()
+        for parameter in inspect.signature(obj).parameters.values()
     ]
 
 
-_resource_origins = (
-    get_origin(Iterator),
-    get_origin(AsyncIterator),
-)
-
-
-def has_resource_origin(origin: Any) -> bool:
-    """Check if the given origin is a resource origin."""
-    return origin in _resource_origins
-
-
 async def run_async(
     func: Callable[P, T],
     /,
@@ -135,15 +93,6 @@ async def run_async(
 def import_string(dotted_path: str) -> Any:
     """
     Import a module or a specific attribute from a module using its dotted string path.
-
-    Args:
-        dotted_path: The dotted path to the object to import.
-
-    Returns:
-        object: The imported module or attribute/class/function.
-
-    Raises:
-        ImportError: If the import fails.
     """
     try:
         module_path, _, attribute_name = dotted_path.rpartition(".")

anydi/ext/_utils.py

@@ -4,9 +4,9 @@ from __future__ import annotations
 
 import inspect
 import logging
-from typing import Any, Callable
+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._utils import get_full_qualname
@@ -32,7 +32,7 @@ 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 parameter.empty
+        and parameter.default is inspect.Parameter.empty
     ):
         return parameter
 
@@ -63,13 +63,7 @@ def patch_annotated_parameter(parameter: inspect.Parameter) -> inspect.Parameter
 def patch_call_parameter(
     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.
-    """
+    """Patch a parameter to inject dependencies using AnyDI."""
     parameter = patch_annotated_parameter(parameter)
 
     if not isinstance(parameter.default, HasInterface):
@@ -84,6 +78,6 @@ def patch_call_parameter(
             "first call because it is running in non-strict mode."
         )
     else:
-        container._validate_injected_parameter(call, parameter)  # noqa
+        container._injector._validate_injected_parameter(call, parameter)  # noqa
 
     parameter.default.interface = parameter.annotation

anydi/ext/django/_settings.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
 from django.conf import settings
 from typing_extensions import TypedDict

anydi/ext/django/_utils.py

@@ -2,14 +2,14 @@ from __future__ import annotations
 
 from collections.abc import Iterator
 from functools import wraps
-from typing import Any
+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 Annotated, get_origin
+from typing_extensions import get_origin
 
 from anydi import Container
 

anydi/ext/django/apps.py

@@ -17,7 +17,7 @@ from ._utils import inject_urlpatterns, register_components, register_settings
 logger = logging.getLogger(__name__)
 
 
-class ContainerConfig(AppConfig):  # type: ignore[misc]
+class ContainerConfig(AppConfig):
     name = "anydi.ext.django"
     label = "anydi_django"