reductable-params 0.1.0__tar.gz

reductable_params-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vizonex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

reductable_params-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: reductable-params
+Version: 0.1.0
+Summary: filters arbitrary paremeters before sending them off to be called
+Author-email: Vizonex <VizonexBusiness@gmail.com>
+Project-URL: repository, https://github.com/Vizonex/reductable-params.git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing_extensions; python_version < "3.14"
+Dynamic: license-file
+
+# reductable-params
+A low level Function packer & sender inspired by pluggy that is designed for mass sending
+as well as ignoring unneeded parameters before sending to a function allowing for large chainable callbacks to be possible in any configuration order.
+
+
+```python
+from reductable_params import reduce
+
+
+def test(a: int, b: str | None = None):
+    pass
+
+def child(a: int):
+    print(f"GOT {a}")
+
+def what_is_b(b: str | None):
+    print(f"B Is {b}")
+
+def main():
+    func = reduce(test)
+    # defaults can be installed before possibly sending 
+    # these to a child function.
+    data = func.install(1) # {"a": 1, b: None}
+    
+    child_func = reduce(child)
+
+    # Calling child_func will send itself off. 
+    # You can customize the data after installing it too.
+    # allowing for tons of creatives uses.
+    child_func(data) # B Parameter is ignored here.
+    # "GOT 1"
+
+    child_2 = reduce(what_is_b)
+    child_2(data)
+    # B Is None
+
+
+if __name__ == "__main__":
+    main()
+```
+
+## Benchmarks
+I decided to run benchmarks incase mainly to prove that this could be better than using `inspect.signature` alone and better for use on a mass scale when running the `install()` function.
+Note that smaller is better and that the timer is measured in seconds running `bench.py` which I have in this repo incase you want to see for yourself.
+
+<img src="install-benchmark.png"/>
+
+I'll add a comparison with pluggy in the future as soon as I get around to doing so.
+
+
+
+

reductable_params-0.1.0/README.md

@@ -0,0 +1,52 @@
+# reductable-params
+A low level Function packer & sender inspired by pluggy that is designed for mass sending
+as well as ignoring unneeded parameters before sending to a function allowing for large chainable callbacks to be possible in any configuration order.
+
+
+```python
+from reductable_params import reduce
+
+
+def test(a: int, b: str | None = None):
+    pass
+
+def child(a: int):
+    print(f"GOT {a}")
+
+def what_is_b(b: str | None):
+    print(f"B Is {b}")
+
+def main():
+    func = reduce(test)
+    # defaults can be installed before possibly sending 
+    # these to a child function.
+    data = func.install(1) # {"a": 1, b: None}
+    
+    child_func = reduce(child)
+
+    # Calling child_func will send itself off. 
+    # You can customize the data after installing it too.
+    # allowing for tons of creatives uses.
+    child_func(data) # B Parameter is ignored here.
+    # "GOT 1"
+
+    child_2 = reduce(what_is_b)
+    child_2(data)
+    # B Is None
+
+
+if __name__ == "__main__":
+    main()
+```
+
+## Benchmarks
+I decided to run benchmarks incase mainly to prove that this could be better than using `inspect.signature` alone and better for use on a mass scale when running the `install()` function.
+Note that smaller is better and that the timer is measured in seconds running `bench.py` which I have in this repo incase you want to see for yourself.
+
+<img src="install-benchmark.png"/>
+
+I'll add a comparison with pluggy in the future as soon as I get around to doing so.
+
+
+
+

reductable_params-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "reductable-params"
+dynamic = ["version"]
+description = "filters arbitrary paremeters before sending them off to be called"
+readme = "README.md"
+authors = [
+    { name = "Vizonex", email = "VizonexBusiness@gmail.com" }
+]
+requires-python = ">=3.9"
+dependencies = [
+    'typing_extensions;  python_version<"3.14"'
+]
+
+[build-system]
+requires = ["setuptools", "cython", "wheel"]
+
+[tool.setuptools.dynamic]
+version = {attr = "reductable_params.__version__"}
+
+[tool.setuptools]
+
+ext-modules = [
+{name="reductable_params._reduce_c", sources = ["src/reductable_params/_reduce_c.pyx"]}
+]
+
+[tool.ruff]
+line-length = 79
+target-version = "py310"
+exclude = [
+    ".git",
+    ".ruff_cache",
+    ".venv",
+    ".vscode",
+]
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle errors
+    "F",   # pyflakes
+    "I",   # isort (import sorting)
+    "RUF", # Ruff-specific rules
+    "W",   # pycodestyle warnings
+]
+
+
+[project.urls]
+    repository = "https://github.com/Vizonex/reductable-params.git"
+

