Teachers often need to notify students about their performance. In this challenge, you'll generate personalized messages for students based on their grades.


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

class TestTask(unittest.TestCase):
    def test_congratulatory_message(self):
        import user_code
        importlib.reload(user_code)
        test_grades = {"Sam": 92}
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.send_notifications(test_grades)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Congratulations Sam, you scored 92! Excellent work!")
        _dynamic_test(
            self,
            expected in output,
            "Prints congratulatory message for grade >= 90",
            f"Expected congratulatory message not found in output: {output}"
        )

    def test_encouraging_message(self):
        import user_code
        importlib.reload(user_code)
        test_grades = {"Jen": 75}
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.send_notifications(test_grades)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Good job Jen, you scored 75. Keep it up!")
        _dynamic_test(
            self,
            expected in output,
            "Prints encouraging message for 70 <= grade < 90",
            f"Expected encouraging message not found in output: {output}"
        )

    def test_supportive_message(self):
        import user_code
        importlib.reload(user_code)
        test_grades = {"Alex": 65}
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.send_notifications(test_grades)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Alex, you scored 65. Let's work together to improve your performance.")
        _dynamic_test(
            self,
            expected in output,
            "Prints supportive message for grade < 70",
            f"Expected supportive message not found in output: {output}"
        )

    def test_handles_all_students(self):
        import user_code
        importlib.reload(user_code)
        test_grades = {
            "Alice": 95,
            "Bob": 82,
            "Charlie": 68,
            "Diana": 74,
            "Evan": 59
        }
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.send_notifications(test_grades)
        output = normalize_text(f.getvalue())
        expected_messages = [
            normalize_text("Congratulations Alice, you scored 95! Excellent work!"),
            normalize_text("Good job Bob, you scored 82. Keep it up!"),
            normalize_text("Charlie, you scored 68. Let's work together to improve your performance."),
            normalize_text("Good job Diana, you scored 74. Keep it up!"),
            normalize_text("Evan, you scored 59. Let's work together to improve your performance.")
        ]
        for expected in expected_messages:
            _dynamic_test(
                self,
                expected in output,
                f"Prints correct message for student: {expected}",
                f"Expected message not found in output: {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: Simulate Sending Notifications

Oplossing

Challenge: Simulate Sending Notifications

Oplossing