tradingapi 0.3.10__tar.gz → 0.3.11__tar.gz

{tradingapi-0.3.10 → tradingapi-0.3.11}/PKG-INFO

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

{tradingapi-0.3.10 → tradingapi-0.3.11}/pyproject.toml

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

tradingapi-0.3.11/tests/test_fivepaisa_stream_reconnect.py

@@ -0,0 +1,135 @@
+import json
+import sys
+import threading
+import time
+from unittest.mock import patch
+
+sys.path.insert(0, "/home/psharma/onedrive/code/tradingapi2")
+
+from tradingapi.broker_base import Brokers
+from tradingapi.fivepaisa import FivePaisa
+from tradingapi import fivepaisa as fivepaisa_module
+
+
+class _SocketState:
+    connected = True
+
+
+class _WebSocket:
+    def __init__(self, sent_requests):
+        self.sock = _SocketState()
+        self.on_open = None
+        self.sent_requests = sent_requests
+
+    def send(self, payload):
+        self.sent_requests.append(json.loads(payload))
+
+
+class _DelayedStreamingApi:
+    def __init__(self, connect_started, allow_connect, stop_stream):
+        self.ws = None
+        self.connect_started = connect_started
+        self.allow_connect = allow_connect
+        self.stop_stream = stop_stream
+        self.connect_calls = 0
+        self.sent_requests = []
+
+    def Request_Feed(self, feed_type, operation, symbols):
+        return {"feed": feed_type, "operation": operation, "symbols": symbols}
+
+    def connect(self, _request):
+        self.connect_calls += 1
+        self.connect_started.set()
+        assert self.allow_connect.wait(timeout=2)
+        self.ws = _WebSocket(self.sent_requests)
+
+    def error_data(self, callback):
+        self.error_callback = callback
+
+    def receive_data(self, callback):
+        callback(self.ws, json.dumps({"Token": 1, "LastRate": 100.0}))
+        self.stop_stream.wait(timeout=2)
+
+    def close_data(self):
+        if self.ws is not None:
+            self.ws.sock.connected = False
+
+
+def _make_broker(api, fresh_login):
+    broker = object.__new__(FivePaisa)
+    broker.api = api
+    broker.broker = Brokers.FIVEPAISA
+    broker.account_key = broker.broker.name
+    broker.subscribe_thread = None
+    broker.subscribed_symbols = []
+    broker._stream_reconnect_lock = threading.Lock()
+    broker._stream_reconnect_serial_lock = threading.Lock()
+    broker._stream_subscriptions_lock = threading.Lock()
+    broker._stream_reconnect_active = False
+    broker._suppress_stream_reconnect = False
+    broker._last_stream_tick_ts = time.time() - 1
+    broker._fp_susertoken_path = "/tmp/fivepaisa-token"
+    broker._fp_restore_session_from_token = lambda _path: True
+    broker._fp_fresh_login = fresh_login
+    broker._wait_for_stream_request_rate_limit = lambda: None
+    broker.map_exchange_for_api = lambda _symbol, _exchange: "N"
+    broker.map_exchange_for_db = lambda _symbol, exchange: exchange
+    broker.exchange_mappings = {
+        "N": {
+            "symbol_map": {"TEST": 1, "TEST2": 2},
+            "symbol_map_reversed": {1: "TEST", 2: "TEST2"},
+            "exchangetype_map": {"TEST": "C", "TEST2": "C"},
+        }
+    }
+    return broker
+
+
+def test_reconnect_waits_for_startup_and_coalesces_queued_callers():
+    connect_started = threading.Event()
+    allow_connect = threading.Event()
+    stop_stream = threading.Event()
+    api = _DelayedStreamingApi(connect_started, allow_connect, stop_stream)
+    fresh_login_calls = []
+    broker = _make_broker(api, lambda path: fresh_login_calls.append(path))
+    errors = []
+
+    def start_stream(symbol):
+        try:
+            broker.start_quotes_streaming("s", [symbol], exchange="NSE")
+        except Exception as exc:
+            errors.append(exc)
+
+    first_caller = threading.Thread(target=start_stream, args=("TEST",))
+    second_caller = threading.Thread(target=start_stream, args=("TEST2",))
+    with patch.object(fivepaisa_module.config, "get", return_value="/tmp/fivepaisa-token"):
+        first_caller.start()
+        assert connect_started.wait(timeout=2)
+        second_caller.start()
+        time.sleep(0.05)
+        allow_connect.set()
+        first_caller.join(timeout=2)
+        second_caller.join(timeout=2)
+        broker.start_quotes_streaming("s", ["TEST"], exchange="NSE")
+
+    stop_stream.set()
+    if broker.subscribe_thread is not None:
+        broker.subscribe_thread.join(timeout=2)
+
+    assert not first_caller.is_alive()
+    assert not second_caller.is_alive()
+    assert not errors
+    assert api.connect_calls == 1
+    assert fresh_login_calls == ["/tmp/fivepaisa-token"]
+    assert broker.subscribed_symbols == ["TEST", "TEST2"]
+    assert api.sent_requests == [
+        {
+            "feed": "mf",
+            "operation": "s",
+            "symbols": [{"Exch": "N", "ExchType": "C", "ScripCode": 2}],
+        },
+        {
+            "feed": "mf",
+            "operation": "s",
+            "symbols": [{"Exch": "N", "ExchType": "C", "ScripCode": 1}],
+        },
+    ]

