Upload app.py

app.py

@@ -0,0 +1,594 @@
+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)
+
+
+# ── VAT alignment fix ───────────────────────────────────────────────────────
+
+def fix_vat_alignment(doc):
+    """
+    After replacements, the VAT amount can end up on a different visual line
+    than the '+VAT @ 23%' label because the description text wraps.
+
+    Fix: set the amount cell to bottom-vertical-align and rebuild it with
+    just three paragraphs (net → spacer → VAT).  The VAT amount then sits
+    at the bottom of the cell, beside the '+VAT @ 23%' label.
+    """
+    from docx.oxml.ns import qn
+    ns = {'w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'}
+
+    for table in doc.tables:
+        for row in table.rows:
+            cells = row.cells
+            # Find the description cell that contains '+VAT @ 23%'
+            desc_cell = None
+            for cell in cells:
+                for p in cell.paragraphs:
+                    if '+VAT @' in p.text:
+                        desc_cell = cell
+                        break
+                if desc_cell:
+                    break
+
+            if not desc_cell:
+                continue
+
+            # Find the amount cell (different element from desc_cell, contains €)
+            amt_cell = None
+            for cell in cells:
+                if cell._element is desc_cell._element:
+                    continue
+                for p in cell.paragraphs:
+                    if '€' in p.text:
+                        amt_cell = cell
+                        break
+                if amt_cell:
+                    break
+
+            if not amt_cell:
+                continue
+
+            # Extract net and VAT amounts
+            amt_paras = amt_cell._element.findall('w:p', ns)
+            net_text = None
+            net_para_ref = None
+            vat_text = None
+            vat_para_ref = None
+
+            for p in amt_paras:
+                text = ''.join(t.text or '' for t in p.findall('.//w:t', ns)).strip()
+                if '€' in text and net_text is None:
+                    net_text = text
+                    net_para_ref = p
+                elif '€' in text:
+                    vat_text = text
+                    vat_para_ref = p
+
+            if not net_text or not vat_text:
+                continue
+
+            # ── Set bottom vertical alignment on the amount cell ──
+            tcPr = amt_cell._element.find('w:tcPr', ns)
+            if tcPr is None:
+                tcPr = amt_cell._element.makeelement(qn('w:tcPr'), {})
+                amt_cell._element.insert(0, tcPr)
+            # Remove any existing vAlign
+            for old_va in tcPr.findall('w:vAlign', ns):
+                tcPr.remove(old_va)
+            vAlign = tcPr.makeelement(qn('w:vAlign'), {qn('w:val'): 'bottom'})
+            tcPr.append(vAlign)
+
+            # ── Rebuild cell paragraphs: net → spacer → VAT ──
+            for p in amt_paras:
+                amt_cell._element.remove(p)
+
+            def _make_centered_para(text, fmt_ref):
+                """Create a centered paragraph with the given text, copying run formatting."""
+                p = amt_cell._element.makeelement(qn('w:p'), {})
+                pPr = p.makeelement(qn('w:pPr'), {})
+                jc = pPr.makeelement(qn('w:jc'), {qn('w:val'): 'center'})
+                pPr.append(jc)
+                p.append(pPr)
+                r = p.makeelement(qn('w:r'), {})
+                if fmt_ref is not None:
+                    orig_runs = fmt_ref.findall('.//w:r', ns)
+                    if orig_runs:
+                        rPr = orig_runs[0].find('w:rPr', ns)
+                        if rPr is not None:
+                            r.append(rPr.__deepcopy__(True))
+                t = r.makeelement(qn('w:t'), {})
+                t.text = text
+                t.set(qn('xml:space'), 'preserve')
+                r.append(t)
+                p.append(r)
+                return p
+
+            # Para 0: net amount
+            amt_cell._element.append(_make_centered_para(net_text, net_para_ref))
+            # Para 1: empty spacer
+            amt_cell._element.append(amt_cell._element.makeelement(qn('w:p'), {}))
+            # Para 2: VAT amount
+            amt_cell._element.append(_make_centered_para(vat_text, vat_para_ref))
+
+            return  # done — only one such row per fee note
+
+
+# ── 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)
+            fix_vat_alignment(doc)
+
+            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()