tradingapi 0.3.5__tar.gz → 0.3.6__tar.gz

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

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

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

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

tradingapi-0.3.6/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.5 → tradingapi-0.3.6}/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.6}/tradingapi/fivepaisa.py

@@ -3738,12 +3738,11 @@ class FivePaisa(BrokerBase):
                     raise BrokerConnectionError(
                         "FivePaisa stream session helpers not initialized; connect() must succeed before streaming"
                     )
-                if not restore_fn(token_path):
-                    trading_logger.log_warning(
-                        "Token restore failed during reconnect, attempting fresh login",
-                        {"broker": self.broker.name},
-                    )
-                    fresh_fn(token_path)
+                # 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)

{tradingapi-0.3.5 → tradingapi-0.3.6}/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:
@@ -3175,8 +3179,10 @@ def calculate_delta(
 ):
     delta = float("nan")
     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
+        ticker = get_price(brokers, long_symbol, checks=["bid", "ask"], exchange=exchange, mds=mds)
+        if not (ticker.bid > 0 and ticker.ask > 0):
+            return float("nan")
+        price = (ticker.bid + ticker.ask) / 2
         t = (
             calc_fractional_business_days(
                 get_tradingapi_now(),
@@ -3284,30 +3290,14 @@ def find_option_with_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
+    # Monotonicity is deterministic from option type: calls lose delta as strike rises, puts gain it.
+    increasing = "_PUT_" in option_chain[0]
 
-    # Determine monotonicity from lowest- vs. highest-strike valid seeds.
-    increasing = seed_samples[-1][1] > seed_samples[0][1]
+    # Seed at midpoint (near ATM) — most liquid, least likely to have stale data.
+    mid_seed = n // 2
+    d = _delta_at(mid_seed)
+    if not math.isnan(d):
+        _consider(mid_seed, abs(d))
 
     # --- Change 2: NaN at mid -> scan to nearest valid neighbor instead of shrinking range ---
     NAN_SCAN_CAP = 5
@@ -3382,6 +3372,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 +3394,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 +3468,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 +4602,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.6}/tradingapi.egg-info/PKG-INFO

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

{tradingapi-0.3.5 → tradingapi-0.3.6}/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