anydi 0.34.0__py3-none-any.whl → 0.34.1a0__py3-none-any.whl

anydi/_context.py

@@ -1,229 +1,54 @@
 from __future__ import annotations
 
-import abc
 import contextlib
-import inspect
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Callable, ClassVar
+from typing import Any
 
-from typing_extensions import Self, final
+from typing_extensions import Self
 
-from ._provider import CallableKind, Provider
-from ._types import AnyInterface, DependencyWrapper, Scope, is_event_type
-from ._utils import (
-    get_full_qualname,
-    is_async_context_manager,
-    is_context_manager,
-    run_async,
-)
+from ._utils import run_async
 
-if TYPE_CHECKING:
-    from ._container import Container
 
+class InstanceContext:
+    """A context to store instances."""
 
-class ScopedContext(abc.ABC):
-    """ScopedContext base class."""
+    __slots__ = ("_instances", "_stack", "_async_stack")
 
-    scope: ClassVar[Scope]
-
-    def __init__(self, container: Container) -> None:
-        self.container = container
-        self._instances: dict[Any, Any] = {}
-
-    def set(self, interface: AnyInterface, instance: Any) -> None:
-        """Set an instance of a dependency in the scoped context."""
-        self._instances[interface] = instance
-
-    @abc.abstractmethod
-    def get_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """Get or create an instance of a dependency from the scoped context."""
-
-    @abc.abstractmethod
-    async def aget_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """Get or create an async instance of a dependency from the scoped context."""
-
-    def _create_instance(self, provider: Provider) -> Any:
-        """Create an instance using the provider."""
-        if provider.kind == CallableKind.COROUTINE:
-            raise TypeError(
-                f"The instance for the coroutine provider `{provider}` cannot be "
-                "created in synchronous mode."
-            )
-        args, kwargs = self._get_provided_args(provider)
-        return provider.call(*args, **kwargs)
-
-    async def _acreate_instance(self, provider: Provider) -> Any:
-        """Create an instance asynchronously using the provider."""
-        args, kwargs = await self._aget_provided_args(provider)
-        if provider.kind == CallableKind.COROUTINE:
-            return await provider.call(*args, **kwargs)
-        return await run_async(provider.call, *args, **kwargs)
-
-    def _resolve_parameter(
-        self, provider: Provider, parameter: inspect.Parameter
-    ) -> Any:
-        self._validate_resolvable_parameter(parameter, call=provider.call)
-        return self.container.resolve(parameter.annotation)
-
-    async def _aresolve_parameter(
-        self, provider: Provider, parameter: inspect.Parameter
-    ) -> Any:
-        self._validate_resolvable_parameter(parameter, call=provider.call)
-        return await self.container.aresolve(parameter.annotation)
-
-    def _validate_resolvable_parameter(
-        self, parameter: inspect.Parameter, call: Callable[..., Any]
-    ) -> None:
-        """Ensure that the specified interface is resolved."""
-        if parameter.annotation in self.container._unresolved_interfaces:  # noqa
-            raise LookupError(
-                f"You are attempting to get the parameter `{parameter.name}` with the "
-                f"annotation `{get_full_qualname(parameter.annotation)}` as a "
-                f"dependency into `{get_full_qualname(call)}` which is not registered "
-                "or set in the scoped context."
-            )
-
-    def _get_provided_args(
-        self, provider: Provider
-    ) -> tuple[list[Any], dict[str, Any]]:
-        """Retrieve the arguments for a provider."""
-        args: list[Any] = []
-        kwargs: dict[str, Any] = {}
-
-        for parameter in provider.parameters:
-            if parameter.annotation in self.container._override_instances:  # noqa
-                instance = self.container._override_instances[parameter.annotation]  # noqa
-            elif parameter.annotation in self._instances:
-                instance = self._instances[parameter.annotation]
-            else:
-                try:
-                    instance = self._resolve_parameter(provider, parameter)
-                except LookupError:
-                    if parameter.default is inspect.Parameter.empty:
-                        raise
-                    instance = parameter.default
-                else:
-                    if self.container.testing:
-                        instance = DependencyWrapper(
-                            interface=parameter.annotation, instance=instance
-                        )
-            if parameter.kind == parameter.POSITIONAL_ONLY:
-                args.append(instance)
-            else:
-                kwargs[parameter.name] = instance
-        return args, kwargs
-
-    async def _aget_provided_args(
-        self, provider: Provider
-    ) -> tuple[list[Any], dict[str, Any]]:
-        """Asynchronously retrieve the arguments for a provider."""
-        args: list[Any] = []
-        kwargs: dict[str, Any] = {}
-
-        for parameter in provider.parameters:
-            if parameter.annotation in self.container._override_instances:  # noqa
-                instance = self.container._override_instances[parameter.annotation]  # noqa
-            elif parameter.annotation in self._instances:
-                instance = self._instances[parameter.annotation]
-            else:
-                try:
-                    instance = await self._aresolve_parameter(provider, parameter)
-                except LookupError:
-                    if parameter.default is inspect.Parameter.empty:
-                        raise
-                    instance = parameter.default
-                else:
-                    if self.container.testing:
-                        instance = DependencyWrapper(
-                            interface=parameter.annotation, instance=instance
-                        )
-            if parameter.kind == parameter.POSITIONAL_ONLY:
-                args.append(instance)
-            else:
-                kwargs[parameter.name] = instance
-        return args, kwargs
-
-
-class ResourceScopedContext(ScopedContext):
-    """ScopedContext with closable resources support."""
-
-    def __init__(self, container: Container) -> None:
-        """Initialize the ScopedContext."""
-        super().__init__(container)
+    def __init__(self) -> None:
+        self._instances: dict[type[Any], Any] = {}
         self._stack = contextlib.ExitStack()
         self._async_stack = contextlib.AsyncExitStack()
 
