modern-di 0.1.0__tar.gz

modern_di-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+name: main
+
+on:
+  push:
+    branches:
+      - main
+  pull_request: {}
+
+concurrency:
+  group: ${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+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
+      - 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.1.0/.github/workflows/publish.yml

@@ -0,0 +1,20 @@
+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.0/.gitignore

@@ -0,0 +1,22 @@
+# Generic things
+*.pyc
+*~
+__pycache__/*
+*.swp
+*.sqlite3
+*.map
+.vscode
+.idea
+.DS_Store
+.env
+.mypy_cache
+.pytest_cache
+.ruff_cache
+.coverage
+htmlcov/
+coverage.xml
+pytest.xml
+dist/
+.python-version
+.venv
+uv.lock

modern_di-0.1.0/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 {{ args }}
+
+publish:
+    rm -rf dist
+    uv build
+    uv publish --token $PYPI_TOKEN

modern_di-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 modern-python
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

modern_di-0.1.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.3
+Name: modern-di
+Version: 0.1.0
+Summary: Simple Dependency Injection framework
+Project-URL: repository, https://github.com/modern-python/that-depends
+Project-URL: docs, https://that-depends.readthedocs.io
+Author-email: Artur Shiriev <me@shiriev.ru>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dependency injector,di,ioc-container,mocks,python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.10
+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)
+[![GitHub stars](https://img.shields.io/github/stars/modern-python/modern-di)](https://github.com/modern-python/modern-di/stargazers)
+
+Dependency injection framework for Python inspired by `dependency-injector` and `dishka`.
+
+It is production-ready and gives you the following:
+- Simple DI framework with IOC-container.
+- Async and sync resolving.
+- Python 3.10-3.13 support.
+- Full coverage by types annotations (mypy in strict mode).
+- Overriding dependencies for tests.
+- Package with zero dependencies.
+
+📚 [Documentation](https://modern-di.readthedocs.io)

modern_di-0.1.0/README.md

@@ -0,0 +1,19 @@
+"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)
+[![GitHub stars](https://img.shields.io/github/stars/modern-python/modern-di)](https://github.com/modern-python/modern-di/stargazers)
+
+Dependency injection framework for Python inspired by `dependency-injector` and `dishka`.
+
+It is production-ready and gives you the following:
+- Simple DI framework with IOC-container.
+- Async and sync resolving.
+- Python 3.10-3.13 support.
+- Full coverage by types annotations (mypy in strict mode).
+- Overriding dependencies for tests.
+- Package with zero dependencies.
+
+📚 [Documentation](https://modern-di.readthedocs.io)

modern_di-0.1.0/docs/conf.py

@@ -0,0 +1,34 @@
+# Configuration file for the Sphinx documentation builder.
+
+# -- Project information
+project = "modern-di"
+copyright = "2024, Modern Python"
+author = "Modern Python Community"
+
+release = ""
+version = ""
+
+# -- General configuration
+extensions = [
+    "sphinx_copybutton",
+    "sphinx.ext.duration",
+    "sphinx.ext.doctest",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.intersphinx",
+    "myst_parser",
+]
+
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3/", None),
+    "sphinx": ("https://www.sphinx-doc.org/en/master/", None),
+}
+intersphinx_disabled_domains = ["std"]
+
+templates_path = ["_templates"]
+
+# -- Options for HTML output
+html_theme = "sphinx_rtd_theme"
+
+# -- Options for EPUB output
+epub_show_urls = "footnote"

modern_di-0.1.0/docs/dev/contributing.md

@@ -0,0 +1,19 @@
+# Contributing
+This is an opensource project, and we are opened to new contributors.
+
+## Getting started
+1. Make sure that you have [uv](https://docs.astral.sh/uv/) and [just](https://just.systems/) installed.
+2. Clone project:
+```
+git@github.com:modern-python/modern-di.git
+cd modern-di
+```
+3. Install dependencies running `just install`
+
+## Running linters
+`Ruff` and `mypy` are used for static analysis.
+
+Run all checks by command `just lint`
+
+## Running tests
+Run all tests by command `just test`

modern_di-0.1.0/docs/dev/development-notes.md

@@ -0,0 +1,25 @@
+# Development Notes
+## Base parts
+### Scope
+- any int enum, starting from 1 with step 1
+
+### Container
+- all states live in containers:
+  - resolved dependencies
+  - context stacks for resources
+  - overrides
+
+### Resolvers
+- completely stateless
+- if dependency is already saved or overridden in `Container`, returns it
+- otherwise build dependency and save it to `Container`
+- can have dependencies only the same or lower scope, check in init
+
+### Graph
+- Cannot be instantiated
+- Contains graph of `Resolvers`
+- Can initialize its resources and factories to container
+
+### Questions
+1. Thread-safety
+2. Configuration without global object

modern_di-0.1.0/docs/index.md

@@ -0,0 +1,11 @@
+```{include} ../README.md
+```
+
+```{eval-rst}
+.. toctree::
+    :maxdepth: 1
+    :caption: For developers
+
+    dev/development-notes
+    dev/contributing
+```

modern_di-0.1.0/docs/requirements.txt

@@ -0,0 +1,4 @@
+sphinx==7.*
+sphinx-rtd-theme==2.*
+myst-parser
+sphinx-copybutton

modern_di-0.1.0/modern_di/__init__.py

@@ -0,0 +1,11 @@
+from modern_di.container import Container
+from modern_di.graph import BaseGraph
+from modern_di.scope import Scope
+
+
+__all__ = [
+    "BaseGraph",
+    "Container",
+    "Scope",
+    "resolvers",
+]

modern_di-0.1.0/modern_di/container.py

@@ -0,0 +1,109 @@
+import contextlib
+import enum
+import types
+import typing
+
+from modern_di.resolver_state import ResolverState
+
+
+if typing.TYPE_CHECKING:
+    import typing_extensions
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+class Container(contextlib.AbstractAsyncContextManager["Container"]):
+    __slots__ = "scope", "parent_container", "_is_async", "_resolver_states", "_overrides"
+
+    def __init__(self, *, scope: enum.IntEnum, parent_container: typing.Optional["Container"] = 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._is_async: bool | None = None
+        self._resolver_states: dict[str, ResolverState[typing.Any]] = {}
+        self._overrides: dict[str, typing.Any] = {}
+
+    def _exit(self) -> None:
+        self._is_async = None
+        self._resolver_states = {}
+
+    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":
+        self._check_entered()
+
+        try:
+            new_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=new_scope, parent_container=self)
+
+    def find_container(self, scope: enum.IntEnum) -> "typing_extensions.Self":
+        container = self
+        while container.scope > scope and container.parent_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]:
+        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)
+
+        return self._resolver_states[resolver_id]
+
+    def override(self, resolver_id: str, override_object: object) -> None:
+        self._overrides[resolver_id] = override_object
+
+    def fetch_override(self, resolver_id: str) -> object | None:
+        return self._overrides.get(resolver_id)
+
+    def reset_override(self, resolver_id: str | None = None) -> None:
+        if resolver_id is None:
+            self._overrides = {}
+        else:
+            self._overrides.pop(resolver_id, None)
+
+    async def __aenter__(self) -> "Container":
+        self._is_async = True
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> None:
+        self._check_entered()
+        for resolver_state in reversed(self._resolver_states.values()):
+            await resolver_state.async_tear_down()
+        self._exit()
+
+    def __enter__(self) -> "Container":
+        self._is_async = False
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> None:
+        self._check_entered()
+        for resolver_state in reversed(self._resolver_states.values()):
+            resolver_state.sync_tear_down()
+        self._exit()

modern_di-0.1.0/modern_di/graph.py

@@ -0,0 +1,39 @@
+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.1.0/modern_di/resolver_state.py

@@ -0,0 +1,38 @@
+import asyncio
+import contextlib
+import typing
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+class ResolverState(typing.Generic[T_co]):
+    __slots__ = "context_stack", "instance", "resolver_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
+
+    async def async_tear_down(self) -> None:
+        if self.context_stack is None:
+            return
+
+        if isinstance(self.context_stack, contextlib.AsyncExitStack):
+            await self.context_stack.aclose()
+        else:
+            self.context_stack.close()
+        self.context_stack = None
+        self.instance = None
+
+    def sync_tear_down(self) -> None:
+        if self.context_stack is None:
+            return
+
+        if isinstance(self.context_stack, contextlib.AsyncExitStack):
+            msg = "Cannot tear down async context in `sync_tear_down`"
+            raise RuntimeError(msg)  # noqa: TRY004
+
+        self.context_stack.close()
+        self.context_stack = None
+        self.instance = None

modern_di-0.1.0/modern_di/resolvers/__init__.py

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

modern_di-0.1.0/modern_di/resolvers/base.py

@@ -0,0 +1,88 @@
+import abc
+import enum
+import itertools
+import typing
+import uuid
+
+from modern_di import Container
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+R = typing.TypeVar("R")
+P = typing.ParamSpec("P")
+
+
+class AbstractResolver(typing.Generic[T_co], abc.ABC):
+    BASE_SLOTS: typing.ClassVar = ["scope", "resolver_id"]
+
+    def __init__(self, scope: enum.IntEnum) -> None:
+        self.scope = scope
+        self.resolver_id: typing.Final = str(uuid.uuid4())
+
+    @abc.abstractmethod
+    async def async_resolve(self, container: Container) -> T_co:
+        """Resolve dependency asynchronously."""
+
+    @abc.abstractmethod
+    def sync_resolve(self, container: Container) -> T_co:
+        """Resolve dependency synchronously."""
+
+    def override(self, override_object: object, container: Container) -> None:
+        container.override(self.resolver_id, override_object)
+
+    def reset_override(self, container: Container) -> None:
+        container.reset_override(self.resolver_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"]
+
+    def __init__(
+        self,
+        scope: enum.IntEnum,
+        creator: typing.Callable[P, typing.Any],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> None:
+        super().__init__(scope)
+
+        if any(x.scope > self.scope for x in itertools.chain(args, kwargs.values()) if isinstance(x, AbstractResolver)):
+            msg = "Scope of dependency cannot be more than scope of dependent"
+            raise RuntimeError(msg)
+
+        self._creator: typing.Final = creator
+        self._args: typing.Final = args
+        self._kwargs: typing.Final = kwargs
+
+    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]
+            ),
+            **typing.cast(
+                P.kwargs,
+                {
+                    k: v.sync_resolve(container) if isinstance(v, AbstractResolver) else v
+                    for k, v in self._kwargs.items()
+                },
+            ),
+        )
+
+    async def _async_build_creator(self, container: Container) -> typing.Any:  # noqa: ANN401
+        return self._creator(
+            *typing.cast(
+                P.args,
+                [await x.async_resolve(container) if isinstance(x, AbstractResolver) else x for x in self._args],
+            ),
+            **typing.cast(
+                P.kwargs,
+                {
+                    k: await v.async_resolve(container) if isinstance(v, AbstractResolver) else v
+                    for k, v in self._kwargs.items()
+                },
+            ),
+        )

modern_di-0.1.0/modern_di/resolvers/factory.py

@@ -0,0 +1,46 @@
+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)
+
+        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 = typing.cast(T_co, await self._async_build_creator(container))
+        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)

modern_di-0.1.0/modern_di/resolvers/resource.py

@@ -0,0 +1,95 @@
+import contextlib
+import enum
+import inspect
+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 Resource(BaseCreatorResolver[T_co]):
+    __slots__ = [*BaseCreatorResolver.BASE_SLOTS, "_creator", "_args", "_kwargs", "_is_async"]
+
+    def _is_creator_async(
+        self,
+        _: contextlib.AbstractContextManager[T_co] | contextlib.AbstractAsyncContextManager[T_co],
+    ) -> typing.TypeGuard[contextlib.AbstractAsyncContextManager[T_co]]:
+        return self._is_async
+
+    def __init__(
+        self,
+        scope: enum.IntEnum,
+        creator: typing.Callable[P, typing.Iterator[T_co] | typing.AsyncIterator[T_co]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> None:
+        new_creator: typing.Any
+        if inspect.isasyncgenfunction(creator):
+            self._is_async = True
+            new_creator = contextlib.asynccontextmanager(creator)
+        elif inspect.isgeneratorfunction(creator):
+            self._is_async = False
+            new_creator = contextlib.contextmanager(creator)
+        else:
+            msg = "Unsupported resource type"
+            raise RuntimeError(msg)
+
+        super().__init__(scope, new_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_async_resource=self._is_async, is_lock_required=self._is_async
+        )
+        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()
+
+        try:
+            if resolver_state.instance is not None:
+                return typing.cast(T_co, resolver_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_)
+            else:
+                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()
+
+        return typing.cast(T_co, 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)
+
+        if self._is_async:
+            msg = "Async resource cannot be resolved synchronously"
+            raise RuntimeError(msg)
+
+        _intermediate_ = self._sync_build_creator(container)
+
+        resolver_state.context_stack = contextlib.ExitStack()
+        resolver_state.instance = resolver_state.context_stack.enter_context(
+            typing.cast(contextlib.AbstractContextManager[typing.Any], _intermediate_)
+        )
+
+        return typing.cast(T_co, resolver_state.instance)

modern_di-0.1.0/modern_di/scope.py

@@ -0,0 +1,8 @@
+import enum
+
+
+class Scope(enum.IntEnum):
+    APP = 1
+    REQUEST = 2
+    ACTION = 3
+    STEP = 4

modern_di-0.1.0/pyproject.toml

@@ -0,0 +1,80 @@
+[project]
+name = "modern-di"
+description = "Simple Dependency Injection framework"
+authors = [
+    { name = "Artur Shiriev", email = "me@shiriev.ru" },
+]
+readme = "README.md"
+requires-python = ">=3.10,<4"
+license = "MIT"
+keywords = ["di", "dependency injector", "ioc-container", "mocks", "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",
+]
+dynamic = ["version"]
+packages = [
+    { include = "modern_di" },
+]
+
+[project.urls]
+repository = "https://github.com/modern-python/that-depends"
+docs = "https://that-depends.readthedocs.io"
+
+[dependency-groups]
+dev = [
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+    "ruff",
+    "mypy",
+    "typing-extensions",
+]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[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.1.0/tests/creators.py

@@ -0,0 +1,22 @@
+import datetime
+import logging
+import typing
+
+
+logger = logging.getLogger(__name__)
+
+
+async def create_async_resource() -> typing.AsyncIterator[datetime.datetime]:
+    logger.debug("Async resource initiated")
+    try:
+        yield datetime.datetime.now(tz=datetime.timezone.utc)
+    finally:
+        logger.debug("Async resource destructed")
+
+
+def create_sync_resource() -> typing.Iterator[datetime.datetime]:
+    logger.debug("Resource initiated")
+    try:
+        yield datetime.datetime.now(tz=datetime.timezone.utc)
+    finally:
+        logger.debug("Resource destructed")

modern_di-0.1.0/tests/resolvers/test_factory.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 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)

modern_di-0.1.0/tests/resolvers/test_resource.py

@@ -0,0 +1,119 @@
+import asyncio
+import typing
+
+import pytest
+
+from modern_di import Container, Scope, resolvers
+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 def test_async_resource() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        async_resource1 = await async_resource.async_resolve(app_container)
+        async_resource2 = await async_resource.async_resolve(app_container)
+        assert async_resource1 is async_resource2
+
+    async with Container(scope=Scope.APP) as app_container:
+        async_resource3 = await async_resource.async_resolve(app_container)
+        async_resource4 = async_resource.sync_resolve(app_container)
+        assert async_resource3 is async_resource4
+        assert async_resource3 is not async_resource1
+
+
+async def test_async_resource_in_sync_container() -> None:
+    with (
+        Container(scope=Scope.APP) as app_container,
+        pytest.raises(RuntimeError, match="Resolving async resource in sync container is not allowed"),
+    ):
+        await async_resource.async_resolve(app_container)
+
+
+async def test_async_resource_calling_sync_exit() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        await async_resource.async_resolve(app_container)
+        with pytest.raises(RuntimeError, match="Cannot tear down async context in `sync_tear_down`"):
+            app_container.__exit__(None, None, None)
+
+
+async def test_sync_resource() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        sync_resource1 = await sync_resource.async_resolve(app_container)
+        sync_resource2 = await sync_resource.async_resolve(app_container)
+        assert sync_resource1 is sync_resource2
+
+    with Container(scope=Scope.APP) as app_container:
+        sync_resource3 = sync_resource.sync_resolve(app_container)
+        sync_resource4 = sync_resource.sync_resolve(app_container)
+        assert sync_resource3 is sync_resource4
+        assert sync_resource3 is not sync_resource1
+
+
+async def test_async_resource_overridden() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        async_resource1 = await async_resource.async_resolve(app_container)
+
+        async_resource.override("override", container=app_container)
+
+        async_resource2 = async_resource.sync_resolve(app_container)
+        async_resource3 = await async_resource.async_resolve(app_container)
+
+        app_container.reset_override()
+
+        async_resource4 = async_resource.sync_resolve(app_container)
+
+        assert async_resource2 is not async_resource1
+        assert async_resource2 is async_resource3
+        assert async_resource4 is async_resource1
+
+
+async def test_sync_resource_overridden() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        sync_resource1 = await sync_resource.async_resolve(app_container)
+
+        sync_resource.override("override", container=app_container)
+
+        sync_resource2 = sync_resource.sync_resolve(app_container)
+        sync_resource3 = await sync_resource.async_resolve(app_container)
+
+        app_container.reset_override()
+
+        sync_resource4 = sync_resource.sync_resolve(app_container)
+
+        assert sync_resource2 is not sync_resource1
+        assert sync_resource2 is sync_resource3
+        assert sync_resource4 is sync_resource1
+
+
+async def test_async_resource_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)
+
+    async def resolve_resource(container: Container) -> str:
+        return await resource.async_resolve(container)
+
+    async with Container(scope=Scope.APP) as app_container:
+        await asyncio.gather(resolve_resource(app_container), resolve_resource(app_container))
+
+    assert calls == 1
+
+
+async def test_resource_unsupported_creator() -> None:
+    with pytest.raises(RuntimeError, match="Unsupported resource type"):
+        resolvers.Resource(Scope.APP, None)  # type: ignore[arg-type]
+
+
+async def test_async_resource_sync_resolve() -> None:
+    async with Container(scope=Scope.APP) as app_container:
+        with pytest.raises(RuntimeError, match="Async resource cannot be resolved synchronously"):
+            async_resource.sync_resolve(app_container)

modern_di-0.1.0/tests/test_container.py

@@ -0,0 +1,41 @@
+import enum
+
+import pytest
+
+from modern_di import Container, Scope
+
+
+def test_container_wrong_init() -> None:
+    with pytest.raises(RuntimeError, match="Only first scope can be used without parent_container"):
+        Container(scope=Scope.REQUEST)
+
+
+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")
+
+
+async def test_container_build_child_async() -> None:
+    async with Container(scope=Scope.APP) as app_container, app_container.build_child_container() as request_container:
+        assert request_container.scope == Scope.REQUEST
+        assert app_container.scope == Scope.APP
+
+
+def test_container_build_child_sync() -> None:
+    with Container(scope=Scope.APP) as app_container, app_container.build_child_container() as request_container:
+        assert request_container.scope == Scope.REQUEST
+        assert app_container.scope == Scope.APP
+
+
+def test_container_scope_limit_reached() -> None:
+    class CustomScope(enum.IntEnum):
+        APP = 1
+        REQUEST = 2
+
+    with Container(scope=CustomScope.APP) as app_container, app_container.build_child_container() as request_container:
+        assert request_container.scope == CustomScope.REQUEST
+        assert app_container.scope == CustomScope.APP
+
+        with pytest.raises(RuntimeError, match="Max scope is reached, REQUEST"):
+            request_container.build_child_container()

modern_di-0.1.0/tests/test_graph.py

@@ -0,0 +1,39 @@
+import pytest
+
+from modern_di import BaseGraph, Container, Scope, resolvers
+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 def test_graph_async_resolve_creators() -> None:
+    class DIGraph(BaseGraph):
+        async_resource = async_resource
+        sync_resource = sync_resource
+
+    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
+
+
+def test_graph_sync_resolve_creators() -> None:
+    class DIGraph(BaseGraph):
+        sync_resource = sync_resource
+
+    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
+
+
+def test_graph_cannot_be_instantiated() -> None:
+    class DIGraph(BaseGraph):
+        sync_resource = sync_resource
+
+    with pytest.raises(RuntimeError, match="DIGraph cannot not be instantiated"):
+        DIGraph()