Update app.py

app.py

@@ -1,20 +1,11 @@
-""" 
-Enhanced FastAPI: Matchmaking Recommendation API 
-Features:
-- /health: Server status 
-- /recommend/{user_id}: Get top N matches with compatibility scores 
-- /feedback: Record user likes/rejects 
-- Cold‑start capable: Any user can get recommendations 
-- CORS enabled for frontend integration 
+"""
+Enhanced FastAPI: Matchmaking Recommendation API
 """
 
 # ----------------------------------------------------------------------
-#  Imports (added pickle‑safety utilities)
+# Imports
 # ----------------------------------------------------------------------
 import os
-import pickle
-import pickletools            # inspect pickle op‑codes safely
-import re                    # glob → regex conversion
 import httpx
 import numpy as np
 from datetime import datetime
@@ -22,113 +13,40 @@ from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from sklearn.metrics.pairwise import cosine_similarity
 import logging
-import json
-import base64
-
-# New typing import (required by the safety helper)
-from typing import Iterable, List
+import joblib
 
 # ----------------------------------------------------------------------
-#  Logging
+# Logging
 # ----------------------------------------------------------------------
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
 )
-logger = logging.getLogger(__name__)
-
-# ----------------------------------------------------------------------
-#  Pickle‑safety helper
-# ----------------------------------------------------------------------
-class PickleSafetyError(RuntimeError):
-    """Raised when a pickle contains a disallowed import."""
-    pass
-
-
-def _glob_to_regex(pattern: str) -> re.Pattern:
-    esc = re.escape(pattern)
-    esc = esc.replace(r"\*\*", r".*")          # recursive *
-    esc = esc.replace(r"\*", r"[^.]+")        # single‑level *
-    return re.compile(f"^{esc}$")
-
-
-def _build_allowlist(pats: Iterable[str]) -> List[re.Pattern]:
-    return [_glob_to_regex(p) for p in pats]
-
-
-def _is_allowed(name: str, regexes: List[re.Pattern]) -> bool:
-    return any(r.match(name) for r in regexes)
-
-
-def _extract_imports(pickle_bytes: bytes) -> List[str]:
-    imports: List[str] = []
-    for op, arg, _ in pickletools.genops(pickle_bytes):
-        if op.name in ("GLOBAL", "STACK_GLOBAL"):
-            module, obj = arg
-            imports.append(f"{module}.{obj}")
-    return imports
-
-
-def safe_pickle_load(
-    fileobj,
-    *,
-    whitelist: Iterable[str] | None = None,
-    raise_on_error: bool = True,
-) -> object:
-    """
-    Load a pickle **only after** verifying that every import it contains
-    matches the supplied ``whitelist`` (glob‑style patterns).
-    """
-    raw = fileobj.read()
-    imports = _extract_imports(raw)
-
-    if whitelist is None:
-        whitelist = [
-            "builtins.object",
-            "builtins.list",
-            "builtins.dict",
-            "builtins.tuple",
-            "builtins.set",
-            "builtins.int",
-            "builtins.float",
-            "builtins.str",
-            "builtins.bytes",
-        ]
-
-    allow_regexes = _build_allowlist(whitelist)
-    bad = [imp for imp in imports if not _is_allowed(imp, allow_regexes)]
-    if bad:
-        msg = ["Pickle rejected – unsafe imports detected:"] + [
-            f"  • {i}" for i in bad
-        ]
-        full_msg = "\n".join(msg)
-        if raise_on_error:
-            raise PickleSafetyError(full_msg)
-        logger.warning(full_msg)
-        return None
-
-    return pickle.loads(raw)
 
+logger = logging.getLogger(__name__)
 
 # ----------------------------------------------------------------------
-#  Config
+# Config
 # ----------------------------------------------------------------------
 SUPABASE_URL = os.getenv(
-    "SUPABASE_URL", "https://nquhiryqtbrtpauuxmsc.supabase.co"
+    "SUPABASE_URL",
+    "https://nquhiryqtbrtpauuxmsc.supabase.co"
 )
+
 SERVICE_KEY = os.getenv("SUPABASE_SERVICE_KEY", "")
 HEADERS = {"apikey": SERVICE_KEY, "Content-Type": "application/json"}
+
 MODEL_PATH = os.getenv("MODEL_PATH", "models/recommendation_model.pkl")
 
+# ----------------------------------------------------------------------
+# App
+# ----------------------------------------------------------------------
 app = FastAPI(
     title="Matchmaking Recommendation API",
     version="2.0.0",
     description="Smart matchmaking using ML-based compatibility scoring",
 )
 
-# ----------------------------------------------------------------------
-#  CORS middleware
-# ----------------------------------------------------------------------
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -138,107 +56,54 @@ app.add_middleware(
 )
 
 # ----------------------------------------------------------------------
-#  Global model holder
+# Global model
 # ----------------------------------------------------------------------
 model = None
 model_loaded_at = None
 
 
-def load_model() -> bool:
-    """Load the trained model from disk, handling dict pickles, JSON strings, or base64‑encoded JSON."""
+# ----------------------------------------------------------------------
+# Load model (FIXED)
+# ----------------------------------------------------------------------
+def load_model():
     global model, model_loaded_at
 
     if not os.path.exists(MODEL_PATH):
-        logger.error(f"Model file not found at {MODEL_PATH}")
         raise FileNotFoundError(f"Model not found at {MODEL_PATH}")
 
-    # ------------------------------------------------------------------
-    # Whitelist – edit only if you need additional packages
-    # ------------------------------------------------------------------
-    whitelist = [
-        "numpy.*",
-        "scipy.*",
-        "pandas.*",
-        "sklearn.*",
-        "torch.*",          # kept for completeness – no torch needed at runtime
-        "builtins.*",
-    ]
-
-    # --------------------------------------------------------------
-    # 1️⃣ Try the safe‑pickle loader first
-    # --------------------------------------------------------------
     try:
-        with open(MODEL_PATH, "rb") as f:
-            raw_obj = safe_pickle_load(f, whitelist=whitelist)
-    except PickleSafetyError as pse:
-        logger.error(f"✗ Unsafe pickle rejected: {pse}")
-        raise
-    except Exception as e:
-        logger.error(f"✗ Error during safe‑pickle load: {e}")
-        raise
+        model = joblib.load(MODEL_PATH)
 
-    # --------------------------------------------------------------
-    # 2️⃣ If we got a dict, we’re done.
-    # --------------------------------------------------------------
-    if isinstance(raw_obj, dict):
-        model = raw_obj
-        logger.info("Model loaded via safe_pickle_load (dictionary).")
-    else:
-        # --------------------------------------------------------------
-        # 3️⃣ Not a dict – try to interpret the string as JSON.
-        # --------------------------------------------------------------
-        if not isinstance(raw_obj, str):
-            raise RuntimeError(
-                "Model file loaded to a non‑dict, non‑string object; cannot proceed."
-            )
+        if not isinstance(model, dict):
+            raise ValueError("Model must be a dictionary")
 
-        stripped = raw_obj.strip()
-        # ---- try plain JSON -------------------------------------------------
-        try:
-            model = json.loads(stripped)
-            logger.info("Model string interpreted as plain JSON.")
-        except json.JSONDecodeError:
-            # ---- try base64‑encoded JSON ------------------------------------
-            try:
-                decoded = base64.b64decode(stripped).decode("utf-8")
-                model = json.loads(decoded)
-                logger.info(
-                    "Model string was base64‑encoded JSON – successfully decoded."
-                )
-            except Exception as decode_err:
-                logger.error(
-                    f"Failed to decode model string as JSON or base64‑JSON: {decode_err}"
-                )
-                raise RuntimeError(
-                    "Model file is a string but not valid JSON nor base64‑encoded JSON."
-                ) from decode_err
-
-    # --------------------------------------------------------------
-    # 4️⃣ Sanity‑check required keys
-    # --------------------------------------------------------------
-    required_keys = {"n_profiles", "trained_at", "feature_matrix"}
-    missing = required_keys - set(model.keys())
-    if missing:
-        raise ValueError(f"Loaded model is missing expected keys: {missing}")
-
-    model_loaded_at = datetime.now()
-    logger.info(
-        f"✓ Model loaded safely: {model['n_profiles']} profiles, trained at {model['trained_at']}"
-    )
-    return True
+        required_keys = {"n_profiles", "trained_at", "feature_matrix"}
+        missing = required_keys - set(model.keys())
+
+        if missing:
+            raise ValueError(f"Missing keys in model: {missing}")
+
+        model_loaded_at = datetime.utcnow()
+
+        logger.info(
+            f"Model loaded: {model['n_profiles']} profiles"
+        )
+
+    except Exception as e:
+        logger.error(f"Model load failed: {e}")
+        raise
 
 
+# ----------------------------------------------------------------------
+# Startup
+# ----------------------------------------------------------------------
 @app.on_event("startup")
 async def startup():
-    """Load model on startup (fails fast if the pickle is unsafe)."""
-    try:
-        load_model()
-    except Exception as e:
-        logger.error(f"[STARTUP ERROR] {e}")
+    load_model()
 
 
 # ----------------------------------------------------------------------
-#  Helper utilities (unchanged)
+# Helpers
 # ----------------------------------------------------------------------
 def safe_str(val):
     if val is None:
@@ -249,11 +114,8 @@ def safe_str(val):
 
 
 def preprocess_user(user_data):
-    try:
-        age = int(user_data.get("age") or 25)
-        age = max(18, min(100, age))
-    except Exception:
-        age = 25
+    age = int(user_data.get("age") or 25)
+    age = max(18, min(100, age))
 
     cat_cols = [
         "religion",
@@ -263,9 +125,8 @@ def preprocess_user(user_data):
         "maslak",
         "region_caste",
     ]
-    cat_vals = [
-        safe_str(user_data.get(col)) or "unknown" for col in cat_cols
-    ]
+
+    cat_vals = [safe_str(user_data.get(c)) or "unknown" for c in cat_cols]
 
     text_fields = {
         "hobbies": safe_str(user_data.get("hobbies")),
@@ -274,20 +135,20 @@ def preprocess_user(user_data):
             user_data.get("preferred_partner_criteria")
         ),
     }
+
     return age, cat_vals, text_fields
 
 
 def encode_user(age, cat_vals, text_fields, le_dict, scaler, tfidf_dict):
     features = []
 
-    # 1. Scale age
+    # Age
     try:
-        age_scaled = scaler.transform([[float(age)]])[0]
-        features.extend(age_scaled)
-    except Exception:
-        features.extend([0.5])
+        features.extend(scaler.transform([[float(age)]])[0])
+    except:
+        features.append(0.5)
 
-    # 2. Encode categoricals
+    # categorical
     cat_cols = [
         "religion",
         "marital_status",
@@ -296,45 +157,50 @@ def encode_user(age, cat_vals, text_fields, le_dict, scaler, tfidf_dict):
         "maslak",
         "region_caste",
     ]
+
     for col, val in zip(cat_cols, cat_vals):
         le = le_dict[col]
+
         if val not in le.classes_:
-            if "unknown" in le.classes_:
-                val = "unknown"
-            else:
-                val = le.classes_[0]
+            val = "unknown" if "unknown" in le.classes_ else le.classes_[0]
+
         try:
-            encoded = le.transform([val])[0]
-            features.append(float(encoded))
-        except Exception:
+            features.append(float(le.transform([val])[0]))
+        except:
             features.append(0.0)
 
-    # 3. TF‑IDF for text fields
-    text_cols = ["hobbies", "personality_traits", "preferred_partner_criteria"]
+    # text TF-IDF
+    text_cols = [
+        "hobbies",
+        "personality_traits",
+        "preferred_partner_criteria",
+    ]
+
     for col in text_cols:
         try:
-            tfidf = tfidf_dict[col]
-            vec = tfidf.transform([text_fields[col]]).toarray()[0]
+            vec = tfidf_dict[col].transform([text_fields[col]]).toarray()[0]
             features.extend(vec)
-        except Exception:
+        except:
             features.extend([0.0] * 20)
 
     return np.array(features).reshape(1, -1)
 
 
 # ----------------------------------------------------------------------
-#  API endpoints (unchanged)
+# Routes
 # ----------------------------------------------------------------------
+@app.get("/")
+async def root():
+    return {"status": "API running"}
+
+
 @app.get("/health")
 async def health():
     return {
-        "status": "running",
+        "status": "ok",
         "model_loaded": model is not None,
-        "model_profiles": model["n_profiles"] if model else 0,
-        "model_trained_at": model["trained_at"] if model else None,
-        "api_loaded_at": model_loaded_at.isoformat()
-        if model_loaded_at
-        else None,
+        "profiles": model["n_profiles"] if model else 0,
+        "loaded_at": model_loaded_at,
     }
 
 
@@ -342,50 +208,33 @@ async def health():
 async def stats():
     if not model:
         raise HTTPException(503, "Model not loaded")
+
     return {
         "total_profiles": model["n_profiles"],
         "feature_dimensions": model["feature_matrix"].shape[1],
-        "model_version": model["version"],
         "trained_at": model["trained_at"],
-        "categorical_features": len(
-            ["religion", "marital_status", "qualification", "country", "maslak", "region_caste"]
-        ),
-        "text_features": len(
-            ["hobbies", "personality_traits", "preferred_partner_criteria"]
-        ),
-        "numeric_features": 1,
     }
 
 
 @app.get("/recommend/{user_id}")
-async def recommend(user_id: str, top_n: int = 10, min_score: float = 0.3):
+async def recommend(user_id: str, top_n: int = 10):
     if not model:
         raise HTTPException(503, "Model not loaded")
 
-    top_n = min(max(1, top_n), 50)
-    min_score = max(0.0, min(1.0, min_score))
-
     try:
-        logger.info(f"Fetching user {user_id}")
         resp = httpx.get(
             f"{SUPABASE_URL}/rest/v1/profiles",
             headers=HEADERS,
             params={"id": f"eq.{user_id}", "select": "*"},
-            timeout=10,
         )
+
         if resp.status_code != 200:
             raise HTTPException(404, "User not found")
-        users = resp.json()
-        if not users:
-            raise HTTPException(404, "User not found")
-        user = users[0]
 
-        user_gender = safe_str(user.get("gender"))
-        if user_gender not in ("male", "female"):
-            raise HTTPException(400, "User gender must be 'male' or 'female'")
-        opposite_gender = "female" if user_gender == "male" else "male"
+        user = resp.json()[0]
 
         age, cat_vals, text_fields = preprocess_user(user)
+
         user_vec = encode_user(
             age,
             cat_vals,
@@ -395,116 +244,40 @@ async def recommend(user_id: str, top_n: int = 10, min_score: float = 0.3):
             model["tfidf_vectorizers"],
         )
 
-        candidates = []
-        for i, p in enumerate(model["profile_data"]):
-            if (
-                p.get("gender") == opposite_gender
-                and p.get("is_active")
-                and p.get("id") != user_id
-            ):
-                candidates.append((i, p))
+        candidates = [
+            (i, p)
+            for i, p in enumerate(model["profile_data"])
+            if p.get("gender") != user.get("gender")
+            and p.get("id") != user_id
+        ]
 
         if not candidates:
             return {"matches": []}
 
-        cand_indices = [c[0] for c in candidates]
-        cand_matrix = model["feature_matrix"][cand_indices]
+        indices = [c[0] for c in candidates]
+        matrix = model["feature_matrix"][indices]
+
+        sims = cosine_similarity(user_vec, matrix)[0]
 
-        sims = cosine_similarity(user_vec, cand_matrix)[0]
+        top = np.argsort(sims)[::-1][:top_n]
 
-        top_positions = np.argsort(sims)[::-1][:top_n]
-        matches = []
-        for pos in top_positions:
-            score = float(sims[pos])
-            if score < min_score:
-                continue
-            candidate = candidates[pos][1]
-            matches.append(
+        results = []
+        for i in top:
+            p = candidates[i][1]
+            results.append(
                 {
-                    "user_id": candidate["id"],
-                    "name": candidate.get("full_name", "Unknown"),
-                    "age": candidate.get("age", 0),
-                    "city": candidate.get("city", ""),
-                    "gender": candidate.get("gender", ""),
-                    "religion": candidate.get("religion", ""),
-                    "compatibility_score": round(score * 100, 1),
-                    "photo_url": candidate.get("profile_picture_url"),
+                    "user_id": p["id"],
+                    "name": p.get("full_name"),
+                    "score": float(sims[i]),
                 }
             )
 
-        logger.info(f"Generated {len(matches)} recommendations for {user_id}")
-        return {
-            "user_id": user_id,
-            "matches": matches,
-            "total_matches": len(matches),
-            "query_timestamp": datetime.utcnow().isoformat(),
-        }
+        return {"matches": results}
 
-    except HTTPException:
-        raise
     except Exception as e:
-        logger.error(f"Error in recommend: {e}")
-        raise HTTPException(500, f"Recommendation failed: {e}")
+        raise HTTPException(500, str(e))
 
 
 @app.post("/feedback")
-async def feedback(request: dict):
-    try:
-        user_id = request.get("user_id")
-        target_id = request.get("target_id")
-        action = request.get("action", "").lower()
-
-        if not user_id or not target_id:
-            raise HTTPException(400, "user_id and target_id required")
-        if action not in ("like", "reject"):
-            raise HTTPException(400, "action must be 'like' or 'reject'")
-
-        data = {
-            "user_id": user_id,
-            "matched_user_id": target_id,
-            "is_liked": action == "like",
-            "is_skipped": action == "reject",
-            "created_at": datetime.utcnow().isoformat(),
-        }
-
-        logger.info(f"Recording feedback: {user_id} {action} {target_id}")
-        resp = httpx.post(
-            f"{SUPABASE_URL}/rest/v1/matches",
-            headers=HEADERS,
-            json=data,
-            timeout=10,
-        )
-        if resp.status_code in (200, 201, 204):
-            logger.info("Feedback recorded successfully")
-            return {"status": "ok", "message": "Feedback recorded"}
-        else:
-            return {"status": "error", "message": resp.text}
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error in feedback: {e}")
-        return {"status": "error", "message": str(e)}
-
-
-@app.get("/")
-async def root():
-    return {
-        "name": "Matchmaking Recommendation API",
-        "version": "2.0.0",
-        "endpoints": {
-            "health": "/health",
-            "stats": "/stats",
-            "recommend": "/recommend/{user_id}",
-            "feedback": "/feedback",
-        },
-        "docs": "/docs",
-    }
-
-
-if __name__ == "__main__":
-    import uvicorn
-
-    port = int(os.getenv("PORT", 7860))
-    host = os.getenv("HOST", "0.0.0.0")
-    logger.info(f"Starting server on {host}:{port}")
-    uvicorn.run(app, host=host, port=port, log_level="info")
+async def feedback(data: dict):
+    return {"status": "received"}