When building a Python script to generate a legal report, begin by clearly organizing your hardcoded input data. For this scenario, you will need two lists: one containing dictionaries for case summaries (with fields like `"case_id"`, `"title"`, `"status"`, and `"summary"`), and another for compliance events (with fields such as `"event_id"`, `"description"`, `"deadline"`, and `"status"`). 

To create the report, filter the case summaries to include only those where the status is `"open"`. For compliance events, select those with deadlines in the future and a status that is not `"completed"`. Format your report as a readable string, grouping open cases and upcoming compliance deadlines under clear headings. Use string concatenation and formatting to ensure your report is well-structured, with each case and event presented on its own line and details clearly labeled. Finally, assign the complete report string to a variable, such as `legal_report`, so it can be used or printed as needed.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
from datetime import datetime, timedelta

class TestTask(unittest.TestCase):
    def setUp(self):
        self.module_name = "user_code"
        if self.module_name in sys.modules:
            del sys.modules[self.module_name]

    def test_only_open_cases_in_report(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'generate_legal_report', None)
        _dynamic_test(self, func is not None, "Function generate_legal_report exists", "Function generate_legal_report is missing")
        if func is None:
            return
        # Use test data
        cases = [
            {"case_id": 1, "title": "Case A", "status": "open", "summary": "Summary A"},
            {"case_id": 2, "title": "Case B", "status": "closed", "summary": "Summary B"},
            {"case_id": 3, "title": "Case C", "status": "open", "summary": "Summary C"},
        ]
        today = datetime.today().date()
        events = []
        report = func(cases, events)
        _dynamic_test(
            self,
            "Case A" in report and "Case C" in report and "Case B" not in report,
            "Report includes only open cases",
            f"Open cases filtering failed. Report: {report}"
        )

    def test_only_upcoming_and_incomplete_events(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'generate_legal_report', None)
        _dynamic_test(self, func is not None, "Function generate_legal_report exists", "Function generate_legal_report is missing")
        if func is None:
            return
        today = datetime.today().date()
        events = [
            {"event_id": 1, "description": "Event A", "deadline": (today + timedelta(days=5)).strftime("%Y-%m-%d"), "status": "pending"},
            {"event_id": 2, "description": "Event B", "deadline": (today + timedelta(days=1)).strftime("%Y-%m-%d"), "status": "pending"},
            {"event_id": 3, "description": "Event C", "deadline": (today - timedelta(days=1)).strftime("%Y-%m-%d"), "status": "pending"},
            {"event_id": 4, "description": "Event D", "deadline": (today + timedelta(days=10)).strftime("%Y-%m-%d"), "status": "completed"},
        ]
        cases = []
        report = func(cases, events)
        _dynamic_test(
            self,
            "Event A" in report and "Event B" in report and "Event C" not in report and "Event D" not in report,
            "Report includes only upcoming and incomplete compliance events",
            f"Event filtering failed. Report: {report}"
        )

    def test_report_format_and_headings(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'generate_legal_report', None)
        _dynamic_test(self, func is not None, "Function generate_legal_report exists", "Function generate_legal_report is missing")
        if func is None:
            return
        today = datetime.today().date()
        cases = [
            {"case_id": 1, "title": "Case A", "status": "open", "summary": "Summary A"}
        ]
        events = [
            {"event_id": 1, "description": "Event A", "deadline": (today + timedelta(days=5)).strftime("%Y-%m-%d"), "status": "pending"}
        ]
        report = func(cases, events)
        _dynamic_test(
            self,
            "LEGAL REPORT" in report and "Open Cases:" in report and "Upcoming Compliance Deadlines:" in report,
            "Report has required section headings",
            f"Missing required headings. Report: {report}"
        )
        _dynamic_test(
            self,
            "- Case A" in report and "- Event A" in report,
            "Report lists cases and events with details",
            f"Missing details in report. Report: {report}"
        )

    def test_legal_report_variable_content(self):
        import user_code
        importlib.reload(user_code)
        legal_report = getattr(user_code, 'legal_report', None)
        _dynamic_test(
            self,
            isinstance(legal_report, str) and len(legal_report) > 0,
            "legal_report variable contains a non-empty string",
            f"legal_report variable is missing or empty. Value: {legal_report}"
        )

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: Report Generator

Ratkaisu