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

modern_di-0.1.1/.github/workflows/ci.yml → modern_di-0.2.1/.github/workflows/core-ci.yml

@@ -1,13 +1,21 @@
-name: main
+name: core ci
 
 on:
   push:
     branches:
       - main
-  pull_request: {}
+    paths:
+      - 'modern_di/**'
+      - 'tests/**'
+      - '.github/workflows/core-ci.yml'
+  pull_request:
+    paths:
+      - 'modern_di/**'
+      - 'tests/**'
+      - '.github/workflows/core-ci.yml'
 
 concurrency:
-  group: ${{ github.head_ref || github.run_id }}
+  group: ${{ github.head_ref || github.run_id }} core
   cancel-in-progress: true
 
 jobs:
@@ -19,7 +27,7 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
-          cache-dependency-glob: "**/pyproject.toml"
+          cache-dependency-glob: "pyproject.toml"
       - run: uv python install 3.10
       - run: just install lint-ci
 
@@ -39,13 +47,6 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
-          cache-dependency-glob: "**/pyproject.toml"
+          cache-dependency-glob: "pyproject.toml"
       - run: uv python install ${{ matrix.python-version }}
       - run: just install test . --cov=. --cov-report xml
-      - uses: codecov/codecov-action@v4.0.1
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-        with:
-          files: ./coverage.xml
-          flags: unittests
-          name: codecov-${{ matrix.python-version }}

modern_di-0.2.1/.github/workflows/fastapi-ci.yml

@@ -0,0 +1,54 @@
+name: fastapi ci
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'integrations/fastapi/**'
+      - '.github/workflows/fastapi-ci.yml'
+  pull_request:
+    paths:
+      - 'integrations/fastapi/**'
+      - '.github/workflows/fastapi-ci.yml'
+
+defaults:
+  run:
+    working-directory: integrations/fastapi
+
+concurrency:
+  group: ${{ github.head_ref || github.run_id }} fastapi
+  cancel-in-progress: false
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: extractions/setup-just@v2
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+          cache-dependency-glob: "pyproject.toml"
+      - run: uv python install 3.10
+      - run: just install lint-ci
+
+  pytest:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version:
+          - "3.10"
+          - "3.11"
+          - "3.12"
+          - "3.13"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: extractions/setup-just@v2
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+          cache-dependency-glob: "pyproject.toml"
+      - run: uv python install ${{ matrix.python-version }}
+      - run: just install test . --cov=. --cov-report xml

modern_di-0.2.1/.github/workflows/publish.yml

@@ -0,0 +1,37 @@
+name: Publish Package
+
+on:
+  release:
+    types:
+      - published
+
+jobs:
+  publish-core:
+    if: startsWith(github.ref_name, 'core')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: extractions/setup-just@v2
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+          cache-dependency-glob: "pyproject.toml"
+      - run: just publish
+        env:
+          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+
+  publish-fastapi:
+    if: startsWith(github.ref_name, 'fastapi')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: extractions/setup-just@v2
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+          cache-dependency-glob: "pyproject.toml"
+      - run: |
+          cd integrations/fastapi
+          just publish
+        env:
+          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}

modern_di-0.2.1/.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.2.1/Justfile

@@ -0,0 +1,23 @@
+default: install lint test
+
+install:
+    uv lock --upgrade
+    uv sync --all-extras --frozen
+
+lint:
+    uv run ruff format .
+    uv run ruff check . --fix
+    uv run mypy .
+
+lint-ci:
+    uv run ruff format . --check
+    uv run ruff check . --no-fix
+    uv run mypy .
+
+test *args:
+    uv run pytest tests {{ args }}
+
+publish:
+    rm -rf dist
+    uv build
+    uv publish --token $PYPI_TOKEN

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: modern-di
-Version: 0.1.1
+Version: 0.2.1
 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
@@ -19,7 +19,6 @@ Description-Content-Type: text/markdown
 
 "Modern-DI"
 ==
