anydi 0.69.0__tar.gz → 0.70.1__tar.gz

{anydi-0.69.0 → anydi-0.70.1}/PKG-INFO

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

{anydi-0.69.0 → anydi-0.70.1}/anydi/_container.py

@@ -25,7 +25,15 @@ from ._module import ModuleDef, ModuleRegistrar
 from ._provider import Provider, ProviderDef, ProviderKind, ProviderParameter
 from ._resolver import Resolver
 from ._scanner import PackageOrIterable, Scanner
-from ._types import NOT_SET, Event, Scope, is_event_type, is_iterator_type, is_none_type
+from ._types import (
+    NOT_SET,
+    Event,
+    Scope,
+    is_event_type,
+    is_iterator_type,
+    is_none_type,
+    to_list,
+)
 
 T = TypeVar("T", bound=Any)
 P = ParamSpec("P")
@@ -49,6 +57,7 @@ class Container:
         }
 
         self._resources: dict[str, list[Any]] = defaultdict(list)
+        self._aliases: dict[Any, Any] = {}  # alias_type → canonical_type
         self._singleton_context = InstanceContext()
         self._scoped_context: dict[str, ContextVar[InstanceContext]] = {}
 
@@ -95,6 +104,11 @@ class Container:
         """Get the registered providers."""
         return self._providers
 
+    @property
+    def aliases(self) -> dict[Any, Any]:
+        """Get the registered aliases."""
+        return self._aliases
+
     @property
     def ready(self) -> bool:
         """Check if the container is ready."""
@@ -339,6 +353,7 @@ class Container:
         scope: Scope = "singleton",
         from_context: bool = False,
         override: bool = False,
+        alias: Any = NOT_SET,
         interface: Any = NOT_SET,
         call: Callable[..., Any] = NOT_SET,
     ) -> Provider:
@@ -366,13 +381,40 @@ class Container:
             dependency_type = interface
         if factory is NOT_SET:
             factory = call if call is not NOT_SET else dependency_type
