Update app.py

app.py

@@ -1,30 +1,193 @@
-import gradio as gr
+import re
 import json
+from typing import Dict, Any
+import dateparser
+import gradio as gr
+
+# ---------- Heuristic extractors (no ML) ----------
+
+def _clean(s: str) -> str:
+    return re.sub(r'\s+', ' ', s).strip()
+
+def extract_parties(text: str):
+    # Common phrasing: "This Lease Agreement is made between X and Y"
+    m = re.search(r'\bbetween\s+(.+?)\s+and\s+(.+?)(?:[,.;\n]| for\b)', text, re.IGNORECASE | re.DOTALL)
+    if m:
+        p1 = _clean(m.group(1))
+        p2 = _clean(m.group(2))
+        # Strip leading roles if present
+        p1 = re.sub(r'^(?:the\s+)?(landlord|lessor|owner)\s*[:\-]*\s*', '', p1, flags=re.I)
+        p2 = re.sub(r'^(?:the\s+)?(tenant|lessee|occupant)\s*[:\-]*\s*', '', p2, flags=re.I)
+        return [p1, p2]
+    # Fallback: look for "Landlord: X" / "Tenant: Y"
+    p = []
+    m1 = re.search(r'\bLandlord\s*[:\-]\s*(.+?)(?:[,.;\n])', text, flags=re.I)
+    m2 = re.search(r'\bTenant\s*[:\-]\s*(.+?)(?:[,.;\n])', text, flags=re.I)
+    if m1: p.append(_clean(m1.group(1)))
+    if m2: p.append(_clean(m2.group(1)))
+    return p or None
+
+def extract_address(text: str):
+    # "premises located at 123 Main St, City, ST 12345"
+    patterns = [
+        r'(?:premises|property)\s+(?:located\s+)?at\s+(.+?)(?:[,.;\n])',
+        r'\blocated at\s+(.+?)(?:[,.;\n])',
+        r'\baddress\s*[:\-]\s*(.+?)(?:[,.;\n])'
+    ]
+    for pat in patterns:
+        m = re.search(pat, text, flags=re.I)
+        if m:
+            return _clean(m.group(1))
+    return None
+
+def extract_term(text: str):
+    # "lease term is 12 months", "for a term of 2 years"
+    m = re.search(r'(?:lease\s+term\s+is|for\s+a\s+term\s+of|term\s*[:\-])\s*(\d{1,3})\s*(month|months|year|years)', text, flags=re.I)
+    if m:
+        n = int(m.group(1))
+        unit = m.group(2).lower()
+        if unit.startswith('year'):
+            return f"{n} years"
+        return f"{n} months"
+    # "12-month term"
+    m = re.search(r'(\d{1,3})\s*-\s*month\s+term', text, flags=re.I)
+    if m:
+        return f"{int(m.group(1))} months"
+    return None
+
+def extract_start_date(text: str):
+    # Try to find the first plausible date near "commencing/starting/effective"
+    window = re.search(r'(?:commencing|starting|effective)\s+on\s+(.{0,60})', text, flags=re.I)
+    candidates = []
+    if window:
+        parsed = dateparser.search.search_dates(window.group(0))
+        if parsed:
+            candidates.extend([d for _, d in parsed])
+    if not candidates:
+        parsed = dateparser.search.search_dates(text)
+        if parsed:
+            candidates.extend([d for _, d in parsed])
+    if candidates:
+        # Return earliest found (often the start date)
+        dt = sorted(candidates)[0]
+        return dt.strftime('%Y-%m-%d')
+    return None
+
+def extract_rent(text: str):
+    # Capture currency and amount, e.g., "$1,500", "€1200", "£900"
+    # Prefer near "monthly rent"
+    near = re.search(r'(?:monthly|base)\s+rent[^.\n]{0,40}?(\$|€|£)?\s*([0-9][\d,]*\.?\d{0,2})', text, flags=re.I)
+    if not near:
+        near = re.search(r'\b(?:rent\s+of|rent\s+is)\s*(\$|€|£)?\s*([0-9][\d,]*\.?\d{0,2})', text, flags=re.I)
+    if near:
+        cur = near.group(1) or ''
+        amt = float(near.group(2).replace(',', ''))
+        currency = {'$': 'USD', '€': 'EUR', '£': 'GBP'}.get(cur, None)
+        return {'amount': amt, 'currency': currency, 'period': 'monthly'}
+    return None
+
+def detect_jurisdiction(text: str):
+    # Basic hints only
+    if re.search(r'\bUnited States\b|\bState of [A-Z][a-z]+|\bNY\b|\bCA\b', text): return "US"
+    if re.search(r'\bEuropean Union\b|\bPortugal\b|\bLisbon\b', text, flags=re.I): return "EU/PT"
+    if re.search(r'\bUnited Kingdom\b|\bEngland\b|\bWales\b', text, flags=re.I): return "UK"
+    return None
+
+CLAUSE_KEYWORDS = {
+    'termination': [r'\bterminate(?:d|s|ion)?\b', r'\bearly termination\b'],
+    'liability': [r'\bliabilit(?:y|ies)\b', r'\blimit(?:ation)? of liability\b'],
+    'indemnity': [r'\bindemnif(?:y|ication)\b', r'\bindemnitor\b'],
+    'governing_law': [r'\bgoverning law\b', r'\blaws? of\b'],
+    'security_deposit': [r'\bsecurity deposit\b'],
+    'late_fee': [r'\blate fee\b', r'\bpenalt(y|ies)\b'],
+    'sublet_assignment': [r'\bsublet\b', r'\bassignment\b'],
+    'maintenance_repairs': [r'\bmaintenance\b', r'\brepairs?\b'],
+    'utilities': [r'\butilities\b', r'\bwater|gas|electricity\b'],
+    'entry_access': [r'\bright of entry\b', r'\baccess\b'],
+}
 
