anydi 0.55.1__py3-none-any.whl → 0.57.0__py3-none-any.whl

anydi/__init__.py

@@ -1,10 +1,10 @@
 """AnyDI public objects and functions."""
 
-from ._container import Container
+from ._container import Container, import_container
 from ._decorators import injectable, provided, provider, request, singleton, transient
 from ._module import Module
 from ._provider import ProviderDef as Provider
-from ._types import Inject, Scope
+from ._types import Inject, Provide, Scope
 
 # Alias for dependency auto marker
 # TODO: deprecate it
@@ -15,9 +15,11 @@ __all__ = [
     "Container",
     "Inject",
     "Module",
+    "Provide",
     "Provider",
     "Scope",
     "auto",
+    "import_container",
     "injectable",
     "provided",
     "provider",

anydi/_container.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import contextlib
-import functools
+import importlib
 import inspect
 import logging
 import types
@@ -11,12 +11,13 @@ import uuid
 from collections import defaultdict
 from collections.abc import AsyncIterator, Callable, Iterable, Iterator
 from contextvars import ContextVar
-from typing import Annotated, Any, TypeVar, cast, get_args, get_origin, overload
+from typing import Any, TypeVar, get_args, get_origin, overload
 
 from typing_extensions import ParamSpec, Self, type_repr
 
 from ._context import InstanceContext
 from ._decorators import is_provided
+from ._injector import Injector
 from ._module import ModuleDef, ModuleRegistrar
 from ._provider import Provider, ProviderDef, ProviderKind, ProviderParameter
 from ._resolver import Resolver
@@ -26,7 +27,6 @@ from ._types import (
     Event,
     Scope,
     is_event_type,
-    is_inject_marker,
     is_iterator_type,
     is_none_type,
 )
@@ -58,10 +58,10 @@ class Container:
         self._request_context_var: ContextVar[InstanceContext | None] = ContextVar(
             "request_context", default=None
         )
-        self._inject_cache: dict[Callable[..., Any], Callable[..., Any]] = {}
 
         # Components
         self._resolver = Resolver(self)
+        self._injector = Injector(self)
         self._modules = ModuleRegistrar(self)
         self._scanner = Scanner(self)
 
@@ -195,12 +195,14 @@ class Container:
     def register(
         self,
         interface: Any,
-        call: Callable[..., Any],
+        call: Callable[..., Any] = NOT_SET,
         *,
-        scope: Scope,
+        scope: Scope = "singleton",
         override: bool = False,
     ) -> Provider:
         """Register a provider for the specified interface."""
+        if call is NOT_SET:
+            call = interface
         return self._register_provider(call, scope, interface, override)
 
     def is_registered(self, interface: Any) -> bool:
@@ -548,115 +550,21 @@ class Container:
         """Decorator to inject dependencies into a callable."""
 
         def decorator(call: Callable[P, T]) -> Callable[P, T]:
-            return self._inject(call)
+            return self._injector.inject(call)
 
         if func is None:
             return decorator
         return decorator(func)
 
-    def run(self, func: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs) -> T:
+    def run(self, func: Callable[..., T], /, *args: Any, **kwargs: Any) -> T:
         """Run the given function with injected dependencies."""
-        return self._inject(func)(*args, **kwargs)
-
-    def _inject(self, call: Callable[P, T]) -> Callable[P, T]:
-        """Inject dependencies into a callable."""
-        if call in self._inject_cache:
-            return cast(Callable[P, T], self._inject_cache[call])
-
-        injected_params = self._get_injected_params(call)
-        if not injected_params:
-            self._inject_cache[call] = call
-            return call
-
-        if inspect.iscoroutinefunction(call):
-
-            @functools.wraps(call)
-            async def awrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-                for name, annotation in injected_params.items():
-                    kwargs[name] = await self.aresolve(annotation)
-                return cast(T, await call(*args, **kwargs))
-
-            self._inject_cache[call] = awrapper
-
-            return awrapper  # type: ignore
-
-        @functools.wraps(call)
-        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-            for name, annotation in injected_params.items():
-                kwargs[name] = self.resolve(annotation)
-            return call(*args, **kwargs)
-
-        self._inject_cache[call] = wrapper
-
-        return wrapper
-
-    def _get_injected_params(self, call: Callable[..., Any]) -> dict[str, Any]:
-        """Get the injected parameters of a callable object."""
-        injected_params: dict[str, Any] = {}
-        for parameter in inspect.signature(call, eval_str=True).parameters.values():
-            interface, should_inject = self.validate_injected_parameter(
-                parameter, call=call
-            )
-            if should_inject:
-                injected_params[parameter.name] = interface
-        return injected_params
-
-    @staticmethod
-    def _unwrap_injected_parameter(parameter: inspect.Parameter) -> inspect.Parameter:
-        if get_origin(parameter.annotation) is not Annotated:
-            return parameter
-
-        origin, *metadata = get_args(parameter.annotation)
-
-        if not metadata or not is_inject_marker(metadata[-1]):
-            return parameter
-
-        if is_inject_marker(parameter.default):
-            raise TypeError(
-                "Cannot specify `Inject` in `Annotated` and "
-                f"default value together for '{parameter.name}'"
-            )
-
-        if parameter.default is not inspect.Parameter.empty:
-            return parameter
-
-        marker = metadata[-1]
-        new_metadata = metadata[:-1]
-        if new_metadata:
-            if hasattr(Annotated, "__getitem__"):
-                new_annotation = Annotated.__getitem__((origin, *new_metadata))  # type: ignore
-            else:
-                new_annotation = Annotated.__class_getitem__((origin, *new_metadata))  # type: ignore
-        else:
-            new_annotation = origin
-        return parameter.replace(annotation=new_annotation, default=marker)
+        return self._injector.inject(func)(*args, **kwargs)
 
     def validate_injected_parameter(
         self, parameter: inspect.Parameter, *, call: Callable[..., Any]
     ) -> tuple[Any, bool]:
         """Validate an injected parameter."""
-        parameter = self._unwrap_injected_parameter(parameter)
-        interface = parameter.annotation
-
-        if not is_inject_marker(parameter.default):
-            return interface, False
-
-        if interface is inspect.Parameter.empty:
-            raise TypeError(
-                f"Missing `{type_repr(call)}` parameter `{parameter.name}` annotation."
-            )
-
-        # Set inject marker interface
-        parameter.default.interface = interface
-
-        if not self.has_provider_for(interface):
-            raise LookupError(
-                f"`{type_repr(call)}` has an unknown dependency parameter "
-                f"`{parameter.name}` with an annotation of "
-                f"`{type_repr(interface)}`."
-            )
-
-        return interface, True
+        return self._injector.validate_parameter(parameter, call=call)
 
     # == Module Registration ==
 
@@ -671,13 +579,62 @@ class Container:
     ) -> None:
         self._scanner.scan(packages=packages, tags=tags)
 
