Upload 42 files

app.py

@@ -452,18 +452,6 @@ def kotak_account() -> dict:
         raise HTTPException(status_code=502, detail=str(exc)) from exc
 
 
-@app.get("/kotak/nifty50-quote")
-def kotak_nifty50_quote() -> dict:
-    try:
-        return kotak_neo_manager.fetch_nifty50_quote()
-    except KotakNeoConfigError as exc:
-        raise HTTPException(status_code=503, detail=str(exc)) from exc
-    except KotakNeoSessionRequired as exc:
-        raise HTTPException(status_code=401, detail=str(exc)) from exc
-    except KotakNeoError as exc:
-        raise HTTPException(status_code=502, detail=str(exc)) from exc
-
-
 @app.get("/kotak/activity-log")
 def kotak_activity_log() -> dict:
     try:

kotak_neo.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import os
 import threading
-import time
 from csv import DictReader
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timezone
@@ -23,7 +22,6 @@ DEFAULT_TIMEOUT_SECONDS = 20
 ACCOUNT_TIMEOUT_SECONDS = 7
 DATA_DIR = Path(__file__).resolve().parent / "data"
 KOTAK_ACTIVITY_LOG_PATH = DATA_DIR / "kotak_activity_log.txt"
-NIFTY50_QUOTE_CACHE_SECONDS = 1.0
 
 
 class KotakNeoError(Exception):
@@ -135,9 +133,6 @@ class KotakNeoManager:
         self.activity_log_path.parent.mkdir(parents=True, exist_ok=True)
         self._seen_activity_keys: set[str] = set()
         self._scrip_cache: dict[str, list[dict[str, str]]] = {}
-        self._quote_cache_lock = threading.Lock()
-        self._nifty50_quote_cache: dict[str, Any] | None = None
-        self._nifty50_quote_cached_at = 0.0
         self._load_existing_activity_keys()
         self._clear_session_locked()
 
@@ -381,42 +376,6 @@ class KotakNeoManager:
             "quotes": list(quote_map.values()),
         }
 
-    def fetch_nifty50_quote(self, *, max_age_seconds: float = NIFTY50_QUOTE_CACHE_SECONDS) -> dict[str, Any]:
-        if not self._configured():
-            raise KotakNeoConfigError("Kotak Neo environment variables are incomplete.")
-
-        with self._lock:
-            context = self._context_locked()
-            cached = self._nifty50_quote_cache
-            cached_at = self._nifty50_quote_cached_at
-        cache_age = time.monotonic() - cached_at
-        if cached and cache_age < max_age_seconds:
-            return {
-                **cached,
-                "cache": {"hit": True, "max_age_seconds": max_age_seconds, "age_seconds": round(cache_age, 3)},
-            }
-
-        with self._quote_cache_lock:
-            with self._lock:
-                context = self._context_locked()
-                cached = self._nifty50_quote_cache
-                cached_at = self._nifty50_quote_cached_at
-            cache_age = time.monotonic() - cached_at
-            if cached and cache_age < max_age_seconds:
-                return {
-                    **cached,
-                    "cache": {"hit": True, "max_age_seconds": max_age_seconds, "age_seconds": round(cache_age, 3)},
-                }
-
-            fresh_quote = self._fetch_nifty50_quote_with_context(context)
-            with self._lock:
-                self._nifty50_quote_cache = fresh_quote
-                self._nifty50_quote_cached_at = time.monotonic()
-            return {
-                **fresh_quote,
-                "cache": {"hit": False, "max_age_seconds": max_age_seconds, "age_seconds": 0.0},
-            }
-
     def _ensure_authenticated_locked(self) -> None:
         if not self.edit_token or not self.edit_sid or not self.base_url:
             raise KotakNeoSessionRequired("Kotak Neo session is not authenticated.")
@@ -532,143 +491,6 @@ class KotakNeoManager:
             timeout=DEFAULT_TIMEOUT_SECONDS,
         )
 
