modern-di 0.2.1__tar.gz → 0.3.0__tar.gz

{modern_di-0.2.1 → modern_di-0.3.0}/.github/workflows/publish.yml

@@ -23,6 +23,9 @@ jobs:
   publish-fastapi:
     if: startsWith(github.ref_name, 'fastapi')
     runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: integrations/fastapi
     steps:
       - uses: actions/checkout@v4
       - uses: extractions/setup-just@v2
@@ -31,7 +34,8 @@ jobs:
           enable-cache: true
           cache-dependency-glob: "pyproject.toml"
       - run: |
-          cd integrations/fastapi
+          export SETUPTOOLS_SCM_PRETEND_VERSION=$(echo "${{ github.ref_name }}" | sed 's/^fastapi-//; s/-.*$//')
+          echo "SETUPTOOLS_SCM_PRETEND_VERSION=$SETUPTOOLS_SCM_PRETEND_VERSION"
           just publish
         env:
           PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}

{modern_di-0.2.1 → modern_di-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: modern-di
-Version: 0.2.1
+Version: 0.3.0
 Summary: Dependency Injection framework with IOC-container and scopes
 Project-URL: repository, https://github.com/modern-python/modern-di
 Project-URL: docs, https://modern-di.readthedocs.io

{modern_di-0.2.1 → modern_di-0.3.0}/docs/dev/development-notes.md

@@ -9,7 +9,7 @@
   - context stacks for resources
   - overrides
 
-### Resolvers
+### Providers
 - completely stateless
 - if dependency is already saved or overridden in `Container`, returns it
 - otherwise build dependency and save it to `Container`
@@ -17,7 +17,7 @@
 
 ### Graph
 - Cannot be instantiated
-- Contains graph of `Resolvers`
+- Contains graph of `Providers`
 - Can initialize its resources and factories to container
 
 ### Questions

{modern_di-0.2.1 → modern_di-0.3.0}/integrations/fastapi/modern_di_fastapi/depends.py

@@ -2,7 +2,7 @@ import dataclasses
 import typing
 
 import fastapi
-import modern_di
+from modern_di import Container, providers
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
@@ -10,15 +10,15 @@ T_co = typing.TypeVar("T_co", covariant=True)
 
 @dataclasses.dataclass(slots=True, frozen=True)
 class Dependency(typing.Generic[T_co]):
-    dependency: modern_di.resolvers.AbstractResolver[T_co]
+    dependency: providers.AbstractProvider[T_co]
 
     async def __call__(self, request: fastapi.Request) -> T_co:
         return await self.dependency.async_resolve(request.state.modern_di_container)
 
 
-def FromDI(dependency: modern_di.resolvers.AbstractResolver[T_co], *, use_cache: bool = True) -> T_co:  # noqa: N802
+def FromDI(dependency: providers.AbstractProvider[T_co], *, use_cache: bool = True) -> T_co:  # noqa: N802
     return typing.cast(T_co, fastapi.Depends(dependency=Dependency(dependency), use_cache=use_cache))
 
 
-def setup_modern_di(container: modern_di.Container, app: fastapi.FastAPI) -> None:
+def setup_modern_di(container: Container, app: fastapi.FastAPI) -> None:
     app.state.modern_di_container = container

{modern_di-0.2.1 → modern_di-0.3.0}/integrations/fastapi/tests/test_fastapi_di.py

@@ -7,7 +7,7 @@ import httpx
 import modern_di
 import pytest
 from asgi_lifespan import LifespanManager
-from modern_di import Scope, resolvers
+from modern_di import Scope, providers
 from starlette import status
 from starlette.requests import Request
 
@@ -41,9 +41,9 @@ def context_adapter_function(*, request: Request, **_: object) -> str:
     return request.method
 
 
-app_factory = resolvers.Factory(Scope.APP, SimpleCreator, dep1="original")
-request_factory = resolvers.Factory(Scope.REQUEST, DependentCreator, dep1=app_factory.cast)
-context_adapter = resolvers.ContextAdapter(Scope.REQUEST, context_adapter_function)
+app_factory = providers.Factory(Scope.APP, SimpleCreator, dep1="original")
+request_factory = providers.Factory(Scope.REQUEST, DependentCreator, dep1=app_factory.cast)
+context_adapter = providers.ContextAdapter(Scope.REQUEST, context_adapter_function)
 
 
 @app.get("/")

{modern_di-0.2.1 → modern_di-0.3.0}/modern_di/__init__.py

@@ -7,5 +7,5 @@ __all__ = [
     "BaseGraph",
     "Container",
     "Scope",
-    "resolvers",
+    "providers",
 ]

{modern_di-0.2.1 → modern_di-0.3.0}/modern_di/container.py

@@ -3,7 +3,7 @@ import enum
 import types
 import typing
 
-from modern_di.resolver_state import ResolverState
+from modern_di.provider_state import ProviderState
 
 
 if typing.TYPE_CHECKING:
@@ -14,7 +14,7 @@ T_co = typing.TypeVar("T_co", covariant=True)
 
 
 class Container(contextlib.AbstractAsyncContextManager["Container"]):
-    __slots__ = "scope", "parent_container", "context", "_is_async", "_resolver_states", "_overrides"
+    __slots__ = "scope", "parent_container", "context", "_is_async", "_provider_states", "_overrides"
 
     def __init__(
         self,
@@ -31,12 +31,12 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
         self.parent_container = parent_container
         self.context: dict[str, typing.Any] = context or {}
         self._is_async: bool | None = None
-        self._resolver_states: dict[str, ResolverState[typing.Any]] = {}
+        self._provider_states: dict[str, ProviderState[typing.Any]] = {}
         self._overrides: dict[str, typing.Any] = {}
 
     def _exit(self) -> None:
         self._is_async = None
-        self._resolver_states = {}
+        self._provider_states = {}
         self._overrides = {}
 
     def _check_entered(self) -> None:
@@ -61,30 +61,30 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
             container = typing.cast("typing_extensions.Self", container.parent_container)
         return container
 
-    def fetch_resolver_state(
-        self, resolver_id: str, is_async_resource: bool = False, is_lock_required: bool = False
-    ) -> ResolverState[typing.Any]:
+    def fetch_provider_state(
+        self, provider_id: str, is_async_resource: bool = False, is_lock_required: bool = False
+    ) -> ProviderState[typing.Any]:
         self._check_entered()
         if is_async_resource and self._is_async is False:
             msg = "Resolving async resource in sync container is not allowed"
             raise RuntimeError(msg)
 
-        if resolver_id not in self._resolver_states:
-            self._resolver_states[resolver_id] = ResolverState(is_lock_required=is_lock_required)
+        if provider_id not in self._provider_states:
+            self._provider_states[provider_id] = ProviderState(is_lock_required=is_lock_required)
 
-        return self._resolver_states[resolver_id]
+        return self._provider_states[provider_id]
 
-    def override(self, resolver_id: str, override_object: object) -> None:
-        self._overrides[resolver_id] = override_object
+    def override(self, provider_id: str, override_object: object) -> None:
+        self._overrides[provider_id] = override_object
 
-    def fetch_override(self, resolver_id: str) -> object | None:
-        return self._overrides.get(resolver_id)
+    def fetch_override(self, provider_id: str) -> object | None:
+        return self._overrides.get(provider_id)
 
-    def reset_override(self, resolver_id: str | None = None) -> None:
-        if resolver_id is None:
+    def reset_override(self, provider_id: str | None = None) -> None:
+        if provider_id is None:
             self._overrides = {}
         else:
-            self._overrides.pop(resolver_id, None)
+            self._overrides.pop(provider_id, None)
 
     async def __aenter__(self) -> "Container":
         self._is_async = True
@@ -97,8 +97,8 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
         traceback: types.TracebackType | None,
     ) -> None:
         self._check_entered()
-        for resolver_state in reversed(self._resolver_states.values()):
-            await resolver_state.async_tear_down()
+        for provider_state in reversed(self._provider_states.values()):
+            await provider_state.async_tear_down()
         self._exit()
 
     def __enter__(self) -> "Container":
@@ -112,6 +112,6 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
         traceback: types.TracebackType | None,
     ) -> None:
         self._check_entered()
