
import unittest
import user_code
import ast
import re   
import unittest
import importlib
import types

class TestTask(unittest.TestCase):
    def test_train_test_split(self):
        import user_code
        importlib.reload(user_code)
        X_train = getattr(user_code, 'X_train', None)
        X_test = getattr(user_code, 'X_test', None)
        y_train = getattr(user_code, 'y_train', None)
        y_test = getattr(user_code, 'y_test', None)
        _dynamic_test(
            self,
            X_train is not None and X_test is not None and y_train is not None and y_test is not None,
            "Data split into train and test sets with correct variable names.",
            "Variables X_train, X_test, y_train, y_test must be defined."
        )
        _dynamic_test(
            self,
            len(X_test) == 3 and len(y_test) == 3 and len(X_train) == 7 and len(y_train) == 7,
            "Correct test/train split sizes (30% test, 70% train)",
            f"Expected 3 test and 7 train samples, got {len(X_test)} test and {len(X_train)} train."
        )

    def test_logistic_regression_fit(self):
        import user_code
        importlib.reload(user_code)
        model = getattr(user_code, 'model', None)
        _dynamic_test(
            self,
            model is not None and hasattr(model, 'coef_'),
            "LogisticRegression model fit to training data.",
            "Model variable not defined or not fitted."
        )

    def test_predictions(self):
        import user_code
        importlib.reload(user_code)
        y_pred = getattr(user_code, 'y_pred', None)
        X_test = getattr(user_code, 'X_test', None)
        _dynamic_test(
            self,
            y_pred is not None and X_test is not None and len(y_pred) == len(X_test),
            "Predictions made on test set and stored in y_pred.",
            f"Expected y_pred to be same length as X_test ({len(X_test)}), got {len(y_pred) if y_pred is not None else 'None'}."
        )

    def test_accuracy_assignment(self):
        import user_code
        importlib.reload(user_code)
        accuracy = getattr(user_code, 'accuracy', None)
        _dynamic_test(
            self,
            isinstance(accuracy, float) and 0.0 <= accuracy <= 1.0,
            "Accuracy variable assigned with a float between 0 and 1.",
            f"accuracy variable has incorrect value: {accuracy}."
        )

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: Predicting Match Outcomes

Oplossing

Challenge: Predicting Match Outcomes

Oplossing