modern-di 0.1.1__tar.gz → 0.2.0__tar.gz

modern_di-0.2.0/.readthedocs.yaml

@@ -0,0 +1,13 @@
+version: 2
+
+build:
+  os: "ubuntu-22.04"
+  tools:
+    python: "3.10"
+
+python:
+  install:
+    - requirements: docs/requirements.txt
+
+sphinx:
+  configuration: docs/conf.py

{modern_di-0.1.1 → modern_di-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: modern-di
-Version: 0.1.1
+Version: 0.2.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.1.1 → modern_di-0.2.0}/modern_di/resolvers/__init__.py

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

modern_di-0.2.0/modern_di/resolvers/factory.py

@@ -0,0 +1,36 @@
+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 Factory(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)
+
+        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:
+            return typing.cast(T_co, override)
+
+        return typing.cast(T_co, self._sync_build_creator(container))

{modern_di-0.1.1 → modern_di-0.2.0}/modern_di/resolvers/resource.py

@@ -46,13 +46,13 @@ class Resource(BaseCreatorResolver[T_co]):
             return typing.cast(T_co, override)
 
         resolver_state = container.fetch_resolver_state(
-            self.resolver_id, is_async_resource=self._is_async, is_lock_required=self._is_async
+            self.resolver_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 resolver_state.resolver_lock:
-            await resolver_state.resolver_lock.acquire()
+        assert resolver_state.resolver_lock
+        await resolver_state.resolver_lock.acquire()
 
         try:
             if resolver_state.instance is not None:
@@ -67,8 +67,7 @@ class Resource(BaseCreatorResolver[T_co]):
                 resolver_state.context_stack = contextlib.ExitStack()
                 resolver_state.instance = resolver_state.context_stack.enter_context(_intermediate_)
         finally:
-            if resolver_state.resolver_lock:
-                resolver_state.resolver_lock.release()
+            resolver_state.resolver_lock.release()
 
         return typing.cast(T_co, resolver_state.instance)
 

modern_di-0.1.1/modern_di/resolvers/factory.py → modern_di-0.2.0/modern_di/resolvers/singleton.py

@@ -9,7 +9,7 @@ T_co = typing.TypeVar("T_co", covariant=True)
 P = typing.ParamSpec("P")
 
 
-class Factory(BaseCreatorResolver[T_co]):
+class Singleton(BaseCreatorResolver[T_co]):
     __slots__ = [*BaseCreatorResolver.BASE_SLOTS, "_creator"]
 
     def __init__(
@@ -26,11 +26,21 @@ class Factory(BaseCreatorResolver[T_co]):
         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)
+        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)
 
-        resolver_state.instance = typing.cast(T_co, await self._async_build_creator(container))
+        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:

modern_di-0.2.0/tests/resolvers/test_factory.py

@@ -0,0 +1,87 @@
+import dataclasses
+
+import pytest
+
+from modern_di import Container, Scope, resolvers
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class SimpleCreator:
+    dep1: str
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class DependentCreator:
+    dep1: SimpleCreator
+
+
+app_factory = resolvers.Factory(Scope.APP, SimpleCreator, dep1="original")
+request_factory = resolvers.Factory(Scope.REQUEST, DependentCreator, dep1=app_factory.cast)
+
+
+async def test_app_factory() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        instance1 = await app_factory.async_resolve(app_container)
+        instance2 = await app_factory.async_resolve(app_container)
+        assert instance1 is not instance2
+
+    with Container(scope=Scope.APP) as app_container:
+        instance3 = app_factory.sync_resolve(app_container)
+        instance4 = app_factory.sync_resolve(app_container)
+        assert instance3 is not instance4
+        assert instance1 is not instance3
+
+
+async def test_request_factory() -> None:
+    with Container(scope=Scope.APP) as app_container:
+        with app_container.build_child_container() as request_container:
+            instance1 = request_factory.sync_resolve(request_container)
+            instance2 = request_factory.sync_resolve(request_container)
+            assert instance1 is not instance2
+
+        async with app_container.build_child_container() as request_container:
+            instance3 = await request_factory.async_resolve(request_container)
+            instance4 = await request_factory.async_resolve(request_container)
+            assert instance3 is not instance4
+
+        assert instance1 is not instance3
+
+
+async def test_app_factory_in_request_scope() -> None:
+    with Container(scope=Scope.APP) as app_container:
+        with app_container.build_child_container():
+            instance1 = await app_factory.async_resolve(app_container)
+
+        async with app_container.build_child_container():
+            instance2 = await app_factory.async_resolve(app_container)
+
+        assert instance1 is not instance2
+
+
+async def test_factory_overridden() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        instance1 = app_factory.sync_resolve(app_container)
+
+        app_factory.override(SimpleCreator(dep1="override"), container=app_container)
+
+        instance2 = app_factory.sync_resolve(app_container)
+        instance3 = await app_factory.async_resolve(app_container)
+        assert instance1 is not instance2
+        assert instance2 is instance3
+        assert instance2.dep1 != instance1.dep1
+
+        app_factory.reset_override(app_container)
+
+        instance4 = app_factory.sync_resolve(app_container)
+
+        assert instance4.dep1 == instance1.dep1
+
+        assert instance3 is not instance4
+
+
+async def test_factory_wrong_dependency_scope() -> None:
+    def some_factory(_: SimpleCreator) -> None: ...
+
+    request_factory_ = resolvers.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)