-    def get_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """Get an instance of a dependency from the scoped context."""
-        instance = self._instances.get(provider.interface)
-        if instance is None:
-            if provider.kind == CallableKind.GENERATOR:
-                instance = self._create_resource(provider)
-            elif provider.kind == CallableKind.ASYNC_GENERATOR:
-                raise TypeError(
-                    f"The provider `{provider}` cannot be started in synchronous mode "
-                    "because it is an asynchronous provider. Please start the provider "
-                    "in asynchronous mode before using it."
-                )
-            else:
-                instance = self._create_instance(provider)
-            self._instances[provider.interface] = instance
-            return instance, True
-        return instance, False
+    def get(self, interface: type[Any]) -> Any | None:
+        """Get an instance from the context."""
+        return self._instances.get(interface)
 
-    async def aget_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """Get an async instance of a dependency from the scoped context."""
-        instance = self._instances.get(provider.interface)
-        if instance is None:
-            if provider.kind == CallableKind.GENERATOR:
-                instance = await run_async(self._create_resource, provider)
-            elif provider.kind == CallableKind.ASYNC_GENERATOR:
-                instance = await self._acreate_resource(provider)
-            else:
-                instance = await self._acreate_instance(provider)
-            self._instances[provider.interface] = instance
-            return instance, True
-        return instance, False
+    def set(self, interface: type[Any], value: Any) -> None:
+        """Set an instance in the context."""
+        self._instances[interface] = value
 
-    def has(self, interface: AnyInterface) -> bool:
-        """Check if the scoped context has an instance of the dependency."""
-        return interface in self._instances
+    def enter(self, cm: contextlib.AbstractContextManager[Any]) -> Any:
+        """Enter the context."""
+        return self._stack.enter_context(cm)
 
-    def _create_instance(self, provider: Provider) -> Any:
-        """Create an instance using the provider."""
-        instance = super()._create_instance(provider)
-        # Enter the context manager if the instance is closable.
-        if is_context_manager(instance):
-            self._stack.enter_context(instance)
-        return instance
+    async def aenter(self, cm: contextlib.AbstractAsyncContextManager[Any]) -> Any:
+        """Enter the context asynchronously."""
+        return await self._async_stack.enter_async_context(cm)
 
