rbp-engine 1.2.4__py3-none-win_amd64.whl

rbp_engine/__init__.py

@@ -0,0 +1,87 @@
+"""rbp_engine — NumPy-friendly Relevance-Based Prediction.
+
+Quick start
+-----------
+>>> import numpy as np
+>>> from rbp_engine import predict, PredictOptions, predict_maxfit, predict_grid, GridOptions, relevance
+>>>
+>>> # y: outcomes (N,),  X: attributes (N, K),  theta: circumstances (K,)
+>>> result = predict(y, X, theta, PredictOptions(threshold=[0.5]))
+>>> result.yhat, result.fit, result.insights.relevance
+>>>
+>>> best = predict_maxfit(y, X, theta)                 # best threshold for you
+>>> out = predict_grid(y, X, theta, GridOptions(k=2))  # attribute-subset search
+>>> float(out.yhat[0])                                 # grid composite (T=1)
+>>>
+>>> r = relevance(X, theta)                            # insights without a full predict
+
+Terminology
+-----------
+* ``theta`` always means **circumstances** — the situation you are predicting for.
+* Use ``help(predict)``, ``help(GridOptions)``, etc. for paste-ready examples.
+
+See Also
+--------
+predict, predict_maxfit, predict_grid
+PredictOptions, MaxFitOptions, GridOptions
+PredictionResults
+relevance, similarity, info_x, info_theta, relevance_metrics
+"""
+
+from __future__ import annotations
+
+from rbp_engine._version import __version__
+from rbp_engine.config import get_percentile_value_algorithm, set_percentile_value_algorithm
+from rbp_engine.errors import RbpError, RbpLicenseError
+from rbp_engine.insights import (
+    RelevanceMetrics,
+    info_theta,
+    info_x,
+    relevance,
+    relevance_metrics,
+    similarity,
+)
+from rbp_engine.functions import predict, predict_grid, predict_maxfit
+from rbp_engine.options import GridOptions, MaxFitOptions, PredictOptions
+from rbp_engine.results import (
+    AuxiliaryInfo,
+    CensorCells,
+    GridCells,
+    GridInsights,
+    Insights,
+    PredictionResults,
+    PredictionWeights,
+    SoloDistribution,
+    SoloDistributionStatistics,
+    YSoloHistogram,
+)
+
+__all__ = [
+    "__version__",
+    "PredictOptions",
+    "MaxFitOptions",
+    "GridOptions",
+    "PredictionResults",
+    "AuxiliaryInfo",
+    "Insights",
+    "PredictionWeights",
+    "SoloDistribution",
+    "SoloDistributionStatistics",
+    "YSoloHistogram",
+    "GridInsights",
+    "GridCells",
+    "CensorCells",
+    "RelevanceMetrics",
+    "predict",
+    "predict_maxfit",
+    "predict_grid",
+    "relevance",
+    "similarity",
+    "info_x",
+    "info_theta",
+    "relevance_metrics",
+    "set_percentile_value_algorithm",
+    "get_percentile_value_algorithm",
+    "RbpError",
+    "RbpLicenseError",
+]

rbp_engine/_arrays.py

