Results

neureptrace.results

aggregate_time_decode_csvs(csv_paths, out_path, *, subject_column=None, observation_csv_paths=None, observation_subject_column=None, ece_bins=DEFAULT_ECE_BINS)

Aggregate time-resolved decoding CSV files and write a summary CSV.

Source code in src/neureptrace/results/__init__.py

def aggregate_time_decode_csvs(
    csv_paths: list[Path],
    out_path: Path,
    *,
    subject_column: str | None = None,
    observation_csv_paths: list[Path] | None = None,
    observation_subject_column: str | None = None,
    ece_bins: int = DEFAULT_ECE_BINS,
) -> pd.DataFrame:
    """Aggregate time-resolved decoding CSV files and write a summary CSV."""
    results = read_time_decode_results(csv_paths, subject_column=subject_column)
    observations = None
    if observation_csv_paths is not None:
        observations = read_time_decode_observations(
            observation_csv_paths,
            subject_column=observation_subject_column,
            result_csv_paths=csv_paths,
            results=results,
        )
    aggregated = aggregate_time_decode_results(results, observations=observations, ece_bins=ece_bins)
    out_path.parent.mkdir(parents=True, exist_ok=True)
    aggregated.to_csv(out_path, index=False)
    return aggregated

aggregate_time_decode_results(results, *, observations=None, ece_bins=DEFAULT_ECE_BINS)

Aggregate fold-level decoding results into time-level summary statistics.

Fold-linear metrics are averaged within subject/time after weighting by n_test when available. When probability observations are provided, ECE is recomputed from pooled held-out probabilities within each subject/time group instead of averaging fold-level ECE values.

Source code in src/neureptrace/results/__init__.py

def aggregate_time_decode_results(
    results: pd.DataFrame,
    *,
    observations: pd.DataFrame | None = None,
    ece_bins: int = DEFAULT_ECE_BINS,
) -> pd.DataFrame:
    """Aggregate fold-level decoding results into time-level summary statistics.

    Fold-linear metrics are averaged within subject/time after weighting by
    ``n_test`` when available. When probability observations are provided,
    ECE is recomputed from pooled held-out probabilities within each
    subject/time group instead of averaging fold-level ECE values.
    """
    subject_time = subject_time_metrics(results, observations=observations, ece_bins=ece_bins)
    group_columns = [column for column in SUMMARY_GROUP_COLUMNS if column in subject_time.columns]
    aggregate_keys = [*group_columns, "time"]

    grouped = subject_time.groupby(aggregate_keys, as_index=False, dropna=False)
    aggregated = grouped[list(METRIC_COLUMNS)].mean()
    n_subjects = grouped["subject"].nunique().rename(columns={"subject": "n_subjects"})
    aggregated = aggregated.merge(n_subjects, on=aggregate_keys)

    for metric in METRIC_COLUMNS:
        sem = grouped[metric].sem().rename(columns={metric: f"{metric}_sem"})
        aggregated = aggregated.merge(sem, on=aggregate_keys)
        aggregated = aggregated.rename(columns={metric: f"{metric}_mean"})

    return aggregated.sort_values(aggregate_keys).reset_index(drop=True)

build_provenance_table(summary, results=None, *, baseline_window=(-0.1, 0.0), effect_window=(0.1, 0.8), selection_metric='accuracy')

Build one-row-per-run provenance with selected parameters and metrics.

Source code in src/neureptrace/results/__init__.py

