Allow pass-through keyword arguments in Python callbacks (#73)

Author: awvwgk

config/ci/python-env.yaml

@@ -12,3 +12,4 @@ dependencies:
   - numpy
   - meson
   - ninja
+  - typing-extensions

python/minpack/library.py

@@ -28,9 +28,10 @@ class UserData:
     disturbing foreign runtime.
     """
 
-    def __init__(self, fcn):
+    def __init__(self, fcn, **kwargs):
         self.fcn = fcn
         self.exception = None
+        self.kwargs = kwargs
 
 
 @ffi.def_extern()
@@ -46,6 +47,7 @@ def func(n, x, fvec, iflag, data) -> None:
         handle.fcn(
             np.frombuffer(ffi.buffer(x, n * real.itemsize), dtype=real),
             np.frombuffer(ffi.buffer(fvec, n * real.itemsize), dtype=real),
+            **handle.kwargs,
         )
     except BaseException as e:
         iflag[0] = -1
@@ -68,6 +70,7 @@ def fcn_hybrj(n, x, fvec, fjac, ldfjac, iflag, data) -> None:
             np.frombuffer(ffi.buffer(fvec, n * real.itemsize), dtype=real),
             np.reshape(fjac, (n, ldfjac)),
             iflag[0] == 2,
+            **handle.kwargs,
         )
     except BaseException as e:
         iflag[0] = -1
@@ -90,6 +93,7 @@ def fcn_lmder(m, n, x, fvec, fjac, ldfjac, iflag, data) -> None:
             np.frombuffer(ffi.buffer(fvec, m * real.itemsize), dtype=real),
             np.reshape(fjac, (n, ldfjac)),
             iflag[0] == 2,
+            **handle.kwargs,
         )
     except BaseException as e:
         iflag[0] = -1
@@ -109,6 +113,7 @@ def func2(m, n, x, fvec, iflag, data) -> None:
         handle.fcn(
             np.frombuffer(ffi.buffer(x, n * real.itemsize), dtype=real),
             np.frombuffer(ffi.buffer(fvec, m * real.itemsize), dtype=real),
+            **handle.kwargs,
         )
     except BaseException as e:
         iflag[0] = -1
@@ -130,6 +135,7 @@ def fcn_lmstr(m, n, x, fvec, fjrow, iflag, data) -> None:
             np.frombuffer(ffi.buffer(fvec, m * real.itemsize), dtype=real),
             np.frombuffer(ffi.buffer(fjrow, n * real.itemsize), dtype=real),
             iflag[0] - 2 if iflag[0] > 1 else None,
+            **handle.kwargs,
         )
     except BaseException as e:
         iflag[0] = -1
@@ -162,8 +168,8 @@ def cffi_callback(func, callback):
     """
 
     @functools.wraps(func)
-    def entry_point(fcn, *args):
-        data = UserData(fcn)
+    def entry_point(fcn, *args, **kwargs):
+        data = UserData(fcn, **kwargs)
         handle = ffi.new_handle(data)
         func(callback, *args, handle)
         if data.exception is not None:
@@ -191,6 +197,7 @@ def hybrd1(
     x: np.ndarray,
     fvec: np.ndarray,
     tol: float = math.sqrt(np.finfo(real).eps),
+    **kwargs,
 ) -> int:
     """
     Find a zero of a system of n nonlinear functions in n variables
@@ -262,6 +269,7 @@ def hybrd1(
         info,
         ffi.cast("double*", wa.ctypes.data),
         lwa,
+        **kwargs,
     )
     ex = info_hy(info[0])
     if ex is not None:
@@ -286,6 +294,7 @@ def hybrd(
     fjac: Optional[np.ndarray] = None,
     r: Optional[np.ndarray] = None,
     qtf: Optional[np.ndarray] = None,
+    **kwargs,
 ) -> int:
     """
     Find a zero of a system of n nonlinear functions in n variables
@@ -353,6 +362,7 @@ def hybrd(
         ffi.cast("double*", wa2.ctypes.data),
         ffi.cast("double*", wa3.ctypes.data),
         ffi.cast("double*", wa4.ctypes.data),
+        **kwargs,
     )
     ex = info_hy(info[0])
     if ex is not None:
@@ -366,6 +376,7 @@ def hybrj1(
     fvec: np.ndarray,
     fjac: np.ndarray,
     tol: float = math.sqrt(np.finfo(real).eps),
+    **kwargs,
 ) -> int:
     """
     Find a zero of a system of n nonlinear functions in n variables
@@ -403,6 +414,7 @@ def hybrj1(
         info,
         ffi.cast("double*", wa.ctypes.data),
         lwa,
+        **kwargs,
     )
     ex = info_hy(info[0])
     if ex is not None:
@@ -424,6 +436,7 @@ def hybrj(
     nprint: int = 0,
     r: Optional[np.ndarray] = None,
     qtf: Optional[np.ndarray] = None,
+    **kwargs,
 ) -> int:
     """
     Find a zero of a system of n nonlinear functions in n variables
@@ -486,6 +499,7 @@ def hybrj(
         ffi.cast("double*", wa2.ctypes.data),
         ffi.cast("double*", wa3.ctypes.data),
         ffi.cast("double*", wa4.ctypes.data),
+        **kwargs,
     )
     ex = info_hy(info[0])
     if ex is not None:
@@ -499,6 +513,7 @@ def lmder1(
     fvec: np.ndarray,
     fjac: np.ndarray,
     tol: float = math.sqrt(np.finfo(real).eps),
+    **kwargs,
 ) -> int:
     """
     Minimize the sum of the squares of m nonlinear functions in n variables
@@ -539,6 +554,7 @@ def lmder1(
         ffi.cast("int*", ipvt.ctypes.data),
         ffi.cast("double*", wa.ctypes.data),
         lwa,
+        **kwargs,
     )
     ex = info_lm(info[0])
     if ex is not None:
@@ -562,6 +578,7 @@ def lmder(
     nprint=0,
     ipvt: Optional[np.ndarray] = None,
     qtf: Optional[np.ndarray] = None,
+    **kwargs,
 ) -> int:
     """
     Minimize the sum of the squares of m nonlinear functions in n variables
@@ -624,6 +641,7 @@ def lmder(
         ffi.cast("double*", wa2.ctypes.data),
         ffi.cast("double*", wa3.ctypes.data),
         ffi.cast("double*", wa4.ctypes.data),
+        **kwargs,
     )
     ex = info_lm(info[0])
     if ex is not None:
@@ -636,6 +654,7 @@ def lmdif1(
     x: np.ndarray,
     fvec: np.ndarray,
     tol: float = math.sqrt(np.finfo(real).eps),
+    **kwargs,
 ) -> int:
     """
     Minimize the sum of the squares of m nonlinear functions in n variables
@@ -709,6 +728,7 @@ def lmdif1(
         ffi.cast("int*", ipvt.ctypes.data),
         ffi.cast("double*", wa.ctypes.data),
         lwa,
+        **kwargs,
     )
     ex = info_lm(info[0])
     if ex is not None:
@@ -733,6 +753,7 @@ def lmdif(
     fjac: Optional[np.ndarray] = None,
     ipvt: Optional[np.ndarray] = None,
     qtf: Optional[np.ndarray] = None,
+    **kwargs,
 ) -> int:
     """
     Minimize the sum of the squares of m nonlinear functions in n variables
@@ -797,6 +818,7 @@ def lmdif(
         ffi.cast("double*", wa2.ctypes.data),
         ffi.cast("double*", wa3.ctypes.data),
         ffi.cast("double*", wa4.ctypes.data),
+        **kwargs,
     )
     ex = info_lm(info[0])
     if ex is not None:
@@ -810,6 +832,7 @@ def lmstr1(
     fvec: np.ndarray,
     fjac: np.ndarray,
     tol: float = math.sqrt(np.finfo(real).eps),
+    **kwargs,
 ) -> int:
     """
     Minimize the sum of the squares of m nonlinear functions in n variables by
@@ -851,6 +874,7 @@ def lmstr1(
         ffi.cast("int*", ipvt.ctypes.data),
         ffi.cast("double*", wa.ctypes.data),
         lwa,
+        **kwargs,
     )
     ex = info_lm(info[0])
     if ex is not None:
@@ -874,6 +898,7 @@ def lmstr(
     nprint=0,
     ipvt: Optional[np.ndarray] = None,
     qtf: Optional[np.ndarray] = None,
+    **kwargs,
 ) -> int:
     """
     Minimize the sum of the squares of m nonlinear functions in n variables by
@@ -937,6 +962,7 @@ def lmstr(
         ffi.cast("double*", wa2.ctypes.data),
         ffi.cast("double*", wa3.ctypes.data),
         ffi.cast("double*", wa4.ctypes.data),
+        **kwargs,
     )
     ex = info_lm(info[0])
     if ex is not None:

python/minpack/test_library.py

@@ -127,7 +127,7 @@ def test_lmder(driver):
         ]
     )
 
