Delete app.py

app.py

@@ -1,1191 +0,0 @@
-# app.py - GeoMate V2 (single-file Streamlit app)
-# Large, feature-rich application implementing many GeoMate V2 features:
-# - Multi-site session-state (up to 4 sites)
-# - Landing page (fancy UI)
-# - Sidebar with model selector + site manager
-# - Soil Classifier (chatbot-style, stepwise, retains inputs, text inputs to avoid +/- steppers)
-# - OCR option (EasyOCR) to auto-extract classification parameters from images
-# - Locator page with map drawing (folium fallback if Earth Engine unavailable)
-# - GeoMate Ask (RAG placeholder; per-site memory stored)
-# - Reports: Basic (10-15 params) and Detailed (all parameters); PDF export
-# - Site comparison feature (compare multiple sites when "Nature of Construction" is same)
-#
-# NOTE: This is a big single-file app. Adjust imports/requirements as necessary.
-
-import os
-import io
-import json
-import re
-import datetime
-from typing import Dict, Any, List, Optional, Tuple
-
-import streamlit as st
-
-# Set page config at top
-st.set_page_config(page_title="GeoMate V2", page_icon="🌍", layout="wide")
-
-# -------------------------
-# Imports that may be optional
-# -------------------------
-# OCR: easyocr (optional)
-try:
-    import easyocr
-    HAVE_EASYOCR = True
-except Exception:
-    HAVE_EASYOCR = False
-
-# Map: folium + streamlit_folium as fallback
-try:
-    import folium
-    from streamlit_folium import st_folium
-    HAVE_FOLIUM = True
-except Exception:
-    HAVE_FOLIUM = False
-
-# Report / PDF
-try:
-    from reportlab.lib.pagesizes import A4
-    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, Image
-    from reportlab.lib import colors
-    HAVE_REPORTLAB = True
-except Exception:
-    HAVE_REPORTLAB = False
-
-# Attempt to import geemap / earthengine (may fail without credentials)
-try:
-    import ee
-    import geemap.foliumap as geemap
-    HAVE_EE = True
-except Exception:
-    HAVE_EE = False
-
-# Groq placeholder: we will not crash if groq is missing; just show warnings
-try:
-    from groq import Groq
-    HAVE_GROQ = True
-except Exception:
-    HAVE_GROQ = False
-
-# ---------- Helper / Config ----------
-MAX_SITES = 4
-
-# Initialize session state shortcut
-ss = st.session_state
-
-# Initialize default session keys
-if "site_descriptions" not in ss:
-    # site_descriptions is list of dicts, one per site
-    ss["site_descriptions"] = []
-if "active_site_index" not in ss:
-    ss["active_site_index"] = 0
-if "llm_model" not in ss:
-    ss["llm_model"] = "llama3-8b-8192"
-if "secrets_status" not in ss:
-    ss["secrets_status"] = {"groq_ok": False, "ee_ok": False}
-if "global_chat_history" not in ss:
-    ss["global_chat_history"] = []  # optional general chat log
-
-# ---------- Secrets check (warn but continue) ----------
-def check_secrets():
-    """Check environment for relevant secrets and update ss.secrets_status."""
-    groq_key = os.environ.get("GROQ_API_KEY") or os.environ.get("GROQ_KEY")
-    service_account = os.environ.get("SERVICE_ACCOUNT") or os.environ.get("EE_SERVICE_ACCOUNT") or os.environ.get("EARTH_ENGINE_KEY")
-    # Update statuses (we don't stop the app; we just show warnings)
-    ss["secrets_status"]["groq_ok"] = bool(groq_key)
-    ss["secrets_status"]["ee_ok"] = bool(service_account)
-    return ss["secrets_status"]
-
-check_secrets()
-
-# ---------- Utilities ----------
-def now_str():
-    return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-def ensure_site(index: int):
-    """Ensure that a site dict exists at site_descriptions[index]."""
-    while len(ss.site_descriptions) <= index:
-        # default structure for a site
-        ss.site_descriptions.append({
-            "Site Name": f"Site-{len(ss.site_descriptions)+1}",
-            "Site Coordinates": "",
-            "lat": None,
-            "lon": None,
-            "Load Bearing Capacity": None,
-            "Skin Shear Strength": None,
-            "Relative Compaction": None,
-            "Rate of Consolidation": None,
-            "Nature of Construction": None,
-            "Soil Profile": None,
-            "Flood Data": None,
-            "Seismic Data": None,
-            "GSD": None,
-            "USCS": None,
-            "AASHTO": None,
-            "GI": None,
-            "classifier_inputs": {},
-            "classifier_decision_path": "",
-            "chat_history": [],
-            "report_convo_state": 0,
-            "map_snapshot": None,
-            "classifier_state": 0,
-            "classifier_chat": []
-        })
-    return ss.site_descriptions[index]
-
-def active_site():
-    idx = ss.active_site_index if 0 <= ss.active_site_index < len(ss.site_descriptions) else 0
-    ensure_site(idx)
-    return idx, ss.site_descriptions[idx]
-
-# ---------- OCR extraction helper ----------
-ocr_reader = None
-if HAVE_EASYOCR:
-    try:
-        # single-language English by default
-        ocr_reader = easyocr.Reader(["en"], gpu=False)
-    except Exception:
-        ocr_reader = None
-
-def parse_numbers_from_text(text: str) -> Dict[str, float]:
-    """
-    Attempt to extract common classification numbers from text:
-    - % passing #200 (P2)
-    - % passing #4 (P4)
-    - D60, D30, D10
-    - LL, PL
-    Returns dict of found floats.
-    """
-    out = {}
-    # common patterns
-    # e.g., "% Passing sieve #200: 35" or "P2 = 35%"
-    patterns = {
-        "P2": [r"%\s*passing\s*#?200[:\s]*([0-9]+(?:\.[0-9]+)?)",
-               r"P2[:\s=]*([0-9]+(?:\.[0-9]+)?)"],
-        "P4": [r"%\s*passing\s*#?4[:\s]*([0-9]+(?:\.[0-9]+)?)",
-               r"P4[:\s=]*([0-9]+(?:\.[0-9]+)?)"],
-        "D60": [r"D60[:\s=]*([0-9]+(?:\.[0-9]+)?)\s*mm?",
-                r"D60\s*=\s*([0-9]+(?:\.[0-9]+)?)"],
-        "D30": [r"D30[:\s=]*([0-9]+(?:\.[0-9]+)?)\s*mm?",
-                r"D30\s*=\s*([0-9]+(?:\.[0-9]+)?)"],
-        "D10": [r"D10[:\s=]*([0-9]+(?:\.[0-9]+)?)\s*mm?",
-                r"D10\s*=\s*([0-9]+(?:\.[0-9]+)?)"],
-        "LL": [r"Liquid\s*Limit\s*(?:[:=])\s*([0-9]+(?:\.[0-9]+)?)",
-               r"LL[:\s=]*([0-9]+(?:\.[0-9]+)?)"],
-        "PL": [r"Plastic\s*Limit\s*(?:[:=])\s*([0-9]+(?:\.[0-9]+)?)",
-               r"PL[:\s=]*([0-9]+(?:\.[0-9]+)?)"]
-    }
-    for key, pats in patterns.items():
-        for p in pats:
-            m = re.search(p, text, flags=re.I)
-            if m:
-                try:
-                    val = float(m.group(1))
-                    out[key] = val
-                    break
-                except:
-                    continue
-    return out
-
-def run_ocr_on_image_bytes(img_bytes: bytes) -> str:
-    """Run OCR on uploaded image bytes and return extracted plain text."""
-    if not ocr_reader:
-        return ""
-    try:
-        import numpy as np
-        from PIL import Image
-        img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
-        arr = np.array(img)
-        results = ocr_reader.readtext(arr, detail=0)
-        text = "\n".join(results)
-        return text
-    except Exception as e:
-        return ""
-
-# -------------------------
-# Soil classification logic (verbatim adapted)
-# -------------------------
-from math import floor
-
-# Engineering characteristics (small sample)
-ENGINEERING_CHARACTERISTICS = {
-    "Gravel": {"Settlement": "None", "Quicksand": "Impossible"},
-    "Coarse sand": {"Settlement": "None", "Quicksand": "Impossible"},
-    "Silt": {"Settlement": "Occurs", "Quicksand": "Liable"},
-    "Clay": {"Settlement": "Occurs", "Quicksand": "Impossible"}
-}
-
-def uscs_aashto_verbatim(inputs: Dict[str, Any]) -> Tuple[str, str, str, int, Dict[str,str]]:
-    """
-    Implements USCS & AASHTO logic adapted from your earlier script.
-    Returns (result_text, uscs_sym, aashto_sym, GI, char_summary)
-    """
-    # safe parse
-    opt = str(inputs.get("opt", "n")).lower()
-    if opt == 'y':
-        uscs = "Pt"
-        uscs_expl = "Peat / organic soil — compressible, high organic content; poor engineering properties."
-        aashto = "Organic (special handling)"
-        GI = 0
-        chars = {"summary":"Highly organic peat — large settlement, low strength, not suitable for foundations."}
-        result_text = f"According to USCS, the soil is {uscs} — {uscs_expl}\nAccording to AASHTO, the soil is {aashto} (Group Index = {GI})"
-        return result_text, uscs, aashto, GI, chars
-
-    # numeric inputs
-    try:
-        P2 = float(inputs.get("P2", 0.0))
-    except:
-        P2 = 0.0
-    try:
-        P4 = float(inputs.get("P4", 0.0))
-    except:
-        P4 = 0.0
-    try:
-        D60 = float(inputs.get("D60", 0.0))
-        D30 = float(inputs.get("D30", 0.0))
-        D10 = float(inputs.get("D10", 0.0))
-    except:
-        D60 = D30 = D10 = 0.0
-    try:
-        LL = float(inputs.get("LL", 0.0))
-        PL = float(inputs.get("PL", 0.0))
-    except:
-        LL = PL = 0.0
-    PI = LL - PL
-
-    Cu = (D60 / D10) if (D10 > 0 and D60 > 0) else 0
-    Cc = ((D30 ** 2) / (D10 * D60)) if (D10 > 0 and D30 > 0 and D60 > 0) else 0
-
-    # default placeholders
-    uscs = "Unknown"
-    uscs_expl = ""
-    aashto = "Unknown"
-
-    # USCS logic
-    if P2 <= 50:
-        if P4 <= 50:
-            # Gravels
-            if Cu and Cc:
-                if Cu >= 4 and 1 <= Cc <= 3:
-                    uscs = "GW"; uscs_expl = "Well-graded gravel (good engineering properties)."
-                else:
-                    uscs = "GP"; uscs_expl = "Poorly-graded gravel."
-            else:
-                if PI < 4 or PI < 0.73 * (LL - 20):
-                    uscs = "GM"; uscs_expl = "Silty gravel."
-                elif PI > 7 and PI > 0.73 * (LL - 20):
-                    uscs = "GC"; uscs_expl = "Clayey gravel."
-                else:
-                    uscs = "GM-GC"; uscs_expl = "Mixed fines."
-        else:
-            # Sands
-            if Cu and Cc:
-                if Cu >= 6 and 1 <= Cc <= 3:
-                    uscs = "SW"; uscs_expl = "Well-graded sand."
-                else:
-                    uscs = "SP"; uscs_expl = "Poorly-graded sand."
-            else:
-                if PI < 4 or PI <= 0.73 * (LL - 20):
-                    uscs = "SM"; uscs_expl = "Silty sand."
-                elif PI > 7 and PI > 0.73 * (LL - 20):
-                    uscs = "SC"; uscs_expl = "Clayey sand."
-                else:
-                    uscs = "SM-SC"; uscs_expl = "Transition silty/clayey sand."
-    else:
-        # fine soils (P2 > 50)
-        nDS = int(inputs.get("nDS", 6))
-        nDIL = int(inputs.get("nDIL", 6))
-        nTG = int(inputs.get("nTG", 6))
-        if LL < 50:
-            if 20 <= LL < 50 and PI <= 0.73 * (LL - 20):
-                if nDS == 1 or nDIL == 3 or nTG == 3:
-                    uscs, uscs_expl = "ML", "Silt (low plasticity)."
-                elif nDS == 3 or nDIL == 3 or nTG == 3:
-                    uscs, uscs_expl = "OL", "Organic silt."
-                else:
-                    uscs, uscs_expl = "ML-OL", "Mixed silt/organic."
-            elif 10 <= LL <= 30 and 4 <= PI <= 7 and PI > 0.72 * (LL - 20):
-                if nDS == 1 or nDIL == 1 or nTG == 1:
-                    uscs, uscs_expl = "ML", "Silt."
-                elif nDS == 2 or nDIL == 2 or nTG == 2:
-                    uscs, uscs_expl = "CL", "Clay (low plasticity)."
-                else:
-                    uscs, uscs_expl = "ML-CL", "Mixed silt/clay."
-            else:
-                uscs, uscs_expl = "CL", "Clay (low plasticity)."
-        else:
-            if PI < 0.73 * (LL - 20):
-                if nDS == 3 or nDIL == 4 or nTG == 4:
-                    uscs, uscs_expl = "MH", "Silt (high plasticity)."
-                elif nDS == 2 or nDIL == 2 or nTG == 4:
-                    uscs, uscs_expl = "OH", "Organic clay/silt (high plasticity)."
-                else:
-                    uscs, uscs_expl = "MH-OH", "Mixed high-plasticity."
-            else:
-                uscs, uscs_expl = "CH", "Clay (high plasticity)."
-
-    # AASHTO logic
-    if P2 <= 35:
-        if P2 <= 15 and P4 <= 30 and PI <= 6:
-            aashto = "A-1-a"
-        elif P2 <= 25 and P4 <= 50 and PI <= 6:
-            aashto = "A-1-b"
-        elif P2 <= 35 and P4 > 0:
-            if LL <= 40 and PI <= 10: aashto = "A-2-4"
-            elif LL >= 41 and PI <= 10: aashto = "A-2-5"
-            elif LL <= 40 and PI >= 11: aashto = "A-2-6"
-            elif LL >= 41 and PI >= 11: aashto = "A-2-7"
-            else: aashto = "A-2"
-        else: aashto = "A-3"
-    else:
-        if LL <= 40 and PI <= 10: aashto = "A-4"
-        elif LL >= 41 and PI <= 10: aashto = "A-5"
-        elif LL <= 40 and PI >= 11: aashto = "A-6"
-        else: aashto = "A-7-5" if PI <= (LL - 30) else "A-7-6"
-
-    a = P2 - 35
-    a = 0 if a < 0 else (40 if a > 40 else a)
-    b = P2 - 15
-    b = 0 if b < 0 else (40 if b > 40 else b)
-    c = LL - 40
-    c = 0 if c < 0 else (20 if c > 20 else c)
-    d = PI - 10
-    d = 0 if d < 0 else (20 if d > 20 else d)
-    GI = floor(0.2*a + 0.005*a*c + 0.01*b*d)
-
-    aashto_expl = f"{aashto} (GI = {GI})"
-
-    # choose engineering char summary
-    if uscs.startswith(("G","S")):
-        char_summary = ENGINEERING_CHARACTERISTICS.get("Coarse sand", {})
-    elif uscs.startswith(("M","C","O","H")):
-        char_summary = ENGINEERING_CHARACTERISTICS.get("Silt", {})
-    else:
-        char_summary = ENGINEERING_CHARACTERISTICS.get("Silt", {})
-
-    result_text = f"USCS: **{uscs}** — {uscs_expl}\n\nAASHTO: **{aashto_expl}**"
-    return result_text, uscs, aashto, GI, char_summary
-
-# -------------------------
-# UI components
-# -------------------------
-
-# ---------- CSS for styling (bubbles, rounded corners, active border) ----------
-def inject_css():
-    st.markdown(
-        """
-        <style>
-        /* App background and fonts */
-        .stApp {
-            background: linear-gradient(180deg, #050505 0%, #0b0b0b 100%);
-            color: #e8eef8;
-            font-family: "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-        }
-        /* Landing hero card */
-        .hero-card {
-            background: linear-gradient(180deg, rgba(255,122,0,0.06), rgba(31,78,121,0.02));
-            border-radius: 14px;
-            padding: 18px;
-            border: 1px solid rgba(255,122,0,0.08);
-        }
-        /* Chat bubble - bot */
-        .chat-bot {
-            background: #111111;
-            border-left: 4px solid #FF7A00;
-            padding: 12px;
-            border-radius: 12px;
-            margin-bottom:8px;
-        }
-        /* Chat bubble - user */
-        .chat-user {
-            background: linear-gradient(90deg,#1f4e79,#0f62fe);
-            padding: 10px;
-            border-radius: 12px;
-            color: white;
-            margin-bottom:8px;
-            text-align: right;
-        }
-        /* small muted text */
-        .muted { color: #97a8c6; font-size:13px }
-        /* fancy sidebar active item */
-        .option-selected { border-left: 4px solid #FF7A00 !important; padding-left:8px !important; }
-        </style>
-        """,
-        unsafe_allow_html=True
-    )
-
-inject_css()
-
-# ---------- Landing page ----------
-def landing_page():
-    st.markdown("<div style='display:flex;align-items:center;gap:12px'>"
-                "<div style='width:72px;height:72px;border-radius:16px;background:linear-gradient(135deg,#ff7a00,#ff3a3a);display:flex;align-items:center;justify-content:center;box-shadow:0 8px 28px rgba(0,0,0,0.6)'>"
-                "<span style='font-size:36px'>🛰️</span></div>"
-                "<div><h1 style='margin:0;color:#FF8C00'>GeoMate V2</h1>"
-                "<div class='muted'>AI geotechnical copilot — soil recognition, classification, locator, RAG, and reports</div></div></div>",
-                unsafe_allow_html=True)
-
-    st.markdown("---")
-    col1, col2 = st.columns([3,1])
-    with col1:
-        st.markdown("<div class='hero-card'>", unsafe_allow_html=True)
-        st.subheader("A smarter way to do geotechnical investigations")
-        st.write("""
-            GeoMate integrates soil classification (USCS & AASHTO), GSD plotting, OCR from images, site locator with mapping,
-            a RAG-powered technical assistant, and professional report generation — all inside Streamlit.
-            Use the sidebar to create project sites, pick an LLM model, and navigate between tools.
-        """)
-        st.markdown("</div>", unsafe_allow_html=True)
-        st.markdown("### Quick Actions")
-        c1, c2, c3 = st.columns(3)
-        if c1.button("🧪 Soil Classifier"):
-            ss.active_site_index = 0
-            st.experimental_rerun()
-        if c2.button("🌍 Locator"):
-            st.experimental_rerun()
-        if c3.button("📑 Reports"):
-            st.experimental_rerun()
-    with col2:
-        st.markdown("<div class='hero-card' style='text-align:center'>", unsafe_allow_html=True)
-        st.markdown(f"<div style='font-size:22px;color:#FF7A00;font-weight:700'>{len(ss.site_descriptions)}</div>", unsafe_allow_html=True)
-        st.markdown("<div class='muted'>Sites configured</div>", unsafe_allow_html=True)
-        st.markdown("</div>", unsafe_allow_html=True)
-
-    # show warnings about secrets in landing page but not blocking
-    if not ss.secrets_status.get("groq_ok", False):
-        st.warning("GROQ / LLM key not found in environment. RAG features will be limited. Set GROQ_API_KEY to enable LLM.")
-    if not ss.secrets_status.get("ee_ok", False):
-        st.info("Earth Engine service account not found. Locator will use fallback maps.")
-
-# ---------- Sidebar ----------
-def sidebar_ui():
-    st.sidebar.markdown("<div style='text-align:center; padding:6px 0;'><h3 style='color:#FF8C00; margin:0;'>GeoMate V2</h3></div>", unsafe_allow_html=True)
-    # model selector
-    st.sidebar.markdown("### LLM Model")
-    model = st.sidebar.selectbox("Select model", ["llama3-8b-8192", "gemma-7b-it", "mixtral-8x7b-32768"], index=0)
-    ss.llm_model = model
-
-    st.sidebar.markdown("---")
-    # Manage sites
-    st.sidebar.markdown("### Project Sites")
-    colA, colB = st.sidebar.columns([3,1])
-    new_site_name = colA.text_input("New site name", key="new_site_name_input")
-    if colB.button("➕", help="Add new site"):
-        if new_site_name:
-            if len(ss.site_descriptions) >= MAX_SITES:
-                st.sidebar.error(f"Maximum {MAX_SITES} sites allowed.")
-            else:
-                ss.site_descriptions.append({
-                    "Site Name": new_site_name,
-                    "Site Coordinates": "",
-                    "lat": None,
-                    "lon": None,
-                    "Load Bearing Capacity": None,
-                    "Skin Shear Strength": None,
-                    "Relative Compaction": None,
-                    "Rate of Consolidation": None,
-                    "Nature of Construction": None,
-                    "Soil Profile": None,
-                    "Flood Data": None,
-                    "Seismic Data": None,
-                    "GSD": None,
-                    "USCS": None,
-                    "AASHTO": None,
-                    "GI": None,
-                    "classifier_inputs": {},
-                    "classifier_decision_path": "",
-                    "chat_history": [],
-                    "report_convo_state": 0,
-                    "map_snapshot": None,
-                    "classifier_state": 0,
-                    "classifier_chat": []
-                })
-                ss.active_site_index = len(ss.site_descriptions)-1
-                st.sidebar.success(f"Site '{new_site_name}' added.")
-                st.experimental_rerun()
-        else:
-            st.sidebar.error("Enter a site name first.")
-
-    # Select active site
-    if ss.site_descriptions:
-        site_names = [s.get("Site Name", f"Site-{i+1}") for i,s in enumerate(ss.site_descriptions)]
-        chosen = st.sidebar.selectbox("Active Site", site_names, index=min(ss.active_site_index, len(site_names)-1))
-        ss.active_site_index = site_names.index(chosen)
-    else:
-        st.sidebar.info("No sites yet. Add a site above.")
-
-    st.sidebar.markdown("---")
-    # Manage sites
-    st.sidebar.markdown("### Project Sites")
-    colA, colB = st.sidebar.columns([3,1])
-    new_site_name = colA.text_input("New site name", key="new_site_name_input")
-    if colB.button("➕", help="Add new site"):
-        if new_site_name:
-            if len(ss.site_descriptions) >= MAX_SITES:
-                st.sidebar.error(f"Maximum {MAX_SITES} sites allowed.")
-            else:
-                ss.site_descriptions.append({
-                    "Site Name": new_site_name,
-                    "Site Coordinates": "",
-                    "lat": None,
-                    "lon": None,
-                    "Load Bearing Capacity": None,
-                    "Skin Shear Strength": None,
-                    "Relative Compaction": None,
-                    "Rate of Consolidation": None,
-                    "Nature of Construction": None,
-                    "Soil Profile": None,
-                    "Flood Data": None,
-                    "Seismic Data": None,
-                    "GSD": None,
-                    "USCS": None,
-                    "AASHTO": None,
-                    "GI": None,
-                    "classifier_inputs": {},
-                    "classifier_decision_path": "",
-                    "chat_history": [],
-                    "report_convo_state": 0,
-                    "map_snapshot": None,
-                    "classifier_state": 0,
-                    "classifier_chat": []
-                })
-                ss.active_site_index = len(ss.site_descriptions)-1
-                st.sidebar.success(f"Site '{new_site_name}' added.")
-                st.rerun()
-        else:
-            st.sidebar.error("Enter a site name first.")
-
-    # Select active site
-    if ss.site_descriptions:
-        site_names = [s.get("Site Name", f"Site-{i+1}") for i,s in enumerate(ss.site_descriptions)]
-        chosen = st.sidebar.selectbox("Active Site", site_names, index=min(ss.active_site_index, len(site_names)-1))
-        ss.active_site_index = site_names.index(chosen)
-    else:
-        st.sidebar.info("No sites yet. Add a site above.")
-
-    st.sidebar.markdown("---")
-    if st.sidebar.button("🔄 Reset Session (clear data)", help="Clears session data (not code)", key="reset_session"):
-        # careful clearing
-        ss.site_descriptions = []
-        ss.active_site_index = 0
-        ss.global_chat_history = []
-        st.rerun()
-
-    # Show JSON of active site in expander
-    st.sidebar.markdown("---")
-    with st.sidebar.expander("Active Site JSON (live)"):
-        if ss.site_descriptions:
-            idx, site = active_site()
-            st.json(site)
-        else:
-            st.write("No site configured.")
-
-# ---------- Soil Classifier Page (chatbot style, stepwise) ----------
-# The UI collects inputs step-by-step and stores them in site['classifier_inputs'].
-# User can type numeric values in text fields (no spinners), or use OCR to auto-fill.
-
-CLASSIFIER_QUESTIONS = [
-    "Is the soil organic (contains high organic matter, feels spongy or odour)? (Yes/No)",
-    "What is the percentage passing the #200 sieve (0.075 mm)? (e.g. 12)",
-    "What is the percentage passing the sieve no. 4 (4.75 mm)? (e.g. 19)",
-    "Do you know the D60, D30, and D10 diameters in mm? (Yes/No)",
-    "Enter D60 (mm) (diameter corresponding to 60% passing), or leave blank if unknown.",
-    "Enter D30 (mm) (diameter corresponding to 30% passing), or leave blank if unknown.",
-    "Enter D10 (mm) (diameter corresponding to 10% passing), or leave blank if unknown.",
-    "What is the Liquid Limit (LL)?",
-    "What is the Plastic Limit (PL)?",
-    "Select observed Dry Strength (see dropdown)",
-    "Select observed Dilatancy (see dropdown)",
-    "Select observed Toughness (see dropdown)",
-    "Would you like to perform classification now? (Yes/No)"
-]
-
-# dropdown mapping per your requested text labels
-DRY_STRENGTH_OPTIONS = [
-    "1. None - slight",
-    "2. Medium - high",
-    "3. Slight - Medium",
-    "4. High - Very high",
-    "5. Null?"
-]
-DILATANCY_OPTIONS = [
-    "1. Quick to slow",
-    "2. None to very slow",
-    "3. Slow",
-    "4. Slow to none",
-    "5. None",
-    "6. Null?"
-]
-TOUGHNESS_OPTIONS = [
-    "1. None",
-    "2. Medium",
-    "3. Slight?",
-    "4. Slight to Medium?",
-    "5. High",
-    "6. Null?"
-]
-
-def soil_classifier_page():
-    st.markdown("## 📊 Soil Classifier (chatbot style)")
-    # tabs: Manual, OCR, Results
-    tab1, tab2, tab3 = st.tabs(["✍️ Manual Input", "📷 OCR Input", "📑 Results & Export"])
-    idx, site = active_site()
-
-    # ensure classifier_inputs exists
-    if "classifier_inputs" not in site:
-        site["classifier_inputs"] = {}
-
-    # state index for classifier conversation
-    if "classifier_state" not in site:
-        site["classifier_state"] = 0
-
-    with tab1:
-        st.markdown("<div class='chat-bot'>🤖 GeoMate: Hello — I'll guide you step-by-step through soil classification.</div>", unsafe_allow_html=True)
-        # Stepwise inputs presented in order, but keep all visible for convenience.
-        # Use text_input for numbers (prevents steppers).
-        c = site["classifier_inputs"]
-
-        # Organic?
-        opt = st.radio("Is the soil organic (contains high organic matter, feels spongy or odour)?", ["No", "Yes"], index=0 if c.get("opt","n")=="n" else 1)
-        c["opt"] = "y" if opt == "Yes" else "n"
-
-        # % passing #200
-        p2 = st.text_input("Percentage passing the #200 sieve (0.075 mm) — enter numeric value:", value=str(c.get("P2","")) )
-        try:
-            c["P2"] = float(p2) if p2.strip()!="" else 0.0
-        except:
-            st.error("P2 must be a number.")
-        # % passing #4
-        p4 = st.text_input("Percentage passing the sieve no. 4 (4.75 mm) — enter numeric value:", value=str(c.get("P4","")) )
-        try:
-            c["P4"] = float(p4) if p4.strip()!="" else 0.0
-        except:
-            st.error("P4 must be a number.")
-
-        # D values
-        know_d = st.radio("Do you know D60/D30/D10 values? ", ["No", "Yes"], index=1 if c.get("D10",0)>0 else 0)
-        if know_d == "Yes":
-            d60 = st.text_input("D60 (mm):", value=str(c.get("D60","")))
-            d30 = st.text_input("D30 (mm):", value=str(c.get("D30","")))
-            d10 = st.text_input("D10 (mm):", value=str(c.get("D10","")))
-            try:
-                c["D60"] = float(d60) if d60.strip()!="" else 0.0
-                c["D30"] = float(d30) if d30.strip()!="" else 0.0
-                c["D10"] = float(d10) if d10.strip()!="" else 0.0
-            except:
-                st.error("D-values must be numeric.")
-        else:
-            c["D60"] = float(c.get("D60",0.0))
-            c["D30"] = float(c.get("D30",0.0))
-            c["D10"] = float(c.get("D10",0.0))
-
-        # LL and PL
-        ll = st.text_input("Liquid Limit (LL):", value=str(c.get("LL","")))
-        pl = st.text_input("Plastic Limit (PL):", value=str(c.get("PL","")))
-        try:
-            c["LL"] = float(ll) if ll.strip()!="" else 0.0
-            c["PL"] = float(pl) if pl.strip()!="" else 0.0
-        except:
-            st.error("LL/PL must be numeric.")
-
-        # fine soil descriptors (dropdowns) - map textual choices to numeric indices for logic
-        ds_choice = st.selectbox("Dry Strength (select one):", DRY_STRENGTH_OPTIONS, index=DRY_STRENGTH_OPTIONS.index(c.get("nDS_text",DRY_STRENGTH_OPTIONS[2])) if c.get("nDS_text") in DRY_STRENGTH_OPTIONS else 2)
-        dil_choice = st.selectbox("Dilatancy:", DILATANCY_OPTIONS, index=DILATANCY_OPTIONS.index(c.get("nDIL_text",DILATANCY_OPTIONS[0])) if c.get("nDIL_text") in DILATANCY_OPTIONS else 0)
-        tg_choice = st.selectbox("Toughness:", TOUGHNESS_OPTIONS, index=TOUGHNESS_OPTIONS.index(c.get("nTG_text",TOUGHNESS_OPTIONS[0])) if c.get("nTG_text") in TOUGHNESS_OPTIONS else 0)
-        # save text+index mapping
-        c["nDS_text"] = ds_choice
-        c["nDIL_text"] = dil_choice
-        c["nTG_text"] = tg_choice
-        # mapping from your requested textual options to numeric index used in classification logic
-        dry_map = {DRY_STRENGTH_OPTIONS[i]: i+1 for i in range(len(DRY_STRENGTH_OPTIONS))}
-        dil_map = {DILATANCY_OPTIONS[i]: i+1 for i in range(len(DILATANCY_OPTIONS))}
-        tough_map = {TOUGHNESS_OPTIONS[i]: i+1 for i in range(len(TOUGHNESS_OPTIONS))}
-        c["nDS"] = dry_map.get(ds_choice, 6)
-        c["nDIL"] = dil_map.get(dil_choice, 6)
-        c["nTG"] = tough_map.get(tg_choice, 6)
-
-        # Save classifier inputs back
-        site["classifier_inputs"] = c
-
-        if st.button("🔍 Classify Soil (USCS & AASHTO)"):
-            # Run classifier
-            res_text, uscs_sym, aashto_sym, GI, char_summary = uscs_aashto_verbatim(site["classifier_inputs"])
-            site["USCS"] = uscs_sym
-            site["AASHTO"] = aashto_sym
-            site["GI"] = GI
-            site["classifier_decision_path"] = res_text
-            # append to classifier chat
-            site.setdefault("classifier_chat", []).append({"time": now_str(), "bot": "Classification completed.", "user_inputs": site["classifier_inputs"]})
-            st.success("Classification complete. Results saved to site.")
-            st.write(res_text)
-            # show characteristics
-            st.write("Engineering characteristics summary:")
-            for k,v in char_summary.items():
-                st.write(f"- **{k}**: {v}")
-
-    with tab2:
-        st.markdown("### OCR Input")
-        st.info("Upload a photo (textbook or lab sheet). OCR will try to extract P2, P4, D10/30/60, LL, PL.")
-        uploaded = st.file_uploader("Upload image (jpg/png)", type=["jpg","jpeg","png"])
-        if uploaded:
-            img_bytes = uploaded.read()
-            st.image(img_bytes, use_column_width=True)
-            if not HAVE_EASYOCR or ocr_reader is None:
-                st.warning("EasyOCR not available on this environment. OCR will not run.")
-            else:
-                with st.spinner("Running OCR..."):
-                    text = run_ocr_on_image_bytes(img_bytes)
-                st.text_area("Extracted text (preview)", value=text, height=200)
-                parsed = parse_numbers_from_text(text)
-                st.write("Parsed numeric values:", parsed)
-                if st.button("Use parsed values to prefill classifier inputs"):
-                    # merge into classifier inputs
-                    for k,v in parsed.items():
-                        site["classifier_inputs"][k] = v
-                    st.success("Parsed values saved to classifier inputs. Go to Manual Input tab to review & classify.")
-
-    with tab3:
-        st.markdown("### Results & Export")
-        if site.get("USCS") or site.get("AASHTO"):
-            st.markdown(f"**USCS:** {site.get('USCS')}  \n**AASHTO:** {site.get('AASHTO')}  \n**Group Index (GI):** {site.get('GI')}")
-            st.markdown("**Decision Path / Notes:**")
-            st.write(site.get("classifier_decision_path", "Not available."))
-            if st.button("📑 Export classification report (PDF)"):
-                fname = export_classification_report_pdf(idx)
-                with open(fname, "rb") as f:
-                    st.download_button("⬇️ Download PDF", data=f, file_name=fname, mime="application/pdf")
-        else:
-            st.info("No classification result yet. Use Manual Input or OCR to provide inputs, then click Classify.")
-
-# ---------- Export classification PDF ----------
-def export_classification_report_pdf(site_idx: int) -> str:
-    site = ss.site_descriptions[site_idx]
-    fname = f"classification_{site.get('Site Name','site')}.pdf"
-    if not HAVE_REPORTLAB:
-        # create a very simple fallback using bytes
-        content = f"Classification Report for {site.get('Site Name')}\nUSCS: {site.get('USCS')}\nAASHTO: {site.get('AASHTO')}\nGI: {site.get('GI')}\n"
-        with open(fname, "w") as f:
-            f.write(content)
-        return fname
-
-    # Use reportlab to make a nice PDF
-    doc = SimpleDocTemplate(fname, pagesize=A4,
-                            leftMargin=22*10, rightMargin=22*10, topMargin=28*10, bottomMargin=22*10)
-    styles = getSampleStyleSheet()
-    title = ParagraphStyle("title", parent=styles["Title"], fontSize=18, textColor=colors.HexColor("#FF7A00"), alignment=1)
-    body = ParagraphStyle("body", parent=styles["BodyText"], fontSize=11, leading=14)
-    elems = []
-    elems.append(Paragraph("GeoMate — Soil Classification Report", title))
-    elems.append(Spacer(1,12))
-    elems.append(Paragraph(f"Site: {site.get('Site Name')}", body))
-    elems.append(Spacer(1,8))
-    # Inputs table
-    inputs = site.get("classifier_inputs", {})
-    rows = [["Parameter", "Value"]]
-    for k in ["opt","P2","P4","D60","D30","D10","LL","PL","nDS_text","nDIL_text","nTG_text"]:
-        rows.append([str(k), str(inputs.get(k, ""))])
-    t = Table(rows, colWidths=[150,300])
-    t.setStyle(TableStyle([("GRID",(0,0),(-1,-1),0.5,colors.grey),("BACKGROUND",(0,0),(-1,0),colors.HexColor("#1F4E79")),("TEXTCOLOR",(0,0),(-1,0),colors.white)]))
-    elems.append(t); elems.append(Spacer(1,12))
-    # Results
-    elems.append(Paragraph(f"USCS: {site.get('USCS')}", body))
-    elems.append(Paragraph(f"AASHTO: {site.get('AASHTO')}", body))
-    elems.append(Paragraph(f"Group Index (GI): {site.get('GI')}", body))
-    elems.append(Spacer(1,8))
-    elems.append(Paragraph("Decision path / notes:", body))
-    elems.append(Paragraph(site.get("classifier_decision_path","Not available"), body))
-    doc.build(elems)
-    return fname
-
-# ---------- Locator Page ----------
-def locator_page():
-    st.markdown("## 🌍 Locator — Mark AOI & fetch data")
-    idx, site = active_site()
-    st.markdown("This page helps you mark a location or polygon for the active site.\nIf Earth Engine is available it will be used; otherwise a fallback map is shown.")
-    # allow user to input lat/lon or draw on a map
-    lat = st.text_input("Latitude", value=str(site.get("lat","") or ""))
-    lon = st.text_input("Longitude", value=str(site.get("lon","") or ""))
-    try:
-        site["lat"] = float(lat) if lat.strip()!="" else None
-        site["lon"] = float(lon) if lon.strip()!="" else None
-    except:
-        st.error("Lat/Lon must be numeric or blank.")
-
-    # Try Earth Engine map if available & secrets present
-    if HAVE_EE and ss.secrets_status.get("ee_ok", False):
-        # initialize EE if not already
-        try:
-            ee.Initialize()
-            st.success("Earth Engine initialized.")
-            # show a simple map centered on site coords
-            center = [site.get("lat") or 0.0, site.get("lon") or 0.0]
-            m = geemap.Map(center=center, zoom=8)
-            st.markdown("Use the map to navigate. (Geemap/EE is enabled)")
-            m.to_streamlit(height=500)
-        except Exception as e:
-            st.error(f"Earth Engine map failed: {e}")
-            # fallback to folium
-            _show_folium_map(site)
-    else:
-        # folium fallback
-        _show_folium_map(site)
-
-    # After user picks/enters AOI, allow fetch data (placeholder)
-    if st.button("Fetch site data (soil profile, flood, seismic)"):
-        # In real app: call Earth Engine functions
-        # For now produce placeholders and save into site
-        site["Soil Profile"] = "Placeholder soil profile fetched for location."
-        site["Flood Data"] = "Placeholder: No major flood history in past 20 years (simulated)."
-        site["Seismic Data"] = "Placeholder: Seismic history fetched (20-year simulated)."
-        st.success("Data fetched and saved into site record.")
-
-def _show_folium_map(site):
-    if not HAVE_FOLIUM:
-        st.info("Map unavailable (folium not installed). Please add folium & streamlit-folium to requirements.")
-        return
-    # show a map with a draw control where user can draw polygon
-    lat0 = site.get("lat") or 0.0
-    lon0 = site.get("lon") or 0.0
-    m = folium.Map(location=[lat0, lon0], zoom_start=6, tiles="OpenStreetMap")
-    # Add marker for current point if present
-    if site.get("lat") and site.get("lon"):
-        folium.Marker(location=[site.get("lat"), site.get("lon")], tooltip="Site location").add_to(m)
-    # Add draw plugin
-    try:
-        from folium.plugins import Draw
-        Draw(export=True).add_to(m)
-    except Exception:
-        pass
-    st.write("You can draw a polygon with the draw tool, then click Export to copy the GeoJSON and paste into the textbox below.")
-    st_data = st_folium(m, height=450)
-    geojson_text = st.text_area("Or paste GeoJSON polygon here (optional):", value=site.get("Site Coordinates") or "", height=120)
-    if geojson_text and st.button("Save site boundary / coordinates"):
-        site["Site Coordinates"] = geojson_text
-        st.success("Saved site geometry.")
-
-# ---------- GeoMate Ask (RAG) Page ----------
-def rag_page():
-    st.markdown("## 🤖 GeoMate Ask — Technical Chatbot (RAG placeholder)")
-    idx, site = active_site()
-    st.markdown("Site-specific chat memory is preserved for this session. The RAG is a placeholder that will call your chosen LLM if GROQ key is set.")
-    if not ss.secrets_status.get("groq_ok", False):
-        st.info("GROQ key missing: RAG responses will be simulated locally. Set GROQ_API_KEY to enable full LLM features.")
-    # display chat history for site
-    history = site.get("chat_history", [])
-    for msg in history[-50:]:
-        if msg.get("role") == "bot":
-            st.markdown(f"<div class='chat-bot'>🤖 GeoMate: {msg.get('text')}</div>", unsafe_allow_html=True)
-        else:
-            st.markdown(f"<div class='chat-user'>👤 {msg.get('text')}</div>", unsafe_allow_html=True)
-    # chat input
-    user_msg = st.text_input("Ask GeoMate about this site (technical):", key=f"rag_input_{idx}")
-    col1, col2 = st.columns([1,3])
-    with col1:
-        if st.button("Send"):
-            if user_msg.strip()=="":
-                st.warning("Enter a message.")
-            else:
-                # append user msg
-                site.setdefault("chat_history", []).append({"time": now_str(), "role": "user", "text": user_msg})
-                # simple simulated bot response or call Groq if available
-                bot_reply = simulated_rag_reply(user_msg, site)
-                site.setdefault("chat_history", []).append({"time": now_str(), "role": "bot", "text": bot_reply})
-                st.experimental_rerun()
-    st.markdown("---")
-    st.markdown("Tip: If you tell GeoMate a numerical value (e.g. 'bearing capacity is 2500 kPa'), it will try to auto-save that into site record.")
-    if st.button("Extract parameters from chat history (auto)"):
-        update_site_description_from_chat(site)
-        st.success("Attempted to extract parameters from chat history into site record.")
-
-def simulated_rag_reply(question: str, site: dict) -> str:
-    """A simple simulated reply or placeholder for calling the LLM API."""
-    # If GROQ available, you would call the LLM here. For now return a helpful canned reply.
-    if ss.secrets_status.get("groq_ok", False) and HAVE_GROQ:
-        try:
-            client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
-            # Build a compact prompt (left as placeholder)
-            prompt = f"Site JSON: {json.dumps(site)}\nUser question: {question}\nAnswer succinctly in a professional tone."
-            resp = client.chat.completions.create(model=ss.llm_model, messages=[{"role":"system","content":"You are GeoMate AI."},{"role":"user","content":prompt}], temperature=0.2)
-            return resp.choices[0].message.content
-        except Exception as e:
-            return f"(LLM call failed) Simulated reply: I understood your question: '{question}'"
-    # local simulated behavior:
-    if "bearing" in question.lower() or "bearing capacity" in question.lower():
-        return "Based on the site data present, a preliminary allowable bearing capacity could be assumed as 200-250 kPa. For a reliable value, perform plate load or SPT correlations."
-    if "gcd" in question.lower():
-        return "Not sure what 'gcd' refers to — please clarify."
-    return "Thanks — I saved your query. For detailed calculations, enable LLM or provide more site inputs."
-
-def update_site_description_from_chat(site: dict):
-    """Scan the recent chat history for numeric engineering parameters and save them into the site dict.
-    This is a heuristic extractor, not a full NER model.
-    """
-    text = " ".join([m.get("text","") for m in site.get("chat_history", [])[-40:]])
-    # patterns
-    # bearing capacity
-    m = re.search(r"(bearing\s*capacity|allowable)\s*(is|=|:)?\s*([0-9]+(?:\.[0-9]+)?)\s*(kpa|kN/m2|kn/m2|psf)?", text, flags=re.I)
-    if m:
-        val = float(m.group(3))
-        site["Load Bearing Capacity"] = f"{val} {m.group(4) or ''}".strip()
-    # skin shear strength
-    m2 = re.search(r"(skin\s*shear\s*strength)\s*(is|=|:)?\s*([0-9]+(?:\.[0-9]+)?)\s*(kpa|kn/m2|psf)?", text, flags=re.I)
-    if m2:
-        site["Skin Shear Strength"] = f"{float(m2.group(3))} {m2.group(4) or ''}".strip()
-    # relative compaction
-    m3 = re.search(r"(relative\s*compaction)\s*(is|=|:)?\s*([0-9]{1,3})\s*%?", text, flags=re.I)
-    if m3:
-        site["Relative Compaction"] = f"{m3.group(3)}%"
-    # Rate of consolidation (text)
-    m4 = re.search(r"(rate of consolidation)\s*(is|=|:)?\s*([a-zA-Z0-9\s\-]+)", text, flags=re.I)
-    if m4:
-        site["Rate of Consolidation"] = m4.group(3).strip()
-    return
-
-# ---------- Reports Page (chatbot collects missing params then generate PDF) ----------
-# Full parameter bank - all parameters you asked for (a representative comprehensive set)
-FULL_PARAM_BANK = [
-    # Project & site
-    ("Project Description", "text"),
-    ("Site Name", "text"),
-    ("Site Coordinates", "text"),
-    ("Site Area (ha)", "number"),
-    ("Topography", "text"),
-    ("Current Land Use", "text"),
-    ("Site History", "text"),
-    # Field investigation
-    ("Number of Boreholes", "number"),
-    ("Max Borehole Depth (m)", "number"),
-    ("SPT N-values (summary)", "text"),
-    ("Groundwater Depth (m)", "number"),
-    ("Refusal Depths", "text"),
-    # Lab tests
-    ("Liquid Limit (LL)", "number"),
-    ("Plastic Limit (PL)", "number"),
-    ("Plasticity Index (PI)", "number"),
-    ("GSD (D10,D30,D60)", "text"),
-    ("MDD (kg/m3)", "number"),
-    ("OMC (%)", "number"),
-    ("CBR (%)", "number"),
-    ("UCS (kPa)", "number"),
-    ("Triaxial results", "text"),
-    ("Consolidation parameters", "text"),
-    ("Swell (%)", "number"),
-    # Design
-    ("Load Bearing Capacity", "text"),
-    ("Skin Shear Strength", "text"),
-    ("Relative Compaction (%)", "number"),
-    ("Rate of Consolidation", "text"),
-    ("Nature of Construction", "text"),
-    # Environmental & hazards
-    ("Flood history (20 yr)", "text"),
-    ("Seismic history (20 yr)", "text"),
-    ("Soil contamination indicators", "text"),
-    ("Environmental concerns", "text"),
-    # Others
-    ("Recommended foundation type", "text"),
-    ("Pavement subgrade classification", "text"),
-    ("Notes/Conclusions", "text")
-]
-
-# Basic param subset (10-15)
-BASIC_PARAM_LIST = [
-    "Site Name","Site Coordinates","Liquid Limit (LL)","Plastic Limit (PL)","GSD (D10,D30,D60)",
-    "Load Bearing Capacity","Skin Shear Strength","Relative Compaction (%)","Groundwater Depth (m)","Nature of Construction"
-]
-
-def reports_page():
-    st.markdown("## 📑 Reports — Basic & Detailed")
-    idx, site = active_site()
-    st.markdown("Choose Basic (10-15 parameters) or Detailed (all parameters) report workflows.")
-    rep_type = st.radio("Report type", ["Basic (10-15 params)","Detailed (full)"])
-    if rep_type.startswith("Basic"):
-        param_list = BASIC_PARAM_LIST
-    else:
-        param_list = [p[0] for p in FULL_PARAM_BANK]
-
-    st.markdown("### Chatbot to collect missing parameters (you can Skip any question)")
-    # Build per-site report convo state index
-    if "report_convo_state" not in site:
-        site["report_convo_state"] = 0
-    # Build a simple queue of params to ask (only missing ones)
-    missing = [p for p in param_list if not site.get(p)]
-    st.write(f"Missing parameters to collect: {len(missing)}")
-    # show conversation history
-    if "report_chat" not in site:
-        site["report_chat"] = []
-    for msg in site.get("report_chat", []):
-        if msg["role"]=="bot":
-            st.markdown(f"<div class='chat-bot'>{msg['text']}</div>", unsafe_allow_html=True)
-        else:
-            st.markdown(f"<div class='chat-user'>{msg['text']}</div>", unsafe_allow_html=True)
-
-    # If no missing, show generate button
-    if not missing:
-        st.success("All required parameters collected for selected report type.")
-        if st.button("📥 Generate PDF Report"):
-            # call PDF generator
-            fname = build_full_report_pdf(idx, report_type=rep_type.split()[0].lower())
-            with open(fname, "rb") as f:
-                st.download_button("⬇️ Download Report PDF", f, file_name=fname, mime="application/pdf")
-        # compare sites option if more than 1 site present
-        if len(ss.site_descriptions) > 1:
-            if st.checkbox("Enable site comparison (for sites with same Nature of Construction)"):
-                # select sites to compare
-                choices = [s.get("Site Name") for s in ss.site_descriptions]
-                sel = st.multiselect("Select sites to compare", choices, default=choices)
-                if len(sel)>=2:
-                    compare_sites(sel)
-        return
-
-    # Ask next missing parameter in conversational style
-    next_param = missing[0]
-    # Bot question style
-    q_text = f"For the active site, please provide the value for **{next_param}**. (You may enter 'skip' to leave it blank.)"
-    st.markdown(f"<div class='chat-bot'>{q_text}</div>", unsafe_allow_html=True)
-    user_ans = st.text_input(f"Answer for {next_param} (or 'skip')", key=f"report_input_{idx}_{site.get('report_convo_state',0)}")
-    col1, col2 = st.columns([1,1])
-    with col1:
-        if st.button("➤ Submit answer"):
-            if user_ans.strip().lower() in ["skip","n","no","don't know","dont know","unknown",""]:
-                site[next_param] = None
-                site.setdefault("report_chat", []).append({"role":"user","text":"skip"})
-                site.setdefault("report_chat", []).append({"role":"bot","text":f"Okay — skipped {next_param}."})
-            else:
-                site[next_param] = user_ans.strip()
-                site.setdefault("report_chat", []).append({"role":"user","text":user_ans.strip()})
-                site.setdefault("report_chat", []).append({"role":"bot","text":f"Saved {next_param}."})
-            # move to next
-            site["report_convo_state"] += 1
-            st.rerun()
-    with col2:
-        if st.button("Skip this"):
-            site[next_param] = None
-            site.setdefault("report_chat", []).append({"role":"user","text":"skip"})
-            site.setdefault("report_chat", []).append({"role":"bot","text":f"Okay — skipped {next_param}."})
-            site["report_convo_state"] += 1
-            st.rerun()
-
-def compare_sites(site_names: List[str]):
-    st.markdown("### Site Comparison")
-    # gather selected site dicts
-    selected = [s for s in ss.site_descriptions if s.get("Site Name") in site_names]
-    # check nature of construction equality
-    natures = set(s.get("Nature of Construction") for s in selected)
-    if len(natures) == 1:
-        st.success("All selected sites share the same Nature of Construction — comparative analysis feasible.")
-    else:
-        st.warning("Sites have different Nature of Construction — comparisons might be limited.")
-    # show a comparison table for key parameters
-    keys = ["Site Name","Load Bearing Capacity","USCS","AASHTO","GI","CBR (%)","Relative Compaction","Groundwater Depth (m)"]
-    data = [keys]
-    for s in selected:
-        row = [s.get(k,"-") for k in keys]
-        data.append(row)
-    # display as table
-    st.table(data)
-
-# ---------- Full report PDF builder ----------
-def build_full_report_pdf(site_idx: int, report_type: str="basic") -> str:
-    site = ss.site_descriptions[site_idx]
-    stamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-    fname = f"geomate_report_{site.get('Site Name','site')}_{report_type}_{stamp}.pdf"
-    if not HAVE_REPORTLAB:
-        # fallback text file
-        with open(fname, "w") as f:
-            f.write(f"GeoMate {report_type.title()} Report for {site.get('Site Name')}\nGenerated: {now_str()}\n\nSite Data:\n")
-            for k,v in site.items():
-                f.write(f"{k}: {v}\n")
-        return fname
-
-    doc = SimpleDocTemplate(fname, pagesize=A4,
-                            leftMargin=22, rightMargin=22, topMargin=28, bottomMargin=22)
-    styles = getSampleStyleSheet()
-    title_style = ParagraphStyle("Title", parent=styles["Title"], fontSize=18, alignment=1, textColor=colors.HexColor("#FF7A00"))
-    h2 = ParagraphStyle("h2", parent=styles["Heading2"], textColor=colors.HexColor("#0f62fe"))
-    body = ParagraphStyle("body", parent=styles["BodyText"], fontSize=11, leading=14)
-
-    elems = []
-    elems.append(Paragraph("GEOTECHNICAL INVESTIGATION REPORT", title_style))
-    elems.append(Spacer(1,8))
-    # project & site info
-    elems.append(Paragraph("Project & Site Information", h2))
-    info = [
-        ["Site Name", site.get("Site Name","-")],
-        ["Coordinates", site.get("Site Coordinates","-")],
-        ["Nature of Construction", site.get("Nature of Construction","-")],
-        ["Date Generated", now_str()]
-    ]
-    t = Table(info, colWidths=[140,350])
-    t.setStyle(TableStyle([("GRID",(0,0),(-1,-1),0.3,colors.grey),("BACKGROUND",(0,0),(0,-1),colors.whitesmoke)]))
-    elems.append(t)
-    elems.append(Spacer(1,8))
-
-    # classification summary
-    elems.append(Paragraph("Classification Summary", h2))
-    elems.append(Paragraph(f"USCS: {site.get('USCS','-')}", body))
-    elems.append(Paragraph(f"AASHTO: {site.get('AASHTO','-')} (GI: {site.get('GI','-')})", body))
-    elems.append(Spacer(1,8))
-
-    # field & lab summary (from site keys)
-    elems.append(Paragraph("Field & Laboratory Summary", h2))
-    lab_rows = []
-    # choose a set of keys to show
-    keys = ["Liquid Limit (LL)","Plastic Limit (PL)","GSD (D10,D30,D60)","MDD (kg/m3)","OMC (%)","CBR (%)","UCS (kPa)","Consolidation parameters"]
-    for k in keys:
-        lab_rows.append([k, site.get(k,"-")])
-    t2 = Table(lab_rows, colWidths=[200,290])
-    t2.setStyle(TableStyle([("GRID",(0,0),(-1,-1),0.3,colors.grey)]))
-    elems.append(t2)
-
-    elems.append(Spacer(1,12))
-    # recommendations stub (could call LLM for detailed text)
-    elems.append(Paragraph("Recommendations", h2))
-    rec_text = site.get("Notes/Conclusions") or "Based on provided data and classification, GeoMate recommends design by a geotechnical professional; consider shallow foundations where suitable, and further testing where required."
-    elems.append(Paragraph(rec_text, body))
-    elems.append(Spacer(1,12))
-
-    # Append map snapshot if provided
-    if site.get("map_snapshot"):
-        try:
-            elems.append(Paragraph("Site Map Snapshot", h2))
-            elems.append(Image(site.get("map_snapshot"), width=400, height=250))
-            elems.append(Spacer(1,8))
-        except Exception:
-            pass
-
-    # Append full site JSON as appendix
-    elems.append(PageBreak())
-    elems.append(Paragraph("Appendix: Full Site Data (JSON)", h2))
-    elems.append(Paragraph(json.dumps(site, indent=2), ParagraphStyle("mono", fontName="Courier", fontSize=8)))
-    doc.build(elems)
-    return fname
-
-# -------------------------
-# Main app layout & routing
-# -------------------------
-def main():
-    sidebar_ui()
-    page = st.sidebar.radio("Pages", ["Landing","Soil Classifier","Locator","GeoMate Ask","Reports"], index=0)
-    # show top bar with active model and site
-    st.markdown(f"<div style='display:flex;align-items:center;justify-content:space-between'>"
-                f"<div><small class='muted'>Model: {ss.llm_model} • Active site: {active_site()[1].get('Site Name')}</small></div>"
-                f"<div><small class='muted'>Session started: {ss.get('session_start', now_str())}</small></div></div>", unsafe_allow_html=True)
-
-    if page == "Landing":
-        landing_page()
-    elif page == "Soil Classifier":
-        soil_classifier_page()
-    elif page == "Locator":
-        locator_page()
-    elif page == "GeoMate Ask":
-        rag_page()
-    elif page == "Reports":
-        reports_page()
-    else:
-        landing_page()
-
-if __name__ == "__main__":
-    # initialize session start time
-    if "session_start" not in ss:
-        ss["session_start"] = now_str()
-    main()