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

anydi/_resolver.py

@@ -6,6 +6,7 @@ import contextlib
 from typing import TYPE_CHECKING, Any, NamedTuple
 
 import anyio.to_thread
+import wrapt  # type: ignore
 from typing_extensions import type_repr
 
 from ._provider import Provider
@@ -15,6 +16,18 @@ if TYPE_CHECKING:
     from ._container import Container
 
 
+class InstanceProxy(wrapt.ObjectProxy):  # type: ignore
+    """Proxy for dependency instances to enable override support."""
+
+    def __init__(self, wrapped: Any, *, interface: type[Any]) -> None:
+        super().__init__(wrapped)  # type: ignore
+        self._self_interface = interface
+
+    @property
+    def interface(self) -> type[Any]:
+        return self._self_interface
+
+
 class CompiledResolver(NamedTuple):
     resolve: Any
     create: Any
@@ -24,32 +37,46 @@ class Resolver:
     def __init__(self, container: Container) -> None:
         self._container = container
         self._unresolved_interfaces: set[Any] = set()
+        # Normal caches (fast path, no override checks)
         self._cache: dict[Any, CompiledResolver] = {}
         self._async_cache: dict[Any, CompiledResolver] = {}
+        # Override caches (with override support)
+        self._override_cache: dict[Any, CompiledResolver] = {}
+        self._async_override_cache: dict[Any, CompiledResolver] = {}
+        # Override instances storage
+        self._override_instances: dict[Any, Any] = {}
 
-        # Determine compilation flags based on whether methods are overridden
-        self._has_override_support = callable(
-            getattr(self._container, "_hook_override_for", None)
-        )
-        self._wrap_dependencies = callable(
-            getattr(self._container, "_hook_wrap_dependency", None)
-        )
-        self._wrap_instance = callable(
-            getattr(self._container, "_hook_post_resolve", None)
-        )
+    @property
+    def override_mode(self) -> bool:
+        """Check if override mode is enabled."""
+        return bool(self._override_instances)
+
+    def add_override(self, interface: Any, instance: Any) -> None:
+        """Add an override instance for an interface."""
+        self._override_instances[interface] = instance
+
+    def remove_override(self, interface: Any) -> None:
+        """Remove an override instance for an interface."""
+        self._override_instances.pop(interface, None)
 
     def add_unresolved(self, interface: Any) -> None:
         self._unresolved_interfaces.add(interface)
 
     def get_cached(self, interface: Any, *, is_async: bool) -> CompiledResolver | None:
         """Get cached resolver if it exists."""
-        cache = self._async_cache if is_async else self._cache
+        if self.override_mode:
+            cache = self._async_override_cache if is_async else self._override_cache
+        else:
+            cache = self._async_cache if is_async else self._cache
         return cache.get(interface)
 
     def compile(self, provider: Provider, *, is_async: bool) -> CompiledResolver:
         """Compile an optimized resolver function for the given provider."""
-        # Select the appropriate cache based on sync/async mode
-        cache = self._async_cache if is_async else self._cache
+        # Select the appropriate cache based on sync/async mode and override mode
+        if self.override_mode:
+            cache = self._async_override_cache if is_async else self._override_cache
+        else:
+            cache = self._async_cache if is_async else self._cache
 
         # Check if already compiled in cache
         if provider.interface in cache:
@@ -61,20 +88,58 @@ class Resolver:
                 self.compile(p.provider, is_async=is_async)
 
         # Compile the resolver and creator functions
-        compiled = self._compile_resolver(provider, is_async=is_async)
+        compiled = self._compile_resolver(
+            provider, is_async=is_async, with_override=self.override_mode
+        )
 
         # Store the compiled functions in the cache
         cache[provider.interface] = compiled
 
         return compiled
 