def build_provenance_table(
    summary: pd.DataFrame,
    results: pd.DataFrame | None = None,
    *,
    baseline_window: tuple[float, float] = (-0.1, 0.0),
    effect_window: tuple[float, float] = (0.1, 0.8),
    selection_metric: str = "accuracy",
) -> pd.DataFrame:
    """Build one-row-per-run provenance with selected parameters and metrics."""
    if selection_metric not in PROVENANCE_METRICS:
        allowed = ", ".join(PROVENANCE_METRICS)
        raise ValueError(f"selection_metric must be one of: {allowed}")
    if "time" not in summary.columns:
        raise ValueError("Summary must contain a time column.")

    normalized_summary = _normalize_group_defaults(summary)
    group_columns = [column for column in SUMMARY_GROUP_COLUMNS if column in normalized_summary.columns]
    rows: list[dict[str, object]] = []
    grouper = group_columns[0] if len(group_columns) == 1 else group_columns
    for keys, group in normalized_summary.groupby(grouper, dropna=False, sort=True):
        key_values = keys if isinstance(keys, tuple) else (keys,)
        group_values = dict(zip(group_columns, key_values, strict=True))
        selected = _best_summary_row(group, selection_metric)
        row: dict[str, object] = {
            **group_values,
            "pca_mode": group_values.get("feature_preprocessor", "none"),
            "n_subjects": int(selected["n_subjects"]) if "n_subjects" in selected else "",
            "selection_metric": selection_metric,
            "selected_time": float(selected["time"]),
        }
        for metric in PROVENANCE_METRICS:
            row[f"selected_{metric}"] = float(selected.get(f"{metric}_mean", np.nan))
            row[f"baseline_{metric}_mean"] = _safe_window_mean(group, f"{metric}_mean", baseline_window)
            row[f"effect_{metric}_mean"] = _safe_window_mean(group, f"{metric}_mean", effect_window)
        row["accuracy_effect_minus_baseline"] = row["effect_accuracy_mean"] - row["baseline_accuracy_mean"]
        row["log_loss_effect_improvement"] = row["baseline_log_loss_mean"] - row["effect_log_loss_mean"]
        row["brier_effect_improvement"] = row["baseline_brier_mean"] - row["effect_brier_mean"]
        row["ece_effect_improvement"] = row["baseline_ece_mean"] - row["effect_ece_mean"]
        rows.append(row)

    provenance = pd.DataFrame(rows)
    if results is not None:
        metadata = _provenance_metadata(results, group_columns)
        provenance = provenance.merge(metadata, on=group_columns, how="left", validate="one_to_one")
    for column in ("selected_params", "source_files"):
        if column not in provenance.columns:
            provenance[column] = ""
        provenance[column] = provenance[column].fillna("")
    for column in ("selected_params_unique", "best_score_mean", "best_score_min", "best_score_max"):
        if column not in provenance.columns:
            provenance[column] = np.nan

    provenance = provenance.drop(columns=["feature_preprocessor"], errors="ignore")
    ordered = [column for column in PROVENANCE_COLUMN_ORDER if column in provenance.columns]
    extras = [column for column in provenance.columns if column not in ordered]
    return provenance[[*ordered, *extras]].reset_index(drop=True)

peak_metric_rows(frame, metric_column, group_columns, time_column='time', prefer_time=0.0)

Select the peak metric row in each group, breaking ties toward a preferred time.

Source code in src/neureptrace/results/tables.py

def peak_metric_rows(
    frame: pd.DataFrame,
    metric_column: str,
    group_columns: Sequence[str],
    time_column: str = "time",
    prefer_time: float = 0.0,
) -> pd.DataFrame:
    """Select the peak metric row in each group, breaking ties toward a preferred time."""
    group_columns = _normalize_columns(group_columns)
    _require_columns(frame, [metric_column, time_column, *group_columns])
    preferred = _finite_numeric_scalar(prefer_time, name="prefer_time")

    rows: list[pd.Series] = []
    for _, group in _iter_groups(frame, group_columns):
        ranked = group.copy()
        ranked["_peak_metric_numeric"] = _finite_numeric_series(ranked[metric_column], name=metric_column)
        ranked["_peak_time_numeric"] = _finite_numeric_series(ranked[time_column], name=time_column)
        ranked["_peak_distance_to_prefer_time"] = (ranked["_peak_time_numeric"] - preferred).abs()
        ranked = ranked.sort_values(
            ["_peak_metric_numeric", "_peak_distance_to_prefer_time", "_peak_time_numeric"],
            ascending=[False, True, True],
            kind="mergesort",
        )
        selected = ranked.iloc[0].drop(labels=["_peak_metric_numeric", "_peak_time_numeric", "_peak_distance_to_prefer_time"])
        selected["peak_distance_to_prefer_time"] = float(ranked.iloc[0]["_peak_distance_to_prefer_time"])
        rows.append(selected)

    result = _sort_group_rows(pd.DataFrame(rows), group_columns)
    return result.reset_index(drop=True)

read_probability_observations(csv_paths, *, subject_column=None, fallback_subjects_by_file=None)

Read held-out probability observation CSVs for exact calibration aggregation.

Source code in src/neureptrace/results/__init__.py