{tradingapi-0.3.10 → tradingapi-0.3.11}/tradingapi/fivepaisa.py

@@ -351,6 +351,7 @@ class FivePaisa(BrokerBase):
             self._fp_fresh_login: Optional[Callable[[str], None]] = None
             self._stream_reconnect_lock = threading.Lock()
             self._stream_reconnect_serial_lock = threading.Lock()
+            self._stream_subscriptions_lock = threading.Lock()
             self._stream_reconnect_active = False
             self._suppress_stream_reconnect = False
             self._last_stream_tick_ts = 0.0
@@ -3392,24 +3393,31 @@ class FivePaisa(BrokerBase):
                 context = create_error_context(date_string=date_string, date_string_type=type(date_string))
                 raise ValidationError("Invalid date string", context)
 
+            def _stale_market_open_timestamp() -> str:
+                now_ist = get_tradingapi_now()
+                if now_ist.tzinfo is not None:
+                    now_ist = now_ist.astimezone(dt.timezone(dt.timedelta(hours=5, minutes=30))).replace(tzinfo=None)
+                market_open = dt.datetime.combine(now_ist.date(), dt.time(9, 15))
+                return market_open.strftime("%Y-%m-%d %H:%M:%S")
+
             # Extract the timestamp using regex (allow negative for .NET min-date, treated as invalid)
             match = re.search(r"/Date\((-?\d+)\)/", date_string)
             if not match:
                 trading_logger.log_warning(
                     "Invalid date format", {"date_string": date_string, "expected_format": "/Date(milliseconds)/"}
                 )
-                return get_tradingapi_now().strftime("%Y-%m-%d %H:%M:%S")
+                return _stale_market_open_timestamp()
 
             try:
                 # Convert the timestamp from milliseconds to seconds
                 timestamp_ms = int(match.group(1))
-                # Treat negative timestamps (e.g. .NET min date) as invalid; substitute current time
+                # Treat negative timestamps (e.g. .NET min date) as invalid; substitute market-open stale time
                 if timestamp_ms < 0:
                     trading_logger.log_info(
                         "Invalid date (negative timestamp)",
                         {"date_string": date_string, "expected_format": "/Date(milliseconds)/"},
                     )
-                    return get_tradingapi_now().strftime("%Y-%m-%d %H:%M:%S")
+                    return _stale_market_open_timestamp()
                 timestamp_s = timestamp_ms / 1000
 
                 # Convert to UTC datetime
@@ -3429,18 +3437,28 @@ class FivePaisa(BrokerBase):
                 return result
 
             except (ValueError, OverflowError) as e:
-                context = create_error_context(
-                    date_string=date_string,
-                    timestamp_ms=timestamp_ms if "timestamp_ms" in locals() else None,
-                    error=str(e),
+                trading_logger.log_warning(
+                    "Error converting timestamp; using market-open stale timestamp",
+                    {
+                        "date_string": date_string,
+                        "timestamp_ms": timestamp_ms if "timestamp_ms" in locals() else None,
+                        "error": str(e),
+                    },
                 )
-                raise DataError(f"Error converting timestamp: {str(e)}", context)
+                return _stale_market_open_timestamp()
 
         except (ValidationError, DataError):
-            raise
+            trading_logger.log_warning(
+                "Validation/data error converting timestamp; using market-open stale timestamp",
+                {"date_string": date_string},
+            )
+            return _stale_market_open_timestamp()
         except Exception as e:
-            context = create_error_context(date_string=date_string, error=str(e))
-            raise DataError(f"Unexpected error converting to IST: {str(e)}", context)
+            trading_logger.log_warning(
+                "Unexpected error converting timestamp; using market-open stale timestamp",
+                {"date_string": date_string, "error": str(e)},
+            )
+            return _stale_market_open_timestamp()
 
     @log_execution_time
     @validate_inputs(
@@ -3760,7 +3778,14 @@ class FivePaisa(BrokerBase):
                     if json_data.get("TickDt"):
                         price.timestamp = self.convert_to_ist(json_data["TickDt"])
                     else:
-                        price.timestamp = dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        now_ist = get_tradingapi_now()
+                        if now_ist.tzinfo is not None:
+                            now_ist = now_ist.astimezone(dt.timezone(dt.timedelta(hours=5, minutes=30))).replace(
+                                tzinfo=None
+                            )
+                        price.timestamp = dt.datetime.combine(now_ist.date(), dt.time(9, 15)).strftime(
+                            "%Y-%m-%d %H:%M:%S"
+                        )
                     prices[resolved_symbol] = price
                     return price
                 except Exception as e:
@@ -3939,9 +3964,13 @@ class FivePaisa(BrokerBase):
                     and is_ws_connected(ws)
                 )
 
-            def reconnect_stream():
+            def reconnect_stream() -> bool:
                 """Start a fresh websocket and restore all subscriptions."""
                 with self._stream_reconnect_serial_lock:
+                    # Another caller may have restored the stream while this caller
+                    # waited for the serial reconnect lock.
+                    if has_live_stream():
+                        return False
                     previous_tick_ts = self._last_stream_tick_ts
                     try:
                         self._suppress_stream_reconnect = True
@@ -3970,7 +3999,9 @@ class FivePaisa(BrokerBase):
                     # 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)
+                    with self._stream_subscriptions_lock:
+                        subscribed_symbols = list(self.subscribed_symbols)
+                    req_list_full = expand_symbols_to_request(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)
@@ -3982,31 +4013,34 @@ class FivePaisa(BrokerBase):
                         copy.deepcopy(self.api.Request_Feed("oi", "s", oi_req_list_full))
                     ] if oi_req_list_full else []
                     reconnect_started_ts = time.time()
