anydi 0.71.0__tar.gz → 0.72.0__tar.gz

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

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

{anydi-0.71.0 → 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.71.0 → 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.71.0 → 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.71.0 → 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.71.0 → 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.71.0 → anydi-0.72.0}/pyproject.toml

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