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

Et praktisk, mellemniveau kursus for Python-udviklere til at mestre datahåndtering med Polars ved brug af virkelige Steam-spildatasæt. Lær Polars' kolonnebaserede paradigme, selektion, aggregering, sammenkobling, omformning samt essentielle operationer med tekst, datoer og manglende data.

Undersøg de centrale forskelle mellem Polars og traditionelle række-baserede DataFrames med fokus på kolonnebaserede operationer, udvælgelse og betinget logik ved brug af Steam-spildatasættet.

Opnå en solid forståelse af Polars' parallelle group-by, aggregering, join og omformningsfunktioner ved brug af Steam-spil og spionindsigts-datasæt.

Udforsk det grundlæggende i datarensning: tekstnormalisering, dato-parsing og robust håndtering af manglende værdier i Polars.

Udfordring: Datoer og Tidspunkter

Løsning