In this challenge, you will automate the process of analyzing a legal contract by writing a Python script that identifies and counts clauses. You will work with a hardcoded contract string, using the pattern of a number followed by a period and a space (such as "1. ", "2. ") to detect where each clause begins. Your script should determine how many clauses are present and extract the first sentence from each clause for display. Focus on string manipulation and pattern recognition, which are essential skills for automating legal document processing.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_count_and_first_sentences(self):
        import user_code
        importlib.reload(user_code)
        contract = (
            "1. This Agreement is made between the parties. It sets forth the terms and conditions. "
            "2. The duration of the Agreement is one year. Extensions are subject to mutual consent. "
            "3. Termination may occur with thirty days' notice. Obligations survive termination."
        )
        expected_num = 3
        expected_sentences = [
            "1. This Agreement is made between the parties.",
            "2. The duration of the Agreement is one year.",
            "3. Termination may occur with thirty days' notice."
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.count_clauses_and_print_first_sentences(contract)
        output = [line.strip() for line in f.getvalue().split('\\n') if line.strip()]
        _dynamic_test(
            self,
            len(output) >= 1 and output[0] == str(expected_num),
            "Correct number of clauses printed.",
            f"Expected clause count '{expected_num}', got '{output[0] if output else None}'",
        )
        _dynamic_test(
            self,
            output[1:] == expected_sentences,
            "First sentences of clauses printed correctly.",
            f"Expected: {expected_sentences}, got: {output[1:]}"
        )

    def test_varying_number_of_clauses(self):
        import user_code
        importlib.reload(user_code)
        contract = (
            "1. Party A agrees to provide services. "
            "2. Payment is due within 30 days. "
        )
        expected_num = 2
        expected_sentences = [
            "1. Party A agrees to provide services.",
            "2. Payment is due within 30 days."
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.count_clauses_and_print_first_sentences(contract)
        output = [line.strip() for line in f.getvalue().split('\\n') if line.strip()]
        _dynamic_test(
            self,
            len(output) >= 1 and output[0] == str(expected_num),
            "Handles different numbers of clauses.",
            f"Expected clause count '{expected_num}', got '{output[0] if output else None}'",
        )
        _dynamic_test(
            self,
            output[1:] == expected_sentences,
            "Prints first sentence for each clause.",
            f"Expected: {expected_sentences}, got: {output[1:]}"
        )

    def test_no_clauses(self):
        import user_code
        importlib.reload(user_code)
        contract = "No clauses here. Just a sentence."
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.count_clauses_and_print_first_sentences(contract)
        output = [line.strip() for line in f.getvalue().split('\\n') if line.strip()]
        _dynamic_test(
            self,
            output == [],
            "No output when there are no clauses.",
            f"Expected no output, got: {output}"
        )

    def test_clauses_not_merged(self):
        import user_code
        importlib.reload(user_code)
        contract = (
            "1. Alpha. 2. Beta. 3. Gamma."
        )
        expected_num = 3
        expected_sentences = [
            "1. Alpha.",
            "2. Beta.",
            "3. Gamma."
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.count_clauses_and_print_first_sentences(contract)
        output = [line.strip() for line in f.getvalue().split('\\n') if line.strip()]
        _dynamic_test(
            self,
            len(output) >= 1 and output[0] == str(expected_num),
            "No clauses are merged; all are detected.",
            f"Expected clause count '{expected_num}', got '{output[0] if output else None}'",
        )
        _dynamic_test(
            self,
            output[1:] == expected_sentences,
            "All clause first sentences printed.",
            f"Expected: {expected_sentences}, got: {output[1:]}"
        )

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: Clause Counter

Solución