reductable_params-0.1.0/setup.cfg

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

reductable_params-0.1.0/src/reductable_params/__init__.py

@@ -0,0 +1,6 @@
+from ._reduce import reduce
+from .abc import is_reducable
+
+__all__ = ("is_reducable", "reduce")
+__author__ = "Vizonex"
+__version__ = "0.1.0"

reductable_params-0.1.0/src/reductable_params/_reduce.py

@@ -0,0 +1,23 @@
+import os
+import sys
+
+NO_EXTENSIONS = bool(os.environ.get("REDUCTABLE_PARAMS_NO_EXTENSIONS"))  # type: bool
+if sys.implementation.name != "cpython":
+    NO_EXTENSIONS = True
+
+# isort: off
+if not NO_EXTENSIONS:  # pragma: no branch
+    try:
+        from ._reduce_c import reduce as reduce_c
+
+        reduce = reduce_c
+    except ImportError:  # pragma: no cover
+        from ._reduce_py import reduce as reduce_py
+
+        reduce = reduce_py
+
+else:
+    from ._reduce_py import reduce as reduce_py
+
+    reduce = reduce_py
+# isort: on

reductable_params-0.1.0/src/reductable_params/_reduce_c.pyi

@@ -0,0 +1,11 @@
+from collections.abc import Callable as Callable
+from typing import Any, Generic, ParamSpec, TypeVar
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+class reduce(Generic[P, T]):
+    __wrapped__: Callable[P, T]
+    def __init__(self, func: Callable[P, T]) -> None: ...
+    def install(self, *args: P.args, **kwargs: P.kwargs) -> dict[str, Any]: ...
+    def __call__(self, /, kwds: dict[str, Any]) -> T: ...

reductable_params-0.1.0/src/reductable_params/_reduce_c.pyx

