check_scorer_aggregation_methods¶

def check_scorer_aggregation_methods(
    scorer,
    y_truth: pl.DataFrame,
    y_pred: pl.DataFrame,
    aggregation_methods: list[str],
) -> None:
    """Check all aggregation_method combinations produce valid output.

    Parameters
    ----------
    scorer : BaseScorer
        Scorer instance with aggregation_method parameter
    y_truth : pl.DataFrame
        Ground truth
    y_pred : pl.DataFrame
        Predictions
    aggregation_methods : list of str
        Valid aggregation methods to test

    Raises
    ------
    AssertionError
        If any aggregation method fails or produces invalid output

    Notes
    -----
    A scalar is returned only when stepwise, vintagewise, and componentwise
    aggregations are all applied together; partial aggregations (e.g.,
    ['stepwise'] only) return a DataFrame.

    """
    for agg_method in aggregation_methods:
        scorer_copy = clone(scorer)
        scorer_copy.set_params(aggregation_method=[agg_method])

        # Always fit scorer before scoring
        scorer_copy.fit(y_truth)

        try:
            score = scorer_copy.score(y_truth, y_pred)

            # Validate return type - can be scalar or DataFrame depending on aggregation
            if isinstance(score, pl.DataFrame):
                # DataFrame is valid for partial aggregations (e.g., stepwise only)
                assert len(score) > 0, f"aggregation_method={agg_method}: returned empty DataFrame"
                assert not score.null_count().sum_horizontal()[0] > 0, (
                    f"aggregation_method={agg_method}: DataFrame contains null values"
                )
            elif isinstance(score, int | float | np.number):
                # Scalar is valid for full aggregations
                assert not np.isnan(score), f"aggregation_method={agg_method}: score is NaN"
            else:
                raise AssertionError(
                    f"aggregation_method={agg_method}: score should be numeric or DataFrame, got {type(score)}"
                )
        except Exception as e:
            raise AssertionError(f"aggregation_method={agg_method} failed: {e}") from e