pmxt 2.46.2__tar.gz → 2.46.4__tar.gz

{pmxt-2.46.2 → pmxt-2.46.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pmxt
-Version: 2.46.2
+Version: 2.46.4
 Summary: Unified prediction market data API - The ccxt for prediction markets
 Author: PMXT Contributors
 License: MIT

{pmxt-2.46.2 → pmxt-2.46.4}/generated/pmxt_internal/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "2.46.2"
+__version__ = "2.46.4"
 
 # Define package exports
 __all__ = [

{pmxt-2.46.2 → pmxt-2.46.4}/generated/pmxt_internal/api_client.py

@@ -91,7 +91,7 @@ class ApiClient:
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/2.46.2/python'
+        self.user_agent = 'OpenAPI-Generator/2.46.4/python'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

{pmxt-2.46.2 → pmxt-2.46.4}/generated/pmxt_internal/configuration.py

@@ -506,7 +506,7 @@ class Configuration:
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: 0.4.4\n"\
-               "SDK Package Version: 2.46.2".\
+               "SDK Package Version: 2.46.4".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self) -> List[HostSetting]:

{pmxt-2.46.2 → pmxt-2.46.4}/pmxt/__init__.py

@@ -145,7 +145,7 @@ def restart_server() -> None:
     )
     _default_manager.restart()
 
-__version__ = "2.46.2"
+__version__ = "2.46.4"
 __all__ = [
     # Exchanges
     "Polymarket",

{pmxt-2.46.2 → pmxt-2.46.4}/pmxt/_server/server/bundled.js

@@ -214440,10 +214440,20 @@ var require_utils25 = __commonJS({
     exports2.paginateLimitlessMarkets = paginateLimitlessMarkets;
     var market_utils_1 = require_market_utils();
     exports2.DEFAULT_LIMITLESS_API_URL = "https://api.limitless.exchange";
-    function mapMarketToUnified(market) {
+    function mapMarketToUnified(market, context = {}) {
       if (!market)
         return null;
+      const resolvedContext = {
+        eventId: getText(market.__pmxtEventId) || context.eventId,
+        eventTitle: getText(market.__pmxtEventTitle) || context.eventTitle,
+        eventDescription: getText(market.__pmxtEventDescription) || context.eventDescription,
+        categories: getStringArray(market.__pmxtCategories) || context.categories,
+        tags: getStringArray(market.__pmxtTags) || context.tags
+      };
       const outcomes = [];
+      const rawTitle = getText(market.title) || getText(market.question) || market.slug;
+      const title = composeMarketTitle(rawTitle, resolvedContext.eventTitle);
+      const hasParentContext = Boolean(resolvedContext.eventTitle && rawTitle);
       if (market.tokens) {
         if (!market.tokens.yes || !market.tokens.no) {
           throw new Error(`[limitless] Market "${market.slug}" is missing token addresses`);
@@ -214451,10 +214461,12 @@ var require_utils25 = __commonJS({
         const prices = Array.isArray(market.prices) ? market.prices : [];
         const yesPrice = prices[0] || 0;
         const noPrice = prices[1] || 0;
+        const yesLabel = hasParentContext ? rawTitle : "Yes";
+        const noLabel = hasParentContext ? `Not ${rawTitle}` : "No";
         outcomes.push({
           outcomeId: market.tokens.yes,
           marketId: market.slug,
-          label: "Yes",
+          label: yesLabel,
           price: yesPrice,
           priceChange24h: 0,
           metadata: { clobTokenId: market.tokens.yes }
@@ -214462,7 +214474,7 @@ var require_utils25 = __commonJS({
         outcomes.push({
           outcomeId: market.tokens.no,
           marketId: market.slug,
-          label: "No",
+          label: noLabel,
           price: noPrice,
           priceChange24h: 0,
           metadata: { clobTokenId: market.tokens.no }
@@ -214476,9 +214488,9 @@ var require_utils25 = __commonJS({
       const um = {
         id: market.slug,
         marketId: market.slug,
-        eventId: market.slug,
-        title: market.title || market.question,
-        description: market.description,
+        eventId: resolvedContext.eventId || market.slug,
+        title,
+        description: market.description || resolvedContext.eventDescription,
         slug: market.slug,
         outcomes,
         resolutionDate: market.expirationTimestamp ? new Date(market.expirationTimestamp) : /* @__PURE__ */ new Date(),
@@ -214490,13 +214502,32 @@ var require_utils25 = __commonJS({
         // Not directly in the flat market list
         url: `https://limitless.exchange/markets/${market.slug}`,
         image: market.logo || `https://limitless.exchange/api/og?slug=${market.slug}`,
-        category: market.categories?.[0],
-        tags: market.tags || [],
+        category: market.categories?.[0] || resolvedContext.categories?.[0],
+        tags: market.tags || resolvedContext.tags || [],
         status
       };
       (0, market_utils_1.addBinaryOutcomes)(um);
       return um;
     }
+    function getText(value) {
+      return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+    }
+    function getStringArray(value) {
+      return Array.isArray(value) ? value.filter((item) => typeof item === "string") : void 0;
+    }
+    function normalizeTitle(value) {
+      return value.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+    }
+    function composeMarketTitle(childTitle, eventTitle) {
+      if (!eventTitle)
+        return childTitle;
+      const normalizedChild = normalizeTitle(childTitle);
+      const normalizedEvent = normalizeTitle(eventTitle);
+      if (!normalizedChild || !normalizedEvent || normalizedChild.startsWith(normalizedEvent)) {
+        return childTitle;
+      }
+      return `${eventTitle} - ${childTitle}`;
+    }
     function mapIntervalToFidelity(interval) {
       const mapping = {
         "1m": 1,
@@ -214707,7 +214738,14 @@ var require_fetcher2 = __commonJS({
         for (const res of rawResults) {
           if (res.markets && Array.isArray(res.markets)) {
             for (const child of res.markets) {
-              allRawMarkets.push(child);
+              allRawMarkets.push({
+                ...child,
+                __pmxtEventId: res.slug,
+                __pmxtEventTitle: res.title || res.question,
+                __pmxtEventDescription: res.description,
+                __pmxtCategories: res.categories,
+                __pmxtTags: res.tags
+              });
             }
           } else {
             allRawMarkets.push(res);
@@ -214840,7 +214878,14 @@ var require_normalizer2 = __commonJS({
           return null;
         let marketsList = [];
         if (raw.markets && Array.isArray(raw.markets)) {
-          marketsList = raw.markets.map((child) => (0, utils_1.mapMarketToUnified)(child)).filter((m) => m !== null);
+          const eventTitle = raw.title || raw.question || "";
+          marketsList = raw.markets.map((child) => (0, utils_1.mapMarketToUnified)(child, {
+            eventId: raw.slug,
+            eventTitle,
+            eventDescription: raw.description,
+            categories: raw.categories,
+            tags: raw.tags
+          })).filter((m) => m !== null);
         } else {
           const unifiedMarket = (0, utils_1.mapMarketToUnified)(raw);
           if (unifiedMarket)
@@ -276713,7 +276758,7 @@ var crypto_1 = require("crypto");
 var crypto_2 = require("crypto");
 var fs_1 = require("fs");
 function getServerVersion() {
-  const baseVersion = true ? "2.46.2" : "0.0.0-dev";
+  const baseVersion = true ? "2.46.4" : "0.0.0-dev";
   const isDev = process.env.NODE_ENV === "development" || process.env.PMXT_ALWAYS_RESTART === "1" || __dirname.includes("/core/src/") || __dirname.includes("/core/dist/");
   if (!isDev) {
     return baseVersion;

{pmxt-2.46.2 → pmxt-2.46.4}/pmxt/client.py

@@ -1808,6 +1808,7 @@ class Exchange(ABC):
                     existing_id = ws._active_subs.pop(sub_key, None)
                     if existing_id:
                         ws._subscriptions.pop(existing_id, None)
+                        ws._data_queues.pop(existing_id, None)
                         ws._data_store.pop(existing_id, None)
         except PmxtError:
             raise

{pmxt-2.46.2 → pmxt-2.46.4}/pmxt/ws_client.py

@@ -8,12 +8,42 @@ does not support the /ws endpoint.
 """
 
 import json
+import socket
 import threading
+import time
 import uuid
-from typing import Any, Callable, Dict, List, Optional
+from collections import deque
+from typing import Any, Deque, Dict, List, Optional
+from urllib.parse import urlparse
 
 from .errors import PmxtError
 
+MAX_QUEUED_MESSAGES_PER_SUBSCRIPTION = 100_000
+CONNECT_ATTEMPTS = 3
+_NO_DATA = object()
+
+
+def _connect_websocket(ws: Any, url: str, timeout: float) -> None:
+    """Connect, preferring IPv4 for hosted pmxt custom-domain websockets."""
+    host = urlparse(url).hostname
+    if host != "api.pmxt.dev":
+        ws.connect(url, timeout=timeout)
+        return
+
+    original_getaddrinfo = socket.getaddrinfo
+
+    def getaddrinfo_ipv4_first(*args: Any, **kwargs: Any) -> Any:
+        results = original_getaddrinfo(*args, **kwargs)
+        ipv4 = [item for item in results if item[0] == socket.AF_INET]
+        other = [item for item in results if item[0] != socket.AF_INET]
+        return ipv4 + other
+
+    socket.getaddrinfo = getaddrinfo_ipv4_first
+    try:
+        ws.connect(url, timeout=timeout)
+    finally:
+        socket.getaddrinfo = original_getaddrinfo
+
 
 class _WsSubscription:
     """Tracks a single subscription and its pending data event."""
@@ -45,7 +75,9 @@ class SidecarWsClient:
         self._reader_thread: Optional[threading.Thread] = None
         self._closed = False
 
-        # request_id -> latest data payload
+        # request_id -> queued data payloads for single-event watch methods
+        self._data_queues: Dict[str, Deque[Dict[str, Any]]] = {}
+        # request_id[:symbol] -> latest data payload for batch snapshots/errors
         self._data_store: Dict[str, Dict[str, Any]] = {}
         # request_id -> subscription metadata
         self._subscriptions: Dict[str, _WsSubscription] = {}
@@ -85,8 +117,28 @@ class SidecarWsClient:
         elif self._access_token:
             url = f"{url}?token={self._access_token}"
 
-        ws = websocket.WebSocket()
-        ws.connect(url, timeout=10)
+        last_error: Optional[Exception] = None
+        ws = None
+        for attempt in range(CONNECT_ATTEMPTS):
+            ws = websocket.WebSocket()
+            try:
+                _connect_websocket(ws, url, timeout=10)
+                last_error = None
+                break
+            except Exception as exc:
+                last_error = exc
+                try:
+                    ws.close()
+                except Exception:
+                    pass
+                if attempt < CONNECT_ATTEMPTS - 1:
+                    time.sleep(0.25 * (attempt + 1))
+
+        if last_error is not None:
+            raise last_error
+        if ws is None:
+            raise PmxtError("WebSocket connection failed")
+        ws.settimeout(None)
         self._ws = ws
         self._closed = False
 
@@ -117,10 +169,9 @@ class SidecarWsClient:
         with self._lock:
             for request_id, sub in list(self._subscriptions.items()):
                 if not sub.event.is_set():
-                    self._data_store[request_id] = {
+                    self._enqueue_data_locked(request_id, {
                         "_error": {"message": error_msg}
-                    }
-                    sub.event.set()
+                    })
 
     def _dispatch(self, msg: Dict[str, Any]) -> None:
         """Route an incoming server message to the matching subscription."""
@@ -129,10 +180,10 @@ class SidecarWsClient:
 
         if event_type == "error":
             # Wake up any waiter with the error stored
-            if request_id and request_id in self._subscriptions:
-                sub = self._subscriptions[request_id]
-                self._data_store[request_id] = {"_error": msg.get("error", {})}
-                sub.event.set()
+            if request_id:
+                with self._lock:
+                    self._data_store[request_id] = {"_error": msg.get("error", {})}
+                    self._enqueue_data_locked(request_id, {"_error": msg.get("error", {})})
             return
 
         if event_type == "subscribed":
@@ -142,14 +193,62 @@ class SidecarWsClient:
         if event_type == "data" and request_id:
             symbol = msg.get("symbol", "")
             data = msg.get("data", {})
-            # Store keyed by (request_id, symbol) for batch methods
-            store_key = f"{request_id}:{symbol}"
-            self._data_store[store_key] = data
-            # Also store by request_id alone for single-symbol methods
-            self._data_store[request_id] = data
-            if request_id in self._subscriptions:
-                sub = self._subscriptions[request_id]
-                sub.event.set()
+            with self._lock:
+                # Store keyed by (request_id, symbol) for batch methods
+                store_key = f"{request_id}:{symbol}"
+                self._data_store[store_key] = data
+                self._enqueue_data_locked(request_id, data)
+
+    def _enqueue_data_locked(self, request_id: str, data: Dict[str, Any]) -> None:
+        queue = self._data_queues.setdefault(request_id, deque())
+        queue.append(data)
+        while len(queue) > MAX_QUEUED_MESSAGES_PER_SUBSCRIPTION:
+            queue.popleft()
+
+        sub = self._subscriptions.get(request_id)
+        if sub:
+            sub.event.set()
+
+    def _pop_data_locked(self, request_id: str) -> Any:
+        queue = self._data_queues.get(request_id)
+        if not queue:
+            return _NO_DATA
+
+        data = queue.popleft()
+        if not queue:
+            self._data_queues.pop(request_id, None)
+            sub = self._subscriptions.get(request_id)
+            if sub:
+                sub.event.clear()
+        return data
+
+    def _wait_for_subscription_data(
+        self,
+        sub: _WsSubscription,
+        timeout: float,
+    ) -> Dict[str, Any]:
+        with self._lock:
+            data = self._pop_data_locked(sub.request_id)
+            if data is _NO_DATA:
+                sub.event.clear()
+
+        if data is _NO_DATA:
+            if not sub.event.wait(timeout=timeout):
+                raise PmxtError(f"Timeout waiting for WebSocket data (method={sub.method})")
+
+            with self._lock:
+                data = self._pop_data_locked(sub.request_id)
+
+        if data is _NO_DATA:
+            return {}
+
+        if isinstance(data, dict) and "_error" in data:
+            err = data["_error"]
+            raise PmxtError(
+                err.get("message", "WebSocket subscription error")
+            )
+
+        return data
 
     # ------------------------------------------------------------------
     # Public API
@@ -181,10 +280,6 @@ class SidecarWsClient:
             existing_id = self._active_subs.get(sub_key)
             if existing_id and existing_id in self._subscriptions:
                 sub = self._subscriptions[existing_id]
-                # Clear previous event so we wait for the NEXT push
-                sub.event.clear()
-                # Clear stale data
-                self._data_store.pop(existing_id, None)
             else:
                 self._ensure_connected()
                 request_id = f"req-{uuid.uuid4().hex[:12]}"
@@ -207,19 +302,7 @@ class SidecarWsClient:
 
                 self._ws.send(json.dumps(message))
 
-        # Block until data arrives
-        if not sub.event.wait(timeout=timeout):
-            raise PmxtError(f"Timeout waiting for WebSocket data (method={method})")
-
-        # Check for error
-        error_data = self._data_store.get(sub.request_id, {})
-        if isinstance(error_data, dict) and "_error" in error_data:
-            err = error_data["_error"]
-            raise PmxtError(
-                err.get("message", "WebSocket subscription error")
-            )
-
-        return self._data_store.get(sub.request_id, {})
+        return self._wait_for_subscription_data(sub, timeout)
 
     def subscribe_batch(
         self,
@@ -257,16 +340,7 @@ class SidecarWsClient:
 
         # Wait for data event (the server may push one consolidated event
         # or multiple per-symbol events)
-        if not sub.event.wait(timeout=timeout):
-            raise PmxtError(f"Timeout waiting for WebSocket data (method={method})")
-
-        # Check for error
-        error_data = self._data_store.get(request_id, {})
-        if isinstance(error_data, dict) and "_error" in error_data:
-            err = error_data["_error"]
-            raise PmxtError(
-                err.get("message", "WebSocket subscription error")
-            )
+        first_data = self._wait_for_subscription_data(sub, timeout)
 
         # Collect per-symbol data
         result: Dict[str, Any] = {}
@@ -277,9 +351,7 @@ class SidecarWsClient:
         # If no per-symbol data found, return the single data event
         # (server may return a dict of all order books in one push)
         if not result:
-            data = self._data_store.get(request_id, {})
-            if isinstance(data, dict) and not data.get("_error"):
-                result = data
+            result = first_data
         return result
 
     def close(self) -> None:
@@ -292,6 +364,9 @@ class SidecarWsClient:
                 import logging
                 logging.warning("WebSocket close error: %s", e)
             self._ws = None
+        with self._lock:
+            self._data_queues.clear()
+            self._data_store.clear()
 
     @property
     def connected(self) -> bool:

{pmxt-2.46.2 → pmxt-2.46.4}/pmxt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pmxt
-Version: 2.46.2
+Version: 2.46.4
 Summary: Unified prediction market data API - The ccxt for prediction markets
 Author: PMXT Contributors
 License: MIT

{pmxt-2.46.2 → pmxt-2.46.4}/pmxt.egg-info/SOURCES.txt

@@ -135,4 +135,5 @@ pmxt/_server/server/bundled.js
 tests/test_converters.py
 tests/test_public_exports.py
 tests/test_sdk_integration.py
-tests/test_streaming_ws_transport.py
+tests/test_streaming_ws_transport.py
+tests/test_ws_client.py

{pmxt-2.46.2 → pmxt-2.46.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pmxt"
-version = "2.46.2"
+version = "2.46.4"
 description = "Unified prediction market data API - The ccxt for prediction markets"
 readme = "README.md"
 requires-python = ">=3.8"

{pmxt-2.46.2 → pmxt-2.46.4}/tests/test_streaming_ws_transport.py

@@ -138,6 +138,7 @@ def test_unwatch_order_book_sends_websocket_unsubscribe(monkeypatch):
             self._ws = FakeSocket()
             self._active_subs = {"watchOrderBook:outcome-1": "req-existing"}
             self._subscriptions = {"req-existing": object()}
+            self._data_queues = {"req-existing": [_raw_order_book()]}
             self._data_store = {"req-existing": _raw_order_book()}
 
         def _ensure_connected(self):
@@ -160,4 +161,5 @@ def test_unwatch_order_book_sends_websocket_unsubscribe(monkeypatch):
     assert fake_ws._ws.sent[0]["args"] == ["outcome-1"]
     assert "watchOrderBook:outcome-1" not in fake_ws._active_subs
     assert "req-existing" not in fake_ws._subscriptions
+    assert "req-existing" not in fake_ws._data_queues
     assert "req-existing" not in fake_ws._data_store

pmxt-2.46.4/tests/test_ws_client.py

@@ -0,0 +1,135 @@
+import threading
+import time
+import socket
+import sys
+import types
+
+import pmxt.ws_client as ws_client
+from pmxt.ws_client import SidecarWsClient, _WsSubscription, _connect_websocket
+
+
+def _register_subscription(client, request_id="req-firehose"):
+    sub = _WsSubscription(request_id, "watchAllOrderBooks", [])
+    with client._lock:
+        client._subscriptions[request_id] = sub
+        client._active_subs["watchAllOrderBooks:"] = request_id
+    return sub
+
+
+def test_queues_repeated_data_events_in_fifo_order():
+    client = SidecarWsClient("http://localhost:3847")
+    _register_subscription(client)
+
+    client._dispatch({"event": "data", "id": "req-firehose", "symbol": "a", "data": {"sequence": 1}})
+    client._dispatch({"event": "data", "id": "req-firehose", "symbol": "b", "data": {"sequence": 2}})
+    client._dispatch({"event": "data", "id": "req-firehose", "symbol": "c", "data": {"sequence": 3}})
+
+    assert client.subscribe("mock", "watchAllOrderBooks", [], timeout=0.1) == {"sequence": 1}
+    assert client.subscribe("mock", "watchAllOrderBooks", [], timeout=0.1) == {"sequence": 2}
+    assert client.subscribe("mock", "watchAllOrderBooks", [], timeout=0.1) == {"sequence": 3}
+
+
+def test_resolves_pending_waiter_and_queues_later_events():
+    client = SidecarWsClient("http://localhost:3847")
+    _register_subscription(client, "req-pending")
+    result = []
+
+    thread = threading.Thread(
+        target=lambda: result.append(client.subscribe("mock", "watchAllOrderBooks", [], timeout=1.0))
+    )
+    thread.start()
+    time.sleep(0.05)
+
+    client._dispatch({"event": "data", "id": "req-pending", "symbol": "a", "data": {"sequence": 1}})
+    client._dispatch({"event": "data", "id": "req-pending", "symbol": "b", "data": {"sequence": 2}})
+
+    thread.join(timeout=1.0)
+    assert result == [{"sequence": 1}]
+    assert client.subscribe("mock", "watchAllOrderBooks", [], timeout=0.1) == {"sequence": 2}
+
+
+def test_close_clears_queued_events():
+    client = SidecarWsClient("http://localhost:3847")
+    _register_subscription(client, "req-close")
+
+    client._dispatch({"event": "data", "id": "req-close", "symbol": "a", "data": {"sequence": 1}})
+    client._dispatch({"event": "data", "id": "req-close", "symbol": "b", "data": {"sequence": 2}})
+
+    assert len(client._data_queues["req-close"]) == 2
+    client.close()
+    assert "req-close" not in client._data_queues
+    assert client._data_store == {}
+
+
+def test_drops_oldest_queued_events_after_cap():
+    client = SidecarWsClient("http://localhost:3847")
+    _register_subscription(client, "req-overflow")
+
+    for sequence in range(1, 100_002):
+        client._dispatch({
+            "event": "data",
+            "id": "req-overflow",
+            "symbol": str(sequence),
+            "data": {"sequence": sequence},
+        })
+
+    assert len(client._data_queues["req-overflow"]) == 100_000
+    assert client.subscribe("mock", "watchAllOrderBooks", [], timeout=0.1) == {"sequence": 2}
+    assert client.subscribe("mock", "watchAllOrderBooks", [], timeout=0.1) == {"sequence": 3}
+
+
+def test_hosted_websocket_connect_prefers_ipv4(monkeypatch):
+    original = socket.getaddrinfo
+
+    def fake_getaddrinfo(*_args, **_kwargs):
+        return [
+            (socket.AF_INET6, None, None, None, ("::1", 443, 0, 0)),
+            (socket.AF_INET, None, None, None, ("127.0.0.1", 443)),
+        ]
+
+    observed = {}
+
+    class FakeWebSocket:
+        def connect(self, url, timeout):
+            observed["url"] = url
+            observed["timeout"] = timeout
+            observed["families"] = [item[0] for item in socket.getaddrinfo("api.pmxt.dev", 443)]
+
+    monkeypatch.setattr(socket, "getaddrinfo", fake_getaddrinfo)
+
+    _connect_websocket(FakeWebSocket(), "wss://api.pmxt.dev/ws?apiKey=test", timeout=10)
+
+    assert observed["url"] == "wss://api.pmxt.dev/ws?apiKey=test"
+    assert observed["timeout"] == 10
+    assert observed["families"] == [socket.AF_INET, socket.AF_INET6]
+    assert socket.getaddrinfo is fake_getaddrinfo
+    monkeypatch.setattr(socket, "getaddrinfo", original)
+
+
+def test_connect_retries_transient_handshake_failures(monkeypatch):
+    attempts = {"count": 0}
+
+    class FakeWebSocket:
+        def settimeout(self, _timeout):
+            return None
+
+        def close(self):
+            return None
+
+    monkeypatch.setitem(sys.modules, "websocket", types.SimpleNamespace(WebSocket=FakeWebSocket))
+
+    def fake_connect(_ws, _url, timeout):
+        assert timeout == 10
+        attempts["count"] += 1
+        if attempts["count"] < 3:
+            raise OSError("transient handshake failure")
+
+    monkeypatch.setattr(ws_client, "_connect_websocket", fake_connect)
+    monkeypatch.setattr(ws_client.time, "sleep", lambda _seconds: None)
+
+    client = SidecarWsClient("https://api.pmxt.dev", api_key="pmxt_test")
+    with client._lock:
+        client._ensure_connected()
+
+    assert attempts["count"] == 3
+    assert client._ws is not None