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

Un corso pratico di livello intermedio per sviluppatori Python per padroneggiare la manipolazione dei dati con Polars, utilizzando dataset reali di giochi Steam. Approfondimento sul paradigma colonnare di Polars, selezione, aggregazione, join, reshaping e operazioni essenziali su stringhe, date e dati mancanti.

Esplora le differenze fondamentali tra Polars e i tradizionali DataFrame basati su righe, concentrandoti sulle operazioni colonnari, sulla selezione e sulla logica condizionale utilizzando il dataset dei giochi Steam.

Acquisizione di una solida comprensione delle capacità di group-by parallelo, aggregazione, join e rimodellamento di Polars utilizzando i dataset di giochi Steam e di analisi delle spie.

Esplora gli elementi essenziali della pulizia dei dati: normalizzazione del testo, parsing delle date e gestione robusta dei valori mancanti in Polars.

Sfida: Passare dalle Righe alle Colonne

Soluzione