Update main.py

main.py

@@ -12,8 +12,22 @@ from pydantic import BaseModel, Field
 from sentence_transformers import SentenceTransformer
 from dateutil.relativedelta import relativedelta
 
-# === Environment ===
-API_KEY = os.getenv("API_KEY")  # shared secret for this API (set as a Space secret/variable)
+# ==== Cache & Env setup (important on HF Spaces) ====
+# Put all model caches under /data (persistent & writable in Spaces)
+CACHE_ROOT = os.getenv("MODEL_CACHE_DIR", "/data/.cache")
+HF_HOME = os.getenv("HF_HOME", os.path.join(CACHE_ROOT, "huggingface"))
+TRANSFORMERS_CACHE = os.getenv("TRANSFORMERS_CACHE", os.path.join(HF_HOME, "transformers"))
+ST_HOME = os.getenv("SENTENCE_TRANSFORMERS_HOME", os.path.join(CACHE_ROOT, "sentence-transformers"))
+
+os.makedirs(TRANSFORMERS_CACHE, exist_ok=True)
+os.makedirs(ST_HOME, exist_ok=True)
+
+os.environ["HF_HOME"] = HF_HOME
+os.environ["TRANSFORMERS_CACHE"] = TRANSFORMERS_CACHE
+os.environ["SENTENCE_TRANSFORMERS_HOME"] = ST_HOME
+
+# ==== App config ====
+API_KEY = os.getenv("API_KEY")  # shared secret for this API
 SUPABASE_URL = os.getenv("SUPABASE_URL")
 SUPABASE_SERVICE_ROLE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
 MODEL_NAME = os.getenv("MODEL_NAME", "BAAI/bge-small-en-v1.5")
@@ -41,7 +55,7 @@ TIME_PATTERNS = [
     r"\b(january|february|march|april|may|june|july|august|september|october|november|december)(?:\s+\d{4})?\b",
 ]
 
-app = FastAPI(title="CIC Check-ins API", version="1.3.0")
+app = FastAPI(title="CIC Check-ins API", version="1.3.1")
 
 # === Auth guard ===
 def require_key(authorization: Optional[str] = Header(None)):
@@ -56,9 +70,15 @@ def require_key(authorization: Optional[str] = Header(None)):
 # === Startup / Shutdown ===
 @app.on_event("startup")
 async def on_startup():
