When you want to automate the organization of legal documents in Python, you can start by using a hardcoded list of document names and their types. This means you define the data directly in your script, rather than reading it from a user or a file. To organize this data, you will build a dictionary where each key is a document type (such as `contract` or `memo`) and the value is a list of file names belonging to that type. After constructing this dictionary, you can display the results by printing the dictionary to the console. This approach helps you quickly see how your documents are grouped by type and can serve as a foundation for more advanced automation tasks.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.documents = [
            ("NDA_AcmeCorp.pdf", "contract"),
            ("Employment_Agreement_2023.docx", "contract"),
            ("Board_Minutes_Jan2024.docx", "minutes"),
            ("Client_Memo_Q1.pdf", "memo"),
            ("Lease_Agreement_Unit5.pdf", "contract"),
            ("Annual_Report_2023.pdf", "report"),
            ("Policy_Update_March.pdf", "memo"),
            ("Shareholder_Resolution.docx", "minutes"),
            ("Financial_Statement_Q4.pdf", "report")
        ]
        self.expected = {
            "contract": ["NDA_AcmeCorp.pdf", "Employment_Agreement_2023.docx", "Lease_Agreement_Unit5.pdf"],
            "minutes": ["Board_Minutes_Jan2024.docx", "Shareholder_Resolution.docx"],
            "memo": ["Client_Memo_Q1.pdf", "Policy_Update_March.pdf"],
            "report": ["Annual_Report_2023.pdf", "Financial_Statement_Q4.pdf"]
        }

    def test_returns_dictionary(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.organize_documents(self.documents)
        _dynamic_test(
            self,
            isinstance(result, dict),
            "Function returns a dictionary.",
            f"Expected a dictionary, got {type(result)}."
        )

    def test_all_types_present(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.organize_documents(self.documents)
        _dynamic_test(
            self,
            set(result.keys()) == set(self.expected.keys()),
            "All document types are present as keys.",
            f"Expected keys {set(self.expected.keys())}, got {set(result.keys())}."
        )

    def test_documents_in_correct_type(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.organize_documents(self.documents)
        for doc_type, files in self.expected.items():
            _dynamic_test(
                self,
                doc_type in result,
                f"Type '{doc_type}' is present.",
                f"Type '{doc_type}' missing in result."
            )
            _dynamic_test(
                self,
                sorted(result[doc_type]) == sorted(files),
                f"All files for type '{doc_type}' are correct.",
                f"For type '{doc_type}', expected {files}, got {result[doc_type]}."
            )

    def test_no_missing_or_duplicate_documents(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.organize_documents(self.documents)
        all_files = [name for name, _ in self.documents]
        result_files = []
        for files in result.values():
            result_files.extend(files)
        _dynamic_test(
            self,
            sorted(all_files) == sorted(result_files),
            "No document names are missing or duplicated.",
            f"Expected all files {sorted(all_files)}, got {sorted(result_files)}."
        )

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: Document Organizer

Oplossing