Microstructure/src/microstructure/research/models.py

"""Transparent model ladder, calibration, metrics, and dependent bootstrap."""

from __future__ import annotations

import math
from dataclasses import dataclass
from datetime import UTC, datetime
from typing import Literal, cast

import numpy as np
import polars as pl
from numpy.typing import NDArray
from sklearn.base import ClassifierMixin  # type: ignore[import-untyped]
from sklearn.dummy import DummyClassifier  # type: ignore[import-untyped]
from sklearn.impute import SimpleImputer  # type: ignore[import-untyped]
from sklearn.linear_model import LogisticRegression  # type: ignore[import-untyped]
from sklearn.metrics import (  # type: ignore[import-untyped]
    accuracy_score,
    average_precision_score,
    balanced_accuracy_score,
    brier_score_loss,
    log_loss,
    roc_auc_score,
)
from sklearn.pipeline import Pipeline  # type: ignore[import-untyped]
from sklearn.preprocessing import StandardScaler  # type: ignore[import-untyped]
from sklearn.tree import DecisionTreeClassifier  # type: ignore[import-untyped]

from microstructure.config import ModelConfig
from microstructure.research.features import model_feature_columns
from microstructure.research.splits import WalkForwardPlan


class ModelEvaluationError(ValueError):
    """Raised when a model evaluation would be invalid or underidentified."""


ModelFamily = Literal["baseline", "logistic", "logistic_l2", "shallow_tree"]


@dataclass(frozen=True, slots=True)
class ModelCandidate:
    """One predeclared member of the transparent classification ladder."""

    name: str
    family: ModelFamily
    c: float | None = None
    max_depth: int | None = None
    min_samples_leaf: int = 1


@dataclass(frozen=True, slots=True)
class BootstrapResult:
    """A deterministic block-bootstrap percentile interval."""

    point_estimate: float
    lower: float | None
    upper: float | None
    n_bootstrap: int
    n_blocks: int
    seed: int
    status: Literal["ok", "insufficient_blocks"]
    draws: tuple[float, ...]


@dataclass(frozen=True, slots=True)
class ModelLadderResult:
    """Out-of-time predictions and fold/final-test comparison rows."""

    predictions: pl.DataFrame
    comparison: pl.DataFrame
    selected_model: str
    feature_columns: tuple[str, ...]
    selection_metric: str


@dataclass(slots=True)
class SigmoidCalibrator:
    """Platt-style calibration fitted only on a chronological calibration tail."""

    estimator: LogisticRegression | None = None
    status: str = "identity_not_fitted"

    def fit(self, y_true: NDArray[np.int64], raw_probability: NDArray[np.float64]) -> None:
        if y_true.size < 8 or np.unique(y_true).size < 2:
            self.status = "identity_insufficient_calibration_data"
            return
        transformed = _logit(raw_probability).reshape(-1, 1)
        estimator = LogisticRegression(C=1.0, solver="lbfgs", max_iter=2_000)
        estimator.fit(transformed, y_true)
        self.estimator = estimator
        self.status = "sigmoid"

    def transform(self, raw_probability: NDArray[np.float64]) -> NDArray[np.float64]:
        if self.estimator is None:
            return np.asarray(np.clip(raw_probability, 1e-12, 1.0 - 1e-12), dtype=np.float64)
        probability = self.estimator.predict_proba(_logit(raw_probability).reshape(-1, 1))[:, 1]
        return np.asarray(probability, dtype=np.float64)


def _logit(probability: NDArray[np.float64]) -> NDArray[np.float64]:
    clipped = np.clip(probability, 1e-6, 1.0 - 1e-6)
    return np.log(clipped / (1.0 - clipped))