-        for resolver_state in reversed(self._resolver_states.values()):
-            resolver_state.sync_tear_down()
+        for provider_state in reversed(self._provider_states.values()):
+            provider_state.sync_tear_down()
         self._exit()

modern_di-0.3.0/modern_di/graph.py

@@ -0,0 +1,39 @@
+import typing
+
+from modern_di import Container
+from modern_di.providers import AbstractProvider, BaseCreatorProvider
+
+
+if typing.TYPE_CHECKING:
+    import typing_extensions
+
+
+T = typing.TypeVar("T")
+P = typing.ParamSpec("P")
+
+
+class BaseGraph:
+    providers: dict[str, AbstractProvider[typing.Any]]
+
+    def __new__(cls, *_: typing.Any, **__: typing.Any) -> "typing_extensions.Self":  # noqa: ANN401
+        msg = f"{cls.__name__} cannot not be instantiated"
+        raise RuntimeError(msg)
+
+    @classmethod
+    def get_providers(cls) -> dict[str, AbstractProvider[typing.Any]]:
+        if not hasattr(cls, "providers"):
+            cls.providers = {k: v for k, v in cls.__dict__.items() if isinstance(v, AbstractProvider)}
+
+        return cls.providers
+
+    @classmethod
+    async def async_resolve_creators(cls, container: Container) -> None:
+        for provider in cls.get_providers().values():
+            if isinstance(provider, BaseCreatorProvider) and provider.scope == container.scope:
+                await provider.async_resolve(container)
+
+    @classmethod
+    def sync_resolve_creators(cls, container: Container) -> None:
+        for provider in cls.get_providers().values():
+            if isinstance(provider, BaseCreatorProvider) and provider.scope == container.scope:
+                provider.sync_resolve(container)