-    # Load embedding model once
-    app.state.model = SentenceTransformer(MODEL_NAME)
-    # Supabase REST client (uses service role for RPCs)
+    # Load embedding model with explicit cache folder (fixes /.cache permission issue)
+    try:
+        app.state.model = SentenceTransformer(MODEL_NAME, cache_folder=ST_HOME)
+    except Exception as e:
+        # Optional fallback to a tiny model if the specified one fails (keeps API available)
+        fallback = "sentence-transformers/all-MiniLM-L6-v2"
+        app.state.model = SentenceTransformer(fallback, cache_folder=ST_HOME)
+        app.state.model_name_fallback = fallback
+    # Supabase REST client
     app.state.http = httpx.AsyncClient(
         base_url=f"{SUPABASE_URL}/rest/v1",
         headers={
@@ -98,12 +118,10 @@ def to_utc_iso(local_iso: str) -> str:
 
 def extract_time_subphrase(text: str, tz: pytz.BaseTzInfo) -> Optional[str]:
     s = (text or "").lower()
-    # 1) Regex heuristics
     for pat in TIME_PATTERNS:
         m = re.search(pat, s)
         if m:
             return m.group(0)
-    # 2) Fallback: search any date in text
     settings = {
         "TIMEZONE": str(tz),
         "RETURN_AS_TIMEZONE_AWARE": True,
@@ -121,7 +139,6 @@ def parse_phrase_to_range(
     tz: Optional[pytz.BaseTzInfo] = None,
     week_start: Optional[str] = None
 ) -> Dict[str, str]:
-    """Parse human phrase into [start, end) in tz. Returns {start, end, source}."""
     tz = tz or LOCAL_TZ
     week_start = (week_start or DEFAULT_WEEK_START).strip().lower()
     s_in = (phrase or "").strip()
@@ -131,7 +148,6 @@ def parse_phrase_to_range(
 
     now = datetime.now(tz)
 
-    # last <weekday>
     m = re.fullmatch(r"last\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)", s)
     if m:
         target = WEEKDAYS[m.group(1)]
@@ -140,7 +156,6 @@ def parse_phrase_to_range(
         day = _day_start(now - timedelta(days=delta))
         return {"start": day.isoformat(), "end": (day + timedelta(days=1)).isoformat(), "source": "weekday"}
 
-    # today / yesterday
     if s == "today":
         start = _day_start(now)
         return {"start": start.isoformat(), "end": (start + timedelta(days=1)).isoformat(), "source": "day"}
@@ -149,7 +164,6 @@ def parse_phrase_to_range(
         start = end - timedelta(days=1)
         return {"start": start.isoformat(), "end": end.isoformat(), "source": "day"}
 
-    # this/last week
     if s == "this week":
         start = _week_start(now, week_start)
         return {"start": start.isoformat(), "end": (start + timedelta(days=7)).isoformat(), "source": "week"}
@@ -158,7 +172,6 @@ def parse_phrase_to_range(
         start = this_start - timedelta(days=7)
         return {"start": start.isoformat(), "end": (start + timedelta(days=7)).isoformat(), "source": "week"}
 
-    # this/last month
     if s == "this month":
         start = _localize(tz, datetime(now.year, now.month, 1))
         end = _localize(tz, datetime(now.year + (1 if now.month == 12 else 0),
@@ -170,7 +183,6 @@ def parse_phrase_to_range(
         end = first_this
         return {"start": start.isoformat(), "end": end.isoformat(), "source": "month"}
 
-    # <month> [year]?
     m = re.fullmatch(rf"({'|'.join(MONTHS)})(?:\s+(\d{{4}}))?", s)
     if m:
         month_name, year_str = m.group(1), m.group(2)
@@ -180,12 +192,11 @@ def parse_phrase_to_range(
         end = _localize(tz, datetime(year + 1, 1, 1)) if month_idx == 12 else _localize(tz, datetime(year, month_idx + 1, 1))
         return {"start": start.isoformat(), "end": end.isoformat(), "source": "month"}
 
-    # (past|last) <N> (days|weeks|months)
     m = re.fullmatch(r"(past|last)\s+(\d+)\s*(day|days|week|weeks|month|months)", s)
     if m:
         n = int(m.group(2))
         unit = m.group(3)
-        end = _day_start(now) + timedelta(days=1)  # through end of today
+        end = _day_start(now) + timedelta(days=1)
         if unit.startswith("day"):
             start = end - timedelta(days=n)
         elif unit.startswith("week"):
@@ -194,7 +205,6 @@ def parse_phrase_to_range(
             start = end - relativedelta(months=n)
         return {"start": start.isoformat(), "end": end.isoformat(), "source": "relative"}
 
-    # quarters: Q1..Q4 [year]?
     m = re.fullmatch(r"q([1-4])(?:\s+(\d{4}))?", s)
     if m:
         q = int(m.group(1))
@@ -204,13 +214,7 @@ def parse_phrase_to_range(
         end = start + relativedelta(months=3)
         return {"start": start.isoformat(), "end": end.isoformat(), "source": "quarter"}
 
-    # fallback: dateparser -> day range
-    settings = {
-        "TIMEZONE": str(tz),
-        "RETURN_AS_TIMEZONE_AWARE": True,
-        "PREFER_DATES_FROM": "past",
-        "RELATIVE_BASE": now
-    }
+    settings = {"TIMEZONE": str(tz), "RETURN_AS_TIMEZONE_AWARE": True, "PREFER_DATES_FROM": "past", "RELATIVE_BASE": now}
     dt = dateparser.parse(s, settings=settings, languages=["en"])
     if not dt:
         raise HTTPException(400, detail=f"Could not parse phrase: {phrase}\n")
@@ -242,7 +246,6 @@ class SearchBody(BaseModel):
     filters: Optional[SearchFilters] = None
     return_fields: List[str] = ["id","ts","sender","username","msg","score"]
 
-# /interpret request schema
 class InterpretDefaults(BaseModel):
     timezone: Optional[str] = None
     week_start: Optional[str] = None
@@ -263,15 +266,12 @@ class InterpretBody(BaseModel):
 # === Routes ===
 @app.get("/")
 async def root():
-    return {
-        "ok": True,
-        "hint": "Use /healthz, /ingest, /search, /phrases/resolve, /interpret, /stats",
-        "week_start": DEFAULT_WEEK_START
-    }
+    return {"ok": True, "hint": "Use /healthz, /ingest, /search, /phrases/resolve, /interpret, /stats", "week_start": DEFAULT_WEEK_START}
 
 @app.get("/healthz")
 async def health():
-    return {"ok": True, "model": MODEL_NAME}
+    model_name = getattr(app.state, "model_name_fallback", MODEL_NAME)
+    return {"ok": True, "model": model_name}
 
 @app.get("/phrases/resolve")
 async def resolve_phrase(phrase: str = Query(..., min_length=1), _: None = Depends(require_key)):
@@ -280,20 +280,12 @@ async def resolve_phrase(phrase: str = Query(..., min_length=1), _: None = Depen
 
 @app.post("/ingest")
 async def ingest(body: IngestBody, _: None = Depends(require_key)):
-    ts_utc = (
-        datetime.fromisoformat(body.timestamp).astimezone(pytz.UTC).isoformat()
-        if body.timestamp else datetime.now(pytz.UTC).isoformat()
-    )
+    ts_utc = (datetime.fromisoformat(body.timestamp).astimezone(pytz.UTC).isoformat()
+              if body.timestamp else datetime.now(pytz.UTC).isoformat())
     vec = embed_text([body.msg])[0]
     payload = {
-        "_id": body.id,
-        "_sender": body.sender,
-        "_username": body.username,
-        "_slack_id": body.slack_id,
-        "_msg": body.msg,
-        "_ts": ts_utc,
-        "_tags": body.tags or [],
-        "_valid": True if body.valid_checkin is not False else False,
+        "_id": body.id, "_sender": body.sender, "_username": body.username, "_slack_id": body.slack_id,
+        "_msg": body.msg, "_ts": ts_utc, "_tags": body.tags or [], "_valid": True if body.valid_checkin is not False else False,
         "_embedding": vec,
     }
     r = await app.state.http.post("/rpc/upsert_checkin", json=payload)
@@ -314,10 +306,7 @@ async def search(body: SearchBody, _: None = Depends(require_key)):
         if body.filters.end:
             end_utc = to_utc_iso(body.filters.end) if "T" in body.filters.end else to_utc_iso(LOCAL_TZ.localize(datetime.fromisoformat(body.filters.end)).isoformat())
     rpc_payload = {
-        "q_embedding": q_vec,
-        "k": max(1, min(body.k, 100)),
-        "start_ts": start_utc,
-        "end_ts": end_utc,
+        "q_embedding": q_vec, "k": max(1, min(body.k, 100)), "start_ts": start_utc, "end_ts": end_utc,
         "sender_eq": body.filters.sender if body.filters and body.filters.sender else None,
         "valid_only": body.filters.valid_only if body.filters else None
     }
@@ -334,11 +323,7 @@ async def search(body: SearchBody, _: None = Depends(require_key)):
     return {"results": out, "used": {"semantic": True}}
 
 @app.get("/stats")
-async def stats(
-    phrase: Optional[str] = None,
-    bucket: Literal["weekly","monthly"] = "weekly",
-    _: None = Depends(require_key)
-):
+async def stats(phrase: Optional[str] = None, bucket: Literal["weekly","monthly"] = "weekly", _: None = Depends(require_key)):
     if phrase:
         rng = parse_phrase_to_range(phrase)
         start_utc, end_utc = to_utc_iso(rng["start"]), to_utc_iso(rng["end"])
@@ -352,15 +337,8 @@ async def stats(
         raise HTTPException(r.status_code, detail=f"Supabase RPC error: {r.text[:300]}")
     return {"bucket": bucket, "range": {"start": start_utc, "end": end_utc}, **r.json()}
 
-# === /interpret ===
-class InterpretResponse(BaseModel):
-    ok: bool
-
 @app.post("/interpret")
 async def interpret(body: InterpretBody, _: None = Depends(require_key)):
-    """
-    Free-form input -> (query, time window) + (optionally) return matching rows.
-    """
     text = (body.text or "").strip()
     if not text:
         raise HTTPException(400, detail="Missing 'text'")
@@ -369,8 +347,10 @@ async def interpret(body: InterpretBody, _: None = Depends(require_key)):
     week_start = DEFAULT_WEEK_START
     if body.defaults:
         if body.defaults.timezone:
-            try: tz = pytz.timezone(body.defaults.timezone)
-            except Exception: pass
+            try:
+                tz = pytz.timezone(body.defaults.timezone)
+            except Exception:
+                pass
         if body.defaults.week_start and body.defaults.week_start.lower() in ("monday","sunday"):
             week_start = body.defaults.week_start.lower()
 
@@ -407,7 +387,7 @@ async def interpret(body: InterpretBody, _: None = Depends(require_key)):
         else:
             return {
                 "ok": False,
-                "error": { "code": "NO_TIME_FOUND", "message": "No time phrase detected and no fallback_range provided." },
+                "error": {"code": "NO_TIME_FOUND", "message": "No time phrase detected and no fallback_range provided."},
                 "hints": ["Add 'last week', 'August', 'past 30 days'", "Or pass defaults.fallback_range"],
                 "query_guess": query or text
             }
@@ -416,7 +396,7 @@ async def interpret(body: InterpretBody, _: None = Depends(require_key)):
     search_payload = {
         "query": query or text,
         "k": max(1, min(opt.k, 100)),
-        "filters": { "start": rng["start"], "end": rng["end"], "sender": opt.infer_sender, "valid_only": None },
+        "filters": {"start": rng["start"], "end": rng["end"], "sender": opt.infer_sender, "valid_only": None},
         "return_fields": opt.return_fields
     }
 
@@ -426,10 +406,8 @@ async def interpret(body: InterpretBody, _: None = Depends(require_key)):
         start_utc = to_utc_iso(search_payload["filters"]["start"])
         end_utc   = to_utc_iso(search_payload["filters"]["end"])
         rpc_payload = {
-            "q_embedding": q_vec,
-            "k": search_payload["k"],
-            "start_ts": start_utc,
-            "end_ts": end_utc,
+            "q_embedding": q_vec, "k": search_payload["k"],
+            "start_ts": start_utc, "end_ts": end_utc,
             "sender_eq": search_payload["filters"]["sender"],
             "valid_only": search_payload["filters"].get("valid_only")
         }
@@ -446,12 +424,10 @@ async def interpret(body: InterpretBody, _: None = Depends(require_key)):
 
     resp: Dict[str, Any] = {
         "ok": True,
-        "input": { "text": body.text, "timezone": str(tz), "week_start": week_start },
+        "input": {"text": body.text, "timezone": str(tz), "week_start": week_start},
         "query": query or text,
-        "time": {
-            "phrase_raw": body.text, "phrase_extracted": extracted, "source": time_source,
-            "start": rng["start"], "end": rng["end"], "tz": rng["tz"]
-        },
+        "time": {"phrase_raw": body.text, "phrase_extracted": extracted, "source": time_source,
+                 "start": rng["start"], "end": rng["end"], "tz": rng["tz"]},
         "search_payload": search_payload
     }
     if suggestions and (not used_fallback):