def build_model_candidates(config: ModelConfig) -> tuple[ModelCandidate, ...]:
    """Expand the typed configuration into a stable, auditable model ladder."""

    candidates: list[ModelCandidate] = [ModelCandidate("historical_prior", "baseline")]
    candidates.append(ModelCandidate(name="logistic_unpenalized", family="logistic"))
    candidates.extend(
        ModelCandidate(name=f"logistic_l2_c_{value:g}", family="logistic_l2", c=value)
        for value in config.logistic_c_values
    )
    candidates.extend(
        ModelCandidate(
            name=f"tree_depth_{depth}",
            family="shallow_tree",
            max_depth=depth,
            min_samples_leaf=config.tree_min_samples_leaf,
        )
        for depth in config.tree_max_depth_values
    )
    return tuple(candidates)


def make_classifier(candidate: ModelCandidate, *, seed: int) -> Pipeline:
    """Construct a CPU-light classifier with train-only preprocessing."""

    imputer = SimpleImputer(strategy="median", keep_empty_features=True)
    if candidate.family == "baseline":
        model: ClassifierMixin = DummyClassifier(strategy="prior")
        return Pipeline([("imputer", imputer), ("model", model)])
    if candidate.family in {"logistic", "logistic_l2"}:
        if candidate.family == "logistic_l2" and (candidate.c is None or candidate.c <= 0):
            raise ModelEvaluationError("regularized logistic C must be positive")
        model = LogisticRegression(
            C=np.inf if candidate.family == "logistic" else candidate.c,
            solver="lbfgs",
            max_iter=2_000,
            random_state=seed,
        )
        return Pipeline([("imputer", imputer), ("scale", StandardScaler()), ("model", model)])
    if candidate.family == "shallow_tree":
        if candidate.max_depth is None or candidate.max_depth < 1:
            raise ModelEvaluationError("tree max_depth must be positive")
        model = DecisionTreeClassifier(
            max_depth=candidate.max_depth,
            min_samples_leaf=candidate.min_samples_leaf,
            random_state=seed,
        )
        return Pipeline([("imputer", imputer), ("model", model)])
    raise ModelEvaluationError(f"unsupported model family: {candidate.family}")


def expected_calibration_error(
    y_true: NDArray[np.int64],
    probability: NDArray[np.float64],
    *,
    bins: int,
) -> float:
    """Return fixed-width expected calibration error."""

    if bins < 1:
        raise ModelEvaluationError("calibration bins must be positive")
    if y_true.size == 0:
        return math.nan
    probability = np.clip(probability, 0.0, 1.0)
    assignments = np.digitize(probability, np.linspace(0.0, 1.0, bins + 1)[1:-1])
    result = 0.0
    for bin_index in range(bins):
        mask = assignments == bin_index
        if np.any(mask):
            result += float(mask.mean()) * abs(
                float(y_true[mask].mean()) - float(probability[mask].mean())
            )
    return result


def classification_metrics(
    y_true: NDArray[np.int64],
    probability: NDArray[np.float64],
    *,
    calibration_bins: int,
) -> dict[str, float]:
    """Compute proper scoring, discrimination, and calibration metrics."""

    if y_true.size == 0 or y_true.shape != probability.shape:
        raise ModelEvaluationError("metric inputs must be equally sized and nonempty")
    if not np.isin(y_true, [0, 1]).all():
        raise ModelEvaluationError("classification target must contain only 0 and 1")
    probability = np.clip(probability.astype(np.float64), 1e-12, 1.0 - 1e-12)
    prediction = (probability >= 0.5).astype(np.int64)
    two_classes = np.unique(y_true).size == 2
    return {
        "accuracy": float(accuracy_score(y_true, prediction)),
        "balanced_accuracy": (
            float(balanced_accuracy_score(y_true, prediction)) if two_classes else math.nan
        ),
        "log_loss": float(log_loss(y_true, probability, labels=[0, 1])),
        "brier_score": float(brier_score_loss(y_true, probability)),
        "roc_auc": float(roc_auc_score(y_true, probability)) if two_classes else math.nan,
        "pr_auc": (
            float(average_precision_score(y_true, probability)) if two_classes else math.nan
        ),
        "expected_calibration_error": expected_calibration_error(
            y_true, probability, bins=calibration_bins
        ),
        "positive_rate": float(y_true.mean()),
    }


def _positive_probability(
    estimator: Pipeline, features: NDArray[np.float64]
) -> NDArray[np.float64]:
    probabilities = np.asarray(estimator.predict_proba(features), dtype=np.float64)
    classes = np.asarray(estimator.classes_)
    if classes.size == 1:
        return np.full(features.shape[0], float(classes[0] == 1), dtype=np.float64)
    positive = np.flatnonzero(classes == 1)
    if positive.size != 1:
        raise ModelEvaluationError("classifier does not expose a binary positive class")
    return np.asarray(probabilities[:, int(positive[0])], dtype=np.float64)


def _rows(frame: pl.DataFrame, indices: NDArray[np.int64]) -> pl.DataFrame:
    return frame.filter(pl.col("_research_row_id").is_in(indices))


def _chronological_calibration_split(
    train: pl.DataFrame,
    *,
    fraction: float,
) -> tuple[pl.DataFrame, pl.DataFrame]:
    if not 0.0 < fraction < 0.5:
        raise ModelEvaluationError("calibration_fraction must be between zero and one half")
    times = sorted(train.get_column("decision_ts_ns").unique().to_list())
    if len(times) < 6:
        return train, train.head(0)
    calibration_count = max(2, math.ceil(len(times) * fraction))
    calibration_start = int(times[-calibration_count])
    base = train.filter(
        (pl.col("decision_ts_ns") < calibration_start)
        & (pl.col("label_information_end_ts_ns") < calibration_start)
    )
    calibration = train.filter(pl.col("decision_ts_ns") >= calibration_start)
    if base.height < 4 or calibration.height < 8:
        return train, train.head(0)
    return base, calibration


def _fit_candidate(
    candidate: ModelCandidate,
    train: pl.DataFrame,
    evaluate: pl.DataFrame,
    *,
    features: tuple[str, ...],
    target: str,
    seed: int,
    calibration_fraction: float,
) -> tuple[NDArray[np.float64], NDArray[np.float64], str, int, ModelCandidate]:
    base, calibration = _chronological_calibration_split(train, fraction=calibration_fraction)
    x_base = base.select(features).to_numpy().astype(np.float64)
    y_base = base.get_column(target).to_numpy().astype(np.int64)
    fit_status = "ok"
    effective_candidate = candidate
    if np.unique(y_base).size < 2 and candidate.family != "baseline":
        effective_candidate = ModelCandidate(
            name=f"{candidate.name}__prior_fallback",
            family="baseline",
        )
        fit_status = "single_class_prior_fallback"
    estimator = make_classifier(effective_candidate, seed=seed)
    estimator.fit(x_base, y_base)

    calibrator = SigmoidCalibrator()
    if not calibration.is_empty():
        x_calibration = calibration.select(features).to_numpy().astype(np.float64)
        y_calibration = calibration.get_column(target).to_numpy().astype(np.int64)
        calibrator.fit(y_calibration, _positive_probability(estimator, x_calibration))
    x_evaluate = evaluate.select(features).to_numpy().astype(np.float64)
    raw_probability = _positive_probability(estimator, x_evaluate)
    probability = calibrator.transform(raw_probability)

    fitting_rows = pl.concat([base, calibration]) if not calibration.is_empty() else base
    fit_cutoff_value = fitting_rows.get_column("label_information_end_ts_ns").max()
    if fit_cutoff_value is None:
        raise ModelEvaluationError("training rows have no observable labels")
    status = f"{fit_status};{calibrator.status}"
    return raw_probability, probability, status, cast(int, fit_cutoff_value), effective_candidate


