tradingapi 0.3.9__tar.gz → 0.3.10__tar.gz

{tradingapi-0.3.9 → tradingapi-0.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingapi
-Version: 0.3.9
+Version: 0.3.10
 Summary: Trade integration with brokers
 Author-email: Pankaj Sharma <sharma.pankaj.kumar@gmail.com>
 License-Expression: MIT

{tradingapi-0.3.9 → tradingapi-0.3.10}/pyproject.toml

@@ -28,7 +28,7 @@ packages = ["tradingapi"]
 
 [project]
 name = "tradingapi"
-version = "0.3.9"
+version = "0.3.10"
 description = "Trade integration with brokers"
 readme = "README.md"
 license = "MIT"

{tradingapi-0.3.9 → tradingapi-0.3.10}/tradingapi/broker_base.py

@@ -571,6 +571,7 @@ class Price:
         high: float = float("nan"),
         low: float = float("nan"),
         volume: int = 0,
+        oi: int = 0,
         symbol: str = "",
         exchange: str = "",
         src: str = "",
@@ -589,6 +590,7 @@ class Price:
             high: High price
             low: Low price
             volume: Total volume
+            oi: Open interest
             symbol: Trading symbol
             exchange: Exchange name
             src: Source of the price data
@@ -606,6 +608,7 @@ class Price:
         self.high = high
         self.low = low
         self.volume = volume
+        self.oi = oi
         self.symbol = symbol
         self.exchange = exchange
         self.src = src
@@ -633,6 +636,7 @@ class Price:
             high=safe_add(self.high, other.high),
             low=safe_add(self.low, other.low),
             volume=safe_add_volume(self.volume, other.volume),
+            oi=safe_add_volume(self.oi, other.oi),
         )
         # dont change symbol
 
@@ -646,6 +650,7 @@ class Price:
         self.high = other.high * size if other.high * size is not float("nan") else self.high
         self.low = other.low * size if other.low * size is not float("nan") else self.low
         self.volume = other.volume if other.volume is not float("nan") else self.volume
+        self.oi = other.oi if other.oi is not float("nan") else self.oi
         self.symbol = other.symbol
         self.exchange = other.exchange
         self.src = other.src
@@ -662,6 +667,7 @@ class Price:
             "high": self.high,
             "low": self.low,
             "volume": self.volume,
+            "oi": self.oi,
             "symbol": self.symbol,
             "exchange": self.exchange,
             "src": self.src,
@@ -680,6 +686,7 @@ class Price:
             high=data.get("high", float("nan")),
             low=data.get("low", float("nan")),
             volume=data.get("volume", 0),
+            oi=data.get("oi", 0),
             symbol=data.get("symbol", ""),
             exchange=data.get("exchange", ""),
             src=data.get("src", ""),

{tradingapi-0.3.9 → tradingapi-0.3.10}/tradingapi/config/config_sample.yaml

@@ -2,13 +2,14 @@
 bhavcopy_folder : /home/psharma/onedrive/rfiles/data/bhavcopy
 
 # Optional: proxy for broker HTTP requests (e.g. connect, save_symbol_data).
-# When a broker has USE_PROXY: true, proxies are fetched from the source (e.g. webshare).
+# USE_PROXY: trading API calls. USE_PROXY_SYMBOL_DOWNLOAD: symbol master download only.
 proxy:
   source: webshare
   api_key: # Webshare API key (or set WEBSHARE_PROXY_API_KEY env)
   username: # Optional: override per-proxy username from API
   password: # Optional: override per-proxy password from API
   country_code: # Optional: e.g. IN
+  max_proxies: 30 # NordVPN servers to try when rotating (symbol download)
   mode: direct
 
 commissions:
@@ -22,6 +23,7 @@ commissions:
 FIVEPAISA:
   EXCHANGES: [NSE, BSE, MCX]
   USE_PROXY: false
+  USE_PROXY_SYMBOL_DOWNLOAD: false
   APP_NAME:
   APP_SOURCE:
   USER_ID:
@@ -41,6 +43,7 @@ FIVEPAISA:
 SHOONYA:
   EXCHANGES: [NSE, BSE, MCX]
   USE_PROXY: false
+  USE_PROXY_SYMBOL_DOWNLOAD: false
   USER:
   PWD:
   VC:
@@ -56,6 +59,7 @@ SHOONYA:
 ICICIDIRECT:
   EXCHANGES: [NSE, BSE, MCX]
   USE_PROXY: false
+  USE_PROXY_SYMBOL_DOWNLOAD: false
   API_KEY:
   API_SECRET:
   USER_ID: # Optional: used by icicidirect-generate-session (AUTO_SESSION_TOKEN_CMD)
@@ -91,6 +95,7 @@ ICICIDIRECT:
 DHAN:
   EXCHANGES: [NSE, BSE]
   USE_PROXY: false
+  USE_PROXY_SYMBOL_DOWNLOAD: false
   CLIENT_ID:
   ACCESS_TOKEN: # Optional fallback if TOTP/PIN flow is not used
   TOTP_TOKEN: # Optional: used for auto token refresh
@@ -107,6 +112,7 @@ DHAN:
 DHAN_ACCOUNT2:
   EXCHANGES: [NSE, BSE]
   USE_PROXY: false
+  USE_PROXY_SYMBOL_DOWNLOAD: false
   CLIENT_ID:
   ACCESS_TOKEN:
   TOTP_TOKEN:

{tradingapi-0.3.9 → tradingapi-0.3.10}/tradingapi/dhan.py

@@ -287,11 +287,21 @@ def save_symbol_data(saveToFolder: bool = False):
         dest_file = f"{bhavcopyfolder}/{dt.datetime.today().strftime('%Y%m%d')}_dhan_codes.csv"
 
         headers = {"User-Agent": "Mozilla/5.0", "Accept": "*/*"}
