anydi 0.42.0__tar.gz → 0.44.0__tar.gz

{anydi-0.42.0 → anydi-0.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.42.0
+Version: 0.44.0
 Summary: Dependency Injection library
 Project-URL: Repository, https://github.com/antonrh/anydi
 Author-email: Anton Ruhlov <antonruhlov@gmail.com>

{anydi-0.42.0 → anydi-0.44.0}/anydi/_container.py

@@ -11,18 +11,15 @@ import uuid
 from collections import defaultdict
 from collections.abc import AsyncIterator, Iterable, Iterator
 from contextvars import ContextVar
-from typing import Annotated, Any, Callable, TypeVar, cast, overload
+from typing import Any, Callable, TypeVar, cast, overload
 
 from typing_extensions import ParamSpec, Self, get_args, get_origin
 
 from ._async import run_sync
 from ._context import InstanceContext
+from ._decorators import is_provided
 from ._module import ModuleDef, ModuleRegistrar
-from ._provider import (
-    Provider,
-    ProviderDef,
-    ProviderKind,
-)
+from ._provider import Provider, ProviderDef, ProviderKind
 from ._scan import PackageOrIterable, Scanner
 from ._scope import ALLOWED_SCOPES, Scope
 from ._typing import (
@@ -52,12 +49,10 @@ class Container:
         *,
         providers: Iterable[ProviderDef] | None = None,
         modules: Iterable[ModuleDef] | None = None,
-        strict: bool = False,
         default_scope: Scope = "transient",
         logger: logging.Logger | None = None,
     ) -> None:
         self._providers: dict[Any, Provider] = {}
-        self._strict = strict
         self._default_scope: Scope = default_scope
         self._logger = logger or logging.getLogger(__name__)
         self._resources: dict[str, list[Any]] = defaultdict(list)
@@ -90,11 +85,6 @@ class Container:
     # Properties
     ############################
 
-    @property
-    def strict(self) -> bool:
-        """Check if strict mode is enabled."""
-        return self._strict
-
     @property
     def default_scope(self) -> Scope:
         """Get the default scope."""
@@ -230,6 +220,10 @@ class Container:
         """Check if a provider is registered for the specified interface."""
         return interface in self._providers
 
+    def has_provider_for(self, interface: Any) -> bool:
+        """Check if a provider exists for the specified interface."""
+        return self.is_registered(interface) or is_provided(interface)
+
     def unregister(self, interface: Any) -> None:
         """Unregister a provider by interface."""
         if not self.is_registered(interface):
@@ -439,19 +433,15 @@ class Container:
         try:
             return self._get_provider(interface)
         except LookupError:
-            if self.strict or interface is inspect.Parameter.empty:
+            if interface is inspect.Parameter.empty:
                 raise
-            if get_origin(interface) is Annotated and (args := get_args(interface)):
-                call = args[0]
-            else:
-                call = interface
-            if inspect.isclass(call) and not is_builtin_type(call):
+            if inspect.isclass(interface) and not is_builtin_type(interface):
                 # Try to get defined scope
-                if hasattr(call, "__scope__"):
-                    scope = getattr(call, "__scope__")
+                if is_provided(interface):
+                    scope = interface.__provided__["scope"]
                 else:
                     scope = parent_scope
-                return self._register_provider(call, scope, interface, **defaults)
+                return self._register_provider(interface, scope, interface, **defaults)
             raise
 
     def _set_provider(self, provider: Provider) -> None:
@@ -467,14 +457,13 @@ class Container:
         if provider.is_resource:
             self._resources[provider.scope].remove(provider.interface)
 
+    @staticmethod
     def _parameter_has_default(
-        self, parameter: inspect.Parameter, /, **defaults: Any
+        parameter: inspect.Parameter, /, **defaults: Any
     ) -> bool:
         has_default_in_kwargs = parameter.name in defaults if defaults else False
-        has_non_strict_default = not self.strict and (
-            parameter.default is not inspect.Parameter.empty
-        )
-        return has_default_in_kwargs or has_non_strict_default
+        has_default = parameter.default is not inspect.Parameter.empty
+        return has_default_in_kwargs or has_default
 
     ############################
     # Instance Methods
@@ -793,8 +782,8 @@ class Container:
             return cast(Callable[P, T], self._inject_cache[call])
 
         injected_params = self._get_injected_params(call)
-
         if not injected_params:
+            self._inject_cache[call] = call
             return call
 
         if inspect.iscoroutinefunction(call):
@@ -825,18 +814,7 @@ class Container:
         for parameter in get_typed_parameters(call):
             if not is_marker(parameter.default):
                 continue
-            try:
-                self._validate_injected_parameter(call, parameter)
-            except LookupError as exc:
-                if not self.strict:
-                    self.logger.debug(
-                        f"Cannot validate the `{type_repr(call)}` parameter "
-                        f"`{parameter.name}` with an annotation of "
-                        f"`{type_repr(parameter.annotation)} due to being "
-                        "in non-strict mode. It will be validated at the first call."
-                    )
-                else:
-                    raise exc
+            self._validate_injected_parameter(call, parameter)
             injected_params[parameter.name] = parameter.annotation
         return injected_params
 
@@ -849,7 +827,7 @@ class Container:
                 f"Missing `{type_repr(call)}` parameter `{parameter.name}` annotation."
             )
 
