modern-di 0.16.2__py3-none-any.whl → 0.17.0__py3-none-any.whl

modern_di/registries/state_registry/state_registry.py

@@ -0,0 +1,52 @@
+import dataclasses
+import typing
+
+from modern_di.providers import AbstractProvider
+from modern_di.registries.state_registry.state import AsyncState, SyncState
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class AsyncStateRegistry:
+    use_lock: bool
+    states: dict[str, AsyncState[typing.Any]] = dataclasses.field(init=False, default_factory=dict)
+
+    def fetch_provider_state(self, provider: AbstractProvider[T_co]) -> AsyncState[T_co] | None:
+        if not provider.HAS_STATE:
+            return None
+
+        if provider_state := self.states.get(provider.provider_id):
+            return provider_state
+
+        # expected to be thread-safe, because setdefault is atomic
+        return self.states.setdefault(provider.provider_id, AsyncState(use_lock=self.use_lock))
+
+    async def clear_state(self) -> None:
+        for provider_state in reversed(self.states.values()):
+            await provider_state.tear_down()
+
+        self.states.clear()
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class SyncStateRegistry:
+    use_lock: bool
+    states: dict[str, SyncState[typing.Any]] = dataclasses.field(init=False, default_factory=dict)
+
+    def fetch_provider_state(self, provider: AbstractProvider[T_co]) -> SyncState[T_co] | None:
+        if not provider.HAS_STATE:
+            return None
+
+        if provider_state := self.states.get(provider.provider_id):
+            return provider_state
+
+        # expected to be thread-safe, because setdefault is atomic
+        return self.states.setdefault(provider.provider_id, SyncState(use_lock=self.use_lock))
+
+    def clear_state(self) -> None:
+        for provider_state in reversed(self.states.values()):
+            provider_state.tear_down()
+
+        self.states.clear()

