python-bindings

name	python-bindings
description	Maintenance and extension rules for stochastic-rs Python (PyO3) bindings — invoke when adding/updating distributions, processes, pricers, calibrators, or estimators that need Python exposure

Python Bindings (PyO3) — stochastic-rs

The stochastic-rs-py cdylib re-exports #[pyclass]-wrapped types from producer crates (stochastic-rs-distributions, -stochastic, -quant, -stats, -copulas). The surface is 234 entries: 218 PyO3 classes + 16 pyfunctions across distributions / stochastic / quant / copulas / stats. AI bindings deferred to 2.x.

This skill covers four pipelines:

1. Distributions — wrapped via py_distribution! / py_distribution_int!
2. Stochastic processes — wrapped via py_process_1d! / py_process_2x1d! / py_process_2d!
3. Quant pricers / calibrators / vol surfaces — hand-written #[pyclass] blocks in stochastic-rs-quant/src/python/
4. Stats estimators — hand-written #[pyfunction]/#[pyclass] blocks

For all four, the entry point is stochastic-rs-py/src/lib.rs, which imports each wrapper and registers it via m.add_class::<PyXxx>() / m.add_function(wrap_pyfunction!(py_xxx, m)?).

1. Macros (auto-generated wrappers)

1.1. py_distribution! — for Simd* distribution types

Producer crate: stochastic-rs-distributions. Macro definition in stochastic-rs-distributions/src/macros.rs. Invoke at the bottom of the distribution's source file, e.g. stochastic-rs-distributions/src/normal.rs:

py_distribution!(PyNormal, SimdNormal,
  sig: (mean, std_dev, seed=None, dtype=None),
  params: (mean: f64, std_dev: f64)
);

sig is the full PyO3 signature and must end with seed=None, dtype=None; params lists only the distribution parameters — the macro appends seed and dtype itself.

What you get:

• PyNormal #[pyclass(unsendable)] — note that py_distribution! does emit unsendable, while the py_process_*! macros do not.
• Two inner slots, inner_f32 / inner_f64. Unlike the process macros there are no separate seeded_* slots: the seed is folded straight into the constructor as &Deterministic::new(sd) (or &Unseeded).
• __new__(mean, std_dev, seed=None, dtype=None) — seed: Option<u64>, dtype: Option<&str> ∈ {"f32", "f64"}, default f64
• sample(n) returning numpy.ndarray
• sample_par(m, n) returning numpy.ndarray (parallel matrix)

IntoF32 / IntoF64 shims in stochastic-rs-core::python convert each parameter to the chosen dtype. All distribution parameters MUST be f64-typed in the macro params: clause — the dispatching to SimdXxx<f32> happens via the shim.

1.2. py_distribution_int! — for integer-valued distributions

Same shape but for Poisson, Binomial, Geometric, etc. that produce u32/i32 arrays.

1.3. py_process_1d! / py_process_2x1d! / py_process_2d!

Producer crate: stochastic-rs-stochastic. Macro definition in stochastic-rs-stochastic/src/macros.rs. Pick by the process's output shape:

Macro	Output shape	Examples
py_process_1d!	Array1<T> (single 1-D path)	Gbm, Ou, Fou, Fbm, Cir
py_process_2x1d!	[Array1<T>; 2] (two 1-D paths)	Sabr, HestonLog, DuffieKan, Cgns, Cbms
py_process_2d!	Array2<T> (correlated multi-asset)	Cfou, Fbs (sheet/fbs.rs)

Not every two-component process uses the macro: Heston itself has a hand-written PyHeston (volatility/heston.rs), as does Merton (whose jump distribution crosses the boundary as a CallableDist). Reach for a hand-written wrapper when the constructor takes something the macro cannot express — a Python callable, or a third type parameter like Heston's scheme selector.

Invoke at the bottom of the process's source file, e.g. stochastic-rs-stochastic/src/diffusion/gbm.rs:

py_process_1d!(PyGbm, Gbm,
  sig: (mu, sigma, n, x0=None, t=None, seed=None, dtype=None),
  params: (mu: f64, sigma: f64, n: usize, x0: Option<f64>, t: Option<f64>)
);

sig is the full PyO3 signature and must end with seed=None, dtype=None; params lists only the model parameters — the macro appends seed: Option<u64> and dtype: Option<&str> itself, and m is not a constructor parameter at all. Note the PascalCase names (PyGbm, Gbm), not the v1.x acronym spelling.

You get exactly two methods:

• PyGbm.sample() → 1-D numpy array
• PyGbm.sample_par(m) → (m, n) numpy array

