Implement resource provider, async injections, fix mypy errors, add f…

…actory provider (#25)

Makefile

@@ -1,8 +1,8 @@
 test:
 	hatch test --cover --all --randomize
 
-#test-ci:
-	#pdm run pytest -rA tests --cov=src --cov-report term-missing --cov-report=xml --asyncio-mode=auto
+test3.8:
+	hatch test -i python="3.8" --cover --randomize
 
 test-py:
 	hatch test -i python="$(v)" --cover --randomize
@@ -50,4 +50,4 @@ release-minor:
 	make release
 
 mypy:
-	pdm run mypy src
+	pdm run mypy src tests

README.md

@@ -30,6 +30,7 @@ Easy dependency injection for all, works with Python 3.8-3.12. Main features and
 * support dependency injection via `Annotated` in `FastAPI`;
 * the code is fully typed and checked with [mypy](https://github.com/python/mypy);
 * **no third-party dependencies**;
+* support **async injections**;
 * no **wiring**;
 * the life cycle of objects (**scope**) is implemented by **providers**;
 * **overriding** dependencies for testing;

docs/dev/migration-from-dependency-injector.md

@@ -28,6 +28,3 @@ To **migrate**, follow these **steps**:
 * `from dependency_injector.containers import DeclarativeContainer` -> `from injection import DeclarativeContainer`;
 
 2. **Replace argument unpacking in the `override_providers` method call with direct argument passing**: `some_container.override_providers(**overrides)` -> `some_container.override_providers(overrides)`;
-
-
-3. **Replace the Factory provider with Transient**: `providers.Factory` -> `providers.Transient`'.

docs/integration-with-web-frameworks/litestar.md

@@ -1,4 +1,4 @@
-# Using with Litestar
+# Litestar
 
 In order to successfully inject dependencies into Litestar request handlers,
 make sure that the following points are completed:

docs/providers/coroutine.md

@@ -1,25 +1,28 @@
 # Coroutine
 
 **Coroutine** provider creates a coroutine.
+Can be resolved only with using the `async_resolve` method.
 
 ## Example
 
 ```python3
-import asyncio
+    import asyncio
+    from typing import Tuple
 
-from injection import DeclarativeContainer, providers
+    from injection import DeclarativeContainer, providers
 
+    async def coroutine(arg1: int, arg2: int) -> Tuple[int, int]:
+        return arg1, arg2
 
-async def coroutine(arg1, arg2):
-    await asyncio.sleep(0.1)
-    return arg1, arg2
+    class DIContainer(DeclarativeContainer):
+        provider = providers.Coroutine(coroutine, arg1=1, arg2=2)
 
+    arg1, arg2 = asyncio.run(DIContainer.provider.async_resolve())
+    assert (arg1, arg2) == (1, 2)
 
-class DIContainer(DeclarativeContainer):
-    provider = providers.Coroutine(coroutine, arg1=1, arg2=2)
-
+    async def main() -> None:
+        arg1, arg2 = await DIContainer.provider.async_resolve(arg1=500, arg2=600)
+        assert (arg1, arg2) == (500, 600)
 
-if __name__ == "__main__":
-    arg1, arg2 = asyncio.run(DIContainer.provider())
-    assert (arg1, arg2) == (1, 2)
+    asyncio.run(main())
 ```

docs/providers/factory.md

@@ -0,0 +1,42 @@
+# Factory
+
+**Factory** works exactly same as **Transient** provider.
+
+Also supports **asynchronous** dependencies.
+
+## Example
+
+```python3
+import asyncio
+from dataclasses import dataclass
+
+from injection import DeclarativeContainer, providers
+
+
+@dataclass
+class SomeClass:
+    field: Tuple[int, int]
+
+
+async def coroutine_func(arg1: int, arg2: int) -> Tuple[int, int]:
+    return arg1, arg2
+
+
+class DIContainer(DeclarativeContainer):
+    coroutine = providers.Coroutine(coroutine_func, arg1=1, arg2=2)
+    sync_factory = providers.Factory(SomeClass, field=(10, 20))
+    async_factory = providers.Factory(SomeClass, field=coroutine)
+
+
+async def main() -> None:
+    instance = await DIContainer.async_factory.async_resolve()
+    assert instance.field == (1, 2)
+
+
+instance1 = DIContainer.sync_factory()
+instance2 = DIContainer.sync_factory()
+
+assert instance1 is not instance2
+
+asyncio.run(main())
+```

docs/providers/resource.md

@@ -0,0 +1,3 @@
+# Resource
+
+soon...

docs/providers/transient.md

@@ -1,27 +1,43 @@
 # Transient
 
-**Transient** provider creates and returns a new object for each call.
+**Transient** provider creates and returns a **new object for each call**.
+You can pass any **callable** object as the first parameter.
+
+Also supports **asynchronous** dependencies.
 
 ## Example
 
 ```python3
+import asyncio
 from dataclasses import dataclass
 
 from injection import DeclarativeContainer, providers
 
 
 @dataclass
 class SomeClass:
-    field: str
+    field: Tuple[int, int]
+
+
+async def coroutine_func(arg1: int, arg2: int) -> Tuple[int, int]:
+    return arg1, arg2
 
 
 class DIContainer(DeclarativeContainer):
-    provider = providers.Transient(SomeClass, field="str_value")
+    coroutine = providers.Coroutine(coroutine_func, arg1=1, arg2=2)
+    sync_transient = providers.Transient(SomeClass, field=(10, 20))
+    async_transient = providers.Transient(SomeClass, field=coroutine)
+
+
+async def main() -> None:
+    instance = await DIContainer.async_transient.async_resolve()
+    assert instance.field == (1, 2)
+
 
+instance1 = DIContainer.sync_transient()
+instance2 = DIContainer.sync_transient()
 
-if __name__ == "__main__":
-    instance1 = DIContainer.provider()
-    instance2 = DIContainer.provider()
+assert instance1 is not instance2
 
-    assert instance1 is not instance2
+asyncio.run(main())
 ```

src/injection/__init__.py

@@ -4,3 +4,12 @@
 from injection.inject.auto_inject import auto_inject
 from injection.inject.inject import inject
 from injection.provide import Provide
+
+__all__ = [
+    "DeclarativeContainer",
+    "Provide",
+    "__version__",
+    "auto_inject",
+    "inject",
+    "providers",
+]

src/injection/base_container.py

@@ -7,7 +7,7 @@
     DuplicatedFactoryTypeAutoInjectionError,
     UnknownProviderTypeAutoInjectionError,
 )
-from injection.providers import Singleton
+from injection.providers import Resource, Singleton
 from injection.providers.base import BaseProvider
 from injection.providers.base_factory import BaseFactoryProvider
 
@@ -25,7 +25,7 @@ def instance(cls) -> "DeclarativeContainer":
         return cls.__instance
 
     @classmethod
-    def __get_providers(cls) -> Dict[str, BaseProvider[Any]]:
+    def _get_providers(cls) -> Dict[str, BaseProvider[Any]]:
         if cls.__providers is None:
             cls.__providers = {
                 member_name: member
@@ -35,14 +35,16 @@ def __get_providers(cls) -> Dict[str, BaseProvider[Any]]:
         return cls.__providers
 
     @classmethod
-    def _get_providers_generator(cls) -> Iterator[BaseProvider[Any]]:
-        for _, member in inspect.getmembers(cls):
-            if isinstance(member, BaseProvider):
-                yield member
+    def get_providers(cls) -> List[BaseProvider[Any]]:
+        return list(cls._get_providers().values())
 
     @classmethod
-    def get_providers(cls) -> List[BaseProvider[Any]]:
-        return list(cls.__get_providers().values())
+    def get_resource_providers(cls) -> List[Resource[Any]]:
+        return [
+            provider
+            for provider in cls.get_providers()
+            if isinstance(provider, Resource)
+        ]
 
     @classmethod
     @contextmanager
@@ -66,7 +68,7 @@ def override_providers(
         *,
         reset_singletons: bool = False,
     ) -> Iterator[None]:
-        current_providers = cls.__get_providers()
+        current_providers = cls._get_providers()
         current_provider_names = set(current_providers.keys())
         given_provider_names = set(providers_for_overriding.keys())
 
@@ -95,24 +97,22 @@ def override_providers(
 
     @classmethod
     def reset_singletons(cls) -> None:
-        providers_gen = cls._get_providers_generator()
+        providers_gen = cls.get_providers()
 
         for provider in providers_gen:
             if isinstance(provider, Singleton):
                 provider.reset()
 
     @classmethod
     def reset_override(cls) -> None:
-        providers = cls.__get_providers()
-
-        for provider in providers.values():
+        for provider in cls.get_providers():
             provider.reset_override()
 
     @classmethod
     def resolve_by_type(cls, type_: Type[Any]) -> Any:
         provider_factory_to_providers = defaultdict(list)
 
-        for provider in cls._get_providers_generator():
+        for provider in cls.get_providers():
             if not issubclass(type(provider), BaseFactoryProvider):
                 continue
 
@@ -129,3 +129,39 @@ def resolve_by_type(cls, type_: Type[Any]) -> Any:
                 return provider()
 
         raise UnknownProviderTypeAutoInjectionError(str(type_))
+
+    @classmethod
+    def init_resources(cls) -> None:
+        for provider in cls.get_resource_providers():
+            if not provider.async_mode:
+                provider()
+
+    @classmethod
+    async def init_resources_async(cls) -> None:
+        for provider in cls.get_resource_providers():
+            if provider.async_mode:
+                await provider.async_resolve()
+
+    @classmethod
+    def close_resources(cls) -> None:
+        for provider in cls.get_resource_providers():
+            if not provider.async_mode:
+                provider.close()
+
+    @classmethod
+    async def close_resources_async(cls) -> None:
+        for provider in cls.get_resource_providers():
+            if provider.async_mode:
+                await provider.async_close()
+
+    @classmethod
+    def close_function_scope_resources(cls) -> None:
+        for provider in cls.get_resource_providers():
+            if not provider.async_mode and provider.function_scope:
+                provider.close()
+
+    @classmethod
+    async def close_function_scope_resources_async(cls) -> None:
+        for provider in cls.get_resource_providers():
+            if provider.async_mode and provider.function_scope:
+                await provider.async_close()