import unittest
import user_code
import ast
import re   
import importlib
import csv
import polars as pl

class TestTask(unittest.TestCase):
    def setUp(self):
        # Local layout representation to test validation logic
        self.df = pl.DataFrame({
            "Required age": [0, 16, 0, 16],
            "Is_Free": [True, False, True, True],
            "Peak CCU": [5000, 12000, 3000, 4500]
        })

    def test_pivot_matrix_columns_exist(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "pivot_game_metrics", None)
        _dynamic_test(
            self,
            callable(func),
            "pivot_game_metrics function exists and is callable.",
            "pivot_game_metrics function is missing or not callable."
        )
        result = func(self.df)
        
        _dynamic_test(
            self,
            result is not None and "Required age" in result.columns,
            "Reshaped DataFrame preserves the row tracking index 'Required age'.",
            "Reshaped DataFrame is missing required index column 'Required age'."
        )
        _dynamic_test(
            self,
            "true" in result.columns or "True" in result.columns,
            "Pivot engine successfully shifted pricing boolean categories into column headers.",
            f"Expected pricing categories as headers, but found columns: {result.columns}"
        )

    def test_pivot_matrix_values_are_accurate(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "pivot_game_metrics", None)
        result = func(self.df)
        
        if result is not None:
            true_col = "true" if "true" in result.columns else "True"
            false_col = "false" if "false" in result.columns else "False"
            
            # Isolate Mature Rating row (Age 16) for calculation verification
            mature_row = result.filter(pl.col("Required age") == 16)
            
            # Age 16 Free mean: 4500
            # Age 16 Paid mean: 12000
            actual_free_ccu = mature_row[true_col][0]
            actual_paid_ccu = mature_row[false_col][0]
            
            _dynamic_test(
                self,
                actual_free_ccu == 4500,
                "Pivot aggregation engine accurately calculated mean values across matching indices.",
                f"Incorrect cell value calculated. Expected 4500, Got: {actual_free_ccu}"
            )
            _dynamic_test(
                self,
                actual_paid_ccu == 12000,
                "Pivot aggregation engine accurately isolated independent column configurations.",
                f"Incorrect cell value mapped. Expected 12000, Got: {actual_paid_ccu}"
            )
        else:
            _dynamic_test(self, False, "", "Reshaping validation skipped due to missing return references.")

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)

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

test_main.py

Dive into the fundamentals of data wrangling with Polars, using real-world Steam game datasets. Learn Polars' columnar paradigm, selection, aggregation, joining, reshaping, and essential string, date, and missing data operations.

Explore the core differences between Polars and traditional row-based DataFrames, focusing on columnar operations, selection, and conditional logic using the Steam games dataset.

Gain a solid understanding of Polars' parallel group-by, aggregation, joining, and reshaping capabilities using the Steam games and spy insights datasets.

Explore the essentials of data cleaning: text normalization, date parsing, and robust handling of missing values in Polars.

Challenge: Reshaping Layouts

Solution