feat: ✨ Allow Pydantic injectable

Author: remimd

documentation/basic-usage.md

@@ -17,12 +17,13 @@ If you wish to inject a new instance each time, use `injectable` decorator.
 ```python
 from injection import injectable
 
-
 @injectable
 class Injectable:
     """ class implementation """
 ```
 
+> **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
+
 ## Inject an instance
 
 To inject one or several instances, use `inject` decorator.
@@ -50,6 +51,9 @@ class DataClass:
     instance: Injectable = ...
 ```
 
+> **Note**: Doesn't work with Pydantic `BaseModel` because the signature of the `__init__` method doesn't contain the
+> dependencies.
+
 ## Inheritance
 
 In the case of inheritance, you can use the decorator parameter `on` to link the injection to one or several other
@@ -99,16 +103,3 @@ from injection import singleton
 def my_recipe() -> Singleton:
     """ recipe implementation """
 ```
-
-## Auto inject
-
-By default, `injectable` and `singleton` decorators will automatically apply `@inject` to the decorated class or 
-function. To disable it, set the `auto_inject` parameter to `False`.
-
-```python
-from injection import singleton
-
-@singleton(auto_inject=False)
-class Singleton:
-    """ class implementation """
-```

injection/__init__.pyi

@@ -36,27 +36,23 @@ class Module:
         /,
         *,
         on: type | Iterable[type] = ...,
-        auto_inject: bool = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
         injectable will be constructed. At injection time, a new instance will be
-        injected each time. Automatically injects constructor dependencies, can be
-        disabled with `auto_inject=False`.
+        injected each time.
         """
     def singleton(
         self,
         wrapped: Callable[..., Any] = ...,
         /,
         *,
         on: type | Iterable[type] = ...,
-        auto_inject: bool = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
         singleton will be constructed. At injection time, the injected instance will
-        always be the same. Automatically injects constructor dependencies, can be
-        disabled with `auto_inject=False`.
+        always be the same.
         """
     def get_instance(self, cls: type[_T]) -> _T | None:
         """

injection/core/module.py

@@ -547,12 +547,8 @@ def __call__(
         /,
         *,
         on: type | Iterable[type] = None,
-        auto_inject: bool = True,
     ):
         def decorator(wp):
-            if auto_inject:
-                wp = self.__module.inject(wp)
-
             @lambda fn: fn()
             def classes():
                 if cls := self.__get_target_class(wp):
@@ -565,7 +561,12 @@ def classes():
                 else:
                     yield on
 
-            injectable = self.__injectable_type(wp)
+            @self.__module.inject
+            @wraps(wp, updated=())
+            def factory(*args, **kwargs):
+                return wp(*args, **kwargs)
+
+            injectable = self.__injectable_type(factory)
             self.__module.update(classes, injectable)
 
             return wp

poetry.lock

@@ -17,6 +17,7 @@ black = "*"
 blacksheep = "^2.0.4"
 flake8 = "*"
 isort = "*"
+pydantic = "^2.5.3"
 pytest = "*"
 pytest-asyncio = "*"
 pytest-cov = "*"

pyproject.toml

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 
 import pytest
+from pydantic import BaseModel
 
 from injection import get_instance, injectable
 
@@ -65,28 +66,32 @@ class C(B):
         assert isinstance(b, C)
         assert a is not b
 
-    def test_injectable_without_auto_inject_raise_type_error(self):
+    def test_injectable_with_inject(self):
         @injectable
         class A:
             ...
 
-        @injectable(auto_inject=False)
+        @injectable
         class B:
-            def __init__(self, a: A):
-                raise NotImplementedError
+            def __init__(self, __a: A):
+                self.a = __a
 
-        with pytest.raises(TypeError):
-            get_instance(B)
+        a = get_instance(A)
+        b = get_instance(B)
+        assert isinstance(a, A)
+        assert isinstance(b, B)
+        assert isinstance(b.a, A)
+        assert a is not b.a
 
-    def test_injectable_with_auto_inject(self):
+    def test_injectable_with_dataclass_and_inject(self):
         @injectable
         class A:
             ...
 
-        @injectable(auto_inject=True)
+        @injectable
+        @dataclass(frozen=True, slots=True)
         class B:
-            def __init__(self, __a: A):
-                self.a = __a
+            a: A
 
         a = get_instance(A)
         b = get_instance(B)
@@ -95,14 +100,13 @@ def __init__(self, __a: A):
         assert isinstance(b.a, A)
         assert a is not b.a
 
-    def test_injectable_with_dataclass_and_auto_inject(self):
+    def test_injectable_with_pydantic_model_and_inject(self):
         @injectable
-        class A:
+        class A(BaseModel):
             ...
 
-        @injectable(auto_inject=True)
-        @dataclass(frozen=True, slots=True)
-        class B:
+        @injectable
+        class B(BaseModel):
             a: A
 
         a = get_instance(A)
@@ -112,15 +116,15 @@ class B:
         assert isinstance(b.a, A)
         assert a is not b.a
 
-    def test_injectable_with_recipe_and_auto_inject(self):
+    def test_injectable_with_recipe_and_inject(self):
         @injectable
         class A:
             ...
 
         class B:
             ...
 
-        @injectable(auto_inject=True)
+        @injectable
         def recipe(__a: A) -> B:
             assert isinstance(__a, A)
             assert __a is not a

tests/test_injectable.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 
 import pytest
+from pydantic import BaseModel
 
 from injection import get_instance, singleton
 
@@ -65,28 +66,32 @@ class C(B):
         assert isinstance(b, C)
         assert a is b
 
-    def test_injectable_without_auto_inject_raise_type_error(self):
+    def test_singleton_with_inject(self):
         @singleton
         class A:
             ...
 
-        @singleton(auto_inject=False)
+        @singleton
         class B:
-            def __init__(self, a: A):
-                raise NotImplementedError
+            def __init__(self, __a: A):
+                self.a = __a
 
-        with pytest.raises(TypeError):
-            get_instance(B)
+        a = get_instance(A)
+        b = get_instance(B)
+        assert isinstance(a, A)
+        assert isinstance(b, B)
+        assert isinstance(b.a, A)
+        assert a is b.a
 
-    def test_singleton_with_auto_inject(self):
+    def test_singleton_with_dataclass_and_inject(self):
         @singleton
         class A:
             ...
 
-        @singleton(auto_inject=True)
+        @singleton
+        @dataclass(frozen=True, slots=True)
         class B:
-            def __init__(self, __a: A):
-                self.a = __a
+            a: A
 
         a = get_instance(A)
         b = get_instance(B)
@@ -95,14 +100,13 @@ def __init__(self, __a: A):
         assert isinstance(b.a, A)
         assert a is b.a
 
-    def test_singleton_with_dataclass_and_auto_inject(self):
+    def test_singleton_with_pydantic_model_and_inject(self):
         @singleton
-        class A:
+        class A(BaseModel):
             ...
 
-        @singleton(auto_inject=True)
-        @dataclass(frozen=True, slots=True)
-        class B:
+        @singleton
+        class B(BaseModel):
             a: A
 
         a = get_instance(A)
@@ -112,15 +116,15 @@ class B:
         assert isinstance(b.a, A)
         assert a is b.a
 
-    def test_singleton_with_recipe_and_auto_inject(self):
+    def test_singleton_with_recipe_and_inject(self):
         @singleton
         class A:
             ...
 
         class B:
             ...
 
-        @singleton(auto_inject=True)
+        @singleton
         def recipe(__a: A) -> B:
             assert isinstance(__a, A)
             assert __a is a