Upload 35 files

app.py

@@ -1,347 +1,347 @@
-from __future__ import annotations
-
-import asyncio
-import threading
-from datetime import date, datetime, time, timedelta
-
-import sys
-from pathlib import Path
-
-from fastapi import BackgroundTasks, Query
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi import FastAPI
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from nifty_backend.runtime import (
-    CLOSE_REFRESH_READY,
-    IST,
-    TPLUS1_READY,
-    close_refresh_due,
-    dashboard_payload,
-    is_trading_day,
-    latest_saved_prediction,
-    latest_tplus1_prediction,
-    next_trading_day,
-    refresh_daily_data,
-    refresh_first5_prediction,
-    refresh_market_close_data,
-    seconds_until_next_ist_run,
-    warm_dashboard_payload_cache,
-)
-
-
-app = FastAPI(title="NIFTY 50 Forecaster Backend")
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=False,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-market_status = "Waiting for next session"
-close_refresh_lock = threading.Lock()
-MARKET_OPEN = time(9, 15)
-FIRST5_READY = time(9, 20)
-MARKET_CLOSE = time(15, 30)
-
-
-def refresh_market_close_data_if_due() -> dict:
-    if not close_refresh_due():
-        return {"status": "skipped", "reason": "close refresh is not due"}
-    if not close_refresh_lock.acquire(blocking=False):
-        return {"status": "skipped", "reason": "close refresh already running"}
-    try:
-        info = refresh_market_close_data()
-        return {"status": "refreshed", **info}
-    finally:
-        close_refresh_lock.release()
-
-
-def latest_prediction_date(payload: dict | None = None) -> date | None:
-    try:
-        latest = payload if payload is not None else latest_saved_prediction()
-        raw = latest.get("input_date")
-        return date.fromisoformat(str(raw)) if raw else None
-    except Exception:
-        return None
-
-
-def current_market_state(now: datetime | None = None) -> dict:
-    global market_status
-    now = now or datetime.now(IST)
-    today = now.date()
-    current_time = now.time()
-    trading_day = is_trading_day(today)
-    latest_date = latest_prediction_date()
-    market_is_open_for_t5 = trading_day and FIRST5_READY <= current_time < MARKET_CLOSE
-    market_is_open_for_tplus1 = trading_day and TPLUS1_READY <= current_time < MARKET_CLOSE
-    has_current_first5 = market_is_open_for_t5 and latest_date == today
-    try:
-        tplus1_latest_date = date.fromisoformat(str(latest_tplus1_prediction().get("input_date"))[:10])
-    except Exception:
-        tplus1_latest_date = None
-    has_current_tplus1 = market_is_open_for_tplus1 and tplus1_latest_date == today
-    next_session = today if trading_day and current_time < MARKET_CLOSE else next_trading_day(today + timedelta(days=1))
-
-    if not trading_day:
-        status = "Market Closed"
-        detail = f"Next trading session is {next_session.isoformat()}."
-    elif current_time < time(9, 0):
-        status = "Waiting for 9:00 AM"
-        detail = "Market has not entered pre-open yet."
-    elif current_time < MARKET_OPEN:
-        status = "Market Pre-Open"
-        detail = "Market opens at 9:15 AM IST."
-    elif current_time < FIRST5_READY:
-        status = "Market Officially Opened"
-        detail = "Waiting for the first 5 one-minute bars."
-    elif current_time <= MARKET_CLOSE:
-        if market_status in {"Fetching T+5 Prediction Data...", "Prediction Failed"}:
-            status = market_status
-            detail = "The first-five-minute prediction job is still resolving."
-        elif has_current_first5:
-            status = "Prediction Ready"
-            detail = "Today's first-five-minute prediction is available."
-        else:
-            status = "Prediction Pending"
-            detail = "No current-session prediction has been generated yet."
-    else:
-        status = "Market Closed"
-        detail = "Trading session has ended."
-
-    return {
-        "market_status": status,
-        "market_detail": detail,
-        "server_time_ist": now.isoformat(),
-        "is_trading_day": trading_day,
-        "session_date": today.isoformat(),
-        "next_session_date": next_session.isoformat(),
-        "latest_prediction_date": latest_date.isoformat() if latest_date else None,
-        "t5_available": has_current_first5,
-        "market_is_open_for_t5": market_is_open_for_t5,
-        "tplus1_available": has_current_tplus1,
-        "market_is_open_for_tplus1": market_is_open_for_tplus1,
-        "latest_tplus1_prediction_date": tplus1_latest_date.isoformat() if tplus1_latest_date else None,
-    }
-
-
-def attach_market_state(payload: dict) -> dict:
-    state = current_market_state()
-    payload.setdefault("data_status", {})
-    payload["data_status"].update(state)
-
-    t5_latest = payload.get("latest") or {}
-    tomorrow_latest = payload.get("tomorrow_latest") or {}
-    tplus1_latest = payload.get("tplus1_latest") or {}
-    t5_available = bool(state["t5_available"] and t5_latest.get("prediction"))
-    tplus1_available = bool(state["tplus1_available"] and tplus1_latest.get("prediction"))
-    market_closed = state["market_status"] == "Market Closed"
-    unavailable_reason = "Market Closed" if market_closed else state["market_status"]
-    tomorrow_available = bool(tomorrow_latest.get("prediction"))
-    refresh_phase = payload.get("data_status", {}).get("refresh_phase")
-    if refresh_phase in {"waiting_second_payload", "refreshing"}:
-        tomorrow_status = "WAITING FOR SECOND PAYLOAD"
-        tomorrow_reason = "Market close refresh is generating the next-session payload."
-    else:
-        tomorrow_status = "Ready" if tomorrow_available else "Pending"
-        tomorrow_reason = None if tomorrow_available else "No saved next-session signal is available."
-    payload["predictions"] = {
-        "tomorrow": {
-            "available": tomorrow_available,
-            "status": tomorrow_status,
-            "reason": tomorrow_reason,
-            "target_date": tomorrow_latest.get("target_date") or state["next_session_date"],
-            "input_date": tomorrow_latest.get("input_date"),
-            "prediction": tomorrow_latest.get("prediction") if tomorrow_available else None,
-            "prob_up": tomorrow_latest.get("prob_up") if tomorrow_available else None,
-            "confidence": tomorrow_latest.get("confidence") if tomorrow_available else None,
-            "threshold": tomorrow_latest.get("threshold") if tomorrow_available else None,
-            "model_name": tomorrow_latest.get("model_name"),
-            "source_model": tomorrow_latest.get("source_model"),
-            "validation_accuracy": tomorrow_latest.get("validation_accuracy"),
-            "test_accuracy": tomorrow_latest.get("test_accuracy"),
-        },
-        "t5": {
-            "available": t5_available,
-            "status": "Ready" if t5_available else unavailable_reason,
-            "reason": None if t5_available else state["market_detail"],
-            "input_date": t5_latest.get("input_date"),
-            "prediction": t5_latest.get("prediction") if t5_available else None,
-            "prob_up": t5_latest.get("prob_up") if t5_available else None,
-            "confidence": t5_latest.get("confidence") if t5_available else None,
-            "threshold": t5_latest.get("threshold") if t5_available else None,
-            "model_name": t5_latest.get("model_name"),
-            "validation_accuracy": (payload.get("summary") or {}).get("validation_accuracy"),
-            "test_accuracy": (payload.get("summary") or {}).get("test_accuracy"),
-        },
-        "tplus1": {
-            "available": tplus1_available,
-            "status": "Ready" if tplus1_available else unavailable_reason,
-            "reason": None if tplus1_available else state["market_detail"],
-            "target_date": tplus1_latest.get("target_date") or state["next_session_date"],
-            "input_date": tplus1_latest.get("input_date"),
-            "prediction": tplus1_latest.get("prediction") if tplus1_available else None,
-            "prob_up": tplus1_latest.get("prob_up") if tplus1_available else None,
-            "confidence": tplus1_latest.get("confidence") if tplus1_available else None,
-            "threshold": tplus1_latest.get("threshold") if tplus1_available else None,
-            "model_name": tplus1_latest.get("model_name"),
-            "validation_accuracy": (payload.get("tplus1_summary") or {}).get("validation_accuracy"),
-            "test_accuracy": (payload.get("tplus1_summary") or {}).get("test_accuracy"),
-        },
-    }
-    return payload
-
-
-async def daily_ist_refresh_loop() -> None:
-    global market_status
-    while True:
-        # Wait until 9:00 AM IST
-        await asyncio.sleep(seconds_until_next_ist_run(time(9, 0)))
-        if not is_trading_day(datetime.now(IST).date()):
-            market_status = "Market Closed"
-            continue
-        market_status = "Market Pre-Open"
-        print("[scheduler] 9:00 AM IST - Market Pre-Open", flush=True)
-
-        # Wait until 9:15 AM IST
-        await asyncio.sleep(seconds_until_next_ist_run(time(9, 15)))
-        market_status = "Market Officially Opened"
-        print("[scheduler] 9:15 AM IST - Market Officially Opened", flush=True)
-
-        # Wait until 9:20 AM IST
-        await asyncio.sleep(seconds_until_next_ist_run(time(9, 20)))
-        market_status = "Fetching T+5 Prediction Data..."
-        print("[scheduler] 9:20 AM IST - Fetching Data", flush=True)
-
-        try:
-            await asyncio.to_thread(refresh_first5_prediction)
-            market_status = "Prediction Ready"
-        except Exception as exc:
-            print(f"[scheduler] first5 refresh failed: {exc}", flush=True)
-            market_status = "Prediction Failed"
-            
-        try:
-            await asyncio.to_thread(refresh_daily_data)
-        except Exception as exc:
-            print(f"[scheduler] daily refresh failed: {exc}", flush=True)
-
-        await asyncio.sleep(seconds_until_next_ist_run(CLOSE_REFRESH_READY))
-        print("[scheduler] 3:45 PM IST - Refreshing close data", flush=True)
-        try:
-            info = await asyncio.to_thread(refresh_market_close_data_if_due)
-            print(f"[scheduler] close refresh result: {info}", flush=True)
-        except Exception as exc:
-            print(f"[scheduler] close refresh failed: {exc}", flush=True)
-
-
-async def refresh_current_session_once() -> None:
-    global market_status
-    now = datetime.now(IST)
-    if not is_trading_day(now.date()) or now.time() < FIRST5_READY:
-        return
-    if latest_prediction_date() == now.date():
-        return
-    market_status = "Fetching T+5 Prediction Data..."
-    print("[startup] Current session needs first-five refresh; fetching now.", flush=True)
-    try:
-        await asyncio.to_thread(refresh_first5_prediction)
-        market_status = "Prediction Ready"
-    except Exception as exc:
-        print(f"[startup] first5 refresh failed: {exc}", flush=True)
-        market_status = "Prediction Failed"
-    try:
-        await asyncio.to_thread(refresh_daily_data)
-    except Exception as exc:
-        print(f"[startup] daily refresh failed: {exc}", flush=True)
-
-
-async def refresh_market_close_once_if_due() -> None:
-    try:
-        info = await asyncio.to_thread(refresh_market_close_data_if_due)
-        if info.get("status") == "refreshed":
-            print(f"[startup] close refresh result: {info}", flush=True)
-    except Exception as exc:
-        print(f"[startup] close refresh failed: {exc}", flush=True)
-
-
-async def warm_dashboard_payload_cache_once() -> None:
-    try:
-        await asyncio.to_thread(warm_dashboard_payload_cache)
-    except Exception as exc:
-        print(f"[startup] dashboard payload warmup failed: {exc}", flush=True)
-
-
-@app.on_event("startup")
-async def start_scheduler() -> None:
-    global market_status
-    # Initialize correct status on startup based on current time
-    now = datetime.now(IST).time()
-    today = datetime.now(IST).date()
-    if not is_trading_day(today):
-        market_status = "Market Closed"
-    elif now < time(9, 0):
-        market_status = "Waiting for 9:00 AM"
-    elif now < time(9, 15):
-        market_status = "Market Pre-Open"
-    elif now < time(9, 20):
-        market_status = "Market Officially Opened"
-    elif latest_prediction_date() == today:
-        market_status = "Prediction Ready"
-    else:
-        market_status = "Prediction Pending"
-        
-    asyncio.create_task(refresh_current_session_once())
-    asyncio.create_task(refresh_market_close_once_if_due())
-    asyncio.create_task(warm_dashboard_payload_cache_once())
-    asyncio.create_task(daily_ist_refresh_loop())
-
-
-@app.get("/health")
-def health() -> dict[str, str]:
-    return {"status": "ok"}
-
-
-@app.get("/")
-def root() -> dict[str, str]:
-    return {"service": "NIFTY 50 Forecaster Backend", "status": "ok"}
-
-
-@app.get("/dashboard")
-def dashboard() -> dict:
-    return attach_market_state(dashboard_payload())
-
-
-@app.get("/cron/keepalive")
-def cron_keepalive(background_tasks: BackgroundTasks) -> dict:
-    close_refresh = {"status": "not_checked"}
-    if close_refresh_due():
-        background_tasks.add_task(refresh_market_close_data_if_due)
-        close_refresh = {"status": "scheduled"}
-    return {"status": "awake", "market": current_market_state(), "close_refresh": close_refresh}
-
-
-@app.get("/prediction/latest")
-def prediction_latest() -> dict:
-    return latest_saved_prediction()
-
-
-@app.post("/prediction/refresh-first5")
-def prediction_refresh_first5(
-    session_date: date | None = Query(default=None, description="Optional YYYY-MM-DD session date in IST."),
-) -> dict:
-    prediction = refresh_first5_prediction(session_date=session_date)
-    return prediction.to_dict()
-
-
-@app.post("/data/refresh-daily")
-def data_refresh_daily() -> dict:
-    return refresh_daily_data()
-
-
-@app.post("/data/refresh-market-close")
-def data_refresh_market_close(
-    session_date: date | None = Query(default=None, description="Optional YYYY-MM-DD session date in IST."),
-) -> dict:
-    return refresh_market_close_data(session_date=session_date)
+from __future__ import annotations
+
+import asyncio
+import threading
+from datetime import date, datetime, time, timedelta
+
+import sys
+from pathlib import Path
+
+from fastapi import BackgroundTasks, Query
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from nifty_backend.runtime import (
+    CLOSE_REFRESH_READY,
+    IST,
+    TPLUS1_READY,
+    close_refresh_due,
+    dashboard_payload,
+    is_trading_day,
+    latest_saved_prediction,
+    latest_tplus1_prediction,
+    next_trading_day,
+    refresh_daily_data,
+    refresh_first5_prediction,
+    refresh_market_close_data,
+    seconds_until_next_ist_run,
+    warm_dashboard_payload_cache,
+)
+
+
+app = FastAPI(title="NIFTY 50 Forecaster Backend")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+market_status = "Waiting for next session"
+close_refresh_lock = threading.Lock()
+MARKET_OPEN = time(9, 15)
+FIRST5_READY = time(9, 20)
+MARKET_CLOSE = time(15, 30)
+
+
+def refresh_market_close_data_if_due() -> dict:
+    if not close_refresh_due():
+        return {"status": "skipped", "reason": "close refresh is not due"}
+    if not close_refresh_lock.acquire(blocking=False):
+        return {"status": "skipped", "reason": "close refresh already running"}
+    try:
+        info = refresh_market_close_data()
+        return {"status": "refreshed", **info}
+    finally:
+        close_refresh_lock.release()
+
+
+def latest_prediction_date(payload: dict | None = None) -> date | None:
+    try:
+        latest = payload if payload is not None else latest_saved_prediction()
+        raw = latest.get("input_date")
+        return date.fromisoformat(str(raw)) if raw else None
+    except Exception:
+        return None
+
+
+def current_market_state(now: datetime | None = None) -> dict:
+    global market_status
+    now = now or datetime.now(IST)
+    today = now.date()
+    current_time = now.time()
+    trading_day = is_trading_day(today)
+    latest_date = latest_prediction_date()
+    market_is_open_for_t5 = trading_day and FIRST5_READY <= current_time < MARKET_CLOSE
+    market_is_open_for_tplus1 = trading_day and TPLUS1_READY <= current_time < MARKET_CLOSE
+    has_current_first5 = market_is_open_for_t5 and latest_date == today
+    try:
+        tplus1_latest_date = date.fromisoformat(str(latest_tplus1_prediction().get("input_date"))[:10])
+    except Exception:
+        tplus1_latest_date = None
+    has_current_tplus1 = market_is_open_for_tplus1 and tplus1_latest_date == today
+    next_session = today if trading_day and current_time < MARKET_CLOSE else next_trading_day(today + timedelta(days=1))
+
+    if not trading_day:
+        status = "Market Closed"
+        detail = f"Next trading session is {next_session.isoformat()}."
+    elif current_time < time(9, 0):
+        status = "Waiting for 9:00 AM"
+        detail = "Market has not entered pre-open yet."
+    elif current_time < MARKET_OPEN:
+        status = "Market Pre-Open"
+        detail = "Market opens at 9:15 AM IST."
+    elif current_time < FIRST5_READY:
+        status = "Market Officially Opened"
+        detail = "Waiting for the first 5 one-minute bars."
+    elif current_time <= MARKET_CLOSE:
+        if market_status in {"Fetching T+5 Prediction Data...", "Prediction Failed"}:
+            status = market_status
+            detail = "The first-five-minute prediction job is still resolving."
+        elif has_current_first5:
+            status = "Prediction Ready"
+            detail = "Today's first-five-minute prediction is available."
+        else:
+            status = "Prediction Pending"
+            detail = "No current-session prediction has been generated yet."
+    else:
+        status = "Market Closed"
+        detail = "Trading session has ended."
+
+    return {
+        "market_status": status,
+        "market_detail": detail,
+        "server_time_ist": now.isoformat(),
+        "is_trading_day": trading_day,
+        "session_date": today.isoformat(),
+        "next_session_date": next_session.isoformat(),
+        "latest_prediction_date": latest_date.isoformat() if latest_date else None,
+        "t5_available": has_current_first5,
+        "market_is_open_for_t5": market_is_open_for_t5,
+        "tplus1_available": has_current_tplus1,
+        "market_is_open_for_tplus1": market_is_open_for_tplus1,
+        "latest_tplus1_prediction_date": tplus1_latest_date.isoformat() if tplus1_latest_date else None,
+    }
+
+
+def attach_market_state(payload: dict) -> dict:
+    state = current_market_state()
+    payload.setdefault("data_status", {})
+    payload["data_status"].update(state)
+
+    t5_latest = payload.get("latest") or {}
+    tomorrow_latest = payload.get("tomorrow_latest") or {}
+    tplus1_latest = payload.get("tplus1_latest") or {}
+    t5_available = bool(state["t5_available"] and t5_latest.get("prediction"))
+    tplus1_available = bool(state["tplus1_available"] and tplus1_latest.get("prediction"))
+    market_closed = state["market_status"] == "Market Closed"
+    unavailable_reason = "Market Closed" if market_closed else state["market_status"]
+    tomorrow_available = bool(tomorrow_latest.get("prediction"))
+    refresh_phase = payload.get("data_status", {}).get("refresh_phase")
+    if refresh_phase in {"waiting_second_payload", "refreshing"}:
+        tomorrow_status = "WAITING FOR SECOND PAYLOAD"
+        tomorrow_reason = "Market close refresh is generating the next-session payload."
+    else:
+        tomorrow_status = "Ready" if tomorrow_available else "Pending"
+        tomorrow_reason = None if tomorrow_available else "No saved next-session signal is available."
+    payload["predictions"] = {
+        "tomorrow": {
+            "available": tomorrow_available,
+            "status": tomorrow_status,
+            "reason": tomorrow_reason,
+            "target_date": tomorrow_latest.get("target_date") or state["next_session_date"],
+            "input_date": tomorrow_latest.get("input_date"),
+            "prediction": tomorrow_latest.get("prediction") if tomorrow_available else None,
+            "prob_up": tomorrow_latest.get("prob_up") if tomorrow_available else None,
+            "confidence": tomorrow_latest.get("confidence") if tomorrow_available else None,
+            "threshold": tomorrow_latest.get("threshold") if tomorrow_available else None,
+            "model_name": tomorrow_latest.get("model_name"),
+            "source_model": tomorrow_latest.get("source_model"),
+            "validation_accuracy": tomorrow_latest.get("validation_accuracy"),
+            "test_accuracy": tomorrow_latest.get("test_accuracy"),
+        },
+        "t5": {
+            "available": t5_available,
+            "status": "Ready" if t5_available else unavailable_reason,
+            "reason": None if t5_available else state["market_detail"],
+            "input_date": t5_latest.get("input_date"),
+            "prediction": t5_latest.get("prediction") if t5_available else None,
+            "prob_up": t5_latest.get("prob_up") if t5_available else None,
+            "confidence": t5_latest.get("confidence") if t5_available else None,
+            "threshold": t5_latest.get("threshold") if t5_available else None,
+            "model_name": t5_latest.get("model_name"),
+            "validation_accuracy": (payload.get("summary") or {}).get("validation_accuracy"),
+            "test_accuracy": (payload.get("summary") or {}).get("test_accuracy"),
+        },
+        "tplus1": {
+            "available": tplus1_available,
+            "status": "Ready" if tplus1_available else unavailable_reason,
+            "reason": None if tplus1_available else state["market_detail"],
+            "target_date": tplus1_latest.get("target_date") or state["next_session_date"],
+            "input_date": tplus1_latest.get("input_date"),
+            "prediction": tplus1_latest.get("prediction") if tplus1_available else None,
+            "prob_up": tplus1_latest.get("prob_up") if tplus1_available else None,
+            "confidence": tplus1_latest.get("confidence") if tplus1_available else None,
+            "threshold": tplus1_latest.get("threshold") if tplus1_available else None,
+            "model_name": tplus1_latest.get("model_name"),
+            "validation_accuracy": (payload.get("tplus1_summary") or {}).get("validation_accuracy"),
+            "test_accuracy": (payload.get("tplus1_summary") or {}).get("test_accuracy"),
+        },
+    }
+    return payload
+
+
+async def daily_ist_refresh_loop() -> None:
+    global market_status
+    while True:
+        # Wait until 9:00 AM IST
+        await asyncio.sleep(seconds_until_next_ist_run(time(9, 0)))
+        if not is_trading_day(datetime.now(IST).date()):
+            market_status = "Market Closed"
+            continue
+        market_status = "Market Pre-Open"
+        print("[scheduler] 9:00 AM IST - Market Pre-Open", flush=True)
+
+        # Wait until 9:15 AM IST
+        await asyncio.sleep(seconds_until_next_ist_run(time(9, 15)))
+        market_status = "Market Officially Opened"
+        print("[scheduler] 9:15 AM IST - Market Officially Opened", flush=True)
+
+        # Wait until 9:20 AM IST
+        await asyncio.sleep(seconds_until_next_ist_run(time(9, 20)))
+        market_status = "Fetching T+5 Prediction Data..."
+        print("[scheduler] 9:20 AM IST - Fetching Data", flush=True)
+
+        try:
+            await asyncio.to_thread(refresh_first5_prediction)
+            market_status = "Prediction Ready"
+        except Exception as exc:
+            print(f"[scheduler] first5 refresh failed: {exc}", flush=True)
+            market_status = "Prediction Failed"
+            
+        try:
+            await asyncio.to_thread(refresh_daily_data)
+        except Exception as exc:
+            print(f"[scheduler] daily refresh failed: {exc}", flush=True)
+
+        await asyncio.sleep(seconds_until_next_ist_run(CLOSE_REFRESH_READY))
+        print("[scheduler] 3:45 PM IST - Refreshing close data", flush=True)
+        try:
+            info = await asyncio.to_thread(refresh_market_close_data_if_due)
+            print(f"[scheduler] close refresh result: {info}", flush=True)
+        except Exception as exc:
+            print(f"[scheduler] close refresh failed: {exc}", flush=True)
+
+
+async def refresh_current_session_once() -> None:
+    global market_status
+    now = datetime.now(IST)
+    if not is_trading_day(now.date()) or now.time() < FIRST5_READY:
+        return
+    if latest_prediction_date() == now.date():
+        return
+    market_status = "Fetching T+5 Prediction Data..."
+    print("[startup] Current session needs first-five refresh; fetching now.", flush=True)
+    try:
+        await asyncio.to_thread(refresh_first5_prediction)
+        market_status = "Prediction Ready"
+    except Exception as exc:
+        print(f"[startup] first5 refresh failed: {exc}", flush=True)
+        market_status = "Prediction Failed"
+    try:
+        await asyncio.to_thread(refresh_daily_data)
+    except Exception as exc:
+        print(f"[startup] daily refresh failed: {exc}", flush=True)
+
+
+async def refresh_market_close_once_if_due() -> None:
+    try:
+        info = await asyncio.to_thread(refresh_market_close_data_if_due)
+        if info.get("status") == "refreshed":
+            print(f"[startup] close refresh result: {info}", flush=True)
+    except Exception as exc:
+        print(f"[startup] close refresh failed: {exc}", flush=True)
+
+
+async def warm_dashboard_payload_cache_once() -> None:
+    try:
+        await asyncio.to_thread(warm_dashboard_payload_cache)
+    except Exception as exc:
+        print(f"[startup] dashboard payload warmup failed: {exc}", flush=True)
+
+
+@app.on_event("startup")
+async def start_scheduler() -> None:
+    global market_status
+    # Initialize correct status on startup based on current time
+    now = datetime.now(IST).time()
+    today = datetime.now(IST).date()
+    if not is_trading_day(today):
+        market_status = "Market Closed"
+    elif now < time(9, 0):
+        market_status = "Waiting for 9:00 AM"
+    elif now < time(9, 15):
+        market_status = "Market Pre-Open"
+    elif now < time(9, 20):
+        market_status = "Market Officially Opened"
+    elif latest_prediction_date() == today:
+        market_status = "Prediction Ready"
+    else:
+        market_status = "Prediction Pending"
+        
+    asyncio.create_task(refresh_current_session_once())
+    asyncio.create_task(refresh_market_close_once_if_due())
+    asyncio.create_task(warm_dashboard_payload_cache_once())
+    asyncio.create_task(daily_ist_refresh_loop())
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+@app.get("/")
+def root() -> dict[str, str]:
+    return {"service": "NIFTY 50 Forecaster Backend", "status": "ok"}
+
+
+@app.get("/dashboard")
+def dashboard() -> dict:
+    return attach_market_state(dashboard_payload())
+
+
+@app.get("/cron/keepalive")
+def cron_keepalive(background_tasks: BackgroundTasks) -> dict:
+    close_refresh = {"status": "not_checked"}
+    if close_refresh_due():
+        background_tasks.add_task(refresh_market_close_data_if_due)
+        close_refresh = {"status": "scheduled"}
+    return {"status": "awake", "market": current_market_state(), "close_refresh": close_refresh}
+
+
+@app.get("/prediction/latest")
+def prediction_latest() -> dict:
+    return latest_saved_prediction()
+
+
+@app.post("/prediction/refresh-first5")
+def prediction_refresh_first5(
+    session_date: date | None = Query(default=None, description="Optional YYYY-MM-DD session date in IST."),
+) -> dict:
+    prediction = refresh_first5_prediction(session_date=session_date)
+    return prediction.to_dict()
+
+
+@app.post("/data/refresh-daily")
+def data_refresh_daily() -> dict:
+    return refresh_daily_data()
+
+
+@app.post("/data/refresh-market-close")
+def data_refresh_market_close(
+    session_date: date | None = Query(default=None, description="Optional YYYY-MM-DD session date in IST."),
+) -> dict:
+    return refresh_market_close_data(session_date=session_date)