anydi 0.56.0__py3-none-any.whl → 0.58.0__py3-none-any.whl

anydi/_resolver.py

@@ -453,7 +453,7 @@ class Resolver:
                 create_lines.append("        context.enter(inst)")
 
         create_lines.append("    if context is not None and store:")
-        create_lines.append("        context.set(_interface, inst)")
+        create_lines.append("        context._instances[_interface] = inst")
 
         # Wrap instance if in override mode (only for override version)
         if with_override:
@@ -470,18 +470,28 @@ class Resolver:
             resolver_lines.append("def _resolver(container, context=None):")
 
         # Only define NOT_SET_ if we actually need it
-        needs_not_set = scope in ("singleton", "request")
+        needs_not_set = scope != "transient"
         if needs_not_set:
             resolver_lines.append("    NOT_SET_ = _NOT_SET")
 
         if scope == "singleton":
             resolver_lines.append("    if context is None:")
             resolver_lines.append("        context = container._singleton_context")
-        elif scope == "request":
-            resolver_lines.append("    if context is None:")
-            resolver_lines.append("        context = container._get_request_context()")
-        else:
+        elif scope == "transient":
             resolver_lines.append("    context = None")
+        else:
+            # Custom scopes (including "request")
+            # Inline context retrieval to avoid method call overhead
+            resolver_lines.append("    if context is None:")
+            resolver_lines.append("        try:")
+            resolver_lines.append("            context = _scoped_context_var.get()")
+            resolver_lines.append("        except LookupError:")
+            resolver_lines.append(
+                f"            raise LookupError("
+                f"'The {scope} context has not been started. "
+                f"Please ensure that the {scope} context is properly initialized "
+                f"before attempting to use it.')"
+            )
 
         if scope == "singleton":
             if with_override:
@@ -507,33 +517,36 @@ class Resolver:
                 store=True,
                 indent="        ",
             )
-        elif scope == "request":
+        elif scope == "transient":
+            # Transient scope
             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_:")
-            resolver_lines.append("        return inst")
+                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="context",
-                store=True,
+                context="",
+                store=False,
             )
         else:
-            # Transient scope
+            # Custom scopes (including "request")
             if with_override:
-                self._add_override_check(resolver_lines, include_not_set=True)
+                self._add_override_check(resolver_lines)
+
+            # Fast path: check cached instance (inline dict access for speed)
+            resolver_lines.append(
+                "    inst = context._instances.get(_interface, NOT_SET_)"
+            )
+            resolver_lines.append("    if inst is not NOT_SET_:")
+            resolver_lines.append("        return inst")
 
             self._add_create_call(
                 resolver_lines,
                 is_async=is_async,
                 with_override=with_override,
-                context="",
-                store=False,
+                context="context",
+                store=True,
             )
 
         create_resolver_lines: list[str] = []
@@ -552,18 +565,26 @@ class Resolver:
 
         if scope == "singleton":
             create_resolver_lines.append("    context = container._singleton_context")
-        elif scope == "request":
+        elif scope == "transient":
+            create_resolver_lines.append("    context = None")
+        else:
+            # Custom scopes (including "request")
+            # Inline context retrieval to avoid method call overhead
+            create_resolver_lines.append("    try:")
+            create_resolver_lines.append("        context = _scoped_context_var.get()")
+            create_resolver_lines.append("    except LookupError:")
             create_resolver_lines.append(
-                "    context = container._get_request_context()"
+                f"        raise LookupError("
+                f"'The {scope} context has not been started. "
+                f"Please ensure that the {scope} context is properly initialized "
+                f"before attempting to use it.')"
             )
-        else:
-            create_resolver_lines.append("    context = None")
 
         if with_override:
             self._add_override_check(create_resolver_lines, include_not_set=True)
 
         # Determine context for create call
-        context_arg = "context" if scope in ("singleton", "request") else ""
+        context_arg = "context" if scope != "transient" else ""
 
         self._add_create_call(
             create_resolver_lines,
@@ -603,6 +624,12 @@ class Resolver:
             "resolver": self,
         }
 
+        # For custom scopes, cache the ContextVar to avoid dictionary lookups
+        if scope not in ("singleton", "transient"):
+            ns["_scoped_context_var"] = self._container._get_scoped_context_var(  # type: ignore[reportPrivateUsage]
+                scope
+            )
+
         # Add async-specific namespace entries
         if is_async:
             ns["_asynccontextmanager"] = contextlib.asynccontextmanager

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

anydi/_types.py

@@ -3,19 +3,21 @@
 from __future__ import annotations
 
 import inspect
