Update app.py

app.py

@@ -871,3 +871,341 @@ def soil_classifier_ui():
         state["step"] = 0
         ss["classifier_states"][site_name] = state
 
+# -------------------------
+# Locator page (chat-style)
+# -------------------------
+def locator_ui():
+    st.header("🌍 Locator — define AOI (GeoJSON or coordinates)")
+    idx, sdict = active_site()
+    site_name = sdict["Site Name"]
+    st.markdown(f"**Active site:** {site_name}")
+    st.info("You can paste GeoJSON for your area of interest or enter a center point (lat, lon). The app will save the AOI to the active site and try to display a map.")
+
+    # Chat-like: ask for GeoJSON or coordinates
+    choice = st.radio("Provide:", ["GeoJSON (polygon)", "Coordinates (lat, lon)"], index=0, key=f"loc_choice_{site_name}")
+    if choice.startswith("GeoJSON"):
+        geo_text = st.text_area("Paste GeoJSON (Polygon or MultiPolygon)", value=sdict.get("map_snapshot") or "", key=f"geojson_area_{site_name}", height=180)
+        if st.button("Save AOI and show map", key=f"save_aoi_{site_name}"):
+            if not geo_text.strip():
+                st.error("No GeoJSON provided.")
+            else:
+                try:
+                    gj = json.loads(geo_text)
+                    sdict["map_snapshot"] = gj
+                    ss["site_descriptions"][idx] = sdict
+                    st.success("AOI saved.")
+                    # Try to display on simple map: compute centroid and show with st.map
+                    # Find centroid of polygon(s)
+                    def centroid_of_geojson(gj_obj):
+                        coords = []
+                        if gj_obj.get("type") == "FeatureCollection":
+                            for f in gj_obj.get("features", []):
+                                geom = f.get("geometry", {})
+                                coords.extend(_extract_coords_from_geom(geom))
+                        else:
+                            geom = gj_obj if "geometry" not in gj_obj else gj_obj["geometry"]
+                            coords.extend(_extract_coords_from_geom(geom))
+                        if not coords:
+                            return None
+                        arr = np.array(coords)
+                        return float(arr[:,1].mean()), float(arr[:,0].mean())
+                    def _extract_coords_from_geom(geom):
+                        if not geom:
+                            return []
+                        t = geom.get("type","")
+                        if t == "Polygon":
+                            return [tuple(pt) for pt in geom.get("coordinates", [])[0]]
+                        if t == "MultiPolygon":
+                            pts=[]
+                            for poly in geom.get("coordinates", []):
+                                pts.extend([tuple(pt) for pt in poly[0]])
+                            return pts
+                        if t == "Point":
+                            return [tuple(geom.get("coordinates",[]))]
+                        return []
+                    cent = centroid_of_geojson(gj)
+                    if cent:
+                        latc, lonc = cent
+                        sdict["lat"] = latc; sdict["lon"] = lonc
+                        ss["site_descriptions"][idx] = sdict
+                        st.map(pd.DataFrame({"lat":[latc],"lon":[lonc]}))
+                    else:
+                        st.info("Could not compute centroid for map preview, but AOI saved.")
+                except Exception as e:
+                    st.error(f"Invalid GeoJSON: {e}")
+    else:
+        # Coordinates mode
+        lat = st.number_input("Latitude", value=float(sdict.get("lat") or 0.0), key=f"loc_lat_{site_name}")
+        lon = st.number_input("Longitude", value=float(sdict.get("lon") or 0.0), key=f"loc_lon_{site_name}")
+        if st.button("Save coordinates and show map", key=f"save_coords_{site_name}"):
+            sdict["lat"] = float(lat); sdict["lon"] = float(lon)
+            ss["site_descriptions"][idx] = sdict
+            st.success("Coordinates saved.")
+            st.map(pd.DataFrame({"lat":[lat],"lon":[lon]}))
+
+    # If EE is available, offer to fetch raster/time series (placeholder)
+    st.markdown("---")
+    if EE_READY:
+        if st.button("Fetch Earth Engine data (soil profile / climate / flood / seismic) — experimental"):
+            st.info("Earth Engine available — fetching (placeholder).")
+            # Placeholder: real implementation would call ee.Dataset/time series and store results
+            try:
+                # example: add a placeholder soil profile
+                sdict["Soil Profile"] = "Placeholder Earth Engine soil profile data (EE initialized)."
+                sdict["Flood Data"] = "Placeholder flood history (20 years) from EE."
+                sdict["Seismic Data"] = "Placeholder seismic history (20 years) from EE."
+                ss["site_descriptions"][idx] = sdict
+                st.success("Earth Engine data fetched and saved to site (placeholder).")
+            except Exception as e:
+                st.error(f"EE fetch failed: {e}")
+    else:
+        st.info("Earth Engine not initialized in this runtime. To enable, set SERVICE_ACCOUNT and EARTH_ENGINE_KEY secrets and ensure earthengine-api is installed.")
+
+# -------------------------
+# GeoMate Ask (RAG chatbot) — simplified RAG integration
+# -------------------------
+def run_llm_completion(prompt: str, model: str = "llama3-8b-8192") -> str:
+    """Minimal LLM wrapper: uses Groq if available; else returns a dummy but structured answer."""
+    if GROQ_OK and GROQ_KEY:
+        try:
+            client = Groq(api_key=GROQ_KEY)
+            comp = client.chat.completions.create(model=model, messages=[{"role":"user", "content": prompt}], temperature=0.2, max_tokens=800)
+            return comp.choices[0].message.content
+        except Exception as e:
+            return f"(Groq error) {e}"
+    else:
+        # Dummy local response for demonstration
+        return f"(Dummy LLM) I received your prompt and would reply here. Model: {model}\n\nPrompt excerpt:\n{prompt[:400]}"
+
+def rag_ui():
+    st.header("🤖 GeoMate Ask — RAG Chatbot (per-site memory)")
+    idx, sdict = active_site()
+    site_name = sdict["Site Name"]
+    st.markdown(f"**Active site:** {site_name}")
+    # Prepare chat history per site
+    ss.setdefault("rag_memory", {})
+    chat = ss["rag_memory"].setdefault(site_name, [])
+    # Show chat
+    for turn in chat[-40:]:
+        role, text = turn.get("role"), turn.get("text")
+        if role == "user":
+            st.markdown(f"**You:** {text}")
+        else:
+            st.markdown(f"**GeoMate:** {text}")
+
+    # user input
+    user_prompt = st.text_input("Ask GeoMate (technical)", key=f"rag_input_{site_name}")
+    col1, col2 = st.columns([3,1])
+    if col1.button("Send", key=f"rag_send_{site_name}") and user_prompt.strip():
+        # append user
+        chat.append({"role":"user", "text":user_prompt, "ts": datetime.now().isoformat()})
+        ss["rag_memory"][site_name] = chat
+        # Build RAG prompt using stored site data + user prompt
+        context = {"site": sdict}
+        full_prompt = f"Site data (json):\n{json.dumps(context, indent=2)}\n\nUser question:\n{user_prompt}\nPlease answer technically."
+        # Run LLM
+        with st.spinner("Running LLM..."):
+            resp = run_llm_completion(full_prompt, model=ss.get("llm_model"))
+        # Append bot response
+        chat.append({"role":"assistant", "text":resp, "ts": datetime.now().isoformat()})
+        ss["rag_memory"][site_name] = chat
+        # Intelligent extraction: try to pick up numeric engineering fields (simple heuristics)
+        update_site_description_from_chat(resp, site_name)
+        safe_rerun()
+
+# small NLP-ish extractor placeholder
+def update_site_description_from_chat(text: str, site_name: str):
+    """Naive extraction: looks for keywords like 'bearing' and a numeric value followed by units."""
+    idx = None
+    for i, s in enumerate(ss["site_descriptions"]):
+        if s["Site Name"] == site_name:
+            idx = i; break
+    if idx is None:
+        return
+    # naive patterns
+    lowered = text.lower()
+    site = ss["site_descriptions"][idx]
+    # look for 'bearing' followed by number (psf, kpa)
+    import re
+    m = re.search(r"bearing.*?([0-9]{2,6})\s*(psf|kpa|kpa\.)?", lowered)
+    if m:
+        val = m.group(1)
+        site["Load Bearing Capacity"] = m.group(0)
+        ss["site_descriptions"][idx] = site
+
+# -------------------------
+# Reports page (two types)
+# -------------------------
+def build_classification_pdf_bytes(site_dict: dict) -> bytes:
+    """Return bytes of a classification-only PDF for a single site. Try ReportLab then FPDF fallback."""
+    text = site_dict.get("classifier_decision_path") or "No classification decision path available."
+    inputs = site_dict.get("classifier_inputs", {})
+    title = f"GeoMate Classification Report — {site_dict['Site Name']}"
+    # Try ReportLab
+    if REPORTLAB_OK:
+        buf = io.BytesIO()
+        doc = SimpleDocTemplate(buf, pagesize=A4)
+        styles = getSampleStyleSheet()
+        elems = []
+        elems.append(Paragraph(title, styles["Title"]))
+        elems.append(Spacer(1,6))
+        elems.append(Paragraph("Classification result and explanation:", styles["Heading2"]))
+        elems.append(Paragraph(text.replace("\n","<br/>"), styles["BodyText"]))
+        elems.append(Spacer(1,6))
+        elems.append(Paragraph("Inputs:", styles["Heading3"]))
+        for k,v in inputs.items():
+            elems.append(Paragraph(f"{k}: {v}", styles["BodyText"]))
+        doc.build(elems)
+        pdf_bytes = buf.getvalue(); buf.close()
+        return pdf_bytes
+    elif FPDF_OK:
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_font("Arial", "B", 14)
+        pdf.cell(0, 10, title, ln=1)
+        pdf.set_font("Arial", "", 11)
+        pdf.multi_cell(0, 6, text)
+        pdf.ln(4)
+        pdf.set_font("Arial", "B", 12)
+        pdf.cell(0,6,"Inputs:", ln=1)
+        pdf.set_font("Arial", "", 10)
+        for k,v in inputs.items():
+            pdf.cell(0,5,f"{k}: {v}", ln=1)
+        out = pdf.output(dest="S").encode("latin-1")
+        return out
+    else:
+        # fallback: simple text file disguised as pdf (not ideal)
+        return ("Classification:\n"+text+"\n\nInputs:\n"+json.dumps(inputs, indent=2)).encode("utf-8")
+
+def build_full_phase1_pdf_bytes(site_list: List[dict], ext_refs: List[str]) -> bytes:
+    """
+    Build full geotechnical report (Phase 1) combining site data, classifier results, GSD and maps (if any).
+    This is a streamlined generation: for production you would expand each analysis section.
+    """
+    title = "GeoMate — Full Geotechnical Investigation Report"
+    # Use ReportLab if available
+    if REPORTLAB_OK:
+        buf = io.BytesIO()
+        doc = SimpleDocTemplate(buf, pagesize=A4, leftMargin=20*mm, rightMargin=20*mm, topMargin=20*mm)
+        styles = getSampleStyleSheet()
+        elems = []
+        elems.append(Paragraph(title, styles["Title"]))
+        elems.append(Spacer(1,8))
+        elems.append(Paragraph(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}", styles["Normal"]))
+        elems.append(Spacer(1,12))
+        # Summary
+        elems.append(Paragraph("SUMMARY", styles["Heading2"]))
+        elems.append(Paragraph("This full geotechnical report was generated by GeoMate V2. The following pages contain site descriptions, classification results and recommendations.", styles["BodyText"]))
+        elems.append(PageBreak())
+        # For each site:
+        for s in site_list:
+            elems.append(Paragraph(f"SITE: {s.get('Site Name','Unnamed')}", styles["Heading1"]))
+            elems.append(Paragraph(f"Location: {s.get('Site Coordinates','Not provided')}", styles["BodyText"]))
+            elems.append(Spacer(1,6))
+            # classifier results
+            elems.append(Paragraph("Classification", styles["Heading2"]))
+            elems.append(Paragraph(s.get("classifier_decision_path","No classification available.").replace("\n","<br/>"), styles["BodyText"]))
+            elems.append(Spacer(1,6))
+            # GSD table
+            if s.get("GSD"):
+                elems.append(Paragraph("GSD Summary", styles["Heading2"]))
+                g = s["GSD"]
+                tdata = [["D10 (mm)", "D30 (mm)", "D60 (mm)", "Cu", "Cc"]]
+                tdata.append([str(g.get("D10")), str(g.get("D30")), str(g.get("D60")), str(g.get("Cu")), str(g.get("Cc"))])
+                t = Table(tdata, colWidths=[30*mm]*5)
+                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(PageBreak())
+        # Add external references
+        elems.append(Paragraph("External References", styles["Heading2"]))
+        for r in ext_refs:
+            elems.append(Paragraph(r, styles["BodyText"]))
+        doc.build(elems)
+        pdf_bytes = buf.getvalue(); buf.close()
+        return pdf_bytes
+    elif FPDF_OK:
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_font("Arial", "B", 16)
+        pdf.cell(0, 10, title, ln=1)
+        pdf.set_font("Arial", "", 11)
+        pdf.ln(4)
+        for s in site_list:
+            pdf.set_font("Arial", "B", 13)
+            pdf.cell(0, 8, f"Site: {s.get('Site Name','')}", ln=1)
+            pdf.set_font("Arial", "", 11)
+            pdf.multi_cell(0, 6, s.get("classifier_decision_path","No classification data."))
+            pdf.ln(4)
+            if s.get("GSD"):
+                g = s["GSD"]
+                pdf.cell(0, 6, f"GSD D10={g.get('D10')}, D30={g.get('D30')}, D60={g.get('D60')}", ln=1)
+            pdf.add_page()
+        out = pdf.output(dest="S").encode("latin-1")
+        return out
+    else:
+        # fallback text
+        parts = [title, "Generated: "+datetime.now().isoformat()]
+        for s in site_list:
+            parts.append("SITE: "+s.get("Site Name",""))
+            parts.append("Classification:\n"+(s.get("classifier_decision_path") or "No data"))
+            parts.append("GSD: "+(json.dumps(s.get("GSD") or {})))
+        parts.append("REFERENCES: "+json.dumps(ext_refs))
+        return ("\n\n".join(parts)).encode("utf-8")
+
+# Reports UI
+def reports_ui():
+    st.header("📑 Reports — Classification-only & Full Geotechnical Report")
+    idx, sdict = active_site()
+    st.subheader("Classification-only Report")
+    st.markdown("Generates a PDF containing the classification result and the decision path for the selected site.")
+    if st.button("Generate Classification PDF", key=f"gen_cls_pdf_{sdict['Site Name']}"):
+        pdf_bytes = build_classification_pdf_bytes(sdict)
+        st.download_button("Download Classification PDF", data=pdf_bytes, file_name=f"{sdict['Site Name']}_classification.pdf", mime="application/pdf")
+    st.markdown("---")
+    st.subheader("Full Geotechnical Report")
+    st.markdown("Chatbot will gather missing parameters and produce a full Phase 1 report for selected sites (up to 4).")
+    # multi-select sites
+    all_site_names = [s["Site Name"] for s in ss["site_descriptions"]]
+    chosen = st.multiselect("Select sites to include", options=all_site_names, default=all_site_names, key="report_sites_select")
+    ext_refs_text = st.text_area("External references (one per line)", key="ext_refs")
+    # If user wants to have the bot gather missing params, start convo
+    if st.button("Start conversational data gather for Full Report", key="start_report_convo"):
+        # We'll run a simple in-app conversational loop: for brevity, ask a set of required params per site
+        required_questions = [
+            ("Load Bearing Capacity", "What is the soil bearing capacity (e.g., 2000 psf or 'Don't know')?"),
+            ("Skin Shear Strength", "Provide skin shear strength (kPa) if known, else 'Don't know'"),
+            ("Relative Compaction", "Relative compaction (%)"),
+            ("Rate of Consolidation", "Rate of consolidation (e.g., cv in m2/year)"),
+            ("Nature of Construction", "Nature of construction (e.g., 2-storey residence)"),
+            ("Other", "Any other relevant notes or 'None'")
+        ]
+        # For each chosen site, ask interactively. We'll perform a sequential loop inside the app (chatbot-style rudimentary)
+        for site_name in chosen:
+            st.info(f"Collecting data for site: {site_name}")
+            # Retrieve site dict
+            site_idx = [i for i,s in enumerate(ss["site_descriptions"]) if s["Site Name"]==site_name][0]
+            site_obj = ss["site_descriptions"][site_idx]
+            for field, q in required_questions:
+                # If field exists and not None, skip confirmation ask
+                current_val = site_obj.get(field)
+                if current_val:
+                    st.write(f"{field} (existing): {current_val}")
+                    keep = st.radio(f"Keep existing {field} for {site_name}?", ["Keep","Replace"], key=f"keep_{site_name}_{field}")
+                    if keep == "Keep":
+                        continue
+                ans = st.text_input(q, key=f"report_q_{site_name}_{field}")
+                if ans.strip().lower() in ["don't know","dont know","skip","n","no","unknown",""]:
+                    site_obj[field] = None
+                else:
+                    site_obj[field] = ans.strip()
+                ss["site_descriptions"][site_idx] = site_obj
+            st.success(f"Data saved for {site_name}.")
+        st.info("Conversational gather complete. Use Generate Full Report PDF button to create the PDF.")
+
+    if st.button("Generate Full Report PDF", key="gen_full_pdf_btn"):
+        # collect selected site dicts
+        site_objs = [s for s in ss["site_descriptions"] if s["Site Name"] in chosen]
+        ext_refs = [r.strip() for r in ext_refs_text.splitlines() if r.strip()]
+        pdf_bytes = build_full_phase1_pdf_bytes(site_objs, ext_refs)
+        st.download_button("Download Full Geotechnical Report", data=pdf_bytes, file_name=f"GeoMate_Full_Report_{datetime.now().strftime('%Y%m%d')}.pdf", mime="application/pdf")
+