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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Mock dataset designed to test boundaries: Free, Budget (exact 10.0), Premium, and invalid Positive values
        self.df = pl.DataFrame({
            "Name": ["Freebie", "Cheap Game", "Exact Ten", "Expensive", "No Reviews", "Negative Reviews"],
            "Price": [0.0, 4.99, 10.0, 14.99, 0.0, 5.0],
            "Positive": [100, 50, 25, 200, 0, -5]
        })

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

    def test_filtering_logic_correct(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "filter_and_tier_games", None)
        result = func(self.df)
        
        # 'No Reviews' (0) and 'Negative Reviews' (-5) should be filtered out
        expected_names = ["Freebie", "Cheap Game", "Exact Ten", "Expensive"]
        
        if result is not None:
            actual_names = result["Name"].to_list()
            _dynamic_test(
                self,
                actual_names == expected_names,
                "Filtering logic correctly retains only games with Positive > 0.",
                f"Filtering logic failed. Expected games: {expected_names}, Got: {actual_names}"
            )
        else:
            _dynamic_test(self, False, "", "Returned DataFrame is None.")

    def test_price_tier_values_correct(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "filter_and_tier_games", None)
        result = func(self.df)
        
        # Expected tiers corresponding to the filtered games
        expected_tiers = ["Free", "Budget", "Budget", "Premium"]
        
        if result is not None and "Price Tier" in result.columns:
            actual_tiers = result["Price Tier"].to_list()
            _dynamic_test(
                self,
                actual_tiers == expected_tiers,
                "'Price Tier' column contains correct classifications (Free, Budget, Premium).",
                f"'Price Tier' values incorrect. Expected: {expected_tiers}, Got: {actual_tiers}"
            )
        else:
            _dynamic_test(self, False, "", "Result missing 'Price Tier' column.")

    def test_original_columns_preserved(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, "filter_and_tier_games", None)
        result = func(self.df)
        
        if result is not None:
            for col in ["Name", "Price", "Positive"]:
                _dynamic_test(
                    self,
                    col in result.columns,
                    f"Context verification passed: Column '{col}' was preserved.",
                    f"Context verification failed: Column '{col}' is missing."
                )
        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(verbosity=2)

test_main.py

Un cours pratique de niveau intermédiaire destiné aux développeurs Python pour maîtriser la manipulation de données avec Polars, en utilisant des jeux de données réels issus de Steam. Approfondissement du paradigme en colonnes de Polars, de la sélection, de l’agrégation, des jointures, de la restructuration, ainsi que des opérations essentielles sur les chaînes de caractères, les dates et les données manquantes.

Explorez les principales différences entre Polars et les DataFrames traditionnels basés sur les lignes, en mettant l'accent sur les opérations en colonnes, la sélection et la logique conditionnelle à l'aide du jeu de données Steam games.

Acquérir une compréhension approfondie des capacités de groupement parallèle, d'agrégation, de jointure et de restructuration de Polars en utilisant les jeux de données Steam games et spy insights.

Explorez les éléments essentiels du nettoyage des données : normalisation du texte, analyse des dates et gestion robuste des valeurs manquantes dans Polars.

Défi : Filtrage et Logique Conditionnelle

Solution