modern_di-0.2.0/tests/resolvers/test_singleton.py

@@ -0,0 +1,115 @@
+import asyncio
+import dataclasses
+import typing
+
+import pytest
+
+from modern_di import Container, Scope, resolvers
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class SimpleCreator:
+    dep1: str
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class DependentCreator:
+    dep1: SimpleCreator
+
+
+app_singleton = resolvers.Singleton(Scope.APP, SimpleCreator, dep1="original")
+request_singleton = resolvers.Singleton(Scope.REQUEST, DependentCreator, dep1=app_singleton.cast)
+
+
+async def test_app_singleton() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        singleton1 = await app_singleton.async_resolve(app_container)
+        singleton2 = await app_singleton.async_resolve(app_container)
+        assert singleton1 is singleton2
+
+    with Container(scope=Scope.APP) as app_container:
+        singleton3 = app_singleton.sync_resolve(app_container)
+        singleton4 = app_singleton.sync_resolve(app_container)
+        assert singleton3 is singleton4
+        assert singleton3 is not singleton1
+
+    async with Container(scope=Scope.APP) as app_container:
+        singleton5 = await app_singleton.async_resolve(app_container)
+        singleton6 = await app_singleton.async_resolve(app_container)
+        assert singleton5 is singleton6
+        assert singleton5 is not singleton3
+        assert singleton5 is not singleton1
+
+
+async def test_request_singleton() -> None:
+    with Container(scope=Scope.APP) as app_container:
+        with app_container.build_child_container() as request_container:
+            instance1 = request_singleton.sync_resolve(request_container)
+            instance2 = request_singleton.sync_resolve(request_container)
+            assert instance1 is instance2
+
+        async with app_container.build_child_container() as request_container:
+            instance3 = await request_singleton.async_resolve(request_container)
+            instance4 = await request_singleton.async_resolve(request_container)
+            assert instance3 is instance4
+
+        assert instance1 is not instance3
+
+
+async def test_app_singleton_in_request_scope() -> None:
+    with Container(scope=Scope.APP) as app_container:
+        with app_container.build_child_container():
+            singleton1 = await app_singleton.async_resolve(app_container)
+
+        async with app_container.build_child_container():
+            singleton2 = await app_singleton.async_resolve(app_container)
+
+        assert singleton1 is singleton2
+
+
+async def test_singleton_overridden() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        singleton1 = app_singleton.sync_resolve(app_container)
+
+        app_singleton.override(SimpleCreator(dep1="override"), container=app_container)
+
+        singleton2 = app_singleton.sync_resolve(app_container)
+        singleton3 = await app_singleton.async_resolve(app_container)
+
+        app_singleton.reset_override(app_container)
+
+        singleton4 = app_singleton.sync_resolve(app_container)
+
+        assert singleton2 is not singleton1
+        assert singleton2 is singleton3
+        assert singleton4 is singleton1
+
+
+async def test_singleton_race_condition() -> None:
+    calls: int = 0
+
+    async def create_resource() -> typing.AsyncIterator[str]:
+        nonlocal calls
+        calls += 1
+        await asyncio.sleep(0)
+        yield ""
+
+    resource = resolvers.Resource(Scope.APP, create_resource)
+    factory_with_resource = resolvers.Singleton(Scope.APP, SimpleCreator, dep1=resource.cast)
+
+    async def resolve_factory(container: Container) -> SimpleCreator:
+        return await factory_with_resource.async_resolve(container)
+
+    async with Container(scope=Scope.APP) as app_container:
+        client1, client2 = await asyncio.gather(resolve_factory(app_container), resolve_factory(app_container))
+
+    assert client1 is client2
+    assert calls == 1
+
+
+async def test_singleton_wrong_dependency_scope() -> None:
+    def some_factory(_: SimpleCreator) -> None: ...
+
+    request_singleton_ = resolvers.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)