-        response = requests.get(DHAN_SECURITY_LIST_URL, headers=headers, timeout=(10, 300))
-        if response.status_code != 200:
-            raise Exception(f"Failed to fetch Dhan symbol data. Status: {response.status_code}")
-
-        df = pd.read_csv(io.BytesIO(response.content), low_memory=False)
+        if os.path.exists(dest_file):
+            df = pd.read_csv(dest_file, low_memory=False)
+        else:
+            from .proxy_utils import request_get_with_broker_proxy
+
+            response = request_get_with_broker_proxy(
+                DHAN_SECURITY_LIST_URL,
+                "DHAN",
+                purpose="symbol_download",
+                headers=headers,
+                timeout=(10, 300),
+            )
+            with open(dest_file, "wb") as f:
+                f.write(response.content)
+            df = pd.read_csv(dest_file, low_memory=False)
         df.columns = [col.strip() for col in df.columns]
         object_cols = df.select_dtypes(include=["object"]).columns
         for col in object_cols:
@@ -1985,6 +1995,11 @@ class Dhan(BrokerBase):
                 market_feed.low = float(ohlc.get("low", data.get("dayLow", float("nan"))) or float("nan"))
                 market_feed.prior_close = float(ohlc.get("close", data.get("previousClosePrice", float("nan"))) or float("nan"))
                 market_feed.volume = int(data.get("volume", data.get("totalTradedVolume", 0)) or 0)
+                raw_oi = data.get("OI", data.get("oi", data.get("open_interest", data.get("openInterest", 0))))
+                try:
+                    market_feed.oi = int(str(raw_oi).strip() or 0)
+                except (TypeError, ValueError):
+                    market_feed.oi = int(float(raw_oi or 0))
                 depth = data.get("depth", {})
                 buy_qty = depth.get("buy", [{}])
                 sell_qty = depth.get("sell", [{}])
@@ -2340,9 +2355,12 @@ class Dhan(BrokerBase):
                 if value in (None, "", "nan"):
                     return 0
                 try:
-                    return int(float(value))
+                    return int(str(value).strip())
                 except (TypeError, ValueError):
-                    return 0
+                    try:
+                        return int(float(value))
+                    except (TypeError, ValueError):
+                        return 0
 
             def _apply_if_valid(current: float, value: Any) -> float:
                 parsed = _to_float(value)
@@ -2391,6 +2409,9 @@ class Dhan(BrokerBase):
                     volume = _to_int(response.get("volume"))
                     if volume:
                         price.volume = volume
+                    oi = _to_int(response.get("OI") or response.get("oi") or response.get("open_interest") or response.get("openInterest"))
+                    if oi:
+                        price.oi = oi
                     price.bid = _apply_if_valid(price.bid, response.get("bidPrice"))
                     price.ask = _apply_if_valid(price.ask, response.get("askPrice"))
                     bid_qty = _to_int(response.get("bidQty"))

{tradingapi-0.3.9 → tradingapi-0.3.10}/tradingapi/fivepaisa.py

@@ -1,4 +1,5 @@
 import datetime as dt
+import copy
 import inspect
 import io
 import json
@@ -157,7 +158,7 @@ def save_symbol_data(saveToFolder: bool = False):
         _proxies = None
         try:
             from .proxy_utils import get_proxies_for_broker
-            _proxies = get_proxies_for_broker("FIVEPAISA")
+            _proxies = get_proxies_for_broker("FIVEPAISA", purpose="symbol_download")
         except Exception:
             pass
         headers = {
@@ -2020,7 +2021,8 @@ class FivePaisa(BrokerBase):
                                 if self.api is None:
                                     raise BrokerConnectionError("API client not initialized")
                                 out = self.api.cancel_order(exch_order_id=order.exch_order_id)
-                                self.log_and_return(out)
+                                if out is not None:
+                                    self.log_and_return(out)
 
                                 if out and "BrokerOrderID" in out:
                                     # Convert broker_order_id to string for consistency
@@ -3482,10 +3484,14 @@ class FivePaisa(BrokerBase):
                 raise MarketDataError(f"Exchange mapping not found: {str(e)}", context)
 
             if scrip_code is None:
+                symbol_map = self.exchange_mappings[mapped_exchange]["symbol_map"]
+                symbol_prefix = str(long_symbol).split("_", 1)[0]
+                matching_symbols = [symbol for symbol in symbol_map if str(symbol).startswith(f"{symbol_prefix}_")]
                 context = create_error_context(
                     long_symbol=long_symbol,
                     mapped_exchange=mapped_exchange,
-                    available_symbols=list(self.exchange_mappings[mapped_exchange]["symbol_map"].keys()),
+                    available_symbol_count=len(symbol_map),
+                    matching_symbol_sample=matching_symbols[:20],
                 )
                 trading_logger.log_warning("No scrip code found for symbol", context)
                 return market_feed  # Return default Price object if no scrip code is found
@@ -3495,11 +3501,32 @@ class FivePaisa(BrokerBase):
             ]
 
             try:
-                # Fetch market feed
                 if self.api is None:
                     raise BrokerConnectionError("API client not initialized")
+
+                def safe_float(value, default=float("nan")):
+                    if value in [None, "", 0, "0", "0.00", float("nan")]:
+                        return default
+                    try:
+                        return float(value)
+                    except (TypeError, ValueError):
+                        return default
+
+                def safe_int(value, default=0):
+                    if value in [None, "", 0, "0", "0.00", float("nan")]:
+                        return default
+                    try:
+                        return int(str(value).strip())
+                    except (TypeError, ValueError):
+                        try:
+                            return int(float(cast(Union[int, float, str], value)))
+                        except (TypeError, ValueError):
+                            return default
+
                 self._wait_for_quote_rate_limit()
-                out = self.api.fetch_market_feed_scrip(req_list)
+                out = self.api.fetch_market_snapshot(
+                    [{"Exchange": mapped_exchange, "ExchangeType": exch_type, "ScripCode": str(scrip_code)}]
+                )
                 if not out or "Data" not in out or len(out["Data"]) == 0:
                     context = create_error_context(
                         long_symbol=long_symbol,
@@ -3507,7 +3534,7 @@ class FivePaisa(BrokerBase):
                         scrip_code=scrip_code,
                         api_response=out,
                     )