{modern_di-0.16.2.dist-info → modern_di-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modern-di
-Version: 0.16.2
+Version: 0.17.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.17.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+modern_di/__init__.py,sha256=3VNwCoKLtuRvHlw1LlEE_GqML6mSPxt2xiIb0lLPglE,296
+modern_di/group.py,sha256=VUs8qHz_mzrFHr88Ztt4bEGJ1lNNcZuLdJD5SPksefc,707
+modern_di/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modern_di/scope.py,sha256=e6Olc-CF89clbYDNGciy-F8EqJt1Mw2703zfuJaEY94,113
+modern_di/containers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modern_di/containers/abstract.py,sha256=UopSKQYz7wdNKSmKdFSNY0DjptRjbzdGmEvfrvkeKTY,3994
+modern_di/containers/async_container.py,sha256=dZHCkPlLU61BPiwRl4TThCLO1Io8XPrkVRCLKPikGwk,3903
+modern_di/containers/sync_container.py,sha256=RvLzLwuAZdrPKTw6aYGesX9NZMLuuxyMlWTY96k7YOk,3908
+modern_di/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modern_di/helpers/attr_getter_helpers.py,sha256=HUjExWLRAz2h0YX2_h5xKPX9-_K3i-BZTeZb3u-Wq5k,221
+modern_di/helpers/type_helpers.py,sha256=sIQmM6aLj8UJ-JL3cpFattdV8rVegDHPFODFAm-fjP0,795
+modern_di/providers/__init__.py,sha256=NidhR4kH4HkgL4tLurG4S2W4mWuG5ENvPEZckWsMW2U,810
+modern_di/providers/abstract.py,sha256=yY2elYgnFDZtKiPLnI1q1I7py2LxVdzOaTNjQpLxT-0,4618
+modern_di/providers/async_factory.py,sha256=Bx_xHET6c_IKttEnwFc4VDpLft25gvVpZ_uDVx3kkYQ,815
+modern_di/providers/async_singleton.py,sha256=jL0aB_uEUIlSsYamvUPHCTkeNxvS4ELjguOvnJ7kirs,1040
+modern_di/providers/container_provider.py,sha256=QMOT767Yl00sPJKBW_926m7ZfyIUOG_zzOoPxg9Na2Q,337
+modern_di/providers/context_provider.py,sha256=lZu_INZnbiWQsR-qMrKEOtZpYaSiE4-rf2ZIP5p3-x8,427
+modern_di/providers/dict.py,sha256=ni2avO16XfX98mE6tgIX8v0Pn4iAPQYL_1YBDB4WlHo,708
+modern_di/providers/factory.py,sha256=ocbdlsPoxtoc_t2D0wWsssP08_8gAUAJmr5IOb4Q3sQ,943
+modern_di/providers/list.py,sha256=KZPBctoE5LqgHemBR3Viq5pA7w6CJMOsHbvlBlbF4Kg,674
+modern_di/providers/object.py,sha256=5hoyLC5whtG2TNlOQe3LKTKTRvQEmhOWpzugN1hczhI,572
+modern_di/providers/resource.py,sha256=avtPsVbmcJ00XQ9JUZSkqmcDQx4Gpg2SX5NyCOnUeZU,3174
+modern_di/providers/singleton.py,sha256=IPI_6HB9z8d_7ftyy3vYJL6hyNyyRTuFDSUm-FkTW5U,1277
+modern_di/registries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modern_di/registries/context_registry.py,sha256=fdHvQIHYyaRqAK8MFG80HXKixo-CRvFN20LeRBHSCs4,412
+modern_di/registries/overrides_registry.py,sha256=Qh5D0z7_sh6Y1S94w7w61vjvVbdu4z9gnRvNGDDdWxk,706
+modern_di/registries/providers_registry.py,sha256=wyuwoSNcLP3vjPw3vttkGuoZu7KmCd8WV6UF5QYLFyk,1564
+modern_di/registries/state_registry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modern_di/registries/state_registry/state.py,sha256=_y7mMDKdNOourTHVp2EYID8ZBVL-NXF0up8vJ80F1tk,1339
+modern_di/registries/state_registry/state_registry.py,sha256=6m0NJRMdYufFXqVoIH5Um7xxGhpZXkDkMgWmCJj2I0E,1813
+modern_di-0.17.0.dist-info/METADATA,sha256=GIGoTHxeslmaGUAzzpdIrB4f9G7RvNQkukB9mGdRKTA,3382
+modern_di-0.17.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+modern_di-0.17.0.dist-info/RECORD,,

modern_di/container.py

@@ -1,171 +0,0 @@
-import contextlib
-import enum
-import types
-import typing
-
-from modern_di.provider_state import ProviderState
-from modern_di.scope import Scope
-
-
-if typing.TYPE_CHECKING:
-    import typing_extensions
-
-
-T_co = typing.TypeVar("T_co", covariant=True)
-
-
-class Container(contextlib.AbstractAsyncContextManager["Container"], contextlib.AbstractContextManager["Container"]):
-    __slots__ = (
-        "_is_async",
-        "_overrides",
-        "_provider_states",
-        "_use_threading_lock",
-        "context",
-        "parent_container",
-        "scope",
-    )
-
-    def __init__(
-        self,
-        *,
-        scope: enum.IntEnum = Scope.APP,
-        parent_container: typing.Optional["Container"] = None,
-        context: dict[str, typing.Any] | None = None,
-        use_threading_lock: bool = True,
-    ) -> None:
-        self.scope = scope
-        self.parent_container = parent_container
-        self.context: dict[str, typing.Any] = context or {}
-        self._is_async: bool | None = None
-        self._provider_states: dict[str, ProviderState[typing.Any]] = {}
-        self._overrides: dict[str, typing.Any] = parent_container._overrides if parent_container else {}  # noqa: SLF001
-        self._use_threading_lock = use_threading_lock
-
-    def _exit(self) -> None:
-        self._is_async = None
-        self._provider_states = {}
-        self._overrides = {}
-        self.context = {}
-
-    def _check_entered(self) -> None:
-        if self._is_async is None:
-            msg = "Enter the context first"
-            raise RuntimeError(msg)
-
-    def build_child_container(
-        self, context: dict[str, typing.Any] | None = None, scope: enum.IntEnum | None = None
-    ) -> "typing_extensions.Self":
-        self._check_entered()
-        if scope and scope <= self.scope:
-            msg = "Scope of child container must be more than current scope"
-            raise RuntimeError(msg)
-
-        if not scope:
-            try:
-                scope = self.scope.__class__(self.scope.value + 1)
-            except ValueError as exc:
-                msg = f"Max scope is reached, {self.scope.name}"
-                raise RuntimeError(msg) from exc
-
-        return self.__class__(scope=scope, parent_container=self, context=context)
-
-    def find_container(self, scope: enum.IntEnum) -> "typing_extensions.Self":
-        container = self
-        if container.scope < scope:
-            msg = f"Scope {scope.name} is not initialized"
-            raise RuntimeError(msg)
-
-        while container.scope > scope and container.parent_container:
-            container = typing.cast("typing_extensions.Self", container.parent_container)
-
-        if container.scope != scope:
-            msg = f"Scope {scope.name} is skipped"
-            raise RuntimeError(msg)
-
-        return container
-
-    def fetch_provider_state(
-        self,
-        provider_id: str,
-        is_async_resource: bool = False,
-        use_asyncio_lock: bool = False,
-        use_threading_lock: 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 provider_state := self._provider_states.get(provider_id):
-            return provider_state
-
-        # expected to be thread-safe, because setdefault is atomic
-        return self._provider_states.setdefault(
-            provider_id,
-            ProviderState(
-                use_asyncio_lock=use_asyncio_lock,
-                use_threading_lock=self._use_threading_lock and use_threading_lock,
-            ),
-        )
-
-    def override(self, provider_id: str, override_object: object) -> None:
-        self._overrides[provider_id] = override_object
-
-    def fetch_override(self, provider_id: str) -> object | None:
-        return self._overrides.get(provider_id)
-
-    def reset_override(self, provider_id: str | None = None) -> None:
-        if provider_id is None:
-            self._overrides = {}
-        else:
-            self._overrides.pop(provider_id, None)
-
-    def async_enter(self) -> "Container":
-        self._is_async = True
-        return self
-
-    def sync_enter(self) -> "Container":
-        self._is_async = False
-        return self
-
-    async def async_close(self) -> None:
-        self._check_entered()
-        for provider_state in reversed(self._provider_states.values()):
-            await provider_state.async_tear_down()
-        self._exit()
-
-    def sync_close(self) -> None:
-        self._check_entered()
-        for provider_state in reversed(self._provider_states.values()):
-            provider_state.sync_tear_down()
-        self._exit()
-
-    async def __aenter__(self) -> "Container":
-        return self.async_enter()
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        traceback: types.TracebackType | None,
-    ) -> None:
-        await self.async_close()
-
-    def __enter__(self) -> "Container":
-        return self.sync_enter()
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: types.TracebackType | None,
-    ) -> None:
-        self.sync_close()
-
-    def __deepcopy__(self, *_: object, **__: object) -> "typing_extensions.Self":
-        """Hack to prevent cloning object."""
-        return self
-
-    def __copy__(self, *_: object, **__: object) -> "typing_extensions.Self":
-        """Hack to prevent cloning object."""
-        return self