There is no sample_seeded(seed) method. The seed is a constructor argument — PyGbm(..., seed=42) — and the generated class holds four Option slots (inner_f32, inner_f64, seeded_f32, seeded_f64) dispatched on (seed, dtype) in __new__. So both float widths are supported for processes, via dtype="f32" / dtype="f64" (default "f64"), through IntoF32 / IntoF64 in stochastic-rs-core::python.

2. Hand-written #[pyclass] (quant pricers / calibrators)

Located in stochastic-rs-quant/src/python/. The module is feature-gated behind #[cfg(feature = "python")] (whole file). Pattern:

#[pyclass(name = "BSMPricer", unsendable)]
pub struct PyBSMPricer {
  inner: crate::pricing::bsm::BSMPricer,
}

#[pymethods]
impl PyBSMPricer {
  #[new]
  // Since 3.0 the Rust pricer holds MODEL parameters only — `BSMPricer`
  // is `{ v, b }`. Spot, strike, rates and maturity are query arguments.
  #[pyo3(signature = (sigma,))]
  fn new(sigma: f64) -> PyResult<Self> {
    if sigma <= 0.0 {
      return Err(PyValueError::new_err("sigma must be > 0"));
    }
    Ok(Self {
      inner: crate::pricing::bsm::BSMPricer::new(sigma, BSMCoc::Merton1973),
    })
  }

  // Keep the Python kwarg names stable across a Rust rename: bind
  // explicitly (`tau: t`) rather than relying on field-init shorthand.
  #[pyo3(signature = (s, k, r, q, tau))]
  fn price(&self, s: f64, k: f64, r: f64, q: f64, tau: f64) -> f64 {
    self.inner.price_call(s, k, r, q, tau)
  }
}

2.1. Calibrators (Result-typed)

When the inner Rust Calibrator returns Result, propagate into Python via PyResult and PyValueError::new_err:

fn calibrate(&self) -> PyResult<(f64, f64, f64, f64, bool)> {
  use crate::traits::Calibrator;
  let res = self.inner.calibrate(None)
    .map_err(|e| PyValueError::new_err(format!("calibration failed: {e}")))?;
  Ok((res.params().alpha, res.params().beta, res.params().nu,
      res.params().rho, res.converged()))
}

This is the standard pattern for the unified Calibrator trait. Cgmysv / HKDE / Hscm / RBergomi calibrators all follow it.

2.2. Constructors that validate user input

Returning PyResult<Self> from #[new] is fully supported by PyO3 and preferred over panic!. Example pattern:

#[new]
fn new(alpha: f64, beta: f64, delta: f64, r: f64, q: f64) -> PyResult<Self> {
  if alpha <= 0.0 {
    return Err(PyValueError::new_err("alpha must be > 0"));
  }
  if !(beta.abs() < alpha) {
    return Err(PyValueError::new_err("|beta| must be < alpha"));
  }
  Ok(Self { ... })
}

3. Registration in stochastic-rs-py/src/lib.rs

Every wrapped type must be registered explicitly. The cdylib's #[pymodule] init function:

#[pymodule]
fn stochastic_rs(_py: Python, m: &PyModule) -> PyResult<()> {
  // 1. Imports — alphabetised within each producer crate's section.
  use stochastic_rs_quant::python::PyBSMPricer;
  use stochastic_rs_quant::python::PyNigFourier;     // new in rc.2
  // ...

  // 2. Registration — group by domain (pricer, calibrator, vol_surface, ...).
  m.add_class::<PyBSMPricer>()?;
  m.add_class::<PyNigFourier>()?;
  // ...

  Ok(())
}

Forgotten add_class is the #1 cause of "module has no attribute X" at import time. Always register a new wrapper in the same PR that adds the #[pyclass].

4. Build & test workflow

4.1. Local development

# From the workspace root.
cd stochastic-rs-py

# Activate / create a venv (only first time):
python -m venv .venv && source .venv/bin/activate
pip install maturin pytest numpy

# Build + install in dev mode (~30s):
maturin develop --release

# Smoke test:
python -c "from stochastic_rs import PyBSMPricer; \
  p = PyBSMPricer(100, 100, 0.05, 0.0, 0.2, 1.0); print(p.price())"

pyproject.toml has [tool.maturin] manifest-path = ".../Cargo.toml" pointing at the cdylib crate.

4.2. Smoke testing

For every new #[pyclass] add a tests/python/test_<topic>.py (driven from the cdylib crate) that exercises:

• __new__ happy path
• __new__ invalid-input branch (expect ValueError)
• The 1–2 most-used methods (sample, price, calibrate, …)

Or write the smoke test inline in Rust under #[cfg(test)] using pyo3::Python::with_gil(|py| { ... }) — that lets cargo test --features python cover it without spawning Python.

4.3. CI

cargo test --workspace --exclude stochastic-rs-py covers the Rust side. Python smoke is on the maturin path under .github/workflows/ci.yml::wheels.

5. Common patterns / gotchas

5.1. Sendability

PyO3 #[pyclass] wrappers default to Send + Sync. For unsendable types (those holding Rc<RefCell<...>>, RefCell<...>, or non-Send external handles like YahooConnector), add unsendable:

#[pyclass(name = "RBergomiCalibrator", unsendable)]

Forgetting unsendable on a non-Send type triggers a compile error ("the trait Send is not implemented for Rc<...>").

5.2. Numpy interop

For Array1<f64> / Array2<f64> returns, use:

use numpy::IntoPyArray;
fn surface(&self, py: Python) -> Py<PyAny> {
  self.inner.surface().into_pyarray(py).into_py_any(py).unwrap()
}

For inputs, accept PyReadonlyArray1<f64> / PyReadonlyArray2<f64> and call .as_array() to get an ArrayView.

5.3. Optional parameters with defaults

#[pyo3(signature = (...))] controls Python-visible defaults. Required: list every parameter, even if you didn't change it. Example with optional + default:

#[pyo3(signature = (s0, r, slices, hurst=0.1, rho=-0.7, eta=2.0, xi0=0.04,
                    max_iters=60, paths=1024))]
fn new(...) -> PyResult<Self> { ... }

5.4. Return-tuple naming

Calibrators that produce many scalars typically return tuples. Document the order in the calibrator's docstring:

/// Calibrate. Returns `(alpha, beta, nu, rho, converged, rmse)`.
fn calibrate(&self) -> PyResult<(f64, f64, f64, f64, bool, f64)> { ... }

For more than ~5 outputs, return a #[pyclass] result struct instead.

5.5. NaN propagation (rc.1+)

CarrMadanPricer::price_call returns f64::NAN for out-of-grid strikes (was 0.0 in rc.0). Python users must detect via math.isnan(). Document this on the price_*_call methods and expose strike_in_grid_* helpers so callers can pre-check.

6. Distribution-specific testing checklist

When wrapping a distribution, confirm:

• py_distribution! invocation at end of source file
• from_seed_source path uses Deterministic::new(seed)
• IntoF32 / IntoF64 shims wrap every numeric parameter
• m.add_class::<PyXxx>() added to stochastic-rs-py/src/lib.rs
• Python smoke test (from stochastic_rs import PyXxx; PyXxx(...))
• sample(n) returns the right shape
• sample_par(m, n) returns shape (m, n)

7. Process-specific testing checklist

• Choose macro: py_process_1d! (1-D) / py_process_2x1d! (2 × 1-D) / py_process_2d! (multi-asset)
• Macro invocation at end of source file
• m.add_class::<PyXxx>() added to stochastic-rs-py/src/lib.rs
• PyXxx(...).sample() smoke test
• PyXxx(..., seed=42).sample() reproduces — exact bit equality (the seed is a constructor kwarg; there is no sample_seeded)
• PyXxx(..., dtype="f32") constructs and samples

8. Pricer / calibrator testing checklist

• #[pyclass(name = "...", unsendable?)] matches the pyi name
• #[pyo3(signature = (...))] lists every parameter
• Constructors validate inputs and return PyResult<Self> with PyValueError::new_err
• Calibrators map inner anyhow::Error to PyValueError
• m.add_class::<PyXxx>() registered
• Smoke test: construct + 1-2 method calls
• Round-trip test where applicable (e.g. price → IV → price)

9. PyPI release (out of scope here — see release-checklist SKILL)

The release-checklist SKILL covers:

• Workspace version bump on 9 crates
• maturin build --release per platform (Linux/macOS x86_64, macOS aarch64, Windows x86_64)
• twine upload
• pyi stub regeneration (maturin generate-stubs if used)

This SKILL only covers the wrapper and registration steps.

10. References

• PyO3 user guide: https://pyo3.rs
• maturin manual: https://www.maturin.rs
• numpy crate: https://docs.rs/numpy
• Module entry point: stochastic-rs-py/src/lib.rs
• Macro definitions: stochastic-rs-distributions/src/macros.rs, stochastic-rs-stochastic/src/macros.rs
• Quant hand-written wrappers: stochastic-rs-quant/src/python/