def read_probability_observations(
    csv_paths: list[Path],
    *,
    subject_column: str | None = None,
    fallback_subjects_by_file: Mapping[str, object] | None = None,
) -> pd.DataFrame:
    """Read held-out probability observation CSVs for exact calibration aggregation."""
    if not csv_paths:
        raise ValueError("At least one observation CSV path is required.")

    fallback_subjects_by_file = dict(fallback_subjects_by_file or {})
    frames = []
    expected_probability_columns: tuple[str, ...] | None = None
    for csv_path in csv_paths:
        frame = pd.read_csv(csv_path)
        prob_columns = probability_columns(frame)
        missing = [column for column in ("time", "true_label") if column not in frame.columns]
        if not prob_columns:
            missing.append("prob_class_*")
        if missing:
            raise ValueError(f"{csv_path} is missing required probability-observation columns: {missing}")
        if expected_probability_columns is None:
            expected_probability_columns = prob_columns
        elif prob_columns != expected_probability_columns:
            raise ValueError(
                f"{csv_path} probability columns {list(prob_columns)} do not match "
                f"the first observation file {list(expected_probability_columns)}."
            )

        fallback_subject = str(fallback_subjects_by_file.get(csv_path.name, csv_path.stem))
        if subject_column is not None:
            if subject_column not in frame.columns:
                raise ValueError(f"{csv_path} is missing subject column '{subject_column}'.")
            frame["subject"] = frame[subject_column]
        elif "subject" not in frame.columns:
            frame["subject"] = fallback_subject

        frame["subject"] = frame["subject"].where(pd.notna(frame["subject"]), fallback_subject).astype(str)
        frame.loc[frame["subject"].str.len() == 0, "subject"] = fallback_subject
        frame = _normalize_group_defaults(frame)
        frame["source_file"] = csv_path.name
        frames.append(frame)

    return pd.concat(frames, ignore_index=True)

read_time_decode_observations(csv_paths, *, subject_column=None, result_csv_paths=None, results=None)

Read probability observations, optionally matching subject fallbacks to result files.

Source code in src/neureptrace/results/__init__.py

def read_time_decode_observations(
    csv_paths: list[Path],
    *,
    subject_column: str | None = None,
    result_csv_paths: list[Path] | None = None,
    results: pd.DataFrame | None = None,
) -> pd.DataFrame:
    """Read probability observations, optionally matching subject fallbacks to result files."""
    fallback_subjects_by_file: Mapping[str, object] | None = None
    if result_csv_paths is not None:
        if results is None:
            results = read_time_decode_results(result_csv_paths)
        fallback_subjects_by_file = _observation_subject_fallbacks(results, result_csv_paths, csv_paths)
    return read_probability_observations(
        csv_paths,
        subject_column=subject_column,
        fallback_subjects_by_file=fallback_subjects_by_file,
    )

read_time_decode_results(csv_paths, *, subject_column=None)

Read one or more time-resolved decoding result CSV files.

Source code in src/neureptrace/results/__init__.py

def read_time_decode_results(
    csv_paths: list[Path],
    *,
    subject_column: str | None = None,
) -> pd.DataFrame:
    """Read one or more time-resolved decoding result CSV files."""
    if not csv_paths:
        raise ValueError("At least one CSV path is required.")

    frames = []
    for csv_path in csv_paths:
        frame = pd.read_csv(csv_path)
        missing = [column for column in ("time", *METRIC_COLUMNS) if column not in frame.columns]
        if missing:
            raise ValueError(f"{csv_path} is missing required columns: {missing}")
        if subject_column is not None:
            if subject_column not in frame.columns:
                raise ValueError(f"{csv_path} is missing subject column '{subject_column}'.")
            frame["subject"] = frame[subject_column].astype(str)
        elif "subject" not in frame.columns:
            frame["subject"] = csv_path.stem
        else:
            frame["subject"] = frame["subject"].astype(str)
        frame = _normalize_group_defaults(frame)
        frame["source_file"] = csv_path.name
        frames.append(frame)

    return pd.concat(frames, ignore_index=True)

subject_time_metrics(results, *, observations=None, metric_columns=None, ece_bins=DEFAULT_ECE_BINS)

Return subject/time metrics with exact pooled ECE when observations are supplied.

Source code in src/neureptrace/results/__init__.py