modern_di-0.2.1/modern_di/resolver_state.py → modern_di-0.3.0/modern_di/provider_state.py

@@ -6,13 +6,13 @@ import typing
 T_co = typing.TypeVar("T_co", covariant=True)
 
 
-class ResolverState(typing.Generic[T_co]):
-    __slots__ = "context_stack", "instance", "resolver_lock"
+class ProviderState(typing.Generic[T_co]):
+    __slots__ = "context_stack", "instance", "provider_lock"
 
     def __init__(self, is_lock_required: bool) -> None:
         self.context_stack: contextlib.AsyncExitStack | contextlib.ExitStack | None = None
         self.instance: T_co | None = None
-        self.resolver_lock: typing.Final = asyncio.Lock() if is_lock_required else None
+        self.provider_lock: typing.Final = asyncio.Lock() if is_lock_required else None
 
     async def async_tear_down(self) -> None:
         if self.context_stack is None:

modern_di-0.3.0/modern_di/providers/__init__.py

@@ -0,0 +1,15 @@
+from modern_di.providers.base import AbstractProvider, BaseCreatorProvider
+from modern_di.providers.context_adapter import ContextAdapter
+from modern_di.providers.factory import Factory
+from modern_di.providers.resource import Resource
+from modern_di.providers.singleton import Singleton
+
+
+__all__ = [
+    "AbstractProvider",
+    "BaseCreatorProvider",
+    "ContextAdapter",
+    "Factory",
+    "Singleton",
+    "Resource",
+]

{modern_di-0.2.1/modern_di/resolvers → modern_di-0.3.0/modern_di/providers}/base.py

@@ -12,12 +12,12 @@ R = typing.TypeVar("R")
 P = typing.ParamSpec("P")
 
 
-class AbstractResolver(typing.Generic[T_co], abc.ABC):
-    BASE_SLOTS: typing.ClassVar = ["scope", "resolver_id"]
+class AbstractProvider(typing.Generic[T_co], abc.ABC):
+    BASE_SLOTS: typing.ClassVar = ["scope", "provider_id"]
 
     def __init__(self, scope: enum.IntEnum) -> None:
         self.scope = scope
-        self.resolver_id: typing.Final = str(uuid.uuid4())
+        self.provider_id: typing.Final = str(uuid.uuid4())
 
     @abc.abstractmethod
     async def async_resolve(self, container: Container) -> T_co:
@@ -28,18 +28,18 @@ class AbstractResolver(typing.Generic[T_co], abc.ABC):
         """Resolve dependency synchronously."""
 
     def override(self, override_object: object, container: Container) -> None:
-        container.override(self.resolver_id, override_object)
+        container.override(self.provider_id, override_object)
 
     def reset_override(self, container: Container) -> None:
-        container.reset_override(self.resolver_id)
+        container.reset_override(self.provider_id)
 
     @property
     def cast(self) -> T_co:
         return typing.cast(T_co, self)
 
 
-class BaseCreatorResolver(AbstractResolver[T_co], abc.ABC):
-    BASE_SLOTS: typing.ClassVar = [*AbstractResolver.BASE_SLOTS, "_args", "_kwargs", "_creator"]
+class BaseCreatorProvider(AbstractProvider[T_co], abc.ABC):
+    BASE_SLOTS: typing.ClassVar = [*AbstractProvider.BASE_SLOTS, "_args", "_kwargs", "_creator"]
 
     def __init__(
         self,
@@ -50,7 +50,7 @@ class BaseCreatorResolver(AbstractResolver[T_co], abc.ABC):
     ) -> None:
         super().__init__(scope)
 
-        if any(x.scope > self.scope for x in itertools.chain(args, kwargs.values()) if isinstance(x, AbstractResolver)):
+        if any(x.scope > self.scope for x in itertools.chain(args, kwargs.values()) if isinstance(x, AbstractProvider)):
             msg = "Scope of dependency cannot be more than scope of dependent"
             raise RuntimeError(msg)
 