@@ -0,0 +1,153 @@
+# cython: freethreading_compatible = True
+
+from types import GenericAlias
+
+cimport cython
+from cpython.dict cimport (
+    PyDict_Contains,
+    PyDict_Copy,
+    PyDict_GetItem,
+    PyDict_GetItemWithError,
+    PyDict_SetItem
+)
+from cpython.object cimport PyObject, PyObject_Call
+from cpython.set cimport PySet_Contains
+from cpython.tuple cimport (
+    PyTuple_GET_ITEM,
+    PyTuple_GET_SIZE,
+    PyTuple_New
+)
+
+from .abc import Reducable
+from .utils import varnames
+
+
+cdef extern from "Python.h":
+    object PyTuple_GetItemObj "PyTuple_GET_ITEM"(object p, Py_ssize_t pos) noexcept
+
+    void PyTuple_SetItemPtr "PyTuple_SET_ITEM"(object  p, Py_ssize_t pos, PyObject* val) noexcept
+    int PyDict_SetItemPtr "PyDict_SetItem"(object p, object key, PyObject* val) except -1
+    Py_ssize_t PyDict_GET_SIZE(dict p)
+
+# This should be enough callables for any decently sized application.
+DEF REDUCE_FREELIST_SIZE = 250 
+
+@cython.freelist(REDUCE_FREELIST_SIZE)
+cdef class reduce:
+    cdef:
+        public object __wrapped__
+        dict _defaults
+        str _name
+        Py_ssize_t _nargs, _nparams
+        tuple _optional
+        tuple _params
+        frozenset _param_set
+        tuple _required
+
+    __class_getitem__ = classmethod(GenericAlias)
+
+    def __init__(
+        self,
+        object func
+    ) -> None:
+        cdef tuple required
+        cdef dict optional
+        # The only bottlekneck is here when ititalizing althought this part is not planned to be benchmarked.
+        required, optional = varnames(func)
+
+        if name := getattr(func, "__name__", None):
+            self._name = f"{name}()"
+        else:
+            self._name = "function"
+
+        self.__wrapped__ = func
+        self._defaults = optional
+        self._nargs = len(required)
+        self._optional = tuple(optional.keys())
+        self._params = required + self._optional
+        self._param_set = frozenset(self._params)
+        self._nparams = len(self._params)
+        self._required = required
+
+    def install(self, *args, **kwargs):
+        r"""Simillar to `inspect.BoundArguments` but a little bit faster,
+        it is based off CPython's getargs.c's algorythms, this will also attempt to
+        install defaults if any are needed. However this does not allow arbitrary
+        arguments to be passed through. Instead, this should primarly be
+        used for writing callback utilities that require a parent function's signature.
+
+        :raises TypeError: if argument parsing fails or has a argument that overlaps in either args or kwargs.
+        """
+        # Mimics checks from vgetargskeywordsfast_impl in getargs.c
+        cdef Py_ssize_t nargs = PyTuple_GET_SIZE(args)
+        cdef Py_ssize_t ntotal = nargs +  PyDict_GET_SIZE(kwargs)
+        cdef Py_ssize_t n
+        cdef frozenset params = self._param_set
+        cdef object k, v
+        cdef dict output
+
+        if ntotal < self._nargs:
+            raise TypeError(f"Not enough params in {self._name}")
+
+        elif ntotal > self._nparams:
+            raise TypeError(
+                "%.200s takes at most %d %sargument%s (%i given)" % (
+                    self._name,
+                    self._nparams,
+                    "keyword" if not self._nargs else "",
+                    "" if self._nparams == 1 else "s",
+                    ntotal
+                )
+            )
+
+        # Begin parsing while checking for overlapping arguments and copy off all the defaults.
+
+        output = PyDict_Copy(self._defaults)
+        for n in range(nargs):
+            k = self._params[n]
+            if PyDict_Contains(kwargs, k):
+                # arg present in tuple and dict
+                raise TypeError(
+                    "argument for %.200s given by name ('%s') and position (%d)" % (
+                    self._name, k, n + 1
+                    )
+                )
+            PyDict_SetItemPtr(output, k, PyTuple_GET_ITEM(args, n))
+
+
+        # replace rest of the defaults with keyword arguments
+        for k, v in kwargs.items():
+            # force up a keyerror if object is not present in the
+            # actual defaults
+            if not PySet_Contains(params, k):
+                raise KeyError(k)
+            PyDict_SetItem(output, k, v)
+
+        return output
+
+    @cython.nonecheck(False)
+    def __call__(self, dict kwds):
+        """Calls reduction wrapper and calls function
+        while ignoring any unwanted arguments. This is useful
+        when chaining together callbacks with different function
+        formations."""
+
+        cdef dict kwargs = PyDict_Copy(self._defaults)
+        cdef tuple args = PyTuple_New(self._nargs)
+        cdef PyObject* v
+        cdef Py_ssize_t k
+
+        for k, key in enumerate(self._required):
+            v = PyDict_GetItemWithError(kwds, key)
+            PyTuple_SetItemPtr(args, k, v)
+
+        for key in self._params[self._nargs:]:
+            v = PyDict_GetItem(kwds, key)
+            if v != NULL:
+                PyDict_SetItemPtr(kwargs, key, v)
+
+        return PyObject_Call(self.__wrapped__, args, kwargs)
+
+
+Reducable.register(reduce)
+

reductable_params-0.1.0/src/reductable_params/_reduce_py.py

