Automating patient communication is a crucial task in modern healthcare settings, especially when it comes to **appointment reminders**. Missed appointments can lead to gaps in care and inefficiencies for clinics. You can use **Python** to streamline this process by analyzing a `DataFrame` containing patient names and appointment dates, then identifying which appointments are scheduled within the next 7 days. For each patient with an upcoming appointment, you can print a personalized reminder message. This approach not only saves staff time but also helps ensure that patients receive timely reminders, improving attendance rates and overall patient care.

import unittest
import user_code
import ast
import re
import importlib
import csv
import sys
import io
import pandas as pd
from datetime import datetime, timedelta
from unittest import mock

class TestTask(unittest.TestCase):
    def setUp(self):
        self.fixed_today = datetime(2023, 6, 1)

    def _patch_today(self, module):
        fixed_today_local = self.fixed_today

        class FixedDateTime(datetime):
            @classmethod
            def today(cls):
                return fixed_today_local

        module.datetime = FixedDateTime

    def test_reminders_within_7_days(self):
        import user_code
        importlib.reload(user_code)
        self._patch_today(user_code)

        today = self.fixed_today.date()
        data = {
            "Patient": ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank"],
            "AppointmentDate": [
                today.strftime("%Y-%m-%d"),
                (today + timedelta(days=3)).strftime("%Y-%m-%d"),
                (today + timedelta(days=7)).strftime("%Y-%m-%d"),
                (today + timedelta(days=8)).strftime("%Y-%m-%d"),
                (today - timedelta(days=1)).strftime("%Y-%m-%d"),
                "not-a-date",
            ],
        }
        df = pd.DataFrame(data)

        f = io.StringIO()
        with mock.patch("sys.stdout", new=f):
            user_code.get_upcoming_appointments(df)

        output = normalize_text(f.getvalue())
        actual_lines = [line for line in output.split("\\n") if line.strip()]

        expected_lines = [
            f"reminder: alice, you have an appointment on {today.strftime('%Y-%m-%d')}.",
            f"reminder: bob, you have an appointment on {(today + timedelta(days=3)).strftime('%Y-%m-%d')}.",
            f"reminder: charlie, you have an appointment on {(today + timedelta(days=7)).strftime('%Y-%m-%d')}.",
        ]

        _dynamic_test(
            self,
            len(actual_lines) == 3,
            "Prints exactly 3 reminders for appointments within 7 days (inclusive)",
            f"Expected 3 reminders, got {len(actual_lines)}: {actual_lines}",
        )

        for idx, expected in enumerate(expected_lines):
            _dynamic_test(
                self,
                idx < len(actual_lines) and actual_lines[idx] == expected,
                f"Reminder line {idx+1} matches expected output",
                f"Expected '{expected}' at position {idx}, got '{actual_lines[idx] if idx < len(actual_lines) else None}'",
            )

    def test_ignores_invalid_dates(self):
        import user_code
        importlib.reload(user_code)
        self._patch_today(user_code)

        data = {
            "Patient": ["Xavier", "Yvonne"],
            "AppointmentDate": ["not-a-date", "2023-06-01"],
        }
        df = pd.DataFrame(data)

        f = io.StringIO()
        with mock.patch("sys.stdout", new=f):
            user_code.get_upcoming_appointments(df)

        output = normalize_text(f.getvalue())
        expected = "reminder: yvonne, you have an appointment on 2023-06-01."

        _dynamic_test(
            self,
            expected in output and "xavier" not in output,
            "Invalid dates are ignored; only valid reminders printed",
            f"Expected only Yvonne reminder, got: {output}",
        )

    def test_empty_dataframe(self):
        import user_code
        importlib.reload(user_code)
        self._patch_today(user_code)

        df = pd.DataFrame({"Patient": [], "AppointmentDate": []})

        f = io.StringIO()
        with mock.patch("sys.stdout", new=f):
            user_code.get_upcoming_appointments(df)

        output = normalize_text(f.getvalue())

        _dynamic_test(
            self,
            output.strip() == "",
            "No reminders printed for empty DataFrame",
            f"Expected no output, got: '{output}'",
        )

    def test_preserves_dataframe_order_after_filtering(self):
        import user_code
        importlib.reload(user_code)
        self._patch_today(user_code)

        today = self.fixed_today.date()
        data = {
            "Patient": ["A", "B", "C"],
            "AppointmentDate": [
                (today + timedelta(days=2)).strftime("%Y-%m-%d"),
                (today + timedelta(days=1)).strftime("%Y-%m-%d"),
                (today + timedelta(days=3)).strftime("%Y-%m-%d"),
            ],
        }
        df = pd.DataFrame(data)

        f = io.StringIO()
        with mock.patch("sys.stdout", new=f):
            user_code.get_upcoming_appointments(df)

        output = normalize_text(f.getvalue())
        actual_lines = [line for line in output.split("\\n") if line.strip()]

        _dynamic_test(
            self,
            len(actual_lines) == 3,
            "Prints 3 reminders for 3 valid rows within range",
            f"Expected 3 reminders, got {len(actual_lines)}: {actual_lines}",
        )

        expected_order = ["a", "b", "c"]
        for idx, name in enumerate(expected_order):
            _dynamic_test(
                self,
                idx < len(actual_lines) and actual_lines[idx].startswith(f"reminder: {name},"),
                f"Reminder order preserved for {name}",
                f"Expected reminder for '{name}' at position {idx}, got '{actual_lines[idx] if idx < len(actual_lines) else None}'",
            )

    def test_does_not_mutate_input_dataframe(self):
        import user_code
        importlib.reload(user_code)
        self._patch_today(user_code)

        today = self.fixed_today.date()
        df = pd.DataFrame(
            {
                "Patient": ["Zed"],
                "AppointmentDate": [(today + timedelta(days=1)).strftime("%Y-%m-%d")],
            }
        )

        before = df.copy(deep=True)

        f = io.StringIO()
        with mock.patch("sys.stdout", new=f):
            user_code.get_upcoming_appointments(df)

        _dynamic_test(
            self,
            df.equals(before),
            "Input DataFrame not mutated",
            f"Expected input DataFrame unchanged, but it was modified.\\nBefore:\\n{before}\\nAfter:\\n{df}",
        )

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

    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 not assign_nodes:
        return code

    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 practical Python course tailored for healthcare professionals, focusing on real-world data analysis, visualization, and automation scenarios in the medical field. Learn to harness Python's power to streamline healthcare workflows, analyze patient data, and visualize medical trends.

Explore the essentials of working with healthcare data in Python, including data structures, importing datasets, and basic data cleaning tailored to medical records.

Master the art of visualizing healthcare data to uncover insights and communicate findings effectively using Python's plotting libraries.

Automate repetitive healthcare tasks and generate insightful reports using Python, streamlining workflows and improving efficiency.

Challenge: Appointment Reminder System

Oplossing