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, videregående kurs for Python-utviklere som ønsker å mestre datahåndtering med Polars, ved bruk av virkelige datasett fra Steam-spill. Lær Polars' kolonnebaserte paradigme, utvalg, aggregering, sammenkobling, omforming og essensielle operasjoner for tekst, dato og manglende data.

Utforsk de grunnleggende forskjellene mellom Polars og tradisjonelle radbaserte DataFrames, med fokus på kolonnebaserte operasjoner, seleksjon og betinget logikk ved bruk av Steam-spilldatasettet.

Få en solid forståelse av Polars' parallelle group-by, aggregering, sammenkobling og omforming ved bruk av datasett fra Steam-spill og spioninnsikt.

Utforsk det grunnleggende innen datarensing: tekstnormalisering, datoanalyse og robust håndtering av manglende verdier i Polars.

Utfordring: Datoer og Klokkeslett

Løsning