import unittest
import user_code
import ast
import re   
import importlib
import csv
import polars as pl
from datetime import date

class TestTask(unittest.TestCase):
    def setUp(self):
        # Build local mock dataframe using exact un-renamed file schemas
        self.df = pl.DataFrame({
            "Name": ["Cyberpunk 2077", "Terraria", "Portal 2", "Bad Date Entry"],
            "Release date": ["Dec 10, 2020", "May 16, 2011", "Apr 18, 2011", "2020-12"]
        })

    def test_release_date_column_exists_and_unrenamed(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "parse_release_dates", None)
        _dynamic_test(
            self,
            callable(func),
            "parse_release_dates function exists and is callable.",
            "parse_release_dates function is missing or not callable."
        )
        result = func(self.df)
        _dynamic_test(
            self,
            result is not None and "Release date" in result.columns,
            "Returned DataFrame successfully preserves the raw casing header 'Release date'.",
            "Returned DataFrame is missing the required raw column 'Release date'. Ensure names are un-renamed."
        )

    def test_date_parsing_logic_and_strict_handling(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "parse_release_dates", None)
        result = func(self.df)
        
        # Expected outputs: Matched strings become date objects, malformed strings become None (Null)
        expected_dates = [date(2020, 12, 10), date(2011, 5, 16), date(2011, 4, 18), None]
        
        if result is not None and "Release date" in result.columns:
            # Polars Date columns map directly to Python datetime.date objects upon exporting to lists
            actual_dates = result["Release date"].to_list()
            _dynamic_test(
                self,
                actual_dates == expected_dates,
                "Date parsing executed successfully. Aligned records converted to dates, unaligned records set to Null.",
                f"Date parsing calculations failed. Expected: {expected_dates}, Got: {actual_dates}"
            )
            
            # Enforce that the data type of the column is a structural Date type
            _dynamic_test(
                self,
                result["Release date"].dtype == pl.Date,
                "Column metadata successfully updated to data type 'pl.Date'.",
                f"Column data type is incorrect. Expected pl.Date, Got: {result['Release date'].dtype}"
            )
        else:
            _dynamic_test(self, False, "", "Date processing validation halted due to schema faults.")

    def test_other_columns_intact(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "parse_release_dates", None)
        result = func(self.df)
        if result is not None:
            _dynamic_test(
                self,
                "Name" in result.columns,
                "Context validation passed: Non-targeted tracking columns like 'Name' remain safe.",
                "Context validation failed: Unrelated columns were dropped during date conversion."
            )
        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: Fechas y Horas

Solución