In legal research, it is often necessary to determine which cases have been influenced by a particular precedent. This can involve tracing not just direct citations but also indirect ones—cases that cite a precedent through a chain of intermediate cases. To accomplish this in Python, you can use either recursion or iteration to traverse a citation network represented as a dictionary. In this context, a dictionary maps each case ID to a list of case IDs it cites as precedents.

To find all cases that are influenced by a given precedent, you need to examine each case in the dictionary and check if it cites the specified precedent, either directly or through a series of intermediate citations. This process is similar to searching through a graph, where cases are nodes and citations are edges. By systematically exploring each case's citations—either by recursively checking if a case's citations eventually lead to the target precedent, or by using an explicit stack or queue for iteration—you can build a set of all cases that are connected to the precedent, directly or indirectly. This approach ensures you identify every case that is part of the citation network rooted at the precedent in question.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io

class TestTask(unittest.TestCase):
    def test_direct_citation(self):
        import user_code
        importlib.reload(user_code)
        citations = {
            "A": ["B"],
            "B": [],
            "C": ["B"],
        }
        result = user_code.find_influenced_cases(citations, "B")
        expected = {"A", "C"}
        _dynamic_test(
            self,
            isinstance(result, set) and result == expected,
            f"Returns all cases that directly cite the precedent: {expected}",
            f"Expected {expected}, got {result}",
        )

    def test_indirect_citation(self):
        import user_code
        importlib.reload(user_code)
        citations = {
            "A": ["B"],
            "B": ["C"],
            "C": ["D"],
            "D": [],
            "E": ["D"],
        }
        result = user_code.find_influenced_cases(citations, "D")
        expected = {"A", "B", "C", "E"}
        _dynamic_test(
            self,
            isinstance(result, set) and result == expected,
            f"Returns all cases that cite the precedent through intermediate cases: {expected}",
            f"Expected {expected}, got {result}",
        )

    def test_no_citation(self):
        import user_code
        importlib.reload(user_code)
        citations = {
            "A": ["B"],
            "B": [],
            "C": ["B"],
        }
        result = user_code.find_influenced_cases(citations, "Z")
        expected = set()
        _dynamic_test(
            self,
            isinstance(result, set) and result == expected,
            f"Returns empty set if no cases cite the precedent.",
            f"Expected empty set, got {result}",
        )

    def test_cycle_handling(self):
        import user_code
        importlib.reload(user_code)
        citations = {
            "A": ["B"],
            "B": ["C"],
            "C": ["A", "D"],
            "D": [],
        }
        # All three cite D through a cycle
        result = user_code.find_influenced_cases(citations, "D")
        expected = {"A", "B", "C"}
        _dynamic_test(
            self,
            isinstance(result, set) and result == expected,
            f"Handles cycles and returns all cases that indirectly cite the precedent.",
            f"Expected {expected}, got {result}",
        )

    def test_sample_data(self):
        import user_code
        importlib.reload(user_code)
        # Use the sample data from the starter code
        citations = {
            "A": ["B", "C"],
            "B": ["D"],
            "C": [],
            "D": ["E"],
            "E": [],
            "F": ["C", "E"],
            "G": ["H"],
            "H": ["E"],
        }
        result = user_code.find_influenced_cases(citations, "E")
        expected = {"A", "B", "D", "F", "G", "H"}
        _dynamic_test(
            self,
            isinstance(result, set) and result == expected,
            f"Correctly finds all direct and indirect citations in sample data.",
            f"Expected {expected}, got {result}",
        )

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: Precedent Finder

解答