Update backend/app/main.py

backend/app/main.py

@@ -563,4 +563,269 @@ async def ocr_endpoint(file: UploadFile = File(...)):
         if m:
             parsed[key] = float(m.group(1))
     # % passing pattern
-    pct_matches = re.findall(r"([0-9]{1,3}\.?\
+    pct_matches = re.findall(r"([0-9]{1,3}\.?\d*)\s*%", text)
+    if pct_matches and "passing_sample" not in parsed:
+        # just attach the first few percentages for user to inspect
+        parsed["passing_percent_sample"] = pct_matches[:10]
+    return {"text": text, "parsed": parsed}
+
+
+@app.post("/api/locator")
+async def locator_endpoint(payload: Dict[str, Any]):
+    """
+    Accepts:
+      - { "lat": float, "lon": float } OR
+      - { "geojson": {...} }
+    Returns:
+      - topography (elevation)
+      - seismic events (USGS past 20 years within radius)
+      - basic flood indicator (based on precipitation trend via CHIRPS if EE enabled)
+      - NDVI / landcover sample (if EE enabled)
+    """
+    lat = payload.get("lat")
+    lon = payload.get("lon")
+    geojson = payload.get("geojson")
+    if not (lat and lon) and not geojson:
+        raise HTTPException(status_code=400, detail="Provide lat/lon or geojson.")
+
+    # get seismic data via USGS API (past 20 years)
+    try:
+        end = datetime.date.today()
+        start = end - datetime.timedelta(days=365*20)
+        usgs_url = "https://earthquake.usgs.gov/fdsnws/event/1/query"
+        params = {
+            "format": "geojson",
+            "starttime": start.isoformat(),
+            "endtime": end.isoformat(),
+            "latitude": lat,
+            "longitude": lon,
+            "maxradiuskm": 100  # 100 km radius; you can adjust
+        }
+        r = requests.get(usgs_url, params=params, timeout=30)
+        usgs = r.json()
+        events = usgs.get("features", [])
+        quake_count = len(events)
+        max_mag = max([ev["properties"].get("mag") or 0 for ev in events]) if events else 0
+    except Exception as e:
+        quake_count = None
+        max_mag = None
+
+    # Elevation via Earth Engine/SRTM if EE is ready
+    topo = None
+    ndvi_summary = None
+    flood_indicator = None
+    if EE_READY:
+        try:
+            point = ee.Geometry.Point([lon, lat])
+            srtm = ee.Image("USGS/SRTMGL1_003")
+            elev = srtm.sample(point, 30).first().get("elevation").getInfo()
+            topo = {"elevation_m": elev}
+            # For NDVI we sample MODIS or Sentinel
+            try:
+                collection = ee.ImageCollection("MODIS/006/MOD13A1").select("NDVI").filterDate((datetime.date.today()-datetime.timedelta(days=365)), datetime.date.today())
+                mean_ndvi = collection.mean().sample(point, 30).first().get("NDVI").getInfo()
+                ndvi_summary = {"mean_ndvi": mean_ndvi}
+            except Exception:
+                ndvi_summary = None
+            # flood estimation: use annual rainfall statistics from CHIRPS (example)
+            try:
+                chirps = ee.ImageCollection("UCSB-CHG/CHIRPS/DAILY").filterDate(start.isoformat(), end.isoformat())
+                annual_sum = chirps.reduce(ee.Reducer.sum())
+                sample = annual_sum.sample(point, 1000).first().get("precipitation_sum").getInfo()
+                flood_indicator = {"annual_precip_sum": sample}
+            except Exception:
+                flood_indicator = None
+        except Exception:
+            topo = None
+
+    return {
+        "seismic": {"count_last_20yrs": quake_count, "max_magnitude": max_mag},
+        "topography": topo,
+        "ndvi": ndvi_summary,
+        "flood_indicator": flood_indicator
+    }
+
+
+@app.post("/api/chat")
+async def chat_endpoint(payload: Dict[str, Any]):
+    """
+    Basic chat endpoint that forwards to Groq if available.
+    payload: { "site_id": str, "message": str, "history": [ {role, content}, ... ] }
+    """
+    message = payload.get("message", "")
+    site_id = payload.get("site_id")
+    history = payload.get("history", [])
+
+    # Save user message into site chat history if provided
+    if site_id and site_id in SITES:
+        SITES[site_id]["chat_history"].append({"role": "user", "text": message, "ts": datetime.datetime.utcnow().isoformat()})
+
+    # If groq configured
+    if groq_client:
+        try:
+            # format messages: system + history + user
+            messages = [{"role": "system", "content": "You are GeoMate, a friendly professional geotechnical engineer assistant."}]
+            for m in history:
+                messages.append({"role": m.get("role", "user"), "content": m.get("content", "")})
+            messages.append({"role": "user", "content": message})
+            completion = groq_client.chat.completions.create(
+                model="meta-llama/llama-4-maverick-17b-128e-instruct",
+                messages=messages,
+                temperature=0.2
+            )
+            reply = completion.choices[0].message.content
+        except Exception as e:
+            reply = f"[Groq error] {e}"
+    else:
+        # Fallback simple rule-based reply
+        reply = f"GeoMate (local fallback): Received your question: '{message[:200]}'. Groq is not configured on the server."
+
+    # Save assistant reply
+    if site_id and site_id in SITES:
+        SITES[site_id]["chat_history"].append({"role": "assistant", "text": reply, "ts": datetime.datetime.utcnow().isoformat()})
+        # attempt to auto-extract parameters from reply (placeholder)
+        # You can implement update_site_description_from_chat logic here
+    return {"reply": reply}
+
+
+# ----------------------------
+# PDF report generator
+# ----------------------------
+def _build_pdf_report_bytes(site: Dict[str, Any], include_classification_only: bool = False) -> bytes:
+    """
+    Build a professional PDF as bytes. Uses ReportLab.
+    If include_classification_only True -> generate classification-only report.
+    """
+    buf = io.BytesIO()
+    doc = SimpleDocTemplate(buf, pagesize=A4, leftMargin=18*mm, rightMargin=18*mm, topMargin=18*mm, bottomMargin=18*mm)
+    styles = getSampleStyleSheet()
+    elems = []
+
+    title_style = ParagraphStyle("title", parent=styles["Title"], fontSize=20, alignment=1, textColor=colors.HexColor("#FF7A00"))
+    h1 = ParagraphStyle("h1", parent=styles["Heading1"], fontSize=14, textColor=colors.HexColor("#1F4E79"))
+    body = ParagraphStyle("body", parent=styles["BodyText"], fontSize=10)
+
+    # Cover
+    elems.append(Paragraph("GEOTECHNICAL INVESTIGATION REPORT", title_style))
+    elems.append(Spacer(1, 6))
+    elems.append(Paragraph(f"Project: {site.get('Site Name', '—')}", body))
+    elems.append(Paragraph(f"Generated: {datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M UTC')}", body))
+    elems.append(Spacer(1, 8))
+
+    # Summary
+    elems.append(Paragraph("SUMMARY", h1))
+    summary_lines = [
+        f"Site name: {site.get('Site Name', '—')}",
+        f"Coordinates: {site.get('Site Coordinates', '')} (lat:{site.get('lat')}, lon:{site.get('lon')})",
+        f"Available data: Laboratory results: {len(site.get('laboratory_results', []))} samples",
+    ]
+    for ln in summary_lines:
+        elems.append(Paragraph(ln, body))
+    elems.append(Spacer(1, 8))
+
+    # Classification-only simpler section
+    if include_classification_only:
+        elems.append(Paragraph("CLASSIFICATION (Abridged)", h1))
+        elems.append(Paragraph(site.get("classifier_decision_path", "Decision path not available."), body))
+        # attach GSD image if present
+        gsd = site.get("GSD")
+        if gsd and isinstance(gsd, dict) and gsd.get("plot_png"):
+            pngdata = base64.b64decode(gsd["plot_png"])
+            img = io.BytesIO(pngdata)
+            rlimg = RLImage(img, width=160*mm, height=80*mm)
+            elems.append(rlimg)
+        doc.build(elems)
+        pdf_bytes = buf.getvalue()
+        buf.close()
+        return pdf_bytes
+
+    # Full report sections
+    elems.append(Paragraph("1.0 INTRODUCTION", h1))
+    elems.append(Paragraph("This report was prepared by GeoMate AI as a Phase 1 geotechnical investigation summary.", body))
+
+    elems.append(Paragraph("2.0 SITE DESCRIPTION AND GEOLOGY", h1))
+    elems.append(Paragraph(site.get("Soil Profile", "Site description not provided."), body))
+
+    # Field and lab data
+    elems.append(Paragraph("3.0 FIELD INVESTIGATION & LABORATORY TESTING", h1))
+    # lab table if present
+    lab_rows = site.get("laboratory_results", [])
+    if lab_rows:
+        headers = ["Sample ID", "Material", "LL", "PI", "LS", "%Clay", "%Silt", "%Sand", "%Gravel"]
+        data = [headers]
+        for r in lab_rows:
+            data.append([r.get("sampleId", "—"), r.get("material", "—"), r.get("liquidLimit", "—"), r.get("plasticityIndex", "—"),
+                         r.get("linearShrinkage", "—"), r.get("percentClay", "—"), r.get("percentSilt", "—"),
+                         r.get("percentSand", "—"), r.get("percentGravel", "—")])
+        t = Table(data, repeatRows=1, colWidths=[40*mm, 40*mm, 15*mm, 15*mm, 12*mm, 12*mm, 12*mm, 12*mm, 12*mm])
+        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)
+    else:
+        elems.append(Paragraph("No laboratory results provided.", body))
+
+    # GSD plot include
+    gsd = site.get("GSD")
+    if gsd and isinstance(gsd, dict) and gsd.get("plot_png"):
+        elems.append(Spacer(1, 8))
+        elems.append(Paragraph("GSD Curve", h1))
+        pngdata = base64.b64decode(gsd["plot_png"])
+        img = io.BytesIO(pngdata)
+        rlimg = RLImage(img, width=160*mm, height=80*mm)
+        elems.append(rlimg)
+
+    # maps snapshot
+    if site.get("map_snapshot"):
+        elems.append(Spacer(1, 8))
+        elems.append(Paragraph("Map snapshot", h1))
+        try:
+            pngdata = base64.b64decode(site["map_snapshot"])
+            img = io.BytesIO(pngdata)
+            rlimg = RLImage(img, width=160*mm, height=100*mm)
+            elems.append(rlimg)
+        except Exception:
+            elems.append(Paragraph("Map snapshot could not be decoded.", body))
+
+    # Evaluation & recommendations
+    elems.append(Spacer(1, 8))
+    elems.append(Paragraph("4.0 EVALUATION OF GEOTECHNICAL PROPERTIES", h1))
+    # Use classifier decision if present
+    if site.get("classifier_decision_path"):
+        elems.append(Paragraph(site["classifier_decision_path"], body))
+    else:
+        elems.append(Paragraph("Classification details not provided.", body))
+
+    elems.append(Spacer(1, 8))
+    elems.append(Paragraph("5.0 RECOMMENDATIONS", h1))
+    recs = [
+        "Ensure positive surface drainage away from structures.",
+        "Remove unsuitable fill from beneath foundation footprints.",
+        "For lightly loaded structures, an allowable bearing pressure of 100 - 150 kPa may be used after further assessment.",
+        "For heavily loaded structures consider piled foundations if poor soils extend beyond 2 m."
+    ]
+    for r in recs:
+        elems.append(Paragraph(r, body))
+
+    doc.build(elems)
+    pdf_bytes = buf.getvalue()
+    buf.close()
+    return pdf_bytes
+
+
+@app.post("/api/report")
+async def report_endpoint(site_id: str = Form(...), classification_only: bool = Form(False)):
+    if site_id not in SITES:
+        raise HTTPException(status_code=404, detail="Site not found")
+    site = SITES[site_id]
+    pdf_bytes = _build_pdf_report_bytes(site, include_classification_only=classification_only)
+    # write file to /tmp
+    out_path = f"/tmp/geomate_report_{site_id}.pdf"
+    with open(out_path, "wb") as f:
+        f.write(pdf_bytes)
+    return FileResponse(out_path, media_type="application/pdf", filename=f"{site.get('Site Name','report')}.pdf")
+
+
+# End of backend file