Update main.py

main.py

@@ -12,6 +12,9 @@ from pymysql.err import OperationalError
 import threading
 warnings.filterwarnings("ignore")
 
+# ── NEW: lightweight event inference from sentences ───────────────────────────
+import re
+from typing import List, Dict, Any, Optional
 # ───────────────────────────────────────────────────────────────────────────────
 # CONFIG
 # ───────────────────────────────────────────────────────────────────────────────
@@ -248,6 +251,140 @@ def gemini_explain(prompt: str, sys: str = None, model: str = EXPLAIN_MODEL) ->
 # ───────────────────────────────────────────────────────────────────────────────
 # UTIL: Build graph & timeline from events (+ risk overlays)
 # ───────────────────────────────────────────────────────────────────────────────
+
+
+
+EVENT_VERBS = {
+    "sold": "SOLD",
+    "purchased": "PURCHASED",
+    "bought": "PURCHASED",
+    "acquired": "ACQUIRED",
+    "donated": "DONATED",
+    "gifted": "DONATED",
+    "bequeathed": "BEQUEATHED",
+    "consigned": "CONSIGNED",
+    "exhibited": "EXHIBITED",
+    "exported": "EXPORTED",
+    "imported": "IMPORTED",
+}
+
+YEAR_RE = re.compile(r"\b(1[6-9]\d{2}|20\d{2})\b")  # 1600–2099
+
+def _clean(s: Optional[str]) -> Optional[str]:
+    if not s: return None
+    s = re.sub(r"\s+", " ", s).strip(" ,.;:-–—")
+    return s or None
+
+def _infer_from_sentence(txt: str) -> Optional[Dict[str, Any]]:
+    """
+    Very pragmatic patterns that cover most catalogue phrasing:
+      - 'sold to X, <place>, 2000'
+      - 'sold to X, by 2000'
+      - 'purchased from Y in 1965'
+      - 'donated by X, <place>, 1971'
+    Returns a dict compatible with provenance_events rows.
+    """
+    if not txt: 
+        return None
+    low = txt.lower()
+
+    # find verb
+    verb = next((EVENT_VERBS[v] for v in EVENT_VERBS if v in low), None)
+    if not verb:
+        return None
+
+    # pull a year (prefers the last year in the string)
+    years = YEAR_RE.findall(txt)
+    year = years[-1] if years else None
+
+    actor = None
+    place = None
+
+    # Common pattern: 'sold to X, place, 2000'
+    m = re.search(r"\b(sold|purchased|bought|acquired|donated|gifted|bequeathed|consigned)\s+(to|by|from)\s+(.*)$", low)
+    if m:
+        # Take the fragment after 'to/by/from'
+        frag = txt[m.end(2)+1:].strip()
+        # Trim trailing year or 'by 2000'
+        frag = re.sub(r"(,\s*)?(by\s*)?\b(1[6-9]\d{2}|20\d{2})\b.*$", "", frag, flags=re.IGNORECASE).strip(" ,.;")
+        # Split on commas: first token is actor; the rest (if any) is place
+        parts = [p.strip() for p in re.split(r",(?![^()]*\))", frag) if p.strip()]
+        if parts:
+            actor = parts[0]
+            if len(parts) > 1:
+                place = ", ".join(parts[1:])
+
+    # Fallback simple 'sold to X' without commas
+    if not actor:
+        m2 = re.search(r"\bsold\s+to\s+([^,.;]+)", low)
+        if m2:
+            actor = _clean(txt[m2.start(1):m2.end(1)])
+
+    return {
+        "event_type": verb,
+        "date_from": f"{year}-01-01" if year else None,
+        "date_to": None,
+        "place": _clean(place),
+        "actor": _clean(actor),
+        "method": None,
+        "source_ref": "inferred:sentence"
+    }
+
+def infer_events_from_sentences(sentences: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    for s in sentences:
+        ev = _infer_from_sentence(s.get("sentence", ""))
+        if ev and (ev.get("actor") or ev.get("place")):
+            ev["seq"] = s.get("seq")
+            out.append(ev)
+    # Deduplicate (actor+place+event_type+date_from)
+    seen = set()
+    uniq = []
+    for e in out:
+        key = (e.get("actor"), e.get("place"), e.get("event_type"), e.get("date_from"))
+        if key in seen: 
+            continue
+        seen.add(key)
+        uniq.append(e)
+    return uniq
+
+# ── OPTIONAL: simple geocode cache for map pins ───────────────────────────────
+def geocode_place_cached(place: str):
+    """Cache in DB: places_cache(place TEXT PRIMARY KEY, lat DOUBLE, lon DOUBLE, updated_at TIMESTAMP)"""
+    if not place:
+        return None
+    with cursor() as cur:
+        cur.execute("CREATE TABLE IF NOT EXISTS places_cache (place VARCHAR(255) PRIMARY KEY, lat DOUBLE, lon DOUBLE, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)")
+        cur.execute("SELECT lat, lon FROM places_cache WHERE place=%s", (place,))
+        row = cur.fetchone()
+        if row and row.get("lat") is not None and row.get("lon") is not None:
+            return row
+
+    # Try Nominatim (best effort). If outbound HTTP is blocked, just skip.
+    try:
+        r = requests.get(
+            "https://nominatim.openstreetmap.org/search",
+            params={"q": place, "format": "json", "limit": 1},
+            headers={"User-Agent": "provenance-radar/1.0"},
+            timeout=6,
+        )
+        j = r.json()
+        if j:
+            lat, lon = float(j[0]["lat"]), float(j[0]["lon"])
+        else:
+            lat, lon = None, None
+    except Exception:
+        lat, lon = None, None
+
+    with cursor() as cur:
+        cur.execute(
+            "INSERT INTO places_cache (place, lat, lon) VALUES (%s,%s,%s) ON DUPLICATE KEY UPDATE lat=VALUES(lat), lon=VALUES(lon), updated_at=CURRENT_TIMESTAMP",
+            (place, lat, lon),
+        )
+    if lat is None or lon is None:
+        return None
+    return {"lat": lat, "lon": lon}
+
 def _policy_hits_for_date(d: str):
     """Return policy codes a given ISO date falls into."""
     if not d:
@@ -430,13 +567,82 @@ def graph(object_id: int):
         obj = cur.fetchone()
         if not obj:
             return jsonify({"ok": False, "error": "not_found"}), 404
+
         cur.execute("""SELECT event_type, date_from, date_to, place, actor, source_ref
                        FROM provenance_events WHERE object_id=%s
                        ORDER BY COALESCE(date_from,'0001-01-01')""", (object_id,))
         events = cur.fetchall()
-    return jsonify({"ok": True, **build_graph_from_events(obj, events)})
 
-@app.get("/api/timeline/<int:object_id>")
+        cur.execute("SELECT seq, sentence FROM provenance_sentences WHERE object_id=%s ORDER BY seq", (object_id,))
+        sents = cur.fetchall()
+
+    inferred = infer_events_from_sentences(sents)
+
+    # Prefer stored events; fill with inferred where stored is thin
+    merged = list(events)
+    if not merged or all((not e.get("actor") and not e.get("place")) for e in merged):
+        merged = inferred
+    else:
+        # add inferred items that add missing actor/place for the same year
+        have = {(e.get("actor"), e.get("place"), e.get("event_type"), to_iso(e.get("date_from"))): True for e in merged}
+        for e in inferred:
+            key = (e.get("actor"), e.get("place"), e.get("event_type"), to_iso(e.get("date_from")))
+            if key not in have:
+                merged.append(e)
+
+    g = build_graph_from_events(obj, merged)
+
+    # NEW: link successive actors to show chain of custody
+    actors_in_time = [ (to_iso(e.get("date_from")) or "0001-01-01", e.get("actor")) for e in merged if e.get("actor") ]
+    actors_in_time.sort(key=lambda x: x[0])
+    for i in range(len(actors_in_time) - 1):
+        a1 = actors_in_time[i][1]; a2 = actors_in_time[i+1][1]
+        if a1 and a2 and a1 != a2:
+            g["edges"].append({
+                "source": f"actor:{a1}",
+                "target": f"actor:{a2}",
+                "label": "TRANSFER",
+                "date": actors_in_time[i+1][0],
+                "weight": 0.8,
+                "policy": _policy_hits_for_date(actors_in_time[i+1][0]),
+                "source_ref": "link:sequence"
+            })
+
+    return jsonify({"ok": True, **g})
+
+@app.get("/api/places/<int:object_id>")
+@with_db_retry
+def places(object_id: int):
+    with cursor() as cur:
+        cur.execute("""SELECT place, date_from FROM provenance_events WHERE object_id=%s""", (object_id,))
+        ev = cur.fetchall()
+        cur.execute("SELECT seq, sentence FROM provenance_sentences WHERE object_id=%s ORDER BY seq", (object_id,))
+        sents = cur.fetchall()
+
+    inferred = infer_events_from_sentences(sents)
+    all_places = []
+    for e in ev + inferred:
+        p = _clean(e.get("place"))
+        if p:
+            all_places.append({"place": p, "date": to_iso(e.get("date_from"))})
+
+    # unique by place, keep earliest date
+    agg = {}
+    for r in all_places:
+        d = r["date"] or "9999-12-31"
+        if r["place"] not in agg or d < (agg[r["place"]].get("date") or "9999-12-31"):
+            agg[r["place"]] = r
+
+    out = []
+    for p, info in agg.items():
+        geo = geocode_place_cached(p)  # may be None if geocoding blocked
+        out.append({"place": p, "date": info.get("date"), "lat": (geo or {}).get("lat"), "lon": (geo or {}).get("lon")})
+
+    # order chronologically for path drawing
+    out.sort(key=lambda x: x.get("date") or "9999-12-31")
+    return jsonify({"ok": True, "places": out})
+  
+@app.get("/api/timeline/<int:object_id>"
 @with_db_retry
 def timeline(object_id: int):
     with cursor() as cur: