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

Ein praxisorientierter, mittlerer Kurs für Python-Entwickler zur Beherrschung des Data Wrangling mit Polars anhand von realen Steam-Spieldatensätzen. Vermittelt wird das spaltenorientierte Paradigma von Polars, Selektion, Aggregation, Verknüpfung, Umformung sowie grundlegende Operationen mit Zeichenketten, Datumswerten und fehlenden Daten.

Untersuchung der grundlegenden Unterschiede zwischen Polars und traditionellen zeilenbasierten DataFrames mit Schwerpunkt auf spaltenbasierten Operationen, Selektion und bedingter Logik anhand des Steam-Games-Datensatzes.

Erwerben Sie ein fundiertes Verständnis der parallelen Group-by-, Aggregations-, Join- und Umformungsfunktionen von Polars anhand der Steam-Spiele- und Spy-Insights-Datensätze.

Erkunden Sie die Grundlagen der Datenbereinigung: Textnormalisierung, Datumsanalyse und robuste Behandlung fehlender Werte in Polars.

Herausforderung: Daten & Zeiten

Lösung