-        return self._register_provider(
+        provider = self._register_provider(
             dependency_type, factory, scope, from_context, override, None
         )
 
+        # Register aliases if specified
+        for alias_type in to_list(alias):
+            self.alias(alias_type, provider.dependency_type)
+
+        return provider
+
+    def alias(self, alias_type: Any, canonical_type: Any, /) -> None:
+        """Register an alias for a dependency type."""
+        if self.ready:
+            raise RuntimeError(
+                "Cannot register aliases after build() has been called. "
+                "All aliases must be registered before building the container."
+            )
+        if alias_type == canonical_type:
+            raise ValueError("Alias type cannot be the same as canonical type.")
+        if alias_type in self._aliases:
+            raise ValueError(
+                f"Alias `{type_repr(alias_type)}` is already registered "
+                f"for `{type_repr(self._aliases[alias_type])}`."
+            )
+        self._aliases[alias_type] = canonical_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 is_registered(self, dependency_type: Any, /) -> bool:
         """Check if a provider is registered for the specified dependency type."""
-        return dependency_type in self._providers
+        canonical = self._resolve_alias(dependency_type)
+        return canonical in self._providers
 
     def has_provider_for(self, dependency_type: Any, /) -> bool:
         """Check if a provider exists for the specified dependency type."""
@@ -400,12 +442,19 @@ class Container:
         self._delete_provider(provider)
 
     def provider(
-        self, *, scope: Scope, override: bool = False
+        self, *, scope: Scope, override: bool = False, alias: Any = NOT_SET
     ) -> Callable[[Callable[P, T]], Callable[P, T]]:
         """Decorator to register a provider function with the specified scope."""
 
         def decorator(call: Callable[P, T]) -> Callable[P, T]:
-            self._register_provider(NOT_SET, call, scope, False, override, None)
+            provider = self._register_provider(
+                NOT_SET, call, scope, False, override, None
+            )
+
+            # Register aliases if specified
+            for alias_type in to_list(alias):
+                self.alias(alias_type, provider.dependency_type)
+
             return call
 
         return decorator
@@ -570,9 +619,10 @@ class Container:
         return provider
 
     def _get_provider(self, dependency_type: Any) -> Provider:
-        """Get provider by dependency type."""
+        """Get provider by dependency type, resolving aliases."""
+        canonical = self._resolve_alias(dependency_type)
         try:
-            return self._providers[dependency_type]
+            return self._providers[canonical]
         except KeyError:
             raise LookupError(
                 f"The provider for `{type_repr(dependency_type)}` has "
@@ -597,6 +647,11 @@ class Container:
                     False,
                     defaults,
                 )
+                # Register aliases if specified
+                if not self.ready:
+                    aliases = to_list(dependency_type.__provided__.get("alias"))
+                    for alias_type in aliases:
+                        self.alias(alias_type, dependency_type)
                 registered = True
             else:
                 raise LookupError(
@@ -677,6 +732,10 @@ class Container:
                         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
                     # Recursively ensure the @provided class is resolved
                     dep_provider = self._ensure_provider_resolved(
                         dep_provider, resolving
@@ -977,6 +1036,10 @@ class Container:
                             False,
                             None,
                         )
+                        # 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
                     elif param.has_default:
                         # Has default, can be missing
                         resolved_params.append(param)

{anydi-0.69.0 → anydi-0.70.1}/anydi/_decorators.py

@@ -29,32 +29,20 @@ ModuleT = TypeVar("ModuleT", bound="Module")
 class ProvidedMetadata(TypedDict):
     """Metadata for classes marked as provided by AnyDI."""
 
-    dependency_type: NotRequired[Any]
     scope: Scope
+    alias: NotRequired[Any]
     from_context: NotRequired[bool]
 
 
-@overload
-def provided(
-    dependency_type: Any, /, *, scope: Scope, from_context: bool = False
-) -> Callable[[ClassT], ClassT]: ...
-
-
-@overload
-def provided(
-    *, scope: Scope, from_context: bool = False
-) -> Callable[[ClassT], ClassT]: ...
-
-
 def provided(
-    dependency_type: Any = NOT_SET, /, *, scope: Scope, from_context: bool = False
+    *, 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:
         metadata: ProvidedMetadata = {"scope": scope}
-        if dependency_type is not NOT_SET:
-            metadata["dependency_type"] = dependency_type
+        if alias is not NOT_SET:
+            metadata["alias"] = alias
         if from_context:
             metadata["from_context"] = from_context
         cls.__provided__ = metadata  # type: ignore[attr-defined]
@@ -69,19 +57,19 @@ def singleton(cls: ClassT, /) -> ClassT: ...
 
 @overload
 def singleton(
-    cls: None = None, /, *, dependency_type: Any = NOT_SET
+    cls: None = None, /, *, alias: Any = NOT_SET
 ) -> Callable[[ClassT], ClassT]: ...
 
 
 def singleton(
-    cls: ClassT | None = None, /, *, dependency_type: Any = NOT_SET
+    cls: ClassT | None = None, /, *, alias: Any = NOT_SET
 ) -> Callable[[ClassT], ClassT] | ClassT:
     """Decorator for marking a class as a singleton dependency."""
 
     def decorator(c: ClassT) -> ClassT:
         metadata: ProvidedMetadata = {"scope": "singleton"}
-        if dependency_type is not NOT_SET:
-            metadata["dependency_type"] = dependency_type
+        if alias is not NOT_SET:
+            metadata["alias"] = alias
         c.__provided__ = metadata  # type: ignore[attr-defined]
         return c
 
@@ -97,19 +85,19 @@ def transient(cls: ClassT, /) -> ClassT: ...
 
 @overload
 def transient(
-    cls: None = None, /, *, dependency_type: Any = NOT_SET
+    cls: None = None, /, *, alias: Any = NOT_SET
 ) -> Callable[[ClassT], ClassT]: ...
 
 
 def transient(
-    cls: ClassT | None = None, /, *, dependency_type: Any = NOT_SET
+    cls: ClassT | None = None, /, *, alias: Any = NOT_SET
 ) -> Callable[[ClassT], ClassT] | ClassT:
     """Decorator for marking a class as a transient dependency."""
 
     def decorator(c: ClassT) -> ClassT:
         metadata: ProvidedMetadata = {"scope": "transient"}
-        if dependency_type is not NOT_SET:
-            metadata["dependency_type"] = dependency_type
+        if alias is not NOT_SET:
+            metadata["alias"] = alias
         c.__provided__ = metadata  # type: ignore[attr-defined]
         return c
 
@@ -125,7 +113,7 @@ def request(cls: ClassT, /, *, from_context: bool = False) -> ClassT: ...
 
 @overload
 def request(
-    cls: None = None, /, *, dependency_type: Any = NOT_SET, from_context: bool = False
+    cls: None = None, /, *, alias: Any = NOT_SET, from_context: bool = False
 ) -> Callable[[ClassT], ClassT]: ...
 
 
@@ -133,15 +121,15 @@ def request(
     cls: ClassT | None = None,
     /,
     *,
-    dependency_type: Any = NOT_SET,
+    alias: Any = NOT_SET,
     from_context: bool = False,
 ) -> Callable[[ClassT], ClassT] | ClassT:
     """Decorator for marking a class as a request-scoped dependency."""
 
     def decorator(c: ClassT) -> ClassT:
         metadata: ProvidedMetadata = {"scope": "request"}
-        if dependency_type is not NOT_SET:
-            metadata["dependency_type"] = dependency_type
+        if alias is not NOT_SET:
+            metadata["alias"] = alias
         if from_context:
             metadata["from_context"] = from_context
         c.__provided__ = metadata  # type: ignore[attr-defined]
@@ -164,10 +152,11 @@ def is_provided(cls: Any) -> TypeGuard[type[Provided]]:
 class ProviderMetadata(TypedDict):
     scope: Scope
     override: bool
+    alias: NotRequired[Any]
 
 
 def provider(
-    *, scope: Scope, override: bool = False
+    *, scope: Scope, override: bool = False, alias: Any = NOT_SET
 ) -> Callable[
     [Callable[Concatenate[ModuleT, P], T]], Callable[Concatenate[ModuleT, P], T]
 ]:
@@ -176,7 +165,10 @@ def provider(
     def decorator(
         target: Callable[Concatenate[ModuleT, P], T],
     ) -> Callable[Concatenate[ModuleT, P], T]:
-        target.__provider__ = ProviderMetadata(scope=scope, override=override)  # type: ignore
+        metadata: ProviderMetadata = {"scope": scope, "override": override}
+        if alias is not NOT_SET:
+            metadata["alias"] = alias
+        target.__provider__ = metadata  # type: ignore
         return target
 
     return decorator

{anydi-0.69.0 → anydi-0.70.1}/anydi/_graph.py

@@ -19,6 +19,14 @@ class Graph:
     def __init__(self, container: Container) -> None:
         self._container = container
 
+    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
+
     def draw(
         self,
         output_format: Literal["tree", "mermaid", "dot", "json"] = "tree",
@@ -127,14 +135,16 @@ class Graph:
                     }
                 )
 
-            providers.append(
-                {
-                    "type": self._get_name(provider, full_path),
-                    "scope": provider.scope,
-                    "from_context": provider.from_context,
-                    "dependencies": dependencies,
-                }
-            )
+            aliases = self._get_aliases_for(provider.dependency_type)
+            provider_data: dict[str, Any] = {
+                "type": self._get_name(provider, full_path),
+                "scope": provider.scope,
+                "from_context": provider.from_context,
+                "dependencies": dependencies,
+            }
+            if aliases:
+                provider_data["aliases"] = aliases
+            providers.append(provider_data)
 
         return json.dumps({"providers": providers}, indent=ident)
 
@@ -167,19 +177,20 @@ class Graph:
 
         return "\n".join(lines)
 
-    @classmethod
     def _format_tree_node(
-        cls, provider: Provider, full_path: bool, param_name: str | None = None
+        self, provider: Provider, full_path: bool, param_name: str | None = None
     ) -> str:
-        name = cls._get_name(provider, full_path)
+        name = self._get_name(provider, full_path)
         scope_label = Graph._get_scope_label(provider.scope, provider.from_context)
         context_marker = " [context]" if provider.from_context else ""
+        aliases = self._get_aliases_for(provider.dependency_type)
+        alias_marker = f" [alias: {', '.join(aliases)}]" if aliases else ""
         if param_name:
-            return f"{param_name}: {name} ({scope_label}){context_marker}"
-        return f"{name} ({scope_label}){context_marker}"
+            return f"{param_name}: {name} ({scope_label}){context_marker}{alias_marker}"
+        return f"{name} ({scope_label}){context_marker}{alias_marker}"
 
-    @staticmethod
     def _render_tree_children(
+        self,
         provider: Provider,
         prefix: str,
         visited: set[Any],
@@ -197,10 +208,10 @@ class Graph:
                 continue
             is_last = i == len(deps) - 1
             connector = "└── " if is_last else "├── "
-            node_text = Graph._format_tree_node(dep_provider, full_path, param.name)
+            node_text = self._format_tree_node(dep_provider, full_path, param.name)
             lines.append(f"{prefix}{connector}{node_text}")
             extension = "    " if is_last else "│   "
-            Graph._render_tree_children(
+            self._render_tree_children(
                 dep_provider, prefix + extension, visited, lines, full_path
             )
 

{anydi-0.69.0 → anydi-0.70.1}/anydi/_resolver.py

@@ -51,12 +51,24 @@ class Resolver:
         return bool(self._overrides) or getattr(self._container, "_test_mode", False)
 
     def add_override(self, dependency_type: Any, instance: Any) -> None:
-        """Add an override instance for a dependency type."""
+        """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
 
     def remove_override(self, dependency_type: Any) -> None:
-        """Remove an override instance for a dependency type."""
+        """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)
 
     def clear_caches(self) -> None:
         """Clear all cached resolvers."""
@@ -105,6 +117,11 @@ 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
+
         return compiled
 
     def _add_override_check(

{anydi-0.69.0 → anydi-0.70.1}/anydi/_scanner.py

@@ -9,6 +9,7 @@ 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
@@ -58,13 +59,15 @@ class Scanner:
 
         # First: register @provided classes
         for cls in provided_classes:
-            dependency_type = cls.__provided__.get("dependency_type", cls)
-            if not self._container.is_registered(dependency_type):
+            if not self._container.is_registered(cls):
                 scope = cls.__provided__["scope"]
                 from_context = cls.__provided__.get("from_context", False)
                 self._container.register(
-                    dependency_type, cls, scope=scope, from_context=from_context
+                    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:

{anydi-0.69.0 → anydi-0.70.1}/anydi/_types.py

@@ -43,3 +43,12 @@ def is_none_type(tp: Any) -> bool:
 def is_iterator_type(tp: Any) -> bool:
     """Check if the given object is an iterator type."""
     return tp in (Iterator, AsyncIterator)
+
+
+def to_list(value: Any) -> list[Any]:
+    """Convert a value to a list, handling None and sequences."""
+    if value is None or value is NOT_SET:
+        return []
+    if isinstance(value, list | tuple):
+        return list(value)  # type: ignore[arg-type]
+    return [value]

{anydi-0.69.0 → anydi-0.70.1}/pyproject.toml

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