-        if not self.is_registered(parameter.annotation):
+        if not self.has_provider_for(parameter.annotation):
             raise LookupError(
                 f"`{type_repr(call)}` has an unknown dependency parameter "
                 f"`{parameter.name}` with an annotation of "

{anydi-0.42.0 → anydi-0.44.0}/anydi/_decorators.py

@@ -1,22 +1,41 @@
 from collections.abc import Iterable
-from typing import Callable, Concatenate, ParamSpec, TypedDict, TypeVar, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Concatenate,
+    ParamSpec,
+    Protocol,
+    TypedDict,
+    TypeGuard,
+    TypeVar,
+    overload,
+)
+
+if TYPE_CHECKING:
+    from ._module import Module
+
 
-from ._module import Module
 from ._scope import Scope
 
 T = TypeVar("T")
 P = ParamSpec("P")
 
 ClassT = TypeVar("ClassT", bound=type)
-ModuleT = TypeVar("ModuleT", bound=Module)
+ModuleT = TypeVar("ModuleT", bound="Module")
+
+
+class ProvidedMetadata(TypedDict):
+    """Metadata for classes marked as provided by AnyDI."""
+
+    scope: Scope
 
 
 def provided(*, scope: Scope) -> Callable[[ClassT], ClassT]:
     """Decorator for marking a class as provided by AnyDI with a specific scope."""
 
     def decorator(cls: ClassT) -> ClassT:
-        cls.__provided__ = True
-        cls.__scope__ = scope
+        cls.__provided__ = ProvidedMetadata(scope=scope)
         return cls
 
     return decorator
@@ -28,6 +47,14 @@ request = provided(scope="request")
 singleton = provided(scope="singleton")
 
 
+class Provided(Protocol):
+    __provided__: ProvidedMetadata
+
+
+def is_provided(cls: Any) -> TypeGuard[type[Provided]]:
+    return hasattr(cls, "__provided__")
+
+
 class ProviderMetadata(TypedDict):
     scope: Scope
     override: bool