modern_di/graph.py

@@ -1,39 +0,0 @@
-import typing
-
-from modern_di import Container
-from modern_di.providers.abstract import AbstractCreatorProvider, AbstractProvider
-
-
-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, AbstractCreatorProvider) 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, AbstractCreatorProvider) and provider.scope == container.scope:
-                provider.sync_resolve(container)

modern_di/providers/context_adapter.py

@@ -1,27 +0,0 @@
-import enum
-import typing
-
-from modern_di import Container
-from modern_di.providers import AbstractProvider
-
-
-T_co = typing.TypeVar("T_co", covariant=True)
-P = typing.ParamSpec("P")
-
-
-class ContextAdapter(AbstractProvider[T_co]):
-    __slots__ = [*AbstractProvider.BASE_SLOTS, "_function"]
-
-    def __init__(
-        self,
-        scope: enum.IntEnum,
-        function: typing.Callable[..., T_co],
-    ) -> None:
-        super().__init__(scope)
-        self._function = function
-
-    async def async_resolve(self, container: Container) -> T_co:
-        return self._function(**container.find_container(self.scope).context)
-
-    def sync_resolve(self, container: Container) -> T_co:
-        return self._function(**container.find_container(self.scope).context)

modern_di/providers/injected_factory.py

@@ -1,45 +0,0 @@
-import functools
-import typing
-
-from modern_di import Container
-from modern_di.providers.abstract import AbstractProvider
-
-
-T_co = typing.TypeVar("T_co", covariant=True)
-P = typing.ParamSpec("P")
-
-
-class SyncInjectedFactory(AbstractProvider[T_co]):
-    __slots__ = [*AbstractProvider.BASE_SLOTS, "_factory_provider"]
-
-    def __init__(self, factory_provider: AbstractProvider[T_co]) -> None:
-        super().__init__(factory_provider.scope)
-        self._factory_provider = factory_provider
-
-    async def async_resolve(self, container: Container) -> typing.Callable[[], T_co]:  # type: ignore[override]
-        return self.sync_resolve(container)
-
-    def sync_resolve(self, container: Container) -> typing.Callable[[], T_co]:  # type: ignore[override]
-        return functools.partial(self._factory_provider.sync_resolve, container)
-
-    @property
-    def cast(self) -> typing.Callable[[], T_co]:  # type: ignore[override]
-        return typing.cast(typing.Callable[[], T_co], self)
-
-
-class AsyncInjectedFactory(AbstractProvider[T_co]):
-    __slots__ = [*AbstractProvider.BASE_SLOTS, "_factory_provider"]
-
-    def __init__(self, factory_provider: AbstractProvider[T_co]) -> None:
-        super().__init__(factory_provider.scope)
-        self._factory_provider = factory_provider
-
-    async def async_resolve(self, container: Container) -> typing.Callable[[], typing.Awaitable[T_co]]:  # type: ignore[override]
-        return self.sync_resolve(container)
-
-    def sync_resolve(self, container: Container) -> typing.Callable[[], typing.Awaitable[T_co]]:  # type: ignore[override]
-        return functools.partial(self._factory_provider.async_resolve, container)
-
-    @property
-    def cast(self) -> typing.Callable[[], typing.Awaitable[T_co]]:  # type: ignore[override]
-        return typing.cast(typing.Callable[[], typing.Awaitable[T_co]], self)