modern_di-0.1.1/tests/resolvers/test_factory.py

@@ -1,115 +0,0 @@
-import asyncio
-import dataclasses
-import typing
-
-import pytest
-
-from modern_di import Container, Scope, resolvers
-
-
-@dataclasses.dataclass(kw_only=True, slots=True)
-class SimpleFactory:
-    dep1: str
-
-
-@dataclasses.dataclass(kw_only=True, slots=True)
-class RequestFactory:
-    dep1: SimpleFactory
-
-
-singleton = resolvers.Factory(Scope.APP, SimpleFactory, dep1="original")
-request_factory = resolvers.Factory(Scope.REQUEST, RequestFactory, dep1=singleton.cast)
-
-
-async def test_factory() -> None:
-    async with Container(scope=Scope.APP) as app_container:
-        singleton1 = await singleton.async_resolve(app_container)
-        singleton2 = await singleton.async_resolve(app_container)
-        assert singleton1 is singleton2
-
-    with Container(scope=Scope.APP) as app_container:
-        singleton3 = singleton.sync_resolve(app_container)
-        singleton4 = singleton.sync_resolve(app_container)
-        assert singleton3 is singleton4
-        assert singleton3 is not singleton1
-
-    async with Container(scope=Scope.APP) as app_container:
-        singleton5 = await singleton.async_resolve(app_container)
-        singleton6 = await singleton.async_resolve(app_container)
-        assert singleton5 is singleton6
-        assert singleton5 is not singleton3
-        assert singleton5 is not singleton1
-
-
-async def test_factory_in_request_scope() -> None:
-    with Container(scope=Scope.APP) as app_container:
-        with app_container.build_child_container() as request_container:
-            instance1 = request_factory.sync_resolve(request_container)
-            instance2 = request_factory.sync_resolve(request_container)
-            assert instance1 is instance2
-
-        async with app_container.build_child_container() as request_container:
-            instance3 = await request_factory.async_resolve(request_container)
-            instance4 = await request_factory.async_resolve(request_container)
-            assert instance3 is instance4
-
-        assert instance1 is not instance3
-
-
-async def test_app_scoped_factory_in_request_scope() -> None:
-    with Container(scope=Scope.APP) as app_container:
-        with app_container.build_child_container():
-            singleton1 = await singleton.async_resolve(app_container)
-
-        async with app_container.build_child_container():
-            singleton2 = await singleton.async_resolve(app_container)
-
-        assert singleton1 is singleton2
-
-
-async def test_factory_overridden() -> None:
-    async with Container(scope=Scope.APP) as app_container:
-        singleton1 = singleton.sync_resolve(app_container)
-
-        singleton.override(SimpleFactory(dep1="override"), container=app_container)
-
-        singleton2 = singleton.sync_resolve(app_container)
-        singleton3 = await singleton.async_resolve(app_container)
-
-        singleton.reset_override(app_container)
-
-        singleton4 = singleton.sync_resolve(app_container)
-
-        assert singleton2 is not singleton1
-        assert singleton2 is singleton3
-        assert singleton4 is singleton1
-
-
-async def test_factory_race_condition() -> None:
-    calls: int = 0
-
-    async def create_resource() -> typing.AsyncIterator[str]:
-        nonlocal calls
-        calls += 1
-        await asyncio.sleep(0)
-        yield ""
-
-    resource = resolvers.Resource(Scope.APP, create_resource)
-    factory_with_resource = resolvers.Factory(Scope.APP, SimpleFactory, dep1=resource.cast)
-
-    async def resolve_factory(container: Container) -> SimpleFactory:
-        return await factory_with_resource.async_resolve(container)
-
-    async with Container(scope=Scope.APP) as app_container:
-        client1, client2 = await asyncio.gather(resolve_factory(app_container), resolve_factory(app_container))
-
-    assert client1 == client2
-    assert calls == 1
-
-
-async def test_factory_wrong_dependency_scope() -> None:
-    def some_factory(_: SimpleFactory) -> None: ...
-
-    request_factory = resolvers.Factory(Scope.REQUEST, SimpleFactory, dep1="original")
-    with pytest.raises(RuntimeError, match="Scope of dependency cannot be more than scope of dependent"):
-        resolvers.Factory(Scope.APP, some_factory, request_factory.cast)