-                    raise MarketDataError("No market feed data received", context)
+                    raise MarketDataError("No market snapshot data received", context)
 
                 snapshot = out["Data"][0]
 
@@ -3555,12 +3582,13 @@ class FivePaisa(BrokerBase):
                         if best_ask_quantity is not None and best_ask_quantity > 0
                         else market_feed.ask_volume
                     )
-                market_feed.exchange = snapshot["Exch"]
-                market_feed.high = snapshot["High"] if snapshot["High"] > 0 else market_feed.high
-                market_feed.low = snapshot["Low"] if snapshot["Low"] > 0 else market_feed.low
-                market_feed.last = snapshot["LastRate"] if snapshot["LastRate"] > 0 else market_feed.last
-                market_feed.prior_close = snapshot["PClose"] if snapshot["PClose"] > 0 else market_feed.prior_close
-                market_feed.volume = snapshot["TotalQty"] if snapshot["TotalQty"] > 0 else market_feed.volume
+                market_feed.exchange = snapshot.get("Exchange", mapped_exchange)
+                market_feed.high = safe_float(snapshot.get("High"), market_feed.high)
+                market_feed.low = safe_float(snapshot.get("Low"), market_feed.low)
+                market_feed.last = safe_float(snapshot.get("LastTradedPrice"), market_feed.last)
+                market_feed.prior_close = safe_float(snapshot.get("PClose"), market_feed.prior_close)
+                market_feed.volume = safe_int(snapshot.get("Volume"), market_feed.volume)
+                market_feed.oi = safe_int(snapshot.get("OpenInterest"), market_feed.oi)
                 market_feed.timestamp = dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
                 trading_logger.log_debug(
@@ -3629,9 +3657,22 @@ class FivePaisa(BrokerBase):
                 context = create_error_context(symbols=symbols, exchange=exchange, error=str(e))
                 raise MarketDataError(f"Failed to map exchange: {str(e)}", context)
 
+            prices: Dict[str, Price] = {}
+
+            def safe_int(value, default=0) -> int:
+                if value in [None, "", 0, "0", "0.00", float("nan")]:
+                    return default
+                try:
+                    return int(str(value).strip())
+                except (TypeError, ValueError):
+                    try:
+                        return int(float(cast(Union[int, float, str], value)))
+                    except (TypeError, ValueError):
+                        return default
+
             def resolve_symbol_and_exchange(json_data):
                 """Resolve a token to the correct symbol/exchange even when the tick exchange key is incomplete."""
-                token = json_data.get("Token")
+                token = json_data.get("Token", json_data.get("ScripCode"))
                 try:
                     token_int = int(token) if token is not None else None
                 except (TypeError, ValueError):
@@ -3671,22 +3712,13 @@ class FivePaisa(BrokerBase):
                     return False
                 if data.get("ReqType"):
                     return False
-                return any(k in data for k in ("Token", "LastRate", "BidRate", "TickDt"))
+                return any(k in data for k in ("Token", "ScripCode", "LastRate", "BidRate", "TickDt", "OpenInterest"))
 
             def map_to_price(json_data):
                 """Map JSON data to Price object."""
                 try:
                     price = Price()
                     price.src = "fp"
-                    price.bid = json_data.get("BidRate", float("nan"))
-                    price.ask = json_data.get("OffRate", float("nan"))
-                    price.bid_volume = json_data.get("BidQty", float("nan"))
-                    price.ask_volume = json_data.get("OffQty", float("nan"))
-                    price.last = json_data.get("LastRate", float("nan"))
-                    price.prior_close = json_data.get("PClose", float("nan"))
-                    price.high = json_data.get("High", float("nan"))
-                    price.low = json_data.get("Low", float("nan"))
-                    price.volume = json_data.get("TotalQty", float("nan"))
                     price.symbol, resolved_exchange = resolve_symbol_and_exchange(json_data)
                     if price.symbol is None:
                         trading_logger.log_warning(
@@ -3700,8 +3732,36 @@ class FivePaisa(BrokerBase):
                             },
                         )
                         return None
+                    resolved_symbol = price.symbol
+                    price = prices.get(resolved_symbol, price)
+                    price.src = "fp"
+                    if "BidRate" in json_data:
+                        price.bid = json_data.get("BidRate", price.bid)
+                    if "OffRate" in json_data:
+                        price.ask = json_data.get("OffRate", price.ask)
+                    if "BidQty" in json_data:
+                        price.bid_volume = json_data.get("BidQty", price.bid_volume)
+                    if "OffQty" in json_data:
+                        price.ask_volume = json_data.get("OffQty", price.ask_volume)
+                    if "LastRate" in json_data:
+                        price.last = json_data.get("LastRate", price.last)
+                    if "PClose" in json_data:
+                        price.prior_close = json_data.get("PClose", price.prior_close)
+                    if "High" in json_data:
+                        price.high = json_data.get("High", price.high)
+                    if "Low" in json_data:
+                        price.low = json_data.get("Low", price.low)
+                    if "TotalQty" in json_data:
+                        price.volume = json_data.get("TotalQty", price.volume)
+                    if "OpenInterest" in json_data:
+                        price.oi = safe_int(json_data.get("OpenInterest"), price.oi)
+                    price.symbol = resolved_symbol
                     price.exchange = self.map_exchange_for_db(price.symbol, resolved_exchange)
-                    price.timestamp = self.convert_to_ist(json_data["TickDt"])
+                    if json_data.get("TickDt"):
+                        price.timestamp = self.convert_to_ist(json_data["TickDt"])
+                    else:
+                        price.timestamp = dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                    prices[resolved_symbol] = price
                     return price
                 except Exception as e:
                     trading_logger.log_error("Error mapping price data", e, {"json_data": json_data})
@@ -3837,14 +3897,26 @@ class FivePaisa(BrokerBase):
                     with self._stream_reconnect_lock:
                         self._stream_reconnect_active = False
 
-            def connect_and_receive(req_data):
+            def connect_and_receive(req_data, extra_req_data=None):
                 """Connect and receive data."""
                 try:
                     if self.api is None:
                         raise BrokerConnectionError("API client not initialized")
                     self.api.connect(req_data)
-                    self.api.error_data(error_data)
                     ws = getattr(self.api, "ws", None)
+                    if ws is not None and extra_req_data:
+                        original_on_open = getattr(ws, "on_open", None)
+
+                        def on_open_with_extra_requests(opened_ws):
+                            if callable(original_on_open):
+                                original_on_open(opened_ws)
+                            for extra_req in extra_req_data or []:
+                                if extra_req:
+                                    self._wait_for_stream_request_rate_limit()
+                                    opened_ws.send(json.dumps(extra_req))
+
+                        ws.on_open = on_open_with_extra_requests
+                    self.api.error_data(error_data)
                     if ws is not None:
                         ws.on_close = close_data
                     self.api.receive_data(on_message)
@@ -3852,14 +3924,19 @@ class FivePaisa(BrokerBase):
                     trading_logger.log_error("Error in connect_and_receive", e, {"req_data": req_data})
                     raise
 
+            def is_ws_connected(ws) -> bool:
+                sock = getattr(ws, "sock", None)
+                return bool(sock is not None and getattr(sock, "connected", False))
+
             def has_live_stream():
                 """Return True only when the streaming thread and websocket are both usable."""
+                ws = getattr(self.api, "ws", None) if self.api is not None else None
                 return (
                     self.subscribe_thread is not None
                     and self.subscribe_thread.is_alive()
-                    and self.api is not None
-                    and getattr(self.api, "ws", None) is not None
-                    and callable(getattr(self.api.ws, "send", None))
+                    and ws is not None
+                    and callable(getattr(ws, "send", None))
+                    and is_ws_connected(ws)
                 )
 
             def reconnect_stream():
@@ -3899,11 +3976,15 @@ class FivePaisa(BrokerBase):
                         raise MarketDataError("No symbols to reconnect after socket closure", context)
                     if self.api is None:
                         raise BrokerConnectionError("API client not initialized")
-                    req_data_full = self.api.Request_Feed("mf", "s", req_list_full)
+                    req_data_full = copy.deepcopy(self.api.Request_Feed("mf", "s", req_list_full))
+                    oi_req_list_full = [dict(item) for item in req_list_full if item.get("ExchType") == "D"]
+                    extra_req_data_full = [
+                        copy.deepcopy(self.api.Request_Feed("oi", "s", oi_req_list_full))
+                    ] if oi_req_list_full else []
                     reconnect_started_ts = time.time()
                     self.subscribe_thread = threading.Thread(
                         target=connect_and_receive,
-                        args=(req_data_full,),
+                        args=(req_data_full, extra_req_data_full),
                         name="MarketDataStreamer",
                     )
                     self.subscribe_thread.start()
@@ -3934,6 +4015,8 @@ class FivePaisa(BrokerBase):
                 ws = getattr(self.api, "ws", None)
                 if ws is None or not callable(getattr(ws, "send", None)):
                     raise AttributeError("WebSocket client does not support send")
+                if not is_ws_connected(ws):
+                    raise WebSocketConnectionClosedException("Connection is already closed.")
                 self._wait_for_stream_request_rate_limit()
                 ws.send(json.dumps(req_data))
 
@@ -4020,7 +4103,9 @@ class FivePaisa(BrokerBase):
                 if req_list is not None and len(req_list) > 0:
                     if self.api is None:
                         raise BrokerConnectionError("API client not initialized")
-                    req_data = self.api.Request_Feed("mf", operation, req_list)
+                    req_data = copy.deepcopy(self.api.Request_Feed("mf", operation, req_list))
+                    oi_req_list = [dict(item) for item in req_list if item.get("ExchType") == "D"]
+                    oi_req_data = copy.deepcopy(self.api.Request_Feed("oi", operation, oi_req_list)) if oi_req_list else None
 
                     # Start the connection and receiving data in a separate thread
                     if not has_live_stream():
@@ -4033,6 +4118,8 @@ class FivePaisa(BrokerBase):
                         )
                         try:
                             send_stream_request(req_data)
+                            if oi_req_data:
+                                send_stream_request(oi_req_data)
                         except (AttributeError, WebSocketConnectionClosedException):
                             trading_logger.log_info(
                                 "WebSocket closed, reconnecting...",

{tradingapi-0.3.9 → tradingapi-0.3.10}/tradingapi/flattrade.py

@@ -108,7 +108,7 @@ def save_symbol_data(saveToFolder: bool = True):
     _proxies = None
     try:
         from .proxy_utils import get_proxies_for_broker
-        _proxies = get_proxies_for_broker("FLATTRADE")
+        _proxies = get_proxies_for_broker("FLATTRADE", purpose="symbol_download")
     except Exception:
         pass
     url = "https://api.shoonya.com/NSE_symbols.txt.zip"
@@ -2398,6 +2398,7 @@ class FlatTrade(BrokerBase):
                 market_feed.high = safe_float(tick_data.get("h"))
                 market_feed.low = safe_float(tick_data.get("l"))
                 market_feed.volume = safe_int(tick_data.get("v"))
+                market_feed.oi = safe_int(tick_data.get("oi"))
 
                 # Handle exchange mapping
                 try:
@@ -2482,6 +2483,17 @@ class FlatTrade(BrokerBase):
             prices = {}
             mapped_exchange = self.map_exchange_for_api(symbols[0], exchange)
 
+            def safe_int_value(value, default=0):
+                if value in [None, "", 0, "0", "0.00", float("nan")]:
+                    return default
+                try:
+                    return int(str(value).strip())
+                except (TypeError, ValueError):
+                    try:
+                        return int(float(value))
+                    except (ValueError, TypeError):
+                        return default
+
             # Function to map JSON data to a Price object
             def map_to_price(json_data):
                 price = Price()
@@ -2527,6 +2539,7 @@ class FlatTrade(BrokerBase):
                     else float(json_data.get("l"))
                 )
                 price.volume = float("nan") if json_data.get("v") in [None, float("nan")] else float(json_data.get("v"))