+    def _add_override_check(
+        self, lines: list[str], *, include_not_set: bool = False
+    ) -> None:
+        """Add override checking code to generated resolver."""
+        lines.append("    override_mode = resolver.override_mode")
+        lines.append("    if override_mode:")
+        if include_not_set:
+            lines.append("        NOT_SET_ = _NOT_SET")
+        lines.append("        override = resolver._get_override_for(_interface)")
+        lines.append("        if override is not NOT_SET_:")
+        lines.append("            return override")
+
+    def _add_create_call(
+        self,
+        lines: list[str],
+        *,
+        is_async: bool,
+        with_override: bool,
+        context: str,
+        store: bool,
+        defaults: str = "None",
+        indent: str = "    ",
+    ) -> None:
+        """Add _create_instance call to generated resolver."""
+        override_arg = "override_mode" if with_override else "False"
+        context_arg = context if context else "None"
+        store_arg = "True" if store else "False"
+
+        if is_async:
+            lines.append(
+                f"{indent}return await _create_instance("
+                f"container, {context_arg}, {store_arg}, {defaults}, {override_arg})"
+            )
+        else:
+            lines.append(
+                f"{indent}return _create_instance("
+                f"container, {context_arg}, {store_arg}, {defaults}, {override_arg})"
+            )
+
     def _compile_resolver(  # noqa: C901
-        self, provider: Provider, *, is_async: bool
+        self, provider: Provider, *, is_async: bool, with_override: bool = False
     ) -> CompiledResolver:
         """Compile optimized resolver functions for the given provider."""
-        has_override_support = self._has_override_support
-        wrap_dependencies = self._wrap_dependencies
-        wrap_instance = self._wrap_instance
         num_params = len(provider.parameters)
         param_resolvers: list[Any] = [None] * num_params
         param_annotations: list[Any] = [None] * num_params
@@ -84,7 +149,11 @@ class Resolver:
         param_shared_scopes: list[bool] = [False] * num_params
         unresolved_messages: list[str] = [""] * num_params
 
-        cache = self._async_cache if is_async else self._cache
+        cache = (
+            (self._async_override_cache if is_async else self._override_cache)
+            if with_override
+            else (self._async_cache if is_async else self._cache)
+        )
 
         for idx, p in enumerate(provider.parameters):
             param_annotations[idx] = p.annotation
@@ -100,13 +169,13 @@ class Resolver:
                     cache[p.provider.interface] = compiled
                 param_resolvers[idx] = compiled.resolve
 
