import unittest
import numpy as np
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_pipeline_exists(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "pipeline"),
            "The `pipeline` variable is defined.",
            "Expected `pipeline` to be defined."
        )

    def test_pipeline_type(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.pipeline, Pipeline),
            "The `pipeline` is a scikit-learn Pipeline.",
            "Expected `pipeline` to be an instance of `Pipeline`."
        )

    def test_pipeline_has_required_steps(self):
        import user_code
        steps = dict(user_code.pipeline.steps)

        condition = (
            "preprocessor" in steps and "model" in steps
            and isinstance(steps["preprocessor"], ColumnTransformer)
        )

        _dynamic_test(
            self,
            condition,
            "The pipeline contains `preprocessor` and `model` steps.",
            "Expected the pipeline to include `preprocessor` and `model` steps."
        )

    def test_predictions_exist(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "y_pred"),
            "The `y_pred` variable is defined.",
            "Expected `y_pred` to be defined."
        )

    def test_predictions_shape(self):
        import user_code
        y_pred = user_code.y_pred

        condition = hasattr(y_pred, "shape") and y_pred.shape == (2,)

        _dynamic_test(
            self,
            condition,
            "The predictions have the correct shape.",
            f"Expected predictions of shape (2,), but got {getattr(y_pred, 'shape', None)}."
        )

    def test_predictions_are_binary(self):
        import user_code
        y_pred = user_code.y_pred
        unique_vals = set(np.unique(y_pred).tolist())

        condition = unique_vals.issubset({0, 1})

        _dynamic_test(
            self,
            condition,
            "The predictions contain valid class labels.",
            f"Expected predictions to contain only 0 and 1, but got {sorted(unique_vals)}."
        )

if __name__ == "__main__":
    unittest.main()


test_main.py

Master the scikit-learn library by learning its API, core abstractions, and engineering patterns. Focus on syntax, structure, and workflow to confidently build, compose, and inspect machine learning pipelines using scikit-learn.

Explore the foundational Estimator API, understand fit/predict/transform, and learn the design philosophy behind scikit-learn’s consistent interface.

Dive into transformers, preprocessing objects, and how to build robust data pipelines using scikit-learn’s modular approach.

Master scikit-learn’s pipeline and composition tools to create maintainable, reproducible workflows.

Leverage scikit-learn’s model selection and evaluation tools for robust, reproducible workflows.

Learn to inspect, configure, and refactor scikit-learn objects for robust, maintainable code. Avoid common anti-patterns.

Challenge: Compose a Data Pipeline

Oplossing

Challenge: Compose a Data Pipeline

Oplossing