def _prediction_rows(
    evaluated: pl.DataFrame,
    *,
    candidate: ModelCandidate,
    requested_candidate: ModelCandidate,
    fold_id: int,
    split: Literal["validation", "test"],
    target: str,
    raw_probability: NDArray[np.float64],
    probability: NDArray[np.float64],
    fit_cutoff_ts_ns: int,
) -> list[dict[str, object]]:
    result: list[dict[str, object]] = []
    for index, row in enumerate(evaluated.iter_rows(named=True)):
        decision_ts_ns = int(row["decision_ts_ns"])
        symbol = str(row.get("symbol", "UNKNOWN"))
        decision_sequence = int(row.get("decision_sequence", row["_research_row_id"]))
        sample_id = str(row.get("sample_id", f"{symbol}:{decision_ts_ns}:{decision_sequence}"))
        if fit_cutoff_ts_ns >= decision_ts_ns:
            raise ModelEvaluationError("model fitting information reaches the evaluation decision")
        result.append(
            {
                "row_id": int(row["_research_row_id"]),
                "sample_id": sample_id,
                "symbol": symbol,
                "instrument": symbol,
                "decision_ts_ns": decision_ts_ns,
                "decision_sequence": decision_sequence,
                "continuity_id": str(row.get("continuity_id", "UNKNOWN")),
                "fold_id": fold_id,
                "split": split,
                "model": candidate.name,
                "family": candidate.family,
                "requested_model": requested_candidate.name,
                "requested_family": requested_candidate.family,
                "y_true": int(row[target]),
                "raw_probability": float(raw_probability[index]),
                "probability": float(probability[index]),
                "predicted_class": int(probability[index] >= 0.5),
                "fit_cutoff_ts_ns": fit_cutoff_ts_ns,
                "is_oos": True,
            }
        )
    return result


def _metric_row(
    *,
    candidate: ModelCandidate,
    requested_candidate: ModelCandidate,
    fold_id: int,
    split: Literal["validation", "test"],
    y_true: NDArray[np.int64],
    probability: NDArray[np.float64],
    calibration_bins: int,
    fit_status: str,
    evaluated: pl.DataFrame,
    horizon_events: int | None,
) -> dict[str, object]:
    metrics = classification_metrics(y_true, probability, calibration_bins=calibration_bins)
    period_start = cast(int, evaluated.get_column("decision_ts_ns").min())
    period_end = cast(int, evaluated.get_column("decision_ts_ns").max())
    instruments = sorted(str(value) for value in evaluated.get_column("symbol").unique())
    instrument_scope = instruments[0] if len(instruments) == 1 else "POOLED"
    return {
        "model": candidate.name,
        "family": candidate.family,
        "requested_model": requested_candidate.name,
        "requested_family": requested_candidate.family,
        "symbol": instrument_scope,
        "instrument": instrument_scope,
        "instrument_scope": instrument_scope,
        "horizon_events": horizon_events,
        "fold_id": fold_id,
        "split": split,
        "period_start_ts_ns": period_start,
        "period_end_ts_ns": period_end,
        "period_start_utc": _ns_to_utc(period_start),
        "period_end_utc": _ns_to_utc(period_end),
        "n_obs": int(y_true.size),
        "fit_status": fit_status,
        **metrics,
    }


def _ns_to_utc(timestamp_ns: int) -> str:
    return (
        datetime.fromtimestamp(timestamp_ns / 1_000_000_000, tz=UTC)
        .isoformat()
        .replace("+00:00", "Z")
    )


def _metric_direction(metric: str) -> Literal["min", "max"]:
    if metric in {"log_loss", "brier_score", "expected_calibration_error"}:
        return "min"
    if metric in {"accuracy", "balanced_accuracy", "roc_auc", "pr_auc"}:
        return "max"
    raise ModelEvaluationError(f"unsupported selection metric: {metric}")