@@ -0,0 +1,119 @@
+from collections.abc import Callable
+from types import GenericAlias
+from typing import Any, Generic
+
+from .abc import P, Reducable, T
+from .utils import varnames
+
+
+class reduce(Generic[P, T]):
+    r"""reduceses arbitrary arguments being sent by only selecting
+    ones that make sense on sending. Useful when chaining together
+    callbacks where function's children may not need all arguments
+    incase callback signatures differ from the parent."""
+
+    __slots__ = (
+        "__wrapped__",
+        "_defaults",
+        "_name",
+        "_nargs",
+        "_nparams",
+        "_optional",
+        "_params",
+        "_params_set",
+        "_required",
+    )
+
+    __class_getitem__ = classmethod(GenericAlias)
+
+    def __init__(
+        self,
+        func: Callable[P, T],
+    ) -> None:
+        # if for some reason inspect wants to grab it, let it do so...
+        required, optional = varnames(func)
+
+        if name := getattr(func, "__name__", None):
+            self._name = f"{name}()"
+        else:
+            self._name = "function"
+
+        self.__wrapped__ = func
+        self._defaults = optional
+        self._nargs = len(required)
+        self._optional = tuple(optional.keys())
+        self._params = required + self._optional
+        self._nparams = len(self._params)
+        self._params_set = frozenset(self._params)
+        self._required = required
+
+    def install(self, *args: P.args, **kwargs: P.kwargs) -> dict[str, Any]:
+        r"""Simillar to `inspect.BoundArguments` but a little bit faster,
+        it is based off CPython's getargs.c's algorythms, this will also
+        attemptto install defaults if any are needed. However this does not
+        allow arbitrary arguments to be passed through. Instead, this should
+        primarlybe used for writing callback utilities that require a parent
+        function's signature.
+
+        :raises TypeError: if argument parsing fails or has a argument that
+            overlaps in either args or kwargs.
+        """
+
+        # Mimics checks from vgetargskeywordsfast_impl in getargs.c
+        ntotal = len(args) + len(kwargs)
+        if ntotal < self._nargs:
+            raise TypeError(f"Not enough params in {self._name}")
+
+        elif ntotal > self._nparams:
+            raise TypeError(
+                "%.200s takes at most %d %sargument%s (%i given)"
+                % (
+                    self._name,
+                    self._nparams,
+                    "keyword" if not self._nargs else "",
+                    "" if self._nparams == 1 else "s",
+                    ntotal,
+                )
+            )
+
+        # Begin parsing while checking for overlapping arguments and copy off
+        # all the defaults.
+
+        output = self._defaults.copy()
+        for n, v in enumerate(args):
+            k = self._params[n]
+            if k in kwargs:
+                # arg present in tuple and dict
+                raise TypeError(
+                    "argument for %.200s given by name ('%s') and position "
+                    "(%d)"
+                    % (self._name, k, n + 1)
+                )
+            output[k] = v
+
+        # replace rest of the defaults with keyword arguments
+        for k, v in kwargs.items():
+            # force up a keyerror if object is somehow
+            # not present in the actual defaults
+            if k not in self._params_set:
+                raise KeyError(k)
+            output[k] = v
+        return output
+
+    def __call__(self, kwds: dict[str, Any]) -> T:
+        """Calls reduction wrapper and calls function
+        while ignoring any unwanted arguments. This is useful
+        when chaining together callbacks with different function
+        formations."""
+
+        kwargs = self._defaults.copy()
+        args = [kwds[key] for key in self._required]
+
+        for k in self._params[self._nargs :]:
+            if k in kwargs:
+                kwargs[k] = kwds[k]
+
+        return self.__wrapped__(*args, **kwargs)
+
+
+Reducable.register(reduce)

reductable_params-0.1.0/src/reductable_params/abc.py

@@ -0,0 +1,38 @@
+import sys
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
+
+if sys.version_info < (3, 10):
+    from typing_extensions import ParamSpec
+else:
+    from typing import ParamSpec
+
+if sys.version_info < (3, 13):
+    from typing_extensions import TypeIs
+else:
+    from typing import TypeIs
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+# Mostly added for pytest's sake but also to prevent breaking
+# if cython is utilized with reducable params but a python version
+# is exposed sort of scenario.
+
+
+class Reducable(Generic[P, T], ABC):
+    __wrapped__: Callable[P, T]
+
+    @abstractmethod
+    def __init__(self, func: Callable[P, T]) -> None: ...
+    @abstractmethod
+    def install(self, *args: P.args, **kwargs: P.kwargs) -> dict[str, Any]: ...
+    @abstractmethod
+    def __call__(self, /, kwds: dict[str, Any]) -> T: ...
+
+
+def is_reducable(obj: object) -> TypeIs[Reducable]:
+    """Used for inspecting to see if a type belongs to a `reduce`
+    class-like object"""
+    return isinstance(obj, Reducable)

reductable_params-0.1.0/src/reductable_params/utils.py

