israeli-law-amender 1.0.0

A Python package for processing and amending Israeli laws using AI

Israeli Law Amender

Project Overview

The Israeli Law Amender is a Python-based tool that automates the complex process of amending Israeli legislation. It leverages the power of Large Language Models (LLMs) to interpret amendment instructions and apply them to existing law documents, which are structured in JSON format. This project aims to significantly reduce the manual effort required to keep legal documents up-to-date, ensuring accuracy and consistency.

The tool is designed with two primary modes of operation: a training mode for batch processing and evaluation of the AI's performance, and a product mode for on-demand, interactive amendment of individual laws.

Features

• AI-Powered Amendments: Uses Google's Gemini models to generate Python scripts that perform the amendments.
• Dual-Mode Operation:
  • Training Mode: Processes large batches of amendments from CSV files, designed for model evaluation and fine-tuning.
  • Product Mode: Interactive command-line interface for amending single laws with user-provided text.
• Comprehensive Validation:
  • In training mode, it performs a fuzzy matching score (Layer 1) and a more sophisticated LLM-based validation (Layer 3) to check the accuracy of the amendments.
  • In product mode, it generates detailed HTML diff reports to visualize changes and runs Layer 3 validation.
• Structured Output: All generated files, including amended laws, scripts, and validation reports, are organized into a clear directory structure for easy review.
• Packaged for Convenience: The tool is set up as a Python package, allowing for easy installation and command-line access.

Workflow

Training Mode

1. Input: The training mode is initiated with a command (amend_law training) and reads predefined CSV files from the Data/ directory. Each CSV contains a list of laws and the corresponding amendment texts.
2. Processing: For each law, the script iterates through its amendments.
3. Generation: For each amendment, it generates a prompt for the Gemini LLM, which returns a Python script designed to apply the amendment.
4. Execution: The generated script is executed, applying the changes to the law's JSON structure.
5. Validation: The amended law is validated against a "gold standard" version. The results, including fuzzy scores and Layer 3 validation scores, are logged.
6. Output: All artifacts, including the amended JSONs, generated scripts, and validation summaries, are saved to their respective directories.

Product Mode

1. Input: The product mode is initiated with the amend_law product command. It then interactively prompts the user for:
   • The location of the original law JSON files.
   • A main directory for all outputs.
   • An API key if not already set as an environment variable.
   • The law to be amended (by ID or name) or a CSV file with a list of laws.
   • The amendment text (pasted directly, from a .txt file, or from the CSV).
2. Processing: Based on the user's input, the tool prepares the data for the amendment process.
3. Generation & Execution: Similar to the training mode, it generates and executes a Python script for each amendment.
4. Reporting: After each amendment is applied, it generates:
   • An HTML diff report showing the exact changes between the previous and the newly amended version.
   • A Layer 3 validation report (in JSON format) that provides an AI-based assessment of the amendment's accuracy.
5. Output: The amended law, the diff report, and the validation report are saved in the user-specified output directory.

Directory Structure

The project is organized as follows:

.
├── Data/                 # Contains CSV files with amendment data.
├── Generated_Scripts_Generalized/ # Stores AI-generated Python scripts from training.
├── JSON_Laws_v2/         # Location of the original, unamended law JSONs.
├── JSON_amd*/            # Directories for amended JSONs from training, grouped by amendment number.
├── Src/                  # Source code for the project.
│   ├── validation/       # Validation scripts.
│   ├── __init__.py
│   ├── Generalized_amd_flow.py
│   ├── laws_amending_script.py
│   └── product_flow_helpers.py
├── laws_to_review/       # Materials for low-scoring amendments are collected here for manual review.
├── main.py               # Main entry point for the application.
├── README.md             # This file.
└── setup.py              # Package setup and configuration.

Installation and Dependencies

To set up the project, it is recommended to use a virtual environment.

1. Clone the repository:

   git clone https://github.com/Miki-Kisel/Final-Project-Laws.git
   cd Final-Project-Laws
   

2. Create and activate a virtual environment:

   python -m venv venv
   source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
   

3. Install the package: The project is configured as a Python package. Installing it will also handle all required dependencies.

   pip install .
   

Dependencies

The main dependencies are:

• google-generativeai
• pandas
• thefuzz[speedup]

These are installed automatically when you run pip install ..

Usage

Before running the tool, make sure to set your Google API key as an environment variable:

export GOOGLE_API_KEY="YOUR_API_KEY"

After installation, you can use the command-line tool amend_law.

Training Mode

To run the training mode, simply execute:

amend_law training

The script will use the predefined paths in Src/laws_amending_script.py to find the input data and save the results.

Product Mode

To run the interactive product mode, execute:

amend_law product

The script will then guide you through the process of providing the necessary files and information.