def _select_model(
    comparison_rows: list[dict[str, object]],
    candidates: tuple[ModelCandidate, ...],
    metric: str,
) -> str:
    direction = _metric_direction(metric)
    scores: list[tuple[float, int, str]] = []
    for order, candidate in enumerate(candidates):
        candidate_rows = [
            row
            for row in comparison_rows
            if row["split"] == "validation"
            and row.get("requested_model", row["model"]) == candidate.name
        ]
        used_fallback = any(row["model"] != candidate.name for row in candidate_rows)
        values = (
            [
                cast(float, row[metric])
                for row in candidate_rows
                if math.isfinite(cast(float, row[metric]))
            ]
            if not used_fallback
            else []
        )
        score = float(np.mean(values)) if values else math.nan
        sortable = score if direction == "min" else -score
        if not math.isfinite(sortable):
            sortable = math.inf
        scores.append((sortable, order, candidate.name))
    return min(scores)[2]


def evaluate_model_ladder(
    frame: pl.DataFrame,
    plan: WalkForwardPlan,
    model_config: ModelConfig,
    *,
    seed: int,
    calibration_bins: int,
    target: str = "future_mid_up",
    features: tuple[str, ...] | None = None,
    calibration_fraction: float = 0.2,
) -> ModelLadderResult:
    """Evaluate every model OOT, select on validation, then open final test once."""

    if target not in frame.columns:
        raise ModelEvaluationError(f"target column not found: {target}")
    selected_features = features or model_feature_columns(frame)
    missing_features = sorted(set(selected_features).difference(frame.columns))
    if missing_features:
        raise ModelEvaluationError(f"feature columns not found: {missing_features}")
    forbidden = [
        name
        for name in selected_features
        if name.startswith("future_") or name.startswith("label_") or name == "right_censored"
    ]
    if forbidden:
        raise ModelEvaluationError(f"label/timing columns cannot be model features: {forbidden}")

    indexed = frame.with_row_index("_research_row_id")
    candidates = build_model_candidates(model_config)
    horizon: int | None = None
    if "label_horizon_events" in frame.columns:
        horizon_values = frame.get_column("label_horizon_events").drop_nulls().unique().to_list()
        if len(horizon_values) == 1:
            horizon = int(horizon_values[0])
    predictions: list[dict[str, object]] = []
    comparison: list[dict[str, object]] = []

    for fold in plan.folds:
        train = _rows(indexed, fold.train_indices).filter(pl.col(target).is_not_null())
        validation = _rows(indexed, fold.validation_indices).filter(pl.col(target).is_not_null())
        for candidate in candidates:
            raw, calibrated, fit_status, fit_cutoff, effective_candidate = _fit_candidate(
                candidate,
                train,
                validation,
                features=selected_features,
                target=target,
                seed=seed,
                calibration_fraction=calibration_fraction,
            )
            y_validation = validation.get_column(target).to_numpy().astype(np.int64)
            predictions.extend(
                _prediction_rows(
                    validation,
                    candidate=effective_candidate,
                    requested_candidate=candidate,
                    fold_id=fold.fold_id,
                    split="validation",
                    target=target,
                    raw_probability=raw,
                    probability=calibrated,
                    fit_cutoff_ts_ns=fit_cutoff,
                )
            )
            comparison.append(
                _metric_row(
                    candidate=effective_candidate,
                    requested_candidate=candidate,
                    fold_id=fold.fold_id,
                    split="validation",
                    y_true=y_validation,
                    probability=calibrated,
                    calibration_bins=calibration_bins,
                    fit_status=fit_status,
                    evaluated=validation,
                    horizon_events=horizon,
                )
            )

    selected_model = _select_model(comparison, candidates, model_config.selection_metric)

    final_train = _rows(indexed, plan.final_train_indices).filter(pl.col(target).is_not_null())
    final_test = _rows(indexed, plan.test_indices).filter(pl.col(target).is_not_null())
    for candidate in candidates:
        raw, calibrated, fit_status, fit_cutoff, effective_candidate = _fit_candidate(
            candidate,
            final_train,
            final_test,
            features=selected_features,
            target=target,
            seed=seed,
            calibration_fraction=calibration_fraction,
        )
        y_test = final_test.get_column(target).to_numpy().astype(np.int64)
        predictions.extend(
            _prediction_rows(
                final_test,
                candidate=effective_candidate,
                requested_candidate=candidate,
                fold_id=-1,
                split="test",
                target=target,
                raw_probability=raw,
                probability=calibrated,
                fit_cutoff_ts_ns=fit_cutoff,
            )
        )
        comparison.append(
            _metric_row(
                candidate=effective_candidate,
                requested_candidate=candidate,
                fold_id=-1,
                split="test",
                y_true=y_test,
                probability=calibrated,
                calibration_bins=calibration_bins,
                fit_status=fit_status,
                evaluated=final_test,
                horizon_events=horizon,
            )
        )

    comparison_frame = pl.DataFrame(comparison).with_columns(
        (pl.col("model") == selected_model).alias("selected_on_validation"),
        pl.when(pl.col("model") == selected_model)
        .then(pl.lit("validation"))
        .otherwise(None)
        .alias("selected_on"),
    )
    prediction_frame = (
        pl.DataFrame(predictions)
        .sort(["split", "fold_id", "model", "decision_ts_ns", "symbol"])
        .with_columns(pl.lit(horizon, dtype=pl.Int64).alias("horizon_events"))
    )
    return ModelLadderResult(
        predictions=prediction_frame,
        comparison=comparison_frame,
        selected_model=selected_model,
        feature_columns=selected_features,
        selection_metric=model_config.selection_metric,
    )