@@ -0,0 +1,38 @@
+"""Array helpers: accept NumPy / array-likes, hand contiguous buffers to ctypes."""
+
+from __future__ import annotations
+
+from ctypes import POINTER, c_double
+from typing import Any
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+from rbp_engine._ffi import RBP_LAYOUT_COL_MAJOR, RBP_LAYOUT_ROW_MAJOR
+
+
+def as_f64_1d(a: ArrayLike, *, name: str) -> NDArray[np.float64]:
+    arr = np.asarray(a, dtype=np.float64)
+    if arr.ndim == 2 and 1 in arr.shape:
+        arr = arr.reshape(-1)
+    if arr.ndim != 1:
+        raise ValueError(f"{name} must be 1-D (or an N×1 / 1×K column/row); got shape {arr.shape}")
+    return np.ascontiguousarray(arr)
+
+
+def as_f64_2d(a: ArrayLike, *, name: str) -> tuple[NDArray[np.float64], int]:
+    """Return (array, layout code). Prefers C-order; uses F-order zero-copy when contiguous."""
+    arr = np.asarray(a, dtype=np.float64)
+    if arr.ndim != 2:
+        raise ValueError(f"{name} must be 2-D; got shape {arr.shape}")
+    if arr.flags["C_CONTIGUOUS"]:
+        return arr, RBP_LAYOUT_ROW_MAJOR
+    if arr.flags["F_CONTIGUOUS"]:
+        return arr, RBP_LAYOUT_COL_MAJOR
+    return np.ascontiguousarray(arr), RBP_LAYOUT_ROW_MAJOR
+
+
+def c_double_ptr(arr: NDArray[np.float64]) -> Any:
+    if arr.size == 0:
+        raise ValueError("array must be non-empty")
+    return arr.ctypes.data_as(POINTER(c_double))

rbp_engine/_cli.py