-    def _create_resource(self, provider: Provider) -> Any:
-        """Create a resource using the provider."""
-        args, kwargs = self._get_provided_args(provider)
-        cm = contextlib.contextmanager(provider.call)(*args, **kwargs)
-        return self._stack.enter_context(cm)
+    def __setitem__(self, interface: type[Any], value: Any) -> None:
+        self._instances[interface] = value
 
-    async def _acreate_instance(self, provider: Provider) -> Any:
-        """Create an instance asynchronously using the provider."""
-        instance = await super()._acreate_instance(provider)
-        # Enter the context manager if the instance is closable.
-        if is_async_context_manager(instance):
-            await self._async_stack.enter_async_context(instance)
-        return instance
+    def __getitem__(self, interface: type[Any]) -> Any:
+        return self._instances[interface]
 
-    async def _acreate_resource(self, provider: Provider) -> Any:
-        """Create a resource asynchronously using the provider."""
-        args, kwargs = await self._aget_provided_args(provider)
-        cm = contextlib.asynccontextmanager(provider.call)(*args, **kwargs)
-        return await self._async_stack.enter_async_context(cm)
+    def __contains__(self, interface: type[Any]) -> bool:
+        return interface in self._instances
 
-    def delete(self, interface: AnyInterface) -> None:
-        """Delete a dependency instance from the scoped context."""
+    def __delitem__(self, interface: type[Any]) -> None:
         self._instances.pop(interface, None)
 
     def __enter__(self) -> Self:
         """Enter the context."""
-        self.start()
         return self
 
     def __exit__(
@@ -231,13 +56,9 @@ class ResourceScopedContext(ScopedContext):
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
-    ) -> bool:
+    ) -> Any:
         """Exit the context."""
-        return self._stack.__exit__(exc_type, exc_val, exc_tb)  # type: ignore[return-value]
-
-    @abc.abstractmethod
-    def start(self) -> None:
-        """Start the scoped context."""
+        return self._stack.__exit__(exc_type, exc_val, exc_tb)
 
     def close(self) -> None:
         """Close the scoped context."""
@@ -245,7 +66,6 @@ class ResourceScopedContext(ScopedContext):
 
     async def __aenter__(self) -> Self:
         """Enter the context asynchronously."""
-        await self.astart()
         return self
 
     async def __aexit__(
@@ -259,65 +79,6 @@ class ResourceScopedContext(ScopedContext):
             self.__exit__, exc_type, exc_val, exc_tb
         ) or await self._async_stack.__aexit__(exc_type, exc_val, exc_tb)
 
-    @abc.abstractmethod
-    async def astart(self) -> None:
-        """Start the scoped context asynchronously."""
-
     async def aclose(self) -> None:
         """Close the scoped context asynchronously."""
         await self.__aexit__(None, None, None)
-
-
-@final
-class SingletonContext(ResourceScopedContext):
-    """A scoped context representing the "singleton" scope."""
-
-    scope = "singleton"
-
-    def start(self) -> None:
-        """Start the scoped context."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
-            self.container.resolve(interface)
-
-    async def astart(self) -> None:
-        """Start the scoped context asynchronously."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
-            await self.container.aresolve(interface)
-
-
-@final
-class RequestContext(ResourceScopedContext):
-    """A scoped context representing the "request" scope."""
-
-    scope = "request"
-
-    def start(self) -> None:
-        """Start the scoped context."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
-            if not is_event_type(interface):
-                continue
-            self.container.resolve(interface)
-
-    async def astart(self) -> None:
-        """Start the scoped context asynchronously."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
-            if not is_event_type(interface):
-                continue
-            await self.container.aresolve(interface)
-
-
-@final
-class TransientContext(ScopedContext):
-    """A scoped context representing the "transient" scope."""
-
-    scope = "transient"
-
-    def get_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """Get or create an instance of a dependency from the transient context."""
-        return self._create_instance(provider), True
-
-    async def aget_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """
-        Get or create an async instance of a dependency from the transient context.
-        """
-        return await self._acreate_instance(provider), True

anydi/_provider.py

@@ -38,6 +38,11 @@ class Provider:
         "_kind",
         "_interface",
         "_parameters",