def _metric_from_arrays(
    y_true: NDArray[np.int64],
    probability: NDArray[np.float64],
    metric: str,
) -> float:
    metrics = classification_metrics(y_true, probability, calibration_bins=10)
    if metric not in metrics:
        raise ModelEvaluationError(f"unsupported bootstrap metric: {metric}")
    return metrics[metric]


def _bootstrap_arrays(
    predictions: pl.DataFrame,
    *,
    block_column: str,
) -> tuple[NDArray[np.int64], NDArray[np.float64], NDArray[np.object_], list[object]]:
    required = {"y_true", "probability", block_column}
    missing = sorted(required.difference(predictions.columns))
    if missing:
        raise ModelEvaluationError(f"bootstrap predictions missing columns: {missing}")
    y_true = predictions.get_column("y_true").to_numpy().astype(np.int64)
    probability = predictions.get_column("probability").to_numpy().astype(np.float64)
    blocks = predictions.get_column(block_column).to_numpy().astype(object)
    unique_blocks = list(dict.fromkeys(blocks.tolist()))
    return y_true, probability, blocks, unique_blocks


def block_bootstrap_metric(
    predictions: pl.DataFrame,
    *,
    metric: str,
    block_column: str,
    n_bootstrap: int,
    seed: int,
) -> BootstrapResult:
    """Bootstrap complete dependency blocks rather than overlapping events."""

    if n_bootstrap < 1:
        raise ModelEvaluationError("n_bootstrap must be positive")
    y_true, probability, blocks, unique_blocks = _bootstrap_arrays(
        predictions, block_column=block_column
    )
    point = _metric_from_arrays(y_true, probability, metric)
    if len(unique_blocks) < 2:
        return BootstrapResult(
            point_estimate=point,
            lower=None,
            upper=None,
            n_bootstrap=n_bootstrap,
            n_blocks=len(unique_blocks),
            seed=seed,
            status="insufficient_blocks",
            draws=(),
        )

    indices_by_block = {block: np.flatnonzero(blocks == block) for block in unique_blocks}
    random = np.random.default_rng(seed)
    draws: list[float] = []
    for _ in range(n_bootstrap):
        sampled_positions = random.choice(len(unique_blocks), size=len(unique_blocks), replace=True)
        sampled_blocks = [unique_blocks[int(position)] for position in sampled_positions]
        sampled_indices = np.concatenate([indices_by_block[block] for block in sampled_blocks])
        draws.append(
            _metric_from_arrays(y_true[sampled_indices], probability[sampled_indices], metric)
        )
    finite = np.asarray([draw for draw in draws if math.isfinite(draw)], dtype=np.float64)
    lower = float(np.quantile(finite, 0.025)) if finite.size else None
    upper = float(np.quantile(finite, 0.975)) if finite.size else None
    return BootstrapResult(
        point_estimate=point,
        lower=lower,
        upper=upper,
        n_bootstrap=n_bootstrap,
        n_blocks=len(unique_blocks),
        seed=seed,
        status="ok",
        draws=tuple(draws),
    )


