Update app.py

app.py

@@ -1,8 +1,13 @@
 # main.py
 """
 Financial Health Score Service (FastAPI)
-Now using GPT-4.1 with strict JSON mode.
-This guarantees the model ALWAYS returns valid JSON.
+
+Rewrite includes:
+- Uses GPT-4.1 with strict JSON schema (response_format)
+- OpenAI JSON is guaranteed valid -> uses message.parsed
+- Bulletproof Mongo fetch for budgets, transactions, currencies
+- Fully rewritten OpenAI call (Option A)
+- No messy regex parsing
 """
 
 import json
@@ -16,7 +21,9 @@ from openai import OpenAI
 from pydantic import BaseModel
 from pymongo import MongoClient
 
-# Load environment
+# ===========================
+# ENV & CLIENT SETUP
+# ===========================
 load_dotenv()
 
 MONGO_URI = os.getenv("MONGO_URI")
@@ -28,18 +35,17 @@ if not MONGO_URI:
 if not OPENAI_API_KEY:
     raise RuntimeError("❌ OPENAI_API_KEY missing in environment variables")
 
-# MongoDB setup
 mongo_client = MongoClient(MONGO_URI)
 default_db = mongo_client.get_default_database()
+if default_db is None:
+    raise RuntimeError("Unable to determine default database from MONGO_URI")
 
 budget_collection = default_db["budget"]
 transaction_collection = default_db["transactions"]
 currencies_collection = default_db["currencies"]
 
-# OpenAI client
 openai = OpenAI(api_key=OPENAI_API_KEY)
 
-# FastAPI app
 app = FastAPI(title="Financial Health Score Service")
 
 
@@ -53,100 +59,98 @@ class ScoreRequest(BaseModel):
 # ===========================
 # HELPERS
 # ===========================
-def safe_number(value):
+def safe_number(v):
     try:
-        return float(value)
-    except Exception:
+        return float(v)
+    except:
         return None
 
 
 def normalize_budgets(budgets):
