tradingapi 0.3.5__tar.gz → 0.3.7__tar.gz

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

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

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

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

tradingapi-0.3.7/tests/test_calculate_delta_realtime_quotes.py

@@ -0,0 +1,29 @@
+import math
+import sys
+from types import SimpleNamespace
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, "/home/psharma/onedrive/code/tradingapi2")
+
+from tradingapi import utils
+
+
+class CalculateDeltaRealtimeQuotesTest(unittest.TestCase):
+    def test_calculate_delta_returns_nan_without_live_bid_ask(self):
+        ticker = SimpleNamespace(bid=0.0, ask=0.0, prior_close=123.45)
+
+        with patch.object(utils, "get_price", return_value=ticker):
+            delta = utils.calculate_delta(
+                brokers=[],
+                long_symbol="TCS_OPT_20260630_PUT_2160",
+                price_f=2325.1,
+                exchange="NFO",
+                mds="mds",
+            )
+
+        self.assertTrue(math.isnan(delta))
+
+
+if __name__ == "__main__":
+    unittest.main()

tradingapi-0.3.7/tests/test_find_option_with_delta.py

@@ -0,0 +1,156 @@
+"""Tests for the anchor-IV based find_option_with_delta.
+
+Quotes are simulated by patching utils._option_mark_price with Black-Scholes
+prices, so implied vols and deltas flow through the real production code path.
+
+Run: /home/psharma/envs/base/bin/python3 tradingapi2/tests/test_find_option_with_delta.py
+"""
+import datetime as dt
+import math
+import sys
+from unittest.mock import patch
+
+# Force import from source repo, not site-packages installed copy.
+sys.path.insert(0, "/home/psharma/onedrive/code/tradingapi2")
+
+from chameli.europeanoptions import BlackScholesPrice
+
+from tradingapi import utils
+
+assert utils.__file__.startswith("/home/psharma/onedrive/code/tradingapi2/"), (
+    f"Wrong tradingapi loaded: {utils.__file__}"
+)
+
+EXPIRY = (dt.date.today() + dt.timedelta(days=30)).strftime("%Y%m%d")
+TRUE_IV = 0.12
+
+
+def make_chain(strikes, opt_type="CALL", underlying="NIFTY", expiry=EXPIRY):
+    return [f"{underlying}_OPT_{expiry}_{opt_type}_{int(s)}_X" for s in strikes]
+
+
+def make_quote_fn(spot, stale_prices=None, nan_strikes=()):
+    """Return a fake _option_mark_price pricing each strike at TRUE_IV.
+
+    stale_prices: {strike: price} overrides simulating stale MDS quotes.
+    nan_strikes: strikes with no usable quote.
+    """
+    stale_prices = stale_prices or {}
+    nan_set = set(nan_strikes)
+
+    def fake_mark(brokers, long_symbol, exchange="NSE", mds=None, as_of=None):
+        strike = float(long_symbol.split("_")[4])
+        opt_type = long_symbol.split("_")[3]
+        if strike in nan_set:
+            return float("nan")
+        if strike in stale_prices:
+            return stale_prices[strike]
+        years = utils._years_to_expiry(long_symbol)
+        return BlackScholesPrice(S=spot, X=strike, r=0, sigma=TRUE_IV, T=years, OptionType=opt_type)
+
+    return fake_mark
+
+
+def run_case(name, chain, spot, target_delta, quote_fn, return_lower=True, expect_found=True):
+    with patch.object(utils, "_option_mark_price", side_effect=quote_fn):
+        idx = utils.find_option_with_delta(
+            brokers=[],
+            price_f=spot,
+            option_chain=chain,
+            target_delta=target_delta,
+            return_lower_delta=return_lower,
+        )
+    found = idx >= 0
+    chosen = float(chain[idx].split("_")[4]) if found else None
+    return name, found, chosen, idx
+
+
+def true_delta_strike(strikes, spot, opt_type, target_delta, chain, return_lower=True):
+    """Reference answer: best strike under the true (flat) IV."""
+    years = utils._years_to_expiry(chain[0])
+    from chameli.europeanoptions import BlackScholesDelta
+
+    best, best_d = None, float("-inf") if return_lower else float("inf")
+    for k in strikes:
+        ad = abs(BlackScholesDelta(S=spot, X=k, r=0, sigma=TRUE_IV, T=years, OptionType=opt_type))
+        if return_lower and ad <= target_delta and ad > best_d:
+            best, best_d = k, ad
+        if not return_lower and ad >= target_delta and ad < best_d:
+            best, best_d = k, ad
+    return best
+
+
+def main():
+    spot = 74350.0
+    strikes = [70000 + 100 * i for i in range(90)]  # 70000..78900
+    results = []
+
+    def check(name, chosen, expected, found=True, expect_found=True, tolerance=100):
+        ok = (found == expect_found) and (
+            not expect_found or (chosen is not None and abs(chosen - expected) <= tolerance)
+        )
+        results.append(ok)
+        print(f"[{'PASS' if ok else 'FAIL'}] {name}: chosen={chosen} expected~{expected}")
+
+    # Case 1 — clean chain, 0.5-delta call.
+    chain = make_chain(strikes)
+    expected = true_delta_strike(strikes, spot, "CALL", 0.5, chain)
+    name, found, chosen, _ = run_case("clean 0.5d call", chain, spot, 0.5, make_quote_fn(spot))
+    check(name, chosen, expected, found)
+
+    # Case 2 — regression for 2026-06-11: stale high quote on far-OTM 75700 call
+    # made it look like 0.5 delta. Must not be picked; answer must stay near spot.
+    stale = {75700.0: 850.0}  # absurdly rich quote -> fake IV/delta
+    name, found, chosen, _ = run_case(
+        "stale far-OTM quote ignored", chain, spot, 0.5, make_quote_fn(spot, stale_prices=stale)
+    )
+    check(name, chosen, expected, found)
+    results.append(chosen != 75700.0)
+    print(f"[{'PASS' if chosen != 75700.0 else 'FAIL'}] stale strike 75700 not selected")
+
+    # Case 3 — NaN cluster at/near ATM: anchor scan must walk outward and still work.
+    nan_atm = [k for k in strikes if abs(k - spot) <= 200]
+    name, found, chosen, _ = run_case(
+        "NaN cluster at ATM", chain, spot, 0.5, make_quote_fn(spot, nan_strikes=nan_atm)
+    )
+    check(name, chosen, expected, found, tolerance=200)
+
+    # Case 4 — whole chain NaN: no anchor -> -1.
+    name, found, chosen, _ = run_case(
+        "all NaN -> -1", chain, spot, 0.5, make_quote_fn(spot, nan_strikes=strikes), expect_found=False
+    )
+    check(name, chosen, None, found, expect_found=False)
+
+    # Case 5 — PUT chain, 0.2 delta.
+    put_chain = make_chain(strikes, opt_type="PUT")
+    expected_put = true_delta_strike(strikes, spot, "PUT", 0.2, put_chain)
+    name, found, chosen, _ = run_case("put 0.2d", put_chain, spot, 0.2, make_quote_fn(spot))
+    check(name, chosen, expected_put, found)
+
+    # Case 6 — empty chain.
+    name, found, chosen, _ = run_case("empty chain -> -1", [], spot, 0.5, make_quote_fn(spot), expect_found=False)
+    check(name, chosen, None, found, expect_found=False)
+
+    # Case 7 — return_lower_delta=False picks from the >= side.
+    expected_hi = true_delta_strike(strikes, spot, "CALL", 0.3, chain, return_lower=False)
+    name, found, chosen, _ = run_case(
+        "0.3d call upper side", chain, spot, 0.3, make_quote_fn(spot), return_lower=False
+    )
+    check(name, chosen, expected_hi, found)
+
+    # Case 8 — stale quote adjacent to the true answer (inside refinement window)
+    # with wildly inconsistent IV must be rejected by the IV band guard.
+    true_strike = expected
+    stale_adjacent = {true_strike + 100: 2500.0}
+    name, found, chosen, _ = run_case(
+        "stale adjacent quote rejected", chain, spot, 0.5, make_quote_fn(spot, stale_prices=stale_adjacent)
+    )
+    check(name, chosen, expected, found)
+
+    passed, total = sum(results), len(results)
+    print(f"\n{passed}/{total} passed")
+    sys.exit(0 if passed == total else 1)
+
+
+if __name__ == "__main__":
+    main()