@@ -0,0 +1,94 @@
+import inspect
+import sys
+from types import CodeType
+from typing import Any
+
+_PYPY = hasattr(sys, "pypy_version_info")
+
+# Forked from pluggy with my own modification.
+# This is also a PR/idea based off this that I have for pluggy to try.
+# SEE: https://github.com/pytest-dev/pluggy/pull/659
+
+_POSITONAL_ONLY = inspect.Parameter.POSITIONAL_ONLY
+_POSITONAL_OR_KW = inspect.Parameter.POSITIONAL_OR_KEYWORD
+
+
+def _varnames_from_code(
+    func: object,
+) -> tuple[tuple[str, ...], dict[str, Any]]:
+    """Faster shortcut than needing to parse a function's given signature."""
+    code: CodeType = getattr(func, "__code__")
+    args = code.co_varnames[: code.co_argcount]
+
+    if defaults := getattr(func, "__defaults__", None):
+        index = -len(defaults)
+        return args[:index], dict(zip(args[index:], defaults))
+    else:
+        return args, {}
+
+
+def _varnames_from_signature(
+    func: object,
+) -> tuple[tuple[str, ...], dict[str, Any]]:
+    """extracts from a function's given signature but is slightly slower"""
+    sig = inspect.signature(func)
+    parameters = sig.parameters
+    required_args = [
+        k for k, v in parameters.items() if v.kind == _POSITONAL_ONLY
+    ]
+    optional = {
+        k: v for k, v in parameters.items() if v.kind == _POSITONAL_OR_KW
+    }
+    return tuple(required_args), optional
+
+
+def varnames(func: object):
+    """Return tuple of positional and keywrord argument names along with
+    defaults for a function, method, class or callable.
+
+    In case of a class, its ``__init__`` method is considered.
+    For methods the ``self`` parameter is not included.
+
+    """
+    if inspect.isclass(func):
+        try:
+            func = func.__init__
+        except AttributeError:  # pragma: no cover - pypy special case
+            return (), {}
+    elif not inspect.isroutine(func):  # callable object?
+        try:
+            func = getattr(func, "__call__", func)
+        except Exception:  # pragma: no cover - pypy special case
+            return (), {}
+
+    try:
+        # func MUST be a function or method here or we won't parse any args.
+        func = func.__func__ if inspect.ismethod(func) else func
+        if hasattr(func, "__code__") and inspect.isroutine(func):
+            # Take the optimized approch rather than sit and parse the given
+            # signature.
+            args, kwargs = _varnames_from_code(
+                func
+                if not hasattr(func, "__wrapped__")
+                else inspect.unwrap(func)
+            )
+        else:
+            # Fallback
+            args, kwargs = _varnames_from_signature(func)
+    except TypeError:  # pragma: no cover
+        return (), {}
+
+    # strip any implicit instance arg
+    # pypy3 uses "obj" instead of "self" for default dunder methods
+    if not _PYPY:
+        implicit_names: tuple[str, ...] = ("self",)
+    else:  # pragma: no cover
+        implicit_names = ("self", "obj")
+    if args:
+        qualname: str = getattr(func, "__qualname__", "")
+        if inspect.ismethod(func) or (
+            "." in qualname and args[0] in implicit_names
+        ):
+            args = args[1:]
+
+    return args, kwargs

reductable_params-0.1.0/src/reductable_params.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: reductable-params
+Version: 0.1.0
+Summary: filters arbitrary paremeters before sending them off to be called
+Author-email: Vizonex <VizonexBusiness@gmail.com>
+Project-URL: repository, https://github.com/Vizonex/reductable-params.git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typing_extensions; python_version < "3.14"
+Dynamic: license-file
+
+# reductable-params
+A low level Function packer & sender inspired by pluggy that is designed for mass sending
+as well as ignoring unneeded parameters before sending to a function allowing for large chainable callbacks to be possible in any configuration order.
+
+
+```python
+from reductable_params import reduce
+
+
+def test(a: int, b: str | None = None):
+    pass
+
+def child(a: int):
+    print(f"GOT {a}")
+
+def what_is_b(b: str | None):
+    print(f"B Is {b}")
+
+def main():
+    func = reduce(test)
+    # defaults can be installed before possibly sending 
+    # these to a child function.
+    data = func.install(1) # {"a": 1, b: None}
+    
+    child_func = reduce(child)
+
+    # Calling child_func will send itself off. 
+    # You can customize the data after installing it too.
+    # allowing for tons of creatives uses.
+    child_func(data) # B Parameter is ignored here.
+    # "GOT 1"
+
+    child_2 = reduce(what_is_b)
+    child_2(data)
+    # B Is None
+
+
+if __name__ == "__main__":
+    main()
+```
+
+## Benchmarks
+I decided to run benchmarks incase mainly to prove that this could be better than using `inspect.signature` alone and better for use on a mass scale when running the `install()` function.
+Note that smaller is better and that the timer is measured in seconds running `bench.py` which I have in this repo incase you want to see for yourself.
+
+<img src="install-benchmark.png"/>
+
+I'll add a comparison with pluggy in the future as soon as I get around to doing so.
+
+
+
+