-def extract_metadata(contract_text):
-    # Placeholder extraction (replace with model pipeline later)
-    metadata = {
-        "parties": ["Landlord", "Tenant"],
-        "property_address": "123 Main Street",
-        "lease_term": "12 months",
-        "start_date": "2025-06-01",
-        "rent_amount": 1500,
-        "clauses": {
-            "termination": True,
-            "liability": True,
-            "indemnity": False
-        },
-        "jurisdiction": "US"
+def extract_clauses(text: str) -> Dict[str, bool]:
+    results = {}
+    for name, pats in CLAUSE_KEYWORDS.items():
+        found = any(re.search(pat, text, flags=re.I) for pat in pats)
+        results[name] = bool(found)
+    return results
+
+def summarize(metadata: Dict[str, Any]) -> str:
+    parts = []
+    if metadata.get('parties'):
+        parts.append(f"**Parties:** {', '.join(metadata['parties'])}")
+    if metadata.get('property_address'):
+        parts.append(f"**Property:** {metadata['property_address']}")
+    if metadata.get('lease_term'):
+        parts.append(f"**Term:** {metadata['lease_term']}")
+    if metadata.get('start_date'):
+        parts.append(f"**Start Date:** {metadata['start_date']}")
+    if metadata.get('rent'):
+        r = metadata['rent']
+        cur = {'USD': '$', 'EUR': '€', 'GBP': '£'}.get(r.get('currency'), '')
+        parts.append(f"**Rent:** {cur}{r.get('amount')} / {r.get('period','monthly')}")
+    if metadata.get('jurisdiction'):
+        parts.append(f"**Jurisdiction:** {metadata['jurisdiction']}")
+    # Clauses brief
+    if metadata.get('clauses'):
+        on = [k.replace('_',' ') for k, v in metadata['clauses'].items() if v]
+        parts.append(f"**Detected Clauses:** {', '.join(on) if on else 'None detected'}")
+    return "  \n".join(parts) if parts else "_No summary available._"
+
+def extract_metadata(contract_text: str) -> Dict[str, Any]:
+    text = contract_text.strip()
+    if not text:
+        return {"error": "No text provided."}
+
+    parties = extract_parties(text)
+    address = extract_address(text)
+    term = extract_term(text)
+    start_date = extract_start_date(text)
+    rent = extract_rent(text)
+    juris = detect_jurisdiction(text)
+    clauses = extract_clauses(text)
+
+    return {
+        "parties": parties,
+        "property_address": address,
+        "lease_term": term,
+        "start_date": start_date,
+        "rent": rent,
+        "jurisdiction": juris,
+        "clauses": clauses
     }
-    return json.dumps(metadata, indent=2)
-
-demo = gr.Interface(
-    fn=extract_metadata,
-    inputs=gr.Textbox(lines=12, placeholder="Paste lease or contract here..."),
-    outputs="json",
-    title="🏠 ProofAssets: Real Estate Tokenizer",
-    description="Extract metadata from real estate contracts and convert into structured format for tokenization."
-)
+
+# ---------- Gradio UI ----------
+
+EXAMPLE_TEXT = """This Lease Agreement is made between Landlord X and Tenant Y for the premises located at 123 Main Street, Albany, NY 12207.
+The lease term is 12 months, commencing on June 1, 2025. The monthly rent is $1,500, due on the first of each month.
+A security deposit is required. Late fees may apply. The governing law shall be the laws of the State of New York.
+Either party may terminate this agreement for cause subject to 30 days' notice. Sublet or assignment requires prior written consent.
+Landlord is responsible for structural repairs; Tenant shall handle routine maintenance. Utilities include water and electricity.
+"""
+
+def run_pipeline(text):
+    meta = extract_metadata(text)
+    # Pretty JSON + human summary
+    summary_md = summarize(meta)
+    json_str = json.dumps(meta, indent=2, ensure_ascii=False)
+    return summary_md, json_str
+
+with gr.Blocks(title="ProofAssets: Real Estate Tokenizer") as demo:
+    gr.Markdown("# 🏠 ProofAssets: Real Estate Tokenizer")
+    gr.Markdown("Paste a lease/contract. The app will extract key fields and detect common clauses. *(Heuristic demo — no legal advice.)*")
+
+    with gr.Row():
+        inp = gr.Textbox(label="Contract Text", lines=14, value=EXAMPLE_TEXT, show_copy_button=True)
+    with gr.Row():
+        btn = gr.Button("Extract Metadata", variant="primary")
+    with gr.Row():
+        summary_out = gr.Markdown(label="Summary")
+    with gr.Row():
+        json_out = gr.JSON(label="Structured JSON")
+
+    btn.click(fn=run_pipeline, inputs=inp, outputs=[summary_out, json_out])
 
 if __name__ == "__main__":
     demo.launch()