tradingapi 0.2.1__tar.gz → 0.3.1__tar.gz

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

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

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

@@ -28,7 +28,7 @@ packages = ["tradingapi"]
 
 [project]
 name = "tradingapi"
-version = "0.2.1"
+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.1/tradingapi/allocation.py

@@ -0,0 +1,163 @@
+"""
+Allocation helpers for budget-based position sizing.
+
+Strategies read their daily pct from ~/onedrive/.tradingapi/allocations/master_allocation_today.yaml,
+then call these helpers at each entry decision to derive a live per-entry target margin.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import yaml
+
+if TYPE_CHECKING:
+    pass
+
+_ALLOCATIONS_DIR = Path(os.path.expanduser("~/onedrive/.tradingapi/allocations"))
+_TODAY_SYMLINK = _ALLOCATIONS_DIR / "master_allocation_today.yaml"
+
+
+def load_today_allocation(broker_name: str, strategy_name: str) -> float:
+    """Return the pct (0.0–1.0) allocated to strategy_name on broker_name today.
+
+    Reads master_allocation_today.yaml (a symlink to today's dated file).
+    Raises FileNotFoundError if the symlink/file is missing.
+    Raises ValueError if the date in the file does not match today.
+    Returns 0.0 if the strategy is listed with pct == 0 (inactive today).
+    Raises KeyError if the broker/strategy is not found in the file at all.
+    """
+    if not _TODAY_SYMLINK.exists():
+        raise FileNotFoundError(
+            f"Master allocation file not found: {_TODAY_SYMLINK}. "
+            "Run generate_master_allocation.py before starting strategies."
+        )
+
+    with open(_TODAY_SYMLINK) as f:
+        data = yaml.safe_load(f)
+
+    file_date = str(data.get("date", "")).strip()
+    today_str = dt.date.today().isoformat()
+    if file_date != today_str:
+        raise ValueError(
+            f"Master allocation file is stale: file date={file_date!r}, today={today_str!r}. "
+            "Regenerate with generate_master_allocation.py."
+        )
+
+    broker_key = broker_name.strip().upper()
+    brokers = data.get("brokers", {})
+    if broker_key not in brokers:
+        raise KeyError(
+            f"Broker {broker_key!r} not found in master allocation. "
+            f"Available brokers: {list(brokers.keys())}"
+        )
+
+    strategies = brokers[broker_key].get("strategies", {})
+    strategy_key = strategy_name.strip().upper()
+    if strategy_key not in strategies:
+        raise KeyError(
+            f"Strategy {strategy_key!r} not found under broker {broker_key!r} in master allocation. "
+            f"Available strategies: {list(strategies.keys())}"
+        )
+
+    entry = strategies[strategy_key]
+    return float(entry.get("pct", 0.0))
+
+
+def broker_capital(broker) -> float:
+    """Fetch live total capital from broker: cash + collateral."""
+    caps = broker.get_available_capital()
+    return float(caps.get("cash", 0.0)) + float(caps.get("collateral", 0.0))
+
+
+def current_utilisation(broker, strategy_name: str) -> float:
+    """Sum of margin currently consumed by open positions of this strategy.
+
+    Calls broker.get_margin_requirement() for each open position (net=False).
+    Exchange is read from Redis per position; defaults to NSE if missing.
+    """
+    from tradingapi.utils import get_pnl_table, hget_with_default
+
+    try:
+        pnl = get_pnl_table(broker, strategy_name, refresh_status=True)
+    except Exception:
+        return 0.0
+
+    if pnl.empty:
+        return 0.0
+
+    open_mask = (pnl["entry_quantity"].fillna(0) + pnl["exit_quantity"].fillna(0)) != 0
+    exit_empty = pnl["exit_time"].fillna("").astype(str).str.strip().isin(["", "0", "NaT"])
+    open_pnl = pnl.loc[open_mask | exit_empty]
+
+    total = 0.0
+    for _, row in open_pnl.iterrows():
+        combo_symbol = str(row.get("symbol", "")).strip()
+        if not combo_symbol:
+            continue
+        net_qty = float(row.get("entry_quantity", 0) or 0) + float(row.get("exit_quantity", 0) or 0)
+        if net_qty == 0:
+            continue
+        # Signed: positive = long, negative = short.
+        # parse_combo_symbol handles both simple and combo symbols uniformly.
+        order_size = int(net_qty)
+
+        entry_keys_str = str(row.get("entry_keys", "")).strip()
+        first_key = entry_keys_str.split()[0] if entry_keys_str else ""
+        exchange = hget_with_default(broker, first_key, "exchange", "NSE") if first_key else "NSE"
+
+        try:
+            margin = broker.get_margin_requirement(combo_symbol, order_size, exchange)
+            if margin is not None:
+                total += float(margin)
+        except Exception:
+            pass
+    return total
+
+
+def remaining_budget(budget: float, utilised: float) -> float:
+    return max(0.0, budget - utilised)
+
+
+def _remaining_factor_sum(open_positions: int, max_positions: int, decay: float, min_frac: float) -> float:
+    """Sum of decay fractions for future legs [open_positions, max_positions)."""
+    return float(sum(
+        max(min_frac, decay ** k)
+        for k in range(open_positions, max_positions)
+    ))
+
+
+def scalping_entry_target(
+    remaining: float,
+    open_positions: int,
+    max_positions: int,
+    decay: float,
+    min_frac: float,
+) -> float:
+    """Target margin for the next scalping entry given remaining budget.
+
+    Entry 1 (0 open): remaining / sum([1.0, 0.75, 0.5625]) ≈ remaining / 2.3125
+    Entry 2 (1 open): remaining / sum([0.75, 0.5625]) ≈ remaining / 1.3125
+    Entry 3 (2 open): remaining / 0.5625 → clamped to remaining (last leg gets all that's left)
+    """
+    if open_positions >= max_positions:
+        return 0.0
+    factor_sum = _remaining_factor_sum(open_positions, max_positions, decay, min_frac)
+    if factor_sum <= 0:
+        return remaining
+    raw = remaining / factor_sum
+    return min(raw, remaining)
+
+
+def strangle_entry_target(budget_now: float, remaining: float, scheduled_entries: int) -> float:
+    """Target margin for the next strangle entry.
+
+    Equal weighting across scheduled entries, clamped to what's actually left.
+    """
+    if scheduled_entries <= 0:
+        return remaining
+    equal_share = budget_now / scheduled_entries
+    return min(equal_share, remaining)

{tradingapi-0.2.1 → tradingapi-0.3.1}/tradingapi/broker_base.py

@@ -1076,7 +1076,7 @@ class BrokerBase(ABC):
         pass
 
     def get_margin_requirement(
-        self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds: Optional[str] = None
+        self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds: Optional[str] = None, net: bool = False
     ) -> Optional[float]:
         """Default broker margin hook. Brokers can override if supported."""
         _get_trading_logger().log_warning(

{tradingapi-0.2.1 → tradingapi-0.3.1}/tradingapi/config.py

@@ -541,6 +541,22 @@ def get_config() -> Config:
     return cast(Config, _config_instance)
 
 
+def get_fno_freeze_limit(broker_name: str, underlying: str) -> Optional[int]:
+    """Return max contracts per FNO order for (broker, underlying).
+
+    Values in tradingapi.yaml are total contracts (= lots × lot_size).
+    Returns None if no limit is configured for the broker/underlying.
+    """
+    try:
+        cfg = get_config()
+        freeze_cfg = cfg.get("freeze_limits") or {}
+        broker_map = (freeze_cfg.get("brokers") or {}).get(str(broker_name).strip().upper(), {})
+        val = broker_map.get(str(underlying).strip().upper())
+        return int(val) if val is not None else None
+    except Exception:
+        return None
+
+
 # Example usage with enhanced error handling
 if __name__ == "__main__":
     try:

{tradingapi-0.2.1 → 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(
@@ -778,7 +782,7 @@ class Dhan(BrokerBase):
         combo_symbol=lambda x: isinstance(x, str) and len(x.strip()) > 0,
         order_size=lambda x: isinstance(x, (int, float)) and int(x) != 0,
     )
-    def get_margin_requirement(self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds=None) -> float:
+    def get_margin_requirement(self, combo_symbol: str, order_size: int, exchange: str = "NSE", mds=None, net: bool = False) -> float:
         """Return basket margin required for a single-leg or multi-leg combo."""
         try:
             if self.api is None:
@@ -826,8 +830,8 @@ class Dhan(BrokerBase):
 
             payload = {
                 "dhanClientId": self.api.client_id,
-                "includePosition": False,
-                "includeOrder": False,
+                "includePosition": net,
+                "includeOrder": net,
                 "includeOrders": False,
                 "scripList": scripts,
                 "scripts": scripts,
@@ -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)