{tradingapi-0.3.5 → tradingapi-0.3.7}/tradingapi/allocation.py

@@ -24,7 +24,7 @@ _TODAY_SYMLINK = _ALLOCATIONS_DIR / "master_allocation_today.yaml"
 def load_today_allocation_entry(broker_name: str, strategy_name: str) -> dict:
     """Return the full allocation entry dict for strategy_name on broker_name today.
 
-    Example return value: {'pct': 0.275, 'redis_db': 8}
+    Example return value: {'pct': 0.225, 'redis_db': 8}
     SCALPING strategies include a 'redis_db' key; others have only 'pct'.
 
     Reads master_allocation_today.yaml (a symlink to today's dated file).

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

@@ -336,6 +336,11 @@ class FivePaisa(BrokerBase):
             self._fp_susertoken_path: Optional[str] = None
             self._fp_restore_session_from_token: Optional[Callable[[str], bool]] = None
             self._fp_fresh_login: Optional[Callable[[str], None]] = None
+            self._stream_reconnect_lock = threading.Lock()
+            self._stream_reconnect_serial_lock = threading.Lock()
+            self._stream_reconnect_active = False
+            self._suppress_stream_reconnect = False
+            self._last_stream_tick_ts = 0.0
 
             trading_logger.log_info(
                 "FivePaisa broker initialized", {"broker_type": "FivePaisa", "config_keys": list(kwargs.keys())}
@@ -3640,8 +3645,10 @@ class FivePaisa(BrokerBase):
                             "Skipping price data with unmapped token",
                             {
                                 "token": json_data.get("Token"),
+                                "scrip_code": json_data.get("ScripCode"),
                                 "exchange": json_data.get("Exch"),
                                 "exchange_type": json_data.get("ExchType"),
+                                "json_data": json_data,
                             },
                         )
                         return None
@@ -3657,43 +3664,126 @@ class FivePaisa(BrokerBase):
                 try:
                     data_str = message.replace(r"\/", "/")
                     json_data = json.loads(data_str)
-                    if len(json_data) == 1:
-                        price = map_to_price(json_data[0])
+                    if isinstance(json_data, list):
+                        for tick_data in json_data:
+                            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):
+                        price = map_to_price(json_data)
+                        if price is not None:
+                            self._last_stream_tick_ts = time.time()
                         if price is not None and ext_callback:
                             ext_callback(price)
                 except Exception as e:
                     trading_logger.log_error("Error processing WebSocket message", e, {"ws_message": message})
 
+            def schedule_reconnect(reason: str, **details):
+                if self._suppress_stream_reconnect:
+                    trading_logger.log_info(
+                        "Skipping WebSocket reconnect during planned close",
+                        {"reason": reason, **details},
+                    )
+                    return
+                with self._stream_reconnect_lock:
+                    if self._stream_reconnect_active:
+                        trading_logger.log_info(
+                            "WebSocket reconnect already in progress",
+                            {"reason": reason, **details},
+                        )
+                        return
+                    self._stream_reconnect_active = True
+                reconnect_thread = threading.Thread(
+                    target=reconnect,
+                    args=(reason, details),
+                    name="FivePaisaReconnect",
+                    daemon=True,
+                )
+                reconnect_thread.start()
+
             def error_data(ws, err):
                 """Handle WebSocket errors."""
                 try:
+                    if ws is not getattr(self.api, "ws", None):
+                        trading_logger.log_info("Ignoring WebSocket error from stale socket", {"error": str(err)})
+                        return
                     trading_logger.log_error("WebSocket error", None, {"error": str(err)})
-                    reconnect()
+                    schedule_reconnect("error", error=str(err))
                 except Exception as e:
                     trading_logger.log_error("Error handling WebSocket error", e, {"original_error": str(err)})
 
+            def close_data(ws, close_status_code, close_msg):
+                """Handle WebSocket closures that do not surface through on_error."""
+                try:
+                    if ws is not getattr(self.api, "ws", None):
+                        trading_logger.log_info(
+                            "Ignoring WebSocket close from stale socket",
+                            {"close_status_code": close_status_code, "close_msg": close_msg},
+                        )
+                        return
+                    trading_logger.log_warning(
+                        "WebSocket closed",
+                        {"close_status_code": close_status_code, "close_msg": close_msg},
+                    )
+                    schedule_reconnect(
+                        "close",
+                        close_status_code=close_status_code,
+                        close_msg=str(close_msg) if close_msg is not None else None,
+                    )
+                except Exception as e:
+                    trading_logger.log_error(
+                        "Error handling WebSocket close",
+                        e,
+                        {"close_status_code": close_status_code, "close_msg": close_msg},
+                    )
+
             _ws_reconnect_state: Dict[str, int] = {"failures": 0}
             _ws_reconnect_max = 10
+            _stream_reconnect_verify_timeout_secs = 8.0
 
-            def reconnect():
+            def reconnect(reason: str, details: Dict[str, Any]):
                 """Reconnect after WebSocket errors — same path as send_stream_request on closed socket."""
-                trading_logger.log_info("Attempting to reconnect after WebSocket error...")
-                time.sleep(5)  # Wait before reconnecting to avoid hammering the broker
                 try:
-                    reconnect_stream()
-                    _ws_reconnect_state["failures"] = 0
-                except Exception as e:
-                    _ws_reconnect_state["failures"] += 1
-                    trading_logger.log_error("Reconnection failed", e, {"subscribed_symbols": self.subscribed_symbols})
-                    if _ws_reconnect_state["failures"] >= _ws_reconnect_max:
-                        trading_logger.log_error(
-                            "WebSocket reconnect giving up after repeated failures",
-                            None,
-                            {"failures": _ws_reconnect_state["failures"], "subscribed_symbols": self.subscribed_symbols},
+                    while True:
+                        trading_logger.log_info(
+                            "Attempting to reconnect after WebSocket event",
+                            {
+                                "reason": reason,
+                                **details,
+                                "attempt": _ws_reconnect_state["failures"] + 1,
+                                "max_attempts": _ws_reconnect_max,
+                            },
                         )
-                        _ws_reconnect_state["failures"] = 0
-                        return
-                    reconnect()
+                        time.sleep(5)
+                        try:
+                            reconnect_stream()
+                            _ws_reconnect_state["failures"] = 0
+                            return
+                        except Exception as e:
+                            _ws_reconnect_state["failures"] += 1
+                            trading_logger.log_error(
+                                "Reconnection failed",
+                                e,
+                                {"subscribed_symbols": self.subscribed_symbols, "reason": reason, **details},
+                            )
+                            if _ws_reconnect_state["failures"] >= _ws_reconnect_max:
+                                trading_logger.log_error(
+                                    "WebSocket reconnect giving up after repeated failures",
+                                    None,
+                                    {
+                                        "failures": _ws_reconnect_state["failures"],
+                                        "subscribed_symbols": self.subscribed_symbols,
+                                        "reason": reason,
+                                        **details,
+                                    },
+                                )
+                                _ws_reconnect_state["failures"] = 0
+                                return
+                finally:
+                    with self._stream_reconnect_lock:
+                        self._stream_reconnect_active = False
 
             def connect_and_receive(req_data):
                 """Connect and receive data."""
@@ -3701,8 +3791,11 @@ class FivePaisa(BrokerBase):
                     if self.api is None:
                         raise BrokerConnectionError("API client not initialized")
                     self.api.connect(req_data)
-                    self.api.receive_data(on_message)
                     self.api.error_data(error_data)
+                    ws = getattr(self.api, "ws", None)
+                    if ws is not None:
+                        ws.on_close = close_data
+                    self.api.receive_data(on_message)
                 except Exception as e:
                     trading_logger.log_error("Error in connect_and_receive", e, {"req_data": req_data})
                     raise
@@ -3719,49 +3812,68 @@ class FivePaisa(BrokerBase):
 
             def reconnect_stream():
                 """Start a fresh websocket and restore all subscriptions."""
-                try:
-                    self._safe_close_streaming_ws()
-                except Exception:
-                    pass
-                self.subscribe_thread = None
-                # Re-authenticate at broker level before reconnecting the websocket.
-                # fivepaisa's server requires a fresh session after a connection drop;
-                # reusing the old api object without re-auth results in a silent connection
-                # that accepts subscriptions but never streams data.
-                trading_logger.log_info("Re-authenticating before stream reconnect", {"broker": self.broker.name})
-                token_path = self._fp_susertoken_path or config.get(f"{self.account_key}.USERTOKEN")
-                if not token_path:
-                    raise BrokerConnectionError("USERTOKEN path not configured")
-                restore_fn = self._fp_restore_session_from_token
-                fresh_fn = self._fp_fresh_login
-                if restore_fn is None or fresh_fn is None:
-                    raise BrokerConnectionError(
-                        "FivePaisa stream session helpers not initialized; connect() must succeed before streaming"
+                with self._stream_reconnect_serial_lock:
+                    previous_tick_ts = self._last_stream_tick_ts
+                    try:
+                        self._suppress_stream_reconnect = True
+                        self._safe_close_streaming_ws()
+                    except Exception:
+                        pass
+                    finally:
+                        self._suppress_stream_reconnect = False
+                    self.subscribe_thread = None
+                    # Re-authenticate at broker level before reconnecting the websocket.
+                    # fivepaisa's server requires a fresh session after a connection drop;
+                    # reusing the old api object without re-auth results in a silent connection
+                    # that accepts subscriptions but never streams data.
+                    trading_logger.log_info("Re-authenticating before stream reconnect", {"broker": self.broker.name})
+                    token_path = self._fp_susertoken_path or config.get(f"{self.account_key}.USERTOKEN")
+                    if not token_path:
+                        raise BrokerConnectionError("USERTOKEN path not configured")
+                    restore_fn = self._fp_restore_session_from_token
+                    fresh_fn = self._fp_fresh_login
+                    if restore_fn is None or fresh_fn is None:
+                        raise BrokerConnectionError(
+                            "FivePaisa stream session helpers not initialized; connect() must succeed before streaming"
+                        )
+                    # Always do a full TOTP re-login for stream reconnects.
+                    # restore_fn succeeds (REST verifies OK) but FivePaisa's WS server silently
+                    # rejects streaming on a token-restored session — subscriptions are accepted
+                    # but no ticks are ever delivered. fresh_fn gets a genuine new session.
+                    fresh_fn(token_path)
+                    req_list_full = expand_symbols_to_request(self.subscribed_symbols)
+                    if not req_list_full:
+                        context = create_error_context(operation=operation, symbols=symbols, exchange=exchange)
+                        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)
+                    reconnect_started_ts = time.time()
+                    self.subscribe_thread = threading.Thread(
+                        target=connect_and_receive,
+                        args=(req_data_full,),
+                        name="MarketDataStreamer",
                     )
-                if not restore_fn(token_path):
-                    trading_logger.log_warning(
-                        "Token restore failed during reconnect, attempting fresh login",
-                        {"broker": self.broker.name},
+                    self.subscribe_thread.start()
+                    should_verify_ticks = previous_tick_ts > 0 and bool(self.subscribed_symbols)
+                    if should_verify_ticks:
+                        deadline = time.time() + _stream_reconnect_verify_timeout_secs
+                        while time.time() < deadline:
+                            if self._last_stream_tick_ts >= reconnect_started_ts:
+                                break
+                            if not has_live_stream():
+                                raise BrokerConnectionError("WebSocket thread died during reconnect verification")
+                            time.sleep(0.5)
+                        else:
+                            raise BrokerConnectionError(
+                                "WebSocket reconnected but remained silent after reconnect verification"
+                            )
+                    else:
+                        time.sleep(2)
+                    trading_logger.log_info(
+                        "Reconnected after socket closure",
+                        {"subscribed_count": len(self.subscribed_symbols), "verified_ticks": should_verify_ticks},
                     )
-                    fresh_fn(token_path)
-                req_list_full = expand_symbols_to_request(self.subscribed_symbols)
-                if not req_list_full:
-                    context = create_error_context(operation=operation, symbols=symbols, exchange=exchange)
-                    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)
-                self.subscribe_thread = threading.Thread(
-                    target=connect_and_receive,
-                    args=(req_data_full,),
-                    name="MarketDataStreamer",
-                )
-                self.subscribe_thread.start()
-                time.sleep(2)
-                trading_logger.log_info(
-                    "Reconnected after socket closure",
-                    {"subscribed_count": len(self.subscribed_symbols)},
-                )
 
             def send_stream_request(req_data):
                 """Send an incremental subscribe/unsubscribe over an existing websocket."""
@@ -3904,12 +4016,15 @@ class FivePaisa(BrokerBase):
             trading_logger.log_info("Stopping quotes streaming")
 
             try:
+                self._suppress_stream_reconnect = True
                 self._safe_close_streaming_ws()
                 self.subscribe_thread = None
                 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)
+            finally:
+                self._suppress_stream_reconnect = False
 
         except BrokerConnectionError:
             raise

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

@@ -2000,10 +2000,14 @@ def update_order_status(
     for attr in required_attributes:
         if not hasattr(fills, attr) or getattr(fills, attr) in [None, "0"]:
             attr_value = getattr(fills, attr, "<missing>")
-            trading_logger.log_error(
+            msg = (
                 f"Missing or invalid attribute {attr} in order information for broker_order_id: {broker_order_id}. "
                 f"value={attr_value!r}, value_type={type(attr_value).__name__}"
             )
+            if attr == "exchange_order_id":
+                trading_logger.log_info(msg)
+            else:
+                trading_logger.log_error(msg)
             return fills
 
     if broker.broker != fills.broker:
@@ -3164,50 +3168,79 @@ def _asof_to_ref_time_naive(as_of: Union[dt.datetime, dt.date, str, pd.Timestamp
     return ref
 
 
-def calculate_delta(
+def _option_mark_price(
     brokers: list[BrokerBase],
-    long_symbol,
-    price_f,
-    market_close_time="15:30:00",
+    long_symbol: str,
     exchange="NSE",
     mds: Optional[str] = None,
     as_of: Optional[Union[dt.datetime, dt.date, str, pd.Timestamp]] = None,
-):
-    delta = float("nan")
+) -> float:
+    """Mark price for an option: live bid/ask mid, or historical last when as_of is set.
+
+    Returns NaN unless there is a usable two-sided quote (live path) or a positive
+    historical price (as_of path). Never falls back to prior_close: stale marks
+    are the root cause of bad delta-strike picks.
+    """
     if as_of is None:
-        ticker = get_price(brokers, long_symbol, checks=["bid", "ask", "prior_close"], exchange=exchange, mds=mds)
-        price = (ticker.bid + ticker.ask) / 2 if ticker.bid > 0 and ticker.ask > 0 else ticker.prior_close
-        t = (
-            calc_fractional_business_days(
-                get_tradingapi_now(),
-                dt.datetime.strptime(long_symbol.split("_")[2] + " " + market_close_time, "%Y%m%d %H:%M:%S"),
-            )
-            / 252
-        )  # convert days number of years
-    else:
-        br: List[BrokerBase] = [brokers] if isinstance(brokers, BrokerBase) else brokers
-        broker = br[0]
-        price_at = get_price_at_time(broker, long_symbol, exchange, as_of=as_of, mds=mds, last=True)
-        if price_at is None or (isinstance(price_at, float) and (math.isnan(price_at) or price_at <= 0)):
+        ticker = get_price(brokers, long_symbol, checks=["bid", "ask"], exchange=exchange, mds=mds)
+        if not (ticker.bid > 0 and ticker.ask > 0) or ticker.ask < ticker.bid:
             return float("nan")
-        price = float(price_at)
-        ref_time = _asof_to_ref_time_naive(as_of)
-        t = (
-            calc_fractional_business_days(
-                ref_time,
-                dt.datetime.strptime(long_symbol.split("_")[2] + " " + market_close_time, "%Y%m%d %H:%M:%S"),
-            )
-            / 252
-        )
-    vol = BlackScholesIV(
+        return (ticker.bid + ticker.ask) / 2
+    br: List[BrokerBase] = [brokers] if isinstance(brokers, BrokerBase) else brokers
+    if not br:
+        return float("nan")
+    price_at = get_price_at_time(br[0], long_symbol, exchange, as_of=as_of, mds=mds, last=True)
+    if price_at is None or (isinstance(price_at, float) and (math.isnan(price_at) or price_at <= 0)):
+        return float("nan")
+    return float(price_at)
+
+
+def _years_to_expiry(
+    long_symbol: str,
+    market_close_time="15:30:00",
+    as_of: Optional[Union[dt.datetime, dt.date, str, pd.Timestamp]] = None,
+) -> float:
+    ref_time = get_tradingapi_now() if as_of is None else _asof_to_ref_time_naive(as_of)
+    expiry = dt.datetime.strptime(long_symbol.split("_")[2] + " " + market_close_time, "%Y%m%d %H:%M:%S")
+    return calc_fractional_business_days(ref_time, expiry) / 252
+
+
+def _implied_vol_for_option(
+    brokers: list[BrokerBase],
+    long_symbol: str,
+    price_f: float,
+    years_to_expiry: float,
+    exchange="NSE",
+    mds: Optional[str] = None,
+    as_of: Optional[Union[dt.datetime, dt.date, str, pd.Timestamp]] = None,
+) -> float:
+    price = _option_mark_price(brokers, long_symbol, exchange=exchange, mds=mds, as_of=as_of)
+    if math.isnan(price):
+        return float("nan")
+    return BlackScholesIV(
         S=price_f,
         X=float(long_symbol.split("_")[4]),
         r=0,
-        T=t,
+        T=years_to_expiry,
         OptionType=long_symbol.split("_")[3],
         OptionPrice=price,
     )
-    delta = BlackScholesDelta(
+
+
+def calculate_delta(
+    brokers: list[BrokerBase],
+    long_symbol,
+    price_f,
+    market_close_time="15:30:00",
+    exchange="NSE",
+    mds: Optional[str] = None,
+    as_of: Optional[Union[dt.datetime, dt.date, str, pd.Timestamp]] = None,
+):
+    t = _years_to_expiry(long_symbol, market_close_time, as_of=as_of)
+    vol = _implied_vol_for_option(brokers, long_symbol, price_f, t, exchange=exchange, mds=mds, as_of=as_of)
+    if math.isnan(vol):
+        return float("nan")
+    return BlackScholesDelta(
         S=price_f,
         X=float(long_symbol.split("_")[4]),
         r=0,
@@ -3215,7 +3248,15 @@ def calculate_delta(
         T=t,
         OptionType=long_symbol.split("_")[3],
     )
-    return delta
+
+
+# find_option_with_delta tuning. Anchor IV is taken from the strike nearest the
+# underlying (most liquid, freshest data); a stale quote elsewhere in the chain
+# can no longer steer the result on its own.
+_ANCHOR_IV_SCAN_STRIKES = 5  # how far from ATM to look for a usable anchor quote
+_ANCHOR_IV_BOUNDS = (0.01, 3.0)  # sane annualized IV range for the anchor
+_REFINE_WINDOW = 2  # strikes around the model pick refined with market quotes
+_REFINE_IV_BAND = (0.5, 2.0)  # market IV / anchor IV ratio accepted during refinement
 
 
 def find_option_with_delta(
@@ -3229,129 +3270,122 @@ def find_option_with_delta(
     mds: Optional[str] = "mds",
     as_of: Optional[Union[dt.datetime, dt.date, str, pd.Timestamp]] = None,
 ):
-    # Determine the correct option exchange
+    """Find the chain index whose |delta| best matches target_delta.
+
+    Approach: anchor a single implied vol at the strike nearest the underlying,
+    compute model deltas for the whole chain from that one vol, pick the best
+    strike, then refine locally with market quotes whose implied vol is
+    consistent with the anchor.
+
+    Rationale: the previous binary search trusted each strike's market quote
+    independently; one stale quote produced a plausible delta and a grossly
+    wrong strike (e.g. ATM reported 1350 points away from spot). Model deltas
+    from a single near-ATM vol cannot be corrupted by stale wings, and the
+    refinement step recovers smile accuracy only from quotes that pass an
+    IV-consistency guard.
+    """
     opt_exchange = "NFO" if exchange == "NSE" else "BFO" if exchange == "BSE" else exchange
-
-    left, right = 0, len(option_chain) - 1
-    best_index = -1  # Default to -1 if no valid option is found
-    best_delta = float("-inf") if return_lower_delta else float("inf")  # Best delta found so far
-
-    def _strike(sym: str) -> float:
-        return float(sym.split("_")[4]) if "_" in sym and len(sym.split("_")) > 4 else float("nan")
-
-    chain_strikes = [_strike(s) for s in option_chain] if option_chain else []
-    strike_lo = min(chain_strikes) if chain_strikes else float("nan")
-    strike_hi = max(chain_strikes) if chain_strikes else float("nan")
     n = len(option_chain)
-    total_delta_checks = 0
-    valid_delta_count = 0
-    nan_delta_count = 0
-    nan_delta_strikes = []  # track strikes where delta could not be calculated
-    # Cache so seeding sweep + binary search never recompute the same strike.
-    delta_cache: dict[int, float] = {}
-
-    def _delta_at(idx: int) -> float:
-        nonlocal total_delta_checks, valid_delta_count, nan_delta_count
-        if idx in delta_cache:
-            return delta_cache[idx]
-        d = calculate_delta(
-            brokers, option_chain[idx], price_f, market_close_time, exchange=opt_exchange, mds=mds, as_of=as_of
-        )
-        total_delta_checks += 1
-        if d is None or math.isnan(d):
-            d = float("nan")
-            nan_delta_count += 1
-            nan_delta_strikes.append(_strike(option_chain[idx]))
-        else:
-            valid_delta_count += 1
-        delta_cache[idx] = d
-        return d
-
-    def _consider(idx: int, abs_delta: float) -> None:
-        nonlocal best_index, best_delta
-        if return_lower_delta:
-            if abs_delta <= target_delta and abs_delta > best_delta:
-                best_delta = abs_delta
-                best_index = idx
-        else:
-            if abs_delta >= target_delta and abs_delta < best_delta:
-                best_delta = abs_delta
-                best_index = idx
-
     if n == 0:
         trading_logger.log_warning(
             f"find_option_with_delta: empty option_chain. price_f={price_f} target_delta={target_delta}"
         )
         return -1
+    if price_f is None or (isinstance(price_f, float) and math.isnan(price_f)) or price_f <= 0:
+        trading_logger.log_warning(
+            f"find_option_with_delta: invalid underlying price_f={price_f} target_delta={target_delta}"
+        )
+        return -1
 
-    # --- Change 1: robust direction seeding via spread-out probes ---
-    seed_fractions = [0.1, 0.25, 0.5, 0.75, 0.9]
-    seed_indices = sorted({min(n - 1, max(0, int(round(f * (n - 1))))) for f in seed_fractions})
-    seed_samples: list[tuple[int, float]] = []  # (idx, |delta|)
-    for idx in seed_indices:
-        d = _delta_at(idx)
-        if not math.isnan(d):
-            ad = abs(d)
-            seed_samples.append((idx, ad))
-            _consider(idx, ad)
-
-    if len(seed_samples) < 2:
-        if best_index < 0:
-            trading_logger.log_warning(
-                f"find_option_with_delta: no valid option strike found (seed failure). "
-                f"price_f={price_f} target_delta={target_delta} return_lower_delta={return_lower_delta} "
-                f"chain_len={n} strike_range=[{strike_lo}, {strike_hi}] "
-                f"valid_delta_count={valid_delta_count} nan_delta_count={nan_delta_count} "
-                f"total_delta_checks={total_delta_checks} nan_delta_strikes={sorted(set(nan_delta_strikes))}"
-            )
-        return best_index
-
-    # Determine monotonicity from lowest- vs. highest-strike valid seeds.
-    increasing = seed_samples[-1][1] > seed_samples[0][1]
+    strikes = [float(sym.split("_")[4]) for sym in option_chain]
+    option_type = option_chain[0].split("_")[3]
+    years = _years_to_expiry(option_chain[0], market_close_time, as_of=as_of)
+    if years <= 0:
+        trading_logger.log_warning(
+            f"find_option_with_delta: option expired or T<=0. symbol={option_chain[0]} years={years}"
+        )
+        return -1
 
-    # --- Change 2: NaN at mid -> scan to nearest valid neighbor instead of shrinking range ---
-    NAN_SCAN_CAP = 5
+    def _iv_at(idx: int) -> float:
+        return _implied_vol_for_option(
+            brokers, option_chain[idx], price_f, years, exchange=opt_exchange, mds=mds, as_of=as_of
+        )
 
-    def _nearest_valid(mid: int, lo: int, hi: int) -> int:
-        # Returns idx of nearest valid delta within [lo, hi], or -1 if none within cap.
-        for step in range(1, NAN_SCAN_CAP + 1):
-            for cand in (mid - step, mid + step):
-                if lo <= cand <= hi and not math.isnan(_delta_at(cand)):
-                    return cand
+    # 1. Anchor IV at (or near) the ATM strike.
+    atm_idx = min(range(n), key=lambda i: abs(strikes[i] - price_f))
+    lo_iv, hi_iv = _ANCHOR_IV_BOUNDS
+    anchor_iv, anchor_idx = float("nan"), -1
+    scan = sorted(
+        range(max(0, atm_idx - _ANCHOR_IV_SCAN_STRIKES), min(n, atm_idx + _ANCHOR_IV_SCAN_STRIKES + 1)),
+        key=lambda i: abs(i - atm_idx),
+    )
+    for i in scan:
+        iv = _iv_at(i)
+        if not math.isnan(iv) and lo_iv <= iv <= hi_iv:
+            anchor_iv, anchor_idx = iv, i
+            break
+    if math.isnan(anchor_iv):
+        trading_logger.log_warning(
+            f"find_option_with_delta: no usable anchor IV near ATM. price_f={price_f} "
+            f"atm_strike={strikes[atm_idx]} scanned_strikes={[strikes[i] for i in scan]} target_delta={target_delta}"
+        )
         return -1
 
-    while left <= right:
-        mid = (left + right) // 2
-        d = _delta_at(mid)
-        eff_idx = mid
-        if math.isnan(d):
-            alt = _nearest_valid(mid, left, right)
-            if alt < 0:
-                # Wide NaN band: stop here instead of expanding into a full-chain scan.
-                break
-            eff_idx = alt
-            d = delta_cache[alt]
-        ad = abs(d)
-        _consider(eff_idx, ad)
-
-        if increasing:
-            if ad > target_delta:
-                right = eff_idx - 1
-            else:
-                left = eff_idx + 1
-        else:
-            if ad > target_delta:
-                left = eff_idx + 1
+    # 2. Model deltas for the whole chain from the single anchor IV (pure math, no quotes).
+    abs_deltas = [
+        abs(BlackScholesDelta(S=price_f, X=k, r=0, sigma=anchor_iv, T=years, OptionType=option_type))
+        for k in strikes
+    ]
+
+    def _pick_best(deltas: list) -> int:
+        best_idx, best_d = -1, float("-inf") if return_lower_delta else float("inf")
+        for i, ad in enumerate(deltas):
+            if math.isnan(ad):
+                continue
+            if return_lower_delta:
+                if ad <= target_delta and ad > best_d:
+                    best_idx, best_d = i, ad
             else:
-                right = eff_idx - 1
+                if ad >= target_delta and ad < best_d:
+                    best_idx, best_d = i, ad
+        return best_idx
 
-    if best_index < 0:
+    model_idx = _pick_best(abs_deltas)
+    if model_idx < 0:
         trading_logger.log_warning(
-            f"find_option_with_delta: no valid option strike found. "
-            f"price_f={price_f} chain_len={n} strike_range=[{strike_lo}, {strike_hi}] "
-            f"valid_delta_count={valid_delta_count} nan_delta_count={nan_delta_count} total_delta_checks={total_delta_checks} "
-            f"nan_delta_strikes={sorted(set(nan_delta_strikes))}"
+            f"find_option_with_delta: no strike satisfies target under model deltas. "
+            f"price_f={price_f} target_delta={target_delta} anchor_iv={anchor_iv:.4f} "
+            f"strike_range=[{strikes[0]}, {strikes[-1]}] return_lower_delta={return_lower_delta}"
+        )
+        return -1
+
+    # 3. Local refinement: overwrite model deltas with market deltas for strikes
+    # around the model pick, but only where the market IV is consistent with the
+    # anchor (stale-quote guard).
+    refined = list(abs_deltas)
+    for i in range(max(0, model_idx - _REFINE_WINDOW), min(n, model_idx + _REFINE_WINDOW + 1)):
+        iv = anchor_iv if i == anchor_idx else _iv_at(i)
+        if math.isnan(iv) or iv <= 0:
+            continue
+        ratio = iv / anchor_iv
+        if not (_REFINE_IV_BAND[0] <= ratio <= _REFINE_IV_BAND[1]):
+            trading_logger.log_debug(
+                f"find_option_with_delta: refinement rejected strike={strikes[i]} "
+                f"iv={iv:.4f} anchor_iv={anchor_iv:.4f} ratio={ratio:.2f}"
+            )
+            continue
+        refined[i] = abs(
+            BlackScholesDelta(S=price_f, X=strikes[i], r=0, sigma=iv, T=years, OptionType=option_type)
         )
+    best_index = _pick_best(refined)
+    if best_index < 0:
+        best_index = model_idx
+
+    trading_logger.log_debug(
+        f"find_option_with_delta: price_f={price_f} target_delta={target_delta} "
+        f"anchor_strike={strikes[anchor_idx]} anchor_iv={anchor_iv:.4f} "
+        f"model_strike={strikes[model_idx]} final_strike={strikes[best_index]}"
+    )
     return best_index
 
 
@@ -3382,6 +3416,7 @@ def get_delta_strike(
     exchange="NSE",
     mds: Optional[str] = None,
     as_of: Optional[Union[dt.datetime, dt.date, str, pd.Timestamp]] = None,
+    max_moneyness: float = 0.07,
 ) -> Union[str, None]:
     """Get option strike price for a given delta with enhanced error handling.
 