-[![Test Coverage](https://codecov.io/gh/modern-python/modern-di/branch/main/graph/badge.svg)](https://codecov.io/gh/modern-python/modern-di)
 [![MyPy Strict](https://img.shields.io/badge/mypy-strict-blue)](https://mypy.readthedocs.io/en/stable/getting_started.html#strict-mode-and-configuration)
 [![Supported versions](https://img.shields.io/pypi/pyversions/modern-di.svg)](https://pypi.python.org/pypi/modern-di)
 [![downloads](https://img.shields.io/pypi/dm/modern-di.svg)](https://pypistats.org/packages/modern-di)
@@ -27,7 +26,7 @@ Description-Content-Type: text/markdown
 
 Dependency injection framework for Python inspired by `dependency-injector` and `dishka`.
 
-It is production-ready and gives you the following:
+It is in early development state and gives you the following:
 - DI framework with IOC-container and scopes.
 - Async and sync resolving.
 - Python 3.10-3.13 support.

{modern_di-0.1.1 → modern_di-0.2.1}/README.md

@@ -1,6 +1,5 @@
 "Modern-DI"
 ==
-[![Test Coverage](https://codecov.io/gh/modern-python/modern-di/branch/main/graph/badge.svg)](https://codecov.io/gh/modern-python/modern-di)
 [![MyPy Strict](https://img.shields.io/badge/mypy-strict-blue)](https://mypy.readthedocs.io/en/stable/getting_started.html#strict-mode-and-configuration)
 [![Supported versions](https://img.shields.io/pypi/pyversions/modern-di.svg)](https://pypi.python.org/pypi/modern-di)
 [![downloads](https://img.shields.io/pypi/dm/modern-di.svg)](https://pypistats.org/packages/modern-di)
@@ -8,7 +7,7 @@
 
 Dependency injection framework for Python inspired by `dependency-injector` and `dishka`.
 
-It is production-ready and gives you the following:
+It is in early development state and gives you the following:
 - DI framework with IOC-container and scopes.
 - Async and sync resolving.
 - Python 3.10-3.13 support.

modern_di-0.2.1/integrations/fastapi/README.md

@@ -0,0 +1,6 @@
+"Modern-DI-FastAPI"
+==
+
+Integration of [Modern-DI](https://github.com/modern-python/modern-di) to FastAPI
+
+📚 [Documentation](https://modern-di.readthedocs.io)

modern_di-0.2.1/integrations/fastapi/modern_di_fastapi/__init__.py

@@ -0,0 +1,9 @@
+from modern_di_fastapi.depends import FromDI, setup_modern_di
+from modern_di_fastapi.middleware import ContainerMiddleware
+
+
+__all__ = [
+    "ContainerMiddleware",
+    "FromDI",
+    "setup_modern_di",
+]

modern_di-0.2.1/integrations/fastapi/modern_di_fastapi/depends.py

@@ -0,0 +1,24 @@
+import dataclasses
+import typing
+
+import fastapi
+import modern_di
+
+
+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]
+
+    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
+    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:
+    app.state.modern_di_container = container

modern_di-0.2.1/integrations/fastapi/modern_di_fastapi/middleware.py

@@ -0,0 +1,27 @@
+import typing
+
+import modern_di
+from starlette.requests import Request
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+
+class ContainerMiddleware:
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(
+        self,
+        scope: Scope,
+        receive: Receive,
+        send: Send,
+    ) -> None:
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        request = Request(scope, receive=receive, send=send)
+        context: dict[str, typing.Any] = {"request": request}
+
+        container: modern_di.Container = request.app.state.modern_di_container
+        async with container.build_child_container(context=context) as request_container:
+            request.state.modern_di_container = request_container
+            return await self.app(scope, receive, send)

modern_di-0.2.1/integrations/fastapi/pyproject.toml

@@ -0,0 +1,90 @@
+[project]
+name = "modern-di-fastapi"
+description = "Modern-DI integration for FastAPI"
+authors = [
+    { name = "Artur Shiriev", email = "me@shiriev.ru" },
+]
+readme = "README.md"
+requires-python = ">=3.10,<4"
+license = "MIT"
+keywords = ["DI", "dependency injector", "ioc-container", "FastAPI", "python"]
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+    "Topic :: Software Development :: Libraries",
+]
+packages = [
+    { include = "modern_di_fastapi" },
+]
+dynamic = ["version"]
+dependencies = [
+    "fastapi>=0.100",
+    "modern-di",
+]
+
+[project.urls]
+repository = "https://github.com/modern-python/modern-di"
+docs = "https://modern-di.readthedocs.io"
+
+[dependency-groups]
+dev = [
+    "httpx",
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+    "ruff",
+    "mypy",
+    "typing-extensions",
+    "asgi-lifespan",
+]
+
+[tool.uv.sources]
+modern-di = { path = "../../" }
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+fallback-version = "0"
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+
+[tool.ruff]
+fix = true
+unsafe-fixes = true
+line-length = 120
+target-version = "py310"
+extend-exclude = [
+    "docs",
+]
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "D1", # allow missing docstrings
+    "S101", # allow asserts
+    "TCH", # ignore flake8-type-checking
+    "FBT", # allow boolean args
+    "ANN101", # missing-type-self
+    "ANN102", # missing-type-cls
+    "D203", # "one-blank-line-before-class" conflicting with D211
+    "D213", # "multi-line-summary-second-line" conflicting with D212
+    "COM812", # flake8-commas "Trailing comma missing"
+    "ISC001", # flake8-implicit-str-concat
+]
+isort.lines-after-imports = 2
+isort.no-lines-before = ["standard-library", "local-folder"]
+
+[tool.pytest.ini_options]
+addopts = "--cov=. --cov-report term-missing"
+asyncio_mode = "auto"
+
+[tool.coverage.report]
+exclude_also = ["if typing.TYPE_CHECKING:"]

modern_di-0.2.1/integrations/fastapi/tests/test_fastapi_di.py

@@ -0,0 +1,69 @@
+import contextlib
+import dataclasses
+import typing
+
+import fastapi
+import httpx
+import modern_di
+import pytest
+from asgi_lifespan import LifespanManager
+from modern_di import Scope, resolvers
+from starlette import status
+from starlette.requests import Request
+
+import modern_di_fastapi
+from modern_di_fastapi import ContainerMiddleware, FromDI
+
+
+@contextlib.asynccontextmanager
+async def lifespan(app_: fastapi.FastAPI) -> typing.AsyncIterator[None]:
+    di_container = modern_di.Container(scope=modern_di.Scope.APP)
+    modern_di_fastapi.setup_modern_di(container=di_container, app=app_)
+    async with di_container:
+        yield
+
+
+app = fastapi.FastAPI(lifespan=lifespan)
+app.add_middleware(ContainerMiddleware)
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class SimpleCreator:
+    dep1: str
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class DependentCreator:
+    dep1: SimpleCreator
+
+
+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.get("/")
+async def read_root(
+    app_factory_instance: typing.Annotated[SimpleCreator, FromDI(app_factory)],
+    request_factory_instance: typing.Annotated[DependentCreator, FromDI(request_factory)],
+    method: typing.Annotated[str, FromDI(context_adapter)],
+) -> str:
+    assert isinstance(app_factory_instance, SimpleCreator)
+    assert isinstance(request_factory_instance, DependentCreator)
+    return method
+
+
+@pytest.fixture(scope="session")
+async def client() -> typing.AsyncIterator[httpx.AsyncClient]:
+    async with LifespanManager(app):
+        yield httpx.AsyncClient(app=app, base_url="http://test")
+
+
+async def test_read_main(client: httpx.AsyncClient) -> None:
+    response = await client.get("/")
+    assert response.status_code == status.HTTP_200_OK
+    assert response.json() == "GET"

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

@@ -14,15 +14,22 @@ T_co = typing.TypeVar("T_co", covariant=True)
 
 
 class Container(contextlib.AbstractAsyncContextManager["Container"]):
-    __slots__ = "scope", "parent_container", "_is_async", "_resolver_states", "_overrides"
+    __slots__ = "scope", "parent_container", "context", "_is_async", "_resolver_states", "_overrides"
 
-    def __init__(self, *, scope: enum.IntEnum, parent_container: typing.Optional["Container"] = None) -> None:
+    def __init__(
+        self,
+        *,
+        scope: enum.IntEnum,
+        parent_container: typing.Optional["Container"] = None,
+        context: dict[str, typing.Any] | None = None,
+    ) -> None:
         if scope.value != 1 and parent_container is None:
             msg = "Only first scope can be used without parent_container"
             raise RuntimeError(msg)
 
         self.scope = scope
         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._overrides: dict[str, typing.Any] = {}
@@ -30,13 +37,14 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
     def _exit(self) -> None:
         self._is_async = None
         self._resolver_states = {}
+        self._overrides = {}
 
     def _check_entered(self) -> None:
         if self._is_async is None:
             msg = "Enter the context first"
             raise RuntimeError(msg)
 
-    def build_child_container(self) -> "typing_extensions.Self":
+    def build_child_container(self, context: dict[str, typing.Any] | None = None) -> "typing_extensions.Self":
         self._check_entered()
 
         try:
@@ -45,7 +53,7 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
             msg = f"Max scope is reached, {self.scope.name}"
             raise RuntimeError(msg) from exc
 
-        return self.__class__(scope=new_scope, parent_container=self)
+        return self.__class__(scope=new_scope, parent_container=self, context=context)
 
     def find_container(self, scope: enum.IntEnum) -> "typing_extensions.Self":
         container = self

{modern_di-0.1.1 → modern_di-0.2.1}/modern_di/resolvers/__init__.py

@@ -1,11 +1,15 @@
 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/context_adapter.py

@@ -0,0 +1,31 @@
+import enum
+import typing
+
+from modern_di import Container
+from modern_di.resolvers import AbstractResolver
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+P = typing.ParamSpec("P")
+
+
+class ContextAdapter(AbstractResolver[T_co]):
+    __slots__ = [*AbstractResolver.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.sync_resolve(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 self._function(**container.context)

modern_di-0.2.1/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.1}/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.1/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.1.1 → modern_di-0.2.1}/pyproject.toml

@@ -41,10 +41,14 @@ build-backend = "hatchling.build"
 
 [tool.hatch.version]
 source = "vcs"
+fallback-version = "0"
 
 [tool.mypy]
 python_version = "3.10"
 strict = true
+exclude = [
+    "integrations",
+]
 
 [tool.ruff]
 fix = true
@@ -53,6 +57,7 @@ line-length = 120
 target-version = "py310"
 extend-exclude = [
     "docs",
+    "integrations"
 ]
 
 [tool.ruff.lint]

modern_di-0.2.1/tests/resolvers/test_context_adapter.py

@@ -0,0 +1,40 @@
+import datetime
+
+from modern_di import Container, Scope, resolvers
+
+
+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)
+
+
+async def test_context_adapter() -> None:
+    now = datetime.datetime.now(tz=datetime.timezone.utc)
+    async with Container(scope=Scope.APP, context={"now": now}) as app_container:
+        instance1 = await context_adapter.async_resolve(app_container)
+        instance2 = context_adapter.sync_resolve(app_container)
+        assert instance1 is instance2 is now
+
+
+async def test_context_adapter_in_request_scope() -> None:
+    now = datetime.datetime.now(tz=datetime.timezone.utc)
+    async with (
+        Container(scope=Scope.APP) as app_container,
+        app_container.build_child_container(context={"now": now}) as request_container,
+    ):
+        instance1 = await request_context_adapter.async_resolve(request_container)
+        instance2 = request_context_adapter.sync_resolve(request_container)
+        assert instance1 is instance2 is now
+
+
+async def test_context_adapter_override() -> None:
+    now = datetime.datetime.now(tz=datetime.timezone.utc)
+    async with Container(scope=Scope.APP, context={"now": now}) as app_container:
+        instance1 = await context_adapter.async_resolve(app_container)
+        context_adapter.override(datetime.datetime.now(tz=datetime.timezone.utc), container=app_container)
+        instance2 = context_adapter.sync_resolve(app_container)
+        assert instance1 is now
+        assert instance2 is not now

modern_di-0.2.1/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.1/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/.github/workflows/publish.yml

@@ -1,20 +0,0 @@
-name: Publish Package
-
-on:
-  release:
-    types:
-      - published
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: extractions/setup-just@v2
-      - uses: astral-sh/setup-uv@v3
-        with:
-          enable-cache: true
-          cache-dependency-glob: "**/pyproject.toml"
-      - run: just publish
-        env:
-          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}

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)