-            msg = (
+            unresolved_message = (
                 f"You are attempting to get the parameter `{p.name}` with the "
                 f"annotation `{type_repr(p.annotation)}` as a dependency into "
                 f"`{type_repr(provider.call)}` which is not registered or set in the "
                 "scoped context."
             )
-            unresolved_messages[idx] = msg
+            unresolved_messages[idx] = unresolved_message
 
         scope = provider.scope
         is_generator = provider.is_generator
@@ -117,11 +186,13 @@ class Resolver:
         create_lines: list[str] = []
         if is_async:
             create_lines.append(
-                "async def _create_instance(container, context, store, defaults):"
+                "async def _create_instance("
+                "container, context, store, defaults, override_mode):"
             )
         else:
             create_lines.append(
-                "def _create_instance(container, context, store, defaults):"
+                "def _create_instance("
+                "container, context, store, defaults, override_mode):"
             )
 
         if no_params:
@@ -170,8 +241,10 @@ class Resolver:
                 create_lines.append(
                     f"                raise LookupError(_unresolved_messages[{idx}])"
                 )
-                create_lines.append(f"            resolver = _param_resolvers[{idx}]")
-                create_lines.append("            if resolver is None:")
+                create_lines.append(
+                    f"            _dep_resolver = _param_resolvers[{idx}]"
+                )
+                create_lines.append("            if _dep_resolver is None:")
                 create_lines.append("                try:")
                 if is_async:
                     create_lines.append(
@@ -230,21 +303,23 @@ class Resolver:
                 create_lines.append("            else:")
                 if is_async:
                     create_lines.append(
-                        f"                arg_{idx} = await resolver("
+                        f"                arg_{idx} = await _dep_resolver("
                         f"container, "
                         f"context if _param_shared_scopes[{idx}] else None)"
                     )
                 else:
                     create_lines.append(
-                        f"                arg_{idx} = resolver("
+                        f"                arg_{idx} = _dep_resolver("
                         f"container, "
                         f"context if _param_shared_scopes[{idx}] else None)"
                     )
                 create_lines.append("        else:")
                 create_lines.append(f"            arg_{idx} = cached")
-                if wrap_dependencies:
+                # Wrap dependencies if in override mode (only for override version)
+                if with_override:
+                    create_lines.append("    if override_mode:")
                     create_lines.append(
-                        f"    arg_{idx} = container._hook_wrap_dependency("
+                        f"        arg_{idx} = resolver._wrap_for_override("
                         f"_param_annotations[{idx}], arg_{idx})"
                     )
 
@@ -380,9 +455,11 @@ class Resolver:
         create_lines.append("    if context is not None and store:")
         create_lines.append("        context.set(_interface, inst)")
 
-        if wrap_instance:
+        # Wrap instance if in override mode (only for override version)
+        if with_override:
+            create_lines.append("    if override_mode:")
             create_lines.append(
-                "    inst = container._hook_post_resolve(_interface, inst)"
+                "        inst = resolver._post_resolve_override(_interface, inst)"
             )
         create_lines.append("    return inst")
 
@@ -393,7 +470,7 @@ class Resolver:
             resolver_lines.append("def _resolver(container, context=None):")
 
         # Only define NOT_SET_ if we actually need it
-        needs_not_set = has_override_support or scope in ("singleton", "request")
+        needs_not_set = scope in ("singleton", "request")
         if needs_not_set:
             resolver_lines.append("    NOT_SET_ = _NOT_SET")
 
@@ -406,22 +483,14 @@ class Resolver:
         else:
             resolver_lines.append("    context = None")
 
-        if has_override_support:
-            resolver_lines.append(
-                "    override = container._hook_override_for(_interface)"
-            )
-            resolver_lines.append("    if override is not NOT_SET_:")
-            resolver_lines.append("        return override")
-
         if scope == "singleton":
+            if with_override:
+                self._add_override_check(resolver_lines)
+
+            # Fast path: check cached instance
             resolver_lines.append("    inst = context.get(_interface)")
             resolver_lines.append("    if inst is not NOT_SET_:")
-            if wrap_instance:
-                resolver_lines.append(
-                    "        return container._hook_post_resolve(_provider, inst)"
-                )
-            else:
-                resolver_lines.append("        return inst")
+            resolver_lines.append("        return inst")
 
             if is_async:
                 resolver_lines.append("    async with context.alock():")
@@ -429,47 +498,43 @@ class Resolver:
                 resolver_lines.append("    with context.lock():")
             resolver_lines.append("        inst = context.get(_interface)")
             resolver_lines.append("        if inst is not NOT_SET_:")
-            if wrap_instance:
-                resolver_lines.append(
-                    "            return container._hook_post_resolve(_provider, inst)"
-                )
-            else:
-                resolver_lines.append("            return inst")
-            if is_async:
-                resolver_lines.append(
-                    "        return await "
-                    "_create_instance(container, context, True, None)"
-                )
-            else:
-                resolver_lines.append(
-                    "        return _create_instance(container, context, True, None)"
-                )
+            resolver_lines.append("            return inst")
+            self._add_create_call(
+                resolver_lines,
+                is_async=is_async,
+                with_override=with_override,
+                context="context",
+                store=True,
+                indent="        ",
+            )
         elif scope == "request":
+            if with_override:
+                self._add_override_check(resolver_lines)
+
+            # Fast path: check cached instance
             resolver_lines.append("    inst = context.get(_interface)")
             resolver_lines.append("    if inst is not NOT_SET_:")
-            if wrap_instance:
-                resolver_lines.append(
-                    "        return container._hook_post_resolve(_provider, inst)"
-                )
-            else:
-                resolver_lines.append("        return inst")
-            if is_async:
-                resolver_lines.append(
-                    "    return await _create_instance(container, context, True, None)"
-                )
-            else:
-                resolver_lines.append(
-                    "    return _create_instance(container, context, True, None)"
-                )
+            resolver_lines.append("        return inst")
+
+            self._add_create_call(
+                resolver_lines,
+                is_async=is_async,
+                with_override=with_override,
+                context="context",
+                store=True,
+            )
         else:
-            if is_async:
-                resolver_lines.append(
-                    "    return await _create_instance(container, None, False, None)"
-                )
-            else:
-                resolver_lines.append(
-                    "    return _create_instance(container, None, False, None)"
-                )
+            # Transient scope
+            if with_override:
+                self._add_override_check(resolver_lines, include_not_set=True)
+
+            self._add_create_call(
+                resolver_lines,
+                is_async=is_async,
+                with_override=with_override,
+                context="",
+                store=False,
+            )
 
         create_resolver_lines: list[str] = []
         if is_async:
@@ -481,9 +546,9 @@ class Resolver:
                 "def _resolver_create(container, defaults=None):"
             )
 
-        # Only define NOT_SET_ if needed for override support
-        if has_override_support:
-            create_resolver_lines.append("    NOT_SET_ = _NOT_SET")
+        if with_override:
+            # Cache override mode check
+            create_resolver_lines.append("    override_mode = resolver.override_mode")
 
         if scope == "singleton":
             create_resolver_lines.append("    context = container._singleton_context")
@@ -494,43 +559,20 @@ class Resolver:
         else:
             create_resolver_lines.append("    context = None")
 
-        if has_override_support:
-            create_resolver_lines.append(
-                "    override = container._hook_override_for(_interface)"
-            )
-            create_resolver_lines.append("    if override is not NOT_SET_:")
-            create_resolver_lines.append("        return override")
+        if with_override:
+            self._add_override_check(create_resolver_lines, include_not_set=True)
 
-        if scope == "singleton":
-            if is_async:
-                create_resolver_lines.append(
-                    "    return await "
-                    "_create_instance(container, context, False, defaults)"
-                )
-            else:
-                create_resolver_lines.append(
-                    "    return _create_instance(container, context, False, defaults)"
-                )
-        elif scope == "request":
-            if is_async:
-                create_resolver_lines.append(
-                    "    return await "
-                    "_create_instance(container, context, False, defaults)"
-                )
-            else:
-                create_resolver_lines.append(
-                    "    return _create_instance(container, context, False, defaults)"
-                )
-        else:
-            if is_async:
-                create_resolver_lines.append(
-                    "    return await "
-                    "_create_instance(container, None, False, defaults)"
-                )
-            else:
-                create_resolver_lines.append(
-                    "    return _create_instance(container, None, False, defaults)"
-                )
+        # Determine context for create call
+        context_arg = "context" if scope in ("singleton", "request") else ""
+
+        self._add_create_call(
+            create_resolver_lines,
+            is_async=is_async,
+            with_override=with_override,
+            context=context_arg,
+            store=False,
+            defaults="defaults",
+        )
 
         lines = create_lines + [""] + resolver_lines + [""] + create_resolver_lines
 
@@ -552,8 +594,13 @@ class Resolver:
             "_NOT_SET": NOT_SET,
             "_contextmanager": contextlib.contextmanager,
             "_is_cm": is_context_manager,
-            "_cache": self._async_cache if is_async else self._cache,
+            "_cache": (
+                (self._async_override_cache if is_async else self._override_cache)
+                if with_override
+                else (self._async_cache if is_async else self._cache)
+            ),
             "_compile": self._compile_resolver,
+            "resolver": self,
         }
 
         # Add async-specific namespace entries