-                    self.subscribe_thread = threading.Thread(
+                    stream_thread = threading.Thread(
                         target=connect_and_receive,
                         args=(req_data_full, extra_req_data_full),
                         name="MarketDataStreamer",
                     )
-                    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:
+                    self.subscribe_thread = stream_thread
+                    stream_thread.start()
+                    should_verify_ticks = previous_tick_ts > 0 and bool(subscribed_symbols)
+                    deadline = time.time() + _stream_reconnect_verify_timeout_secs
+                    while time.time() < deadline:
+                        if should_verify_ticks and self._last_stream_tick_ts >= reconnect_started_ts:
+                            break
+                        if not should_verify_ticks and has_live_stream():
+                            break
+                        if not stream_thread.is_alive():
+                            raise BrokerConnectionError("WebSocket thread died during reconnect verification")
+                        time.sleep(0.1)
+                    else:
+                        if should_verify_ticks:
                             raise BrokerConnectionError(
                                 "WebSocket reconnected but remained silent after reconnect verification"
                             )
-                    else:
-                        time.sleep(2)
+                        raise BrokerConnectionError("WebSocket did not connect during reconnect verification")
                     trading_logger.log_info(
                         "Reconnected after socket closure",
-                        {"subscribed_count": len(self.subscribed_symbols), "verified_ticks": should_verify_ticks},
+                        {"subscribed_count": len(subscribed_symbols), "verified_ticks": should_verify_ticks},
                     )
+                    return True
 
             def send_stream_request(req_data):
                 """Send an incremental subscribe/unsubscribe over an existing websocket."""
@@ -4079,17 +4113,21 @@ class FivePaisa(BrokerBase):
             def update_current_subscriptions(operation, symbols):
                 """Update current subscriptions."""
                 try:
-                    if operation == "s":
-                        self.subscribed_symbols.extend(symbols)
-                        trading_logger.log_info(
-                            "Symbols subscribed", {"symbols": symbols, "total_subscribed": len(self.subscribed_symbols)}
-                        )
-                    elif operation == "u":
-                        self.subscribed_symbols = list(set(self.subscribed_symbols) - set(symbols))
-                        trading_logger.log_info(
-                            "Symbols unsubscribed",
-                            {"symbols": symbols, "total_subscribed": len(self.subscribed_symbols)},
-                        )
+                    with self._stream_subscriptions_lock:
+                        if operation == "s":
+                            self.subscribed_symbols = list(dict.fromkeys([*self.subscribed_symbols, *symbols]))
+                            message = "Symbols subscribed"
+                        else:
+                            removed_symbols = set(symbols)
+                            self.subscribed_symbols = [
+                                symbol for symbol in self.subscribed_symbols if symbol not in removed_symbols
+                            ]
+                            message = "Symbols unsubscribed"
+                        total_subscribed = len(self.subscribed_symbols)
+                    trading_logger.log_info(
+                        message,
+                        {"symbols": symbols, "total_subscribed": total_subscribed},
+                    )
                 except Exception as e:
                     trading_logger.log_error(
                         "Error updating subscriptions", e, {"operation": operation, "symbols": symbols}
@@ -4111,7 +4149,10 @@ class FivePaisa(BrokerBase):
                     if not has_live_stream():
                         # WS is dead — full reconnect restoring all subscribed_symbols (already updated above).
                         # Connecting with just the current op's req_data would lose all prior subscriptions.
-                        reconnect_stream()
+                        if not reconnect_stream():
+                            send_stream_request(req_data)
+                            if oi_req_data:
+                                send_stream_request(oi_req_data)
                     else:
                         trading_logger.log_info(
                             "Requesting streaming for existing connection", {"req_data": json.dumps(req_data)}
@@ -4125,8 +4166,10 @@ class FivePaisa(BrokerBase):
                                 "WebSocket closed, reconnecting...",
                                 {"operation": operation, "symbols_count": len(symbols), "exchange": exchange},
                             )
-                            reconnect_stream()
-                            # New connection already has full subscription; no need to send again
+                            if not reconnect_stream():
+                                send_stream_request(req_data)
+                                if oi_req_data:
+                                    send_stream_request(oi_req_data)
                 else:
                     trading_logger.log_warning(
                         "No valid request list generated", {"symbols": symbols, "req_list": req_list}