@@ -49,8 +76,15 @@ def provider(
     return decorator
 
 
+class Provider(Protocol):
+    __provider__: ProviderMetadata
+
+
+def is_provider(obj: Callable[..., Any]) -> TypeGuard[Provider]:
+    return hasattr(obj, "__provider__")
+
+
 class InjectableMetadata(TypedDict):
-    wrapped: bool
     tags: Iterable[str] | None
 
 
@@ -71,10 +105,18 @@ def injectable(
     """Decorator for marking a function or method as requiring dependency injection."""
 
     def decorator(inner: Callable[P, T]) -> Callable[P, T]:
-        inner.__injectable__ = InjectableMetadata(wrapped=True, tags=tags)  # type: ignore
+        inner.__injectable__ = InjectableMetadata(tags=tags)  # type: ignore
         return inner
 
     if func is None:
         return decorator
 
     return decorator(func)
+
+
+class Injectable(Protocol):
+    __injectable__: InjectableMetadata
+
+
+def is_injectable(obj: Callable[..., Any]) -> TypeGuard[Injectable]:
+    return hasattr(obj, "__injectable__")

{anydi-0.42.0 → anydi-0.44.0}/anydi/_module.py

@@ -4,9 +4,10 @@ import importlib
 import inspect
 from typing import TYPE_CHECKING, Any, Callable
 
+from ._decorators import ProviderMetadata, is_provider
+
 if TYPE_CHECKING:
     from ._container import Container
-    from ._decorators import ProviderMetadata
 
 
 class ModuleMeta(type):
@@ -14,9 +15,9 @@ class ModuleMeta(type):
 
     def __new__(cls, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> Any:
         attrs["providers"] = [
-            (name, getattr(value, "__provider__"))
+            (name, value.__provider__)
             for name, value in attrs.items()
-            if hasattr(value, "__provider__")
+            if is_provider(value)
         ]
         return super().__new__(cls, name, bases, attrs)
 

{anydi-0.42.0 → anydi-0.44.0}/anydi/_scan.py

@@ -6,9 +6,9 @@ import pkgutil
 from collections.abc import Iterable
 from dataclasses import dataclass
 from types import ModuleType
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any, Callable, Union
 
-from ._decorators import InjectableMetadata
+from ._decorators import is_injectable
 from ._typing import get_typed_parameters, is_marker
 
 if TYPE_CHECKING:
@@ -73,9 +73,8 @@ class Scanner:
 
         return dependencies
 
-    @staticmethod
     def _scan_module(
-        module: ModuleType, *, tags: Iterable[str]
+        self, module: ModuleType, *, tags: Iterable[str]
     ) -> list[ScannedDependency]:
         """Scan a module for decorated members."""
         dependencies: list[ScannedDependency] = []
@@ -84,27 +83,28 @@ class Scanner:
             if getattr(member, "__module__", None) != module.__name__:
                 continue
 
-            metadata: InjectableMetadata = getattr(
-                member,
-                "__injectable__",
-                InjectableMetadata(wrapped=False, tags=[]),
-            )
-
-            should_include = False
-            if metadata["wrapped"]:
-                should_include = True
-            elif tags and metadata["tags"]:
-                should_include = bool(set(metadata["tags"]) & set(tags))
-            elif tags and not metadata["tags"]:
-                continue  # tags are provided but member has none
-
-            if not should_include:
-                for param in get_typed_parameters(member):
-                    if is_marker(param.default):
-                        should_include = True
-                        break
-
-            if should_include:
+            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: Iterable[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
+
+        # If no tags are passed and not explicitly injectable,
+        # check for parameter markers
+        if not tags:
+            for param in get_typed_parameters(member):
+                if is_marker(param.default):
+                    return True
+
+        return False

{anydi-0.42.0 → anydi-0.44.0}/anydi/ext/_utils.py

@@ -9,7 +9,6 @@ from typing import Annotated, Any, Callable
 from typing_extensions import get_args, get_origin
 
 from anydi._container import Container
-from anydi._typing import type_repr
 
 logger = logging.getLogger(__name__)
 
@@ -69,15 +68,6 @@ def patch_call_parameter(
     if not isinstance(parameter.default, HasInterface):
         return None
 
-    if not container.strict and not container.is_registered(parameter.annotation):
-        logger.debug(
-            f"Callable `{type_repr(call)}` injected parameter "
-            f"`{parameter.name}` with an annotation of "
-            f"`{type_repr(parameter.annotation)}` "
-            "is not registered. It will be registered at runtime with the "
-            "first call because it is running in non-strict mode."
-        )
-    else:
-        container._validate_injected_parameter(call, parameter)  # noqa
+    container._validate_injected_parameter(call, parameter)  # noqa
 
     parameter.default.interface = parameter.annotation

{anydi-0.42.0 → anydi-0.44.0}/anydi/ext/django/_settings.py

@@ -8,7 +8,6 @@ from typing_extensions import TypedDict
 
 class Settings(TypedDict):
     CONTAINER_FACTORY: str | None
-    STRICT_MODE: bool
     REGISTER_SETTINGS: bool
     REGISTER_COMPONENTS: bool
     INJECT_URLCONF: str | Sequence[str] | None
@@ -19,7 +18,6 @@ class Settings(TypedDict):
 
 DEFAULTS = Settings(
     CONTAINER_FACTORY=None,
-    STRICT_MODE=False,
     REGISTER_SETTINGS=False,
     REGISTER_COMPONENTS=False,
     MODULES=[],

{anydi-0.42.0 → anydi-0.44.0}/anydi/ext/django/_utils.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from functools import wraps
 from typing import Annotated, Any
 
 from django.conf import settings
@@ -9,7 +8,6 @@ from django.core.cache import BaseCache, caches
 from django.db import connections
 from django.db.backends.base.base import BaseDatabaseWrapper
 from django.urls import URLPattern, URLResolver, get_resolver
-from typing_extensions import get_origin
 
 from anydi import Container
 
@@ -29,14 +27,11 @@ def register_settings(
             continue
 
         container.register(
-            Annotated[Any, f"{prefix}{setting_name}"],
+            Annotated[type(setting_value), f"{prefix}{setting_name}"],
             _get_setting_value(setting_value),
             scope="singleton",
         )
 
-    # Patch AnyDI to resolve Any types for annotated settings
-    _patch_any_typed_annotated(container, prefix=prefix)
-
 
 def register_components(container: Container) -> None:
     """Register Django components into the container."""
@@ -91,38 +86,3 @@ def iter_urlpatterns(
 
 def _get_setting_value(value: Any) -> Any:
     return lambda: value
-
-
-def _any_typed_interface(interface: Any, prefix: str) -> Any:
-    origin = get_origin(interface)
-    if origin is not Annotated:
-        return interface  # pragma: no cover
-    named = interface.__metadata__[-1]
-
-    if isinstance(named, str) and named.startswith(prefix):
-        _, setting_name = named.rsplit(prefix, maxsplit=1)
-        return Annotated[Any, f"{prefix}{setting_name}"]
-    return interface
-
-
-def _patch_any_typed_annotated(container: Container, *, prefix: str) -> None:
-    def _patch_resolve(resolve: Any) -> Any:
-        @wraps(resolve)
-        def wrapper(interface: Any) -> Any:
-            return resolve(_any_typed_interface(interface, prefix))
-
-        return wrapper
-
-    def _patch_aresolve(resolve: Any) -> Any:
-        @wraps(resolve)
-        async def wrapper(interface: Any) -> Any:
-            return await resolve(_any_typed_interface(interface, prefix))
-
-        return wrapper
-
-    container.resolve = _patch_resolve(  # type: ignore
-        container.resolve
-    )
-    container.aresolve = _patch_aresolve(  # type: ignore
-        container.aresolve
-    )

{anydi-0.42.0 → anydi-0.44.0}/anydi/ext/django/apps.py

@@ -34,9 +34,7 @@ class ContainerConfig(AppConfig):
                 ) from exc
             self.container = container_factory()
         else:
-            self.container = anydi.Container(
-                strict=self.settings["STRICT_MODE"],
-            )
+            self.container = anydi.Container()
 
     def ready(self) -> None:  # noqa: C901
         # Register Django settings

{anydi-0.42.0 → anydi-0.44.0}/anydi/ext/pytest_plugin.py

@@ -88,8 +88,8 @@ def _anydi_inject(
     container = cast(Container, request.getfixturevalue("anydi_setup_container"))
 
     for argname, interface in _anydi_injected_parameter_iterator():
-        # Skip if the interface is not registered
-        if container.strict and not container.is_registered(interface):
+        # Skip if the interface has no provider
+        if not container.has_provider_for(interface):
             continue
 
         try:
@@ -128,8 +128,8 @@ def _anydi_ainject(
         container = cast(Container, request.getfixturevalue("anydi_setup_container"))
 
         for argname, interface in _anydi_injected_parameter_iterator():
-            # Skip if the interface is not registered
-            if container.strict and not container.is_registered(interface):
+            # Skip if the interface has no provider
+            if not container.has_provider_for(interface):
                 continue
 
             try:

{anydi-0.42.0 → anydi-0.44.0}/anydi/testing.py

@@ -23,14 +23,12 @@ class TestContainer(Container):
         *,
         providers: Sequence[ProviderDef] | None = None,
         modules: Iterable[ModuleDef] | None = None,
-        strict: bool = False,
         default_scope: Scope = "transient",
         logger: logging.Logger | None = None,
     ) -> None:
         super().__init__(
             providers=providers,
             modules=modules,
-            strict=strict,
             default_scope=default_scope,
             logger=logger,
         )
@@ -47,7 +45,6 @@ class TestContainer(Container):
                 )
                 for provider in container.providers.values()
             ],
-            strict=container.strict,
             default_scope=container.default_scope,
             logger=container.logger,
         )
@@ -57,7 +54,7 @@ class TestContainer(Container):
         """
         Override the provider for the specified interface with a specific instance.
         """
-        if not self.is_registered(interface) and self.strict:
+        if not self.has_provider_for(interface):
             raise LookupError(
                 f"The provider interface `{type_repr(interface)}` not registered."
             )

{anydi-0.42.0 → anydi-0.44.0}/docs/extensions/django.md

@@ -59,7 +59,6 @@ The `HelloService` will be automatically injected into the hello view through th
 `ANYDI` supports the following settings:
 
 * `CONTAINER_FACTORY: str | None` - Specifies the factory function used to create the container. If not provided, the default container factory will be utilized.
-* `STRICT_MODE: bool` - Determines the container's behavior when a dependency cannot be resolved. If set to `True`, the container will raise an exception. If `False`, it will attempt to automatically create the dependency.
 * `REGISTER_SETTINGS: bool` - If `True`, the container will register the Django settings within it.
 * `REGISTER_COMPONENTS: bool` - If `True`, the container will register Django components such as the database and cache.
 * `INJECT_URLCONF: str | Sequence[str] | None` - Specifies the URL configuration where dependencies should be injected.
@@ -148,7 +147,7 @@ from anydi import Container
 
 
 def get_container() -> Container:
-    container = Container(strict=True)
+    container = Container()
     # Add custom container configuration here
     return container
 ```

{anydi-0.42.0 → anydi-0.44.0}/docs/usage.md

@@ -145,10 +145,11 @@ assert not container.is_resolved(int)
 
     This pattern can be used while writing unit tests to ensure that each test case has a clean dependency graph.
 
-## Strict Mode
+## Auto-Registration
 
 
-`AnyDI` operates in non-strict mode by default, meaning it doesn't require explicit registration for every type. It can dynamically resolve or auto-register dependencies, simplifying setups where manual registration for each type is impractical.
+`AnyDI` doesn't require explicit registration for every type. It can dynamically resolve and auto-register dependencies,
+simplifying setups where manual registration for each type is impractical.
 
 Consider a scenario with class dependencies:
 
@@ -194,19 +195,6 @@ assert container.is_resolved(Repository)
 assert container.is_resolved(Database)
 ```
 
-### Enabling Strict Mode
-
-For strict checking, enable strict mode by setting `strict=True` when creating the `Container`. In strict mode, all types must be explicitly registered or have a definable provider before instantiation.
-
-```python
-container = Container(strict=True)
-
-# Raises LookupError if `Service` or dependencies aren't registered.
-_ = container.resolve(Service)
-```
-
-Here's an improved version of the documentation with some enhancements for clarity, completeness, and formatting:
-
 ### Automatic Resource Management
 
 When your class dependencies implement the context manager protocol by defining the `__enter__/__aenter__` and `__exit__/__aexit__` methods, these resources are automatically managed by the container for `singleton` and `request` scoped providers.
@@ -229,7 +217,7 @@ class Connection:
         self.disconnected = True
 
 
-container = Container(strict=False)
+container = Container()
 connection = container.resolve(Connection)
 
 assert container.is_resolved(Connection)

{anydi-0.42.0 → anydi-0.44.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anydi"
-version = "0.42.0"
+version = "0.44.0"
 description = "Dependency Injection library"
 authors = [{ name = "Anton Ruhlov", email = "antonruhlov@gmail.com" }]
 requires-python = "~=3.9"
@@ -65,6 +65,7 @@ dev = [
     "pydantic-settings>=2.4.0,<3",
     "bump-my-version>=1.1.4",
     "pyright>=1.1.401",
+    "pytest-mock>=3.14.1",
 ]
 docs = [
     "mkdocs>=1.4.2,<2",
@@ -136,7 +137,7 @@ omit = [
 ]
 
 [tool.bumpversion]
-current_version = "0.42.0"
+current_version = "0.44.0"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.

{anydi-0.42.0 → anydi-0.44.0}/tests/ext/fastapi/app.py

@@ -10,7 +10,7 @@ from anydi.testing import TestContainer
 
 from tests.ext.fixtures import Mail, MailService, User, UserService
 
-container = TestContainer(strict=True)
+container = TestContainer()
 
 
 @container.provider(scope="singleton")

{anydi-0.42.0 → anydi-0.44.0}/tests/ext/fastapi/test_ext.py

@@ -15,7 +15,7 @@ def test_inject_param_missing_interface() -> None:
 
 
 def test_install_without_annotation() -> None:
-    container = Container(strict=True)
+    container = Container()
 
     @container.provider(scope="singleton")
     def message() -> str:
@@ -34,7 +34,7 @@ def test_install_without_annotation() -> None:
 
 
 def test_install_unknown_annotation() -> None:
-    container = Container(strict=True)
+    container = Container()
 
     app = FastAPI()
 

{anydi-0.42.0 → anydi-0.44.0}/tests/ext/faststream/test_ext.py

@@ -15,7 +15,7 @@ def test_inject_param_missing_interface() -> None:
 
 
 def test_install_without_annotation() -> None:
-    container = Container(strict=True)
+    container = Container()
 
     @container.provider(scope="singleton")
     def message() -> str:
@@ -34,7 +34,7 @@ def test_install_without_annotation() -> None:
 
 
 def test_install_unknown_annotation() -> None:
-    container = Container(strict=True)
+    container = Container()
 
     broker = RedisBroker()
 

{anydi-0.42.0 → anydi-0.44.0}/tests/ext/faststream/test_subscribers.py

@@ -18,7 +18,7 @@ class UserMessage(BaseModel):
 
 @pytest.fixture(scope="session")
 def container() -> Container:
-    container = Container(strict=True)
+    container = Container()
 
     @container.provider(scope="singleton")
     def provide_user_service() -> UserService:

{anydi-0.42.0 → anydi-0.44.0}/tests/ext/test_pytest_plugin.py

@@ -14,7 +14,7 @@ class UnknownService:
 
 @pytest.fixture(scope="module")
 def container() -> Container:
-    container = Container(strict=True)
+    container = Container()
     container.register(Service, lambda: Service(), scope="singleton")
     return container