@@ -569,3 +616,59 @@ class Resolver:
         creator = ns["_resolver_create"]
 
         return CompiledResolver(resolver, creator)
+
+    def _get_override_for(self, interface: Any) -> Any:
+        """Hook for checking if an interface has an override."""
+        return self._override_instances.get(interface, NOT_SET)
+
+    def _wrap_for_override(self, annotation: Any, value: Any) -> Any:
+        """Hook for wrapping dependencies to enable override patching."""
+        return InstanceProxy(value, interface=annotation)
+
+    def _post_resolve_override(self, interface: Any, instance: Any) -> Any:  # noqa: C901
+        """Hook for patching resolved instances to support override."""
+        if interface in self._override_instances:
+            return self._override_instances[interface]
+
+        if not hasattr(instance, "__dict__") or hasattr(
+            instance, "__resolver_getter__"
+        ):
+            return instance
+
+        wrapped = {
+            name: value.interface
+            for name, value in instance.__dict__.items()
+            if isinstance(value, InstanceProxy)
+        }
+
+        def __resolver_getter__(name: str) -> Any:
+            if name in wrapped:
+                _interface = wrapped[name]
+                # Resolve the dependency if it's wrapped
+                return self._container.resolve(_interface)
+            raise LookupError
+
+        # Attach the resolver getter to the instance
+        instance.__resolver_getter__ = __resolver_getter__
+
+        if not hasattr(instance.__class__, "__getattribute_patched__"):
+
+            def __getattribute__(_self: Any, name: str) -> Any:
+                # Skip the resolver getter
+                if name in {"__resolver_getter__", "__class__"}:
+                    return object.__getattribute__(_self, name)
+
+                if hasattr(_self, "__resolver_getter__"):
+                    try:
+                        return _self.__resolver_getter__(name)
+                    except LookupError:
+                        pass
+
+                # Fall back to default behavior
+                return object.__getattribute__(_self, name)
+
+            # Apply the patched resolver if wrapped attributes exist
+            instance.__class__.__getattribute__ = __getattribute__
+            instance.__class__.__getattribute_patched__ = True
+
+        return instance

