Update app.py to serve index.html and improve API

app.py

@@ -1,136 +1,100 @@
+import json
 import logging
-from fastapi import FastAPI
-from datasets import load_dataset
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
 import pandas as pd
 import numpy as np
+import os
 
-# -------------------------------------------------
-# Logging configuration
-# -------------------------------------------------
+app = FastAPI()
+
+# ---------------------------------------------------------
+# Logging
+# ---------------------------------------------------------
 logging.basicConfig(
     level=logging.INFO,
-    format="%(asctime)s | %(levelname)s | %(message)s"
+    format="%(asctime)s [%(levelname)s] %(message)s"
 )
 logger = logging.getLogger(__name__)
 
-app = FastAPI()
-
-# -------------------------------------------------
-# Lazy dataset cache
-# -------------------------------------------------
-DF = None
-
-
-def load_data_once():
-    """
-    Load the dataset only once using streaming mode.
-    Hugging Face Spaces cannot download large datasets at startup,
-    so streaming=True avoids timeouts and memory issues.
-    """
-    global DF
-
-    if DF is None:
-        logger.info("Loading dataset (streaming mode): kurry/sp500_earnings_transcripts ...")
-
-        ds = load_dataset(
-            "kurry/sp500_earnings_transcripts",
-            split="train",
-            streaming=True
-        )
-
-        # Convert streaming dataset → pandas DataFrame
-        # Limit rows to avoid memory overload
-        rows = []
-        for i, item in enumerate(ds):
-            rows.append(item)
-            if i > 5000:   # Safety limit for Spaces
-                break
-
-        DF = pd.DataFrame(rows)
-        logger.info(f"Loaded {len(DF)} rows into DataFrame")
-
-    return DF
-
+# ---------------------------------------------------------
+# CORS (optional but useful for frontend)
+# ---------------------------------------------------------
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-# -------------------------------------------------
-# Utility: convert NumPy → Python
-# -------------------------------------------------
-def to_python(obj):
+# ---------------------------------------------------------
+# Lazy-loaded dataset
+# ---------------------------------------------------------
+DATASET_PATH = "transcripts.csv"   # change if needed
+df_cache = None
+
+def load_dataset():
+    global df_cache
+    if df_cache is None:
+        logger.info("Loading dataset...")
+        if not os.path.exists(DATASET_PATH):
+            raise FileNotFoundError(f"Dataset not found: {DATASET_PATH}")
+        df_cache = pd.read_csv(DATASET_PATH)
+        logger.info(f"Dataset loaded with {len(df_cache)} rows.")
+    return df_cache
+
+# ---------------------------------------------------------
+# JSON-safe conversion
+# ---------------------------------------------------------
+def to_json_safe(obj):
     if isinstance(obj, (np.integer, np.int64)):
         return int(obj)
     if isinstance(obj, (np.floating, np.float64)):
         return float(obj)
-    if isinstance(obj, (np.bool_,)):
-        return bool(obj)
-    if isinstance(obj, pd.Timestamp):
-        return obj.isoformat()
+    if isinstance(obj, (np.ndarray, list)):
+        return [to_json_safe(x) for x in obj]
+    if isinstance(obj, dict):
+        return {k: to_json_safe(v) for k, v in obj.items()}
     return obj
 
-
-def clean_dict(d):
-    return {k: to_python(v) for k, v in d.items()}
-
-
-# -------------------------------------------------
-# Routes
-# -------------------------------------------------
-
-@app.on_event("startup")
-def startup_event():
-    logger.info("🚀 Earnings Transcript API starting up")
-
-
-@app.get("/")
-def root():
-    logger.info("Root endpoint called")
-    return {"message": "Earnings Transcript API is running"}
-
-
+# ---------------------------------------------------------
+# Serve index.html at "/"
+# ---------------------------------------------------------
+@app.get("/", response_class=HTMLResponse)
+def serve_index():
+    if not os.path.exists("index.html"):
+        return "<h1>index.html not found</h1>"
+    with open("index.html", "r") as f:
+        return f.read()
+
+# ---------------------------------------------------------
+# List all tickers
+# ---------------------------------------------------------
 @app.get("/tickers")
-def list_tickers():
-    logger.info("Listing all tickers")
-    df = load_data_once()
-
-    if "symbol" not in df.columns:
-        return {"error": "Dataset does not contain 'symbol' column"}
-
-    tickers = sorted(df["symbol"].dropna().unique().tolist())
-    logger.info(f"Returned {len(tickers)} tickers")
+def get_tickers():
+    df = load_dataset()
+    tickers = sorted(df["symbol"].unique().tolist())
     return {"tickers": tickers}
 
-
+# ---------------------------------------------------------
+# Get transcript for a symbol
+# ---------------------------------------------------------
 @app.get("/transcript/{symbol}")
 def get_transcript(symbol: str):
-    logger.info(f"Transcript request received for symbol: {symbol}")
+    df = load_dataset()
 
-    df = load_data_once()
     symbol = symbol.upper()
+    logger.info(f"Fetching transcript for: {symbol}")
 
-    if "symbol" not in df.columns:
-        return {"error": "Dataset missing 'symbol' column"}
-
-    rows = df[df["symbol"] == symbol]
-
-    if rows.empty:
-        logger.warning(f"No transcripts found for symbol: {symbol}")
-        return {"error": f"No transcripts found for symbol {symbol}"}
-
-    row = rows.iloc[0]
-    base_info = clean_dict(row.to_dict())
+    subset = df[df["symbol"] == symbol]
 
-    # Extract structured content (correct column name)
-    segments = row.get("structured_content", None)
+    if subset.empty:
+        raise HTTPException(status_code=404, detail=f"No transcript found for {symbol}")
 
-    if isinstance(segments, list):
-        logger.info(f"Cleaning {len(segments)} segments for {symbol}")
-        cleaned_segments = [
-            clean_dict(seg) for seg in segments if isinstance(seg, dict)
-        ]
-        base_info["segments"] = cleaned_segments
-    else:
-        logger.info(f"No structured_content found for {symbol}")
-        base_info["segments"] = []
+    # Convert each row to JSON-safe dict
+    records = subset.to_dict(orient="records")
+    safe_records = [to_json_safe(r) for r in records]
 
-    logger.info(f"Returning transcript for {symbol}")
-    return base_info
+    return {"symbol": symbol, "records": safe_records}