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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Updated to match the exact column names expected by your solution
        self.df = pl.DataFrame({
            "Name": ["Portal 2", "Counter-Strike", "Dota 2"],
            "Positive": [90, 80, 50],
            "Negative": [10, 20, 50]
        })

    def test_positive_ratio_column_exists(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "calculate_positive_ratio", None)
        _dynamic_test(
            self,
            callable(func),
            "calculate_positive_ratio function exists and is callable.",
            "calculate_positive_ratio function is missing or not callable."
        )
        result = func(self.df)
        _dynamic_test(
            self,
            result is not None and "Positive Ratio" in result.columns,
            "Returned DataFrame contains 'Positive Ratio' column.",
            "Returned DataFrame is missing 'Positive Ratio' column."
        )

    def test_positive_ratio_values_correct(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "calculate_positive_ratio", None)
        result = func(self.df)
        
        # Expected ratios: 90/100 = 0.9, 80/100 = 0.8, 50/100 = 0.5
        expected = [0.9, 0.8, 0.5]
        if result is not None and "Positive Ratio" in result.columns:
            actual = result["Positive Ratio"].to_list()
            # Checking with tolerance for floating-point values
            is_correct = all(abs(a - b) < 1e-5 for a, b in zip(actual, expected))
            _dynamic_test(
                self,
                is_correct,
                "'Positive Ratio' column contains correct proportional values.",
                f"'Positive Ratio' values incorrect. Expected: {expected}, Got: {actual}"
            )
        else:
            _dynamic_test(self, False, "", "Result missing 'Positive Ratio' column.")

    def test_context_behavior_preserves_columns(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "calculate_positive_ratio", None)
        result = func(self.df)
        if result is not None:
            # Enforce that it used with_columns (keeps everything) rather than select (drops unmentioned columns)
            # Updated to match your expected input column names
            for col in ["Name", "Positive", "Negative"]:
                _dynamic_test(
                    self,
                    col in result.columns,
                    f"Context verification passed: Column '{col}' was preserved.",
                    f"Context verification failed: Column '{col}' is missing. Did you accidentally use .select() instead of .with_columns()?"
                )
        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__":
    # verbosity=2 ensures dynamic names are printed to standard output
    unittest.main(verbosity=2)

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: Kjernekontekster Select vs With_columns

Løsning