modern_di/providers/selector.py

@@ -1,39 +0,0 @@
-import enum
-import typing
-
-from modern_di import Container
-from modern_di.providers.abstract import AbstractProvider
-
-
-T_co = typing.TypeVar("T_co", covariant=True)
-P = typing.ParamSpec("P")
-
-
-class Selector(AbstractProvider[T_co]):
-    __slots__ = [*AbstractProvider.BASE_SLOTS, "_function", "_providers"]
-
-    def __init__(
-        self, scope: enum.IntEnum, function: typing.Callable[..., str], **providers: AbstractProvider[T_co]
-    ) -> None:
-        super().__init__(scope)
-        self._check_providers_scope(kwargs=providers)
-        self._function: typing.Final = function
-        self._providers: typing.Final = providers
-
-    async def async_resolve(self, container: Container) -> T_co:
-        container = container.find_container(self.scope)
-        selected_key = self._function(**container.context)
-        if selected_key not in self._providers:
-            msg = f"No provider matches {selected_key}"
-            raise RuntimeError(msg)
-
-        return await self._providers[selected_key].async_resolve(container)
-
-    def sync_resolve(self, container: Container) -> T_co:
-        container = container.find_container(self.scope)
-        selected_key = self._function(**container.context)
-        if selected_key not in self._providers:
-            msg = f"No provider matches {selected_key}"
-            raise RuntimeError(msg)
-
-        return self._providers[selected_key].sync_resolve(container)

