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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Initializing local mock dataset using Polars DataFrame to match your solution
        self.df = pl.DataFrame({
            "Name": ["Portal", "Half-Life", "Left 4 Dead"],
            "Positive": [1500, 2000, 1800],
            "Negative": [100, 150, 120]
        })

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

    def test_total_reviews_values_correct(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "add_total_reviews", None)
        result = func(self.df)
        expected = [1600, 2150, 1920]
        
        if result is not None and "Total Reviews" in result.columns:
            actual = result["Total Reviews"].to_list()
            _dynamic_test(
                self,
                actual == expected,
                "'Total Reviews' column contains correct sums.",
                f"'Total Reviews' values incorrect. Expected: {expected}, Got: {actual}"
            )
        else:
            _dynamic_test(self, False, "", "Result missing 'Total Reviews' column.")

    def test_original_columns_unchanged(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "add_total_reviews", None)
        result = func(self.df)
        if result is not None:
            # Updated to match the columns your code actually uses
            for col in ["Name", "Positive", "Negative"]:
                _dynamic_test(
                    self,
                    col in result.columns,
                    f"Column '{col}' is present in the returned DataFrame.",
                    f"Column '{col}' is missing in the returned DataFrame."
                )
        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__":
    # Added verbosity=2 so standard output clearly shows the dynamic naming
    unittest.main(verbosity=2)

test_main.py

En praktisk, intermediär kurs för Python-utvecklare som vill bemästra datahantering med Polars, med hjälp av verkliga Steam-speldataset. Lär dig Polars kolumnära paradigm, urval, aggregering, sammanslagning, omformning samt viktiga operationer för strängar, datum och hantering av saknade data.

Utforska de grundläggande skillnaderna mellan Polars och traditionella radbaserade DataFrames, med fokus på kolumnbaserade operationer, urval och villkorslogik med hjälp av Steam-speldatasetet.

Få en gedigen förståelse för Polars parallella group-by, aggregering, sammanslagning och omformningsmöjligheter med hjälp av Steam-spel och spioninsiktsdatamängder.

Utforska grunderna i datarensning: textnormalisering, datumtolkning och robust hantering av saknade värden i Polars.

Utmaning: Att Gå Från Rader Till Kolumner

Lösning