@@ -0,0 +1,109 @@
+"""Console entry point for the bundled ``rbp-license-info`` native CLI.
+
+Wheels stage the platform binary at ``rbp_engine/bin/``. The ``[project.scripts]``
+entry ``rbp-license-info`` in ``pyproject.toml`` installs a small launcher on
+PATH that ends up here and replaces itself with that binary (or falls back to a
+cargo ``target/`` build for source checkouts).
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def _cli_names() -> tuple[str, ...]:
+    if sys.platform == "win32":
+        return ("rbp-license-info.exe", "rbp-license-info")
+    return ("rbp-license-info",)
+
+
+def _cargo_candidates(names: tuple[str, ...]) -> list[Path]:
+    # _cli.py → rbp_engine/ → python/ → repo root
+    repo_root = Path(__file__).resolve().parents[2]
+    paths: list[Path] = []
+    for name in names:
+        paths.extend(
+            [
+                repo_root / "target" / "release" / name,
+                repo_root / "target" / "debug" / name,
+            ]
+        )
+    cargo_target = os.environ.get("CARGO_TARGET_DIR")
+    if cargo_target:
+        for name in names:
+            paths.extend(
+                [
+                    Path(cargo_target) / "release" / name,
+                    Path(cargo_target) / "debug" / name,
+                ]
+            )
+    return paths
+
+
+def find_cli_path() -> Path:
+    """Return the path to ``rbp-license-info``, or raise ``FileNotFoundError``."""
+    names = _cli_names()
+    tried: list[str] = []
+
+    env = os.environ.get("RBP_LICENSE_INFO")
+    if env:
+        path = Path(env)
+        tried.append(str(path))
+        if path.is_file():
+            return path.resolve()
+        raise FileNotFoundError(f"RBP_LICENSE_INFO={path} is not a file")
+
+    base = Path(__file__).resolve().parent
+    for name in names:
+        bundled = base / "bin" / name
+        tried.append(str(bundled))
+        if bundled.is_file():
+            return bundled.resolve()
+
+    existing: list[Path] = []
+    for path in _cargo_candidates(names):
+        tried.append(str(path))
+        if path.is_file():
+            existing.append(path.resolve())
+    if existing:
+        return max(existing, key=lambda p: p.stat().st_mtime)
+
+    raise FileNotFoundError(
+        "Could not find rbp-license-info. Install a platform wheel of rbp-engine, "
+        "build with `cargo build --release --bin rbp-license-info` at the repo "
+        "root, or set RBP_LICENSE_INFO to the full path.\n"
+        "Tried:\n  - " + "\n  - ".join(tried)
+    )
+
+
+def _ensure_executable(path: Path) -> None:
+    """Restore +x if the wheel unpack stripped permission bits (common for data)."""
+    if sys.platform == "win32":
+        return
+    try:
+        mode = path.stat().st_mode
+        if mode & 0o111:
+            return
+        path.chmod(mode | 0o111)
+    except OSError:
+        pass
+
+
+def main(argv: list[str] | None = None) -> None:
+    """Run the native CLI, replacing this process when possible."""
+    args = list(sys.argv[1:] if argv is None else argv)
+    path = find_cli_path()
+    _ensure_executable(path)
+    cmd = [str(path), *args]
+    if sys.platform == "win32":
+        # os.execv on Windows does not reliably replace the process for
+        # console-script launchers; spawn and forward the exit code instead.
+        raise SystemExit(subprocess.call(cmd))
+    os.execv(str(path), cmd)
+
+
+if __name__ == "__main__":
+    main()

rbp_engine/_ffi.py

@@ -0,0 +1,460 @@
+"""Low-level ctypes bindings. Prefer the public ``rbp_engine`` API."""
+
+from __future__ import annotations
+
+from ctypes import (
+    POINTER,
+    c_char_p,
+    c_double,
+    c_int32,
+    c_size_t,
+    c_uint32,
+    c_uint8,
+    c_void_p,
+)
+from typing import Any
+
+from rbp_engine._native import load_library
+from rbp_engine.errors import RbpError, RbpLicenseError
+
+RBP_OK = 0
+RBP_ERR_LICENSE = 4
+RBP_LAYOUT_ROW_MAJOR = 0
+RBP_LAYOUT_COL_MAJOR = 1
+RBP_GRID_CENSOR_RELEVANCE = 0
+RBP_GRID_CENSOR_SIMILARITY = 1
+
+RbpPredictOptionsP = c_void_p
+RbpMaxFitOptionsP = c_void_p
+RbpGridOptionsP = c_void_p
+RbpPredictionResultsP = c_void_p
+
+
+def _bind_has(lib: Any, name: str, *extra: Any) -> None:
+    fn = getattr(lib, name)
+    fn.restype = c_int32
+    fn.argtypes = [RbpPredictionResultsP, *extra]
+
+
+def _bind_copy1(lib: Any, name: str) -> None:
+    fn = getattr(lib, name)
+    fn.restype = c_int32
+    fn.argtypes = [RbpPredictionResultsP, POINTER(c_double), c_size_t]
+
+
+def _bind_dims2(lib: Any, name: str, *extra: Any) -> None:
+    fn = getattr(lib, name)
+    fn.restype = c_int32
+    fn.argtypes = [RbpPredictionResultsP, *extra, POINTER(c_size_t), POINTER(c_size_t)]
+
+
+def _bind_copy2(lib: Any, name: str, *extra: Any) -> None:
+    fn = getattr(lib, name)
+    fn.restype = c_int32
+    fn.argtypes = [RbpPredictionResultsP, *extra, POINTER(c_double), c_size_t, c_int32]
+
+
+def _configure_deep_results(lib: Any) -> None:
+    for name in (
+        "rbp_results_has_weights",
+        "rbp_results_has_weights_excluded",
+        "rbp_results_has_include",
+        "rbp_results_has_auxiliary",
+        "rbp_results_has_maxfit_index",
+        "rbp_results_has_y_solo",
+        "rbp_results_has_xi_solo",
+        "rbp_results_has_ysolo_distribution",
+        "rbp_results_has_grid_insights",
+        "rbp_results_has_grid_cells",
+        "rbp_results_has_k_cells",
+        "rbp_results_has_combi_cells",
+        "rbp_results_has_ysolo_cells",
+    ):
+        _bind_has(lib, name)
+
+    for name in (
+        "rbp_results_has_yhat_cells",
+        "rbp_results_has_adjusted_fit_cells",
+        "rbp_results_has_n_cells",
+        "rbp_results_has_weights_cells",
+        "rbp_results_has_xi_solo_cells",
+    ):
+        _bind_has(lib, name, c_int32)
+
+    lib.rbp_results_num_combinations.restype = c_size_t
+    lib.rbp_results_num_combinations.argtypes = [RbpPredictionResultsP]
+    lib.rbp_results_maxfit_index_len.restype = c_size_t
+    lib.rbp_results_maxfit_index_len.argtypes = [RbpPredictionResultsP]
+
+    for name in (
+        "rbp_results_weights_dims",
+        "rbp_results_weights_excluded_dims",
+        "rbp_results_include_dims",
+        "rbp_results_xi_solo_dims",
+        "rbp_results_ysolo_distribution_dims",
+        "rbp_results_k_cells_dims",
+        "rbp_results_combi_cells_dims",
+        "rbp_results_ysolo_cells_dims",
+    ):
+        _bind_dims2(lib, name)
+
+    for name in (
+        "rbp_results_yhat_cells_dims",
+        "rbp_results_adjusted_fit_cells_dims",
+        "rbp_results_n_cells_dims",
+    ):
+        _bind_dims2(lib, name, c_int32)
+
+    for name in (
+        "rbp_results_copy_weights",
+        "rbp_results_copy_weights_excluded",
+        "rbp_results_copy_xi_solo",
+        "rbp_results_copy_ysolo_bin_counts",
+        "rbp_results_copy_k_cells",
+        "rbp_results_copy_combi_cells",
+        "rbp_results_copy_ysolo_cells",
+    ):
+        _bind_copy2(lib, name)
+
+    for name in (
+        "rbp_results_copy_yhat_cells",
+        "rbp_results_copy_adjusted_fit_cells",
+        "rbp_results_copy_n_cells",
+    ):
+        _bind_copy2(lib, name, c_int32)
+
+    lib.rbp_results_copy_include.restype = c_int32
+    lib.rbp_results_copy_include.argtypes = [
+        RbpPredictionResultsP,
+        POINTER(c_uint8),
+        c_size_t,
+        c_int32,
+    ]
+
+    for name in (
+        "rbp_results_copy_aux_phi",
+        "rbp_results_copy_aux_lambda_sq",
+        "rbp_results_copy_aux_full_var",
+        "rbp_results_copy_aux_part_var",
+        "rbp_results_copy_aux_r_star",
+        "rbp_results_copy_aux_r_star_percent",
+        "rbp_results_copy_aux_rho",
+        "rbp_results_copy_aux_n",
+        "rbp_results_copy_aux_k",
+        "rbp_results_copy_weights_concentration",
+        "rbp_results_copy_maxfit_index",
+        "rbp_results_copy_y_solo",
+        "rbp_results_copy_ysolo_sigma",
+        "rbp_results_copy_ysolo_skewness",
+        "rbp_results_copy_ysolo_kurtosis",
+        "rbp_results_copy_ysolo_pearson_modality_index",
+        "rbp_results_copy_ysolo_bimodal_index",
+        "rbp_results_copy_ysolo_bin_edges",
+        "rbp_results_copy_ysolo_bin_centers",
+        "rbp_results_copy_ysolo_bin_widths",
+        "rbp_results_copy_variable_weights",
+        "rbp_results_copy_mctc",
+        "rbp_results_copy_mctp",
+        "rbp_results_copy_cctp",
+        "rbp_results_copy_xi_solo_composite",
+    ):
+        _bind_copy1(lib, name)
+
+    for name in ("rbp_results_weights_cells_dims", "rbp_results_xi_solo_cells_dims"):
+        fn = getattr(lib, name)
+        fn.restype = c_int32
+        fn.argtypes = [
+            RbpPredictionResultsP,
+            c_int32,
+            POINTER(c_size_t),
+            POINTER(c_size_t),
+            POINTER(c_size_t),
+        ]
+
+    for name in ("rbp_results_copy_weights_cells", "rbp_results_copy_xi_solo_cells"):
+        fn = getattr(lib, name)
+        fn.restype = c_int32
+        fn.argtypes = [RbpPredictionResultsP, c_int32, POINTER(c_double), c_size_t]
+
+
+def _configure(lib: Any) -> Any:
+    lib.rbp_abi_version.restype = c_uint32
+    lib.rbp_abi_version.argtypes = []
+
+    lib.rbp_last_error.restype = c_char_p
+    lib.rbp_last_error.argtypes = []
+
+    lib.rbp_set_percentile_value_algorithm.restype = c_int32
+    lib.rbp_set_percentile_value_algorithm.argtypes = [c_int32]
+    lib.rbp_get_percentile_value_algorithm.restype = c_int32
+    lib.rbp_get_percentile_value_algorithm.argtypes = []
+    lib.rbp_set_percentile_value_algorithm_str.restype = c_int32
+    lib.rbp_set_percentile_value_algorithm_str.argtypes = [c_char_p]
+
+    # Predict options
+    lib.rbp_predict_options_create.restype = RbpPredictOptionsP
+    lib.rbp_predict_options_create.argtypes = []
+    lib.rbp_predict_options_free.argtypes = [RbpPredictOptionsP]
+
+    lib.rbp_predict_options_set_threshold.restype = c_int32
+    lib.rbp_predict_options_set_threshold.argtypes = [
+        RbpPredictOptionsP,
+        POINTER(c_double),
+        c_size_t,
+    ]
+    for name in (
+        "rbp_predict_options_set_censor_type",
+        "rbp_predict_options_set_censor_unit",
+        "rbp_predict_options_set_censor_operator",
+        "rbp_predict_options_set_prediction_scale",
+        "rbp_predict_options_set_adj_fit_multiplier",
+        "rbp_predict_options_set_inv_method",
+        "rbp_predict_options_set_verify_missing_data",
+        "rbp_predict_options_set_include_linear_regression",
+    ):
+        fn = getattr(lib, name)
+        fn.restype = c_int32
+        fn.argtypes = [RbpPredictOptionsP, c_int32]
+
+    for name in (
+        "rbp_predict_options_set_censor_type_str",
+        "rbp_predict_options_set_censor_unit_str",
+        "rbp_predict_options_set_censor_operator_str",
+    ):
+        fn = getattr(lib, name)
+        fn.restype = c_int32
+        fn.argtypes = [RbpPredictOptionsP, c_char_p]
+
+    lib.rbp_predict.restype = c_int32
+    lib.rbp_predict.argtypes = [
+        POINTER(c_double),
+        c_size_t,
+        POINTER(c_double),
+        c_size_t,
+        c_size_t,
+        c_int32,
+        POINTER(c_double),
+        c_size_t,
+        RbpPredictOptionsP,
+        POINTER(RbpPredictionResultsP),
+    ]
+
+    # MaxFit
+    lib.rbp_maxfit_options_create.restype = RbpMaxFitOptionsP
+    lib.rbp_maxfit_options_create.argtypes = []
+    lib.rbp_maxfit_options_free.argtypes = [RbpMaxFitOptionsP]
+    lib.rbp_maxfit_options_set_objective.restype = c_int32
+    lib.rbp_maxfit_options_set_objective.argtypes = [RbpMaxFitOptionsP, c_char_p]
+    lib.rbp_maxfit_options_set_threshold.restype = c_int32
+    lib.rbp_maxfit_options_set_threshold.argtypes = [
+        RbpMaxFitOptionsP,
+        POINTER(c_double),
+        c_size_t,
+    ]
+    for name in (
+        "rbp_maxfit_options_set_censor_type",
+        "rbp_maxfit_options_set_censor_unit",
+        "rbp_maxfit_options_set_censor_operator",
+        "rbp_maxfit_options_set_prediction_scale",
+        "rbp_maxfit_options_set_adj_fit_multiplier",
+        "rbp_maxfit_options_set_inv_method",
+        "rbp_maxfit_options_set_verify_missing_data",
+        "rbp_maxfit_options_set_include_linear_regression",
+        "rbp_maxfit_options_set_inner_parallel",
+    ):
+        fn = getattr(lib, name)
+        fn.restype = c_int32
+        fn.argtypes = [RbpMaxFitOptionsP, c_int32]
+    lib.rbp_maxfit_options_set_censor_type_str.restype = c_int32
+    lib.rbp_maxfit_options_set_censor_type_str.argtypes = [RbpMaxFitOptionsP, c_char_p]
+    lib.rbp_maxfit_options_set_inner_parallel_str.restype = c_int32
+    lib.rbp_maxfit_options_set_inner_parallel_str.argtypes = [RbpMaxFitOptionsP, c_char_p]
+
+    lib.rbp_maxfit.restype = c_int32
+    lib.rbp_maxfit.argtypes = [
+        POINTER(c_double),
+        c_size_t,
+        POINTER(c_double),
+        c_size_t,
+        c_size_t,
+        c_int32,
+        POINTER(c_double),
+        c_size_t,
+        RbpMaxFitOptionsP,
+        POINTER(RbpPredictionResultsP),
+    ]
+
+    # Grid
+    lib.rbp_grid_options_create.restype = RbpGridOptionsP
+    lib.rbp_grid_options_create.argtypes = []
+    lib.rbp_grid_options_free.argtypes = [RbpGridOptionsP]
+    lib.rbp_grid_options_set_max_iter.restype = c_int32
+    lib.rbp_grid_options_set_max_iter.argtypes = [RbpGridOptionsP, c_size_t]
+    lib.rbp_grid_options_set_k.restype = c_int32
+    lib.rbp_grid_options_set_k.argtypes = [RbpGridOptionsP, c_size_t]
+    lib.rbp_grid_options_set_seed.restype = c_int32
+    lib.rbp_grid_options_set_seed.argtypes = [RbpGridOptionsP, c_uint32]
+    lib.rbp_grid_options_set_retain_all.restype = c_int32
+    lib.rbp_grid_options_set_retain_all.argtypes = [RbpGridOptionsP, c_int32]
+    lib.rbp_grid_options_set_retain_grid_objects_str.restype = c_int32
+    lib.rbp_grid_options_set_retain_grid_objects_str.argtypes = [RbpGridOptionsP, c_char_p]
+    lib.rbp_grid_options_set_attribute_combi.restype = c_int32
+    lib.rbp_grid_options_set_attribute_combi.argtypes = [
+        RbpGridOptionsP,
+        POINTER(c_double),
+        c_size_t,
+        c_size_t,
+        c_int32,
+    ]
+    lib.rbp_grid_options_set_threshold.restype = c_int32
+    lib.rbp_grid_options_set_threshold.argtypes = [
+        RbpGridOptionsP,
+        POINTER(c_double),
+        c_size_t,
+    ]
+    for name in (
+        "rbp_grid_options_set_censor_type",
+        "rbp_grid_options_set_censor_unit",
+        "rbp_grid_options_set_censor_operator",
+        "rbp_grid_options_set_prediction_scale",
+        "rbp_grid_options_set_adj_fit_multiplier",
+        "rbp_grid_options_set_inv_method",
+        "rbp_grid_options_set_verify_missing_data",
+        "rbp_grid_options_set_include_linear_regression",
+        "rbp_grid_options_set_inner_parallel",
+    ):
+        fn = getattr(lib, name)
+        fn.restype = c_int32
+        fn.argtypes = [RbpGridOptionsP, c_int32]
+    lib.rbp_grid_options_set_censor_type_str.restype = c_int32
+    lib.rbp_grid_options_set_censor_type_str.argtypes = [RbpGridOptionsP, c_char_p]
+    lib.rbp_grid_options_set_inner_parallel_str.restype = c_int32
+    lib.rbp_grid_options_set_inner_parallel_str.argtypes = [RbpGridOptionsP, c_char_p]
+
+    lib.rbp_grid.restype = c_int32
+    lib.rbp_grid.argtypes = [
+        POINTER(c_double),
+        c_size_t,
+        POINTER(c_double),
+        c_size_t,
+        c_size_t,
+        c_int32,
+        POINTER(c_double),
+        c_size_t,
+        RbpGridOptionsP,
+        POINTER(RbpPredictionResultsP),
+    ]
+
+    # Insights
+    for name in ("rbp_relevance", "rbp_similarity", "rbp_info_theta"):
+        fn = getattr(lib, name)
+        fn.restype = c_int32
+        fn.argtypes = [
+            POINTER(c_double),
+            c_size_t,
+            c_size_t,
+            c_int32,
+            POINTER(c_double),
+            c_size_t,
+            POINTER(c_double),
+            c_int32,
+            POINTER(c_double),
+            c_size_t,
+        ]
+
+    lib.rbp_info_x.restype = c_int32
+    lib.rbp_info_x.argtypes = [
+        POINTER(c_double),
+        c_size_t,
+        c_size_t,
+        c_int32,
+        POINTER(c_double),
+        c_int32,
+        POINTER(c_double),
+        c_size_t,
+    ]
+
+    lib.rbp_relevance_metrics.restype = c_int32
+    lib.rbp_relevance_metrics.argtypes = [
+        POINTER(c_double),
+        c_size_t,
+        c_size_t,
+        c_int32,
+        POINTER(c_double),
+        c_size_t,
+        POINTER(c_double),
+        c_int32,
+        POINTER(c_double),
+        c_size_t,
+        POINTER(c_double),
+        c_size_t,
+        POINTER(c_double),
+        c_size_t,
+        POINTER(c_double),
+        c_size_t,
+    ]
+
+    # Results
+    lib.rbp_prediction_results_free.argtypes = [RbpPredictionResultsP]
+    for name in (
+        "rbp_results_num_observations",
+        "rbp_results_num_variables",
+        "rbp_results_num_thresholds",
+    ):
+        fn = getattr(lib, name)
+        fn.restype = c_size_t
+        fn.argtypes = [RbpPredictionResultsP]
+
+    for name in (
+        "rbp_results_copy_thresholds",
+        "rbp_results_copy_yhat",
+        "rbp_results_copy_fit",
+        "rbp_results_copy_adjusted_fit",
+        "rbp_results_copy_agreement",
+        "rbp_results_copy_asymmetry",
+        "rbp_results_copy_k_fit",
+        "rbp_results_copy_outlier_influence",
+        "rbp_results_copy_yhat_linear",
+        "rbp_results_copy_relevance",
+        "rbp_results_copy_similarity",
+        "rbp_results_copy_info_x",
+        "rbp_results_copy_info_theta",
+    ):
+        fn = getattr(lib, name)
+        fn.restype = c_int32
+        fn.argtypes = [RbpPredictionResultsP, POINTER(c_double), c_size_t]
+
+    lib.rbp_results_has_yhat_linear.restype = c_int32
+    lib.rbp_results_has_yhat_linear.argtypes = [RbpPredictionResultsP]
+
+    _configure_deep_results(lib)
+    return lib
+
+
+_configured: Any | None = None
+
+
+def get_lib() -> Any:
+    global _configured
+    if _configured is None:
+        # Clear native CDLL cache if ABI symbols were added since last load in-process.
+        load_library.cache_clear()
+        _configured = _configure(load_library())
+    return _configured
+
+
+def last_error(lib: Any | None = None) -> str:
+    lib = lib or get_lib()
+    msg = lib.rbp_last_error()
+    if not msg:
+        return ""
+    return msg.decode("utf-8", errors="replace")
+
+
+def check(status: int, lib: Any | None = None) -> None:
+    if status == RBP_OK:
+        return
+    message = last_error(lib) or f"RBP native call failed (status={status})"
+    if status == RBP_ERR_LICENSE:
+        raise RbpLicenseError(message, status=status)
+    raise RbpError(message, status=status)