tradingapi 0.3.0__tar.gz → 0.3.1__tar.gz

{tradingapi-0.3.0 → tradingapi-0.3.1}/PKG-INFO

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

{tradingapi-0.3.0 → tradingapi-0.3.1}/pyproject.toml

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

tradingapi-0.3.1/tests/test_find_option_with_delta.py

@@ -0,0 +1,122 @@
+"""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()

{tradingapi-0.3.0 → tradingapi-0.3.1}/tradingapi/dhan.py

@@ -402,6 +402,10 @@ class Dhan(BrokerBase):
             self._global_market_data_rate_limit_lock_key = "dhan:market_data:lock"
             self._historical_audit_redis = None
             self._historical_audit_redis_db = 1
+            self._audit_enabled_cache: bool = False
+            self._audit_enabled_cache_ts: float = 0.0
+            self._audit_pid: str = str(os.getpid())
+            self._audit_proc_name: str = os.path.basename(sys.argv[0]) if sys.argv and sys.argv[0] else ""
             atexit.register(self._mark_process_shutting_down)
 
             trading_logger.log_info(
@@ -979,53 +983,51 @@ class Dhan(BrokerBase):
             parsed = parsed.replace(hour=23, minute=59, second=59, microsecond=999000)
         return parsed.isoformat(timespec="milliseconds")
 
-    def _log_historical_request_audit(
-        self,
-        symbol: Optional[str],
-        security_id: int,
-        interval: str,
-        from_date: str,
-        to_date: str,
-    ) -> None:
+    def _audit_dhan_call(self, call_type: str, fields: dict) -> None:
+        """Unified Redis stream audit for all Dhan API call types and errors.
+
+        call_type: "historical" | "quote" | "stream" | "error" | "stream_disconnect"
+        Toggle live (no restart): redis-cli -n 1 SET audit:dhan:enabled 1|0
+        """
+        now = time.monotonic()
+        if now - self._audit_enabled_cache_ts < 5.0:
+            if not self._audit_enabled_cache:
+                return
+        else:
+            try:
+                val = self._get_historical_audit_redis().get("audit:dhan:enabled")
+                self._audit_enabled_cache = val in (b"1", "1")
+            except Exception:
+                self._audit_enabled_cache = False
+            self._audit_enabled_cache_ts = now
+            if not self._audit_enabled_cache:
+                return
         try:
             audit_redis = self._get_historical_audit_redis()
             tz_ist = pytz.timezone("Asia/Kolkata")
             now_ist = dt.datetime.now(tz_ist)
             day_key = now_ist.strftime("%Y%m%d")
-            ts_ist = now_ist.isoformat(timespec="milliseconds")
-            symbol_str = str(symbol or "")
-
-            total_key = f"audit:dhan:historical:req:count:day:{day_key}"
-            per_symbol_key = f"audit:dhan:historical:req:count:symbol:{day_key}"
-            stream_key = f"audit:dhan:historical:req:v1:{day_key}"
-            ttl_seconds = 60 * 60 * 24 * 45
-
-            from_dt_ist = self._format_ist_datetime_string(from_date, is_end=False)
-            to_dt_ist = self._format_ist_datetime_string(to_date, is_end=True)
-
+            ttl = 60 * 60 * 24 * 45
+            stream_key = f"audit:dhan:{call_type}:req:v1:{day_key}"
+            combined_key = f"audit:dhan:all:req:v1:{day_key}"
+            count_key = f"audit:dhan:{call_type}:req:count:day:{day_key}"
+            entry = {
+                "ts_ist": now_ist.isoformat(timespec="milliseconds"),
+                "call_type": call_type,
+                "pid": self._audit_pid,
+                "proc": self._audit_proc_name,
+                **{k: str(v) for k, v in fields.items()},
+            }
             pipe = audit_redis.pipeline()
-            pipe.incr(total_key)
-            if symbol_str:
-                pipe.hincrby(per_symbol_key, symbol_str, 1)
-            pipe.xadd(
-                stream_key,
-                {
-                    "ts_ist": ts_ist,
-                    "symbol": symbol_str,
-                    "security_id": str(security_id),
-                    "interval": str(interval),
-                    "from_date": from_dt_ist,
-                    "to_date": to_dt_ist,
-                },
-                maxlen=500000,
-                approximate=True,
-            )
-            pipe.expire(total_key, ttl_seconds)
-            pipe.expire(per_symbol_key, ttl_seconds)
-            pipe.expire(stream_key, ttl_seconds)
+            pipe.incr(count_key)
+            pipe.xadd(stream_key, entry, maxlen=500000, approximate=True)
+            pipe.xadd(combined_key, entry, maxlen=1000000, approximate=True)
+            pipe.expire(count_key, ttl)
+            pipe.expire(stream_key, ttl)
+            pipe.expire(combined_key, ttl)
             pipe.execute()
         except Exception as e:
-            trading_logger.log_warning("Failed to audit Dhan historical request", {"error": str(e), "symbol": symbol})
+            trading_logger.log_warning(f"Failed to audit Dhan {call_type} call", {"error": str(e)})
 
     def _fetch_dhan_historical(
         self,
@@ -1060,13 +1062,13 @@ class Dhan(BrokerBase):
             url = self.api.base_url + "/charts/intraday"
 
         self._wait_for_historical_rate_limit()
-        self._log_historical_request_audit(
-            symbol=symbol,
-            security_id=security_id,
-            interval=periodicity,
-            from_date=from_date,
-            to_date=to_date,
-        )
+        self._audit_dhan_call("historical", {
+            "symbol": symbol or "",
+            "security_id": security_id,
+            "interval": periodicity,
+            "from_date": from_date,
+            "to_date": to_date,
+        })
         response = self.api.session.post(url, headers=self.api.header, timeout=self.api.timeout, data=json.dumps(payload))
         return self.api._parse_response(response)
 
@@ -1809,14 +1811,22 @@ class Dhan(BrokerBase):
                             continue
                     historical_data_list.sort(key=lambda x: x.date)
                 else:
+                    _hist_err = _extract_dhan_error_details(data)
                     trading_logger.log_error(
                         "No data from Dhan historical API",
                         None,
                         {
                             "symbol": long_symbol,
-                            **_extract_dhan_error_details(data),
+                            **_hist_err,
                         },
                     )
+                    self._audit_dhan_call("error", {
+                        "call_type": "historical",
+                        "symbol": long_symbol,
+                        "security_id": security_id,
+                        "exchange_segment": exchange_segment,
+                        **_hist_err,
+                    })
 
                 if periodicity in {"1d", "d"} and date_end_dt.date() == get_tradingapi_now().date():
                     # Refresh today's daily bar from 1m data (up-to-date partial OHLC), matching Shoonya-style behavior.
@@ -1949,6 +1959,11 @@ class Dhan(BrokerBase):
                 raise BrokerConnectionError("Dhan API not initialized")
 
             self._wait_for_quote_rate_limit()
+            self._audit_dhan_call("quote", {
+                "symbol": long_symbol,
+                "security_id": security_id,
+                "exchange_segment": exchange_segment,
+            })
             out = self.api.quote_data(securities={exchange_segment: [int(security_id)]})
             if out and out.get("status") == "success":
                 response_data = out.get("data", {}) or {}
@@ -1971,9 +1986,17 @@ class Dhan(BrokerBase):
                     market_feed.ask_volume = int(sell_qty[0].get("quantity", 0) or 0)
                 return market_feed
 
+            _quote_err = _extract_dhan_error_details(out)
+            self._audit_dhan_call("error", {
+                "call_type": "quote",
+                "symbol": long_symbol,
+                "security_id": security_id,
+                "exchange_segment": exchange_segment,
+                **_quote_err,
+            })
             trading_logger.log_warning(
                 "Dhan quote_data unavailable",
-                {"long_symbol": long_symbol, **_extract_dhan_error_details(out)},
+                {"long_symbol": long_symbol, **_quote_err},
             )
 
             return market_feed
@@ -2438,6 +2461,18 @@ class Dhan(BrokerBase):
                                 # Call synchronously; avoids RuntimeError from asyncio.to_thread()
                                 # when concurrent.futures thread pool is torn down by another component.
                                 self._wait_for_stream_request_rate_limit()
+                                self._audit_dhan_call("stream", {
+                                    "request_code": message.get("RequestCode", ""),
+                                    "instrument_count": len(message.get("InstrumentList", [])),
+                                    "operation": "subscribe",
+                                    "symbols": ",".join(
+                                        stream_symbol_map.get(
+                                            (_DHAN_FEED_SEGMENT_MAP.get(instr.get("ExchangeSegment", ""), ("", -1))[1], int(instr.get("SecurityId", -1))),
+                                            (instr.get("SecurityId", ""), ""),
+                                        )[0]
+                                        for instr in message.get("InstrumentList", [])
+                                    ),
+                                })
                                 await ws.send(json.dumps(message))
                             while self._streaming:
                                 raw = await ws.recv()
@@ -2462,6 +2497,10 @@ class Dhan(BrokerBase):
                         trading_logger.log_info("Dhan streaming thread closed cleanly")
                     else:
                         trading_logger.log_error("Dhan streaming thread error", e, {})
+                        self._audit_dhan_call("stream_disconnect", {
+                            "error": str(e),
+                            "error_type": type(e).__name__,
+                        })
                 finally:
                     try:
                         if loop is not None and not loop.is_closed():
@@ -2500,6 +2539,18 @@ class Dhan(BrokerBase):
                 async def _send_incremental_messages():
                     for message in delta_messages:
                         self._wait_for_stream_request_rate_limit()
+                        self._audit_dhan_call("stream", {
+                            "request_code": message.get("RequestCode", ""),
+                            "instrument_count": len(message.get("InstrumentList", [])),
+                            "operation": "subscribe_delta",
+                            "symbols": ",".join(
+                                stream_symbol_map.get(
+                                    (_DHAN_FEED_SEGMENT_MAP.get(instr.get("ExchangeSegment", ""), ("", -1))[1], int(instr.get("SecurityId", -1))),
+                                    (instr.get("SecurityId", ""), ""),
+                                )[0]
+                                for instr in message.get("InstrumentList", [])
+                            ),
+                        })
                         await ws.send(json.dumps(message))
 
                 future = asyncio.run_coroutine_threadsafe(_send_incremental_messages(), loop)

{tradingapi-0.3.0 → tradingapi-0.3.1}/tradingapi/fivepaisa.py

@@ -45,13 +45,11 @@ def _patch_py5paisa_for_mom(api) -> None:
          call accumulates stale body keys across calls; the polluted body
          makes the 5paisa server hang past 5s. Reset to a fresh deep copy
          before each MOM call.
-      3. order_request() does log_response(res["body"]["Message"]) for the
-         MOM branch, but the MOM response has no "Message" key — the KeyError
-         is raised at the subscript (not inside log_response), is swallowed
-         by the bare except, and the function silently returns None. Inject
-         an empty "Message" into the response by wrapping session.post for
-         the duration of the MOM call so the subscript succeeds and
-         res["body"] is returned normally.
+      3. order_request() does res["body"]["Message"] for MOM, but the MOM
+         response has no "Message" key — KeyError is raised at the subscript,
+         swallowed by the bare except, and the function silently returns None.
+         Replace order_request for the MOM case to extract res["body"] directly
+         without touching "Message".
     """
     if getattr(api, "_tradingapi_patched", False):
         return
