Metadata-Version: 2.4
Name: israeli-law-amender
Version: 1.0.0
Summary: A Python package for processing and amending Israeli laws using AI
Home-page: https://github.com/Double-N-A/israeli-law-amender
Author: Hila Peled, Nitzan Naimi, Ohad Nahari, Ran Cohen
Author-email: hila.peled@mail.huji.ac.il, nitzan.naimi@mail.huji.ac.il, ohad.nahar@mail.huji.ac.il, ran.cohen@mail.huji.ac.il
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Legal Industry
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Topic :: Text Processing :: Linguistic
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires-Python: >=3.8
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: google-generativeai>=0.3.0
Requires-Dist: google-api-core>=2.0.0
Requires-Dist: pandas>=1.3.0
Requires-Dist: pathlib2>=2.3.0
Requires-Dist: thefuzz[speedup]>=0.19.0
Requires-Dist: sentence-transformers>=2.2.0
Dynamic: author
Dynamic: author-email
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: license-file
Dynamic: requires-dist
Dynamic: requires-python
Dynamic: summary

# 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:**
    ```bash
    git clone https://github.com/Miki-Kisel/Final-Project-Laws.git
    cd Final-Project-Laws
    ```

2.  **Create and activate a virtual environment:**
    ```bash
    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.
    ```bash
    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:
```bash
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:
```bash
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:
```bash
amend_law product
```
The script will then guide you through the process of providing the necessary files and information.