def paired_block_bootstrap_difference(
    left: pl.DataFrame,
    right: pl.DataFrame,
    *,
    metric: str,
    block_column: str,
    n_bootstrap: int,
    seed: int,
) -> BootstrapResult:
    """Return a paired left-minus-right metric interval using common blocks."""

    required = {"row_id", "y_true", "probability", block_column}
    for name, frame in (("left", left), ("right", right)):
        missing = sorted(required.difference(frame.columns))
        if missing:
            raise ModelEvaluationError(f"{name} predictions missing columns: {missing}")
    paired = left.select(
        "row_id",
        "y_true",
        block_column,
        pl.col("probability").alias("left_probability"),
    ).join(
        right.select(
            "row_id",
            pl.col("y_true").alias("right_y_true"),
            pl.col("probability").alias("right_probability"),
        ),
        on="row_id",
        how="inner",
        validate="1:1",
    )
    if paired.height != left.height or paired.height != right.height:
        raise ModelEvaluationError("paired predictions must contain identical unique row IDs")
    if paired.filter(pl.col("y_true") != pl.col("right_y_true")).height:
        raise ModelEvaluationError("paired predictions disagree on target values")

    y_true = paired.get_column("y_true").to_numpy().astype(np.int64)
    left_probability = paired.get_column("left_probability").to_numpy().astype(np.float64)
    right_probability = paired.get_column("right_probability").to_numpy().astype(np.float64)
    blocks = paired.get_column(block_column).to_numpy().astype(object)
    unique_blocks = list(dict.fromkeys(blocks.tolist()))
    point = _metric_from_arrays(y_true, left_probability, metric) - _metric_from_arrays(
        y_true, right_probability, metric
    )
    if len(unique_blocks) < 2:
        return BootstrapResult(
            point, None, None, n_bootstrap, len(unique_blocks), seed, "insufficient_blocks", ()
        )
    indices_by_block = {block: np.flatnonzero(blocks == block) for block in unique_blocks}
    random = np.random.default_rng(seed)
    draws: list[float] = []
    for _ in range(n_bootstrap):
        sampled_positions = random.choice(len(unique_blocks), size=len(unique_blocks), replace=True)
        sampled_blocks = [unique_blocks[int(position)] for position in sampled_positions]
        sampled_indices = np.concatenate([indices_by_block[block] for block in sampled_blocks])
        draws.append(
            _metric_from_arrays(y_true[sampled_indices], left_probability[sampled_indices], metric)
            - _metric_from_arrays(
                y_true[sampled_indices], right_probability[sampled_indices], metric
            )
        )
    finite = np.asarray([draw for draw in draws if math.isfinite(draw)], dtype=np.float64)
    return BootstrapResult(
        point_estimate=point,
        lower=float(np.quantile(finite, 0.025)) if finite.size else None,
        upper=float(np.quantile(finite, 0.975)) if finite.size else None,
        n_bootstrap=n_bootstrap,
        n_blocks=len(unique_blocks),
        seed=seed,
        status="ok",
        draws=tuple(draws),
    )


__all__ = [
    "BootstrapResult",
    "ModelCandidate",
    "ModelEvaluationError",
    "ModelLadderResult",
    "SigmoidCalibrator",
    "block_bootstrap_metric",
    "build_model_candidates",
    "classification_metrics",
    "evaluate_model_ladder",
    "expected_calibration_error",
    "make_classifier",
    "paired_block_bootstrap_difference",
]