check_transformer_methods_call_check_is_fitted

yohou.testing.transformer.check_transformer_methods_call_check_is_fitted(transformer, X, y=None)

Check all transformer methods (except fit) raise NotFittedError when unfitted.

Validates that transform(), rewind(), observe(), observe_transform(), and inverse_transform() methods all check fitted state and raise NotFittedError before operating on an unfitted transformer.

Parameters

Name	Type	Description	Default
transformer	BaseTransformer	Unfitted transformer instance	required
X	DataFrame	Training/test data with "time" column (should have at least 100 rows for slicing)	required
y	DataFrame	Target data for supervised transformers	None

Raises

Type	Description
AssertionError	If any method fails to raise NotFittedError when called on unfitted transformer

Source Code

View on GitHub

Show/Hide source

def check_transformer_methods_call_check_is_fitted(transformer, X: pl.DataFrame, y: pl.DataFrame | None = None) -> None:
    """Check all transformer methods (except fit) raise NotFittedError when unfitted.

    Validates that transform(), rewind(), observe(), observe_transform(), and
    inverse_transform() methods all check fitted state and raise NotFittedError
    before operating on an unfitted transformer.

    Parameters
    ----------
    transformer : BaseTransformer
        Unfitted transformer instance
    X : pl.DataFrame
        Training/test data with "time" column (should have at least 100 rows for slicing)
    y : pl.DataFrame, optional
        Target data for supervised transformers

    Raises
    ------
    AssertionError
        If any method fails to raise NotFittedError when called on unfitted transformer

    """
    transformer_clone = clone(transformer)

    # Test that transform() raises NotFittedError when unfitted
    try:
        transformer_clone.transform(X)
        raise AssertionError(
            f"{transformer_clone.__class__.__name__}.transform() must raise NotFittedError when called on unfitted transformer"
        )
    except NotFittedError:
        pass  # Expected

    # Test that observe() raises NotFittedError when unfitted
    try:
        transformer_clone.observe(X)
        raise AssertionError(
            f"{transformer_clone.__class__.__name__}.observe() must raise NotFittedError when called on unfitted transformer"
        )
    except NotFittedError:
        pass  # Expected

    # Test that rewind() raises NotFittedError when unfitted
    try:
        transformer_clone.rewind(X)
        raise AssertionError(
            f"{transformer_clone.__class__.__name__}.rewind() must raise NotFittedError when called on unfitted transformer"
        )
    except NotFittedError:
        pass  # Expected

    # Test that observe_transform() raises NotFittedError when unfitted
    try:
        transformer_clone.observe_transform(X)
        raise AssertionError(
            f"{transformer_clone.__class__.__name__}.observe_transform() must raise NotFittedError when called on unfitted transformer"
        )
    except NotFittedError:
        pass  # Expected

    # Test that rewind_transform() raises NotFittedError when unfitted
    try:
        transformer_clone.rewind_transform(X)
        raise AssertionError(
            f"{transformer_clone.__class__.__name__}.rewind_transform() must raise NotFittedError when called on unfitted transformer"
        )
    except NotFittedError:
        pass  # Expected

    # Test inverse_transform() if implemented
    if hasattr(transformer_clone, "inverse_transform"):
        # Need to fit the transformer first to be able to call transform and get X_t
        transformer_clone.fit(X, y)
        X_t = transformer_clone.transform(X)

        # Create a fresh unfitted clone
        transformer_clone2 = clone(transformer)
        try:
            transformer_clone2.inverse_transform(X_t, X_p=X)
            raise AssertionError(
                f"{transformer.__class__.__name__}.inverse_transform() must raise NotFittedError when called on unfitted transformer"
            )
        except NotFittedError:
            pass  # Expected