Add barebones wiring.py implementation

Author: scottzach1

README.md

@@ -1 +1,29 @@
-# Injected
+# Python Injection Framework (PIF)
+
+A simple Python dependency injection framework.
+
+## Usage
+
+**This project is under active development. The following example does not represent the final state for the project.**
+
+```python
+from pif import wiring, providers
+
+
+def my_function(a: str = providers.Singleton[str](lambda: "hello wolrd")):
+    return a
+
+
+if __name__ == '__main__':
+    assert isinstance(my_function(), providers.Singleton)
+
+    wiring.wire([__name__])
+
+    assert "hello world" == my_function()
+```
+
+## Authors
+
+| [![Zac Scott](https://avatars.githubusercontent.com/u/38968222)](https://github.com/scottzach1) |
+|:------------------------------------------------------------------------------------------------|
+| [Zac Scott (scottzach1)](https://github.com/scottzach1)                                         |

pif/__init__.py

@@ -0,0 +1,56 @@
+#                  _   _                 _     _
+#    ___  ___ ___ | |_| |_ ______ _  ___| |__ / |
+#   / __|/ __/ _ \| __| __|_  / _` |/ __| '_ \| |
+#   \__ \ (_| (_) | |_| |_ / / (_| | (__| | | | |
+#   |___/\___\___/ \__|\__/___\__,_|\___|_| |_|_|
+#
+#        Zac Scott (github.com/scottzach1)
+#
+#  https://github.com/scottzach1/python-injector-framework
+
+import abc
+from typing import Callable
+
+
+class Provider[T](abc.ABC):
+    """
+    Signposts something that can be injected.
+    """
+
+    @abc.abstractmethod
+    def __call__(self, *args, **kwargs) -> T:
+        """
+        Evaluate the value to provide.
+        """
+
+
+class ExistingSingleton[T](Provider):
+    """
+    Provide an existing object instance.
+    """
+
+    def __init__(self, t: T):
+        self.t = t
+
+    def __call__(self) -> T:
+        return self.t
+
+
+UNSET = object()
+
+
+class Singleton[T](Provider):
+    """
+    Provide a singleton instance.
+    """
+
+    def __init__(self, func: Callable[[...], T], *args, **kwargs):
+        self._func = func
+        self._args = args
+        self._kwargs = kwargs
+        self._result = UNSET
+
+    def __call__(self) -> T:
+        if self._result is UNSET:
+            self._result = self._func(*self._args, **self._kwargs)
+        return self._result

pif/providers.py

@@ -0,0 +1,123 @@
+#                  _   _                 _     _
+#    ___  ___ ___ | |_| |_ ______ _  ___| |__ / |
+#   / __|/ __/ _ \| __| __|_  / _` |/ __| '_ \| |
+#   \__ \ (_| (_) | |_| |_ / / (_| | (__| | | | |
+#   |___/\___\___/ \__|\__/___\__,_|\___|_| |_|_|
+#
+#        Zac Scott (github.com/scottzach1)
+#
+#  https://github.com/scottzach1/python-injector-framework
+
+import functools
+import importlib
+import inspect
+import types
+from typing import Any, Callable
+
+from pif import providers
+
+
+def patch_args_decorator[T: Callable](func: T, patched_kwargs: dict[str, Any]) -> T:
+    """
+    Get a decorated copy of `func` with patched arguments.
+
+    TODO(scottzach1) - add support for positional kwargs.
+
+    :param func: to decorate.
+    :param patched_kwargs: the kwargs to patch.
+    :return: the decorated function.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        patched_kwargs.update(kwargs)
+        return func(*args, **patched_kwargs)
+
+    wrapper._patched_func = func
+    return wrapper
+
+
+def is_patched(func: Callable | types.FunctionType) -> bool:
+    """
+    Checks if a function has been "patched" by the `patch_args_decorator`
+
+    :param func: the function to check.
+    :return: True if patched, False otherwise.
+    """
+    return hasattr(func, "_patched_func")
+
+
+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..
+
+    :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)
+
+    return func
+
+
+def unpatch_method[T: Callable | types.FunctionType](func: T) -> T:
+    """
+    Get an "unpatched" copy of a method.
+
+    If the value was not patched, the provided function will be returned unchanged.
+
+    :param func: the function to unpatch.
+    :return: the unpatched provided function.
+    """
+    return getattr(func, "_patched_func", func)
+
+
+def wire(modules: list[types.ModuleType | str]) -> None:
+    """
+    Patch all methods in the module containing `Provide` default arguments.
+
+    :param modules: list of modules to wire.
+    """
+    for module in modules:
+        if isinstance(module, str):
+            module = importlib.import_module(module)
+
+        for name, obj in inspect.getmembers(module):
+            if inspect.isfunction(obj):
+                if obj is not (patched := patch_method(obj)):
+                    setattr(module, name, patched)
+            elif inspect.isclass(obj):
+                for method_name, method in inspect.getmembers(obj, inspect.isfunction):
+                    if method is not (patched := patch_method(method)):
+                        setattr(obj, method_name, patched)
+
+
+def unwire(modules: list[types.ModuleType]) -> None:
+    """
+    Unpatch all methods in the module containing `Provide` default arguments.
+
+    :param modules: list of modules to wire.
+    """
+    for module in modules:
+        if isinstance(module, str):
+            module = importlib.import_module(module)
+
+        for name, obj in inspect.getmembers(module):
+            if inspect.isfunction(obj):
+                if obj is not (unpatched := unpatch_method(obj)):
+                    setattr(module, name, unpatched)
+            elif inspect.isclass(obj):
+                for method_name, method in inspect.getmembers(obj, inspect.isfunction):
+                    if method is not (unpatched := unpatch_method(method)):
+                        setattr(obj, method_name, unpatched)

pif/wiring.py

@@ -0,0 +1,38 @@
+import inspect
+
+from pif import providers, wiring
+
+provider = providers.Singleton[str](lambda: "hello")
+
+
+def my_func(a: str = provider):
+    """
+    Our dummy method to test wiring for the module.
+    """
+    return a
+
+
+def test_patch_kwarg():
+    """
+    Test the very rudimentary wiring logic for a module.
+    """
+    sig_before = inspect.signature(my_func)
+    doc_before = my_func.__doc__
+    assert provider == my_func()
+    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 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 not wiring.is_patched(my_func)
+    assert sig_before == sig_unwired
+    assert doc_before == doc_unwired