def subject_time_metrics(
    results: pd.DataFrame,
    *,
    observations: pd.DataFrame | None = None,
    metric_columns: Sequence[str] | str | None = None,
    ece_bins: int = DEFAULT_ECE_BINS,
) -> pd.DataFrame:
    """Return subject/time metrics with exact pooled ECE when observations are supplied."""
    selected_metric_columns = _selected_metric_columns(metric_columns)
    missing = [column for column in ("subject", "time", *selected_metric_columns) if column not in results.columns]
    if missing:
        raise ValueError(f"Results are missing required columns: {missing}")
    ece_bins = _validate_positive_integer(ece_bins, name="ece_bins")

    results = _normalize_emission_mode(results)
    group_columns = [column for column in SUMMARY_GROUP_COLUMNS if column in results.columns]
    subject_time_keys = [*group_columns, "subject", "time"]
    subject_time = _mean_across_folds(results, subject_time_keys, metric_columns=selected_metric_columns).sort_values(
        subject_time_keys
    )
    if observations is not None and "ece" in selected_metric_columns:
        prepared_observations = _prepare_observations_for_subject_time(results, observations, group_columns)
        subject_time = _replace_ece_from_observations(
            subject_time,
            prepared_observations,
            subject_time_keys,
            n_bins=ece_bins,
            expected_counts=_expected_observation_counts(results, subject_time_keys),
        )
    return subject_time.sort_values(subject_time_keys).reset_index(drop=True)

summarize_metric_table(frame, value_column, group_columns, participant_column=None, chance_column=None, scale=1.0, *, percent_scale=None, percent_prefix='percent', chance_percent_column=None, chance_class_columns=None, permutation_p_column=None, p_value_thresholds=(0.05, 0.01), zero_singleton_dispersion=False)

Summarize a figure-independent metric table across rows or participants.

Optional keyword arguments add common grouped-reporting fields while keeping the default output backward-compatible: percentage-scaled metric summaries, chance-level ranges and class-count summaries, permutation p-value counts, and zero-valued dispersion for singleton groups.

Source code in src/neureptrace/results/tables.py

def summarize_metric_table(
    frame: pd.DataFrame,
    value_column: str,
    group_columns: Sequence[str] | str | None,
    participant_column: str | None = None,
    chance_column: str | None = None,
    scale: float = 1.0,
    *,
    percent_scale: float | None = None,
    percent_prefix: str = "percent",
    chance_percent_column: str | None = None,
    chance_class_columns: Sequence[str] | str | None = None,
    permutation_p_column: str | None = None,
    p_value_thresholds: Sequence[float] = (0.05, 0.01),
    zero_singleton_dispersion: bool = False,
) -> pd.DataFrame:
    """Summarize a figure-independent metric table across rows or participants.

    Optional keyword arguments add common grouped-reporting fields while keeping
    the default output backward-compatible: percentage-scaled metric summaries,
    chance-level ranges and class-count summaries, permutation p-value counts,
    and zero-valued dispersion for singleton groups.
    """
    group_columns = _normalize_columns(group_columns)
    chance_class_columns = _normalize_columns(chance_class_columns)
    required_columns = [value_column, *group_columns]
    if participant_column is not None:
        required_columns.append(participant_column)
    if chance_column is not None:
        required_columns.append(chance_column)
    _require_columns(frame, required_columns)

    working = frame.copy()
    working[value_column] = pd.to_numeric(working[value_column], errors="coerce") * scale
    if chance_column is not None:
        working[chance_column] = _numeric_without_booleans(working[chance_column]) * scale

    rows: list[dict[str, object]] = []
    for group_key, group in _iter_groups(working, group_columns):
        row = _group_row(group_columns, group_key)
        values = group[value_column]
        mean, std, sem, median = _series_summary(values, zero_singleton_dispersion=zero_singleton_dispersion)
        row.update(
            {
                "n_rows": int(len(group)),
                f"{value_column}_mean": mean,
                f"{value_column}_std": std,
                f"{value_column}_sem": sem,
                f"{value_column}_median": median,
            }
        )
        if percent_scale is not None:
            row.update(
                {
                    f"{percent_prefix}_mean": _scaled_or_nan(mean, percent_scale),
                    f"{percent_prefix}_median": _scaled_or_nan(median, percent_scale),
                    f"{percent_prefix}_std": _scaled_or_nan(std, percent_scale),
                    f"{percent_prefix}_sem": _scaled_or_nan(sem, percent_scale),
                }
            )
        if participant_column is not None:
            row["n_participants"] = int(group[participant_column].nunique(dropna=True))
        if chance_column is not None:
            chance_values = _chance_values_for_group(
                group,
                chance_column,
                chance_class_columns=chance_class_columns,
                scale=scale,
            )
            difference = values - chance_values
            chance_mean = _nanmean(chance_values)
            row[f"{chance_column}_mean"] = chance_mean
            row[f"{value_column}_above_chance_count"] = int((difference > 0).sum())
            row[f"{value_column}_minus_{chance_column}_mean"] = _nanmean(difference)
            if chance_percent_column is not None and percent_scale is not None:
                row[chance_percent_column] = _scaled_or_nan(chance_mean, percent_scale)
            if chance_class_columns:
                chance_classes = _chance_classes_for_group(
                    group,
                    chance_column,
                    chance_class_columns=chance_class_columns,
                    scale=scale,
                )
                row[f"{chance_column}_min"] = _nanmin(chance_values)
                row[f"{chance_column}_max"] = _nanmax(chance_values)
                row["chance_classes_mean"] = _nanmean(chance_classes)
                row["chance_classes_counts"] = _chance_classes_counts(chance_classes)
        if permutation_p_column is not None:
            p_values = _numeric_column_values(group, permutation_p_column)
            finite_p_values = p_values[np.isfinite(p_values)]
            row["n_with_permutation"] = int(finite_p_values.size)
            for threshold in p_value_thresholds:
                row[f"n_significant_p_{_threshold_suffix(threshold)}"] = int(np.sum(finite_p_values < float(threshold)))
        rows.append(row)

    return _sorted_frame(rows, group_columns)