+                price.oi = safe_int_value(json_data.get("oi"))
                 symbol = self.exchange_mappings[json_data.get("e")]["symbol_map_reversed"].get(int(json_data.get("tk")))
                 price.exchange = self.map_exchange_for_db(symbol, json_data.get("e"))
                 price.timestamp = self.convert_ft_to_ist(int(json_data.get("ft", 0)))
@@ -2541,9 +2554,11 @@ class FlatTrade(BrokerBase):
                     if ext_callback:
                         ext_callback(price)
                 elif message.get("t") == "tf":
-                    required_keys = {"bp1", "sp1", "c", "lp", "bq1", "sq1", "h", "l"}
+                    required_keys = {"bp1", "sp1", "c", "lp", "bq1", "sq1", "h", "l", "oi"}
                     if required_keys & message.keys():
                         price = prices.get(message.get("tk"))
+                        if price is None:
+                            return
                         if message.get("bp1"):
                             price.bid = float(message.get("bp1"))
                         if message.get("sp1"):
@@ -2562,6 +2577,8 @@ class FlatTrade(BrokerBase):
                             price.low = float(message.get("l"))
                         if message.get("v"):
                             price.volume = float(message.get("v"))
+                        if message.get("oi") not in [None, "", float("nan")]:
+                            price.oi = safe_int_value(message.get("oi"), price.oi)
                         price.timestamp = self.convert_ft_to_ist(int(message.get("ft", 0)))
                         prices[message.get("tk")] = price
                         if ext_callback:

{tradingapi-0.3.9 → tradingapi-0.3.10}/tradingapi/icicidirect.py

@@ -135,7 +135,7 @@ def save_symbol_data(saveToFolder: bool = True) -> pd.DataFrame:
     try:
         from .proxy_utils import get_proxies_for_broker
 
-        _proxies = get_proxies_for_broker("ICICIDIRECT")
+        _proxies = get_proxies_for_broker("ICICIDIRECT", purpose="symbol_download")
     except Exception:
         pass
     _prev_ipv6 = _temporarily_force_ipv4()
@@ -1553,9 +1553,12 @@ class IciciDirect(BrokerBase):
             if v in [None, ""]:
                 return default
             try:
-                return int(float(cast(Union[int, float, str], v)))
+                return int(str(cast(Union[int, float, str], v)).strip())
             except Exception:
-                return default
+                try:
+                    return int(float(cast(Union[int, float, str], v)))
+                except Exception:
+                    return default
 
         market_feed.bid = _f("bPrice")
         market_feed.ask = _f("sPrice")
@@ -1566,6 +1569,10 @@ class IciciDirect(BrokerBase):
         market_feed.low = _f("low")
         market_feed.prior_close = _f("close")
         market_feed.volume = _i("ttq")
+        for oi_key in ("open_interest", "oi", "OpenInterest", "OI"):
+            if tick.get(oi_key) not in [None, ""]:
+                market_feed.oi = _i(oi_key)
+                break
         if isinstance(tick.get("ltt"), str) and tick.get("ltt"):
             ltt = str(tick.get("ltt"))
             try:

tradingapi-0.3.10/tradingapi/proxy_utils.py