-    normalized = []
-    for budget in budgets:
-        head_categories = []
-        heads = budget.get("headCategories") or []
-
-        for head in heads:
-            head_categories.append({
-                "spendLimitType": head.get("spendLimitType"),
-                "spendAmount": safe_number(head.get("spendAmount")),
-                "maxAmount": safe_number(head.get("maxAmount")),
-                "remainingAmount": safe_number(head.get("remainingAmount")),
-                "notifications": head.get("notifications") or [],
+    out = []
+    for b in budgets:
+        heads = []
+        for h in b.get("headCategories", []) or []:
+            heads.append({
+                "spendLimitType": h.get("spendLimitType"),
+                "spendAmount": safe_number(h.get("spendAmount")),
+                "maxAmount": safe_number(h.get("maxAmount")),
+                "remainingAmount": safe_number(h.get("remainingAmount")),
+                "notifications": h.get("notifications") or []
             })
 
-        normalized.append({
-            "name": budget.get("name"),
-            "status": budget.get("status"),
-            "period": budget.get("period"),
-            "maxAmount": safe_number(budget.get("maxAmount")),
-            "spendAmount": safe_number(budget.get("spendAmount")),
-            "remainingAmount": safe_number(budget.get("remainingAmount")),
-            "rollover": budget.get("rollover"),
-            "notifications": budget.get("notifications") or [],
-            "headCategories": head_categories,
+        out.append({
+            "name": b.get("name"),
+            "status": b.get("status"),
+            "period": b.get("period"),
+            "maxAmount": safe_number(b.get("maxAmount")),
+            "spendAmount": safe_number(b.get("spendAmount")),
+            "remainingAmount": safe_number(b.get("remainingAmount")),
+            "rollover": b.get("rollover"),
+            "notifications": b.get("notifications") or [],
+            "headCategories": heads,
         })
-
-    return normalized
+    return out
 
 
-def normalize_transactions(transactions):
-    trimmed = []
-    for txn in transactions:
-        date_value = txn.get("date")
-        date_str = date_value.date().isoformat() if isinstance(date_value, datetime) else None
+def normalize_transactions(txns):
+    out = []
+    for txn in txns:
+        date_val = txn.get("date")
+        if isinstance(date_val, datetime):
+            date_str = date_val.date().isoformat()
+        else:
+            date_str = None
 
+        # Resolve currency
         currency_code = None
         currency_id = txn.get("currency")
 
         try:
-            # Handle ObjectId or string forms
             if isinstance(currency_id, ObjectId):
-                currency_doc = currencies_collection.find_one({"_id": currency_id})
-            elif isinstance(currency_id, str):
-                currency_doc = currencies_collection.find_one({"_id": ObjectId(currency_id)})
+                doc = currencies_collection.find_one({"_id": currency_id})
             elif isinstance(currency_id, dict) and "$oid" in currency_id:
-                currency_doc = currencies_collection.find_one({"_id": ObjectId(currency_id["$oid"])})
+                doc = currencies_collection.find_one({"_id": ObjectId(currency_id["$oid"])})
+            elif isinstance(currency_id, str):
+                try:
+                    doc = currencies_collection.find_one({"_id": ObjectId(currency_id)})
+                except:
+                    doc = currencies_collection.find_one({"code": currency_id}) or \
+                          currencies_collection.find_one({"currency": currency_id})
             else:
-                currency_doc = None
+                doc = None
 
-            if currency_doc:
-                currency_code = currency_doc.get("code") or currency_doc.get("currency")
-
-        except Exception:
+            if doc:
+                currency_code = doc.get("code") or doc.get("currency")
+        except:
             currency_code = None
 
-        trimmed.append({
+        out.append({
             "type": txn.get("type"),
             "amount": safe_number(txn.get("amount")),
             "currency": currency_code,
             "date": date_str,
         })
-    return trimmed
+    return out
 
 
-def score_prompt(budgets, transactions):
-    return {
-        "role": "user",
-        "content": f"""
-You are a financial wellness expert. Using the budgets and last 30 days of transactions below, 
-rate the user’s financial health from 0 to 100 (higher = better).
+def build_prompt(budgets, transactions):
+    return f"""
+You are a financial wellness expert. Use the user's budgets and last 30 days of transactions
+to compute a financial health score from 0 to 100.
 
 Rules:
-- Always prefix amounts with currency code when available (e.g., INR 5000).
-- Keep the explanation short (1–2 sentences).
-- Consider income, expenses, spending consistency, and remaining budgets.
+- When mentioning amounts, ALWAYS prefix with currency code when available (e.g., "INR 10,000").
+- Keep explanation short (1–2 sentences).
+- Score must reflect spending habits, budget usage, and financial balance.
+- Respond ONLY using the JSON schema enforced below.
 
 Budgets:
-{json.dumps(normalize_budgets(budgets), indent=2)}
+{json.dumps(budgets, indent=2)}
 
-Transactions (last 30 days):
-{json.dumps(normalize_transactions(transactions), indent=2)}
-
-Respond ONLY using this exact JSON structure:
-{{ "score": number, "explanation": "string" }}
+Transactions:
+{json.dumps(transactions, indent=2)}
 """
-    }
 
 
 # ===========================
@@ -154,7 +158,7 @@ Respond ONLY using this exact JSON structure:
 # ===========================
 @app.get("/")
 def root():
-    return {"status": "Financial Health Score service is running"}
+    return {"status": "Financial Health Score service running"}
 
 
 @app.post("/financial-score")
@@ -162,21 +166,23 @@ def financial_score(payload: ScoreRequest):
     # Validate ObjectId
     try:
         user_id = ObjectId(payload.userId)
-    except Exception:
+    except:
         raise HTTPException(status_code=400, detail="Invalid userId")
 
     # Fetch budgets
-    budgets = list(budget_collection.find({"createdBy": user_id}))
+    budgets_raw = list(budget_collection.find({"createdBy": user_id}))
+    budgets = normalize_budgets(budgets_raw)
 
     # Fetch last 30 days transactions
     thirty_days_ago = datetime.utcnow() - timedelta(days=30)
-    transactions = list(
-        transaction_collection.find({
-            "user": user_id,
-            "date": {"$gte": thirty_days_ago}
-        }).sort("date", -1).limit(120)
+    txns_raw = list(
+        transaction_collection.find(
+            {"user": user_id, "date": {"$gte": thirty_days_ago}}
+        ).sort("date", -1).limit(150)
     )
+    transactions = normalize_transactions(txns_raw)
 
+    # If no data at all
     if not budgets and not transactions:
         return {
             "userId": payload.userId,
@@ -184,35 +190,57 @@ def financial_score(payload: ScoreRequest):
             "explanation": "No budgets or recent transactions found."
         }
 
-    # Build messages
-    messages = [score_prompt(budgets, transactions)]
+    prompt = build_prompt(budgets, transactions)
 
-    # -- Strict JSON Mode using GPT-4.1 --
+    # ===========================
+    # STRICT GPT-4.1 JSON (Option A)
+    # ===========================
     try:
         response = openai.chat.completions.create(
             model="gpt-4.1",
-            response_format={"type": "json_object"},   # 🔥 Guarantees valid JSON
-            messages=messages,
-            temperature=0.4,
+            temperature=0.6,
+            response_format={
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "financial_score",
+                    "schema": {
+                        "type": "object",
+                        "properties": {
+                            "score": {"type": "number"},
+                            "explanation": {"type": "string"}
+                        },
+                        "required": ["score", "explanation"],
+                        "additionalProperties": False
+                    }
+                }
+            },
+            messages=[
+                {"role": "system", "content": "You are a financial scoring engine."},
+                {"role": "user", "content": prompt}
+            ]
         )
     except Exception as exc:
         raise HTTPException(status_code=502, detail=f"OpenAI request failed: {exc}")
 
-    # Direct JSON — no more parsing issues
-    parsed = response.choices[0].message.parsed
+    # `.parsed` contains GUARANTEED VALID JSON
+    try:
+        parsed = response.choices[0].message.parsed
+    except Exception:
+        raise HTTPException(
+            status_code=502,
+            detail="OpenAI response did not include parsed JSON (unexpected)"
+        )
 
-    # Validate shapes
+    # Score
     score_val = parsed.get("score", 0)
-    explanation = parsed.get("explanation", "")
-
     try:
         score_val = int(float(score_val))
-        score_val = max(0, min(100, score_val))
-    except Exception:
+    except:
         score_val = 0
+    score_val = max(0, min(100, score_val))
 
     return {
         "userId": payload.userId,
         "score": score_val,
-        "explanation": explanation
+        "explanation": parsed.get("explanation")
     }