write_provenance_table(summary, result_csv_paths, out_path, *, baseline_window=(-0.1, 0.0), effect_window=(0.1, 0.8), selection_metric='accuracy')

Write a benchmark provenance CSV from an aggregate summary and fold-level results.

Source code in src/neureptrace/results/__init__.py

def write_provenance_table(
    summary: pd.DataFrame,
    result_csv_paths: list[Path] | None,
    out_path: Path,
    *,
    baseline_window: tuple[float, float] = (-0.1, 0.0),
    effect_window: tuple[float, float] = (0.1, 0.8),
    selection_metric: str = "accuracy",
) -> pd.DataFrame:
    """Write a benchmark provenance CSV from an aggregate summary and fold-level results."""
    results = read_time_decode_results(result_csv_paths) if result_csv_paths else None
    provenance = build_provenance_table(
        summary,
        results,
        baseline_window=baseline_window,
        effect_window=effect_window,
        selection_metric=selection_metric,
    )
    out_path.parent.mkdir(parents=True, exist_ok=True)
    provenance.to_csv(out_path, index=False)
    return provenance

Tables

neureptrace.results.tables

peak_metric_rows(frame, metric_column, group_columns, time_column='time', prefer_time=0.0)

Select the peak metric row in each group, breaking ties toward a preferred time.

Source code in src/neureptrace/results/tables.py

def peak_metric_rows(
    frame: pd.DataFrame,
    metric_column: str,
    group_columns: Sequence[str],
    time_column: str = "time",
    prefer_time: float = 0.0,
) -> pd.DataFrame:
    """Select the peak metric row in each group, breaking ties toward a preferred time."""
    group_columns = _normalize_columns(group_columns)
    _require_columns(frame, [metric_column, time_column, *group_columns])
    preferred = _finite_numeric_scalar(prefer_time, name="prefer_time")

    rows: list[pd.Series] = []
    for _, group in _iter_groups(frame, group_columns):
        ranked = group.copy()
        ranked["_peak_metric_numeric"] = _finite_numeric_series(ranked[metric_column], name=metric_column)
        ranked["_peak_time_numeric"] = _finite_numeric_series(ranked[time_column], name=time_column)
        ranked["_peak_distance_to_prefer_time"] = (ranked["_peak_time_numeric"] - preferred).abs()
        ranked = ranked.sort_values(
            ["_peak_metric_numeric", "_peak_distance_to_prefer_time", "_peak_time_numeric"],
            ascending=[False, True, True],
            kind="mergesort",
        )
        selected = ranked.iloc[0].drop(labels=["_peak_metric_numeric", "_peak_time_numeric", "_peak_distance_to_prefer_time"])
        selected["peak_distance_to_prefer_time"] = float(ranked.iloc[0]["_peak_distance_to_prefer_time"])
        rows.append(selected)

    result = _sort_group_rows(pd.DataFrame(rows), group_columns)
    return result.reset_index(drop=True)

summarize_metric_table(frame, value_column, group_columns, participant_column=None, chance_column=None, scale=1.0, *, percent_scale=None, percent_prefix='percent', chance_percent_column=None, chance_class_columns=None, permutation_p_column=None, p_value_thresholds=(0.05, 0.01), zero_singleton_dispersion=False)

