anydi 0.67.2__py3-none-any.whl → 0.69.0__py3-none-any.whl

anydi/_scanner.py

@@ -33,18 +33,24 @@ class Scanner:
         self._container = container
 
     def scan(
-        self, /, packages: PackageOrIterable, *, tags: Iterable[str] | None = None
+        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):
+        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)
@@ -52,16 +58,47 @@ class Scanner:
 
         # First: register @provided classes
         for cls in provided_classes:
-            if not self._container.is_registered(cls):
+            dependency_type = cls.__provided__.get("dependency_type", cls)
+            if not self._container.is_registered(dependency_type):
                 scope = cls.__provided__["scope"]
-                self._container.register(cls, scope=scope)
+                from_context = cls.__provided__.get("from_context", False)
+                self._container.register(
+                    dependency_type, cls, scope=scope, from_context=from_context
+                )
 
         # Second: inject @injectable functions
         for dependency in injectable_dependencies:
             decorated = self._container.inject()(dependency.member)
             setattr(dependency.module, dependency.member.__name__, decorated)
 
-    def _iter_modules(self, packages: Iterable[Package]) -> Iterator[ModuleType]:
+    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):
@@ -69,14 +106,16 @@ class Scanner:
 
             # Single module (not a package)
             if not hasattr(package, "__path__"):
-                yield package
+                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__ + "."
             ):
-                yield importlib.import_module(module_info.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."""

anydi/ext/fastapi.py

@@ -35,7 +35,7 @@ class FastAPIMarker(params.Depends, Marker):
     async def _fastapi_dependency(
         self, container: Annotated[Container, Depends(get_container)]
     ) -> Any:
-        return await container.aresolve(self.interface)
+        return await container.aresolve(self.dependency_type)
 
 
 # Configure Inject() and Provide[T] to use FastAPI-specific marker at import time

anydi/ext/faststream.py

@@ -62,7 +62,7 @@ class FastStreamMarker(Dependant, Marker):
 
     async def _faststream_dependency(self, context: ContextRepo) -> Any:
         container = get_container_from_context(context)
-        return await container.aresolve(self.interface)
+        return await container.aresolve(self.dependency_type)
 
 
 # Configure Inject() and Provide[T] to use FastStream-specific marker

anydi/ext/pydantic_settings.py

@@ -26,14 +26,14 @@ def install(
         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
+                origin = field_info.return_type
             elif isinstance(field_info, FieldInfo):
-                interface = field_info.annotation
+                origin = field_info.annotation
             else:
                 continue
 
             container.register(
-                Annotated[interface, f"{prefix}{setting_name}"],
+                Annotated[origin, f"{prefix}{setting_name}"],
                 _get_setting_value(getattr(_settings, setting_name)),
                 scope="singleton",
             )