Upload 42 files

kotak_neo.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 import threading
+from csv import DictReader
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timezone
 from pathlib import Path
@@ -131,6 +132,7 @@ class KotakNeoManager:
         self.activity_log_path = KOTAK_ACTIVITY_LOG_PATH
         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._load_existing_activity_keys()
         self._clear_session_locked()
 
@@ -291,11 +293,19 @@ class KotakNeoManager:
         trades = sorted(_extract_items(results["trades"]), key=_sort_key, reverse=True)
         orders = sorted(_extract_items(results["orders"]), key=_sort_key, reverse=True)
 
+        normalized_trades = [self._normalize_trade(item) for item in trades]
+        normalized_orders = [self._normalize_order(item) for item in orders]
+
         quotes = self._safe_account_call(
             "quotes",
             lambda: self._fetch_quotes_with_context(
                 context,
-                self._instrument_tokens_for_quotes(holdings, positions),
+                self._instrument_tokens_for_quotes(
+                    context,
+                    holdings,
+                    positions,
+                    normalized_trades,
+                ),
                 timeout=ACCOUNT_TIMEOUT_SECONDS,
             )
             ,
@@ -305,8 +315,6 @@ class KotakNeoManager:
 
         normalized_holdings = [self._normalize_holding(item, quote_map) for item in holdings]
         normalized_positions = [self._normalize_position(item, quote_map) for item in positions]
-        normalized_trades = [self._normalize_trade(item) for item in trades]
-        normalized_orders = [self._normalize_order(item) for item in orders]
         self._append_activity_entries(normalized_trades, normalized_orders)
         journal = self._read_activity_journal()
         merged_trades = self._merge_activity(normalized_trades, journal["trades"])
@@ -337,6 +345,10 @@ class KotakNeoManager:
         return {
             "status": self.status(),
             "as_of": _utc_now_iso(),
+            "neo_behavior": {
+                "holdings_note": "Kotak Neo shows CNC delivery buys in Positions on trade day and in Holdings/T1 from the next trading day.",
+                "trade_history_note": "Kotak Neo trade history availability is limited by Neo's own order and portfolio tracker behavior.",
+            },
             "summary": {
                 "available_cash": available_cash,
                 "current_capital": current_capital,
@@ -559,6 +571,8 @@ class KotakNeoManager:
         ]
         if any(marker in text for marker in empty_markers):
             return True
+        if label in {"positions", "trades", "orders"} and text.strip() == "kotak neo rejected the request.":
+            return True
         if label in {"holdings", "positions", "trades", "orders"} and "424" in text:
             return True
         return False
@@ -594,8 +608,10 @@ class KotakNeoManager:
 
     def _instrument_tokens_for_quotes(
         self,
+        context: dict[str, str],
         holdings: list[dict[str, Any]],
         positions: list[dict[str, Any]],
+        trades: list[dict[str, Any]] | None = None,
     ) -> list[dict[str, str]]:
         unique: dict[tuple[str, str], dict[str, str]] = {}
 
@@ -616,9 +632,84 @@ class KotakNeoManager:
                     "exchange_segment": exchange,
                     "instrument_token": token,
                 }
+            elif exchange:
+                resolved = self._resolve_symbol_token(
+                    context,
+                    exchange_segment=exchange,
+                    symbol=_first_text(item.get("trdSym"), item.get("sym")),
+                )
+                if resolved:
+                    unique[(exchange, resolved)] = {
+                        "exchange_segment": exchange,
+                        "instrument_token": resolved,
+                    }
+
+        for item in trades or []:
+            exchange = _first_text(item.get("exchange_segment"), item.get("exSeg"))
+            if not exchange:
+                continue
+            resolved = self._resolve_symbol_token(
+                context,
+                exchange_segment=exchange,
+                symbol=_first_text(item.get("trading_symbol"), item.get("trdSym"), item.get("symbol"), item.get("sym")),
+            )
+            if resolved:
+                unique[(exchange, resolved)] = {
+                    "exchange_segment": exchange,
+                    "instrument_token": resolved,
+                }
 
         return list(unique.values())
 
+    def _resolve_symbol_token(
+        self,
+        context: dict[str, str],
+        *,
+        exchange_segment: str,
+        symbol: str | None,
+    ) -> str | None:
+        symbol = str(symbol or "").strip()
+        if not symbol:
+            return None
+        candidates = self._load_scrip_candidates(context, exchange_segment)
+        symbol_upper = symbol.upper()
+        base_symbol_upper = symbol_upper.split("-")[0]
+        for item in candidates:
+            trading_symbol = str(item.get("pTrdSymbol") or "").upper()
+            symbol_name = str(item.get("pSymbolName") or "").upper()
+            token = str(item.get("pSymbol") or "").strip()
+            if not token:
+                continue
+            if trading_symbol == symbol_upper or symbol_name == base_symbol_upper:
+                return token
+        return None
+
+    def _load_scrip_candidates(self, context: dict[str, str], exchange_segment: str) -> list[dict[str, str]]:
+        key = str(exchange_segment).lower()
+        if key in self._scrip_cache:
+            return self._scrip_cache[key]
+
+        response = requests.get(
+            f"{context['base_url'].rstrip('/')}/script-details/1.0/masterscrip/file-paths",
+            headers={
+                "Authorization": context["consumer_key"],
+                "Accept": "application/json",
+            },
+            timeout=ACCOUNT_TIMEOUT_SECONDS,
+        )
+        data = self._decode_response(response)
+        file_paths = ((data.get("data") or {}).get("filesPaths") or []) if isinstance(data, dict) else []
+        csv_url = next((path for path in file_paths if key in str(path).lower()), None)
+        if not csv_url:
+            self._scrip_cache[key] = []
+            return []
+
+        csv_response = requests.get(csv_url, timeout=ACCOUNT_TIMEOUT_SECONDS)
+        csv_response.raise_for_status()
+        rows = list(DictReader(csv_response.text.splitlines()))
+        self._scrip_cache[key] = rows
+        return rows
+
     def _build_quote_map(self, payload: dict[str, Any]) -> dict[str, dict[str, Any]]:
         items = _extract_items(payload)
         quote_map: dict[str, dict[str, Any]] = {}
@@ -736,6 +827,7 @@ class KotakNeoManager:
             "updated_at": _first_text(item.get("hsUpTm"), item.get("exTm"), item.get("flDtTm")),
         }
 
+
     def _normalize_trade(self, item: dict[str, Any]) -> dict[str, Any]:
         return {
             "activity_type": "trade",