tradingapi 0.3.7__tar.gz → 0.3.9__tar.gz

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

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

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

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

tradingapi-0.3.9/tests/test_broker_side_terminal_order.py

@@ -0,0 +1,30 @@
+from tradingapi.broker_base import (
+    is_broker_side_terminal_message,
+    is_broker_side_terminal_order,
+    is_missing_exchange_order_id,
+)
+
+
+def test_is_missing_exchange_order_id():
+    assert is_missing_exchange_order_id("0")
+    assert is_missing_exchange_order_id(0)
+    assert is_missing_exchange_order_id(None)
+    assert is_missing_exchange_order_id("")
+    assert not is_missing_exchange_order_id("2700000201461104")
+
+
+def test_is_broker_side_terminal_message():
+    assert is_broker_side_terminal_message("Trading not allowed in illiquid  contract")
+    assert is_broker_side_terminal_message("Order rejected by RMS")
+    assert is_broker_side_terminal_message(
+        "RMS:23226063020407:You have insufficient funds. Please add Rs.71301.37 to trade."
+    )
+    assert is_broker_side_terminal_message("Cancelled by user")
+    assert not is_broker_side_terminal_message("")
+    assert not is_broker_side_terminal_message("Success")
+
+
+def test_is_broker_side_terminal_order_requires_missing_exchange_id():
+    msg = "Trading not allowed in illiquid contract"
+    assert is_broker_side_terminal_order("0", msg)
+    assert not is_broker_side_terminal_order("12345", msg)

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

@@ -95,6 +95,49 @@ class OrderStatus(Enum):
     CANCELLED = 7  # Cancelled by Exchange
 
 
+_BROKER_SIDE_TERMINAL_KEYWORDS = (
+    "illiquid",
+    "not allowed",
+    "not permitted",
+    "barred",
+    "freeze",
+    "frozen",
+    "restricted",
+    "invalid contract",
+    "invalid scrip",
+    "security not available",
+    "order rejected",
+    "rejected by",
+    "cannot place",
+    "unable to place",
+    "trading disabled",
+    "not tradable",
+    "not tradeable",
+    "margin shortfall",
+    "insufficient margin",
+    "insufficient funds",
+    "rms reject",
+)
+
+
+def is_missing_exchange_order_id(exch_order_id) -> bool:
+    value = str(exch_order_id or "").strip()
+    return value in {"", "0", "None", "NONE", "null", "nan", "NaN"}
+
+
+def is_broker_side_terminal_message(message: str) -> bool:
+    msg = str(message or "").strip().lower()
+    if not msg:
+        return False
+    if "reject" in msg or "cancel" in msg:
+        return True
+    return any(keyword in msg for keyword in _BROKER_SIDE_TERMINAL_KEYWORDS)
+
+
+def is_broker_side_terminal_order(exch_order_id, message: str) -> bool:
+    return is_missing_exchange_order_id(exch_order_id) and is_broker_side_terminal_message(message)
+
+
 def _validate_quantity(quantity):
     """
     Validate quantity parameter that can be int, float, or string representation.
@@ -756,6 +799,86 @@ class BrokerBase(ABC):
             "symbol_map_reversed": {},
         }
 
+    def _request_cancel_broker_side_terminal_order(self, order: "Order") -> bool:
+        """Send an explicit broker cancel when the order may still be live."""
+        broker_order_id = str(getattr(order, "broker_order_id", "") or "").strip()
+        if not broker_order_id or broker_order_id == "0" or broker_order_id.upper().endswith("P"):
+            return False
+        if getattr(order, "paper", False) in (True, "True", "true"):
+            return False
+        try:
+            self.cancel_order(broker_order_id=broker_order_id, resolve_terminal=False)
+            return True
+        except Exception as e:
+            _get_trading_logger().log_warning(
+                "Cancel request failed for broker-side terminal order",
+                {"broker_order_id": broker_order_id, "error": str(e)},
+            )
+            return False
+
+    def _resolve_broker_side_terminal_order(
+        self,
+        order: "Order",
+        message: str,
+        *,
+        order_size=None,
+        order_price=None,
+    ) -> OrderInfo:
+        """Cancel if possible and return a zero-fill CANCELLED OrderInfo."""
+        broker_order_id = str(getattr(order, "broker_order_id", "") or "").strip()
+        if message:
+            order.message = message
+            if broker_order_id:
+                try:
+                    self.redis_o.hset(broker_order_id, "message", message)
+                except Exception:
+                    pass
+
+        cancel_requested = self._request_cancel_broker_side_terminal_order(order)
+        order.status = OrderStatus.CANCELLED
+        if broker_order_id:
+            try:
+                self.redis_o.hset(broker_order_id, "status", OrderStatus.CANCELLED.name)
+            except Exception:
+                pass
+
+        _get_trading_logger().log_info(
+            "Broker-side terminal order resolved as cancelled",
+            {
+                "broker_order_id": broker_order_id,
+                "long_symbol": getattr(order, "long_symbol", ""),
+                "message": message,
+                "cancel_requested": cancel_requested,
+            },
+        )
+        return OrderInfo(
+            order_size=order_size if order_size is not None else order.quantity,
+            order_price=order_price if order_price is not None else order.price,
+            fill_size=0,
+            fill_price=0,
+            status=OrderStatus.CANCELLED,
+            broker_order_id=broker_order_id,
+            exchange_order_id=getattr(order, "exch_order_id", ""),
+            broker=getattr(order, "broker", None) or self.broker,
+        )
+
+    def _apply_broker_side_terminal_resolution(
+        self,
+        order: "Order",
+        order_info: OrderInfo,
+        message: Optional[str] = None,
+    ) -> OrderInfo:
+        msg = str(message if message is not None else getattr(order, "message", "") or "").strip()
+        exch_id = order_info.exchange_order_id or getattr(order, "exch_order_id", "")
+        if not is_broker_side_terminal_order(exch_id, msg):
+            return order_info
+        return self._resolve_broker_side_terminal_order(
+            order,
+            msg,
+            order_size=order_info.order_size,
+            order_price=order_info.order_price,
+        )
+
     @abstractmethod
     def update_symbology(self, **kwargs):
         """

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

@@ -1476,7 +1476,11 @@ class Dhan(BrokerBase):
 
             fills = None
             try:
-                fills = self.get_order_info(broker_order_id=broker_order_id, order=order)
+                fills = self.get_order_info(
+                    broker_order_id=broker_order_id,
+                    order=order,
+                    resolve_terminal=kwargs.get("resolve_terminal", False),
+                )
             except Exception:
                 pass
 
@@ -1617,15 +1621,7 @@ class Dhan(BrokerBase):
             if order is not None and error_message:
                 order.message = error_message
 
-            if status == OrderStatus.REJECTED:
-                try:
-                    internal_order_id = self.redis_o.hget(broker_order_id, "orderRef")
-                    if internal_order_id:
-                        delete_broker_order_id(self, internal_order_id, broker_order_id)
-                except Exception:
-                    pass
-
-            return OrderInfo(
+            order_info = OrderInfo(
                 order_size=order_qty,
                 order_price=order_price,
                 fill_size=fill_size,
@@ -1635,6 +1631,20 @@ class Dhan(BrokerBase):
                 exchange_order_id=exch_order_id,
                 broker=self.broker,
             )
+            if kwargs.get("resolve_terminal", True):
+                order_info = self._apply_broker_side_terminal_resolution(
+                    order, order_info, message=error_message or order.message
+                )
+
+            if order_info.status == OrderStatus.REJECTED:
+                try:
+                    internal_order_id = self.redis_o.hget(broker_order_id, "orderRef")
+                    if internal_order_id:
+                        delete_broker_order_id(self, internal_order_id, broker_order_id)
+                except Exception:
+                    pass
+
+            return order_info
 
         except (ValidationError, OrderError, BrokerConnectionError):
             raise

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

@@ -85,7 +85,19 @@ def _patch_py5paisa_for_mom(api) -> None:
     api.multi_order_Margin = fixed_multi_order_Margin
     api._tradingapi_patched = True
 
-from .broker_base import BrokerBase, Brokers, HistoricalData, Order, OrderInfo, OrderStatus, Price, _normalize_as_of_date
+from .broker_base import (
+    BrokerBase,
+    Brokers,
+    HistoricalData,
+    Order,
+    OrderInfo,
+    OrderStatus,
+    Price,
+    _normalize_as_of_date,
+    is_broker_side_terminal_message,
+    is_broker_side_terminal_order,
+    is_missing_exchange_order_id,
+)
 from .config import get_config
 from .utils import (
     delete_broker_order_id,
@@ -1914,6 +1926,17 @@ class FivePaisa(BrokerBase):
             context = create_error_context(kwargs=kwargs, error=str(e))
             raise OrderError(f"Unexpected error modifying order: {str(e)}", context)
 
+    @log_execution_time
+    @validate_inputs(broker_order_id=lambda x: isinstance(x, str) and len(x.strip()) > 0)
+    def _request_cancel_broker_side_terminal_order(self, order: Order) -> bool:
+        if is_missing_exchange_order_id(getattr(order, "exch_order_id", None)):
+            trading_logger.log_info(
+                "FivePaisa order blocked before exchange; marking cancelled locally",
+                {"broker_order_id": order.broker_order_id, "message": order.message},
+            )
+            return False
+        return super()._request_cancel_broker_side_terminal_order(order)
+
     @log_execution_time
     @validate_inputs(broker_order_id=lambda x: isinstance(x, str) and len(x.strip()) > 0)
     def cancel_order(self, **kwargs) -> Order:
@@ -1968,7 +1991,11 @@ class FivePaisa(BrokerBase):
                     if date_matches:
                         # Get current order info
                         try:
-                            fills = self.get_order_info(broker_order_id=broker_order_id, order=order)
+                            fills = self.get_order_info(
+                                broker_order_id=broker_order_id,
+                                order=order,
+                                resolve_terminal=kwargs.get("resolve_terminal", False),
+                            )
                         except Exception as e:
                             trading_logger.log_error(
                                 "Failed to get order info for cancellation",
@@ -2247,6 +2274,7 @@ class FivePaisa(BrokerBase):
         """
         try:
             trading_logger.log_debug("Getting order info", {"broker_order_id": kwargs.get("broker_order_id")})
+            resolve_terminal = kwargs.get("resolve_terminal", True)
 
             def return_db_as_fills(order: Order):
                 """Return order info from database for historical orders."""
@@ -2272,6 +2300,11 @@ class FivePaisa(BrokerBase):
                     trading_logger.log_error("Error in return_db_as_fills", e, {"order": str(order)})
                     raise
 
+            def _finalize_order_book_info(order: Order, order_info: OrderInfo, reason: str = "") -> OrderInfo:
+                if not resolve_terminal:
+                    return order_info
+                return self._apply_broker_side_terminal_resolution(order, order_info, message=reason or order.message)
+
             def get_orderinfo_from_orders(exch_order_id: str, order: Order, broker_order_id: str) -> OrderInfo:
                 """Get order info from order book."""
                 try:
@@ -2281,21 +2314,18 @@ class FivePaisa(BrokerBase):
                     if len(orders) > 0:
                         fivepaisa_order = orders[orders.BrokerOrderId.astype(str) == str(broker_order_id)]
                         if len(fivepaisa_order) == 1:
-                            if fivepaisa_order.OrderStatus.str.lower().str.contains("rejected").iloc[0] is True:
-                                # order cancelled by broker before reaching exchange
-                                trading_logger.log_info(
-                                    "Order rejected by broker",
-                                    {"broker_order_id": broker_order_id, "reason": str(fivepaisa_order.Reason.iloc[0])},
-                                )
-                                broker_order_id = str(fivepaisa_order.BrokerOrderId.iloc[0])
-                                try:
-                                    internal_order_id = self.redis_o.hget(broker_order_id, "orderRef")
-                                    if internal_order_id is not None:
-                                        delete_broker_order_id(self, internal_order_id, broker_order_id)
-                                except Exception as e:
-                                    trading_logger.log_warning(
-                                        "Failed to delete broker order ID",
-                                        {"broker_order_id": broker_order_id, "error": str(e)},
+                            reason = str(fivepaisa_order.Reason.iloc[0] if "Reason" in fivepaisa_order.columns else "")
+                            exch_id = fivepaisa_order.ExchOrderID.iloc[0]
+                            if (
+                                fivepaisa_order.OrderStatus.str.lower().str.contains("rejected").iloc[0] is True
+                                or is_broker_side_terminal_order(exch_id, reason or order.message)
+                            ):
+                                if resolve_terminal:
+                                    return self._resolve_broker_side_terminal_order(
+                                        order,
+                                        reason or order.message,
+                                        order_size=order.quantity,
+                                        order_price=order.price,
                                     )
                                 return OrderInfo(
                                     order_size=order.quantity,
@@ -2304,7 +2334,7 @@ class FivePaisa(BrokerBase):
                                     fill_price=0,
                                     status=OrderStatus.REJECTED,
                                     broker_order_id=order.broker_order_id,
-                                    exchange_order_id=fivepaisa_order.ExchOrderID.iloc[0],
+                                    exchange_order_id=exch_id,
                                     broker=self.broker,
                                 )
                             else:
@@ -2332,15 +2362,19 @@ class FivePaisa(BrokerBase):
                                         contract_size = self.exchange_mappings[order.exchange]["contractsize_map"].get(
                                             long_symbol
                                         )
-                                        return OrderInfo(
-                                            order_size=order.quantity,
-                                            order_price=order.price,
-                                            fill_size=fill_size * contract_size,
-                                            fill_price=fill_price,
-                                            status=status,
-                                            broker_order_id=order.broker_order_id,
-                                            exchange_order_id=fivepaisa_order.ExchOrderID.iloc[0],
-                                            broker=self.broker,
+                                        return _finalize_order_book_info(
+                                            order,
+                                            OrderInfo(
+                                                order_size=order.quantity,
+                                                order_price=order.price,
+                                                fill_size=fill_size * contract_size,
+                                                fill_price=fill_price,
+                                                status=status,
+                                                broker_order_id=order.broker_order_id,
+                                                exchange_order_id=fivepaisa_order.ExchOrderID.iloc[0],
+                                                broker=self.broker,
+                                            ),
+                                            reason,
                                         )
                                     except Exception as e:
                                         trading_logger.log_error(
@@ -2350,15 +2384,19 @@ class FivePaisa(BrokerBase):
                                         )
                                         raise
                                 else:
-                                    return OrderInfo(
-                                        order_size=order.quantity,
-                                        order_price=order.price,
-                                        fill_size=fill_size,
-                                        fill_price=fill_price,
-                                        status=status,
-                                        broker_order_id=order.broker_order_id,
-                                        exchange_order_id=fivepaisa_order.ExchOrderID.iloc[0],
-                                        broker=self.broker,
+                                    return _finalize_order_book_info(
+                                        order,
+                                        OrderInfo(
+                                            order_size=order.quantity,
+                                            order_price=order.price,
+                                            fill_size=fill_size,
+                                            fill_price=fill_price,
+                                            status=status,
+                                            broker_order_id=order.broker_order_id,
+                                            exchange_order_id=fivepaisa_order.ExchOrderID.iloc[0],
+                                            broker=self.broker,
+                                        ),
+                                        reason,
                                     )
                         else:
                             trading_logger.log_debug(
@@ -2400,15 +2438,19 @@ class FivePaisa(BrokerBase):
                                             contract_size = self.exchange_mappings[order.exchange][
                                                 "contractsize_map"
                                             ].get(long_symbol)
-                                            return OrderInfo(
-                                                order_size=order_size,
-                                                order_price=order_price,
-                                                fill_size=fill_size * contract_size,
-                                                fill_price=fill_price,
-                                                status=status,
-                                                broker_order_id=broker_order_id,
-                                                exchange_order_id=row["ExchOrderID"],
-                                                broker=self.broker,
+                                            return _finalize_order_book_info(
+                                                order,
+                                                OrderInfo(
+                                                    order_size=order_size,
+                                                    order_price=order_price,
+                                                    fill_size=fill_size * contract_size,
+                                                    fill_price=fill_price,
+                                                    status=status,
+                                                    broker_order_id=broker_order_id,
+                                                    exchange_order_id=row["ExchOrderID"],
+                                                    broker=self.broker,
+                                                ),
+                                                str(row.get("Reason", "")),
                                             )
                                         except Exception as e:
                                             trading_logger.log_error(
@@ -2418,15 +2460,19 @@ class FivePaisa(BrokerBase):
                                             )
                                             raise
                                     else:
-                                        return OrderInfo(
-                                            order_size=order_size,
-                                            order_price=order_price,
-                                            fill_size=fill_size,
-                                            fill_price=fill_price,
-                                            status=status,
-                                            broker_order_id=broker_order_id,
-                                            exchange_order_id=row["ExchOrderID"],
-                                            broker=self.broker,
+                                        return _finalize_order_book_info(
+                                            order,
+                                            OrderInfo(
+                                                order_size=order_size,
+                                                order_price=order_price,
+                                                fill_size=fill_size,
+                                                fill_price=fill_price,
+                                                status=status,
+                                                broker_order_id=broker_order_id,
+                                                exchange_order_id=row["ExchOrderID"],
+                                                broker=self.broker,
+                                            ),
+                                            str(row.get("Reason", "")),
                                         )
                     return OrderInfo(
                         order_size=order.quantity,
@@ -2534,20 +2580,14 @@ class FivePaisa(BrokerBase):
                 )
 
             # Handle orders with no exchange order ID
-            if order.exch_order_id in [0, "0", None, "None"]:
-                if "reject" in order.message.lower() or "cancel" in order.message.lower():
-                    fills = OrderInfo()
-                    if "reject" in order.message.lower():
-                        fills.status = OrderStatus.REJECTED
-                    if "cancel" in order.message.lower():
-                        fills.status = OrderStatus.CANCELLED
-                    fills.fill_price = 0
-                    fills.fill_size = 0
-                    fills.broker = self.broker
-                    fills.broker_order_id = order.broker_order_id
-                    fills.order_price = order.price
-                    fills.order_size = order.quantity
-                    return fills
+            if is_missing_exchange_order_id(order.exch_order_id):
+                if resolve_terminal and is_broker_side_terminal_message(order.message):
+                    return self._resolve_broker_side_terminal_order(
+                        order,
+                        order.message,
+                        order_size=order.quantity,
+                        order_price=order.price,
+                    )
                 return get_orderinfo_from_orders("0", order=order, broker_order_id=broker_order_id)
             else:
                 # Handle orders with exchange order ID
@@ -3625,6 +3665,14 @@ class FivePaisa(BrokerBase):
 
                 return None, tick_exchange
 
+            def is_market_feed_payload(data):
+                """True for MarketFeedV3 tick objects; false for trade/order pushes (ReqType) and subscribe acks."""
+                if not isinstance(data, dict):
+                    return False
+                if data.get("ReqType"):
+                    return False
+                return any(k in data for k in ("Token", "LastRate", "BidRate", "TickDt"))
+
             def map_to_price(json_data):
                 """Map JSON data to Price object."""
                 try:
@@ -3666,12 +3714,16 @@ class FivePaisa(BrokerBase):
                     json_data = json.loads(data_str)
                     if isinstance(json_data, list):
                         for tick_data in json_data:
+                            if not is_market_feed_payload(tick_data):
+                                continue
                             price = map_to_price(tick_data)
                             if price is not None:
                                 self._last_stream_tick_ts = time.time()
                             if price is not None and ext_callback:
                                 ext_callback(price)
                     elif isinstance(json_data, dict):
+                        if not is_market_feed_payload(json_data):
+                            return
                         price = map_to_price(json_data)
                         if price is not None:
                             self._last_stream_tick_ts = time.time()

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

@@ -1608,7 +1608,7 @@ class FlatTrade(BrokerBase):
             except (ValueError, TypeError):
                 date_matches = False
             if date_matches:
-                fills = self.get_order_info(broker_order_id=broker_order_id)
+                fills = self.get_order_info(broker_order_id=broker_order_id, resolve_terminal=kwargs.get("resolve_terminal", False))
                 if fills.fill_size < round(float(order.quantity)):
                     trading_logger.log_info(
                         "Cancelling broker order",
@@ -1644,6 +1644,7 @@ class FlatTrade(BrokerBase):
             raise BrokerConnectionError("FlatTrade API is not initialized")
 
         trading_logger.log_debug("Getting order info", {"broker_order_id": kwargs.get("broker_order_id")})
+        resolve_terminal = kwargs.get("resolve_terminal", True)
 
         def return_db_as_fills(order: Order) -> OrderInfo:
             order_info = OrderInfo()
@@ -1728,6 +1729,9 @@ class FlatTrade(BrokerBase):
             order_info.status = status_mapping[latest_status.get("status")]
         else:
             order_info.status = OrderStatus.UNDEFINED
+        if resolve_terminal:
+            terminal_message = latest_status.get("rejreason") or latest_status.get("emsg") or order.message
+            order_info = self._apply_broker_side_terminal_resolution(order, order_info, message=terminal_message)
         return order_info
 
     # ------------------------------------------------------------------

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

@@ -2456,8 +2456,26 @@ class IciciDirect(BrokerBase):
             )
             status_raw = str(rec.get("status", rec.get("order_status", "")))
             status = self._normalize_order_status(status_raw, fill_size, order_size, exchange_order_id)
+            terminal_message = str(
+                rec.get("reason", rec.get("remarks", rec.get("message", rec.get("reject_reason", ""))))
+                or ""
+            )
 
-            return OrderInfo(
+            order = kwargs.get("order")
+            if order is None:
+                order_data = self.redis_o.hgetall(order_id) if hasattr(self, "redis_o") else {}
+                if order_data:
+                    order = Order(**order_data)
+                else:
+                    order = Order(
+                        broker_order_id=order_id,
+                        broker=self.broker.name,
+                        exch_order_id=exchange_order_id,
+                    )
+            if terminal_message:
+                order.message = terminal_message
+
+            order_info = OrderInfo(
                 order_size=order_size,
                 order_price=order_price,
                 fill_size=fill_size,
@@ -2467,6 +2485,11 @@ class IciciDirect(BrokerBase):
                 exchange_order_id=exchange_order_id,
                 broker=self.broker,
             )
+            if kwargs.get("resolve_terminal", True):
+                order_info = self._apply_broker_side_terminal_resolution(
+                    order, order_info, message=terminal_message or order.message
+                )
+            return order_info
         except (ValidationError, BrokerConnectionError, OrderError):
             raise
         except Exception as e:

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

@@ -1724,7 +1724,7 @@ class Shoonya(BrokerBase):
             except (ValueError, TypeError):
                 date_matches = False
             if date_matches:
-                fills = self.get_order_info(broker_order_id=broker_order_id)
+                fills = self.get_order_info(broker_order_id=broker_order_id, resolve_terminal=kwargs.get("resolve_terminal", False))
                 if fills.fill_size < round(float(order.quantity)):
                     trading_logger.log_info(
                         "Cancelling broker order",
@@ -1760,6 +1760,7 @@ class Shoonya(BrokerBase):
             raise BrokerConnectionError("Shoonya API is not initialized")
 
         trading_logger.log_debug("Getting order info", {"broker_order_id": kwargs.get("broker_order_id")})
+        resolve_terminal = kwargs.get("resolve_terminal", True)
 
         def return_db_as_fills(order: Order) -> OrderInfo:
             order_info = OrderInfo()
@@ -1844,6 +1845,9 @@ class Shoonya(BrokerBase):
             order_info.status = status_mapping[latest_status.get("status")]
         else:
             order_info.status = OrderStatus.UNDEFINED
+        if resolve_terminal:
+            terminal_message = latest_status.get("rejreason") or latest_status.get("emsg") or order.message
+            order_info = self._apply_broker_side_terminal_resolution(order, order_info, message=terminal_message)
         return order_info
 
     # ------------------------------------------------------------------

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

@@ -27,7 +27,17 @@ from selenium.webdriver.common.keys import Keys
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import WebDriverWait
 
-from .broker_base import BrokerBase, HistoricalData, Order, OrderInfo, OrderStatus, Position, Price
+from .broker_base import (
+    BrokerBase,
+    HistoricalData,
+    Order,
+    OrderInfo,
+    OrderStatus,
+    Position,
+    Price,
+    is_broker_side_terminal_order,
+    is_missing_exchange_order_id,
+)
 from .config import get_config, get_fno_freeze_limit
 from .exceptions import (
     SymbolError,
@@ -692,10 +702,8 @@ def get_pnl_table(
                 # Refresh status if requested
                 if refresh_status:
                     try:
-                        for entry_key in entry_keys:
-                            order = Order(**cast(dict[str, Any], broker.redis_o.hgetall(entry_key)))
-                            broker_order_id = order.broker_order_id
-                            update_order_status(broker, int_order_id, broker_order_id, eod=eod)
+                        _prune_terminal_entry_legs(broker, int_order_id, eod=eod)
+                        symbol = cast(str, broker.redis_o.hget(int_order_id, "long_symbol") or symbol)
                     except Exception as e:
                         trading_logger.log_error(
                             f"Error refreshing entry status for {int_order_id}",
@@ -721,9 +729,9 @@ def get_pnl_table(
                             for leg_symbol, expected_qty in expected_legs.items()
                         )
                         if not fully_filled:
-                            derived_symbol = _build_effective_symbol_from_positions(entry_position)
-                            if derived_symbol:
-                                effective_symbol = derived_symbol
+                            resolved_symbol = _resolve_effective_combo_symbol(symbol, entry_position)
+                            if resolved_symbol:
+                                effective_symbol = resolved_symbol
                     if "?" not in effective_symbol and entry_order_type:
                         side = entry_order_type
                     base_position = parse_combo_symbol(effective_symbol)
@@ -1300,6 +1308,38 @@ def _build_effective_symbol_from_positions(positions: Dict[str, Position]) -> st
     return ":".join(f"{sym}?{int(size / norm)}" for sym, size in non_zero)
 
 
+def _resolve_effective_combo_symbol(
+    original_combo: str,
+    entry_position: Dict[str, Position],
+) -> str:
+    """Prefer subset of original combo with preserved leg ratios; GCD infer only as fallback."""
+    active_legs = {sym for sym, pos in entry_position.items() if pos.size != 0}
+    if not active_legs:
+        return original_combo
+    if "?" not in original_combo:
+        if original_combo in active_legs and len(active_legs) == 1:
+            return original_combo
+        if len(active_legs) == 1:
+            return next(iter(active_legs))
+        return _build_effective_symbol_from_positions(entry_position)
+
+    try:
+        original_legs = parse_combo_symbol(original_combo)
+    except Exception:
+        return _build_effective_symbol_from_positions(entry_position)
+
+    remaining_parts = [
+        f"{leg_sym}?{ratio}" for leg_sym, ratio in original_legs.items() if leg_sym in active_legs
+    ]
+    if not remaining_parts:
+        return _build_effective_symbol_from_positions(entry_position)
+    if len(remaining_parts) == len(original_legs):
+        return original_combo
+    if len(remaining_parts) == 1:
+        return remaining_parts[0]
+    return ":".join(remaining_parts)
+
+
 @log_execution_time
 @validate_inputs(combo_symbol=lambda x: isinstance(x, str) and len(x.strip()) > 0)
 def parse_combo_symbol(combo_symbol):
@@ -1639,6 +1679,8 @@ def transmit_entry_order(
         temp_order.price = lmt_price
         out = broker.place_order(temp_order)
         int_order_id = _process_broker_order_update(broker, out, order.long_symbol)
+    if int_order_id:
+        _prune_terminal_entry_legs(broker, int_order_id)
     return int_order_id
 
 
@@ -1878,6 +1920,66 @@ def exit_is_expiration(broker: BrokerBase, internal_order_id: str) -> bool:
     return out
 
 
+def _order_info_fill_size(fills: OrderInfo) -> float:
+    try:
+        return float(fills.fill_size or 0)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def should_prune_terminal_zero_fill_leg(
+    fills: OrderInfo,
+    *,
+    redis_order: Optional[Order] = None,
+) -> bool:
+    """True when a zero-fill leg is terminal and safe to remove from entry_keys."""
+    if _order_info_fill_size(fills) > 0:
+        return False
+    if fills.status in (OrderStatus.CANCELLED, OrderStatus.REJECTED):
+        return True
+    message = str(getattr(fills, "message", "") or "")
+    exch_order_id = getattr(fills, "exchange_order_id", "")
+    if redis_order is not None:
+        if not message.strip():
+            message = str(redis_order.message or "")
+        if is_missing_exchange_order_id(exch_order_id):
+            exch_order_id = redis_order.exch_order_id
+    return is_broker_side_terminal_order(exch_order_id, message)
+
+
+def _sync_internal_order_long_symbol(broker: BrokerBase, internal_order_id: str) -> None:
+    """Rewrite parent long_symbol to match remaining filled entry legs after pruning."""
+    if not internal_order_id or not cast(bool, broker.redis_o.exists(internal_order_id)):
+        return
+    long_symbol = cast(str, broker.redis_o.hget(internal_order_id, "long_symbol") or "")
+    if "?" not in long_symbol:
+        return
+    entry_keys = hget_with_default(broker, internal_order_id, "entry_keys", "").split()
+    if not entry_keys or not any(k.strip() for k in entry_keys):
+        return
+    positions = get_open_position_by_order(broker, internal_order_id, exclude_zero=True, side=["entry"])
+    resolved = _resolve_effective_combo_symbol(long_symbol, positions)
+    if resolved and resolved != long_symbol:
+        cast(bool, broker.redis_o.hset(internal_order_id, "long_symbol", resolved))
+        trading_logger.log_info(
+            "Updated internal order long_symbol after terminal leg prune",
+            {"internal_order_id": internal_order_id, "old_symbol": long_symbol, "new_symbol": resolved},
+        )
+
+
+def _prune_terminal_entry_legs(broker: BrokerBase, internal_order_id: str, *, eod: bool = False) -> None:
+    """Refresh entry legs and delete zero-fill terminal legs; sync combo long_symbol."""
+    if not internal_order_id or not cast(bool, broker.redis_o.exists(internal_order_id)):
+        return
+    entry_keys = hget_with_default(broker, internal_order_id, "entry_keys", "").split()
+    for entry_key in list(entry_keys):
+        if not entry_key or not cast(bool, broker.redis_o.exists(entry_key)):
+            continue
+        order = Order(**cast(dict[str, Any], broker.redis_o.hgetall(entry_key)))
+        update_order_status(broker, internal_order_id, str(order.broker_order_id), eod=eod)
+    _sync_internal_order_long_symbol(broker, internal_order_id)
+
+
 def delete_broker_order_id(
     broker,
     internal_order_id: str,
@@ -1978,8 +2080,20 @@ def update_order_status(
     if not broker_order_id_str or broker_order_id_str == "0" or broker_order_id_str.upper().endswith("P"):
         return None
 
+    redis_order: Optional[Order] = None
     try:
-        fills = broker.get_order_info(broker_order_id=broker_order_id_str)
+        redis_order_data = cast(dict[str, Any], broker.redis_o.hgetall(broker_order_id_str))
+        if redis_order_data:
+            redis_order = Order(**redis_order_data)
+    except Exception:
+        redis_order = None
+
+    get_order_info_kwargs: dict[str, Any] = {"broker_order_id": broker_order_id_str}
+    if redis_order is not None:
+        get_order_info_kwargs["order"] = redis_order
+
+    try:
+        fills = broker.get_order_info(**get_order_info_kwargs)
     except Exception as e:
         trading_logger.log_error(
             "Error calling get_order_info in update_order_status",
@@ -2006,22 +2120,22 @@ def update_order_status(
             )
             if attr == "exchange_order_id":
                 trading_logger.log_info(msg)
-            else:
-                trading_logger.log_error(msg)
+                continue
+            trading_logger.log_error(msg)
             return fills
 
     if broker.broker != fills.broker:
         return fills
 
-    if fills.status == OrderStatus.CANCELLED and fills.fill_size > 0:
+    if fills.status == OrderStatus.CANCELLED and _order_info_fill_size(fills) > 0:
         broker.redis_o.hset(broker_order_id, "price", str(fills.fill_price))
         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)
-    elif (fills.status == OrderStatus.CANCELLED and fills.fill_size == 0) or (fills.status == OrderStatus.REJECTED):
+    elif should_prune_terminal_zero_fill_leg(fills, redis_order=redis_order):
         delete_broker_order_id(broker, internal_order_id, broker_order_id)
     elif eod:
-        if fills.fill_size > 0:
+        if _order_info_fill_size(fills) > 0:
             broker.redis_o.hset(broker_order_id, "price", str(fills.fill_price))
             broker.redis_o.hset(broker_order_id, "quantity", str(fills.fill_size))
             broker.redis_o.hset(broker_order_id, "status", fills.status.name)

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

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

{tradingapi-0.3.7 → tradingapi-0.3.9}/tradingapi.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 README.md
 pyproject.toml
+tests/test_broker_side_terminal_order.py
 tests/test_calculate_delta_realtime_quotes.py
 tests/test_find_option_with_delta.py
 tradingapi/__init__.py