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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflex-sdk
-Version: 0.3.2
+Version: 0.3.4
 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.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reflex-sdk"
-version = "0.3.2"
+version = "0.3.4"
 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.4}/reflex/auth_runner.py

@@ -75,6 +75,76 @@ def _resolve_api_key() -> str | None:
     return None
 
 
+# NET.3: known Modal regional endpoints we can probe to find the nearest.
+# Each entry: (region_key, probe_url). Probe must be cheap (HEAD or short GET).
+# Added regions appear here once their primeNode is registered with Convex.
+KNOWN_REGIONS = (
+    (
+        "us-west",
+        "https://reflex-inc--reflex-inference-molmoact-webrtc-baseline-mo-8e694d.us-west.modal.direct/health",
+    ),
+    (
+        "us-east",
+        "https://reflex-inc--reflex-inference-molmoact-webrtc-baseline-us-e787db.us-east.modal.direct/health",
+    ),
+)
+REGION_PROBE_TIMEOUT_S = 2.5
+REGION_PROBE_SAMPLES = 2
+
+
+def _probe_nearest_region() -> str | None:
+    """Probe known regions; return the lowest-latency region key.
+
+    Costs one HEAD-equivalent per region per sample. Cached for the lifetime
+    of the process via REFLEX_PINNED_REGION env var; subsequent calls skip
+    the probe. Returns None on total failure (no region pickable, authorize
+    proceeds with no region hint).
+    """
+    pinned = (os.environ.get("REFLEX_PINNED_REGION") or "").strip().lower()
+    if pinned:
+        return pinned
+
+    import concurrent.futures as _cf
+
+    def _probe_one(url: str) -> float:
+        latencies = []
+        for _ in range(REGION_PROBE_SAMPLES):
+            t0 = time.perf_counter()
+            try:
+                req = urllib.request.Request(
+                    url, method="GET",
+                    headers={"user-agent": USER_AGENT},
+                )
+                with urllib.request.urlopen(req, timeout=REGION_PROBE_TIMEOUT_S) as r:
+                    r.read(64)
+                latencies.append(time.perf_counter() - t0)
+            except Exception:
+                return float("inf")
+        return min(latencies)
+
+    results: dict[str, float] = {}
+    with _cf.ThreadPoolExecutor(max_workers=len(KNOWN_REGIONS)) as ex:
+        future_to_region = {
+            ex.submit(_probe_one, url): region for region, url in KNOWN_REGIONS
+        }
+        for fut in _cf.as_completed(future_to_region):
+            region = future_to_region[fut]
+            results[region] = fut.result()
+
+    if not results or all(v == float("inf") for v in results.values()):
+        return None
+    best = min(results, key=lambda k: results[k])
+    best_ms = results[best] * 1000
+    print(
+        f"[reflex] region probe: chose {best!r} ({best_ms:.0f}ms) — "
+        f"{ {k: f'{v*1000:.0f}ms' for k, v in results.items()} }",
+        file=sys.stderr, flush=True,
+    )
+    # Cache the pick for the rest of the process (avoids re-probing per call).
+    os.environ["REFLEX_PINNED_REGION"] = best
+    return best
+
+
 def _convex_mutation(convex_url: str, path: str, args: dict, *, timeout: float = 30.0) -> dict:
     body = json.dumps({"path": path, "format": "json", "args": args}).encode("utf-8")
     req = urllib.request.Request(
@@ -116,11 +186,24 @@ def maybe_authorize(
         or CONVEX_URL_DEFAULT
     )
 
+    # NET.3: probe nearest region (cached after first call). Skipped via
+    # REFLEX_SKIP_REGION_PROBE=1 if the caller already knows their region.
+    client_region: str | None = None
+    if not os.environ.get("REFLEX_SKIP_REGION_PROBE"):
+        try:
+            client_region = _probe_nearest_region()
+        except Exception as exc:
+            print(f"[reflex] region probe failed ({exc}); proceeding without hint", file=sys.stderr, flush=True)
+
+    auth_args = {"apiKey": api_key, "baseModel": base_model, "robotType": robot_type}
+    if client_region:
+        auth_args["clientRegion"] = client_region
+
     t0 = time.perf_counter()
     result = _convex_mutation(
         convex_url,
         "publicApi:authorizeSession",
-        {"apiKey": api_key, "baseModel": base_model, "robotType": robot_type},
+        auth_args,
     )
     dt_ms = (time.perf_counter() - t0) * 1000
 

{reflex_sdk-0.3.2 → reflex_sdk-0.3.4}/reflex/connect_runner.py

@@ -176,11 +176,35 @@ def run_session(
     started_cameras: list[str] = []
     last_heartbeat = 0.0
     interrupted = False
+    sigint_count = 0
     executor: concurrent.futures.ThreadPoolExecutor | None = None
 
     def _on_signal(signum, _frame):  # noqa: ANN001 - signal callback signature
-        nonlocal interrupted
+        nonlocal interrupted, sigint_count
         interrupted = True
+        sigint_count += 1
+        # Before the transport has connected there's no graceful work pending,
+        # so unwind immediately — otherwise the user's ^C only sets a flag while
+        # transport.start() keeps blocking in `fut.result(timeout=...)`.
+        if not transport_started:
+            log.warning(
+                "received signal %s before transport connected — aborting", signum
+            )
+            signal.signal(signal.SIGINT, signal.SIG_DFL)
+            signal.signal(signal.SIGTERM, signal.SIG_DFL)
+            raise KeyboardInterrupt(f"signal {signum}")
+        # During an active session the first signal triggers graceful homing.
+        # A second signal escalates to force-exit so a stuck shutdown can't
+        # trap the user — restore the default handler and re-raise.
+        if sigint_count >= 2:
+            log.warning(
+                "received signal %s a second time — forcing exit", signum
+            )
+            signal.signal(signal.SIGINT, signal.SIG_DFL)
+            signal.signal(signal.SIGTERM, signal.SIG_DFL)
+            raise KeyboardInterrupt(
+                f"forced exit (signal {signum} x{sigint_count})"
+            )
         log.warning("received signal %s; ending session and homing arms", signum)
 
     prev_sigint = signal.signal(signal.SIGINT, _on_signal)

{reflex_sdk-0.3.2 → reflex_sdk-0.3.4}/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.4}/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.4}/reflex_sdk.egg-info/PKG-INFO

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