@@ -61,12 +61,12 @@ class BaseCreatorResolver(AbstractResolver[T_co], abc.ABC):
     def _sync_build_creator(self, container: Container) -> typing.Any:  # noqa: ANN401
         return self._creator(
             *typing.cast(
-                P.args, [x.sync_resolve(container) if isinstance(x, AbstractResolver) else x for x in self._args]
+                P.args, [x.sync_resolve(container) if isinstance(x, AbstractProvider) else x for x in self._args]
             ),
             **typing.cast(
                 P.kwargs,
                 {
-                    k: v.sync_resolve(container) if isinstance(v, AbstractResolver) else v
+                    k: v.sync_resolve(container) if isinstance(v, AbstractProvider) else v
                     for k, v in self._kwargs.items()
                 },
             ),
@@ -76,12 +76,12 @@ class BaseCreatorResolver(AbstractResolver[T_co], abc.ABC):
         return self._creator(
             *typing.cast(
                 P.args,
-                [await x.async_resolve(container) if isinstance(x, AbstractResolver) else x for x in self._args],
+                [await x.async_resolve(container) if isinstance(x, AbstractProvider) else x for x in self._args],
             ),
             **typing.cast(
                 P.kwargs,
                 {
-                    k: await v.async_resolve(container) if isinstance(v, AbstractResolver) else v
+                    k: await v.async_resolve(container) if isinstance(v, AbstractProvider) else v
                     for k, v in self._kwargs.items()
                 },
             ),

{modern_di-0.2.1/modern_di/resolvers → modern_di-0.3.0/modern_di/providers}/context_adapter.py

@@ -2,15 +2,15 @@ import enum
 import typing
 
 from modern_di import Container
-from modern_di.resolvers import AbstractResolver
+from modern_di.providers import AbstractProvider
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
 P = typing.ParamSpec("P")
 
 
-class ContextAdapter(AbstractResolver[T_co]):
-    __slots__ = [*AbstractResolver.BASE_SLOTS, "_function"]
+class ContextAdapter(AbstractProvider[T_co]):
+    __slots__ = [*AbstractProvider.BASE_SLOTS, "_function"]
 
     def __init__(
         self,
@@ -25,7 +25,7 @@ class ContextAdapter(AbstractResolver[T_co]):
 
     def sync_resolve(self, container: Container) -> T_co:
         container = container.find_container(self.scope)
-        if (override := container.fetch_override(self.resolver_id)) is not None:
+        if (override := container.fetch_override(self.provider_id)) is not None:
             return typing.cast(T_co, override)
 
         return self._function(**container.context)

{modern_di-0.2.1/modern_di/resolvers → modern_di-0.3.0/modern_di/providers}/factory.py

@@ -2,15 +2,15 @@ import enum
 import typing
 
 from modern_di import Container
-from modern_di.resolvers import BaseCreatorResolver
+from modern_di.providers import BaseCreatorProvider
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
 P = typing.ParamSpec("P")
 
 
-class Factory(BaseCreatorResolver[T_co]):
-    __slots__ = [*BaseCreatorResolver.BASE_SLOTS, "_creator"]
+class Factory(BaseCreatorProvider[T_co]):
+    __slots__ = [*BaseCreatorProvider.BASE_SLOTS, "_creator"]
 
     def __init__(
         self,
@@ -23,14 +23,14 @@ class Factory(BaseCreatorResolver[T_co]):
 
     async def async_resolve(self, container: Container) -> T_co:
         container = container.find_container(self.scope)
-        if (override := container.fetch_override(self.resolver_id)) is not None:
+        if (override := container.fetch_override(self.provider_id)) is not None:
             return typing.cast(T_co, override)
 
         return typing.cast(T_co, await self._async_build_creator(container))
 
     def sync_resolve(self, container: Container) -> T_co:
         container = container.find_container(self.scope)
-        if (override := container.fetch_override(self.resolver_id)) is not None:
+        if (override := container.fetch_override(self.provider_id)) is not None:
             return typing.cast(T_co, override)
 
         return typing.cast(T_co, self._sync_build_creator(container))

{modern_di-0.2.1/modern_di/resolvers → modern_di-0.3.0/modern_di/providers}/resource.py

@@ -4,15 +4,15 @@ import inspect
 import typing
 
 from modern_di import Container
-from modern_di.resolvers import BaseCreatorResolver
+from modern_di.providers import BaseCreatorProvider
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
 P = typing.ParamSpec("P")
 
 
-class Resource(BaseCreatorResolver[T_co]):
-    __slots__ = [*BaseCreatorResolver.BASE_SLOTS, "_creator", "_args", "_kwargs", "_is_async"]
+class Resource(BaseCreatorProvider[T_co]):
+    __slots__ = [*BaseCreatorProvider.BASE_SLOTS, "_creator", "_args", "_kwargs", "_is_async"]
 
     def _is_creator_async(
         self,
@@ -42,43 +42,43 @@ class Resource(BaseCreatorResolver[T_co]):
 
     async def async_resolve(self, container: Container) -> T_co:
         container = container.find_container(self.scope)
-        if (override := container.fetch_override(self.resolver_id)) is not None:
+        if (override := container.fetch_override(self.provider_id)) is not None:
             return typing.cast(T_co, override)
 
-        resolver_state = container.fetch_resolver_state(
-            self.resolver_id, is_async_resource=self._is_async, is_lock_required=True
+        provider_state = container.fetch_provider_state(
+            self.provider_id, is_async_resource=self._is_async, is_lock_required=True
         )
-        if resolver_state.instance is not None:
-            return typing.cast(T_co, resolver_state.instance)
+        if provider_state.instance is not None:
+            return typing.cast(T_co, provider_state.instance)
 
-        assert resolver_state.resolver_lock
-        await resolver_state.resolver_lock.acquire()
+        assert provider_state.provider_lock
+        await provider_state.provider_lock.acquire()
 
         try:
-            if resolver_state.instance is not None:
-                return typing.cast(T_co, resolver_state.instance)
+            if provider_state.instance is not None:
+                return typing.cast(T_co, provider_state.instance)
 
             _intermediate_ = await self._async_build_creator(container)
 
             if self._is_creator_async(self._creator):  # type: ignore[arg-type]
-                resolver_state.context_stack = contextlib.AsyncExitStack()
-                resolver_state.instance = await resolver_state.context_stack.enter_async_context(_intermediate_)
+                provider_state.context_stack = contextlib.AsyncExitStack()
+                provider_state.instance = await provider_state.context_stack.enter_async_context(_intermediate_)
             else:
-                resolver_state.context_stack = contextlib.ExitStack()
-                resolver_state.instance = resolver_state.context_stack.enter_context(_intermediate_)
+                provider_state.context_stack = contextlib.ExitStack()
+                provider_state.instance = provider_state.context_stack.enter_context(_intermediate_)
         finally:
-            resolver_state.resolver_lock.release()
+            provider_state.provider_lock.release()
 
-        return typing.cast(T_co, resolver_state.instance)
+        return typing.cast(T_co, provider_state.instance)
 
     def sync_resolve(self, container: Container) -> T_co:
         container = container.find_container(self.scope)
-        if (override := container.fetch_override(self.resolver_id)) is not None:
+        if (override := container.fetch_override(self.provider_id)) is not None:
             return typing.cast(T_co, override)
 
-        resolver_state = container.fetch_resolver_state(self.resolver_id)
-        if resolver_state.instance is not None:
-            return typing.cast(T_co, resolver_state.instance)
+        provider_state = container.fetch_provider_state(self.provider_id)
+        if provider_state.instance is not None:
+            return typing.cast(T_co, provider_state.instance)
 
         if self._is_async:
             msg = "Async resource cannot be resolved synchronously"
@@ -86,9 +86,9 @@ class Resource(BaseCreatorResolver[T_co]):
 
         _intermediate_ = self._sync_build_creator(container)
 
-        resolver_state.context_stack = contextlib.ExitStack()
-        resolver_state.instance = resolver_state.context_stack.enter_context(
+        provider_state.context_stack = contextlib.ExitStack()
+        provider_state.instance = provider_state.context_stack.enter_context(
             typing.cast(contextlib.AbstractContextManager[typing.Any], _intermediate_)
         )
 
-        return typing.cast(T_co, resolver_state.instance)
+        return typing.cast(T_co, provider_state.instance)

modern_di-0.3.0/modern_di/providers/singleton.py

@@ -0,0 +1,56 @@
+import enum
+import typing
+
+from modern_di import Container
+from modern_di.providers import BaseCreatorProvider
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+P = typing.ParamSpec("P")
+
+
+class Singleton(BaseCreatorProvider[T_co]):
+    __slots__ = [*BaseCreatorProvider.BASE_SLOTS, "_creator"]
+
+    def __init__(
+        self,
+        scope: enum.IntEnum,
+        creator: typing.Callable[P, T_co],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> None:
+        super().__init__(scope, creator, *args, **kwargs)
+
+    async def async_resolve(self, container: Container) -> T_co:
+        container = container.find_container(self.scope)
+        if (override := container.fetch_override(self.provider_id)) is not None:
+            return typing.cast(T_co, override)
+
+        provider_state = container.fetch_provider_state(self.provider_id, is_lock_required=True)
+        if provider_state.instance is not None:
+            return typing.cast(T_co, provider_state.instance)
+
+        assert provider_state.provider_lock
+        await provider_state.provider_lock.acquire()
+
+        try:
+            if provider_state.instance is not None:
+                return typing.cast(T_co, provider_state.instance)
+
+            provider_state.instance = typing.cast(T_co, await self._async_build_creator(container))
+        finally:
+            provider_state.provider_lock.release()
+
+        return provider_state.instance
+
+    def sync_resolve(self, container: Container) -> T_co:
+        container = container.find_container(self.scope)
+        if (override := container.fetch_override(self.provider_id)) is not None:
+            return typing.cast(T_co, override)
+
+        provider_state = container.fetch_provider_state(self.provider_id)
+        if provider_state.instance is not None:
+            return typing.cast(T_co, provider_state.instance)
+
+        provider_state.instance = self._sync_build_creator(container)
+        return typing.cast(T_co, provider_state.instance)

{modern_di-0.2.1 → modern_di-0.3.0}/tests/resolvers/test_context_adapter.py

@@ -1,14 +1,14 @@
 import datetime
 
-from modern_di import Container, Scope, resolvers
+from modern_di import Container, Scope, providers
 
 
 def context_adapter_function(*, now: datetime.datetime, **_: object) -> datetime.datetime:
     return now
 
 
-context_adapter = resolvers.ContextAdapter(Scope.APP, context_adapter_function)
-request_context_adapter = resolvers.ContextAdapter(Scope.REQUEST, context_adapter_function)
+context_adapter = providers.ContextAdapter(Scope.APP, context_adapter_function)
+request_context_adapter = providers.ContextAdapter(Scope.REQUEST, context_adapter_function)
 
 
 async def test_context_adapter() -> None:

{modern_di-0.2.1 → modern_di-0.3.0}/tests/resolvers/test_factory.py

@@ -2,7 +2,7 @@ import dataclasses
 
 import pytest
 
-from modern_di import Container, Scope, resolvers
+from modern_di import Container, Scope, providers
 
 
 @dataclasses.dataclass(kw_only=True, slots=True)
@@ -15,8 +15,8 @@ class DependentCreator:
     dep1: SimpleCreator
 
 
-app_factory = resolvers.Factory(Scope.APP, SimpleCreator, dep1="original")
-request_factory = resolvers.Factory(Scope.REQUEST, DependentCreator, dep1=app_factory.cast)
+app_factory = providers.Factory(Scope.APP, SimpleCreator, dep1="original")
+request_factory = providers.Factory(Scope.REQUEST, DependentCreator, dep1=app_factory.cast)
 
 
 async def test_app_factory() -> None:
@@ -82,6 +82,6 @@ async def test_factory_overridden() -> None:
 async def test_factory_wrong_dependency_scope() -> None:
     def some_factory(_: SimpleCreator) -> None: ...
 
-    request_factory_ = resolvers.Factory(Scope.REQUEST, SimpleCreator, dep1="original")
+    request_factory_ = providers.Factory(Scope.REQUEST, SimpleCreator, dep1="original")
     with pytest.raises(RuntimeError, match="Scope of dependency cannot be more than scope of dependent"):
-        resolvers.Singleton(Scope.APP, some_factory, request_factory_.cast)
+        providers.Singleton(Scope.APP, some_factory, request_factory_.cast)

{modern_di-0.2.1 → modern_di-0.3.0}/tests/resolvers/test_resource.py

@@ -3,12 +3,12 @@ import typing
 
 import pytest
 
-from modern_di import Container, Scope, resolvers
+from modern_di import Container, Scope, providers
 from tests.creators import create_async_resource, create_sync_resource
 
 
-async_resource = resolvers.Resource(Scope.APP, create_async_resource)
-sync_resource = resolvers.Resource(Scope.APP, create_sync_resource)
+async_resource = providers.Resource(Scope.APP, create_async_resource)
+sync_resource = providers.Resource(Scope.APP, create_sync_resource)
 
 
 async def test_async_resource() -> None:
@@ -97,7 +97,7 @@ async def test_async_resource_race_condition() -> None:
         await asyncio.sleep(0)
         yield ""
 
-    resource = resolvers.Resource(Scope.APP, create_resource)
+    resource = providers.Resource(Scope.APP, create_resource)
 
     async def resolve_resource(container: Container) -> str:
         return await resource.async_resolve(container)
@@ -110,7 +110,7 @@ async def test_async_resource_race_condition() -> None:
 
 async def test_resource_unsupported_creator() -> None:
     with pytest.raises(RuntimeError, match="Unsupported resource type"):
-        resolvers.Resource(Scope.APP, None)  # type: ignore[arg-type]
+        providers.Resource(Scope.APP, None)  # type: ignore[arg-type]
 
 
 async def test_async_resource_sync_resolve() -> None:

{modern_di-0.2.1 → modern_di-0.3.0}/tests/resolvers/test_singleton.py

@@ -4,7 +4,7 @@ import typing
 
 import pytest
 
-from modern_di import Container, Scope, resolvers
+from modern_di import Container, Scope, providers
 
 
 @dataclasses.dataclass(kw_only=True, slots=True)
@@ -17,8 +17,8 @@ class DependentCreator:
     dep1: SimpleCreator
 
 
-app_singleton = resolvers.Singleton(Scope.APP, SimpleCreator, dep1="original")
-request_singleton = resolvers.Singleton(Scope.REQUEST, DependentCreator, dep1=app_singleton.cast)
+app_singleton = providers.Singleton(Scope.APP, SimpleCreator, dep1="original")
+request_singleton = providers.Singleton(Scope.REQUEST, DependentCreator, dep1=app_singleton.cast)
 
 
 async def test_app_singleton() -> None:
@@ -94,8 +94,8 @@ async def test_singleton_race_condition() -> None:
         await asyncio.sleep(0)
         yield ""
 
-    resource = resolvers.Resource(Scope.APP, create_resource)
-    factory_with_resource = resolvers.Singleton(Scope.APP, SimpleCreator, dep1=resource.cast)
+    resource = providers.Resource(Scope.APP, create_resource)
+    factory_with_resource = providers.Singleton(Scope.APP, SimpleCreator, dep1=resource.cast)
 
     async def resolve_factory(container: Container) -> SimpleCreator:
         return await factory_with_resource.async_resolve(container)
@@ -110,6 +110,6 @@ async def test_singleton_race_condition() -> None:
 async def test_singleton_wrong_dependency_scope() -> None:
     def some_factory(_: SimpleCreator) -> None: ...
 
-    request_singleton_ = resolvers.Singleton(Scope.REQUEST, SimpleCreator, dep1="original")
+    request_singleton_ = providers.Singleton(Scope.REQUEST, SimpleCreator, dep1="original")
     with pytest.raises(RuntimeError, match="Scope of dependency cannot be more than scope of dependent"):
-        resolvers.Singleton(Scope.APP, some_factory, request_singleton_.cast)
+        providers.Singleton(Scope.APP, some_factory, request_singleton_.cast)

{modern_di-0.2.1 → modern_di-0.3.0}/tests/test_container.py

@@ -13,7 +13,7 @@ def test_container_wrong_init() -> None:
 def test_container_not_opened() -> None:
     container = Container(scope=Scope.APP)
     with pytest.raises(RuntimeError, match="Enter the context first"):
-        container.fetch_resolver_state("some_id")
+        container.fetch_provider_state("some_id")
 
 
 async def test_container_build_child_async() -> None:

{modern_di-0.2.1 → modern_di-0.3.0}/tests/test_graph.py

@@ -1,11 +1,11 @@
 import pytest
 
-from modern_di import BaseGraph, Container, Scope, resolvers
+from modern_di import BaseGraph, Container, Scope, providers
 from tests.creators import create_async_resource, create_sync_resource
 
 
-async_resource = resolvers.Resource(Scope.APP, create_async_resource)
-sync_resource = resolvers.Resource(Scope.APP, create_sync_resource)
+async_resource = providers.Resource(Scope.APP, create_async_resource)
+sync_resource = providers.Resource(Scope.APP, create_sync_resource)
 
 
 async def test_graph_async_resolve_creators() -> None:
@@ -16,8 +16,8 @@ async def test_graph_async_resolve_creators() -> None:
     async with Container(scope=Scope.APP) as app_container:
         await DIGraph.async_resolve_creators(app_container)
 
-        assert len(app_container._resolver_states) == 2  # noqa: SLF001, PLR2004
-    assert len(app_container._resolver_states) == 0  # noqa: SLF001
+        assert len(app_container._provider_states) == 2  # noqa: SLF001, PLR2004
+    assert len(app_container._provider_states) == 0  # noqa: SLF001
 
 
 def test_graph_sync_resolve_creators() -> None:
@@ -27,8 +27,8 @@ def test_graph_sync_resolve_creators() -> None:
     with Container(scope=Scope.APP) as app_container:
         DIGraph.sync_resolve_creators(app_container)
 
-        assert len(app_container._resolver_states) == 1  # noqa: SLF001
-    assert len(app_container._resolver_states) == 0  # noqa: SLF001
+        assert len(app_container._provider_states) == 1  # noqa: SLF001
+    assert len(app_container._provider_states) == 0  # noqa: SLF001
 
 
 def test_graph_cannot_be_instantiated() -> None:

modern_di-0.2.1/modern_di/graph.py

@@ -1,39 +0,0 @@
-import typing
-
-from modern_di import Container
-from modern_di.resolvers import AbstractResolver, BaseCreatorResolver
-
-
-if typing.TYPE_CHECKING:
-    import typing_extensions
-
-
-T = typing.TypeVar("T")
-P = typing.ParamSpec("P")
-
-
-class BaseGraph:
-    resolvers: dict[str, AbstractResolver[typing.Any]]
-
-    def __new__(cls, *_: typing.Any, **__: typing.Any) -> "typing_extensions.Self":  # noqa: ANN401
-        msg = f"{cls.__name__} cannot not be instantiated"
-        raise RuntimeError(msg)
-
-    @classmethod
-    def get_resolvers(cls) -> dict[str, AbstractResolver[typing.Any]]:
-        if not hasattr(cls, "resolvers"):
-            cls.resolvers = {k: v for k, v in cls.__dict__.items() if isinstance(v, AbstractResolver)}
-
-        return cls.resolvers
-
-    @classmethod
-    async def async_resolve_creators(cls, container: Container) -> None:
-        for resolver in cls.get_resolvers().values():
-            if isinstance(resolver, BaseCreatorResolver) and resolver.scope == container.scope:
-                await resolver.async_resolve(container)
-
-    @classmethod
-    def sync_resolve_creators(cls, container: Container) -> None:
-        for resolver in cls.get_resolvers().values():
-            if isinstance(resolver, BaseCreatorResolver) and resolver.scope == container.scope:
-                resolver.sync_resolve(container)

modern_di-0.2.1/modern_di/resolvers/__init__.py

@@ -1,15 +0,0 @@
-from modern_di.resolvers.base import AbstractResolver, BaseCreatorResolver
-from modern_di.resolvers.context_adapter import ContextAdapter
-from modern_di.resolvers.factory import Factory
-from modern_di.resolvers.resource import Resource
-from modern_di.resolvers.singleton import Singleton
-
-
-__all__ = [
-    "AbstractResolver",
-    "BaseCreatorResolver",
-    "ContextAdapter",
-    "Factory",
-    "Singleton",
-    "Resource",
-]

modern_di-0.2.1/modern_di/resolvers/singleton.py

@@ -1,56 +0,0 @@
-import enum
-import typing
-
-from modern_di import Container
-from modern_di.resolvers import BaseCreatorResolver
-
-
-T_co = typing.TypeVar("T_co", covariant=True)
-P = typing.ParamSpec("P")
-
-
-class Singleton(BaseCreatorResolver[T_co]):
-    __slots__ = [*BaseCreatorResolver.BASE_SLOTS, "_creator"]
-
-    def __init__(
-        self,
-        scope: enum.IntEnum,
-        creator: typing.Callable[P, T_co],
-        *args: P.args,
-        **kwargs: P.kwargs,
-    ) -> None:
-        super().__init__(scope, creator, *args, **kwargs)
-
-    async def async_resolve(self, container: Container) -> T_co:
-        container = container.find_container(self.scope)
-        if (override := container.fetch_override(self.resolver_id)) is not None:
-            return typing.cast(T_co, override)
-
-        resolver_state = container.fetch_resolver_state(self.resolver_id, is_lock_required=True)
-        if resolver_state.instance is not None:
-            return typing.cast(T_co, resolver_state.instance)
-
-        assert resolver_state.resolver_lock
-        await resolver_state.resolver_lock.acquire()
-
-        try:
-            if resolver_state.instance is not None:
-                return typing.cast(T_co, resolver_state.instance)
-
-            resolver_state.instance = typing.cast(T_co, await self._async_build_creator(container))
-        finally:
-            resolver_state.resolver_lock.release()
-
-        return resolver_state.instance
-
-    def sync_resolve(self, container: Container) -> T_co:
-        container = container.find_container(self.scope)
-        if (override := container.fetch_override(self.resolver_id)) is not None:
-            return typing.cast(T_co, override)
-
-        resolver_state = container.fetch_resolver_state(self.resolver_id)
-        if resolver_state.instance is not None:
-            return typing.cast(T_co, resolver_state.instance)
-
-        resolver_state.instance = self._sync_build_creator(container)
-        return typing.cast(T_co, resolver_state.instance)