
import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_sum_calculation(self):
        import user_code

        importlib.reload(user_code)
        # Capture output
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.track_habit([8, 7, 6, 9, 8, 7, 10])
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "weekly total: 55" in output,
            "Correctly calculates weekly total for [8, 7, 6, 9, 8, 7, 10]",
            f"Expected 'Weekly Total: 55' in output, got: {output}",
        )

    def test_average_calculation(self):
        import user_code

        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.track_habit([8, 7, 6, 9, 8, 7, 10])
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "weekly average: 7.857142857142857" in output,
            "Correctly calculates weekly average for [8, 7, 6, 9, 8, 7, 10]",
            f"Expected 'Weekly Average: 7.857142857142857' in output, got: {output}",
        )

    def test_sum_calculation_uniform(self):
        import user_code

        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.track_habit([2, 2, 2, 2, 2, 2, 2])
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "weekly total: 14" in output,
            "Correctly calculates weekly total for [2, 2, 2, 2, 2, 2, 2]",
            f"Expected 'Weekly Total: 14' in output, got: {output}",
        )

    def test_average_calculation_uniform(self):
        import user_code

        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.track_habit([2, 2, 2, 2, 2, 2, 2])
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "weekly average: 2.0" in output,
            "Correctly calculates weekly average for [2, 2, 2, 2, 2, 2, 2]",
            f"Expected 'Weekly Average: 2.0' in output, got: {output}",
        )

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

Master practical Python skills for everyday tasks, from calculations and data organization to visualizing information and automating routines. This course blends engaging theory with hands-on challenges, empowering you to solve real-world problems efficiently using Python.

Learn to use Python for automating calculations and streamlining daily routines, from budgeting to simple reminders.

Discover how Python can help you organize, analyze, and summarize everyday data, from to-do lists to simple statistics.

Learn to create simple visualizations and formatted outputs to communicate information clearly and effectively.

Challenge: Weekly Habit Tracker

Solution