
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import importlib
import sys
import io

class TestTask(unittest.TestCase):
    def setUp(self):
        # Example test data
        self.df = pd.DataFrame({
            'user_id': ['u1', 'u1', 'u2', 'u2', 'u3', 'u3', 'u3'],
            'feature': ['A', 'B', 'A', 'C', 'B', 'C', 'A'],
            'usage_count': [5, 2, 3, 7, 1, 4, 2]
        })
        self.expected_matrix = pd.DataFrame({
            'A': [5, 3, 2],
            'B': [2, 0, 1],
            'C': [0, 7, 4]
        }, index=['u1', 'u2', 'u3'])
        self.expected_matrix.index.name = 'user_id'
        self.expected_matrix.columns.name = 'feature'

    def test_matrix_shape_and_values(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'compute_core_feature_matrix', None)
        _dynamic_test(
            self,
            callable(func),
            'Function compute_core_feature_matrix exists',
            'compute_core_feature_matrix is not defined.'
        )
        matrix = func(self.df)
        _dynamic_test(
            self,
            isinstance(matrix, pd.DataFrame),
            'Output is a DataFrame',
            f'Output is not a DataFrame: {type(matrix)}'
        )
        # Check index and columns
        _dynamic_test(
            self,
            list(matrix.index) == list(self.expected_matrix.index),
            'User index matches expected',
            f'Expected index {self.expected_matrix.index}, got {matrix.index}'
        )
        _dynamic_test(
            self,
            list(matrix.columns) == list(self.expected_matrix.columns),
            'Feature columns match expected',
            f'Expected columns {self.expected_matrix.columns}, got {matrix.columns}'
        )
        # Check values
        for user in self.expected_matrix.index:
            for feat in self.expected_matrix.columns:
                expected = self.expected_matrix.loc[user, feat]
                actual = matrix.loc[user, feat]
                _dynamic_test(
                    self,
                    actual == expected,
                    f'Correct usage count for user {user}, feature {feat}',
                    f'Expected {expected} for user {user}, feature {feat}, got {actual}'
                )

    def test_matrix_fill_value(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'compute_core_feature_matrix', None)
        matrix = func(self.df)
        # Check that missing user-feature pairs are filled with 0
        _dynamic_test(
            self,
            matrix.loc['u2', 'B'] == 0,
            'Missing user-feature pairs are filled with 0',
            f"Expected 0 at ('u2','B'), got {matrix.loc['u2','B']}"
        )
        _dynamic_test(
            self,
            matrix.loc['u1', 'C'] == 0,
            'Missing user-feature pairs are filled with 0',
            f"Expected 0 at ('u1','C'), got {matrix.loc['u1','C']}"
        )

    def test_heatmap_plot_runs(self):
        import user_code
        importlib.reload(user_code)
        compute_func = getattr(user_code, 'compute_core_feature_matrix', None)
        plot_func = getattr(user_code, 'plot_core_feature_heatmap', None)
        _dynamic_test(
            self,
            callable(plot_func),
            'plot_core_feature_heatmap is defined',
            'plot_core_feature_heatmap is not defined.'
        )
        core_matrix = compute_func(self.df)
        # Redirect plt.show to avoid blocking
        plt_show_orig = plt.show
        plt.show = lambda: None
        try:
            plot_func(core_matrix)
            _dynamic_test(
                self,
                True,
                'plot_core_feature_heatmap runs without error',
                'plot_core_feature_heatmap raised an error.'
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                '',
                f'plot_core_feature_heatmap raised an error: {e}'
            )
        finally:
            plt.show = plt_show_orig

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

Learn to analyze user interactions at the feature level, map adoption curves, detect high-value behavioral paths, and cluster users by product usage using Python and machine learning.

Dive deep into user event logs to map feature adoption, uncover retention-driving behaviors, and segment users by their actual product usage patterns using Python.

Challenge: Feature Adoption Heatmap

Oplossing