-    def fcn(x, fvec, fjac, jacobian: bool) -> None:
+    def fcn(x, fvec, fjac, jacobian: bool, y) -> None:
         if jacobian:
             for i in range(fvec.size):
                 tmp1, tmp2 = i + 1, 16 - i - 1
@@ -151,14 +151,14 @@ def fcn(x, fvec, fjac, jacobian: bool) -> None:
     fvecp = np.zeros(15, dtype=np.float64)
     err = np.zeros(15, dtype=np.float64)
     minpack.library.chkder(x, fvec, fjac, xp, fvecp, False, err)
-    fcn(x, fvec, fjac, False)
-    fcn(x, fvec, fjac, True)
-    fcn(xp, fvecp, fjac, False)
+    fcn(x, fvec, fjac, False, y=y)
+    fcn(x, fvec, fjac, True, y=y)
+    fcn(xp, fvecp, fjac, False, y=y)
     minpack.library.chkder(x, fvec, fjac, xp, fvecp, True, err)
 
     assert pytest.approx(err) == 15 * [1.0]
 
-    assert driver(fcn, x, fvec, fjac, tol) == 1
+    assert driver(fcn, x, fvec, fjac, tol, y=y) == 1
 
     assert pytest.approx(x, abs=100 * tol) == [0.8241058e-1, 0.1133037e1, 0.2343695e1]
 