@@ -0,0 +1,294 @@
+"""
+Proxy utilities for broker HTTP requests.
+
+When a broker has USE_PROXY=True (API) or USE_PROXY_SYMBOL_DOWNLOAD=True (symbol master),
+configured, get_proxies_for_broker() returns a proxies dict for use with requests.
+Used in connect() and save_symbol_data() for each broker.
+"""
+import os
+import random
+from typing import Any, Dict, Optional, Tuple, Union
+from urllib.parse import quote
+
+import requests
+
+from tradingapi import trading_logger
+
+_WEBSHARE_LIST_URL = "https://proxy.webshare.io/api/v2/proxy/list/"
+
+
+def _get_proxy_credentials(proxy_cfg: Dict[str, Any]) -> tuple[Optional[str], Optional[str]]:
+    username = proxy_cfg.get("user") or proxy_cfg.get("username")
+    password = proxy_cfg.get("pass") or proxy_cfg.get("password")
+    return username, password
+
+
+def _get_proxy_config(broker_name: str, purpose: str = "api") -> Optional[tuple[Any, Dict[str, Any]]]:
+    try:
+        from .config import get_config
+
+        config = get_config()
+    except Exception:
+        return None
+
+    if purpose == "symbol_download":
+        use_proxy = config.get(f"{broker_name}.USE_PROXY_SYMBOL_DOWNLOAD")
+    else:
+        use_proxy = config.get(f"{broker_name}.USE_PROXY")
+    if not use_proxy:
+        return None
+
+    proxy_cfg = config.configs.get("proxy")
+    if not isinstance(proxy_cfg, dict):
+        trading_logger.log_debug("Proxy not used: no proxy section in config", context={"broker": broker_name})
+        return None
+
+    return config, proxy_cfg
+
+
+def get_proxy_verify_ssl(broker_name: str, purpose: str = "api") -> bool:
+    """Return False when broker proxy requires disabled SSL verify (e.g. NordVPN)."""
+    cfg = _get_proxy_config(broker_name, purpose=purpose)
+    if not cfg:
+        return True
+    _, proxy_cfg = cfg
+    source = (proxy_cfg.get("source") or "").strip().lower()
+    return source != "nordvpn"
+
+
+def _nordvpn_max_proxies(proxy_cfg: Dict[str, Any]) -> int:
+    try:
+        return max(1, int(proxy_cfg.get("max_proxies") or 30))
+    except (TypeError, ValueError):
+        return 30
+
+
+def _build_nordvpn_proxies(proxy_cfg: Dict[str, Any], broker_name: str) -> list[Dict[str, str]]:
+    username, password = _get_proxy_credentials(proxy_cfg)
+    if not username or not password:
+        trading_logger.log_warning(
+            "Proxy enabled but proxy user/pass not set for NordVPN",
+            context={"broker": broker_name},
+        )
+        return []
+    country_code = proxy_cfg.get("country_code") or "IN"
+    try:
+        from chameli.interactions import get_nordvpn_proxies
+
+        host_ports = get_nordvpn_proxies(country_code=country_code, max_proxies=_nordvpn_max_proxies(proxy_cfg))
+        u = quote(str(username), safe="")
+        p = quote(str(password), safe="")
+        return [
+            {"http": f"https://{u}:{p}@{host_port}", "https": f"https://{u}:{p}@{host_port}"}
+            for host_port in host_ports
+        ]
+    except Exception as e:
+        trading_logger.log_warning(
+            "Failed to fetch NordVPN proxy for broker",
+            context={"broker": broker_name, "error": str(e)},
+        )
+        return []
+
+
+def iter_proxies_for_broker(broker_name: str, purpose: str = "api"):
+    """
+    Yield (proxies_dict, verify_ssl) tuples to try for HTTP requests.
+    NordVPN yields multiple servers; others yield at most one entry.
+    When proxy is disabled, yields a single direct request config.
+    """
+    cfg = _get_proxy_config(broker_name, purpose=purpose)
+    if not cfg:
+        yield {}, True
+        return
+
+    _, proxy_cfg = cfg
+    source = (proxy_cfg.get("source") or "webshare").strip().lower()
+    if source == "nordvpn":
+        proxies_list = _build_nordvpn_proxies(proxy_cfg, broker_name)
+        if not proxies_list:
+            yield {}, True
+            return
+        for proxies in proxies_list:
+            yield proxies, False
+        return
+
+    proxies = get_proxies_for_broker(broker_name, purpose=purpose)
+    if proxies:
+        yield proxies, get_proxy_verify_ssl(broker_name, purpose=purpose)
+    else:
+        yield {}, True
+
+
+def suppress_insecure_request_warnings() -> None:
+    import urllib3
+
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+
+def request_get_with_broker_proxy(
+    url: str,
+    broker_name: str,
+    purpose: str = "symbol_download",
+    headers: Optional[Dict[str, str]] = None,
+    timeout: Union[float, Tuple[float, float]] = (10, 300),
+    min_content_bytes: int = 100_000,
+) -> requests.Response:
+    """
+    GET url using broker proxy settings, rotating NordVPN servers until a valid response.
+    Validates status 200 and minimum response size (Dhan 403 pages are ~919 bytes).
+    """
+    suppress_insecure_request_warnings()
+    response = None
+    last_status = None
+    last_error = None
+    for proxies, verify in iter_proxies_for_broker(broker_name, purpose=purpose):
+        proxy_host = (proxies or {}).get("https", "").split("@")[-1] if proxies else "direct"
+        try:
+            response = requests.get(
+                url,
+                headers=headers or {},
+                proxies=proxies or {},
+                verify=verify,
+                timeout=timeout,
+            )
+            last_status = response.status_code
+            if response.status_code == 200 and len(response.content) >= min_content_bytes:
+                if proxy_host and proxy_host != "direct":
+                    trading_logger.log_info(
+                        "HTTP request succeeded via proxy",
+                        context={"broker": broker_name, "proxy": proxy_host, "url": url},
+                    )
+                return response
+            trading_logger.log_warning(
+                "Proxy HTTP attempt rejected or too small",
+                context={
+                    "broker": broker_name,
+                    "proxy": proxy_host or "direct",
+                    "status_code": response.status_code,
+                    "content_bytes": len(response.content),
+                },
+            )
+        except requests.RequestException as exc:
+            last_error = str(exc)
+            trading_logger.log_warning(
+                "Proxy HTTP attempt failed",
+                context={"broker": broker_name, "proxy": proxy_host or "direct", "error": last_error},
+            )
+
+    detail = f"status={last_status}" if last_status is not None else last_error or "unknown error"
+    raise requests.RequestException(f"All proxy attempts failed for {broker_name}: {detail}")
+
+
+def get_proxies_for_broker(broker_name: str, purpose: str = "api") -> Optional[Dict[str, str]]:
+    """
+    Return a proxies dict for use with requests if proxy is enabled for the given purpose
+    and proxy config (e.g. Webshare, NordVPN) is present. Otherwise return None.
+
+    purpose:
+        "api" – controlled by {broker}.USE_PROXY (connect, trading API calls)
+        "symbol_download" – controlled by {broker}.USE_PROXY_SYMBOL_DOWNLOAD (save_symbol_data)
+
+    Returns:
+        {"http": "http://user:pass@host:port", "https": "http://user:pass@host:port"}
+        or None if proxy should not be used.
+    """
+    cfg = _get_proxy_config(broker_name, purpose=purpose)
+    if not cfg:
+        return None
+    _, proxy_cfg = cfg
+
+    source = (proxy_cfg.get("source") or "webshare").strip().lower()
+    if source == "nordvpn":
+        proxies_list = _build_nordvpn_proxies(proxy_cfg, broker_name)
+        return proxies_list[0] if proxies_list else None
+
+    if source != "webshare":
+        trading_logger.log_debug(
+            "Proxy not used: unsupported proxy source",
+            context={"broker": broker_name, "source": source},
+        )
+        return None
+
+    api_key = proxy_cfg.get("api_key") or os.getenv("WEBSHARE_PROXY_API_KEY")
+    if not api_key:
+        trading_logger.log_warning("Proxy enabled but proxy.api_key not set", context={"broker": broker_name})
+        return None
+
+    mode = proxy_cfg.get("mode") or "direct"
+    country_code = proxy_cfg.get("country_code")
+    params: Dict[str, Any] = {"mode": mode, "page": 1, "page_size": 100}
+    if country_code:
+        params["country_code"] = country_code
+
+    try:
+        resp = requests.get(
+            _WEBSHARE_LIST_URL,
+            params=params,
+            headers={"Authorization": api_key},
+            timeout=15,
+        )
+        if resp.status_code != 200:
+            trading_logger.log_warning(
+                "Webshare proxy list failed",
+                context={"broker": broker_name, "status_code": resp.status_code},
+            )
+            return None
+        data = resp.json()
+        results = data.get("results") or []
+        valid_proxies = [p for p in results if p.get("valid")]
+        if not valid_proxies:
+            trading_logger.log_warning("No valid Webshare proxies in list", context={"broker": broker_name})
+            return None
+        proxy = random.choice(valid_proxies)
+        host = proxy.get("proxy_address", "")
+        port = proxy.get("port", 80)
+        username, password = _get_proxy_credentials(proxy_cfg)
+        username = username or proxy.get("username")
+        password = password or proxy.get("password")
+        if username and password:
+            proxy_url = f"http://{username}:{password}@{host}:{port}"
+        else:
+            proxy_url = f"http://{host}:{port}"
+        return {"http": proxy_url, "https": proxy_url}
+    except Exception as e:
+        trading_logger.log_warning(
+            "Failed to fetch proxy for broker",
+            context={"broker": broker_name, "error": str(e)},
+        )
+        return None
+
+
+def set_proxy_env_for_broker(broker_name: str) -> Optional[Dict[str, Optional[str]]]:
+    """
+    If broker has USE_PROXY enabled, set HTTP_PROXY and HTTPS_PROXY in the environment
+    from Webshare and return the previous env values (so caller can restore).
+    Otherwise return None and do not change env.
+    """
+    proxies = get_proxies_for_broker(broker_name)
+    if not proxies:
+        return None
+    proxy_url = proxies.get("https") or proxies.get("http")
+    if not proxy_url:
+        return None
+    old = {
+        "HTTP_PROXY": os.environ.get("HTTP_PROXY"),
+        "HTTPS_PROXY": os.environ.get("HTTPS_PROXY"),
+        "http_proxy": os.environ.get("http_proxy"),
+        "https_proxy": os.environ.get("https_proxy"),
+    }
+    os.environ["HTTP_PROXY"] = proxy_url
+    os.environ["HTTPS_PROXY"] = proxy_url
+    os.environ["http_proxy"] = proxy_url
+    os.environ["https_proxy"] = proxy_url
+    return old
+
+
+def restore_proxy_env(previous: Optional[Dict[str, Optional[str]]]) -> None:
+    """Restore HTTP_PROXY/HTTPS_PROXY env from a dict returned by set_proxy_env_for_broker."""
+    if not previous:
+        return
+    for key, value in previous.items():
+        if value is None:
+            os.environ.pop(key, None)
+        else:
+            os.environ[key] = value

