Delete app.py

app.py

@@ -1,483 +0,0 @@
-import os
-import re
-import subprocess
-import tempfile
-import zipfile
-import csv
-from datetime import datetime
-from io import StringIO
-from difflib import SequenceMatcher
-
-import gradio as gr
-from docx import Document
-
-
-TEMPLATE_PATH = "Fee-Note-Template.docx"
-ADDRESSES_PATH = "Solicitors-Addresses.txt"
-
-
-# ── Solicitor address loading & fuzzy matching ──────────────────────────────
-
-def load_solicitor_addresses():
-    """
-    Parse Solicitors-Addresses.txt → dict of {canonical_name: address}.
-    Also builds a lookup index keyed by normalised name for fuzzy matching.
-    """
-    addresses = {}
-
-    if not os.path.exists(ADDRESSES_PATH):
-        return addresses
-
-    with open(ADDRESSES_PATH, "r", encoding="utf-8") as f:
-        content = f.read()
-
-    blocks = content.strip().split("\n\n")
-
-    for block in blocks:
-        lines = block.strip().split("\n")
-        if not lines:
-            continue
-
-        firm_name = lines[0].strip()
-        address = ""
-
-        for line in lines[1:]:
-            if line.strip().startswith("Address:"):
-                address = line.replace("Address:", "").strip()
-                break
-
-        if firm_name and address:
-            addresses[firm_name] = address
-
-    return addresses
-
-
-# Common legal entity suffixes to strip for matching purposes
-_LEGAL_SUFFIXES = re.compile(
-    r"\b(llp|llc|ltd|limited|plc|dac|clg|lp|inc|incorporated|solicitors?)\b",
-    re.IGNORECASE,
-)
-
-
-def normalise_firm_name(name):
-    """
-    Normalise a firm name for comparison:
-    - lowercase
-    - '&' ↔ 'and'
-    - strip punctuation (dots, commas, apostrophes)
-    - strip common legal suffixes (LLP, Ltd, Solicitors, etc.)
-    - collapse whitespace
-    """
-    s = name.lower().strip()
-    # Normalise ampersand ↔ 'and'
-    s = s.replace(" & ", " and ").replace("&", " and ")
-    # Strip common punctuation
-    s = re.sub(r"[.,;:'\u2018\u2019\u201C\u201D\"()]+", "", s)
-    # Strip legal suffixes (LLP, Ltd, Solicitors, etc.)
-    s = _LEGAL_SUFFIXES.sub("", s)
-    # Collapse whitespace
-    s = re.sub(r"\s+", " ", s).strip()
-    return s
-
-
-def find_solicitor(input_name, addresses_dict):
-    """
-    Try to match input_name against canonical solicitor names.
-    Returns (canonical_name, address) or raises ValueError.
-
-    Matching strategy (in order):
-    1. Exact match (case-insensitive)
-    2. Normalised exact match (& ↔ and, strip punctuation)
-    3. Substring containment (either direction)
-    4. Token overlap ≥ 70%
-    5. SequenceMatcher ratio ≥ 0.80
-    """
-    if not input_name:
-        raise ValueError("Solicitor name is empty")
-
-    # 1. Exact case-insensitive
-    for canonical, addr in addresses_dict.items():
-        if input_name.lower() == canonical.lower():
-            return canonical, addr
-
-    # 2. Normalised exact
-    input_norm = normalise_firm_name(input_name)
-    for canonical, addr in addresses_dict.items():
-        if input_norm == normalise_firm_name(canonical):
-            return canonical, addr
-
-    # 3. Substring containment
-    for canonical, addr in addresses_dict.items():
-        canon_norm = normalise_firm_name(canonical)
-        if input_norm in canon_norm or canon_norm in input_norm:
-            return canonical, addr
-
-    # 4. Token overlap
-    input_tokens = set(input_norm.split())
-    best_overlap = 0
-    best_match = None
-    for canonical, addr in addresses_dict.items():
-        canon_tokens = set(normalise_firm_name(canonical).split())
-        if not canon_tokens:
-            continue
-        overlap = len(input_tokens & canon_tokens) / max(len(input_tokens), len(canon_tokens))
-        if overlap > best_overlap:
-            best_overlap = overlap
-            best_match = (canonical, addr)
-
-    if best_overlap >= 0.70 and best_match:
-        return best_match
-
-    # 5. SequenceMatcher
-    best_ratio = 0
-    best_match = None
-    for canonical, addr in addresses_dict.items():
-        ratio = SequenceMatcher(None, input_norm, normalise_firm_name(canonical)).ratio()
-        if ratio > best_ratio:
-            best_ratio = ratio
-            best_match = (canonical, addr)
-
-    if best_ratio >= 0.80 and best_match:
-        return best_match
-
-    # No match — build helpful error
-    # Show top 3 closest matches
-    scored = []
-    for canonical in addresses_dict:
-        ratio = SequenceMatcher(None, input_norm, normalise_firm_name(canonical)).ratio()
-        scored.append((canonical, ratio))
-    scored.sort(key=lambda x: x[1], reverse=True)
-    suggestions = [f"  • {name} ({ratio:.0%})" for name, ratio in scored[:3]]
-
-    raise ValueError(
-        f"Solicitor '{input_name}' not found.\n"
-        f"Closest matches:\n" + "\n".join(suggestions) + "\n\n"
-        f"You can add this firm using the 'Add New Solicitor' section below."
-    )
-
-
-# ── Cross-run text replacement ──────────────────────────────────────────────
-
-def replace_in_paragraph(paragraph, old_text, new_text):
-    """
-    Replace text across runs in a paragraph while preserving formatting
-    of the first run. Handles placeholders split across multiple runs.
-    """
-    full_text = paragraph.text
-    if old_text not in full_text:
-        return False
-
-    new_full = full_text.replace(old_text, new_text)
-
-    runs = paragraph.runs
-    if not runs:
-        return False
-
-    # Preserve first run's formatting, put all text there, clear the rest
-    runs[0].text = new_full
-    for r in runs[1:]:
-        r.text = ""
-    return True
-
-
-def apply_replacements(doc, replacements):
-    """Apply all replacements across paragraphs and table cells."""
-    for old, new in replacements.items():
-        # Top-level paragraphs
-        for p in doc.paragraphs:
-            replace_in_paragraph(p, old, new)
-        # Table cells
-        for table in doc.tables:
-            for row in table.rows:
-                for cell in row.cells:
-                    for p in cell.paragraphs:
-                        replace_in_paragraph(p, old, new)
-
-
-# ── PDF conversion ──────────────────────────────────────────────────────────
-
-def convert_docx_to_pdf(docx_path, output_dir):
-    """
-    Convert a .docx to .pdf using LibreOffice.
-    Returns the path to the generated PDF.
-    """
-    try:
-        subprocess.run(
-            [
-                "libreoffice", "--headless", "--norestore",
-                "--convert-to", "pdf",
-                "--outdir", output_dir,
-                docx_path,
-            ],
-            capture_output=True,
-            timeout=30,
-            check=True,
-        )
-        pdf_name = os.path.splitext(os.path.basename(docx_path))[0] + ".pdf"
-        pdf_path = os.path.join(output_dir, pdf_name)
-        if os.path.exists(pdf_path):
-            return pdf_path
-    except Exception:
-        pass
-    return None
-
-
-# ── Date formatting ─────────────────────────────────────────────────────────
-
-def format_date_for_fee_note(dt=None):
-    """
-    Format date as '6 March 2026' (no leading zero on day).
-    """
-    if dt is None:
-        dt = datetime.today()
-    return f"{dt.day} {dt.strftime('%B')} {dt.year}"
-
-
-# ── Main generation logic ───────────────────────────────────────────────────
-
-def generate_batch_fee_notes(csv_text):
-    """
-    Process pipe-delimited input and generate fee note DOCX + PDF files.
-
-    Required columns:
-        filename | solicitor_name | case_record | case_name | description | net_amount
-    """
-    addresses_lookup = load_solicitor_addresses()
-
-    if not csv_text.strip():
-        raise gr.Error("Input is empty. Please paste at least one row of data.")
-
-    # Check if user included a header row
-    lines = csv_text.strip().split("\n")
-    first_line_lower = lines[0].lower()
-    has_header = "filename" in first_line_lower and "solicitor" in first_line_lower
-
-    if not has_header:
-        # Prepend the header row automatically
-        csv_text = "filename | solicitor_name | case_record | case_name | description | net_amount\n" + csv_text
-
-    csv_reader = csv.DictReader(
-        StringIO(csv_text),
-        delimiter="|",
-        quotechar='"',
-    )
-
-    if not csv_reader.fieldnames:
-        raise gr.Error("Could not parse input. Check the format and try again.")
-
-    csv_reader.fieldnames = [h.strip() for h in csv_reader.fieldnames]
-
-    required_cols = {"filename", "solicitor_name", "case_record", "case_name", "description", "net_amount"}
-    provided_cols = set(csv_reader.fieldnames)
-
-    if not required_cols.issubset(provided_cols):
-        missing = required_cols - provided_cols
-        raise gr.Error(
-            f"Missing required columns: {', '.join(missing)}\n"
-            f"Required: filename | solicitor_name | case_record | case_name | description | net_amount"
-        )
-
-    if not os.path.exists(TEMPLATE_PATH):
-        raise gr.Error(
-            f"Template '{TEMPLATE_PATH}' not found. "
-            f"Please upload Fee-Note-Template.docx to the Space."
-        )
-
-    tmpdir = tempfile.mkdtemp()
-    output_files = []
-    today_str = format_date_for_fee_note()
-    errors = []
-
-    rows = list(csv_reader)
-    if not rows:
-        raise gr.Error("No data rows found. Please check your input.")
-
-    for row_num, row in enumerate(rows, start=1):
-        try:
-            row = {k: (v.strip() if v else "") for k, v in row.items()}
-
-            filename = row["filename"].strip()
-            if not filename:
-                errors.append(f"Row {row_num}: filename is empty, skipped.")
-                continue
-
-            fee_note_number = filename
-            docx_name = filename if filename.endswith(".docx") else filename + ".docx"
-
-            solicitor_name = row["solicitor_name"].strip()
-            canonical_name, address = find_solicitor(solicitor_name, addresses_lookup)
-
-            # Parse net amount
-            raw_net = row["net_amount"].replace("€", "").replace(",", "").strip()
-            if not raw_net:
-                errors.append(f"Row {row_num}: net_amount is empty, skipped.")
-                continue
-
-            net_value = float(raw_net)
-            vat_value = round(net_value * 0.23, 2)
-            gross_value = round(net_value + vat_value, 2)
-
-            net_str = f"€{net_value:,.2f}"
-            vat_str = f"€{vat_value:,.2f}"
-            gross_str = f"€{gross_value:,.2f}"
-
-            # Load template and apply replacements
-            doc = Document(TEMPLATE_PATH)
-
-            replacements = {
-                "[Insert Todays Date Here]": today_str,
-                "[Insert Solicitor Here]": canonical_name,
-                "[Insert Address Here]": address,
-                "[Insert Case Record Number]": row["case_record"].strip(),
-                "[Insert Case Name]": row["case_name"].strip(),
-                "[Insert Description]": row["description"].strip(),
-                "[Insert Net Amount]": net_str,
-                "[Insert VAT at .23% of Net Amount]": vat_str,
-                "[Insert Gross Here]": gross_str,
-                "[Insert Number Here]": fee_note_number,
-            }
-
-            apply_replacements(doc, replacements)
-
-            docx_path = os.path.join(tmpdir, docx_name)
-            doc.save(docx_path)
-            output_files.append((docx_name, docx_path))
-
-            # Convert to PDF
-            pdf_path = convert_docx_to_pdf(docx_path, tmpdir)
-            if pdf_path:
-                pdf_name = os.path.splitext(docx_name)[0] + ".pdf"
-                output_files.append((pdf_name, pdf_path))
-
-        except ValueError as e:
-            errors.append(f"Row {row_num}: {str(e)}")
-        except Exception as e:
-            errors.append(f"Row {row_num}: unexpected error — {str(e)}")
-
-    if not output_files:
-        error_msg = "No fee notes were generated.\n\n" + "\n".join(errors) if errors else "No fee notes were generated."
-        raise gr.Error(error_msg)
-
-    # Create zip
-    zip_path = os.path.join(tmpdir, "Fee-Notes.zip")
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
-        for display_name, file_path in output_files:
-            zf.write(file_path, arcname=display_name)
-
-    status_parts = [f"Generated {len([f for f in output_files if f[0].endswith('.docx')])} fee notes (DOCX + PDF)."]
-    if errors:
-        status_parts.append("\n**Warnings:**\n" + "\n".join(f"- {e}" for e in errors))
-
-    return zip_path, "\n".join(status_parts)
-
-
-# ── Add new solicitor ───────────────────────────────────────────────────────
-
-def add_solicitor(firm_name, firm_address, firm_domain, firm_email_notes):
-    """Append a new solicitor to Solicitors-Addresses.txt."""
-    if not firm_name.strip():
-        raise gr.Error("Firm name is required.")
-    if not firm_address.strip():
-        raise gr.Error("Address is required.")
-
-    block = f"\n\n{firm_name.strip()}\nAddress: {firm_address.strip()}"
-    if firm_domain.strip():
-        block += f"\nDomain: {firm_domain.strip()}"
-    if firm_email_notes.strip():
-        block += f"\nEmail return always: {firm_email_notes.strip()}"
-
-    with open(ADDRESSES_PATH, "a", encoding="utf-8") as f:
-        f.write(block + "\n")
-
-    # Reload and return updated list
-    addresses = load_solicitor_addresses()
-    firms_list = "\n".join(f"• {name} — {addr}" for name, addr in sorted(addresses.items()))
-    return f"Added **{firm_name.strip()}** successfully.\n\n**Current firms ({len(addresses)}):**\n{firms_list}"
-
-
-def get_current_firms():
-    """Return formatted list of current firms."""
-    addresses = load_solicitor_addresses()
-    if not addresses:
-        return "No firms loaded. Check that Solicitors-Addresses.txt exists in the Space."
-    return "\n".join(f"• **{name}** — {addr}" for name, addr in sorted(addresses.items()))
-
-
-# ── Gradio UI ───────────────────────────────────────────────────────────────
-
-with gr.Blocks(title="Fee Note Generator", theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        """
-        # Fee Note Generator
-
-        Paste pipe-delimited fee note data below. Each row generates a DOCX and PDF fee note from your template.
-
-        **Format** (header row is optional — it will be added automatically if missing):
-
-        ```
-        filename | solicitor_name | case_record | case_name | description | net_amount
-        ```
-
-        - **filename**: becomes the file name and fee note number (e.g. `20264402` → `20264402.docx` / `.pdf`)
-        - **solicitor_name**: matched against the solicitor directory (fuzzy matching handles minor variations)
-        - **net_amount**: numeric, e.g. `200` or `1000.00` — VAT (23%) and gross are calculated automatically
-        - **Date**: today's date is inserted automatically
-        """
-    )
-
-    with gr.Row():
-        csv_input = gr.Textbox(
-            lines=14,
-            label="Pipe-delimited input",
-            placeholder=(
-                "20264402 | O'Connor LLP | 2023/00700 | Permanent TSB PLC v Jeffrey Barrett | "
-                "Attendance, Limerick Circuit Court County Registrar 6.3.26, adjourned | 200\n"
-                "20264403 | Beauchamps LLP | 2023/00538 | Pepper Finance v Lynch | "
-                "Attendance, Limerick Circuit Court County Registrar 6.3.26, adjourned | 200"
-            ),
-        )
-
-    with gr.Row():
-        run_button = gr.Button("Generate Fee Notes", variant="primary", size="lg")
-
-    with gr.Row():
-        output_zip = gr.File(label="Download fee notes (.zip)")
-        status_output = gr.Markdown(label="Status")
-
-    run_button.click(
-        fn=generate_batch_fee_notes,
-        inputs=[csv_input],
-        outputs=[output_zip, status_output],
-    )
-
-    # ── Add New Solicitor section ──
-    gr.Markdown("---")
-    gr.Markdown("### Add New Solicitor")
-    gr.Markdown("Add a firm that isn't in the directory yet. It will be available immediately for the next generation run.")
-
-    with gr.Row():
-        with gr.Column():
-            new_firm_name = gr.Textbox(label="Firm Name", placeholder="e.g. MDM Solicitors LLP")
-            new_firm_address = gr.Textbox(label="Address", placeholder="e.g. 16 Lavitt's Quay, Cork, T12 ED74")
-        with gr.Column():
-            new_firm_domain = gr.Textbox(label="Domain (optional)", placeholder="e.g. mdmsolicitors.ie")
-            new_firm_email = gr.Textbox(label="Email routing notes (optional)", placeholder="e.g. returns@mdmsolicitors.ie")
-
-    add_button = gr.Button("Add Solicitor", size="sm")
-    add_result = gr.Markdown()
-
-    add_button.click(
-        fn=add_solicitor,
-        inputs=[new_firm_name, new_firm_address, new_firm_domain, new_firm_email],
-        outputs=[add_result],
-    )
-
-    # ── Current directory ──
-    gr.Markdown("---")
-    with gr.Accordion("View Current Solicitor Directory", open=False):
-        firms_display = gr.Markdown(value=get_current_firms)
-        refresh_btn = gr.Button("Refresh", size="sm")
-        refresh_btn.click(fn=get_current_firms, outputs=[firms_display])
-
-
-demo.launch()