@@ -202,7 +202,7 @@ def test_lmdif(driver):
         ]
     )
 
-    def fcn(x, fvec) -> None:
+    def fcn(x, fvec, y) -> None:
         for i in range(fvec.size):
             tmp1, tmp2 = i + 1, 16 - i - 1
             tmp3 = tmp2 if i >= 8 else tmp1
@@ -213,7 +213,7 @@ def fcn(x, fvec) -> None:
     fjac = np.zeros((3, 15), dtype=np.float64)
     tol = sqrt(np.finfo(np.float64).eps)
 
-    assert driver(fcn, x, fvec, tol) == 1
+    assert driver(fcn, x, fvec, tol, y=y) == 1
 
     assert pytest.approx(x, abs=100 * tol) == [0.8241058e-1, 0.1133037e1, 0.2343695e1]
 
@@ -260,7 +260,7 @@ def test_lmstr_exception(driver):
     class DummyException(Exception):
         ...
 
-    def fcn(x, fvec, fjac, row) -> None:
+    def fcn(x, fvec, fjrow, row) -> None:
         raise DummyException()
 
     x = np.array([-1.2, 1.0])

python/minpack/typing.py

@@ -4,10 +4,54 @@
 """
 
 import numpy as np
-from typing import Optional, Callable
+from typing import Optional
+try:
+    from typing import Protocol
+except ImportError:
+    from typing_extensions import Protocol
 
-CallableHybrd = Callable[[np.ndarray, np.ndarray], None]
-CallableHybrj = Callable[[np.ndarray, np.ndarray, np.ndarray, bool], None]
-CallableLmder = Callable[[np.ndarray, np.ndarray, np.ndarray, bool], None]
-CallableLmdif = Callable[[np.ndarray, np.ndarray], None]
-CallableLmstr = Callable[[np.ndarray, np.ndarray, np.ndarray, Optional[int]], None]
+
+class CallableHybrd(Protocol):
+    def __call__(self, x: np.ndarray, fvec: np.ndarray, **kwargs) -> None:
+        ...
+
+
+class CallableHybrj(Protocol):
+    def __call__(
+        self,
+        x: np.ndarray,
+        fvec: np.ndarray,
+        fjac: np.ndarray,
+        jacobian: bool,
+        **kwargs
+    ) -> None:
+        ...
+
+
+class CallableLmder(Protocol):
+    def __call__(
+        self,
+        x: np.ndarray,
+        fvec: np.ndarray,
+        fjac: np.ndarray,
+        jacobian: bool,
+        **kwargs
+    ) -> None:
+        ...
+
+
+class CallableLmdif(Protocol):
+    def __call__(self, x: np.ndarray, fvec: np.ndarray, **kwargs) -> None:
+        ...
+
+
+class CallableLmstr(Protocol):
+    def __call__(
+        self,
+        x: np.ndarray,
+        fvec: np.ndarray,
+        fjrow: np.ndarray,
+        row: Optional[int],
+        **kwargs
+    ) -> None:
+        ...