-    # == Testing ==
+    # == Testing / Override Support ==
 
     @contextlib.contextmanager
     def override(self, interface: Any, instance: Any) -> Iterator[None]:
-        raise RuntimeError(
-            "Dependency overriding is not supported in this container.\n"
-            "Wrap your container with `anydi.testing.Container` instead.\n"
-            "Example:\n\n"
-            "    container = TestContainer.from_container(container)"
+        """Override a dependency with a specific instance for testing."""
+        if not self.has_provider_for(interface):
+            raise LookupError(
+                f"The provider interface `{type_repr(interface)}` not registered."
+            )
+        self._resolver.add_override(interface, instance)
+        try:
+            yield
+        finally:
+            self._resolver.remove_override(interface)
+
+
+def import_container(container_path: str) -> Container:
+    """Import container from a string path."""
+    # Replace colon with dot for unified processing
+    container_path = container_path.replace(":", ".")
+
+    try:
+        module_path, attr_name = container_path.rsplit(".", 1)
+    except ValueError as exc:
+        raise ImportError(
+            f"Invalid container path '{container_path}'. "
+            "Expected format: 'module.path:attribute' or 'module.path.attribute'"
+        ) from exc
+
+    try:
+        module = importlib.import_module(module_path)
+    except ImportError as exc:
+        raise ImportError(
+            f"Failed to import module '{module_path}' "
+            f"from container path '{container_path}'"
+        ) from exc
+
+    try:
+        container_or_factory = getattr(module, attr_name)
+    except AttributeError as exc:
+        raise ImportError(
+            f"Module '{module_path}' has no attribute '{attr_name}'"
+        ) from exc
+
+    # If it's a callable (factory), call it
+    if callable(container_or_factory) and not isinstance(
+        container_or_factory, Container
+    ):
+        container = container_or_factory()
+    else:
+        container = container_or_factory
+
+    if not isinstance(container, Container):
+        raise ImportError(
+            f"Expected Container instance, got {type(container).__name__} "
+            f"from '{container_path}'"
         )
+
+    return container

anydi/_injector.py

@@ -0,0 +1,132 @@
+"""Dependency injection utilities."""
+
+from __future__ import annotations
+
+import functools
+import inspect
+from collections.abc import Callable
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    TypeVar,
+    cast,
+    get_args,
+    get_origin,
+)
+
+from typing_extensions import ParamSpec, type_repr
+
+from ._types import is_provide_marker
+
+if TYPE_CHECKING:
+    from ._container import Container
+
+T = TypeVar("T", bound=Any)
+P = ParamSpec("P")
+
+
+class Injector:
+    """Handles dependency injection for callables."""
+
+    def __init__(self, container: Container) -> None:
+        self.container = container
+        self._cache: dict[Callable[..., Any], Callable[..., Any]] = {}
+
+    def inject(self, call: Callable[P, T]) -> Callable[P, T]:
+        """Inject dependencies into a callable."""
+        if call in self._cache:
+            return cast(Callable[P, T], self._cache[call])
+
+        injected_params = self._get_injected_params(call)
+        if not injected_params:
+            self._cache[call] = call
+            return call
+
+        if inspect.iscoroutinefunction(call):
+
+            @functools.wraps(call)
+            async def awrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+                for name, annotation in injected_params.items():
+                    kwargs[name] = await self.container.aresolve(annotation)
+                return cast(T, await call(*args, **kwargs))
+
+            self._cache[call] = awrapper
+
+            return awrapper  # type: ignore
+
+        @functools.wraps(call)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            for name, annotation in injected_params.items():
+                kwargs[name] = self.container.resolve(annotation)
+            return call(*args, **kwargs)
+
+        self._cache[call] = wrapper
+
+        return wrapper
+
+    def _get_injected_params(self, call: Callable[..., Any]) -> dict[str, Any]:
+        """Get the injected parameters of a callable object."""
+        injected_params: dict[str, Any] = {}
+        for parameter in inspect.signature(call, eval_str=True).parameters.values():
+            interface, should_inject = self.validate_parameter(parameter, call=call)
+            if should_inject:
+                injected_params[parameter.name] = interface
+        return injected_params
+
+    def validate_parameter(
+        self, parameter: inspect.Parameter, *, call: Callable[..., Any]
+    ) -> tuple[Any, bool]:
+        """Validate an injected parameter."""
+        parameter = self.unwrap_parameter(parameter)
+        interface = parameter.annotation
+
+        if not is_provide_marker(parameter.default):
+            return interface, False
+
+        if interface is inspect.Parameter.empty:
+            raise TypeError(
+                f"Missing `{type_repr(call)}` parameter `{parameter.name}` annotation."
+            )
+
+        # Set inject marker interface
+        parameter.default.interface = interface
+
+        if not self.container.has_provider_for(interface):
+            raise LookupError(
+                f"`{type_repr(call)}` has an unknown dependency parameter "
+                f"`{parameter.name}` with an annotation of "
+                f"`{type_repr(interface)}`."
+            )
+
+        return interface, True
+
+    @staticmethod
+    def unwrap_parameter(parameter: inspect.Parameter) -> inspect.Parameter:
+        if get_origin(parameter.annotation) is not Annotated:
+            return parameter
+
+        origin, *metadata = get_args(parameter.annotation)
+
+        if not metadata or not is_provide_marker(metadata[-1]):
+            return parameter
+
+        if is_provide_marker(parameter.default):
+            raise TypeError(
+                "Cannot specify `Inject` in `Annotated` and "
+                f"default value together for '{parameter.name}'"
+            )
+
+        if parameter.default is not inspect.Parameter.empty:
+            return parameter
+
+        marker = metadata[-1]
+        new_metadata = metadata[:-1]
+        if new_metadata:
+            if hasattr(Annotated, "__getitem__"):
+                new_annotation = Annotated.__getitem__((origin, *new_metadata))  # type: ignore
+            else:
+                new_annotation = Annotated.__class_getitem__((origin, *new_metadata))  # type: ignore
+        else:
+            new_annotation = origin
+        return parameter.replace(annotation=new_annotation, default=marker)