anydi 0.69.0__tar.gz → 0.70.0__tar.gz

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

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

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

@@ -17,7 +17,7 @@ from typing import Any, Literal, TypeVar, get_args, get_origin, overload
 from typing_extensions import ParamSpec, Self, type_repr
 
 from ._context import InstanceContext
-from ._decorators import is_provided
+from ._decorators import get_alias_list, is_provided
 from ._graph import Graph
 from ._injector import Injector
 from ._marker import Marker
@@ -49,6 +49,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 +96,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."""
@@ -370,9 +376,30 @@ class Container:
             dependency_type, factory, scope, from_context, override, None
         )
 
+    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."""
@@ -570,9 +597,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 +625,10 @@ class Container:
                     False,
                     defaults,
                 )
+                # Register aliases if specified
+                if not self.ready:
+                    for alias_type in get_alias_list(dependency_type.__provided__):
+                        self.alias(alias_type, dependency_type)
                 registered = True
             else:
                 raise LookupError(
@@ -677,6 +709,9 @@ class Container:
                         False,
                         None,
                     )
+                    # Register aliases if specified
+                    for alias_type in get_alias_list(dependency_type.__provided__):
+                        self._aliases[alias_type] = dependency_type
                     # Recursively ensure the @provided class is resolved
                     dep_provider = self._ensure_provider_resolved(
                         dep_provider, resolving
@@ -977,6 +1012,11 @@ class Container:
                             False,
                             None,
                         )
+                        # Register aliases if specified
+                        for alias_type in get_alias_list(
+                            param_dependency_type.__provided__
+                        ):
+                            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.0}/anydi/_decorators.py

@@ -29,32 +29,30 @@ 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 get_alias_list(provided: ProvidedMetadata) -> list[Any]:
+    """Get alias list from __provided__ metadata, normalizing single to list."""
+    alias = provided.get("alias")
+    if alias is None:
+        return []
+    if isinstance(alias, list | tuple):
+        return list(alias)  # type: ignore
+    return [alias]
 
 
 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 +67,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 +95,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 +123,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 +131,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]

{anydi-0.69.0 → anydi-0.70.0}/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.0}/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.0}/anydi/_scanner.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass
 from types import ModuleType
 from typing import TYPE_CHECKING, Any
 
-from ._decorators import Provided, is_injectable, is_provided
+from ._decorators import Provided, get_alias_list, is_injectable, is_provided
 
 if TYPE_CHECKING:
     from ._container import Container
@@ -58,13 +58,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 get_alias_list(cls.__provided__):
+                self._container.alias(alias_type, cls)
 
         # Second: inject @injectable functions
         for dependency in injectable_dependencies:

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

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