{tradingapi-0.3.9 → tradingapi-0.3.10}/tradingapi/shoonya.py

@@ -129,7 +129,7 @@ def save_symbol_data(saveToFolder: bool = True) -> pd.DataFrame:
     _proxies = None
     try:
         from .proxy_utils import get_proxies_for_broker
-        _proxies = get_proxies_for_broker("SHOONYA")
+        _proxies = get_proxies_for_broker("SHOONYA", purpose="symbol_download")
     except Exception:
         pass
     url = "https://api.shoonya.com/NSE_symbols.txt.zip"
@@ -2569,6 +2569,7 @@ class Shoonya(BrokerBase):
                 market_feed.high = safe_float(tick_data.get("h"))
                 market_feed.low = safe_float(tick_data.get("l"))
                 market_feed.volume = safe_int(tick_data.get("v"))
+                market_feed.oi = safe_int(tick_data.get("oi"))
 
                 # Handle exchange mapping
                 try:
@@ -2653,6 +2654,17 @@ class Shoonya(BrokerBase):
             prices: Dict[str, Price] = {}
             mapped_exchange = self.map_exchange_for_api(symbols[0], exchange)
 
+            def safe_int_value(value, default=0):
+                if value in [None, "", 0, "0", "0.00", float("nan")]:
+                    return default
+                try:
+                    return int(str(value).strip())
+                except (TypeError, ValueError):
+                    try:
+                        return int(float(value))
+                    except (ValueError, TypeError):
+                        return default
+
             # Function to map JSON data to a Price object
             def map_to_price(json_data) -> Price:
                 price = Price()
@@ -2698,6 +2710,7 @@ class Shoonya(BrokerBase):
                     else float(json_data.get("l"))
                 )
                 price.volume = float("nan") if json_data.get("v") in [None, float("nan")] else float(json_data.get("v"))
+                price.oi = safe_int_value(json_data.get("oi"))
                 symbol = self.exchange_mappings[json_data.get("e")]["symbol_map_reversed"].get(int(json_data.get("tk")))
                 price.exchange = self.map_exchange_for_db(symbol, json_data.get("e"))
                 price.timestamp = self.convert_ft_to_ist(int(json_data.get("ft", 0)))
@@ -2719,7 +2732,7 @@ class Shoonya(BrokerBase):
                                 {"symbol": price.symbol, "src": price.src},
                             )
                 elif message.get("t") == "tf":
-                    required_keys = {"bp1", "sp1", "c", "lp", "bq1", "sq1", "h", "l"}
+                    required_keys = {"bp1", "sp1", "c", "lp", "bq1", "sq1", "h", "l", "oi"}
                     if required_keys & message.keys():
                         price = prices.get(message.get("tk"))
                         if price is not None:
@@ -2741,6 +2754,8 @@ class Shoonya(BrokerBase):
                                 price.low = float(message.get("l"))
                             if message.get("v"):
                                 price.volume = float(message.get("v"))
