Upload 35 files

app.py

@@ -15,10 +15,12 @@ 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,
@@ -74,7 +76,13 @@ def current_market_state(now: datetime | None = None) -> dict:
     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:
@@ -113,6 +121,9 @@ def current_market_state(now: datetime | None = None) -> dict:
         "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,
     }
 
 
@@ -123,7 +134,9 @@ def attach_market_state(payload: dict) -> dict:
 
     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"))
@@ -163,6 +176,20 @@ def attach_market_state(payload: dict) -> dict:
             "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
 

data/tplus1_test_predictions.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd7f63239d5705969cbe5423169c9fdcb88d59b838b02913d0aa5c455a7ca41c
+size 13681

models/nifty_1420_tplus1_logistic_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:77fea2ef4be30e6355377c1badadc94e9cb941fb62a31e731fad83b0f171c63e
+size 5321

models/tplus1_latest_prediction.csv

@@ -0,0 +1,2 @@
+input_date,target_date,forecast_for,prediction,prob_up,confidence,threshold,model_name,decision_overlay,validation_accuracy,test_accuracy,accuracy_goal
+2026-05-21,2026-05-22,next trading session after 2026-05-21,UP,0.620604654276822,0.620604654276822,0.578,logistic_regression_l1_C0.35_balanced,prev_target_mean10_le_0.4_up;m02_range_1m_ge_0.000479116_up,0.66,0.6368421052631579,0.63

models/tplus1_summary.json

@@ -0,0 +1,37 @@
+{
+  "target": "T+1 NIFTY 50 close greater than T 14:20 close",
+  "exchange_instrument": "NSE NIFTY 50 index",
+  "window_start": "14:00",
+  "window_end": "14:20",
+  "lookback_days_requested": 1000,
+  "supervised_rows": 1000,
+  "train_rows": 660,
+  "valid_rows": 150,
+  "test_rows": 190,
+  "train_start": "2022-04-28",
+  "train_end": "2024-12-31",
+  "valid_start": "2025-01-01",
+  "valid_end": "2025-08-06",
+  "test_start": "2025-08-07",
+  "test_end": "2026-05-20",
+  "model_name": "logistic_regression_l1_C0.35_balanced",
+  "threshold": 0.578,
+  "validation_accuracy": 0.66,
+  "test_accuracy": 0.6368421052631579,
+  "baseline_test_accuracy": 0.5052631578947369,
+  "validation_auc": 0.5085348506401137,
+  "test_auc": 0.54864804964539,
+  "test_log_loss": 0.715200083567372,
+  "test_brier": 0.2580990249203714,
+  "accuracy_goal": 0.63,
+  "accuracy_goal_met_on_test": true,
+  "feature_count": 40,
+  "latest_input_date": "2026-05-21",
+  "latest_window_rows": 21,
+  "latest_forecast_for": "next trading session after 2026-05-21",
+  "latest_prob_up": 0.620604654276822,
+  "latest_prediction": "UP",
+  "latest_confidence": 0.620604654276822,
+  "decision_overlay": "prev_target_mean10_le_0.4_up;m02_range_1m_ge_0.000479116_up",
+  "top_features": 40
+}

nifty_backend/runtime.py

@@ -26,6 +26,7 @@ IST = ZoneInfo("Asia/Kolkata")
 YAHOO_NIFTY_SYMBOL = "^NSEI"
 MARKET_CLOSE = time(15, 30)
 CLOSE_REFRESH_READY = time(15, 45)
+TPLUS1_READY = time(14, 30)
 BACKEND_ROOT = Path(__file__).resolve().parents[1]
 DATA_DIR = BACKEND_ROOT / "data"
 MODEL_DIR = BACKEND_ROOT / "models"
@@ -39,6 +40,10 @@ TOMORROW_MODEL_PATH = MODEL_DIR / "nifty_tomorrow_direction_model.joblib"
 TOMORROW_LATEST_PATH = MODEL_DIR / "tomorrow_latest_prediction.csv"
 TOMORROW_SUMMARY_PATH = MODEL_DIR / "tomorrow_summary.json"
 TOMORROW_TEST_PREDICTIONS_PATH = DATA_DIR / "tomorrow_test_predictions.parquet"
