anydi 0.70.2__tar.gz → 0.72.0__tar.gz

{anydi-0.70.2 → anydi-0.72.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.70.2
+Version: 0.72.0
 Summary: Dependency Injection library
 Keywords: dependency injection,dependencies,di,async,asyncio,application
 Author: Anton Ruhlov

{anydi-0.70.2 → anydi-0.72.0}/anydi/_container.py

@@ -58,6 +58,7 @@ class Container:
 
         self._resources: dict[str, list[Any]] = defaultdict(list)
         self._aliases: dict[Any, Any] = {}  # alias_type → canonical_type
+        self._aliases_by_canonical: dict[Any, set[Any]] = defaultdict(set)
         self._singleton_context = InstanceContext()
         self._scoped_context: dict[str, ContextVar[InstanceContext]] = {}
 
@@ -405,12 +406,22 @@ class Container:
                 f"Alias `{type_repr(alias_type)}` is already registered "
                 f"for `{type_repr(self._aliases[alias_type])}`."
             )
+        if canonical_type not in self._providers:
+            raise ValueError(
+                f"Cannot create alias: provider for `{type_repr(canonical_type)}` "
+                "is not registered. Register the provider first."
+            )
         self._aliases[alias_type] = canonical_type
+        self._aliases_by_canonical[canonical_type].add(alias_type)
 
     def _resolve_alias(self, dependency_type: Any) -> Any:
         """Resolve an alias to its canonical type."""
         return self._aliases.get(dependency_type, dependency_type)
 
+    def get_aliases_for(self, canonical_type: Any, /) -> set[Any]:
+        """Get all aliases that point to the given canonical type."""
+        return self._aliases_by_canonical.get(canonical_type, set())
+
     def is_registered(self, dependency_type: Any, /) -> bool:
         """Check if a provider is registered for the specified dependency type."""
         canonical = self._resolve_alias(dependency_type)
@@ -722,20 +733,23 @@ class Container:
                 # Check if it's a @provided class
                 if inspect.isclass(dependency_type) and is_provided(dependency_type):
                     provided_scope = dependency_type.__provided__["scope"]
+                    from_context = dependency_type.__provided__.get(
+                        "from_context", False
+                    )
 
                     # Auto-register @provided class
                     dep_provider = self._register_provider(
                         dependency_type,
                         dependency_type,
                         provided_scope,
-                        False,
+                        from_context,
                         False,
                         None,
                     )
                     # Register aliases if specified
                     aliases = to_list(dependency_type.__provided__.get("alias"))
                     for alias_type in aliases:
-                        self._aliases[alias_type] = dependency_type
+                        self.alias(alias_type, dependency_type)
                     # Recursively ensure the @provided class is resolved
                     dep_provider = self._ensure_provider_resolved(
                         dep_provider, resolving
@@ -833,6 +847,9 @@ class Container:
             del self._providers[provider.dependency_type]
         if provider.is_resource:
             self._resources[provider.scope].remove(provider.dependency_type)
+        # Remove aliases pointing to this provider
+        for alias in self._aliases_by_canonical.pop(provider.dependency_type, set()):
+            self._aliases.pop(alias, None)
 
     # == Instance Resolution ==
 
@@ -1039,7 +1056,7 @@ class Container:
                         # Register aliases if specified
                         provided_meta = param_dependency_type.__provided__
                         for alias_type in to_list(provided_meta.get("alias")):
-                            self._aliases[alias_type] = param_dependency_type
+                            self.alias(alias_type, param_dependency_type)
                     elif param.has_default:
                         # Has default, can be missing
                         resolved_params.append(param)

{anydi-0.70.2 → anydi-0.72.0}/anydi/_decorators.py

@@ -34,12 +34,22 @@ class ProvidedMetadata(TypedDict):
     from_context: NotRequired[bool]
 
 
+def _check_already_provided(cls: type) -> None:
+    """Check if class already has __provided__ defined directly on it."""
+    if "__provided__" in cls.__dict__:
+        raise TypeError(
+            f"Class `{cls.__name__}` already has `__provided__` defined. "
+            "Remove the duplicate scope decorator or manual `__provided__` attribute."
+        )
+
+
 def provided(
     *, scope: Scope, alias: Any = NOT_SET, from_context: bool = False
 ) -> Callable[[ClassT], ClassT]:
     """Decorator for marking a class as provided by AnyDI with a specific scope."""
 
     def decorator(cls: ClassT) -> ClassT:
+        _check_already_provided(cls)
         metadata: ProvidedMetadata = {"scope": scope}
         if alias is not NOT_SET:
             metadata["alias"] = alias
@@ -67,6 +77,7 @@ def singleton(
     """Decorator for marking a class as a singleton dependency."""
 
     def decorator(c: ClassT) -> ClassT:
+        _check_already_provided(c)
         metadata: ProvidedMetadata = {"scope": "singleton"}
         if alias is not NOT_SET:
             metadata["alias"] = alias
@@ -95,6 +106,7 @@ def transient(
     """Decorator for marking a class as a transient dependency."""
 
     def decorator(c: ClassT) -> ClassT:
+        _check_already_provided(c)
         metadata: ProvidedMetadata = {"scope": "transient"}
         if alias is not NOT_SET:
             metadata["alias"] = alias
@@ -127,6 +139,7 @@ def request(
     """Decorator for marking a class as a request-scoped dependency."""
 
     def decorator(c: ClassT) -> ClassT:
+        _check_already_provided(c)
         metadata: ProvidedMetadata = {"scope": "request"}
         if alias is not NOT_SET:
             metadata["alias"] = alias

{anydi-0.70.2 → anydi-0.72.0}/anydi/_graph.py

@@ -21,11 +21,10 @@ class Graph:
 
     def _get_aliases_for(self, dependency_type: Any) -> list[str]:
         """Get list of alias names that point to a dependency type."""
-        aliases: list[str] = []
-        for alias, canonical in self._container.aliases.items():
-            if canonical == dependency_type:
-                aliases.append(type_repr(alias).rsplit(".", 1)[-1])
-        return aliases
+        return [
+            type_repr(alias).rsplit(".", 1)[-1]
+            for alias in self._container.get_aliases_for(dependency_type)
+        ]
 
     def draw(
         self,

{anydi-0.70.2 → anydi-0.72.0}/anydi/_resolver.py

@@ -53,22 +53,20 @@ class Resolver:
     def add_override(self, dependency_type: Any, instance: Any) -> None:
         """Add an override for a type, its canonical type, and all aliases."""
         self._overrides[dependency_type] = instance
-        canonical = self._container.aliases.get(dependency_type)
-        if canonical is not None:
-            self._overrides[canonical] = instance
-        for alias, canon in self._container.aliases.items():
-            if canon == dependency_type:
-                self._overrides[alias] = instance
+        canonical_type = self._container.aliases.get(dependency_type)
+        if canonical_type is not None:
+            self._overrides[canonical_type] = instance
+        for alias in self._container.get_aliases_for(dependency_type):
+            self._overrides[alias] = instance
 
     def remove_override(self, dependency_type: Any) -> None:
         """Remove an override for a type, its canonical type, and all aliases."""
         self._overrides.pop(dependency_type, None)
-        canonical = self._container.aliases.get(dependency_type)
-        if canonical is not None:
-            self._overrides.pop(canonical, None)
-        for alias, canon in self._container.aliases.items():
-            if canon == dependency_type:
-                self._overrides.pop(alias, None)
+        canonical_type = self._container.aliases.get(dependency_type)
+        if canonical_type is not None:
+            self._overrides.pop(canonical_type, None)
+        for alias in self._container.get_aliases_for(dependency_type):
+            self._overrides.pop(alias, None)
 
     def clear_caches(self) -> None:
         """Clear all cached resolvers."""
@@ -103,7 +101,11 @@ class Resolver:
         for param in provider.parameters:
             if param.provider is not None:
                 # Look up the current provider to handle overrides
-                current_provider = self._container.providers.get(param.dependency_type)
+                # Resolve alias to canonical type if needed
+                canonical_type = self._container.aliases.get(
+                    param.dependency_type, param.dependency_type
+                )
+                current_provider = self._container.providers.get(canonical_type)
                 if current_provider is not None:
                     self.compile(current_provider, is_async=is_async)
                 else:
@@ -117,10 +119,9 @@ class Resolver:
         # Store the compiled functions in the cache
         cache[provider.dependency_type] = compiled
 
-        # Also store under all aliases that point to this type
-        for alias, canonical in self._container.aliases.items():
-            if canonical == provider.dependency_type:
-                cache[alias] = compiled
+        # Also store under aliases that point to this canonical type
+        for alias in self._container.get_aliases_for(provider.dependency_type):
+            cache[alias] = compiled
 
         return compiled
 
@@ -198,7 +199,11 @@ class Resolver:
 
             if param.provider is not None:
                 # Look up the current provider from the container to handle overrides
-                current_provider = self._container.providers.get(param.dependency_type)
+                # Resolve alias to canonical type if needed
+                canonical_type = self._container.aliases.get(
+                    param.dependency_type, param.dependency_type
+                )
+                current_provider = self._container.providers.get(canonical_type)
                 if current_provider is not None:
                     compiled = cache.get(current_provider.dependency_type)
                 else:

anydi-0.72.0/anydi/_scanner.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import pkgutil
+from collections.abc import Iterable, Iterator
+from dataclasses import dataclass
+from types import ModuleType
+from typing import TYPE_CHECKING, Any
+
+from ._decorators import Provided, is_injectable, is_provided
+from ._types import to_list
+
+if TYPE_CHECKING:
+    from ._container import Container
+
+Package = ModuleType | str
+PackageOrIterable = 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:
+    _scanning_packages: set[str] = set()
+
+    def __init__(self, container: Container) -> None:
+        self._container = container
+        self._importing_modules: set[str] = set()
+
+    def scan(
+        self,
+        /,
+        packages: PackageOrIterable,
+        *,
+        tags: Iterable[str] | None = None,
+        ignore: PackageOrIterable | None = None,
+    ) -> None:
+        """Scan packages or modules for decorated members and inject dependencies.
+
+        Supports relative package paths (like Python's relative imports):
+        - "." scans the caller's package
+        - ".submodule" scans a submodule of the caller's package
+        - ".." scans the parent package
+        - "..sibling" scans a sibling package
+        """
+        if isinstance(packages, (ModuleType, str)):
+            packages = [packages]
+
+        # Resolve relative package paths
+        caller_package = self._get_caller_package(packages, ignore)
+        packages = self._resolve_relative_packages(packages, caller_package)
+        ignore = self._resolve_relative_packages(ignore, caller_package)
+
+        pkg_names = {p if isinstance(p, str) else p.__name__ for p in packages}
+        overlap = pkg_names & Scanner._scanning_packages
+        if overlap:
+            raise RuntimeError(
+                f"Circular import detected: scan() called recursively!\n\n"
+                f"Already scanning packages: {', '.join(sorted(overlap))}\n\n"
+                "This happens when a scanned module triggers container creation "
+                "(e.g., via lazy proxy).\n\n"
+                "Solutions:\n"
+                "- Add the problematic module to scan() ignore list\n"
+                "- Move container imports inside functions (lazy import)\n"
+                "- Avoid lazy container initialization in scanned modules"
+            )
+
+        Scanner._scanning_packages.update(pkg_names)
+        try:
+            self._do_scan(packages, tags=tags, ignore=ignore)
+        finally:
+            Scanner._scanning_packages -= pkg_names
+
+    def _do_scan(  # noqa: C901
+        self,
+        packages: PackageOrIterable,
+        *,
+        tags: Iterable[str] | None = None,
+        ignore: PackageOrIterable | None = None,
+    ) -> None:
+        """Internal scan implementation."""
+        if isinstance(packages, (ModuleType, str)):
+            packages = [packages]
+
+        tags_set: set[str] = set(tags) if tags else set()
+        ignore_prefixes = self._normalize_ignore(ignore)
+        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, ignore_prefixes=ignore_prefixes):
+            module_name = module.__name__
+            for name, member in vars(module).items():
+                if name.startswith("_"):
+                    continue
+                if getattr(member, "__module__", None) != module_name:
+                    continue
+
+                if inspect.isclass(member) and is_provided(member):
+                    provided_classes.append(member)
+                elif callable(member) and is_injectable(member):
+                    member_tags = set(member.__injectable__["tags"] or ())
+                    if not tags_set or (tags_set & member_tags):
+                        injectable_dependencies.append(
+                            ScannedDependency(member=member, module=module)
+                        )
+
+        # First: register @provided classes
+        for cls in provided_classes:
+            if not self._container.is_registered(cls):
+                scope = cls.__provided__["scope"]
+                from_context = cls.__provided__.get("from_context", False)
+                self._container.register(
+                    cls, cls, scope=scope, from_context=from_context
+                )
+            # Create aliases if specified (alias → cls)
+            for alias_type in to_list(cls.__provided__.get("alias")):
+                self._container.alias(alias_type, cls)
+
+        # Second: inject @injectable functions
+        for dependency in injectable_dependencies:
+            decorated = self._container.inject()(dependency.member)
+            setattr(dependency.module, dependency.member.__name__, decorated)
+
+    def _has_relative_packages(self, *package_lists: PackageOrIterable | None) -> bool:
+        """Check if any package list contains relative paths."""
+        for packages in package_lists:
+            if packages is None:
+                continue
+            if isinstance(packages, str):
+                if packages.startswith("."):
+                    return True
+            elif isinstance(packages, ModuleType):
+                continue
+            else:
+                for p in packages:
+                    if isinstance(p, str) and p.startswith("."):
+                        return True
+        return False
+
+    def _get_caller_package(
+        self,
+        packages: Iterable[Package],
+        ignore: PackageOrIterable | None,
+    ) -> str | None:
+        """Get the package name of the module that called scan()."""
+        if not self._has_relative_packages(packages, ignore):
+            return None
+
+        frame = inspect.currentframe()
+        try:
+            while frame is not None:
+                frame = frame.f_back
+                if frame is None:
+                    break
+                module_name = frame.f_globals.get("__name__")
+                if module_name and not module_name.startswith("anydi"):
+                    # Return package portion (remove module name if present)
+                    if "." in module_name:
+                        return module_name.rsplit(".", 1)[0]
+                    return module_name
+        finally:
+            del frame
+
+        raise ValueError(
+            "Cannot use relative package paths: unable to determine caller package. "
+            "Use absolute package names instead."
+        )
+
+    def _resolve_relative_name(self, relative_name: str, base_package: str) -> str:
+        """Resolve a relative package name to absolute."""
+        num_dots = len(relative_name) - len(relative_name.lstrip("."))
+        remainder = relative_name[num_dots:]
+
+        package_parts = base_package.split(".")
+
+        # Navigate up for parent references (..)
+        if num_dots > 1:
+            levels_up = num_dots - 1
+            if levels_up >= len(package_parts):
+                raise ValueError(
+                    f"Cannot resolve '{relative_name}': "
+                    f"too many parent levels for base package '{base_package}'"
+                )
+            package_parts = package_parts[:-levels_up]
+
+        if remainder:
+            return ".".join(package_parts) + "." + remainder
+        return ".".join(package_parts)
+
+    def _resolve_relative_packages(
+        self,
+        packages: PackageOrIterable | None,
+        caller_package: str | None,
+    ) -> list[Package]:
+        """Resolve relative package names to absolute names."""
+        if packages is None:
+            return []
+
+        if isinstance(packages, (ModuleType, str)):
+            packages = [packages]
+
+        resolved: list[Package] = []
+        for package in packages:
+            if isinstance(package, ModuleType):
+                resolved.append(package)
+            elif not package.startswith("."):
+                resolved.append(package)
+            else:
+                if caller_package is None:
+                    raise ValueError(
+                        "Cannot use relative package paths: "
+                        "unable to determine caller package. "
+                        "Use absolute package names instead."
+                    )
+                resolved.append(self._resolve_relative_name(package, caller_package))
+
+        return resolved
+
+    def _normalize_ignore(self, ignore: PackageOrIterable | None) -> tuple[str, ...]:
+        """Normalize ignore parameter to a tuple of module name prefixes."""
+        if ignore is None:
+            return ()
+
+        if isinstance(ignore, (ModuleType, str)):
+            ignore = [ignore]
+
+        prefixes: list[str] = []
+        for item in ignore:
+            name = item.__name__ if isinstance(item, ModuleType) else item
+            prefixes.append(name)
+            prefixes.append(name + ".")  # For startswith check
+        return tuple(prefixes)
+
+    def _should_ignore_module(
+        self, module_name: str, ignore_prefixes: tuple[str, ...]
+    ) -> bool:
+        """Check if a module should be ignored based on ignore prefixes."""
+        return module_name.startswith(ignore_prefixes) if ignore_prefixes else False
+
+    def _iter_modules(
+        self, packages: Iterable[Package], *, ignore_prefixes: tuple[str, ...]
+    ) -> Iterator[ModuleType]:
+        """Iterate over all modules in the given packages."""
+        for package in packages:
+            if isinstance(package, str):
+                package = importlib.import_module(package)
+
+            # Single module (not a package)
+            if not hasattr(package, "__path__"):
+                if not self._should_ignore_module(package.__name__, ignore_prefixes):
+                    yield package
+                continue
+
+            # Package - walk all submodules
+            for module_info in pkgutil.walk_packages(
+                package.__path__, prefix=package.__name__ + "."
+            ):
+                if not self._should_ignore_module(module_info.name, ignore_prefixes):
+                    yield from self._import_module_with_tracking(module_info.name)
+
+    def _import_module_with_tracking(self, module_name: str) -> Iterator[ModuleType]:
+        """Import a module while tracking for circular imports."""
+        # Check if we're already importing this module (circular import)
+        if module_name in self._importing_modules:
+            import_chain = " -> ".join(sorted(self._importing_modules))
+            raise RuntimeError(
+                f"Circular import detected during container scanning!\n"
+                f"Module '{module_name}' is being imported while already "
+                f"in the import chain.\n"
+                f"Import chain: {import_chain} -> {module_name}\n\n"
+                f"This usually happens when:\n"
+                f"1. A scanned module imports the container at module level\n"
+                f"2. The container creation triggers scanning\n"
+                f"3. Scanning tries to import the module again\n\n"
+                f"Solutions:\n"
+                f"- Add '{module_name}' to the ignore list\n"
+                f"- Move container imports inside functions (lazy import)\n"
+                f"- Check for modules importing the container module"
+            )
+
+        # Track that we're importing this module
+        self._importing_modules.add(module_name)
+        try:
+            module = importlib.import_module(module_name)
+            yield module
+        finally:
+            # Always cleanup, even if import fails
+            self._importing_modules.discard(module_name)

{anydi-0.70.2 → anydi-0.72.0}/anydi/ext/typer.py

@@ -97,8 +97,10 @@ def _process_callback(callback: Callable[..., Any], container: Container) -> Any
         processed_parameter = container._injector.unwrap_parameter(parameter)
         if should_inject:
             injected_param_names.add(parameter.name)
+            # Resolve alias to canonical type if needed
+            canonical_type = container.aliases.get(dependency_type, dependency_type)
             try:
-                scopes.add(container.providers[dependency_type].scope)
+                scopes.add(container.providers[canonical_type].scope)
             except KeyError:
                 if inspect.isclass(dependency_type) and is_provided(dependency_type):
                     scopes.add(dependency_type.__provided__["scope"])

{anydi-0.70.2 → anydi-0.72.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anydi"
-version = "0.70.2"
+version = "0.72.0"
 description = "Dependency Injection library"
 authors = [{ name = "Anton Ruhlov", email = "antonruhlov@gmail.com" }]
 requires-python = ">=3.10.0, <3.15"

anydi-0.70.2/anydi/_scanner.py

@@ -1,160 +0,0 @@
-from __future__ import annotations
-
-import importlib
-import inspect
-import pkgutil
-from collections.abc import Callable, Iterable, Iterator
-from dataclasses import dataclass
-from types import ModuleType
-from typing import TYPE_CHECKING, Any
-
-from ._decorators import Provided, is_injectable, is_provided
-from ._types import to_list
-
-if TYPE_CHECKING:
-    from ._container import Container
-
-Package = ModuleType | str
-PackageOrIterable = 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,
-        ignore: PackageOrIterable | None = None,
-    ) -> None:
-        """Scan packages or modules for decorated members and inject dependencies."""
-        if isinstance(packages, (ModuleType, str)):
-            packages = [packages]
-
-        tags_list = list(tags) if tags else []
-        ignore_prefixes = self._normalize_ignore(ignore)
-        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, ignore_prefixes=ignore_prefixes):
-            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"]
-                from_context = cls.__provided__.get("from_context", False)
-                self._container.register(
-                    cls, cls, scope=scope, from_context=from_context
-                )
-            # Create aliases if specified (alias → cls)
-            for alias_type in to_list(cls.__provided__.get("alias")):
-                self._container.alias(alias_type, cls)
-
-        # Second: inject @injectable functions
-        for dependency in injectable_dependencies:
-            decorated = self._container.inject()(dependency.member)
-            setattr(dependency.module, dependency.member.__name__, decorated)
-
-    def _normalize_ignore(self, ignore: PackageOrIterable | None) -> list[str]:
-        """Normalize ignore parameter to a list of module name prefixes."""
-        if ignore is None:
-            return []
-
-        if isinstance(ignore, (ModuleType, str)):
-            ignore = [ignore]
-
-        prefixes: list[str] = []
-        for item in ignore:
-            if isinstance(item, ModuleType):
-                prefixes.append(item.__name__)
-            else:
-                prefixes.append(item)
-        return prefixes
-
-    def _should_ignore_module(
-        self, module_name: str, ignore_prefixes: list[str]
-    ) -> bool:
-        """Check if a module should be ignored based on ignore prefixes."""
-        for prefix in ignore_prefixes:
-            if module_name == prefix or module_name.startswith(prefix + "."):
-                return True
-        return False
-
-    def _iter_modules(
-        self, packages: Iterable[Package], *, ignore_prefixes: list[str]
-    ) -> Iterator[ModuleType]:
-        """Iterate over all modules in the given packages."""
-        for package in packages:
-            if isinstance(package, str):
-                package = importlib.import_module(package)
-
-            # Single module (not a package)
-            if not hasattr(package, "__path__"):
-                if not self._should_ignore_module(package.__name__, ignore_prefixes):
-                    yield package
-                continue
-
-            # Package - walk all submodules
-            for module_info in pkgutil.walk_packages(
-                package.__path__, prefix=package.__name__ + "."
-            ):
-                if not self._should_ignore_module(module_info.name, ignore_prefixes):
-                    yield importlib.import_module(module_info.name)
-
-    def _scan_module_for_provided(self, module: ModuleType) -> list[type[Provided]]:
-        """Scan a module for @provided classes."""
-        provided_classes: list[type[Provided]] = []
-
-        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)
-
-        return provided_classes
-
-    def _scan_module_for_injectable(
-        self, module: ModuleType, *, tags: list[str]
-    ) -> list[ScannedDependency]:
-        """Scan a module for @injectable functions."""
-        dependencies: list[ScannedDependency] = []
-
-        for _, member in inspect.getmembers(module, predicate=callable):
-            if getattr(member, "__module__", None) != module.__name__:
-                continue
-
-            if self._should_include_member(member, tags=tags):
-                dependencies.append(ScannedDependency(member=member, module=module))
-
-        return dependencies
-
-    @staticmethod
-    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
-
-        return False