Evaluate Provider args and kwargs in Factory/Singleton providers

Author: scottzach1

pif/providers/factory.py

@@ -12,6 +12,7 @@
 from typing import Callable
 
 from pif.providers.provider import Provider
+from pif.wiring import intercept
 
 
 class Factory[T](Provider):
@@ -22,7 +23,7 @@ class Factory[T](Provider):
     __slots__ = ("_func", "_depends")
 
     def __init__(self, func: Callable[[...], T], *args, **kwargs):
-        self._func = functools.partial(func, *args, **kwargs)
+        self._func = functools.partial(intercept(func), *args, **kwargs)
 
     def _evaluate(self) -> T:
         return self._func()

pif/providers/singleton.py

@@ -12,19 +12,22 @@
 from typing import Callable
 
 from pif.providers.provider import Provider
+from pif.wiring import intercept
 
 UNSET = object()
 
 
 class Singleton[T](Provider):
     """
     Provide a singleton instance.
+
+    Note that overriding any provider arguments will not cause the singleton to reevaluate.
     """
 
     __slots__ = ("_func", "_func", "_result", "_depends")
 
     def __init__(self, func: Callable[[...], T], *args, **kwargs):
-        self._func = functools.partial(func, *args, **kwargs)
+        self._func = functools.partial(intercept(func), *args, **kwargs)
         self._result = UNSET
 
     def _evaluate(self) -> T:

pif/wiring.py

@@ -18,6 +18,21 @@
 from pif.providers.provider import Provider
 
 
+def intercept(func):
+    """
+    Intercepts the args and kwargs at runtime evaluating any Provider values.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(
+            *(a() if isinstance(a, Provider) else a for a in args),
+            **{k: v() if isinstance(v, Provider) else v for k, v in kwargs.items()},
+        )
+
+    return wrapper
+
+
 def patch_args(
     signature: inspect.Signature,
     args: tuple[Any, ...],

tests/test_providers.py

@@ -1,3 +1,5 @@
+from collections import namedtuple
+
 import pytest
 
 from pif import exceptions, providers
@@ -199,3 +201,109 @@ def test_factory():
 
     assert dict_alt == dict_1
     assert dict_alt is not dict_1
+
+
+def test_transitive_factory_wired():
+    """
+    Checking the factory provider evaluates Provider args and kwargs.
+    """
+    model = namedtuple("Model", "a b")
+
+    provider_a = providers.Factory[str](lambda: "a")
+    provider_b = providers.Factory[str](lambda: "b")
+
+    provider = providers.Factory[tuple](model, provider_a, b=provider_b)
+
+    assert provider_a() == "a"
+    assert provider_b() == "b"
+
+    model_1 = provider()
+    model_2 = provider()
+    assert model("a", "b") == model_1
+    assert model_1 == model_2
+    assert model_1 is not model_2
+
+
+def test_transitive_factory_override():
+    """
+    Checking the factory provider generates different value when Provider arg and kwarg is overridden.
+    """
+    model = namedtuple("Model", "a b")
+
+    provider_a = providers.Factory[str](lambda: "a")
+    provider_b = providers.Factory[str](lambda: "b")
+    assert provider_a() == "a"
+    assert provider_b() == "b"
+
+    provider = providers.Factory[tuple](model, provider_a, b=provider_b)
+
+    model_1 = provider()
+    model_2 = provider()
+    assert model("a", "b") == model_1
+    assert model_1 == model_2
+    assert model_1 is not model_2
+
+    with (
+        provider_a.override_existing("b"),
+        provider_b.override_existing("a"),
+    ):
+        assert provider_a() == "b"
+        assert provider_b() == "a"
+
+        model_3 = provider()
+        model_4 = provider()
+        assert model("b", "a") == model_3
+        assert model_3 == model_4
+        assert model_3 is not model_4
+
+    model_5 = provider()
+    model_6 = provider()
+    assert model("a", "b") == model_5
+    assert model_5 == model_6
+    assert model_5 is not model_6
+
+
+def test_transitive_singleton_wired():
+    """
+    Checking the singleton provider evaluates Provider args and kwargs.
+    """
+    model = namedtuple("Model", "a b")
+
+    provider_a = providers.Singleton[str](lambda: "a")
+    provider_b = providers.Singleton[str](lambda: "b")
+    assert provider_a() == "a"
+    assert provider_b() == "b"
+
+    provider = providers.Singleton[tuple](model, provider_a, provider_b)
+
+    model_1 = provider()
+    model_2 = provider()
+    assert model("a", "b") == model_1
+    assert model_1 == model_2
+    assert model_1 is model_2
+
+
+def test_transitive_singleton_override():
+    """
+    Checking the singleton provide retains cached value even when Provider arg and kwarg is overridden.
+    """
+    model = namedtuple("Model", "a b")
+
+    provider_a = providers.Singleton[str](lambda: "a")
+    provider_b = providers.Singleton[str](lambda: "b")
+    assert provider_a() == "a"
+    assert provider_b() == "b"
+
+    provider = providers.Singleton[tuple](model, provider_a, provider_b)
+
+    model_1 = provider()
+    model_2 = provider()
+    assert model("a", "b") == model_1
+    assert model_1 == model_2
+    assert model_1 is model_2
+
+    with (
+        provider_a.override_existing("b"),
+        provider_b.override_existing("a"),
+    ):
+        assert model_1 == provider()  # Overriding does not change the cached value.