When tracking compliance events, you often need to identify which deadlines are approaching soon. In Python, you can use the `datetime` module to parse string dates, compare them to today's date, and filter for events occurring within a specific time window. Begin by representing your compliance events as a list of dictionaries, each containing an event name and a due date in string format (such as `"2024-07-15"`). To work with these dates, use `datetime.strptime()` to convert the string into a `datetime.date` object. You can then get today's date using `datetime.date.today()`, and calculate the difference in days between each event's due date and today. By filtering for events where this difference is between 0 and 7, you'll identify all compliance events due within the next week. This approach is useful for legal professionals who need to stay on top of imminent deadlines and avoid compliance issues.


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_events_due_within_7_days(self):
        import user_code
        importlib.reload(user_code)
        events = [
            {"name": "Event A", "due_date": "2024-07-03"},
            {"name": "Event B", "due_date": "2024-07-10"},
            {"name": "Event C", "due_date": "2024-07-11"},
            {"name": "Event D", "due_date": "2024-07-09"},
        ]
        today_str = "2024-07-03"
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.display_upcoming_compliance_events(events, today_str)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "event: event a, due: 2024-07-03" in output and
            "event: event d, due: 2024-07-09" in output and
            "event: event b, due: 2024-07-10" in output and
            "event: event c, due: 2024-07-11" not in output,
            "Correctly identifies events due within 7 days (including today and day 7)",
            f"Output did not correctly filter events: {output}"
        )

    def test_excludes_events_outside_7_days(self):
        import user_code
        importlib.reload(user_code)
        events = [
            {"name": "Event X", "due_date": "2024-07-01"},
            {"name": "Event Y", "due_date": "2024-07-15"},
        ]
        today_str = "2024-07-03"
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.display_upcoming_compliance_events(events, today_str)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "event: event x," not in output and "event: event y," not in output,
            "Events not due within 0-7 days are excluded",
            f"Events outside window should not be displayed: {output}"
        )

    def test_includes_today_and_seventh_day(self):
        import user_code
        importlib.reload(user_code)
        events = [
            {"name": "Event Today", "due_date": "2024-07-03"},
            {"name": "Event Seventh", "due_date": "2024-07-10"},
            {"name": "Event Eighth", "due_date": "2024-07-11"}
        ]
        today_str = "2024-07-03"
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.display_upcoming_compliance_events(events, today_str)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "event: event today," in output and "event: event seventh," in output and "event: event eighth," not in output,
            "Includes events due today and exactly on the 7th day",
            f"Today and 7th day events missing or extra events: {output}"
        )

    def test_empty_event_list(self):
        import user_code
        importlib.reload(user_code)
        events = []
        today_str = "2024-07-03"
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.display_upcoming_compliance_events(events, today_str)
        output = f.getvalue()
        _dynamic_test(
            self,
            output.strip() == "",
            "Handles empty event list without error or output",
            f"Expected no output for empty event list, got: {output}"
        )

    def test_parses_date_strings(self):
        import user_code
        importlib.reload(user_code)
        events = [
            {"name": "Event Parse", "due_date": "2024-07-06"}
        ]
        today_str = "2024-07-03"
        try:
            f = io.StringIO()
            with redirect_stdout(f):
                user_code.display_upcoming_compliance_events(events, today_str)
            output = normalize_text(f.getvalue())
            _dynamic_test(
                self,
                "event: event parse," in output,
                "Correctly parses and displays a valid event date string",
                f"Failed to parse event date string or output missing: {output}"
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "No exception raised when parsing valid date strings",
                f"Exception raised while parsing valid date strings: {e}"
            )

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

This course empowers legal professionals to harness the power of Python for automating, analyzing, and streamlining legal tasks. Through engaging theory and hands-on challenges, you'll learn to process legal documents, analyze case data, and visualize legal trends using Python's robust ecosystem.

Learn how Python can automate the handling, extraction, and management of legal documents, reducing manual effort and increasing accuracy.

Explore how Python can be used to analyze legal case data, uncover trends, and support legal research.

Master Python techniques for legal research, compliance monitoring, and reporting to enhance legal practice.

Challenge: Compliance Tracker

Ratkaisu