@@ -64,28 +62,35 @@ def _patch_py5paisa_for_mom(api) -> None:
     except Exception:
         pass
 
-    original_mom = api.multi_order_Margin
-    original_post = api.session.post
+    original_order_request = api.order_request
 
-    def post_with_message_key(*args, **kwargs):
-        response = original_post(*args, **kwargs)
+    def safe_order_request(req_type):
+        if req_type != "MOM":
+            return original_order_request(req_type)
         try:
-            data = response.json()
-            if isinstance(data, dict) and isinstance(data.get("body"), dict):
-                data["body"].setdefault("Message", "")
-                response.json = lambda: data  # type: ignore[method-assign]
-        except Exception:
-            pass
-        return response
+            api.payload["body"]["ClientCode"] = api.client_code
+            api.payload["head"]["key"] = api.USER_KEY
+            from py5paisa.const import HEADERS
+            token = api.access_token or api.Jwt_token
+            headers = dict(HEADERS)
+            headers["Authorization"] = f"Bearer {token}"
+            headers["5Paisa-API-Uid"] = api.APIUID
+            res = api.session.post(api.MULTIORDERMARGIN_ROUTE, json=api.payload, headers=headers).json()
+            api.payload = copy.deepcopy(GENERIC_PAYLOAD)
+            return res.get("body")
+        except Exception as e:
+            from . import trading_logger
+            trading_logger.log_warning("py5paisa MOM request failed", {"error": repr(e)})
+            api.payload = copy.deepcopy(GENERIC_PAYLOAD)
+            return None
 
     def fixed_multi_order_Margin(**order):
         api.payload = copy.deepcopy(GENERIC_PAYLOAD)