+        "_is_coroutine",
+        "_is_generator",
+        "_is_async_generator",
+        "_is_async",
+        "_is_resource",
     )
 
     def __init__(
@@ -52,6 +57,12 @@ class Provider:
         # Detect the kind of callable provider
         self._detect_kind()
 
+        self._is_coroutine = self._kind == CallableKind.COROUTINE
+        self._is_generator = self._kind == CallableKind.GENERATOR
+        self._is_async_generator = self._kind == CallableKind.ASYNC_GENERATOR
+        self._is_async = self._is_coroutine or self._is_async_generator
+        self._is_resource = self._is_generator or self._is_async_generator
+
         # Validate the scope of the provider
         self._validate_scope()
 
@@ -96,13 +107,30 @@ class Provider:
     def parameters(self) -> list[inspect.Parameter]:
         return self._parameters
 
+    @property
+    def is_coroutine(self) -> bool:
+        """Check if the provider is a coroutine."""
+        return self._is_coroutine
+
+    @property
+    def is_generator(self) -> bool:
+        """Check if the provider is a generator."""
+        return self._is_generator
+
+    @property
+    def is_async_generator(self) -> bool:
+        """Check if the provider is an async generator."""
+        return self._is_async_generator
+
+    @property
+    def is_async(self) -> bool:
+        """Check if the provider is an async callable."""
+        return self._is_async
+
     @property
     def is_resource(self) -> bool:
         """Check if the provider is a resource."""
-        return self._kind in {
-            CallableKind.GENERATOR,
-            CallableKind.ASYNC_GENERATOR,
-        }
+        return self._is_resource
 
     def _validate_scope(self) -> None:
         """Validate the scope of the provider."""

anydi/_types.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
 
 import inspect
+from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import Annotated, Any, TypeVar, Union
+from types import ModuleType
+from typing import Annotated, Any, NamedTuple, Union
 
 from typing_extensions import Literal, Self, TypeAlias
 
 Scope = Literal["transient", "singleton", "request"]
 
-T = TypeVar("T")
 AnyInterface: TypeAlias = Union[type[Any], Annotated[Any, ...]]
-Interface: TypeAlias = type[T]
 
 
 class Marker:
@@ -47,3 +47,19 @@ class DependencyWrapper:
         if name in {"interface", "instance"}:
             return object.__getattribute__(self, name)
         return getattr(self.instance, name)
+
+
+class ProviderDecoratorArgs(NamedTuple):
+    scope: Scope
+    override: bool
+
+
+@dataclass(frozen=True)
+class Dependency:
+    member: Any
+    module: ModuleType
+
+
+class InjectableDecoratorArgs(NamedTuple):
+    wrapped: bool
+    tags: Iterable[str] | None

anydi/ext/django/middleware.py

@@ -14,15 +14,15 @@ def request_scoped_middleware(
     if iscoroutinefunction(get_response):
 
         async def async_middleware(request: HttpRequest) -> Any:
-            async with container.arequest_context() as ctx:
-                ctx.set(HttpRequest, instance=request)
+            async with container.arequest_context() as context:
+                context.set(HttpRequest, request)
                 return await get_response(request)
 
         return async_middleware
 
     def middleware(request: HttpRequest) -> Any:
-        with container.request_context() as ctx:
-            ctx.set(HttpRequest, instance=request)
+        with container.request_context() as context:
+            context.set(HttpRequest, request)
             return get_response(request)
 
     return middleware

anydi/ext/starlette/middleware.py

@@ -18,6 +18,6 @@ class RequestScopedMiddleware(BaseHTTPMiddleware):
     async def dispatch(
         self, request: Request, call_next: RequestResponseEndpoint
     ) -> Response:
-        async with self.container.arequest_context() as ctx:
-            ctx.set(Request, instance=request)
+        async with self.container.arequest_context() as context:
+            context.set(Request, request)
             return await call_next(request)

{anydi-0.34.0.dist-info → anydi-0.34.1a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anydi
-Version: 0.34.0
+Version: 0.34.1a0
 Summary: Dependency Injection library
 Home-page: https://github.com/antonrh/anydi
 License: MIT

{anydi-0.34.0.dist-info → anydi-0.34.1a0.dist-info}/RECORD

@@ -1,11 +1,9 @@
-anydi/__init__.py,sha256=EsR-HiMe8cWS9PQbY23ibc91STK1WTn02DFMPV-TNU4,509
-anydi/_container.py,sha256=p1e8Lrh5JIzrtSsvqYWe8sP-W7dmlpxERspOGS4iivE,21884
-anydi/_context.py,sha256=2QvG4fDnfafXu7yF2EbY8kds96hkKyd8vni_NVmUrRs,12734
+anydi/__init__.py,sha256=OfRg2EfXD65pHTGQKhfkABMwUhw5LvsuTQV_Tv4V4wk,501
+anydi/_container.py,sha256=RyP0k8MXZfDr3mjjMo86auidKrlAGstEgY2AxpAHEAg,35346
+anydi/_context.py,sha256=7LV_SL4QWkJeiG7_4D9PZ5lmU-MPzhofxC95zCgY9Gc,2651
 anydi/_logger.py,sha256=UpubJUnW83kffFxkhUlObm2DmZX1Pjqoz9YFKS-JOPg,52
-anydi/_module.py,sha256=cgojC7Z7oMtsUnkfSc65cRYOfZ8Q6KwjusNJzx_VSbk,2729
-anydi/_provider.py,sha256=w_GnRo324aqNORRJwuURexA54c1M3smj34Q8EaV0QGE,6213
-anydi/_scanner.py,sha256=F2sHgJvkRYXYnu4F5iSrnIPVzwnNeS7tRPXziirh4NI,4898
-anydi/_types.py,sha256=90xdbH2NrFXbridFf9mjOknhcXMW5L0jm92zP_LvKrg,1120
+anydi/_provider.py,sha256=fcfzYOlpJ1fMqbMPAd6uI9_lap8n2ljJ9e10OEQpI4s,7176
+anydi/_types.py,sha256=55Wvaxcs2DPpVXrMqhHebT_ZeGDnH-H_zhND306vaoU,1397
 anydi/_utils.py,sha256=INI0jNIXrJ6LS4zqJymMO2yUEobpxmBGASf4G_vR6AU,4378
 anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/_utils.py,sha256=U6sRqWzccWUu7eMhbXX1NrwcaxitQF9cO1KxnKF37gw,2566
@@ -14,7 +12,7 @@ anydi/ext/django/_container.py,sha256=cxVoYQG16WP0S_Yv4TnLwuaaT7NVEOhLWO-YdALJUb
 anydi/ext/django/_settings.py,sha256=Z0RlAuXoO73oahWeMkK10w8c-4uCBde-DBpeKTV5USY,853
 anydi/ext/django/_utils.py,sha256=q6X6GApBm0oBK8DnoRZhTq2m4tAdKRYL__gVgKn3idg,3977
 anydi/ext/django/apps.py,sha256=mjbf_mDCpNSriGnILzhRIr8wFHLMEK8sUerbmRku6i0,2844
-anydi/ext/django/middleware.py,sha256=tryIaBVmfPmilGrnKpLNlLCOPN5rw4_pXY3ojFXv3O0,856
+anydi/ext/django/middleware.py,sha256=5OUdp0OWRozyW338Sq04BDhacaFlyUTTOduS_7EwCTA,854
 anydi/ext/django/ninja/__init__.py,sha256=kW3grUgWp_nkWSG_-39ADHMrZLGNcj9TsJ9OW8iWWrk,546
 anydi/ext/django/ninja/_operation.py,sha256=wSWa7D73XTVlOibmOciv2l6JHPe1ERZcXrqI8W-oO2w,2696
 anydi/ext/django/ninja/_signature.py,sha256=2cSzKxBIxXLqtwNuH6GSlmjVJFftoGmleWfyk_NVEWw,2207
@@ -23,10 +21,10 @@ anydi/ext/faststream.py,sha256=qXnNGvAqWWp9kbhbQUE6EF_OPUiYQmtOH211_O7BI_0,1898
 anydi/ext/pydantic_settings.py,sha256=8IXXLuG_OvKbvKlBkBRQUHcXgbTpgQUxeWyoMcRIUQM,1488
 anydi/ext/pytest_plugin.py,sha256=3x_ZYFcLp4ZCRrs7neoohmWz56O9ydm92jxi_LnyD7w,4298
 anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi/ext/starlette/middleware.py,sha256=PKip_omFZDgg7h2OY-nnV2OIS1MbbmrrOJBwG7_Peuw,793
+anydi/ext/starlette/middleware.py,sha256=9CQtGg5ZzUz2gFSzJr8U4BWzwNjK8XMctm3n52M77Z0,792
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi-0.34.0.dist-info/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
-anydi-0.34.0.dist-info/METADATA,sha256=VwSg8GNsINsMsEnlpRkFPxzGDCqYuqfyt5yJ1sL3pR8,5071
-anydi-0.34.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-anydi-0.34.0.dist-info/entry_points.txt,sha256=GmQblwzxFg42zva1HyBYJJ7TvrTIcSAGBHmyi3bvsi4,42
-anydi-0.34.0.dist-info/RECORD,,
+anydi-0.34.1a0.dist-info/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
+anydi-0.34.1a0.dist-info/METADATA,sha256=ifXLCYsyeltoiS9jE3Kx49Bh3AOj86Q3zYXhypnb3sc,5073
+anydi-0.34.1a0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+anydi-0.34.1a0.dist-info/entry_points.txt,sha256=GmQblwzxFg42zva1HyBYJJ7TvrTIcSAGBHmyi3bvsi4,42
+anydi-0.34.1a0.dist-info/RECORD,,

anydi/_module.py

@@ -1,94 +0,0 @@
-"""AnyDI decorators module."""
-
-from __future__ import annotations
-
-import inspect
-from typing import TYPE_CHECKING, Any, Callable, TypeVar
-
-from typing_extensions import Concatenate, NamedTuple, ParamSpec
-
-from ._types import Scope
-from ._utils import import_string
-
-if TYPE_CHECKING:
-    from ._container import Container
-
-T = TypeVar("T")
-M = TypeVar("M", bound="Module")
-P = ParamSpec("P")
-
-
-class ModuleMeta(type):
-    """A metaclass used for the Module base class."""
-
-    def __new__(cls, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> Any:
-        attrs["providers"] = [
-            (name, getattr(value, "__provider__"))
-            for name, value in attrs.items()
-            if hasattr(value, "__provider__")
-        ]
-        return super().__new__(cls, name, bases, attrs)
-
-
-class Module(metaclass=ModuleMeta):
-    """A base class for defining AnyDI modules."""
-
-    providers: list[tuple[str, ProviderDecoratorArgs]]
-
-    def configure(self, container: Container) -> None:
-        """Configure the AnyDI container with providers and their dependencies."""
-
-
-class ModuleRegistry:
-    def __init__(self, container: Container) -> None:
-        self.container = container
-
-    def register(
-        self, module: Module | type[Module] | Callable[[Container], None] | str
-    ) -> None:
-        """Register a module as a callable, module type, or module instance."""
-
-        # Callable Module
-        if inspect.isfunction(module):
-            module(self.container)
-            return
-
-        # Module path
-        if isinstance(module, str):
-            module = import_string(module)
-
-        # Class based Module or Module type
-        if inspect.isclass(module) and issubclass(module, Module):
-            module = module()
-
-        if isinstance(module, Module):
-            module.configure(self.container)
-            for provider_name, decorator_args in module.providers:
-                obj = getattr(module, provider_name)
-                self.container.provider(
-                    scope=decorator_args.scope,
-                    override=decorator_args.override,
-                )(obj)
-
-
-class ProviderDecoratorArgs(NamedTuple):
-    scope: Scope
-    override: bool
-
-
-def provider(
-    *, scope: Scope, override: bool = False
-) -> Callable[[Callable[Concatenate[M, P], T]], Callable[Concatenate[M, P], T]]:
-    """Decorator for marking a function or method as a provider in a AnyDI module."""
-
-    def decorator(
-        target: Callable[Concatenate[M, P], T],
-    ) -> Callable[Concatenate[M, P], T]:
-        setattr(
-            target,
-            "__provider__",
-            ProviderDecoratorArgs(scope=scope, override=override),
-        )
-        return target
-
-    return decorator