Summarize a figure-independent metric table across rows or participants.

Optional keyword arguments add common grouped-reporting fields while keeping the default output backward-compatible: percentage-scaled metric summaries, chance-level ranges and class-count summaries, permutation p-value counts, and zero-valued dispersion for singleton groups.

Source code in src/neureptrace/results/tables.py

def summarize_metric_table(
    frame: pd.DataFrame,
    value_column: str,
    group_columns: Sequence[str] | str | None,
    participant_column: str | None = None,
    chance_column: str | None = None,
    scale: float = 1.0,
    *,
    percent_scale: float | None = None,
    percent_prefix: str = "percent",
    chance_percent_column: str | None = None,
    chance_class_columns: Sequence[str] | str | None = None,
    permutation_p_column: str | None = None,
    p_value_thresholds: Sequence[float] = (0.05, 0.01),
    zero_singleton_dispersion: bool = False,
) -> pd.DataFrame:
    """Summarize a figure-independent metric table across rows or participants.

    Optional keyword arguments add common grouped-reporting fields while keeping
    the default output backward-compatible: percentage-scaled metric summaries,
    chance-level ranges and class-count summaries, permutation p-value counts,
    and zero-valued dispersion for singleton groups.
    """
    group_columns = _normalize_columns(group_columns)
    chance_class_columns = _normalize_columns(chance_class_columns)
    required_columns = [value_column, *group_columns]
    if participant_column is not None:
        required_columns.append(participant_column)
    if chance_column is not None:
        required_columns.append(chance_column)
    _require_columns(frame, required_columns)

    working = frame.copy()
    working[value_column] = pd.to_numeric(working[value_column], errors="coerce") * scale
    if chance_column is not None:
        working[chance_column] = _numeric_without_booleans(working[chance_column]) * scale

    rows: list[dict[str, object]] = []
    for group_key, group in _iter_groups(working, group_columns):
        row = _group_row(group_columns, group_key)
        values = group[value_column]
        mean, std, sem, median = _series_summary(values, zero_singleton_dispersion=zero_singleton_dispersion)
        row.update(
            {
                "n_rows": int(len(group)),
                f"{value_column}_mean": mean,
                f"{value_column}_std": std,
                f"{value_column}_sem": sem,
                f"{value_column}_median": median,
            }
        )
        if percent_scale is not None:
            row.update(
                {
                    f"{percent_prefix}_mean": _scaled_or_nan(mean, percent_scale),
                    f"{percent_prefix}_median": _scaled_or_nan(median, percent_scale),
                    f"{percent_prefix}_std": _scaled_or_nan(std, percent_scale),
                    f"{percent_prefix}_sem": _scaled_or_nan(sem, percent_scale),
                }
            )
        if participant_column is not None:
            row["n_participants"] = int(group[participant_column].nunique(dropna=True))
        if chance_column is not None:
            chance_values = _chance_values_for_group(
                group,
                chance_column,
                chance_class_columns=chance_class_columns,
                scale=scale,
            )
            difference = values - chance_values
            chance_mean = _nanmean(chance_values)
            row[f"{chance_column}_mean"] = chance_mean
            row[f"{value_column}_above_chance_count"] = int((difference > 0).sum())
            row[f"{value_column}_minus_{chance_column}_mean"] = _nanmean(difference)
            if chance_percent_column is not None and percent_scale is not None:
                row[chance_percent_column] = _scaled_or_nan(chance_mean, percent_scale)
            if chance_class_columns:
                chance_classes = _chance_classes_for_group(
                    group,
                    chance_column,
                    chance_class_columns=chance_class_columns,
                    scale=scale,
                )
                row[f"{chance_column}_min"] = _nanmin(chance_values)
                row[f"{chance_column}_max"] = _nanmax(chance_values)
                row["chance_classes_mean"] = _nanmean(chance_classes)
                row["chance_classes_counts"] = _chance_classes_counts(chance_classes)
        if permutation_p_column is not None:
            p_values = _numeric_column_values(group, permutation_p_column)
            finite_p_values = p_values[np.isfinite(p_values)]
            row["n_with_permutation"] = int(finite_p_values.size)
            for threshold in p_value_thresholds:
                row[f"n_significant_p_{_threshold_suffix(threshold)}"] = int(np.sum(finite_p_values < float(threshold)))
        rows.append(row)

    return _sorted_frame(rows, group_columns)