-        api.session.post = post_with_message_key  # type: ignore[method-assign]
-        try:
-            return original_mom(**order)
-        finally:
-            api.session.post = original_post  # type: ignore[method-assign]
+        for k, v in order.items():
+            api.payload["body"][k] = v
+        return safe_order_request("MOM")
 
+    api.order_request = safe_order_request
     api.multi_order_Margin = fixed_multi_order_Margin
     api._tradingapi_patched = True
 

{tradingapi-0.3.0 → tradingapi-0.3.1}/tradingapi/utils.py

@@ -3242,116 +3242,132 @@ def find_option_with_delta(
     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
-    # Determine if delta is increasing or decreasing
-    mid = (left + right) // 2
-    delta_1, delta_2 = float("nan"), float("nan")
-
-    # Find the first valid left-side delta
-    i = mid
-    while i >= left and math.isnan(delta_1):
-        total_delta_checks += 1
-        delta_1 = calculate_delta(
-            brokers, option_chain[i], price_f, market_close_time, exchange=opt_exchange, mds=mds, as_of=as_of
+    nan_delta_strikes = []  # track strikes where delta could not be calculated
+    # Cache so seeding sweep + binary search + linear fallback 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
         )
-        if math.isnan(delta_1):
+        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
-        i -= 1
+        delta_cache[idx] = d
+        return d
 
-    # Find the first valid right-side delta
-    i = mid + 1
-    while i <= right and math.isnan(delta_2):
-        total_delta_checks += 1
-        delta_2 = calculate_delta(
-            brokers, option_chain[i], price_f, market_close_time, exchange=opt_exchange, mds=mds, as_of=as_of
-        )
-        if math.isnan(delta_2):
-            nan_delta_count += 1
+    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:
-            valid_delta_count += 1
-        i += 1
+            if abs_delta >= target_delta and abs_delta < best_delta:
+                best_delta = abs_delta
+                best_index = idx
 
-    # If we cannot determine a valid direction, return -1
-    if math.isnan(delta_1) or math.isnan(delta_2):
-        trading_logger.log_info(
-            f"find_option_with_delta: no valid option strike found (direction inference failed). "
-            f"price_f={price_f} target_delta={target_delta} return_lower_delta={return_lower_delta} "
-            f"chain_len={len(option_chain)} strike_range=[{strike_lo}, {strike_hi}] "
-            f"delta_1={delta_1} delta_2={delta_2} "
-            f"mid_strike={_strike(option_chain[mid]) if option_chain and mid < len(option_chain) else None} "
-            f"valid_delta_count={valid_delta_count} nan_delta_count={nan_delta_count} total_delta_checks={total_delta_checks}"
+    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
+
+    # --- 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:
+        # Too few seeds; fall through to linear scan over the whole chain.
+        for idx in range(n):
+            d = _delta_at(idx)
+            if math.isnan(d):
+                continue
+            _consider(idx, abs(d))
+        if best_index < 0:
+            trading_logger.log_warning(
+                f"find_option_with_delta: no valid option strike found (linear fallback after 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
 
-    increasing = abs(delta_2) > abs(delta_1)  # True if deltas increase with strike price
-    # if delta is nan, we need to decide if the search range is to the left or right of the present strike
-    # and use delta_2's position vis_a-vis target_delta to determine the direction of move to identity next best delta.
-    move_right_on_nan_delta = True
-    if abs(delta_2) > target_delta and increasing:
-        move_right_on_nan_delta = False
-    elif abs(delta_2) > target_delta and not increasing:
-        move_right_on_nan_delta = True
-    elif abs(delta_2) < target_delta and increasing:
-        move_right_on_nan_delta = True
-    elif abs(delta_2) < target_delta and not increasing:
-        move_right_on_nan_delta = False
+    # Determine monotonicity from lowest- vs. highest-strike valid seeds.
+    increasing = seed_samples[-1][1] > seed_samples[0][1]
 
-    while left <= right:
-        mid = (left + right) // 2
-        delta = calculate_delta(
-            brokers, option_chain[mid], price_f, market_close_time, exchange=opt_exchange, mds=mds, as_of=as_of
-        )
-        total_delta_checks += 1
-        delta = abs(delta)  # always select an option using the absolute value of delta.
+    # --- Change 2: NaN at mid -> scan to nearest valid neighbor instead of shrinking range ---
+    NAN_SCAN_CAP = 5
 
-        if math.isnan(delta):
-            nan_delta_count += 1
-            # Don't exclude the range containing current best (where target delta likely is).
-            # Otherwise e.g. NaN at mid=59 leads to right=58 and we exclude [59,119], losing index 110.
-            if best_index >= 0:
-                if mid < best_index:
-                    left = mid + 1  # Keep [mid+1, right] so we don't drop best_index
-                else:
-                    right = mid - 1  # Keep [left, mid-1]
-            else:
-                if move_right_on_nan_delta:
-                    left = mid + 1
-                else:
-                    right = mid - 1
-            continue
-        valid_delta_count += 1
+    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
+        return -1
 
-        # Update best index if this delta is a better fit
-        if return_lower_delta:
-            if delta <= target_delta and delta > best_delta:
-                best_delta = delta
-                best_index = mid
-        else:
-            if delta >= target_delta and delta < best_delta:
-                best_delta = delta
-                best_index = mid
+    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 — bail to linear fallback below.
+                break
+            eff_idx = alt
+            d = delta_cache[alt]
+        ad = abs(d)
+        _consider(eff_idx, ad)
 
-        # Adjust binary search range based on delta trend
         if increasing:
-            if delta > target_delta:
-                right = mid - 1  # Search lower strikes for smaller deltas
+            if ad > target_delta:
+                right = eff_idx - 1
             else:
-                left = mid + 1  # Search higher strikes for bigger deltas
+                left = eff_idx + 1
         else:
-            if delta > target_delta:
-                left = mid + 1  # Search higher strikes for smaller deltas
+            if ad > target_delta:
+                left = eff_idx + 1
             else:
-                right = mid - 1  # Search lower strikes for bigger deltas
+                right = eff_idx - 1
+
+    # --- Change 3: linear-scan fallback if binary search failed to land a best ---
+    if best_index < 0:
+        for idx in range(n):
+            if idx in delta_cache:
+                d = delta_cache[idx]
+            else:
+                d = _delta_at(idx)
+            if math.isnan(d):
+                continue
+            _consider(idx, abs(d))
 
     if best_index < 0:
         trading_logger.log_warning(
             f"find_option_with_delta: no valid option strike found. "
-            f"price_f={price_f} chain_len={len(option_chain)} 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"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))}"
         )
     return best_index
 

{tradingapi-0.3.0 → tradingapi-0.3.1}/tradingapi.egg-info/PKG-INFO

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

{tradingapi-0.3.0 → tradingapi-0.3.1}/tradingapi.egg-info/SOURCES.txt

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