Upload 7 files

kotak_neo.py

@@ -6,6 +6,8 @@ from datetime import datetime, timezone
 from typing import Any
 from urllib.parse import quote
 
+import json
+
 import requests
 
 
@@ -199,18 +201,46 @@ class KotakNeoManager:
         with self._lock:
             self._ensure_authenticated_locked()
 
-            holdings_raw = self._request_trading_api_locked("portfolio/v1/holdings")
-            positions_raw = self._request_trading_api_locked("quick/user/positions")
-            trades_raw = self._request_trading_api_locked("quick/user/trades")
-            orders_raw = self._request_trading_api_locked("quick/user/orders")
-            limits_raw = self._request_trading_api_locked("quick/user/limits")
+            holdings_raw = self._safe_account_call_locked(
+                "holdings",
+                lambda: self._request_trading_api_locked("portfolio/v1/holdings"),
+                default={"data": []},
+            )
+            positions_raw = self._safe_account_call_locked(
+                "positions",
+                lambda: self._request_trading_api_locked("quick/user/positions"),
+                default={"data": []},
+            )
+            trades_raw = self._safe_account_call_locked(
+                "trades",
+                lambda: self._request_trading_api_locked("quick/user/trades"),
+                default={"data": []},
+            )
+            orders_raw = self._safe_account_call_locked(
+                "orders",
+                lambda: self._request_trading_api_locked("quick/user/orders"),
+                default={"data": []},
+            )
+            limits_raw = self._safe_account_call_locked(
+                "limits",
+                lambda: self._post_trading_api_locked(
+                    "quick/user/limits",
+                    payload={"seg": "ALL", "exch": "ALL", "prod": "ALL"},
+                    content_type="application/x-www-form-urlencoded",
+                ),
+                default={},
+            )
 
             holdings = _extract_items(holdings_raw)
             positions = _extract_items(positions_raw)
             trades = sorted(_extract_items(trades_raw), key=_sort_key, reverse=True)
             orders = sorted(_extract_items(orders_raw), key=_sort_key, reverse=True)
 
-            quotes = self._fetch_quotes_locked(self._instrument_tokens_for_quotes(holdings, positions))
+            quotes = self._safe_account_call_locked(
+                "quotes",
+                lambda: self._fetch_quotes_locked(self._instrument_tokens_for_quotes(holdings, positions)),
+                default={"data": []},
+            )
             quote_map = self._build_quote_map(quotes)
 
             normalized_holdings = [self._normalize_holding(item, quote_map) for item in holdings]
@@ -293,6 +323,45 @@ class KotakNeoManager:
         self._raise_for_error(response, data, session_sensitive=True)
         return data
 
+    def _post_trading_api_locked(
+        self,
+        path: str,
+        payload: dict[str, Any],
+        *,
+        content_type: str = "application/json",
+    ) -> dict[str, Any]:
+        self._ensure_authenticated_locked()
+        headers = {
+            "Sid": self.edit_sid or "",
+            "Auth": self.edit_token or "",
+            "Accept": "application/json",
+            "Content-Type": content_type,
+        }
+        query_params = {"sId": self.server_id or ""}
+        url = f"{self.base_url.rstrip('/')}/{path.lstrip('/')}"
+
+        if content_type == "application/x-www-form-urlencoded":
+            body = {"jData": json.dumps(payload)}
+            response = requests.post(
+                url,
+                headers=headers,
+                params=query_params,
+                data=body,
+                timeout=DEFAULT_TIMEOUT_SECONDS,
+            )
+        else:
+            response = requests.post(
+                url,
+                headers=headers,
+                params=query_params,
+                json=payload,
+                timeout=DEFAULT_TIMEOUT_SECONDS,
+            )
+
+        data = self._decode_response(response)
+        self._raise_for_error(response, data, session_sensitive=True)
+        return data
+
     def _fetch_quotes_locked(self, instrument_tokens: list[dict[str, str]]) -> dict[str, Any]:
         if not instrument_tokens:
             return {"data": []}
@@ -325,6 +394,21 @@ class KotakNeoManager:
             return parsed
         return {"data": parsed}
 
+    def _safe_account_call_locked(
+        self,
+        label: str,
+        fn,
+        *,
+        default: dict[str, Any],
+    ) -> dict[str, Any]:
+        try:
+            return fn()
+        except KotakNeoSessionRequired:
+            raise
+        except Exception as exc:
+            print(f"[kotak] {label} call failed: {exc}", flush=True)
+            return default
+
     def _raise_for_error(
         self,
         response: requests.Response,
@@ -341,12 +425,16 @@ class KotakNeoManager:
             data.get("emsg"),
         )
 
-        if response.status_code == 403 or stat == "not_ok":
+        session_expired = response.status_code == 403 or "invalid session" in (message or "").lower()
+        if session_expired:
             if session_sensitive:
                 self._clear_session_locked()
                 raise KotakNeoSessionRequired(message or "Kotak Neo session expired.")
             raise KotakNeoError(message or "Kotak Neo rejected the request.")
 
+        if stat == "not_ok":
+            raise KotakNeoError(message or "Kotak Neo rejected the request.")
+
         if response.status_code >= 400 or (st_code is not None and st_code >= 400):
             raise KotakNeoError(message or f"Kotak Neo request failed with HTTP {response.status_code}.")