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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Initializing local mock dataset using exact un-renamed raw file schemas
        # FIX: Changed pl.F64 to pl.Float64 to match proper Polars type syntax
        self.df = pl.DataFrame({
            "Name": ["Half-Life 2", "Unreleased Indie Game", "Portal", "Free Beta Test"],
            "Price": [9.99, None, 19.99, None]  # None acts as Null in Polars constructors
        }, schema={"Name": pl.String, "Price": pl.Float64})

    def test_price_column_exists_and_unnamed(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "handle_missing_prices", None)
        _dynamic_test(
            self,
            callable(func),
            "handle_missing_prices function exists and is callable.",
            "handle_missing_prices function is missing or not callable."
        )
        result = func(self.df)
        _dynamic_test(
            self,
            result is not None and "Price" in result.columns,
            "Returned DataFrame retains original raw column name 'Price'.",
            "Returned DataFrame is missing the required raw column 'Price'. Did you accidentally rename it?"
        )

    def test_null_values_filled_correctly(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "handle_missing_prices", None)
        result = func(self.df)
        
        # Expected outputs: None values should map to 0.0, actual numbers must remain unaltered
        expected_prices = [9.99, 0.0, 19.99, 0.0]
        
        if result is not None and "Price" in result.columns:
            actual_prices = result["Price"].to_list()
            _dynamic_test(
                self,
                actual_prices == expected_prices,
                "Null values successfully targeted and replaced with fallback float values.",
                f"Null replacement logic failed. Expected: {expected_prices}, Got: {actual_prices}"
            )
        else:
            _dynamic_test(self, False, "", "Sanitation evaluation halted due to column tracking schema faults.")

    def test_other_attributes_preserved(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "handle_missing_prices", None)
        result = func(self.df)
        if result is not None:
            _dynamic_test(
                self,
                "Name" in result.columns,
                "Context validation passed: Text identifier column 'Name' remains unchanged.",
                "Context validation failed: Primary data structural columns were altered or dropped."
            )
        else:
            _dynamic_test(self, False, "", "Returned DataFrame is None.")

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)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    if not assign_nodes:
        return code

    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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

test_main.py

Un curso práctico de nivel intermedio para desarrolladores de Python que deseen dominar la manipulación de datos con Polars, utilizando conjuntos de datos reales de juegos de Steam. Aprenda el paradigma columnar de Polars, selección, agregación, combinación, reestructuración y operaciones esenciales con cadenas, fechas y datos faltantes.

Explora las diferencias fundamentales entre Polars y los DataFrames tradicionales basados en filas, centrándote en las operaciones columnares, la selección y la lógica condicional utilizando el conjunto de datos de juegos de Steam.

Adquisición de una comprensión sólida de las capacidades de agrupación paralela, agregación, combinación y reestructuración de Polars utilizando los conjuntos de datos de juegos de Steam y de insights de espías.

Explora los aspectos esenciales de la limpieza de datos: normalización de texto, análisis de fechas y manejo robusto de valores faltantes en Polars.

Desafío: Manejo de Valores Nulos

Solución