When you want to visualize legal case trends over time, you often need to group your data by important columns—such as by **'Year'** and **'Outcome'**—to reveal patterns. In Python, you can use `pandas` to read and group data, even from a hardcoded CSV string. To plot these groupings, libraries like `matplotlib` and `seaborn` are especially useful. For this challenge, you will work with a hardcoded CSV string that contains legal case data with **'Year'** and **'Outcome'** columns. First, you will group the data by both year and outcome, count the number of cases for each outcome in each year, and then create a bar chart to visualize these trends. `matplotlib` or `seaborn` can create the chart, and you can save the resulting figure as an image file using their built-in save functions. This approach allows you to share your insights visually without needing to read or write any data files.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import os
import pandas as pd
import matplotlib.pyplot as plt
from io import StringIO

class TestTask(unittest.TestCase):
    def setUp(self):
        # Remove output file if it exists before test
        self.filename = "case_trends.png"
        if os.path.exists(self.filename):
            os.remove(self.filename)
        # Expected DataFrame after reading
        self.expected_df = pd.DataFrame({
            'Year': [2020, 2020, 2020, 2021, 2021, 2021, 2022, 2022, 2022, 2022],
            'Outcome': ['Won', 'Lost', 'Settled', 'Won', 'Won', 'Lost', 'Settled', 'Lost', 'Settled', 'Won']
        })

    def tearDown(self):
        if os.path.exists(self.filename):
            os.remove(self.filename)

    def test_dataframe_read(self):
        import user_code
        csv_data = """Year,Outcome\\n2020,Won\\n2020,Lost\\n2020,Settled\\n2021,Won\\n2021,Won\\n2021,Lost\\n2022,Settled\\n2022,Lost\\n2022,Settled\\n2022,Won\\n"""
        df = pd.read_csv(StringIO(csv_data))
        _dynamic_test(
            self,
            df.shape == (10, 2) and list(df.columns) == ['Year', 'Outcome'],
            "CSV string is read into a DataFrame with correct columns and shape.",
            f"Expected shape (10,2) with columns ['Year','Outcome'], got shape {df.shape} and columns {list(df.columns)}."
        )

    def test_groupby_counts(self):
        import user_code
        csv_data = """Year,Outcome\\n2020,Won\\n2020,Lost\\n2020,Settled\\n2021,Won\\n2021,Won\\n2021,Lost\\n2022,Settled\\n2022,Lost\\n2022,Settled\\n2022,Won\\n"""
        df = pd.read_csv(StringIO(csv_data))
        grouped = df.groupby(['Year', 'Outcome']).size().unstack(fill_value=0)
        _dynamic_test(
            self,
            grouped.loc[2020, 'Won'] == 1 and grouped.loc[2021, 'Won'] == 2 and grouped.loc[2022, 'Settled'] == 2,
            "Data is grouped by 'Year' and 'Outcome' with correct counts.",
            f"Expected counts not found in grouped data: {grouped}"
        )

    def test_chart_saved(self):
        import user_code
        import importlib
        import sys
        import io
        import builtins
        # Remove file if exists
        if os.path.exists(self.filename):
            os.remove(self.filename)
        # Capture print output
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        try:
            importlib.reload(user_code)
        finally:
            sys.stdout = sys_stdout
        _dynamic_test(
            self,
            os.path.exists(self.filename),
            "Chart image file is saved with the correct filename.",
            f"Expected file '{self.filename}' was not found."
        )

    def test_bar_chart_generated(self):
        import user_code
        import importlib
        import matplotlib
        matplotlib.use('Agg')
        import matplotlib.pyplot as plt
        import sys
        import io
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        importlib.reload(user_code)
        sys.stdout = sys_stdout
        # Check that a bar chart is present in the figure
        fig = plt.gcf()
        found_bar = any(isinstance(child, matplotlib.container.BarContainer) for child in fig.axes[0].containers)
        _dynamic_test(
            self,
            found_bar,
            "A bar chart is generated in the figure.",
            "No bar chart was found in the generated figure."
        )

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: Case Trend Visualizer

Ratkaisu