-from collections.abc import AsyncIterator, Iterator
+from collections.abc import AsyncIterator, Callable, Iterator
 from types import NoneType
-from typing import Any, Literal
+from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeVar
 
 from typing_extensions import Sentinel
 
-Scope = Literal["transient", "singleton", "request"]
+T = TypeVar("T")
+
+Scope = Literal["transient", "singleton", "request"] | str
 
 NOT_SET = Sentinel("NOT_SET")
 
 
-class InjectMarker:
-    """A marker object for declaring injectable dependencies."""
+class ProvideMarker:
+    """A marker object for declaring dependency."""
 
     __slots__ = ("_interface",)
 
@@ -32,13 +34,52 @@ class InjectMarker:
     def interface(self, interface: Any) -> None:
         self._interface = interface
 
+    def __class_getitem__(cls, item: Any) -> Any:
+        return Annotated[item, cls()]
+
+
+_provide_factory: Callable[[], Any] = ProvideMarker
+
+
+def set_provide_factory(factory: Callable[[], Any]) -> Callable[[], Any]:
+    """Set the global factory used by Inject() and Provide."""
+    global _provide_factory
+    previous = _provide_factory
+    _provide_factory = factory
+    return previous
+
+
+def is_provide_marker(obj: Any) -> bool:
+    return isinstance(obj, ProvideMarker)
+
 
-def is_inject_marker(obj: Any) -> bool:
-    return isinstance(obj, InjectMarker)
+class _ProvideMeta(type):
+    """Metaclass for Provide that delegates __class_getitem__ to the current factory."""
+
+    def __getitem__(cls, item: Any) -> Any:
+        # Use the current factory's __class_getitem__ if available
+        factory = _provide_factory
+        if hasattr(factory, "__class_getitem__"):
+            return factory.__class_getitem__(item)  # type: ignore[attr-defined]
+        # Fallback to creating Annotated with factory instance
+        return Annotated[item, factory()]
+
+
+if TYPE_CHECKING:
+    Provide = Annotated[T, ProvideMarker()]
+
+else:
+
+    class Provide(metaclass=_ProvideMeta):
+        pass
 
 
 def Inject() -> Any:
-    return InjectMarker()
+    return _provide_factory()
+
+
+# Alias from backward compatibility
+is_inject_marker = is_provide_marker
 
 
 class Event:

anydi/ext/fastapi.py

@@ -11,37 +11,12 @@ from fastapi.dependencies.models import Dependant
 from fastapi.routing import APIRoute
 from starlette.requests import Request
 
-from anydi._container import Container
-from anydi._types import InjectMarker
+from anydi import Container, Inject
+from anydi._types import ProvideMarker, set_provide_factory
 
 from .starlette.middleware import RequestScopedMiddleware
 
-__all__ = ["RequestScopedMiddleware", "install", "get_container", "Inject"]
-
-
-def install(app: FastAPI, container: Container) -> None:
-    """Install AnyDI into a FastAPI application.
-
-    This function installs the AnyDI container into a FastAPI application by attaching
-    it to the application state. It also patches the route dependencies to inject the
-    required dependencies using AnyDI.
-    """
-    app.state.container = container  # noqa
-
-    patched = []
-
-    for route in app.routes:
-        if not isinstance(route, APIRoute):
-            continue
-        for dependant in _iter_dependencies(route.dependant):
-            if dependant.cache_key in patched:
-                continue
-            patched.append(dependant.cache_key)
-            call, *params = dependant.cache_key
-            if not call:
-                continue  # pragma: no cover
-            for parameter in inspect.signature(call, eval_str=True).parameters.values():
-                container.validate_injected_parameter(parameter, call=call)
+__all__ = ["install", "get_container", "Inject", "RequestScopedMiddleware"]
 
 
 def get_container(request: Request) -> Container:
@@ -49,10 +24,10 @@ def get_container(request: Request) -> Container:
     return cast(Container, request.app.state.container)
 
 
-class _Inject(params.Depends, InjectMarker):
+class _ProvideMarker(params.Depends, ProvideMarker):
     def __init__(self) -> None:
         super().__init__(dependency=self._dependency, use_cache=True)
