tradingapi 0.4.0__tar.gz → 0.5.0__tar.gz

{tradingapi-0.4.0 → tradingapi-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingapi
-Version: 0.4.0
+Version: 0.5.0
 Summary: Trade integration with brokers
 Author-email: Pankaj Sharma <sharma.pankaj.kumar@gmail.com>
 License-Expression: MIT
@@ -170,6 +170,10 @@ The package requires:
 - Redis (for order tracking and logging)
 - Broker-specific SDKs (automatically installed via dependencies)
 
+## Adding a new broker
+
+Step-by-step checklist (package, YAML, website, PnL/EOD, order manager): [`docs/ADDING_A_BROKER.md`](docs/ADDING_A_BROKER.md).
+
 ## Configuration
 
 ### Configuration File Structure

{tradingapi-0.4.0 → tradingapi-0.5.0}/README.md

@@ -151,6 +151,10 @@ The package requires:
 - Redis (for order tracking and logging)
 - Broker-specific SDKs (automatically installed via dependencies)
 
+## Adding a new broker
+
+Step-by-step checklist (package, YAML, website, PnL/EOD, order manager): [`docs/ADDING_A_BROKER.md`](docs/ADDING_A_BROKER.md).
+
 ## Configuration
 
 ### Configuration File Structure

{tradingapi-0.4.0 → tradingapi-0.5.0}/pyproject.toml

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

tradingapi-0.5.0/tests/test_flattrade_symbology.py

@@ -0,0 +1,50 @@
+import datetime as dt
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+sys.path.insert(0, "/home/psharma/onedrive/code/tradingapi2")
+
+from tradingapi import flattrade
+
+
+class FlatTradeSymbologyTest(unittest.TestCase):
+    def test_update_uses_bod_filename(self):
+        with tempfile.TemporaryDirectory() as folder:
+            symbols_path = Path(folder) / "20260902_symbols.csv"
+            symbols_path.write_text(
+                "long_symbol,LotSize,Scripcode,Exch,ExchType,TickSize,trading_symbol\n"
+                "NIFTY_IND___,1,26000,NSE,NSE,0.05,Nifty 50\n",
+                encoding="utf-8",
+            )
+            broker = object.__new__(flattrade.FlatTrade)
+            broker.account_key = "FLATTRADE"
+            with (
+                patch.object(
+                    flattrade.config,
+                    "get",
+                    return_value=folder,
+                ),
+                patch.object(
+                    flattrade,
+                    "get_tradingapi_now",
+                    return_value=dt.datetime(2026, 9, 2, 9, 57),
+                ),
+                patch.object(
+                    flattrade,
+                    "save_symbol_data",
+                    side_effect=AssertionError("BOD file should be reused"),
+                ),
+            ):
+                broker.update_symbology()
+
+            self.assertEqual(
+                broker.exchange_mappings["NSE"]["symbol_map"]["NIFTY_IND___"],
+                26000,
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

{tradingapi-0.4.0 → tradingapi-0.5.0}/tradingapi/dhan.py

@@ -1605,6 +1605,22 @@ class Dhan(BrokerBase):
                 data = data[0] if data else {}
             if not isinstance(data, dict):
                 raise OrderError(f"Unexpected get_order_by_id payload type: {type(data).__name__}")
+            # success + empty payload = wrong account / order not visible — do not invent a zero fill
+            if not data:
+                trading_logger.log_warning(
+                    "get_order_by_id returned empty data; skipping status update",
+                    {"order_id": broker_order_id, "account": self.account_key},
+                )
+                return OrderInfo(
+                    order_size=order.quantity,
+                    order_price=order.price,
+                    fill_size=0,
+                    fill_price=0,
+                    status=OrderStatus.UNDEFINED,
+                    broker_order_id=broker_order_id,
+                    exchange_order_id=getattr(order, "exch_order_id", "") or "",
+                    broker=self.broker,
+                )
 
             # Dhan order status mapping
             dhan_status = str(data.get("orderStatus", "")).upper()

{tradingapi-0.4.0 → tradingapi-0.5.0}/tradingapi/flattrade.py

@@ -95,8 +95,8 @@ class FlatTradeApiPy(NorenApi):
     def __init__(self):
         NorenApi.__init__(
             self,
-            host="https://piconnect.flattrade.in/PiConnectTP/",
-            websocket="wss://piconnect.flattrade.in/PiConnectWSTp/",
+            host="https://piconnect.flattrade.in/PiConnectAPI",
+            websocket="wss://piconnect.flattrade.in/PiConnectWSAPI/",
         )
 
 
@@ -110,6 +110,19 @@ def save_symbol_data(saveToFolder: bool = True):
             return lst[0]
 
     bhavcopyfolder = config.get("bhavcopy_folder")
+    symbol_columns = [
+        "long_symbol",
+        "LotSize",
+        "Scripcode",
+        "Exch",
+        "ExchType",
+        "TickSize",
+        "trading_symbol",
+    ]
+    codes_nse_cash = pd.DataFrame(columns=symbol_columns)
+    codes_bse_cash = pd.DataFrame(columns=symbol_columns)
+    codes_nse_fno = pd.DataFrame(columns=symbol_columns)
+    codes_bse_fno = pd.DataFrame(columns=symbol_columns)
     _proxies = None
     try:
         from .proxy_utils import get_proxies_for_broker
@@ -152,14 +165,14 @@ def save_symbol_data(saveToFolder: bool = True):
                 codes = codes[(codes.Instrument.isin(["EQ", "BE", "XX", "BZ", "RR", "IV", "INDEX"]))]
                 codes["long_symbol"] = None
 
-                def process_row(row):
+                def process_nse_cash_row(row):
                     symbol = row["Symbol"]
                     if row["Instrument"] == "INDEX":
                         return f"{symbol}_IND___".upper()
                     else:
                         return f"{symbol}_STK___".upper()
 
-                codes["long_symbol"] = codes.apply(process_row, axis=1)
+                codes["long_symbol"] = codes.apply(process_nse_cash_row, axis=1)
                 codes["Exch"] = "NSE"
                 codes["ExchType"] = "CASH"
                 new_column_names = {
@@ -206,14 +219,14 @@ def save_symbol_data(saveToFolder: bool = True):
                 ]
                 codes["long_symbol"] = None
 
-                def process_row(row):
+                def process_bse_cash_row(row):
                     symbol = row["Symbol"]
                     if row["Instrument"] == "INDEX":
                         return f"{symbol}_IND___".upper()
                     else:
                         return f"{symbol}_STK___".upper()
 
-                codes["long_symbol"] = codes.apply(process_row, axis=1)
+                codes["long_symbol"] = codes.apply(process_bse_cash_row, axis=1)
                 codes["Exch"] = "BSE"
                 codes["ExchType"] = "CASH"
                 new_column_names = {
@@ -266,14 +279,18 @@ def save_symbol_data(saveToFolder: bool = True):
                     codes_fno["Expiry"], format="%d-%b-%Y", errors="coerce"
                 ).dt.strftime("%Y%m%d")
 
-                def process_row(row):
+                def process_nse_fno_row(row):
                     symbol = row["Symbol"]
-                    if row["Instrument"].startswith("OPT"):
+                    instrument = row["Instrument"]
+                    if pd.isna(instrument) or pd.isna(symbol):
+                        return None
+                    if str(instrument).startswith("OPT"):
                         return f"{symbol}_OPT_{row['Expiry']}_{'CALL' if row['OptionType']=='CE' else 'PUT'}_{row['StrikePrice']:g}".upper()
                     else:
                         return f"{symbol}_FUT_{row['Expiry']}__".upper()
 
-                codes_fno["long_symbol"] = codes_fno.apply(process_row, axis=1)
+                codes_fno["long_symbol"] = codes_fno.apply(process_nse_fno_row, axis=1)
+                codes_fno = codes_fno.dropna(subset=["long_symbol"])
                 codes_fno["Exch"] = "NFO"
                 codes_fno["ExchType"] = "NFO"
                 new_column_names = {
@@ -312,18 +329,24 @@ def save_symbol_data(saveToFolder: bool = True):
                 codes_fno["Expiry"] = pd.to_datetime(
                     codes_fno["Expiry"], format="%d-%b-%Y", errors="coerce"
                 ).dt.strftime("%Y%m%d")
-                codes_fno["Symbol"] = codes_fno["TradingSymbol"].str.extract(
-                    r"^([A-Z]+(?:50)?)(?=\d{2}(?:[A-Z]\d+|\d+)[A-Z]{2})"
+                codes_fno[["Symbol", "ts_rest"]] = codes_fno["TradingSymbol"].str.extract(
+                    r"^(SENSEX50|[A-Z0-9&-]*?[A-Z&-])(?=(?:\d{2}|FUT))(.*)$",
+                    expand=True,
                 )
+                codes_fno["Symbol"] = codes_fno["Symbol"].fillna(codes_fno["TradingSymbol"])
 
-                def process_row(row):
+                def process_bse_fno_row(row):
                     symbol = row["Symbol"]
-                    if row["Instrument"].startswith("OPT"):
+                    instrument = row["Instrument"]
+                    if pd.isna(instrument) or pd.isna(symbol):
+                        return None
+                    if str(instrument).startswith("OPT"):
                         return f"{symbol}_OPT_{row['Expiry']}_{'CALL' if row['OptionType']=='CE' else 'PUT'}_{row['StrikePrice']:g}".upper()
                     else:
                         return f"{symbol}_FUT_{row['Expiry']}__".upper()
 
-                codes_fno["long_symbol"] = codes_fno.apply(process_row, axis=1)
+                codes_fno["long_symbol"] = codes_fno.apply(process_bse_fno_row, axis=1)
+                codes_fno = codes_fno.dropna(subset=["long_symbol"])
                 codes_fno["Exch"] = "BFO"
                 codes_fno["ExchType"] = "BFO"
                 new_column_names = {
@@ -365,6 +388,7 @@ class FlatTrade(BrokerBase):
         self.api = None
         self.subscribe_thread = None
         self.subscribed_symbols = []
+        self.subscribed_req_tokens = []
         self.socket_opened = False
         self._is_connected_cache_ttl_secs = 3.0
         self._last_is_connected_check_ts = 0.0
@@ -501,6 +525,20 @@ class FlatTrade(BrokerBase):
             """Verify if the current session is valid using existing is_connected method."""
             return self.is_connected()
 
+        def _apply_api_session(user, pwd, susertoken):
+            self.api = FlatTradeApiPy()
+            kwargs = {"userid": user, "password": pwd, "usertoken": susertoken}
+            try:
+                params = inspect.signature(self.api.set_session).parameters
+            except (TypeError, ValueError):
+                params = {}
+            if "accesstoken" in params:
+                kwargs["accesstoken"] = susertoken
+            self.api.set_session(**kwargs)
+            inject_oauth_header = getattr(self.api, "injectOAuthHeader", None)
+            if callable(inject_oauth_header):
+                inject_oauth_header(susertoken, user, user)
+
         def _restore_session_from_token(susertoken_path):
             """Attempt to restore session from existing token."""
             try:
@@ -515,8 +553,7 @@ class FlatTrade(BrokerBase):
                     trading_logger.log_warning("Empty token file", {"broker": self.broker.name})
                     return False
 
-                self.api = FlatTradeApiPy()
-                self.api.set_session(userid=user, password=pwd, usertoken=susertoken)
+                _apply_api_session(user, pwd, susertoken)
 
                 # Verify the session is actually working
                 if _verify_session(self):
@@ -557,14 +594,28 @@ class FlatTrade(BrokerBase):
                     "Accept": "application/json",
                     "Accept-Language": "en-US,en;q=0.5",
                     "Host": "authapi.flattrade.in",
-                    "Origin": f"{HOST}",
-                    "Referer": f"{HOST}/",
+                    "Origin": HOST,
+                    "Referer": f"{HOST}/?app_key={api_key}",
                 }
 
                 def encode_item(item):
                     encoded_item = hashlib.sha256(item.encode()).hexdigest()
                     return encoded_item
 
+                def ftauth_payload(sid, override=""):
+                    return {
+                        "UserName": user,
+                        "Password": encode_item(pwd),
+                        "App": "",
+                        "ClientID": "",
+                        "Key": "",
+                        "APIKey": api_key,
+                        "PAN_DOB": pyotp.TOTP(token).now(),
+                        "Sid": sid,
+                        "Override": override,
+                        "Version": "2",
+                    }
+
                 def get_authcode():
                     try:
                         with requests.Session() as session:
@@ -578,17 +629,7 @@ class FlatTrade(BrokerBase):
 
                                 response = session.post(
                                     routes["ftauth"],
-                                    json={
-                                        "UserName": user,
-                                        "Password": encode_item(pwd),
-                                        "App": "",
-                                        "ClientID": "",
-                                        "Key": "",
-                                        "APIKey": api_key,
-                                        "PAN_DOB": pyotp.TOTP(token).now(),
-                                        "Sid": sid,
-                                        "Override": "",
-                                    },
+                                    json=ftauth_payload(sid),
                                 )
 
                                 if response.status_code == 200:
@@ -600,17 +641,7 @@ class FlatTrade(BrokerBase):
                                         )
                                         response = session.post(
                                             routes["ftauth"],
-                                            json={
-                                                "UserName": user,
-                                                "Password": encode_item(pwd),
-                                                "App": "",
-                                                "ClientID": "",
-                                                "Key": "",
-                                                "APIKey": api_key,
-                                                "PAN_DOB": pyotp.TOTP(token).now(),
-                                                "Sid": sid,
-                                                "Override": "Y",
-                                            },
+                                            json=ftauth_payload(sid, "Y"),
                                         )
                                         if response.status_code == 200:
                                             response_data = response.json()
@@ -716,8 +747,7 @@ class FlatTrade(BrokerBase):
 
                         # Initialize API
                         try:
-                            self.api = FlatTradeApiPy()
-                            self.api.set_session(userid=user, password=pwd, usertoken=susertoken)
+                            _apply_api_session(user, pwd, susertoken)
                             trading_logger.log_info("API session established", {"user": user})
                         except Exception as e:
                             context = create_error_context(user=user, error=str(e))
@@ -1152,7 +1182,10 @@ class FlatTrade(BrokerBase):
     @retry_on_error(max_retries=2, delay=1.0, backoff_factor=2.0)
     def update_symbology(self, **kwargs):
         dt_today = get_tradingapi_now().date()
-        symbols_path = os.path.join(config.get(f"{self.account_key}.SYMBOLCODES"), f"{dt_today}_symbols.csv")
+        symbols_path = os.path.join(
+            config.get(f"{self.account_key}.SYMBOLCODES"),
+            f"{dt_today:%Y%m%d}_symbols.csv",
+        )
         if not os.path.exists(symbols_path):
             codes = save_symbol_data(saveToFolder=False)
             codes = codes.dropna(subset=["long_symbol"])
@@ -1165,13 +1198,17 @@ class FlatTrade(BrokerBase):
         # Iterate through the data frame and create mappings based on exchange
 
         for exchange, group in codes.groupby("Exch"):
+            scrip_int = pd.to_numeric(group["Scripcode"], errors="coerce")
+            scrip_int = scrip_int.apply(lambda x: int(x) if pd.notna(x) else None)
             self.exchange_mappings[exchange] = {
-                "symbol_map": dict(zip(group["long_symbol"], group["Scripcode"])),
+                "symbol_map": dict(zip(group["long_symbol"], scrip_int)),
                 "contractsize_map": dict(zip(group["long_symbol"], group["LotSize"])),
                 "exchange_map": dict(zip(group["long_symbol"], group["Exch"])),
                 "exchangetype_map": dict(zip(group["long_symbol"], group["ExchType"])),
                 "contracttick_map": dict(zip(group["long_symbol"], group["TickSize"])),
-                "symbol_map_reversed": dict(zip(group["Scripcode"], group["long_symbol"])),
+                "symbol_map_reversed": {
+                    code: name for code, name in zip(scrip_int, group["long_symbol"]) if code is not None
+                },
                 "tradingsymbol_map": dict(zip(group["long_symbol"], group["trading_symbol"])),
             }
         return codes
@@ -1379,6 +1416,7 @@ class FlatTrade(BrokerBase):
                                 order.message = "No broker order ID in response"
                                 return order
 
+                            fills = None
                             try:
                                 fills = self.get_order_info(broker_order_id=order.broker_order_id)
                                 order.exch_order_id = fills.exchange_order_id
@@ -1397,9 +1435,8 @@ class FlatTrade(BrokerBase):
                                     "Error getting order history", e, {"broker_order_id": order.broker_order_id}
                                 )
 
-                            if order.price == 0:
-                                if fills.fill_price > 0 and order.price == 0:
-                                    order.price = fills.fill_price
+                            if order.price == 0 and fills is not None and fills.fill_price > 0:
+                                order.price = fills.fill_price
 
                             trading_logger.log_info("Placed Order", {"order": str(order)})
                         else:
@@ -1698,13 +1735,13 @@ class FlatTrade(BrokerBase):
                 broker=self.broker,
             )
 
+        valid_date = None
         try:
             valid_date = parse_datetime(order.remote_order_id[:8])
-            date_valid = True
         except (ValueError, TypeError):
-            date_valid = False
+            pass
         # Compare as string: valid_date is datetime from parse_datetime; only use return_db_as_fills for past days
-        if date_valid and (
+        if valid_date is not None and (
             valid_date.strftime("%Y-%m-%d") != dt.datetime.today().strftime("%Y-%m-%d")
             or (order.remote_order_id != "" and order.broker != self.broker)
         ):
@@ -1904,16 +1941,14 @@ class FlatTrade(BrokerBase):
             if refresh_mapping:
                 try:
                     # Parse date_end to get YYYYMMDD format
+                    date_end_for_mapping = None
                     try:
-                        date_end_dt = parse_datetime(date_end)
-                        date_end_str = date_end_dt.strftime("%Y-%m-%d")
-                        date_end_valid = True
+                        date_end_for_mapping = parse_datetime(date_end)
                     except (ValueError, TypeError):
-                        date_end_valid = False
-                    if not date_end_valid:
+                        pass
+                    if not isinstance(date_end_for_mapping, (dt.datetime, dt.date)):
                         raise ValueError(f"Invalid date_end format: {date_end}")
-                    date_end_obj = dt.datetime.strptime(str(date_end_str), "%Y-%m-%d")
-                    date_end_yyyymmdd = date_end_obj.strftime("%Y%m%d")
+                    date_end_yyyymmdd = date_end_for_mapping.strftime("%Y%m%d")
 
                     # Get symbol codes path from config
                     symbol_codes_path = config.get(f"{self.account_key}.SYMBOLCODES")
@@ -2010,16 +2045,12 @@ class FlatTrade(BrokerBase):
                 # once NSENIFTY is amended to NIFTY in databae, we can remove this line.
 
                 # Parse date_start (accepts datetime, date, or string) -> datetime for API
+                date_start_parsed = None
                 try:
                     date_start_parsed = parse_datetime(date_start)
-                    date_start_valid = True
                 except (ValueError, TypeError):
-                    date_start_valid = False
-                if (
-                    not date_start_valid
-                    or date_start_parsed is None
-                    or not isinstance(date_start_parsed, (dt.datetime, dt.date))
-                ):
+                    pass
+                if not isinstance(date_start_parsed, (dt.datetime, dt.date)):
                     raise ValueError(f"Invalid date_start format: {date_start}")
                 date_start_dt = dt.datetime.strptime(
                     date_start_parsed.strftime("%Y-%m-%d") + " " + resolved_market_open_time,
@@ -2027,16 +2058,12 @@ class FlatTrade(BrokerBase):
                 )
 
                 # Parse date_end (accepts datetime, date, or string) -> datetime for API
+                date_end_parsed = None
                 try:
                     date_end_parsed = parse_datetime(date_end)
-                    date_end_valid = True
                 except (ValueError, TypeError):
-                    date_end_valid = False
-                if (
-                    not date_end_valid
-                    or date_end_parsed is None
-                    or not isinstance(date_end_parsed, (dt.datetime, dt.date))
-                ):
+                    pass
+                if not isinstance(date_end_parsed, (dt.datetime, dt.date)):
                     raise ValueError(f"Invalid date_end format: {date_end}")
                 date_end_dt = dt.datetime.strptime(
                     date_end_parsed.strftime("%Y-%m-%d") + " " + resolved_market_close_time,
@@ -2352,12 +2379,12 @@ class FlatTrade(BrokerBase):
         if self.api is None:
             raise BrokerConnectionError("FlatTrade API is not initialized")
 
+        market_feed = Price()
+        market_feed.src = "sh"
+        market_feed.symbol = long_symbol
         try:
             trading_logger.log_debug("Fetching quote", {"long_symbol": long_symbol, "exchange": exchange})
             mapped_exchange = self.map_exchange_for_api(long_symbol, exchange)
-            market_feed = Price()  # Initialize with default values
-            market_feed.src = "sh"
-            market_feed.symbol = long_symbol
 
             # Validate exchange mapping exists
             if mapped_exchange not in self.exchange_mappings:
@@ -2647,7 +2674,9 @@ class FlatTrade(BrokerBase):
                                     list(self.subscribed_symbols) if hasattr(self, "subscribed_symbols") else []
                                 )
                                 if active_symbols:
-                                    reconnect_req_list = expand_symbols_to_request(active_symbols)
+                                    reconnect_req_list = list(self.subscribed_req_tokens) or expand_symbols_to_request(
+                                        active_symbols
+                                    )
                                     trading_logger.log_info(
                                         "Resubscribing to symbols after reconnection",
                                         {"symbols_count": len(active_symbols), "req_list": reconnect_req_list},
@@ -2700,11 +2729,20 @@ class FlatTrade(BrokerBase):
                     time.sleep(1)
 
             def resolve_exchange_from_symbology(long_symbol: str):
-                """Resolve API exchange for a symbol from symbology (which exchange's symbol_map contains it)."""
+                """Prefer the caller's exchange so dual-listed names (e.g. INFY) stay on NSE vs BSE."""
+                preferred = None
+                try:
+                    preferred = self.map_exchange_for_api(long_symbol, exchange)
+                except Exception:
+                    preferred = mapped_exchange
+                if preferred:
+                    symbol_map = self.exchange_mappings.get(preferred, {}).get("symbol_map", {})
+                    if long_symbol in symbol_map:
+                        return preferred
                 for exch in self.exchange_mappings:
                     if long_symbol in self.exchange_mappings[exch]["symbol_map"]:
                         return exch
-                return None
+                return preferred
 
             # Function to expand symbols into request format
             def expand_symbols_to_request(symbol_list):
@@ -2745,34 +2783,32 @@ class FlatTrade(BrokerBase):
                 return req_list
 
             # Function to update the subscription list
-            def update_subscription_list(operation, symbols):
+            def update_subscription_list(operation, symbols, tokens):
                 if operation == "s":
                     self.subscribed_symbols = list(set(self.subscribed_symbols + symbols))
+                    self.subscribed_req_tokens = list(set(self.subscribed_req_tokens + tokens))
                 elif operation == "u":
                     self.subscribed_symbols = list(set(self.subscribed_symbols) - set(symbols))
+                    self.subscribed_req_tokens = [t for t in self.subscribed_req_tokens if t not in tokens]
 
-            # Update subscriptions and request list
-            update_subscription_list(operation, symbols)
             req_list = expand_symbols_to_request(symbols)
+            update_subscription_list(operation, symbols, req_list)
 
-            # Start the WebSocket connection if not already started
             if self.subscribe_thread is None:
                 self.subscribe_thread = threading.Thread(target=connect_and_subscribe, name="MarketDataStreamer")
                 self.subscribe_thread.start()
 
-            # Wait until the socket is opened before subscribing/unsubscribing
             while not self.socket_opened:
                 time.sleep(1)
 
-                # Manage subscription based on operation
-                if req_list:
-                    if operation == "s":
-                        trading_logger.log_info("Requesting streaming", {"req_list": req_list})
-                        self._wait_for_stream_request_rate_limit()
-                        self.api.subscribe(req_list)
-                    elif operation == "u":
-                        trading_logger.log_info("Unsubscribing streaming", {"req_list": req_list})
-                        self.api.unsubscribe(req_list)
+            if req_list:
+                if operation == "s":
+                    trading_logger.log_info("Requesting streaming", {"req_list": req_list})
+                    self._wait_for_stream_request_rate_limit()
+                    self.api.subscribe(req_list)
+                elif operation == "u":
+                    trading_logger.log_info("Unsubscribing streaming", {"req_list": req_list})
+                    self.api.unsubscribe(req_list)
         except Exception as e:
             trading_logger.log_error(
                 "Unexpected error in start_quotes_streaming",
@@ -2780,6 +2816,25 @@ class FlatTrade(BrokerBase):
                 {"operation": operation, "symbols_count": len(symbols) if symbols else 0, "exchange": exchange},
             )
 
+    @log_execution_time
+    @retry_on_error(max_retries=2, delay=1.0, backoff_factor=2.0)
+    def stop_streaming(self):
+        try:
+            trading_logger.log_info("Stopping quotes streaming")
+            if hasattr(self, "api") and self.api and getattr(self, "socket_opened", False):
+                try:
+                    self.api.close_websocket()
+                except Exception as e:
+                    trading_logger.log_warning("Failed to close WebSocket", {"error": str(e)})
+            self.socket_opened = False
+            self.subscribe_thread = None
+            self.subscribed_symbols = []
+            self.subscribed_req_tokens = []
+            trading_logger.log_info("Streaming stopped successfully")
+        except Exception as e:
+            context = create_error_context(error=str(e))
+            raise BrokerConnectionError(f"Failed to stop streaming: {str(e)}", context)
+
     @log_execution_time
     @validate_inputs(long_symbol=lambda x: x is None or (isinstance(x, str) and len(x.strip()) >= 0))
     @retry_on_error(max_retries=2, delay=1.0, backoff_factor=2.0)
@@ -2802,7 +2857,8 @@ class FlatTrade(BrokerBase):
                         holding = pd.DataFrame([raw_holding])
                     else:
                         holding = pd.DataFrame(columns=["long_symbol", "quantity"])
-
+                    if len(holding) == 0:
+                        holding = pd.DataFrame(columns=["long_symbol", "quantity"]).astype({"quantity": float})
                     if len(holding) > 0:
                         try:
                             if "exch" not in holding.columns and "exch_tsym" not in holding.columns:
@@ -3056,14 +3112,29 @@ class FlatTrade(BrokerBase):
                 {"row_count": len(scripcode)},
             )
 
+            def mapping_keys(exchange_val):
+                raw = "" if exchange_val is None or (isinstance(exchange_val, float) and pd.isna(exchange_val)) else str(exchange_val).strip()
+                if raw in self.exchange_mappings:
+                    return [raw]
+                up = raw.upper()
+                if up in self.exchange_mappings:
+                    return [up]
+                if not up:
+                    return list(self.exchange_mappings.keys())
+                keyed = [k for k in self.exchange_mappings if str(k).upper().startswith(up[0])]
+                return keyed if keyed else list(self.exchange_mappings.keys())
+
             def lookup(scripcode_val, exchange_val):
                 try:
-                    exch_map = self.exchange_mappings.get(exchange_val, {})
-                    rev = exch_map.get("symbol_map_reversed", {})
-                    code = int(scripcode_val) if scripcode_val is not None else None
+                    code = int(float(scripcode_val)) if scripcode_val is not None and not pd.isna(scripcode_val) else None
                     if code is None:
                         return None
-                    return rev.get(code) or rev.get(scripcode_val)
+                    for key in mapping_keys(exchange_val):
+                        rev = self.exchange_mappings.get(key, {}).get("symbol_map_reversed", {})
+                        found = rev.get(code) or rev.get(scripcode_val)
+                        if found:
+                            return found
+                    return None
                 except (TypeError, ValueError, KeyError):
                     return None
 
@@ -3114,9 +3185,19 @@ class FlatTrade(BrokerBase):
                 )
                 raise SymbolError(f"Exchange mapping not found: {str(e)}", context)
 
+            lot_from_map = self.exchange_mappings[exchange]["contractsize_map"].get(long_symbol)
+            if lot_from_map is not None and pd.notna(lot_from_map):
+                return int(lot_from_map)
+
             if code is not None:
                 try:
-                    series = cast(pd.Series, self.codes.loc[self.codes.Scripcode == code, "LotSize"])
+                    series = cast(
+                        pd.Series,
+                        self.codes.loc[
+                            (self.codes.Scripcode == code) & (self.codes.Exch == exchange),
+                            "LotSize",
+                        ],
+                    )
                     if len(series) > 0:
                         lot_size = int(series.iloc[0])
                     else:

{tradingapi-0.4.0 → tradingapi-0.5.0}/tradingapi/shoonya.py

@@ -392,6 +392,7 @@ class Shoonya(BrokerBase):
         self.api = None
         self.subscribe_thread = None
         self.subscribed_symbols = []
+        self.subscribed_req_tokens: List[str] = []
         self.socket_opened = False
         self._is_connected_cache_ttl_secs = 3.0
         self._last_is_connected_check_ts = 0.0
@@ -2880,7 +2881,9 @@ class Shoonya(BrokerBase):
                                     list(self.subscribed_symbols) if hasattr(self, "subscribed_symbols") else []
                                 )
                                 if active_symbols:
-                                    reconnect_req_list = expand_symbols_to_request(active_symbols)
+                                    reconnect_req_list = list(self.subscribed_req_tokens) or expand_symbols_to_request(
+                                        active_symbols
+                                    )
                                     trading_logger.log_info(
                                         "Resubscribing to symbols after reconnection",
                                         {
@@ -2937,11 +2940,20 @@ class Shoonya(BrokerBase):
                     time.sleep(1)
 
             def resolve_exchange_from_symbology(long_symbol: str):
-                """Resolve API exchange for a symbol from symbology (which exchange's symbol_map contains it)."""
+                """Prefer the caller's exchange so dual-listed names (e.g. INFY) stay on NSE vs BSE."""
+                preferred = None
+                try:
+                    preferred = self.map_exchange_for_api(long_symbol, exchange)
+                except Exception:
+                    preferred = mapped_exchange
+                if preferred:
+                    symbol_map = self.exchange_mappings.get(preferred, {}).get("symbol_map", {})
+                    if long_symbol in symbol_map:
+                        return preferred
                 for exch in self.exchange_mappings:
                     if long_symbol in self.exchange_mappings[exch]["symbol_map"]:
                         return exch
-                return None
+                return preferred
 
             # Function to expand symbols into request format
             def expand_symbols_to_request(symbol_list) -> List[str]:
@@ -2982,34 +2994,33 @@ class Shoonya(BrokerBase):
                 return req_list
 
             # Function to update the subscription list
-            def update_subscription_list(operation, symbols) -> None:
+            def update_subscription_list(operation, symbols, tokens) -> None:
                 if operation == "s":
                     self.subscribed_symbols = list(set(self.subscribed_symbols + symbols))
+                    self.subscribed_req_tokens = list(set(self.subscribed_req_tokens + tokens))
                 elif operation == "u":
                     self.subscribed_symbols = list(set(self.subscribed_symbols) - set(symbols))
+                    self.subscribed_req_tokens = [t for t in self.subscribed_req_tokens if t not in tokens]
 
-            # Update subscriptions and request list
-            update_subscription_list(operation, symbols)
             req_list = expand_symbols_to_request(symbols)
+            update_subscription_list(operation, symbols, req_list)
 
             # Start the WebSocket connection if not already started
             if self.subscribe_thread is None:
                 self.subscribe_thread = threading.Thread(target=connect_and_subscribe, name="MarketDataStreamer")
                 self.subscribe_thread.start()
 
-            # Wait until the socket is opened before subscribing/unsubscribing
             while not self.socket_opened:
                 time.sleep(1)
 
-                # Manage subscription based on operation
-                if req_list:
-                    if operation == "s":
-                        trading_logger.log_info("Requesting streaming", {"req_list": req_list})
-                        self._wait_for_stream_request_rate_limit()
-                        self.api.subscribe(req_list)
-                    elif operation == "u":
-                        trading_logger.log_info("Unsubscribing streaming", {"req_list": req_list})
-                        self.api.unsubscribe(req_list)
+            if req_list:
+                if operation == "s":
+                    trading_logger.log_info("Requesting streaming", {"req_list": req_list})
+                    self._wait_for_stream_request_rate_limit()
+                    self.api.subscribe(req_list)
+                elif operation == "u":
+                    trading_logger.log_info("Unsubscribing streaming", {"req_list": req_list})
+                    self.api.unsubscribe(req_list)
         except Exception as e:
             trading_logger.log_error(
                 "Unexpected error in start_quotes_streaming",
@@ -3017,6 +3028,25 @@ class Shoonya(BrokerBase):
                 {"operation": operation, "symbols_count": len(symbols) if symbols else 0, "exchange": exchange},
             )
 
+    @log_execution_time
+    @retry_on_error(max_retries=2, delay=1.0, backoff_factor=2.0)
+    def stop_streaming(self):
+        try:
+            trading_logger.log_info("Stopping quotes streaming")
+            if hasattr(self, "api") and self.api and getattr(self, "socket_opened", False):
+                try:
+                    self.api.close_websocket()
+                except Exception as e:
+                    trading_logger.log_warning("Failed to close WebSocket", {"error": str(e)})
+            self.socket_opened = False
+            self.subscribe_thread = None
+            self.subscribed_symbols = []
+            self.subscribed_req_tokens = []
+            trading_logger.log_info("Streaming stopped successfully")
+        except Exception as e:
+            context = create_error_context(error=str(e))
+            raise BrokerConnectionError(f"Failed to stop streaming: {str(e)}", context)
+
     @log_execution_time
     @validate_inputs(long_symbol=lambda x: x is None or (isinstance(x, str) and len(x.strip()) >= 0))
     @retry_on_error(max_retries=2, delay=1.0, backoff_factor=2.0)
@@ -3039,6 +3069,8 @@ class Shoonya(BrokerBase):
                         holding = pd.DataFrame([raw_holding])
                     else:
                         holding = pd.DataFrame(columns=["long_symbol", "quantity"])
+                    if len(holding) == 0:
+                        holding = pd.DataFrame(columns=["long_symbol", "quantity"]).astype({"quantity": float})
                     if len(holding) > 0:
                         try:
                             # Resolve long_symbol from mappings using Scripcode + Exchange
@@ -3310,14 +3342,37 @@ class Shoonya(BrokerBase):
                 {"row_count": len(scripcode)},
             )
 
+            def mapping_keys(exchange_val):
+                raw = (
+                    ""
+                    if exchange_val is None or (isinstance(exchange_val, float) and pd.isna(exchange_val))
+                    else str(exchange_val).strip()
+                )
+                if raw in self.exchange_mappings:
+                    return [raw]
+                up = raw.upper()
+                if up in self.exchange_mappings:
+                    return [up]
+                if not up:
+                    return list(self.exchange_mappings.keys())
+                keyed = [k for k in self.exchange_mappings if str(k).upper().startswith(up[0])]
+                return keyed if keyed else list(self.exchange_mappings.keys())
+
             def lookup(scripcode_val, exchange_val):
                 try:
-                    exch_map = self.exchange_mappings.get(exchange_val, {})
-                    rev = exch_map.get("symbol_map_reversed", {})
-                    code = int(scripcode_val) if scripcode_val is not None else None
+                    code = (
+                        int(float(scripcode_val))
+                        if scripcode_val is not None and not pd.isna(scripcode_val)
+                        else None
+                    )
                     if code is None:
                         return None
-                    return rev.get(code) or rev.get(scripcode_val)
+                    for key in mapping_keys(exchange_val):
+                        rev = self.exchange_mappings.get(key, {}).get("symbol_map_reversed", {})
+                        found = rev.get(code) or rev.get(scripcode_val)
+                        if found:
+                            return found
+                    return None
                 except (TypeError, ValueError, KeyError):
                     return None
 

{tradingapi-0.4.0 → tradingapi-0.5.0}/tradingapi/utils.py

@@ -2172,8 +2172,21 @@ def update_order_status(
             broker.redis_o.hset(broker_order_id, "quantity", str(fills.fill_size))
             broker.redis_o.hset(broker_order_id, "status", fills.status.name)
             broker.redis_o.hset(broker_order_id, "exch_order_id", fills.exchange_order_id)
-        else:
+        elif fills.status in (OrderStatus.CANCELLED, OrderStatus.REJECTED, OrderStatus.FILLED):
+            # Broker confirmed terminal zero-fill — safe to prune.
             delete_broker_order_id(broker, internal_order_id, broker_order_id)
+        else:
+            # UNDEFINED/OPEN/PENDING with fill_size=0 is often a failed/wrong-account
+            # lookup; never delete Redis state in that case.
+            trading_logger.log_warning(
+                "EOD skip delete for ambiguous zero-fill order status",
+                {
+                    "internal_order_id": internal_order_id,
+                    "broker_order_id": broker_order_id,
+                    "status": getattr(fills.status, "name", str(fills.status)),
+                    "fill_size": fills.fill_size,
+                },
+            )
     else:
         if fills.status == OrderStatus.HISTORICAL:
             return fills

{tradingapi-0.4.0 → tradingapi-0.5.0}/tradingapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradingapi
-Version: 0.4.0
+Version: 0.5.0
 Summary: Trade integration with brokers
 Author-email: Pankaj Sharma <sharma.pankaj.kumar@gmail.com>
 License-Expression: MIT
@@ -170,6 +170,10 @@ The package requires:
 - Redis (for order tracking and logging)
 - Broker-specific SDKs (automatically installed via dependencies)
 
+## Adding a new broker
+
+Step-by-step checklist (package, YAML, website, PnL/EOD, order manager): [`docs/ADDING_A_BROKER.md`](docs/ADDING_A_BROKER.md).
+
 ## Configuration
 
 ### Configuration File Structure

{tradingapi-0.4.0 → tradingapi-0.5.0}/tradingapi.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ tests/test_calculate_delta_realtime_quotes.py
 tests/test_find_option_with_delta.py
 tests/test_fivepaisa_historical_recovery.py
 tests/test_fivepaisa_stream_reconnect.py
+tests/test_flattrade_symbology.py
 tests/test_market_hours_config.py
 tradingapi/__init__.py
 tradingapi/allocation.py