Upload 6 files

README.md

@@ -0,0 +1,42 @@
+---
+title: FeeNoteGen
+emoji: ⚖️
+colorFrom: indigo
+colorTo: gray
+sdk: gradio
+sdk_version: 5.12.0
+python_version: 3.11
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Fee Note Generator
+
+Batch fee note generator for counsel. Paste pipe-delimited fee note data and receive DOCX + PDF fee notes generated from a template.
+
+## Features
+
+- **Auto date**: Today's date is inserted automatically — no need to update the template
+- **Fuzzy solicitor matching**: Handles variations like `AB Wolfe & Co.` vs `AB Wolfe and Co.` automatically
+- **DOCX + PDF output**: Both formats generated for every fee note
+- **VAT calculation**: Net → VAT (23%) → Gross calculated automatically
+- **Add solicitors on the fly**: New firms can be added via the UI without redeploying
+- **Cross-run replacement**: Handles Word's internal text splitting reliably
+
+## Input format
+
+```
+filename | solicitor_name | case_record | case_name | description | net_amount
+20264402 | O'Connor LLP | 2023/00700 | Permanent TSB PLC v Barrett | Attendance, Limerick CC 6.3.26 | 200
+```
+
+The header row is optional — if omitted, it is added automatically.
+
+## Files
+
+- `app.py` — Main application
+- `Fee-Note-Template.docx` — Template with placeholders
+- `Solicitors-Addresses.txt` — Solicitor directory (name, address, domain, email routing)
+- `packages.txt` — System dependencies (LibreOffice for PDF conversion)
+- `requirements.txt` — Python dependencies

Solicitors-Addresses.txt

@@ -0,0 +1,74 @@
+Mason Hayes & Curran
+Address: South Bank House, Barrow St, Dublin 4
+Domain: mhc.ie 
+Email return always: awallace@mhc.ie unless if last email is sent from noshea@mhc.ie then email noshea@mhc.ie and cc awallace@mhc.ie
+
+Lavelle Partners
+Address: Bankside, Charlemont, Dublin 2
+Domain: lavellepartners.ie
+Email return always: courtoutcomes@lavellesolicitors.ie
+
+Hugh J Ward and Co
+Address: 9 Seville Place, North Wall, Dublin 1
+Domain: hughjwardsolicitors.ie
+Email return always: hjwagentinstructions@hughjwardsolicitors.ie and also jstuart@hughjwardsolicitors.ie
+
+O'Connor LLP
+Address: 8 Clare St, Dublin 2
+Domain: oclegal.ie 
+Email return always: always mirra.nepomuceno@oclegal.ie and ashley.coakley@oclegal.ie
+
+Matheson
+Address: 70 Sir John Rogerson's Quay, Dublin 2
+Domain: matheson.com
+
+AB Wolfe and Co. 
+Address: 70 Sir John Rogerson's Quay, Dublin 2
+Domain: matheson.com
+
+
+Belgard Solicitors
+Address: Cookstown Court, Old Belgard Road, Dublin 24
+Domain: belgardsolicitors.ie
+
+Eversheds Sutherland
+Address: One Earlsfort Centre, Dublin 2
+Domain: eversheds-sutherland.com
+Email return always: courtenquiries@evershedssutherland.ie
+
+Dillon Eustace
+Address: 2 Grand Canal Square, Dublin 2
+Domain: dilloneustace.com
+
+Beauchamps LLP
+Address: Riverside Two, Sir John Rogerson's Quay, Dublin 2
+Domain: beauchamps.ie
+Email Return Always: repocourtoutcomes@beauchamps.ie
+
+BHSM LLP
+Address: 76 Baggot Street Lower, Dublin 2
+Domain: bhsm.ie
+Email Return Contact Always: rmelvin@bhsm.ie
+
+OSM Partners
+Address: 87 Harcourt Street, Dublin 2
+Domain: osmpartners.ie 
+Email Return Contact Always: skeogh@osmpartners.ie and also cc preilly@osmpartners.ie
+
+Joynt and Crawford
+Address: 8 Anglesea Terrace, Dublin 2
+Domain: joyntandcrawford.ie
+Email return always: suzannefinglas@joyntcrawford.ie and check for emails in relation to the matter sent from tamara.mclaughlin@joyntcrawford.ie
+
+Fieldfisher
+Address: 45 Mespil Road, Dublin 4
+Domain: fieldfisher.com
+
+RDJ LLP
+Address: Aengus House, Dock Street, Galway
+
+AMOSS
+Address: Warrington House, Mount St Cresc, Dublin 2
+
+MDM Solicitors
+Address: 16 Lavitt's Quay, Cork, T12 ED74, Ireland

app.py

@@ -0,0 +1,483 @@
+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()

packages.txt

@@ -0,0 +1 @@
+libreoffice-nogui

requirements.txt

@@ -0,0 +1,2 @@
+gradio==5.12.0
+python-docx==1.1.2