Progress reports help teachers communicate student performance. In this challenge, you'll generate a text report summarizing each student's grades.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import os

class TestTask(unittest.TestCase):
    def setUp(self):
        self.test_file = "test_progress_report.txt"
        self.students = [
            {"name": "Alice", "grades": [85, 90, 78]},
            {"name": "Bob", "grades": [92, 88, 95]},
            {"name": "Charlie", "grades": [70, 75, 80]},
            {"name": "Diana", "grades": []}
        ]
    def tearDown(self):
        if os.path.exists(self.test_file):
            os.remove(self.test_file)

    def test_one_line_per_student(self):
        import user_code
        importlib.reload(user_code)
        user_code.generate_progress_report(self.students, self.test_file)
        with open(self.test_file, "r") as f:
            lines = f.readlines()
        _dynamic_test(
            self,
            len(lines) == len(self.students),
            "File contains one line per student",
            f"Expected {len(self.students)} lines, got {len(lines)}"
        )

    def test_average_grade_two_decimals(self):
        import user_code
        importlib.reload(user_code)
        user_code.generate_progress_report(self.students, self.test_file)
        with open(self.test_file, "r") as f:
            lines = [l.strip() for l in f.readlines()]
        expected = [
            "Student: Alice, Average Grade: 84.33",
            "Student: Bob, Average Grade: 91.67",
            "Student: Charlie, Average Grade: 75.00",
            "Student: Diana, Average Grade: 0.00"
        ]
        for i, exp in enumerate(expected):
            _dynamic_test(
                self,
                exp == lines[i],
                f"Correct format for line {i+1}: {exp}",
                f"Line {i+1} incorrect. Expected: '{exp}', got: '{lines[i]}'"
            )

    def test_handles_students_with_no_grades(self):
        import user_code
        importlib.reload(user_code)
        students = [
            {"name": "Eve", "grades": []},
            {"name": "Frank", "grades": [100]}
        ]
        user_code.generate_progress_report(students, self.test_file)
        with open(self.test_file, "r") as f:
            lines = [l.strip() for l in f.readlines()]
        _dynamic_test(
            self,
            "Student: Eve, Average Grade: 0.00" in lines,
            "Handles students with no grades (0.00)",
            f"Expected 'Student: Eve, Average Grade: 0.00' in lines, got {lines}"
        )
        _dynamic_test(
            self,
            "Student: Frank, Average Grade: 100.00" in lines,
            "Handles students with grades (100.00)",
            f"Expected 'Student: Frank, Average Grade: 100.00' in lines, got {lines}"
        )

    def test_overwrites_existing_file(self):
        # Write something to the file first
        with open(self.test_file, "w") as f:
            f.write("Old content\\n")
        import user_code
        importlib.reload(user_code)
        user_code.generate_progress_report(self.students, self.test_file)
        with open(self.test_file, "r") as f:
            content = f.read()
        _dynamic_test(
            self,
            "Old content" not in content,
            "Function overwrites the specified file",
            "File was not overwritten as expected"
        )

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

A beginner-friendly Python course designed specifically for teachers. Learn how to use Python to organize grades, analyze student performance, and automate classroom tasks with engaging, real-world examples.

Learn the basics of Python programming with a focus on classroom and grade organization. This section introduces Python syntax, variables, and simple data structures through relatable educational scenarios.

Dive deeper into Python by learning how to organize, analyze, and visualize student grades. This section covers dictionaries, conditional logic, and basic data analysis techniques tailored for teachers.

Explore how Python can automate common classroom tasks such as attendance tracking, assignment management, and generating reports. This section introduces file operations and more advanced automation techniques.

Challenge: Generate a Progress Report

Løsning