-        InjectMarker.__init__(self)
+        ProvideMarker.__init__(self)
 
     async def _dependency(
         self, container: Annotated[Container, Depends(get_container)]
@@ -60,13 +35,36 @@ class _Inject(params.Depends, InjectMarker):
         return await container.aresolve(self.interface)
 
 
-def Inject() -> Any:
-    return _Inject()
+# Configure Inject() and Provide[T] to use FastAPI-specific marker
+set_provide_factory(_ProvideMarker)
 
 
 def _iter_dependencies(dependant: Dependant) -> Iterator[Dependant]:
-    """Iterate over the dependencies of a dependant."""
     yield dependant
     if dependant.dependencies:
         for sub_dependant in dependant.dependencies:
             yield from _iter_dependencies(sub_dependant)
+
+
+def _validate_route_dependencies(
+    route: APIRoute, container: Container, patched: set[tuple[Any, ...]]
+) -> None:
+    for dependant in _iter_dependencies(route.dependant):
+        if dependant.cache_key in patched:
+            continue
+        patched.add(dependant.cache_key)
+        call, *_ = dependant.cache_key
+        if not call:
+            continue  # pragma: no cover
+        for parameter in inspect.signature(call, eval_str=True).parameters.values():
+            container.validate_injected_parameter(parameter, call=call)
+
+
+def install(app: FastAPI, container: Container) -> None:
+    """Install AnyDI into a FastAPI application."""
+    app.state.container = container  # noqa
+    patched: set[tuple[Any, ...]] = set()
+    for route in app.routes:
+        if not isinstance(route, APIRoute):
+            continue
+        _validate_route_dependencies(route, container, patched)

anydi/ext/faststream.py

@@ -10,49 +10,43 @@ from faststream import ContextRepo
 from faststream.broker.core.usecase import BrokerUsecase
 
 from anydi import Container
-from anydi._types import InjectMarker
+from anydi._types import Inject, ProvideMarker, set_provide_factory
 
-
-def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
-    """Install AnyDI into a FastStream broker.
-
-    This function installs the AnyDI container into a FastStream broker by attaching
-    it to the broker. It also patches the broker handlers to inject the required
-    dependencies using AnyDI.
-    """
-    broker._container = container  # type: ignore
-
-    for handler in _get_broken_handlers(broker):
-        call = handler._original_call  # noqa
-        for parameter in inspect.signature(call, eval_str=True).parameters.values():
-            container.validate_injected_parameter(parameter, call=call)
-
-
-def _get_broken_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
-    if (handlers := getattr(broker, "handlers", None)) is not None:
-        return [handler.calls[0][0] for handler in handlers.values()]
-    # faststream > 0.5.0
-    return [
-        subscriber.calls[0].handler
-        for subscriber in broker._subscribers.values()  # noqa
-    ]
+__all__ = ["install", "get_container", "Inject"]
 
 
 def get_container(broker: BrokerUsecase[Any, Any]) -> Container:
+    """Get the AnyDI container from a FastStream broker."""
     return cast(Container, getattr(broker, "_container"))  # noqa
 
 
-class _Inject(Depends, InjectMarker):
-    """Parameter dependency class for injecting dependencies using AnyDI."""
-
+class _ProvideMarker(Depends, ProvideMarker):
     def __init__(self) -> None:
         super().__init__(dependency=self._dependency, use_cache=True, cast=True)
-        InjectMarker.__init__(self)
+        ProvideMarker.__init__(self)
 
     async def _dependency(self, context: ContextRepo) -> Any:
         container = get_container(context.get("broker"))
         return await container.aresolve(self.interface)
 
 
-def Inject() -> Any:
-    return _Inject()
+# Configure Inject() and Provide[T] to use FastStream-specific marker
+set_provide_factory(_ProvideMarker)
+
+
+def _get_broker_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
+    if (handlers := getattr(broker, "handlers", None)) is not None:
+        return [handler.calls[0][0] for handler in handlers.values()]
+    return [
+        subscriber.calls[0].handler
+        for subscriber in broker._subscribers.values()  # noqa
+    ]
+
+
+def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
+    """Install AnyDI into a FastStream broker."""
+    broker._container = container  # type: ignore
+    for handler in _get_broker_handlers(broker):
+        call = handler._original_call  # noqa
+        for parameter in inspect.signature(call, eval_str=True).parameters.values():
+            container.validate_injected_parameter(parameter, call=call)

anydi/ext/pydantic_settings.py

@@ -22,7 +22,8 @@ def install(
         prefix += "."
 
     def _register_settings(_settings: BaseSettings) -> None:
-        all_fields = {**_settings.model_fields, **_settings.model_computed_fields}
+        settings_cls = type(_settings)
+        all_fields = {**settings_cls.model_fields, **settings_cls.model_computed_fields}
         for setting_name, field_info in all_fields.items():
             if isinstance(field_info, ComputedFieldInfo):
                 interface = field_info.return_type