modern_di-0.16.2.dist-info/RECORD

@@ -1,25 +0,0 @@
-modern_di/__init__.py,sha256=L01VkzSJiV0d0FPrh1DZ-Wy5mUmoG6X-oLz7xYxtehI,194
-modern_di/container.py,sha256=sNHUGk8Y_eoQSLsSc-ZOqUBP2edsZwpifigcBH2Ka7g,5576
-modern_di/graph.py,sha256=X60wtG3Mqus_5YZNiZlQuXoHODBp7rYl_IHJs7GzSQM,1356
-modern_di/provider_state.py,sha256=oU08QnMr0yhIZKkz0Pee8_RnWtETDE9ux4JB83qhwTI,1358
-modern_di/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-modern_di/scope.py,sha256=e6Olc-CF89clbYDNGciy-F8EqJt1Mw2703zfuJaEY94,113
-modern_di/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-modern_di/helpers/attr_getter_helpers.py,sha256=HUjExWLRAz2h0YX2_h5xKPX9-_K3i-BZTeZb3u-Wq5k,221
-modern_di/providers/__init__.py,sha256=u19TXXMG0Ex8YsAnLzsf2mz3K78zEFVLBT_SiD51Dyw,873
-modern_di/providers/abstract.py,sha256=cRMTL09RRFzgtfzDu7Ba1qkcJ8uQ00WJ1xtDBZbWYhU,5873
-modern_di/providers/async_factory.py,sha256=eW7Y517NwUg_lov6YccCaBNUNuOEVEfQbAXjDQ-DUOI,1075
-modern_di/providers/async_singleton.py,sha256=DIrix--RxrfDJfjP1OaTqk7-NNrG2MCQIt_wCaF2O3I,1649
-modern_di/providers/container_provider.py,sha256=r5IEQXgKtPwvHvbqkbPnmGyDGGCCjokTtdard9Rvt40,548
-modern_di/providers/context_adapter.py,sha256=_b1x3ToQPWT-9KkDioFhw1W8Q1VXZYUnczfYzMTobVA,760
-modern_di/providers/dict.py,sha256=k_6BH51xyyE1dJmk-cJG3Qzssyf8M90zgD7dEtLF3LI,856
-modern_di/providers/factory.py,sha256=uQOZ7-_thFUsWE13JeBpJYkQa-e9tt__1tJF4u92WvY,1492
-modern_di/providers/injected_factory.py,sha256=KkDww-zUgm41LFt5j8crRzzFuBSkmKvOfptzHWMgVok,1848
-modern_di/providers/list.py,sha256=Y9rcAWR50EvV8ns8HYAw2ZMJbSASjmMBkr_SZXb8uhc,774
-modern_di/providers/object.py,sha256=Sm0mb3Ua7cZ5Ay65fLvl7fnJDSQrQZwvzio3lkkXP2A,825
-modern_di/providers/resource.py,sha256=jEP6Ppr0gmdgWaQGF4sU2PIdt5xSzxcSDubC_IqxE1k,4559
-modern_di/providers/selector.py,sha256=8WCqdaIxb2SNp-hKs1F9pfW0v3PdFr2IfH9VGMxWejs,1417
-modern_di/providers/singleton.py,sha256=gfJvAQ7L0JBYlhrzKvaYYDiWo8MPbp0CCU8hGtuzs7U,2357
-modern_di-0.16.2.dist-info/METADATA,sha256=pjeBhf9ylEBUnbv6FNt161UCxlMuOAKMogo-n7s34pU,3382
-modern_di-0.16.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-modern_di-0.16.2.dist-info/RECORD,,