anydi/_scanner.py

@@ -3,13 +3,12 @@ from __future__ import annotations
 import importlib
 import inspect
 import pkgutil
-from collections.abc import Callable, Iterable
+from collections.abc import Callable, Iterable, Iterator
 from dataclasses import dataclass
 from types import ModuleType
 from typing import TYPE_CHECKING, Any
 
-from ._decorators import is_injectable
-from ._types import is_inject_marker
+from ._decorators import Provided, is_injectable, is_provided
 
 if TYPE_CHECKING:
     from ._container import Container
@@ -38,45 +37,64 @@ class Scanner:
     ) -> 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:
+            packages = [packages]
+
+        tags_list = list(tags) if tags else []
+        provided_classes: list[type[Provided]] = []
+        injectable_dependencies: list[ScannedDependency] = []
+
+        # Single pass: collect both @provided classes and @injectable functions
+        for module in self._iter_modules(packages):
+            provided_classes.extend(self._scan_module_for_provided(module))
+            injectable_dependencies.extend(
+                self._scan_module_for_injectable(module, tags=tags_list)
+            )
+
+        # First: register @provided classes
+        for cls in provided_classes:
+            if not self._container.is_registered(cls):
+                scope = cls.__provided__["scope"]
+                self._container.register(cls, scope=scope)
+
+        # Second: inject @injectable functions
+        for dependency in injectable_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 []
+    def _iter_modules(self, packages: Iterable[Package]) -> Iterator[ModuleType]:
+        """Iterate over all modules in the given packages."""
+        for package in packages:
+            if isinstance(package, str):
+                package = importlib.import_module(package)
 
-        if isinstance(package, str):
-            package = importlib.import_module(package)
+            # Single module (not a package)
+            if not hasattr(package, "__path__"):
+                yield package
+                continue
 
-        if not hasattr(package, "__path__"):
-            return self._scan_module(package, tags=tags)
+            # Package - walk all submodules
+            for module_info in pkgutil.walk_packages(
+                package.__path__, prefix=package.__name__ + "."
+            ):
+                yield importlib.import_module(module_info.name)
 
-        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))
+    def _scan_module_for_provided(self, module: ModuleType) -> list[type[Provided]]:
+        """Scan a module for @provided classes."""
+        provided_classes: list[type[Provided]] = []
 
-        return dependencies
+        for _, member in inspect.getmembers(module, predicate=inspect.isclass):
+            if getattr(member, "__module__", None) != module.__name__:
+                continue
+
+            if is_provided(member):
+                provided_classes.append(member)
 
-    def _scan_module(
-        self, module: ModuleType, *, tags: Iterable[str]
+        return provided_classes
+
+    def _scan_module_for_injectable(
+        self, module: ModuleType, *, tags: list[str]
     ) -> list[ScannedDependency]:
-        """Scan a module for decorated members."""
+        """Scan a module for @injectable functions."""
         dependencies: list[ScannedDependency] = []
 
         for _, member in inspect.getmembers(module, predicate=callable):
@@ -89,22 +107,12 @@ class Scanner:
         return dependencies
 
     @staticmethod
-    def _should_include_member(
-        member: Callable[..., Any], *, tags: Iterable[str]
-    ) -> bool:
+    def _should_include_member(member: Callable[..., Any], *, tags: list[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 parameter in inspect.signature(member).parameters.values():
-                if is_inject_marker(parameter.default):
-                    return True
-
         return False