reductable_params-0.1.0/src/reductable_params.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/reductable_params/__init__.py
+src/reductable_params/_reduce.py
+src/reductable_params/_reduce_c.pyi
+src/reductable_params/_reduce_c.pyx
+src/reductable_params/_reduce_py.py
+src/reductable_params/abc.py
+src/reductable_params/py.typed
+src/reductable_params/utils.py
+src/reductable_params.egg-info/PKG-INFO
+src/reductable_params.egg-info/SOURCES.txt
+src/reductable_params.egg-info/dependency_links.txt
+src/reductable_params.egg-info/requires.txt
+src/reductable_params.egg-info/top_level.txt
+tests/test_reduce.py

reductable_params-0.1.0/src/reductable_params.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

reductable_params-0.1.0/src/reductable_params.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[:python_version < "3.14"]
+typing_extensions

reductable_params-0.1.0/src/reductable_params.egg-info/top_level.txt

@@ -0,0 +1 @@
+reductable_params

reductable_params-0.1.0/tests/test_reduce.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import pytest
+
+from reductable_params._reduce_c import reduce as reduce_c
+from reductable_params._reduce_py import reduce as reduce_py
+from reductable_params.abc import Reducable, is_reducable
+
+
+@pytest.fixture(
+    params=[
+        (85022, 43727, 128749),
+        (14444, 84793, 99237),
+        (54194, 7697, 61891),
+        (89370, 55869, 145239),
+        (81581, 85501, 167082),
+        (64190, 90931, 155121),
+        (24752, 78572, 103324),
+        (31516, 8151, 39667),
+        (67001, 96812, 163813),
+        (31638, 95508, 127146),
+    ]
+)
+def addition_cases(request: pytest.FixtureRequest) -> tuple[int, ...]:
+    return request.param
+
+
+class BaseTestReduce:
+    reduce: type[Reducable]
+
+    def make_test_1(self) -> Reducable[[int, str | None], None]:
+        def sig(a: str, b: int | None = None):
+            pass
+
+        return self.reduce(sig)
+
+    def test_install(self) -> None:
+        func = self.make_test_1()
+        assert {"a": "1", "b": 2} == func.install(a="1", b=2)
+        assert {"a": "1", "b": 2} == func.install("1", b=2)
+        assert {"a": "1", "b": 2} == func.install("1", 2)
+        assert {"a": "1", "b": None} == func.install(a="1")
+        assert {"a": "1", "b": None} == func.install("1")
+
+    def test_bad_install_too_many_arguments(self):
+        func = self.make_test_1()
+        with pytest.raises(TypeError):
+            # Too Many Arguments
+            func.install("1", 2, 3)
+
+    def test_bad_install_too_little_arguments(self):
+        func = self.make_test_1()
+        with pytest.raises(BaseException):
+            # Too Little Arguments
+            func.install()
+
+    def test_bad_install_overlapping(self):
+        func = self.make_test_1()
+        with pytest.raises(TypeError):
+            # Overlapping tuple and dict keywords
+            func.install("1", a="10")
+
+    def test_calling_returnables(self, addition_cases: tuple[int, ...]):
+        def addition_cb(a: int, b: int):
+            return a + b
+
+        a, b, c = addition_cases
+        func = self.reduce(addition_cb)
+        assert func({"a": a, "b": b}) == c
+
+    def test_call_raises(self):
+        class Problem(Exception):
+            pass
+
+        def raise_me():
+            raise Problem("problem...")
+
+        func = self.reduce(raise_me)
+
+        with pytest.raises(Problem, match=r"problem..."):
+            func({})
+
+    def test_call_with_unwanted_arguments(self):
+        def i_require_foo(foo: str):
+            assert foo == "SPAM"
+
+        func = self.reduce(i_require_foo)
+        # It's what reduce's job is intended to do.
+        # Allow creating pluggy-like systems but at a
+        # very low level...
+        func({"foo": "SPAM", "extra": "BLAH BLAH BLAH"})
+
+    def test_is_reducable_check(self):
+        assert is_reducable(self.make_test_1())
+        assert is_reducable(0xDEAD) is False
+
+
+class TestPyReduce(BaseTestReduce):
+    reduce = reduce_py
+
+
+class TestCReduce(BaseTestReduce):
+    reduce = reduce_c