Injectinator 0.1.0__tar.gz

injectinator-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: Injectinator
+Version: 0.1.0
+Summary: Very simple dependency injection
+Author-email: Chris Read <centurix@gmail.com>
+License: MIT
+Project-URL: homepage, https://github.com/Centurix/injectinator
+Project-URL: repository, https://github.com/Centurix/injectinator
+Keywords: dependency,injection,di,decorator
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+![build workflow](https://github.com/Centurix/injectinator/actions/workflows/test.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![uv-managed](https://img.shields.io/badge/uv-managed-blueviolet)
+
+INJECTINATOR
+=
+
+Very Simple Dependency Injection.
+
+Here's the function, just paste it where you need it:
+
+```
+def injectinator(func):
+    def wrapper(*args, **kwargs):
+        replacements = dict(zip(
+            func.__code__.co_varnames[:func.__code__.co_argcount],
+            list(([None] * func.__code__.co_argcount) + list(func.__defaults__ or []))[-func.__code__.co_argcount:]
+        ))
+        for position, default in enumerate(replacements.keys()):
+            if position >= len(args):
+                if default not in kwargs and isinstance(replacements[default], type):
+                    kwargs[default] = replacements[default]()
+        return func(*args, **kwargs)
+    return wrapper
+```
+
+Need some kind of dependency injection but don't want a massive library adding to your
+dependency graph that introduces potential supply chain attacks? Well, this is what you need.
+
+This also doesn't need any imports to work. Just paste the script above here's an example of how to use it:
+
+```
+class BaseClass:
+    # You don't really need this base class, but for the sake of method contracts it's here 
+    def print(self):
+        ...
+
+class InjectedClass(BaseClass):
+    # This will be the default injected class if nothing is provided in a call
+    def print(self):
+        print("Default class")
+
+
+class SuppliedClass(BaseClass):
+    # This will be a supplied class
+    def print(self):
+        print("Supplied class")
+
+
+@injectinator
+def test(injected=InjectedClass):
+    # Can have as many parameters as you like, note that the class is a reference to the class, not an instance
+    injected.print()
+
+# Two calls, first creates an instance of InjectedClass and passes it to the function, second supplies an instance of SuppliedClass
+test()
+test(SuppliedClass())
+```
+
+Wait I hear you say: Can't we just create an instance of the class in the function specification like this?
+
+```
+def test(injected=InjectedClass()):
+    ...
+```
+
+You can, but the instantiation is performed when Python creates the definition of the function, not at the time you run
+the function. Which means that the object it creates is re-used every time you call the function, which is not desirable.
+
+Also, if you need to debug this, you might need to change it to:
+
+```
+import functools
+
+def injectinator(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        ...
+```
+
+This will retain the call stack and debugging easier. But as the script is below, you can add it without imports.
+
+Notes on this script
+-
+
+- It relies on dunder methods on `func` itself, so these _could_ change in the future. They've all been clumped up together for this reason to make it obvious when it fails because the Python foundation changed their usage of dunders
+- There is no parameter support on the injected class, it could be adjusted to support them
+- All the config for the injection is in the function specification rather than the decorator
+- There's no types. It should have types I guess. Probably added to the two function specifications. Could be lazy and just make it all `Any` but then you'd have to drag in `typing` as an import for this gist
+- I have not timed this. It could be wildly inefficient. There's an iteration enumerating over the function parameter list so its O(n)
+- This script does work with arbitrary length argument specifications like adding `*args` to the end
+- Although it is DI in 11 lines, I've no interest in code golf.
+
+Operation
+-
+
+1. Figure out what the default values are for each argument, dump the results in `replacements`
+1. Skip supplied positional values
+1. For arguments with a default value that do not have a keyword supplied value and the default is a class type, create an instance and add to the keyword argument dictionary
+1. Invoke the wrapped function/method with positional and keyword values

injectinator-0.1.0/README.md

@@ -0,0 +1,100 @@
+![build workflow](https://github.com/Centurix/injectinator/actions/workflows/test.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![uv-managed](https://img.shields.io/badge/uv-managed-blueviolet)
+
+INJECTINATOR
+=
+
+Very Simple Dependency Injection.
+
+Here's the function, just paste it where you need it:
+
+```
+def injectinator(func):
+    def wrapper(*args, **kwargs):
+        replacements = dict(zip(
+            func.__code__.co_varnames[:func.__code__.co_argcount],
+            list(([None] * func.__code__.co_argcount) + list(func.__defaults__ or []))[-func.__code__.co_argcount:]
+        ))
+        for position, default in enumerate(replacements.keys()):
+            if position >= len(args):
+                if default not in kwargs and isinstance(replacements[default], type):
+                    kwargs[default] = replacements[default]()
+        return func(*args, **kwargs)
+    return wrapper
+```
+
+Need some kind of dependency injection but don't want a massive library adding to your
+dependency graph that introduces potential supply chain attacks? Well, this is what you need.
+
+This also doesn't need any imports to work. Just paste the script above here's an example of how to use it:
+
+```
+class BaseClass:
+    # You don't really need this base class, but for the sake of method contracts it's here 
+    def print(self):
+        ...
+
+class InjectedClass(BaseClass):
+    # This will be the default injected class if nothing is provided in a call
+    def print(self):
+        print("Default class")
+
+
+class SuppliedClass(BaseClass):
+    # This will be a supplied class
+    def print(self):
+        print("Supplied class")
+
+
+@injectinator
+def test(injected=InjectedClass):
+    # Can have as many parameters as you like, note that the class is a reference to the class, not an instance
+    injected.print()
+
+# Two calls, first creates an instance of InjectedClass and passes it to the function, second supplies an instance of SuppliedClass
+test()
+test(SuppliedClass())
+```
+
+Wait I hear you say: Can't we just create an instance of the class in the function specification like this?
+
+```
+def test(injected=InjectedClass()):
+    ...
+```
+
+You can, but the instantiation is performed when Python creates the definition of the function, not at the time you run
+the function. Which means that the object it creates is re-used every time you call the function, which is not desirable.
+
+Also, if you need to debug this, you might need to change it to:
+
+```
+import functools
+
+def injectinator(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        ...
+```
+
+This will retain the call stack and debugging easier. But as the script is below, you can add it without imports.
+
+Notes on this script
+-
+
+- It relies on dunder methods on `func` itself, so these _could_ change in the future. They've all been clumped up together for this reason to make it obvious when it fails because the Python foundation changed their usage of dunders
+- There is no parameter support on the injected class, it could be adjusted to support them
+- All the config for the injection is in the function specification rather than the decorator
+- There's no types. It should have types I guess. Probably added to the two function specifications. Could be lazy and just make it all `Any` but then you'd have to drag in `typing` as an import for this gist
+- I have not timed this. It could be wildly inefficient. There's an iteration enumerating over the function parameter list so its O(n)
+- This script does work with arbitrary length argument specifications like adding `*args` to the end
+- Although it is DI in 11 lines, I've no interest in code golf.
+
+Operation
+-
+
+1. Figure out what the default values are for each argument, dump the results in `replacements`
+1. Skip supplied positional values
+1. For arguments with a default value that do not have a keyword supplied value and the default is a class type, create an instance and add to the keyword argument dictionary
+1. Invoke the wrapped function/method with positional and keyword values

injectinator-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "Injectinator"
+version = "0.1.0"
+description = "Very simple dependency injection"
+authors = [
+    {name = "Chris Read",email = "centurix@gmail.com"},
+]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = []
+license = {text = "MIT"}
+keywords = ["dependency", "injection", "di", "decorator"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries"
+]
+
+[project.urls]
+homepage = "https://github.com/Centurix/injectinator"
+repository = "https://github.com/Centurix/injectinator"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+]
+
+[tool.setuptools]
+license-files = []
+
+[tool.pytest.ini_options]
+pythonpath = [".", "src"]

injectinator-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

injectinator-0.1.0/src/Injectinator.egg-info/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: Injectinator
+Version: 0.1.0
+Summary: Very simple dependency injection
+Author-email: Chris Read <centurix@gmail.com>
+License: MIT
+Project-URL: homepage, https://github.com/Centurix/injectinator
+Project-URL: repository, https://github.com/Centurix/injectinator
+Keywords: dependency,injection,di,decorator
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+![build workflow](https://github.com/Centurix/injectinator/actions/workflows/test.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![uv-managed](https://img.shields.io/badge/uv-managed-blueviolet)
+
+INJECTINATOR
+=
+
+Very Simple Dependency Injection.
+
+Here's the function, just paste it where you need it:
+
+```
+def injectinator(func):
+    def wrapper(*args, **kwargs):
+        replacements = dict(zip(
+            func.__code__.co_varnames[:func.__code__.co_argcount],
+            list(([None] * func.__code__.co_argcount) + list(func.__defaults__ or []))[-func.__code__.co_argcount:]
+        ))
+        for position, default in enumerate(replacements.keys()):
+            if position >= len(args):
+                if default not in kwargs and isinstance(replacements[default], type):
+                    kwargs[default] = replacements[default]()
+        return func(*args, **kwargs)
+    return wrapper
+```
+
+Need some kind of dependency injection but don't want a massive library adding to your
+dependency graph that introduces potential supply chain attacks? Well, this is what you need.
+
+This also doesn't need any imports to work. Just paste the script above here's an example of how to use it:
+
+```
+class BaseClass:
+    # You don't really need this base class, but for the sake of method contracts it's here 
+    def print(self):
+        ...
+
+class InjectedClass(BaseClass):
+    # This will be the default injected class if nothing is provided in a call
+    def print(self):
+        print("Default class")
+
+
+class SuppliedClass(BaseClass):
+    # This will be a supplied class
+    def print(self):
+        print("Supplied class")
+
+
+@injectinator
+def test(injected=InjectedClass):
+    # Can have as many parameters as you like, note that the class is a reference to the class, not an instance
+    injected.print()
+
+# Two calls, first creates an instance of InjectedClass and passes it to the function, second supplies an instance of SuppliedClass
+test()
+test(SuppliedClass())
+```
+
+Wait I hear you say: Can't we just create an instance of the class in the function specification like this?
+
+```
+def test(injected=InjectedClass()):
+    ...
+```
+
+You can, but the instantiation is performed when Python creates the definition of the function, not at the time you run
+the function. Which means that the object it creates is re-used every time you call the function, which is not desirable.
+
+Also, if you need to debug this, you might need to change it to:
+
+```
+import functools
+
+def injectinator(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        ...
+```
+
+This will retain the call stack and debugging easier. But as the script is below, you can add it without imports.
+
+Notes on this script
+-
+
+- It relies on dunder methods on `func` itself, so these _could_ change in the future. They've all been clumped up together for this reason to make it obvious when it fails because the Python foundation changed their usage of dunders
+- There is no parameter support on the injected class, it could be adjusted to support them
+- All the config for the injection is in the function specification rather than the decorator
+- There's no types. It should have types I guess. Probably added to the two function specifications. Could be lazy and just make it all `Any` but then you'd have to drag in `typing` as an import for this gist
+- I have not timed this. It could be wildly inefficient. There's an iteration enumerating over the function parameter list so its O(n)
+- This script does work with arbitrary length argument specifications like adding `*args` to the end
+- Although it is DI in 11 lines, I've no interest in code golf.
+
+Operation
+-
+
+1. Figure out what the default values are for each argument, dump the results in `replacements`
+1. Skip supplied positional values
+1. For arguments with a default value that do not have a keyword supplied value and the default is a class type, create an instance and add to the keyword argument dictionary
+1. Invoke the wrapped function/method with positional and keyword values

injectinator-0.1.0/src/Injectinator.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+src/Injectinator.egg-info/PKG-INFO
+src/Injectinator.egg-info/SOURCES.txt
+src/Injectinator.egg-info/dependency_links.txt
+src/Injectinator.egg-info/top_level.txt
+src/injectinator/__init__.py
+tests/test_inject.py

injectinator-0.1.0/src/Injectinator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

injectinator-0.1.0/src/Injectinator.egg-info/top_level.txt

@@ -0,0 +1 @@
+injectinator

injectinator-0.1.0/src/injectinator/__init__.py

@@ -0,0 +1,15 @@
+import functools  # This is only needed for debugging, you can remove
+
+def injectinator(func):
+    @functools.wraps(func)  # This is only needed for debugging, you can remove
+    def wrapper(*args, **kwargs):
+        replacements = dict(zip(
+            func.__code__.co_varnames[:func.__code__.co_argcount],
+            list(([None] * func.__code__.co_argcount) + list(func.__defaults__ or []))[-func.__code__.co_argcount:]
+        ))
+        for position, default in enumerate(replacements.keys()):
+            if position >= len(args):
+                if default not in kwargs and isinstance(replacements[default], type):
+                    kwargs[default] = replacements[default]()
+        return func(*args, **kwargs)
+    return wrapper

injectinator-0.1.0/tests/test_inject.py

@@ -0,0 +1,68 @@
+from src.injectinator import injectinator
+from abc import ABC, abstractmethod
+
+
+# Classes to test injection with
+class BaseClass(ABC):
+    @abstractmethod
+    def test_method(self, arg1: int = 1) -> int:
+        raise NotImplemented("test_method Not implemented")
+
+class ClassA(BaseClass):
+    def test_method(self, arg1: int = 1) -> int:
+        return arg1 + 1
+
+class ClassB(BaseClass):
+    def test_method(self, arg1: int = 1) -> int:
+        return arg1 + 2
+
+def test_inject_with_no_arguments_no_return():
+    """No arguments, no return"""
+    @injectinator
+    def function_to_test() -> None:
+        pass
+
+    result = function_to_test()
+    assert result is None
+
+def test_inject_with_no_arguments_int_return():
+    """No arguments, integer return"""
+    @injectinator
+    def function_to_test() -> int:
+        return 1
+
+    result = function_to_test()
+    assert type(result) == int
+    assert result == 1
+
+def test_inject_with_positional_arguments_int_return():
+    """One positional argument, integer return"""
+    @injectinator
+    def function_to_test(arg1: int) -> int:
+        return arg1
+
+    result = function_to_test(2)
+    assert type(result) == int
+    assert result == 2
+
+def test_inject_with_injected_argument_int_return():
+    """Positional argument with injected class and integer return"""
+    @injectinator
+    def function_to_test(arg1: int, arg2: BaseClass=ClassA) -> int:
+        return arg2.test_method(arg1)
+
+    result = function_to_test(0)
+    assert type(result) == int
+    assert result == 1
+
+    result = function_to_test(0, ClassB())
+    assert type(result) == int
+    assert result == 2
+
+    result = function_to_test(arg1=0)
+    assert type(result) == int
+    assert result == 1
+
+    result = function_to_test(arg1=0, arg2=ClassB())
+    assert type(result) == int
+    assert result == 2