Add @wiring.injected to auto-injected methods

This @wiring.injected decorator does not require wiring.wire() to
patch a method. This implementation also adds support for
positional-only arguments.

Author: scottzach1

README.md

@@ -10,15 +10,12 @@ A simple Python dependency injection framework.
 from pif import wiring, providers
 
 
-def my_function(a: str = providers.Singleton[str](lambda: "hello wolrd")):
+@wiring.injected
+def my_function(a: str = providers.Singleton[str](lambda: "hello world")):
     return a
 
 
 if __name__ == '__main__':
-    assert isinstance(my_function(), providers.Singleton)
-
-    wiring.wire([__name__])
-
     assert "hello world" == my_function()
 ```
 

pif/wiring.py

@@ -11,28 +11,57 @@
 import functools
 import importlib
 import inspect
+import itertools
 import types
-from typing import Callable
+from typing import Any, Callable
 
 from pif import providers
 
 
-def patch_args_decorator[T: Callable](func: T, patched_kwargs: dict[str, providers.Provider]) -> T:
+def patch_args(
+    signature: inspect.Signature,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+) -> tuple[tuple[Any, ...], dict[str, Any]]:
     """
-    Get a decorated copy of `func` with patched arguments.
+    Patch the args and kwargs at runtime using the signature for reference.
 
-    TODO(scottzach1) - add support for positional kwargs.
+    :param signature: to lookup method parameters.
+    :param args: provided at runtime
+    :param kwargs: provided at runtime.
+    :return: injected args and kwargs to pass to func.
+    """
+    for i, (name, value) in enumerate(signature.parameters.items()):
+        if isinstance(value.default, providers.Provider) and i >= len(args):
+            if value.kind == inspect.Parameter.POSITIONAL_ONLY:
+                args = (
+                    *args,
+                    *(p.default for p in itertools.islice(signature.parameters.values(), len(args), i)),
+                    value.default(),
+                )
+            if (
+                value.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
+                and name not in kwargs
+            ):
+                kwargs[name] = value.default()
+    return args, kwargs
+
+
+def injected[T: Callable](func: T) -> T:
+    """
+    Get a decorated copy of `func` with patched arguments.
 
     :param func: to decorate.
-    :param patched_kwargs: the kwargs to patch.
     :return: the decorated function.
     """
+    signature = inspect.signature(func)
+
+    if not any(p for p in signature.parameters.values() if isinstance(p.default, providers.Provider)):
+        return func
 
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
-        for keyword in patched_kwargs:
-            if keyword not in kwargs:
-                kwargs[keyword] = patched_kwargs[keyword]()
+        args, kwargs = patch_args(signature, args, kwargs)
 
         return func(*args, **kwargs)
 
@@ -54,22 +83,13 @@ def patch_method[T: Callable | types.FunctionType](func: T) -> T:
     """
     Return a "patched" version of the method provided.
 
-    If no values required patching, the provided function will be returned unchanged..
+    If no values required patching, the provided function will be returned unchanged.
 
     :param func: to patch default values.
     :return: a "patched" version of the method provided.
     """
-    patched_args = {}
-
-    for name, value in inspect.signature(func).parameters.items():
-        if value.kind == inspect.Parameter.POSITIONAL_ONLY:
-            continue  # TODO(scottzach1) Add support for non keyword arguments.
-
-        if isinstance(value.default, providers.Provider):
-            patched_args[name] = value.default
-
-    if patched_args:
-        return patch_args_decorator(func, patched_args)
+    if any(1 for param in inspect.signature(func).parameters.values() if isinstance(param.default, providers.Provider)):
+        return injected(func)
 
     return func
 

pyproject.toml

@@ -25,7 +25,7 @@ select = [
     "SIM", # flake8-simplify
     "I", # isort
 ]
-
+ignore = ["B008"]
 fixable = ["ALL"]
 
 [build-system]

tests/test_wiring.py

@@ -3,10 +3,12 @@
 
 from pif import providers, wiring
 
-provider = providers.Singleton[str](lambda: "hello")
 
+def provide(s: str) -> providers.Singleton[str]:
+    return providers.Singleton[str](lambda: f"{s}_injected")
 
-def my_func(a: str = provider):
+
+def my_func(a: str = provide("a")):
     """
     Our dummy method to test wiring for the module.
     """
@@ -19,21 +21,21 @@ def test_patch_kwarg():
     """
     sig_before = inspect.signature(my_func)
     doc_before = my_func.__doc__
-    assert provider == my_func()
+    assert isinstance(my_func(), providers.Singleton)
     assert not wiring.is_patched(my_func)
 
     wiring.wire([__name__])
     sig_wired = inspect.signature(my_func)
     doc_wired = my_func.__doc__
-    assert my_func() == "hello"
+    assert my_func() == "a_injected"
     assert sig_before == sig_wired
     assert doc_before == doc_wired
     assert wiring.is_patched(my_func)
 
     wiring.unwire([__name__])
     sig_unwired = inspect.signature(my_func)
     doc_unwired = my_func.__doc__
-    assert provider == my_func()
+    assert isinstance(my_func(), providers.Singleton)
     assert not wiring.is_patched(my_func)
     assert sig_before == sig_unwired
     assert doc_before == doc_unwired
@@ -44,17 +46,78 @@ def test_patch_lazy():
     Test that our wiring implementation lazily evaluates providers.
     """
     mock = MagicMock()
-
-    def func(v=None):
-        return v
-
-    assert not mock.call_count
-    patched = wiring.patch_args_decorator(func, {"v": mock})
     assert not mock.call_count
 
-    assert func() is None
+    @wiring.injected
+    def func(v=providers.Singleton[MagicMock](lambda: mock)):
+        return v()
+
     assert not mock.call_count
-    assert isinstance(patched(), MagicMock)
+    assert isinstance(func(), MagicMock)
     assert mock.call_count == 1
-    assert isinstance(patched(), MagicMock)
+    assert isinstance(func(), MagicMock)
     assert mock.call_count == 2
+
+
+def test_patch_positional_only():
+    """
+    Test patching for POSITIONAL_ONLY arguments.
+    """
+
+    @wiring.injected
+    def p1(a, b=provide("b"), c="c_default", /):
+        return a, b, c
+
+    assert p1(None) == (None, "b_injected", "c_default")
+    assert p1(None, None) == (None, None, "c_default")
+
+    @wiring.injected
+    def p2(a, b=None, c=provide("c"), /):
+        return a, b, c
+
+    assert p2(None) == (None, None, "c_injected")
+    assert p2(None, None) == (None, None, "c_injected")
+    assert p2(None, None, "c_override") == (None, None, "c_override")
+
+
+def test_patch_positional():
+    """
+    Test patching for POSITIONAL_OR_KEYWORD arguments.
+    """
+
+    @wiring.injected
+    def p1(a, b=provide("b"), c="c_default"):
+        return a, b, c
+
+    assert p1(None) == (None, "b_injected", "c_default")
+    assert p1(None, None) == (None, None, "c_default")
+    assert p1(a=None) == (None, "b_injected", "c_default")
+    assert p1(a=None, b=None) == (None, None, "c_default")
+
+    @wiring.injected
+    def p2(a, b=None, c=provide("c")):
+        return a, b, c
+
+    assert p2(None) == (None, None, "c_injected")
+    assert p2(None, None) == (None, None, "c_injected")
+    assert p2(None, None, "c_override") == (None, None, "c_override")
+    assert p2(a=None) == (None, None, "c_injected")
+    assert p2(a=None, b=None) == (None, None, "c_injected")
+    assert p2(a=None, b=None, c="c_override") == (None, None, "c_override")
+
+
+def test_patch_positional_or_keyword():
+    """
+    Test patching for VAR_POSITIONAL argument.
+    """
+
+    @wiring.injected
+    def p1(a, b=provide("b"), *c, d="d_default", e=provide("e")):
+        return a, b, *c, d, e
+
+    assert p1("a") == ("a", "b_injected", "d_default", "e_injected")
+    assert p1("a", "b") == ("a", "b", "d_default", "e_injected")
+    assert p1("a", "b", "c1") == ("a", "b", "c1", "d_default", "e_injected")
+    assert p1("a", "b", "c1", "c2") == ("a", "b", "c1", "c2", "d_default", "e_injected")
+    assert p1("a", "b", "c1", "c2", d="d") == ("a", "b", "c1", "c2", "d", "e_injected")
+    assert p1("a", "b", "c1", "c2", d="d", e="e") == ("a", "b", "c1", "c2", "d", "e")