+TPLUS1_MODEL_PATH = MODEL_DIR / "nifty_1420_tplus1_logistic_model.joblib"
+TPLUS1_LATEST_PATH = MODEL_DIR / "tplus1_latest_prediction.csv"
+TPLUS1_SUMMARY_PATH = MODEL_DIR / "tplus1_summary.json"
+TPLUS1_TEST_PREDICTIONS_PATH = DATA_DIR / "tplus1_test_predictions.parquet"
 REFRESH_STATE_PATH = MODEL_DIR / "refresh_state.json"
 REFRESH_WAITING = "waiting_second_payload"
 REFRESH_REFRESHING = "refreshing"
@@ -522,6 +527,194 @@ def latest_tomorrow_prediction() -> dict[str, Any]:
     }
 
 
+def load_tplus1_summary() -> dict[str, Any]:
+    if TPLUS1_SUMMARY_PATH.exists():
+        return json.loads(TPLUS1_SUMMARY_PATH.read_text(encoding="utf-8"))
+    return {
+        "model_name": "logistic_regression_l1_C0.35_balanced",
+        "target": "T+1 NIFTY 50 close greater than T 14:20 close",
+        "window_start": "14:00",
+        "window_end": "14:20",
+        "threshold": 0.578,
+        "validation_accuracy": 0.66,
+        "test_accuracy": 0.6368421052631579,
+        "baseline_test_accuracy": 0.5052631578947369,
+        "test_rows": 190,
+        "feature_count": 40,
+    }
+
+
+def latest_tplus1_prediction() -> dict[str, Any]:
+    if TPLUS1_LATEST_PATH.exists():
+        row = pd.read_csv(TPLUS1_LATEST_PATH).iloc[-1].to_dict()
+        return {k: (None if pd.isna(v) else v) for k, v in row.items()}
+    summary = load_tplus1_summary()
+    return {
+        "input_date": summary.get("latest_input_date"),
+        "target_date": None,
+        "forecast_for": summary.get("latest_forecast_for"),
+        "prediction": summary.get("latest_prediction"),
+        "prob_up": summary.get("latest_prob_up"),
+        "confidence": summary.get("latest_confidence"),
+        "threshold": summary.get("threshold"),
+        "model_name": summary.get("model_name", "logistic_regression_l1_C0.35_balanced"),
+        "validation_accuracy": summary.get("validation_accuracy"),
+        "test_accuracy": summary.get("test_accuracy"),
+    }
+
+
+def _minute_frame_for_tplus1() -> pd.DataFrame:
+    minute = pd.read_parquet(NIFTY_1M_PATH)
+    minute = minute.copy()
+    minute["dt"] = pd.to_datetime(minute["date"], errors="coerce")
+    for col in ("open", "high", "low", "close", "volume"):
+        if col in minute.columns:
+            minute[col] = pd.to_numeric(minute[col], errors="coerce")
+    minute = minute.dropna(subset=["dt", "open", "high", "low", "close"]).sort_values("dt").reset_index(drop=True)
+    minute["session_date"] = minute["dt"].dt.normalize()
+    minute["time"] = minute["dt"].dt.strftime("%H:%M")
+    return minute
+
+
+def _build_tplus1_session_features(minute: pd.DataFrame) -> pd.DataFrame:
+    window = minute[(minute["time"] >= "14:00") & (minute["time"] <= "14:20")].copy()
+    window["minute_offset"] = window.groupby("session_date", sort=True).cumcount()
+    grouped = window.groupby("session_date", sort=True)
+    base = grouped.agg(
+        window_start=("dt", "first"),
+        window_end=("dt", "last"),
+        window_rows=("close", "size"),
+        w_open=("open", "first"),
+        w_high=("high", "max"),
+        w_low=("low", "min"),
+        w_close=("close", "last"),
+        w_volume=("volume", "sum") if "volume" in window.columns else ("close", "size"),
+    ).reset_index().rename(columns={"session_date": "date"})
+    base = base[base["window_rows"] == 21].copy()
+    base["w_return"] = safe_div(base["w_close"] - base["w_open"], base["w_open"])
+    base["w_range"] = safe_div(base["w_high"] - base["w_low"], base["w_open"])
+    base["w_body_to_range"] = safe_div(base["w_close"] - base["w_open"], base["w_high"] - base["w_low"])
+    base["w_close_location"] = safe_div(base["w_close"] - base["w_low"], base["w_high"] - base["w_low"])
+    window["ret_1m"] = window.groupby("session_date")["close"].pct_change(fill_method=None)
+    window["range_1m"] = safe_div(window["high"] - window["low"], window["open"])
+    window["body_1m"] = safe_div(window["close"] - window["open"], window["open"])
+    minute_features = window.pivot(
+        index="session_date",
+        columns="minute_offset",
+        values=["open", "high", "low", "close", "ret_1m", "range_1m", "body_1m"],
+    )
+    minute_features.columns = [f"m{int(offset):02d}_{field}" for field, offset in minute_features.columns]
+    minute_features = minute_features.reset_index().rename(columns={"session_date": "date"})
+    session_close = (
+        minute.groupby("session_date", sort=True)
+        .agg(day_close=("close", "last"))
+        .reset_index()
+        .rename(columns={"session_date": "date"})
+    )
+    frame = base.merge(minute_features, on="date", how="left").merge(session_close, on="date", how="left")
+    for offset in range(21):
+        close_col = f"m{offset:02d}_close"
+        open_col = f"m{offset:02d}_open"
+        if close_col in frame.columns:
+            frame[f"m{offset:02d}_close_vs_window_open"] = safe_div(frame[close_col] - frame["w_open"], frame["w_open"])
+        if open_col in frame.columns and close_col in frame.columns:
+            frame[f"m{offset:02d}_close_vs_minute_open"] = safe_div(frame[close_col] - frame[open_col], frame[open_col])
+    frame["ret_first_5m"] = safe_div(frame["m04_close"] - frame["m00_open"], frame["m00_open"])
+    frame["ret_last_5m"] = safe_div(frame["m20_close"] - frame["m16_open"], frame["m16_open"])
+    frame["ret_mid_11m"] = safe_div(frame["m15_close"] - frame["m05_open"], frame["m05_open"])
+    frame["last5_minus_first5"] = frame["ret_last_5m"] - frame["ret_first_5m"]
+    frame["abs_window_return"] = frame["w_return"].abs()
+    frame["dow"] = frame["date"].dt.dayofweek
+    frame["dom"] = frame["date"].dt.day
+    frame["month"] = frame["date"].dt.month
+    return frame.sort_values("date").reset_index(drop=True)
+
+
+def _add_tplus1_target_features(features: pd.DataFrame) -> pd.DataFrame:
+    frame = features.copy()
+    frame["target_date"] = frame["date"].shift(-1)
+    frame["target_close"] = frame["day_close"].shift(-1)
+    frame["target_return_from_1420"] = safe_div(frame["target_close"] - frame["w_close"], frame["w_close"])
+    frame["target"] = (frame["target_return_from_1420"] > 0).astype("float64")
+    frame.loc[frame["target_close"].isna(), "target"] = np.nan
+    for lag in (1, 2, 3, 5, 10):
+        frame[f"prev_target_lag{lag}"] = frame["target"].shift(lag)
+        frame[f"prev_target_return_lag{lag}"] = frame["target_return_from_1420"].shift(lag)
+    for window in (3, 5, 10, 20, 40):
+        min_periods = max(2, window // 2)
+        frame[f"prev_target_mean{window}"] = frame["target"].shift(1).rolling(window, min_periods=min_periods).mean()
+        shifted_return = frame["target_return_from_1420"].shift(1)
+        frame[f"prev_target_return_mean{window}"] = shifted_return.rolling(window, min_periods=min_periods).mean()
+        frame[f"prev_target_return_std{window}"] = shifted_return.rolling(window, min_periods=min_periods).std()
+    return frame
+
+
+def _apply_tplus1_overlays(pred: np.ndarray, frame: pd.DataFrame, overlays: list[dict[str, Any]]) -> np.ndarray:
+    adjusted = np.asarray(pred, dtype="int64").copy()
+    for overlay in overlays:
+        feature = str(overlay.get("feature", ""))
+        if feature not in frame.columns:
+            continue
+        series = pd.to_numeric(frame[feature], errors="coerce")
+        value = float(overlay.get("value", 0.0))
+        if overlay.get("op") == "<=":
+            mask = (series <= value).fillna(False).to_numpy(dtype=bool)
+        else:
+            mask = (series >= value).fillna(False).to_numpy(dtype=bool)
+        action = overlay.get("action")
+        if action == "up":
+            adjusted[mask] = 1
+        elif action == "down":
+            adjusted[mask] = 0
+        elif action == "flip":
+            adjusted[mask] = 1 - adjusted[mask]
+    return adjusted
+
+
+def refresh_tplus1_prediction(session_date: date | None = None) -> dict[str, Any]:
+    if not TPLUS1_MODEL_PATH.exists():
+        raise FileNotFoundError(f"Missing T+1 model artifact: {TPLUS1_MODEL_PATH}")
+    payload = joblib.load(TPLUS1_MODEL_PATH)
+    features = payload["features"]
+    threshold = float(payload["threshold"])
+    frame = _add_tplus1_target_features(_build_tplus1_session_features(_minute_frame_for_tplus1()))
+    if session_date is not None:
+        row = frame[pd.to_datetime(frame["date"], errors="coerce").dt.date == session_date].tail(1)
+    else:
+        row = frame.tail(1)
+    if row.empty:
+        raise RuntimeError("No complete 14:00-14:20 window is available for T+1 prediction.")
+    missing = [col for col in features if col not in row.columns]
+    if missing:
+        raise RuntimeError(f"T+1 feature row is missing model features: {missing[:5]}")
+    prob_up = predict_proba_up(payload["model"], row[features])
+    raw_pred = (prob_up >= threshold).astype("int64")
+    overlay_payload = payload.get("decision_overlay")
+    overlays = overlay_payload.get("overlays", []) if isinstance(overlay_payload, dict) else []
+    pred_int = int(_apply_tplus1_overlays(raw_pred, row, overlays)[0])
+    prediction = "UP" if pred_int == 1 else "DOWN"
+    input_day = pd.to_datetime(row["date"].iloc[0]).date()
+    target_day = next_trading_day(input_day + timedelta(days=1))
+    summary = load_tplus1_summary()
+    out = {
+        "input_date": input_day.isoformat(),
+        "target_date": target_day.isoformat(),
+        "forecast_for": f"next trading session after {input_day.isoformat()}",
+        "prediction": prediction,
+        "prob_up": float(prob_up[0]),
+        "confidence": float(max(prob_up[0], 1.0 - prob_up[0])),
+        "threshold": threshold,
+        "model_name": str(payload.get("model_name", summary.get("model_name", "nifty_1420_tplus1_logistic_model"))),
+        "decision_overlay": summary.get("decision_overlay"),
+        "validation_accuracy": summary.get("validation_accuracy"),
+        "test_accuracy": summary.get("test_accuracy"),
+        "accuracy_goal": summary.get("accuracy_goal"),
+    }
+    pd.DataFrame([out]).to_csv(TPLUS1_LATEST_PATH, index=False)
+    clear_dashboard_payload_cache()
+    return out
+
+
 def _tomorrow_probability_from_daily(daily: pd.DataFrame, fallback_prob: float) -> float:
     if daily.empty or len(daily) < 5:
         return float(fallback_prob)
@@ -630,6 +823,16 @@ def load_tomorrow_test_predictions() -> pd.DataFrame:
     return df.sort_values(sort_col).reset_index(drop=True)
 
 
+def load_tplus1_test_predictions() -> pd.DataFrame:
+    if not TPLUS1_TEST_PREDICTIONS_PATH.exists():
+        return pd.DataFrame()
+    df = pd.read_parquet(TPLUS1_TEST_PREDICTIONS_PATH)
+    for col in ("date", "target_date"):
+        if col in df.columns:
+            df[col] = pd.to_datetime(df[col], errors="coerce")
+    return df.sort_values("date").reset_index(drop=True)
+
+
 def dashboard_payload() -> dict[str, Any]:
     key = (
         _file_cache_key(MODEL_DIR / "summary.json"),
@@ -639,6 +842,10 @@ def dashboard_payload() -> dict[str, Any]:
         _file_cache_key(TOMORROW_LATEST_PATH),
         _file_cache_key(TOMORROW_TEST_PREDICTIONS_PATH),
         _file_cache_key(TOMORROW_MODEL_PATH),
+        _file_cache_key(TPLUS1_SUMMARY_PATH),
+        _file_cache_key(TPLUS1_LATEST_PATH),
+        _file_cache_key(TPLUS1_TEST_PREDICTIONS_PATH),
+        _file_cache_key(TPLUS1_MODEL_PATH),
         _file_cache_key(REFRESH_STATE_PATH),
         _file_cache_key(NIFTY_1D_PATH),
         _file_cache_key(OPENING_DATASET_PATH),
@@ -659,9 +866,12 @@ def _dashboard_payload_cached(key: tuple[tuple[str, int | None, int | None], ...
     t5_latest = _latest_saved_prediction_uncached()
     tomorrow_summary = load_tomorrow_summary()
     tomorrow_latest = latest_tomorrow_prediction()
+    tplus1_summary = load_tplus1_summary()
+    tplus1_latest = latest_tplus1_prediction()
     refresh_state = load_refresh_state()
     t5_test = load_test_predictions()
     tomorrow_test = load_tomorrow_test_predictions()
+    tplus1_test = load_tplus1_test_predictions()
     daily = pd.read_parquet(NIFTY_1D_PATH)
     daily["date"] = pd.to_datetime(daily["date"], errors="coerce")
     daily = daily.sort_values("date").tail(180)
@@ -706,6 +916,16 @@ def _dashboard_payload_cached(key: tuple[tuple[str, int | None, int | None], ...
             "recent_accuracy": tomorrow_accuracy,
             "test_rows": int(tomorrow_summary.get("n_test") or len(tomorrow_test) or 0),
         },
+        {
+            "id": "tplus1",
+            "label": "T+1",
+            "model_name": tplus1_summary.get("model_name", "nifty_1420_tplus1_logistic_model"),
+            "source_model": "14:00-14:20 logistic forecaster",
+            "validation_accuracy": tplus1_summary.get("validation_accuracy"),
+            "test_accuracy": tplus1_summary.get("test_accuracy"),
+            "recent_accuracy": float(tplus1_test.tail(40)["correct"].mean()) if not tplus1_test.empty and "correct" in tplus1_test.columns else tplus1_summary.get("test_accuracy"),
+            "test_rows": int(tplus1_summary.get("test_rows") or len(tplus1_test) or 0),
+        },
         {
             "id": "t5",
             "label": "T+5",
@@ -733,9 +953,11 @@ def _dashboard_payload_cached(key: tuple[tuple[str, int | None, int | None], ...
     return {
         "latest": t5_latest,
         "tomorrow_latest": tomorrow_latest,
+        "tplus1_latest": tplus1_latest,
         "metrics": metrics,
         "summary": summary,
         "tomorrow_summary": tomorrow_summary,
+        "tplus1_summary": tplus1_summary,
         "candidates": load_candidate_results(),
         "charts": {
             "daily_close": _json_ready_frame(daily[["date", "open", "high", "low", "close"]]),
@@ -745,6 +967,7 @@ def _dashboard_payload_cached(key: tuple[tuple[str, int | None, int | None], ...
             "recent_predictions": _json_ready_frame(recent_predictions),
             "t5_recent_predictions": _json_ready_frame(recent_predictions),
             "tomorrow_recent_predictions": _json_ready_frame(tomorrow_recent),
+            "tplus1_recent_predictions": _json_ready_frame(tplus1_test.tail(40)),
         },
         "data_status": {
             "nifty_1m_rows": int(len(pd.read_parquet(NIFTY_1M_PATH, columns=["date"]))),
@@ -752,6 +975,7 @@ def _dashboard_payload_cached(key: tuple[tuple[str, int | None, int | None], ...
             "training_rows": int(len(dataset)),
             "test_prediction_rows": int(len(t5_test)),
             "tomorrow_test_prediction_rows": int(len(tomorrow_test)),
+            "tplus1_test_prediction_rows": int(len(tplus1_test)),
             "latest_daily_date": pd.to_datetime(daily["date"]).max().date().isoformat(),
             "refresh_phase": refresh_state.get("phase", REFRESH_NORMAL),
             "refresh_state": refresh_state,
@@ -853,6 +1077,7 @@ def refresh_market_close_data(session_date: date | None = None) -> dict[str, Any
         minute_frame = append_parquet_rows(NIFTY_1M_PATH, minutes, ["date"])
         daily_info = refresh_daily_data()
         t5_prediction = refresh_first5_prediction(session_date=session_date, minutes=minutes)
+        tplus1_prediction = refresh_tplus1_prediction(session_date=session_date)
         outcomes = update_opening_outcomes_from_daily()
         tomorrow_prediction = refresh_tomorrow_prediction(session_date=session_date)
         state = save_refresh_state(REFRESH_READY, session_date=session_date)
@@ -864,6 +1089,7 @@ def refresh_market_close_data(session_date: date | None = None) -> dict[str, Any
             "daily": daily_info,
             "opening_dataset": outcomes,
             "t5_prediction": t5_prediction.to_dict(),
+            "tplus1_prediction": tplus1_prediction,
             "tomorrow_prediction": tomorrow_prediction,
             "refresh_state": state,
         }