+                            if message.get("oi") not in [None, "", float("nan")]:
+                                price.oi = safe_int_value(message.get("oi"), price.oi)
                             price.timestamp = self.convert_ft_to_ist(int(message.get("ft", 0)))
                             prices[message.get("tk")] = price
                             if ext_callback is not None:

{tradingapi-0.3.9 → tradingapi-0.3.10}/tradingapi/utils.py

@@ -2790,6 +2790,7 @@ def get_price(
             ask_volume=sum(price.ask_volume for price in prices),
             prior_close=sum(price.prior_close for price in prices),
             last=sum(price.last for price in prices),
+            oi=sum(price.oi for price in prices),
             symbol=prices[0].symbol,  # Assuming symbol remains the same for all prices
         )
 

{tradingapi-0.3.9 → tradingapi-0.3.10}/tradingapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingapi
-Version: 0.3.9
+Version: 0.3.10
 Summary: Trade integration with brokers
 Author-email: Pankaj Sharma <sharma.pankaj.kumar@gmail.com>
 License-Expression: MIT

tradingapi-0.3.9/tradingapi/proxy_utils.py

@@ -1,130 +0,0 @@
-"""
-Proxy utilities for broker HTTP requests.
-
-When a broker has USE_PROXY=True in config and proxy settings (e.g. Webshare) are
-configured, get_proxies_for_broker() returns a proxies dict for use with requests.
-Used in connect() and save_symbol_data() for each broker.
-"""
-import os
-import random
-from typing import Any, Dict, Optional
-
-import requests
-
-from tradingapi import trading_logger
-
-_WEBSHARE_LIST_URL = "https://proxy.webshare.io/api/v2/proxy/list/"
-
-
-def get_proxies_for_broker(broker_name: str) -> Optional[Dict[str, str]]:
-    """
-    Return a proxies dict for use with requests if this broker has USE_PROXY enabled
-    and proxy config (e.g. Webshare) is present. Otherwise return None.
-
-    Returns:
-        {"http": "http://user:pass@host:port", "https": "http://user:pass@host:port"}
-        or None if proxy should not be used.
-    """
-    try:
-        from .config import get_config
-
-        config = get_config()
-    except Exception:
-        return None
-
-    use_proxy = config.get(f"{broker_name}.USE_PROXY")
-    if not use_proxy:
-        return None
-
-    proxy_cfg = config.configs.get("proxy")
-    if not isinstance(proxy_cfg, dict):
-        trading_logger.log_debug("Proxy not used: no proxy section in config", context={"broker": broker_name})
-        return None
-
-    source = (proxy_cfg.get("source") or "").strip().lower()
-    if source != "webshare":
-        trading_logger.log_debug("Proxy not used: only webshare source is supported", context={"broker": broker_name})
-        return None
-
-    api_key = proxy_cfg.get("api_key") or os.getenv("WEBSHARE_PROXY_API_KEY")
-    if not api_key:
-        trading_logger.log_warning("Proxy enabled but proxy.api_key not set", context={"broker": broker_name})
-        return None
-
-    mode = proxy_cfg.get("mode") or "direct"
-    country_code = proxy_cfg.get("country_code")
-    params: Dict[str, Any] = {"mode": mode, "page": 1, "page_size": 100}
-    if country_code:
-        params["country_code"] = country_code
-
-    try:
-        resp = requests.get(
-            _WEBSHARE_LIST_URL,
-            params=params,
-            headers={"Authorization": api_key},
-            timeout=15,
-        )
-        if resp.status_code != 200:
-            trading_logger.log_warning(
-                "Webshare proxy list failed",
-                context={"broker": broker_name, "status_code": resp.status_code},
-            )
-            return None
-        data = resp.json()
-        results = data.get("results") or []
-        valid_proxies = [p for p in results if p.get("valid")]
-        if not valid_proxies:
-            trading_logger.log_warning("No valid Webshare proxies in list", context={"broker": broker_name})
-            return None
-        proxy = random.choice(valid_proxies)
-        host = proxy.get("proxy_address", "")
-        port = proxy.get("port", 80)
-        username = proxy.get("username") or proxy_cfg.get("username")
-        password = proxy.get("password") or proxy_cfg.get("password")
-        if username and password:
-            proxy_url = f"http://{username}:{password}@{host}:{port}"
-        else:
-            proxy_url = f"http://{host}:{port}"
-        return {"http": proxy_url, "https": proxy_url}
-    except Exception as e:
-        trading_logger.log_warning(
-            "Failed to fetch proxy for broker",
-            context={"broker": broker_name, "error": str(e)},
-        )
-        return None
-
-
-def set_proxy_env_for_broker(broker_name: str) -> Optional[Dict[str, Optional[str]]]:
-    """
-    If broker has USE_PROXY enabled, set HTTP_PROXY and HTTPS_PROXY in the environment
-    from Webshare and return the previous env values (so caller can restore).
-    Otherwise return None and do not change env.
-    """
-    proxies = get_proxies_for_broker(broker_name)
-    if not proxies:
-        return None
-    proxy_url = proxies.get("https") or proxies.get("http")
-    if not proxy_url:
-        return None
-    old = {
-        "HTTP_PROXY": os.environ.get("HTTP_PROXY"),
-        "HTTPS_PROXY": os.environ.get("HTTPS_PROXY"),
-        "http_proxy": os.environ.get("http_proxy"),
-        "https_proxy": os.environ.get("https_proxy"),
-    }
-    os.environ["HTTP_PROXY"] = proxy_url
-    os.environ["HTTPS_PROXY"] = proxy_url
-    os.environ["http_proxy"] = proxy_url
-    os.environ["https_proxy"] = proxy_url
-    return old
-
-
-def restore_proxy_env(previous: Optional[Dict[str, Optional[str]]]) -> None:
-    """Restore HTTP_PROXY/HTTPS_PROXY env from a dict returned by set_proxy_env_for_broker."""
-    if not previous:
-        return
-    for key, value in previous.items():
-        if value is None:
-            os.environ.pop(key, None)
-        else:
-            os.environ[key] = value