
import unittest
import user_code
import ast
import re   
import unittest
import importlib
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'Player': ['Alice', 'Bob', 'Charlie', 'Diana', 'Ethan'],
            'Points': [12, 18, 15, 20, 10]
        }
        self.df = pd.DataFrame(self.data)

    def test_mean_points(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.analyze_player_stats(self.df)
        expected = self.df['Points'].mean()
        _dynamic_test(
            self,
            abs(result[0] - expected) < 1e-6,
            f"Mean points is correct: {result[0]}",
            f"Mean points incorrect. Expected {expected}, got {result[0]}"
        )

    def test_median_points(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.analyze_player_stats(self.df)
        expected = self.df['Points'].median()
        _dynamic_test(
            self,
            abs(result[1] - expected) < 1e-6,
            f"Median points is correct: {result[1]}",
            f"Median points incorrect. Expected {expected}, got {result[1]}"
        )

    def test_std_points(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.analyze_player_stats(self.df)
        expected = self.df['Points'].std()
        _dynamic_test(
            self,
            abs(result[2] - expected) < 1e-6,
            f"Standard deviation is correct: {result[2]}",
            f"Standard deviation incorrect. Expected {expected}, got {result[2]}"
        )

    def test_interpretation_string(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.analyze_player_stats(self.df)
        interp = result[3]
        mean_val = f"mean points: {result[0]:.2f}".lower()
        median_val = f"median points: {result[1]:.2f}".lower()
        std_val = f"standard deviation: {result[2]:.2f}".lower()
        _dynamic_test(
            self,
            mean_val in interp.lower(),
            "Interpretation string references mean.",
            f"Interpretation string missing mean: '{mean_val}'"
        )
        _dynamic_test(
            self,
            median_val in interp.lower(),
            "Interpretation string references median.",
            f"Interpretation string missing median: '{median_val}'"
        )
        _dynamic_test(
            self,
            std_val in interp.lower(),
            "Interpretation string references standard deviation.",
            f"Interpretation string missing std: '{std_val}'"
        )
        _dynamic_test(
            self,
            ("mean and median are close" in interp.lower()) or ("mean is close to median" in interp.lower()),
            "Interpretation comments on mean and median relationship.",
            "Interpretation string should comment on the relationship between mean and median."
        )
        _dynamic_test(
            self,
            ("standard deviation indicates greater variability" in interp.lower()) or ("standard deviation suggests greater variability" in interp.lower()),
            "Interpretation comments on variability.",
            "Interpretation string should comment on what standard deviation suggests about variability."
        )

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
    # Collect all assignment nodes to modify
    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 nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    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

Explore the core concepts and practical techniques of sports analytics using Python. This course covers essential data analysis, visualization, and machine learning methods tailored for sports data, empowering you to extract insights and make data-driven decisions in the sports domain.

Gain foundational knowledge of sports analytics, explore common data sources, and learn how to handle and visualize sports data using Python.

Delve into statistical methods for analyzing sports data, including descriptive statistics, correlation, and hypothesis testing.

Learn to build and evaluate predictive models for sports outcomes using machine learning techniques.

Challenge: Analyzing Player Performance

Solution

Challenge: Analyzing Player Performance

Solution