@@ -3403,6 +3438,10 @@ def get_delta_strike(
         as_of: Optional. When omitted (default), behavior matches pre-change realtime paths.
             When set, underlying and option marks use historical OHLC at that time; T for IV/delta
             uses ``as_of`` instead of now.
+        max_moneyness: Maximum allowed deviation of the found strike from the underlying price,
+            as a fraction (e.g. 0.07 = 7%). Applies symmetrically to ITM and OTM strikes.
+            Rejects results where stale market data produced a plausible-looking but wrong delta.
+            Defaults to 0.07.
 
     Returns:
         Union[str, None]: Option symbol or None if not found
@@ -3473,7 +3512,17 @@ def get_delta_strike(
         as_of=as_of,
     )
     if index >= 0:
-        return option_chain[index]
+        sym = option_chain[index]
+        strike = float(sym.split("_")[4])
+        deviation = abs(strike / price_f - 1.0)
+        if deviation > max_moneyness:
+            trading_logger.log_warning(
+                f"get_delta_strike: moneyness sanity check failed. "
+                f"strike={strike} price_f={price_f} deviation={deviation:.1%} max_moneyness={max_moneyness:.1%} "
+                f"delta={delta} option_type={option_type} symbol={sym}"
+            )
+            return None
+        return sym
     else:
         trading_logger.log_debug(f"get_delta_strike: no option found (index={index})")
         return None
@@ -4597,3 +4646,68 @@ def register_strategy_capital(
     except Exception as e:
         trading_logger.log_error(f"Failed to register strategy capital: {e}", exc_info=True)
         return False
+
+
+def close_all_positions(
+    broker: BrokerBase,
+    strategy: str,
+    exchange: str,
+    paper: bool,
+    refresh_status: bool = True,
+    price_types: list[str] = ["LMT"],
+    exclude_today_expiry: bool = False,
+    publish: bool = True,
+    additional_infos: list[str] | None = None,
+) -> list[str]:
+    """Close all open positions for a strategy by placing exit orders.
+
+    Reads open positions from get_pnl_table (authoritative Redis state, not in-memory cache),
+    places one exit order per open position, then publishes updated trades to Redis.
+
+    Args:
+        broker: Broker instance used for order placement and Redis access.
+        strategy: Strategy name.
+        exchange: Exchange string (e.g. "NSE", "BSE") passed to place_combo_order.
+        paper: Paper trading flag passed through to place_combo_order.
+        price_types: Order price type(s), e.g. ["LMT"], ["MKT"], ["BID+0.05"].
+        exclude_today_expiry: If True, skip symbols whose expiry date is today or earlier.
+        publish: Whether to publish trades to Redis after placing orders.
+        additional_infos: Per-order metadata list passed to place_combo_order (e.g. [json.dumps({"message": "..."})]).
+
+    Returns:
+        List of symbols for which exit orders were successfully placed.
+    """
+    closed_symbols: list[str] = []
+    pnl = get_pnl_table(broker, strategy, refresh_status=refresh_status)
+    if pnl.empty:
+        return closed_symbols
+    open_rows = pnl[(pnl["entry_quantity"].fillna(0) + pnl["exit_quantity"].fillna(0)) != 0]
+    for _, row in open_rows.iterrows():
+        symbol = str(row["symbol"])
+        if exclude_today_expiry:
+            parts = symbol.split("_")
+            if len(parts) > 2 and parts[2] <= dt.datetime.today().strftime("%Y%m%d"):
+                trading_logger.log_info(f"close_all_positions: skipping today-expiry symbol {symbol}")
+                continue
+        qty = int(float(row["entry_quantity"]) + float(row["exit_quantity"]))
+        if qty == 0:
+            continue
+        try:
+            place_combo_order(
+                execution_broker=broker,
+                strategy=strategy,
+                symbols=[symbol],
+                quantities=[-qty],
+                entry=False,
+                exchanges=[exchange],
+                price_types=price_types,
+                paper=paper,
+                additional_infos=additional_infos if additional_infos is not None else [""],
+            )
+            trading_logger.log_info(f"close_all_positions: exit placed {symbol} qty={qty}")
+            closed_symbols.append(symbol)
+        except Exception as e:
+            trading_logger.log_error(f"close_all_positions: failed to place exit for {symbol} qty={qty}: {e}")
+    if publish:
+        publish_trades_to_redis(broker, strategy, publish=not paper)
+    return closed_symbols

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

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

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

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

tradingapi-0.3.5/tests/test_find_option_with_delta.py

@@ -1,122 +0,0 @@
-"""Standalone test for find_option_with_delta NaN-robustness fix.
-
-Run: /home/psharma/envs/base/bin/python3 tradingapi2/tests/test_find_option_with_delta.py
-"""
-import math
-import sys
-from unittest.mock import patch
-
-# Force import from source repo, not site-packages installed copy.
-sys.path.insert(0, "/home/psharma/onedrive/code/tradingapi2")
-
-from tradingapi import utils
-
-assert utils.__file__.startswith("/home/psharma/onedrive/code/tradingapi2/"), (
-    f"Wrong tradingapi loaded: {utils.__file__}"
-)
-
-
-def make_chain(strikes, expiry="20260529", opt_type="CALL", underlying="NIFTY"):
-    # Symbol format expected by _strike() and calculate_delta: "<u>_<x>_<expiry>_<type>_<strike>_..."
-    return [f"{underlying}_X_{expiry}_{opt_type}_{int(s) if s == int(s) else s}_X" for s in strikes]
-
-
-def bs_like_delta(strike, spot, opt_type="CALL"):
-    """Smooth monotone proxy for |delta| as a function of strike. Just needs to be monotone."""
-    # CALL delta ~ N(d1); approximate with logistic in (spot - strike)
-    x = (spot - strike) / (spot * 0.05)
-    sig = 1.0 / (1.0 + math.exp(-x))
-    return sig if opt_type == "CALL" else -(1.0 - sig)
-
-
-def run_case(name, chain, price_f, target_delta, nan_strikes=(), return_lower=True, expect_index=True):
-    nan_set = set(nan_strikes)
-    call_log = []
-
-    def fake_calc_delta(brokers, sym, pf, *a, **kw):
-        strike = float(sym.split("_")[4])
-        call_log.append(strike)
-        if strike in nan_set:
-            return float("nan")
-        return bs_like_delta(strike, pf, opt_type=sym.split("_")[3])
-
-    with patch.object(utils, "calculate_delta", side_effect=fake_calc_delta):
-        idx = utils.find_option_with_delta(
-            brokers=[],
-            price_f=price_f,
-            option_chain=chain,
-            target_delta=target_delta,
-            return_lower_delta=return_lower,
-        )
-
-    found = idx >= 0
-    status = "PASS" if found == expect_index else "FAIL"
-    chosen_strike = float(chain[idx].split("_")[4]) if found else None
-    chosen_delta = bs_like_delta(chosen_strike, price_f) if chosen_strike is not None else None
-    delta_str = f"{abs(chosen_delta):.4f}" if chosen_delta is not None else "n/a"
-    print(
-        f"[{status}] {name}: idx={idx} strike={chosen_strike} |delta|≈{delta_str} "
-        f"calls={len(call_log)} unique={len(set(call_log))} target={target_delta}"
-    )
-    return status == "PASS", idx, len(call_log)
-
-
-def main():
-    results = []
-
-    # Case 1 — clean chain, no NaN. Should land near target_delta=0.3 and be efficient.
-    strikes = [64900 + 100 * i for i in range(215)]  # 64900..86300
-    chain = make_chain(strikes)
-    ok, idx, calls = run_case("clean chain, target=0.3", chain, 76956.7, 0.3)
-    results.append(ok)
-    assert calls < 30, f"clean chain should be cheap, got {calls} calls"
-
-    # Case 2 — exact repro of warning: NaN at deep ITM call strikes.
-    nan_strikes = [64900.0, 65100.0, 65400.0, 66100.0, 67500.0]
-    ok, idx, calls = run_case(
-        "warning repro: 5 NaN deep-ITM, target=0.3", chain, 76956.7, 0.3, nan_strikes=nan_strikes
-    )
-    results.append(ok)
-
-    # Case 3 — NaN cluster centered on mid (chain mid ~ index 107, strike ~75600).
-    mid_nans = [strikes[i] for i in range(100, 115)]
-    ok, _, _ = run_case("NaN cluster around mid", chain, 76956.7, 0.3, nan_strikes=mid_nans)
-    results.append(ok)
-
-    # Case 4 — NaN around the seeding fractions (0.1, 0.25, 0.5, 0.75, 0.9).
-    seed_idxs = [int(round(f * 214)) for f in [0.1, 0.25, 0.5, 0.75]]  # leave 0.9 valid
-    seed_nans = [strikes[i] for i in seed_idxs]
-    ok, _, _ = run_case("NaN at most seed fractions", chain, 76956.7, 0.3, nan_strikes=seed_nans)
-    results.append(ok)
-
-    # Case 5 — all but two strikes NaN; should still find via linear fallback.
-    valid_strikes = {strikes[50], strikes[160]}
-    all_nan = [s for s in strikes if s not in valid_strikes]
-    ok, _, _ = run_case(
-        "only 2 valid strikes (linear fallback)", chain, 76956.7, 0.3, nan_strikes=all_nan
-    )
-    results.append(ok)
-
-    # Case 6 — entire chain NaN: must return -1 with warning, not crash.
-    ok, idx, _ = run_case(
-        "all NaN -> expect -1", chain, 76956.7, 0.3, nan_strikes=strikes, expect_index=False
-    )
-    results.append(ok)
-
-    # Case 7 — PUT chain (decreasing |delta| with strike).
-    put_chain = make_chain(strikes, opt_type="PUT")
-    ok, _, _ = run_case("PUT chain target=0.3", put_chain, 76956.7, 0.3)
-    results.append(ok)
-
-    # Case 8 — empty chain.
-    ok, idx, _ = run_case("empty chain -> -1", [], 76956.7, 0.3, expect_index=False)
-    results.append(ok)
-
-    passed = sum(results)
-    total = len(results)
-    print(f"\n{passed}/{total} passed")
-    sys.exit(0 if passed == total else 1)
-
-
-if __name__ == "__main__":
-    main()