-    def _fetch_nifty50_quote_with_context(self, context: dict[str, str]) -> dict[str, Any]:
-        candidates = self._nifty50_quote_candidates(context)
-        errors: list[str] = []
-
-        for candidate in candidates:
-            try:
-                payload = self._fetch_quotes_with_context(
-                    context,
-                    [
-                        {
-                            "exchange_segment": candidate["exchange_segment"],
-                            "instrument_token": candidate["instrument_token"],
-                        }
-                    ],
-                    timeout=ACCOUNT_TIMEOUT_SECONDS,
-                )
-                items = _extract_items(payload)
-                if not items:
-                    errors.append(
-                        f"{candidate['lookup_source']}: quotes returned no items for {candidate['instrument_token']}"
-                    )
-                    continue
-                normalized = self._normalize_nifty50_quote(items[0], candidate)
-                if normalized.get("price") is None:
-                    errors.append(
-                        f"{candidate['lookup_source']}: quote payload did not include a usable last traded price"
-                    )
-                    continue
-                return normalized
-            except KotakNeoError as exc:
-                errors.append(f"{candidate['lookup_source']}: {exc}")
-
-        error_message = "Unable to fetch the NIFTY 50 quote from Kotak Neo."
-        if errors:
-            error_message = f"{error_message} " + " | ".join(errors)
-        raise KotakNeoError(error_message)
-
-    def _nifty50_quote_candidates(self, context: dict[str, str]) -> list[dict[str, Any]]:
-        candidates: list[dict[str, Any]] = []
-        master_candidate = self._resolve_nifty50_master_candidate(context)
-        if master_candidate:
-            candidates.append(master_candidate)
-        candidates.append(
-            {
-                "exchange_segment": "nse_cm",
-                "instrument_token": "Nifty 50",
-                "display_name": "NIFTY 50",
-                "lookup_source": "quotes_doc_fallback",
-                "master_match": None,
-            }
-        )
-        return candidates
-
-    def _resolve_nifty50_master_candidate(self, context: dict[str, str]) -> dict[str, Any] | None:
-        candidates = self._load_scrip_candidates(context, "nse_cm")
-        for item in candidates:
-            normalized_values = {
-                self._normalize_scrip_text(item.get("pSymbolName")),
-                self._normalize_scrip_text(item.get("pTrdSymbol")),
-                self._normalize_scrip_text(item.get("pDesc")),
-                self._normalize_scrip_text(item.get("pCombinedSymbol")),
-                self._normalize_scrip_text(item.get("pScripRefKey")),
-            }
-            normalized_values.discard("")
-            if not normalized_values:
-                continue
-            if "NIFTY50" not in normalized_values and not any(
-                value.startswith("NIFTY50") or "NIFTY50INDEX" in value for value in normalized_values
-            ):
-                continue
-            instrument_token = _first_text(
-                item.get("pSymbol"),
-                item.get("pTrdSymbol"),
-                item.get("pSymbolName"),
-            )
-            if not instrument_token:
-                continue
-            return {
-                "exchange_segment": "nse_cm",
-                "instrument_token": instrument_token,
-                "display_name": _first_text(item.get("pDesc"), item.get("pSymbolName"), item.get("pTrdSymbol"))
-                or "NIFTY 50",
-                "lookup_source": "masterscrip",
-                "master_match": {
-                    "pSymbol": item.get("pSymbol"),
-                    "pSymbolName": item.get("pSymbolName"),
-                    "pTrdSymbol": item.get("pTrdSymbol"),
-                    "pDesc": item.get("pDesc"),
-                },
-            }
-        return None
-
-    def _normalize_scrip_text(self, value: Any) -> str:
-        return "".join(ch for ch in str(value or "").upper() if ch.isalnum())
-
-    def _normalize_nifty50_quote(
-        self,
-        item: dict[str, Any],
-        candidate: dict[str, Any],
-    ) -> dict[str, Any]:
-        price = _first_number(item.get("last_traded_price"), item.get("ltp"), item.get("iv"))
-        previous_close = _first_number(item.get("close"), item.get("c"), item.get("ic"))
-        change = _first_number(item.get("change"), item.get("cng"))
-        if change is None and price is not None and previous_close is not None:
-            change = price - previous_close
-
-        change_pct = None
-        if change is not None and previous_close not in (None, 0):
-            change_pct = change / previous_close
-        if change_pct is None:
-            change_pct = _first_number(item.get("net_change_percentage"), item.get("nc"))
-
-        return {
-            "symbol": "NIFTY 50",
-            "display_name": candidate.get("display_name") or "NIFTY 50",
-            "exchange_segment": candidate.get("exchange_segment") or _first_text(item.get("exchange_segment"), item.get("e")) or "nse_cm",
-            "instrument_token": candidate.get("instrument_token") or _first_text(item.get("instrument_token"), item.get("tk")),
-            "price": price,
-            "previous_close": previous_close,
-            "change": change,
-            "change_pct": change_pct,
-            "quote_time": _first_text(
-                item.get("updRecvTm"),
-                item.get("hsUpTm"),
-                item.get("flDtTm"),
-                item.get("exTm"),
-                item.get("ltt"),
-            ),
-            "fetched_at": _utc_now_iso(),
-            "source": {
-                "provider": "Kotak Neo Quotes API",
-                "lookup_source": candidate.get("lookup_source"),
-                "master_match": candidate.get("master_match"),
-            },
-            "raw": item,
-        }
-
     def _fetch_quotes_with_context(
         self,
         context: dict[str, str],