reflex-sdk 0.3.2__tar.gz → 0.3.3__tar.gz

{reflex_sdk-0.3.2 → reflex_sdk-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex-sdk
-Version: 0.3.2
+Version: 0.3.3
 Summary: Python SDK for Reflex hosted robot inference and training
 Author: Reflex
 Project-URL: Homepage, https://tryreflex.ai

{reflex_sdk-0.3.2 → reflex_sdk-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reflex-sdk"
-version = "0.3.2"
+version = "0.3.3"
 description = "Python SDK for Reflex hosted robot inference and training"
 readme = "README.md"
 requires-python = ">=3.9"

{reflex_sdk-0.3.2 → reflex_sdk-0.3.3}/reflex/transports/_webrtc_client.py

@@ -415,33 +415,70 @@ class WebRTCClient:
             method="POST",
             headers=signaling_headers,
         )
-        # Auto-wake cold Modal worker — retry up to 6× 60s on 503/connect error.
-        # Modal scales workers to zero after idle; first request takes 30-90s to
-        # cold-start. The cli would otherwise crash with HTTPError 503.
+        # Auto-wake cold Modal worker. Modal scales workers to zero after idle;
+        # first request takes 30-90s to cold-start. Both the signaling POST and
+        # the ICE wait below share a single deadline = `timeout` seconds from
+        # start, so callers tune one number to govern the whole connect.
+        deadline = time.monotonic() + float(timeout)
+        loop = asyncio.get_event_loop()
+
+        def _do_post(per_attempt_timeout: float) -> dict:
+            with urllib.request.urlopen(req, timeout=per_attempt_timeout) as r:
+                return json.loads(r.read())
+
         t0 = time.perf_counter()
-        last_err = None
-        for _attempt in range(7):
+        attempt = 0
+        last_err: BaseException | None = None
+        warned = False
+        resp = None
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                msg = (
+                    f"WebRTC signaling timeout after {time.perf_counter()-t0:.1f}s "
+                    f"(budget {timeout:.0f}s)"
+                )
+                if last_err is not None:
+                    raise RuntimeError(f"{msg} — last error: {last_err!r}") from last_err
+                raise RuntimeError(f"{msg} — no response from {self.signaling_url}")
+            attempt += 1
+            # Cap each POST at 30s so a stalled connect can't burn the whole
+            # budget on one attempt — we'd rather retry sooner with feedback.
+            per_attempt = min(remaining, 30.0)
             try:
-                with urllib.request.urlopen(req, timeout=60) as r:
-                    resp = json.loads(r.read())
+                resp = await loop.run_in_executor(None, _do_post, per_attempt)
                 last_err = None
                 break
             except urllib.error.HTTPError as exc:
                 last_err = exc
-                if exc.code in (502, 503, 504):
-                    if _attempt == 0:
-                        print(f"[webrtc-client] worker cold (HTTP {exc.code}) — waking...", flush=True)
-                    time.sleep(10)
-                    continue
-                raise
+                if exc.code not in (502, 503, 504):
+                    raise
             except (urllib.error.URLError, TimeoutError) as exc:
                 last_err = exc
-                if _attempt == 0:
-                    print(f"[webrtc-client] worker unreachable ({exc!r}) — retrying...", flush=True)
-                time.sleep(10)
-                continue
-        if last_err is not None:
-            raise last_err
+
+            if not warned:
+                warned = True
+                if isinstance(last_err, urllib.error.HTTPError):
+                    print(
+                        f"[webrtc-client] worker cold (HTTP {last_err.code}) — "
+                        f"waking, budget {timeout:.0f}s...",
+                        flush=True,
+                    )
+                else:
+                    print(
+                        f"[webrtc-client] worker unreachable ({last_err!r}) — "
+                        f"retrying, budget {timeout:.0f}s...",
+                        flush=True,
+                    )
+            elapsed = time.perf_counter() - t0
+            print(
+                f"[webrtc-client] cold-wake attempt {attempt} failed at "
+                f"{elapsed:.0f}s of {timeout:.0f}s — sleeping before retry",
+                flush=True,
+            )
+            sleep_for = min(10.0, max(0.0, deadline - time.monotonic()))
+            if sleep_for > 0:
+                await asyncio.sleep(sleep_for)
         print(f"[webrtc-client] signaling roundtrip: {(time.perf_counter()-t0)*1000:.0f}ms", flush=True)
 
         await self.pc.setRemoteDescription(RTCSessionDescription(
@@ -449,13 +486,23 @@ class WebRTCClient:
         ))
         self.session_id = resp.get("session_id")
 
-        # Wait for ICE + DTLS + DataChannel to come up
-        t0 = time.perf_counter()
+        # Wait for ICE + DTLS + DataChannel using whatever time is left in the
+        # shared deadline. Floor at 1s so a near-exhausted budget still gives
+        # ICE a meaningful chance instead of insta-timing-out.
+        ice_remaining = max(1.0, deadline - time.monotonic())
+        ice_t0 = time.perf_counter()
         try:
-            await asyncio.wait_for(self._connected.wait(), timeout=timeout)
-            print(f"[webrtc-client] connected in {(time.perf_counter()-t0)*1000:.0f}ms  session={self.session_id}", flush=True)
+            await asyncio.wait_for(self._connected.wait(), timeout=ice_remaining)
+            print(
+                f"[webrtc-client] connected in {(time.perf_counter()-ice_t0)*1000:.0f}ms  "
+                f"session={self.session_id}",
+                flush=True,
+            )
         except asyncio.TimeoutError:
-            raise RuntimeError("WebRTC connection timeout — likely NAT/firewall blocked direct UDP")
+            raise RuntimeError(
+                f"WebRTC ICE/DataChannel timeout after {ice_remaining:.1f}s — "
+                "likely NAT/firewall blocked direct UDP"
+            )
 
         # H.264 keyframes can take ~500ms-1s to arrive at the server after
         # negotiation. Sleep briefly so the first measured infer() finds a

{reflex_sdk-0.3.2 → reflex_sdk-0.3.3}/reflex/transports/webrtc.py

@@ -148,7 +148,12 @@ class WebRTCTransport(Transport):
         fut = asyncio.run_coroutine_threadsafe(
             self._client.connect(timeout=self._connect_timeout), self._loop
         )
-        fut.result(timeout=self._connect_timeout + 5.0)
+        # The client owns the deadline (signaling cold-wake + ICE share one
+        # budget = connect_timeout). +30s slack here lets an in-flight urllib
+        # POST in an executor thread unwind its TCP timeout naturally after
+        # the inner coroutine cancels — avoids a bare TimeoutError leaking up
+        # while the inner is in the middle of raising its own diagnostic one.
+        fut.result(timeout=self._connect_timeout + 30.0)
 
     def stop(self) -> None:
         if self._client is not None and self._loop is not None:

{reflex_sdk-0.3.2 → reflex_sdk-0.3.3}/reflex_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex-sdk
-Version: 0.3.2
+Version: 0.3.3
 Summary: Python SDK for Reflex hosted robot inference and training
 Author: Reflex
 Project-URL: Homepage, https://tryreflex.ai