Skip to content

check_fit_sets_forecaster_attributes

yohou.testing.forecaster.check_fit_sets_forecaster_attributes(forecaster, y, X_actual=None, forecasting_horizon=3, X_future=None, X_forecast=None)

Check fit() sets required forecaster attributes.

Validates that fit() creates all required attributes for forecasters including fit_forecasting_horizon_, interval_, groups_, local_y_schema_, observation buffers, and transformer references.

Parameters

Name Type Description Default
forecaster BaseForecaster

Unfitted forecaster instance

 required
y DataFrame

Training target data with "time" column

 required
X_actual DataFrame

Training features with "time" column

 None
forecasting_horizon int

Number of steps ahead to forecast

 3
X_future DataFrame

Known-future features with "time" column

 None
X_forecast DataFrame

External forecasts in tidy format

 None

Raises

Type Description
AssertionError

If required attributes are not set after fit()

Source Code

View on GitHub

Show/Hide source 
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
def check_fit_sets_forecaster_attributes(
    forecaster,
    y: pl.DataFrame,
    X_actual: pl.DataFrame | None = None,
    forecasting_horizon: int = 3,
    X_future: pl.DataFrame | None = None,
    X_forecast: pl.DataFrame | None = None,
) -> None:
    """Check fit() sets required forecaster attributes.

    Validates that fit() creates all required attributes for forecasters including
    fit_forecasting_horizon_, interval_, groups_, local_y_schema_,
    observation buffers, and transformer references.

    Parameters
    ----------
    forecaster : BaseForecaster
        Unfitted forecaster instance
    y : pl.DataFrame
        Training target data with "time" column
    X_actual : pl.DataFrame, optional
        Training features with "time" column
    forecasting_horizon : int, default=3
        Number of steps ahead to forecast
    X_future : pl.DataFrame, optional
        Known-future features with "time" column
    X_forecast : pl.DataFrame, optional
        External forecasts in tidy format

    Raises
    ------
    AssertionError
        If required attributes are not set after fit()

    """
    forecaster_clone = clone(forecaster)
    forecaster_clone.fit(y, X_actual, forecasting_horizon=forecasting_horizon, X_future=X_future, X_forecast=X_forecast)

    # Check core fitted attributes
    assert hasattr(forecaster_clone, "fit_forecasting_horizon_"), "fit() must set fit_forecasting_horizon_ attribute"
    assert forecaster_clone.fit_forecasting_horizon_ == forecasting_horizon, (
        f"fit_forecasting_horizon_ should be {forecasting_horizon}, got {forecaster_clone.fit_forecasting_horizon_}"
    )

    assert hasattr(forecaster_clone, "interval_"), "fit() must set interval_ attribute (timedelta)"

    assert hasattr(forecaster_clone, "groups_"), "fit() must set groups_ attribute (None or list)"
    assert hasattr(forecaster_clone, "local_y_schema_"), (
        "fit() must set local_y_schema_ attribute (dict[str, pl.DataType])"
    )
    assert hasattr(forecaster_clone, "local_X_actual_schema_"), (
        "fit() must set local_X_actual_schema_ attribute (dict[str, pl.DataType])"
    )
    assert hasattr(forecaster_clone, "shared_X_actual_schema_"), (
        "fit() must set shared_X_actual_schema_ attribute (None or dict[str, pl.DataType])"
    )
    assert hasattr(forecaster_clone, "local_y_t_schema_"), (
        "fit() must set local_y_t_schema_ attribute (None or dict[str, pl.DataType])"
    )
    assert hasattr(forecaster_clone, "local_X_t_schema_"), (
        "fit() must set local_X_t_schema_ attribute (None or dict[str, pl.DataType])"
    )

    # Check observation buffers
    assert hasattr(forecaster_clone, "_y_observed"), "fit() must set _y_observed buffer"
    assert hasattr(forecaster_clone, "_X_t_observed"), "fit() must set _X_t_observed buffer"

    # Check transformer attributes
    if forecaster_clone.target_transformer is not None:
        assert hasattr(forecaster_clone, "target_transformer_"), (
            "fit() must set target_transformer_ when target_transformer provided"
        )

    if forecaster_clone.feature_transformer is not None:
        assert hasattr(forecaster_clone, "feature_transformer_"), (
            "fit() must set feature_transformer_ when feature_transformer provided"
        )

    # Check step column attributes when X_future/X_forecast provided
    if X_future is not None or X_forecast is not None:
        assert hasattr(forecaster_clone, "_step_column_names_"), "fit() must set _step_column_names_ attribute"
        assert len(forecaster_clone._step_column_names_) > 0, (
            "_step_column_names_ should be non-empty when X_future/X_forecast provided"
        )
        if X_future is not None:
            assert hasattr(forecaster_clone, "_X_future_schema_"), (
                "fit() must set _X_future_schema_ when X_future provided"
            )
            assert hasattr(forecaster_clone, "_X_future_raw_"), "fit() must set _X_future_raw_ when X_future provided"
            assert forecaster_clone._X_future_raw_ is not None, (
                "_X_future_raw_ should not be None when X_future provided"
            )
        if X_forecast is not None:
            assert hasattr(forecaster_clone, "_X_forecast_schema_"), (
                "fit() must set _X_forecast_schema_ when X_forecast provided"
            )
            assert hasattr(forecaster_clone, "_X_forecast_raw_"), (
                "fit() must set _X_forecast_raw_ when X_forecast provided"
            )
            assert forecaster_clone._X_forecast_raw_ is not None, (
                "_X_forecast_raw_ should not be None when X_forecast provided"
            )
    elif hasattr(forecaster_clone, "_step_column_names_"):
        assert len(forecaster_clone._step_column_names_) == 0, (
            "_step_column_names_ should be empty when no X_future/X_forecast"
        )