plexus-python 0.7.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

plexus/__init__.py

@@ -7,8 +7,8 @@ Plexus — thin Python SDK for sending telemetry to the Plexus gateway.
     px.send("temperature", 72.5)
 """
 
-from plexus.client import Plexus, PlexusError, AuthenticationError, read_mjpeg_frames
+from plexus.client import AuthenticationError, Plexus, PlexusError, read_mjpeg_frames
 from plexus.config import RetryConfig
 
-__version__ = "0.7.1"
-__all__ = ["Plexus", "PlexusError", "AuthenticationError", "RetryConfig", "read_mjpeg_frames"]
+__version__ = "0.8.0"
+__all__ = ["AuthenticationError", "Plexus", "PlexusError", "RetryConfig", "read_mjpeg_frames"]

plexus/buffer.py

@@ -17,7 +17,8 @@ import os
 import sqlite3
 import threading
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from collections.abc import Callable
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -26,11 +27,11 @@ class BufferBackend(ABC):
     """Abstract buffer backend for storing telemetry points locally."""
 
     @abstractmethod
-    def add(self, points: List[Dict[str, Any]]) -> None:
+    def add(self, points: list[dict[str, Any]]) -> None:
         """Add points to the buffer, evicting oldest if over capacity."""
 
     @abstractmethod
-    def get_all(self) -> List[Dict[str, Any]]:
+    def get_all(self) -> list[dict[str, Any]]:
         """Return a copy of all buffered points without clearing."""
 
     @abstractmethod
@@ -45,7 +46,7 @@ class BufferBackend(ABC):
     def resize(self, max_size: int) -> None:
         """Update the maximum buffer capacity."""
 
-    def drain(self, batch_size: int = 5000) -> Tuple[List[Dict[str, Any]], int]:
+    def drain(self, batch_size: int = 5000) -> tuple[list[dict[str, Any]], int]:
         """Remove and return the oldest batch_size points atomically.
 
         Returns (points, remaining_count). Points are deleted from the buffer
@@ -73,13 +74,13 @@ class MemoryBuffer(BufferBackend):
     This extracts the original behavior from Plexus client._failed_buffer.
     """
 
-    def __init__(self, max_size: int = 10_000, on_overflow: Optional[Callable[[int], None]] = None):
+    def __init__(self, max_size: int = 10_000, on_overflow: Callable[[int], None] | None = None):
         self._max_size = max_size
         self._on_overflow = on_overflow
-        self._buffer: List[Dict[str, Any]] = []
+        self._buffer: list[dict[str, Any]] = []
         self._lock = threading.Lock()
 
-    def add(self, points: List[Dict[str, Any]]) -> None:
+    def add(self, points: list[dict[str, Any]]) -> None:
         with self._lock:
             self._buffer.extend(points)
             if len(self._buffer) > self._max_size:
@@ -89,7 +90,7 @@ class MemoryBuffer(BufferBackend):
                 if self._on_overflow:
                     self._on_overflow(overflow)
 
-    def get_all(self) -> List[Dict[str, Any]]:
+    def get_all(self) -> list[dict[str, Any]]:
         with self._lock:
             return list(self._buffer)
 
@@ -105,7 +106,7 @@ class MemoryBuffer(BufferBackend):
         with self._lock:
             self._max_size = max_size
 
-    def drain(self, batch_size: int = 5000) -> Tuple[List[Dict[str, Any]], int]:
+    def drain(self, batch_size: int = 5000) -> tuple[list[dict[str, Any]], int]:
         with self._lock:
             batch = self._buffer[:batch_size]
             self._buffer = self._buffer[batch_size:]
@@ -129,10 +130,10 @@ class SqliteBuffer(BufferBackend):
 
     def __init__(
         self,
-        path: Optional[str] = None,
-        max_size: Optional[int] = 100_000,
-        max_bytes: Optional[int] = None,
-        on_overflow: Optional[Callable[[int], None]] = None,
+        path: str | None = None,
+        max_size: int | None = 100_000,
+        max_bytes: int | None = None,
+        on_overflow: Callable[[int], None] | None = None,
     ):
         self._max_size = max_size
         self._max_bytes = max_bytes
@@ -159,7 +160,7 @@ class SqliteBuffer(BufferBackend):
         )
         self._conn.commit()
 
-    def add(self, points: List[Dict[str, Any]]) -> None:
+    def add(self, points: list[dict[str, Any]]) -> None:
         if not points:
             return
         with self._lock:
@@ -178,7 +179,7 @@ class SqliteBuffer(BufferBackend):
             self._conn.commit()
             self._evict()
 
-    def get_all(self) -> List[Dict[str, Any]]:
+    def get_all(self) -> list[dict[str, Any]]:
         with self._lock:
             cursor = self._conn.execute("SELECT data FROM points ORDER BY id")
             return [json.loads(row[0]) for row in cursor.fetchall()]
@@ -197,7 +198,7 @@ class SqliteBuffer(BufferBackend):
         with self._lock:
             self._max_size = max_size
 
-    def drain(self, batch_size: int = 5000) -> Tuple[List[Dict[str, Any]], int]:
+    def drain(self, batch_size: int = 5000) -> tuple[list[dict[str, Any]], int]:
         """Remove and return the oldest batch_size points atomically.
 
         Uses a single transaction: SELECT then DELETE by rowid. If the process

plexus/cameras/__init__.py

@@ -1,7 +1,7 @@
 from plexus.cameras.thermal import (
-    NoCameraFound,
     MLX90640Camera,
     MLX90641Camera,
+    NoCameraFound,
     SimulatedThermalCamera,
     ThermalCamera,
     ThermalFrame,
@@ -12,9 +12,9 @@ from plexus.cameras.thermal import (
 )
 
 __all__ = [
-    "NoCameraFound",
     "MLX90640Camera",
     "MLX90641Camera",
+    "NoCameraFound",
     "SimulatedThermalCamera",
     "ThermalCamera",
     "ThermalFrame",

plexus/cameras/thermal.py

@@ -23,7 +23,7 @@ import base64
 import time
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Any, Dict, Optional
+from typing import Any
 
 import cv2
 import numpy as np
@@ -89,17 +89,17 @@ class ThermalFrame:
     sensor_height: int       # native sensor height
     temp_min: float
     temp_max: float
-    temps: Optional[np.ndarray]  # native res; None when sensor > threshold
+    temps: np.ndarray | None  # native res; None when sensor > threshold
     timestamp_ms: int
 
     def to_message(
-        self, camera_id: str, source_id: Optional[str] = None, quality: int = 85
-    ) -> Dict[str, Any]:
+        self, camera_id: str, source_id: str | None = None, quality: int = 85
+    ) -> dict[str, Any]:
         """Build the gateway `video_frame` wire message for this frame."""
         _, buf = cv2.imencode(".jpg", self.image, [cv2.IMWRITE_JPEG_QUALITY, quality])
         b64 = base64.b64encode(buf.tobytes()).decode("ascii")
 
-        msg: Dict[str, Any] = {
+        msg: dict[str, Any] = {
             "type": "video_frame",
             "camera_id": camera_id,
             "frame": b64,
@@ -133,7 +133,7 @@ def _upscale_size(sw: int, sh: int) -> tuple[int, int]:
 
 
 def build_thermal_frame(
-    temps: np.ndarray, timestamp_ms: Optional[int] = None
+    temps: np.ndarray, timestamp_ms: int | None = None
 ) -> ThermalFrame:
     """Colorize a temperature array into a ThermalFrame.
 

plexus/cli.py

@@ -2,7 +2,7 @@
 Plexus CLI — `plexus init` style auth, plus a few sibling commands.
 
 Designed to feel like fly.io / vercel CLIs:
-    $ pip install plexus
+    $ pip install plexus-python
     $ plexus init
     Opening browser to https://app.plexus.company/auth/cli...
     ✓ Saved API key as cli-<host>. You're set up.
@@ -29,11 +29,9 @@ import sys
 import threading
 import urllib.parse
 import webbrowser
-from typing import Optional
 
 from . import config
 
-
 DEFAULT_TIMEOUT_SECONDS = 300
 SUCCESS_REDIRECT_SECONDS = 10
 SUCCESS_HTML_TEMPLATE = """<!doctype html>
@@ -187,7 +185,7 @@ def _success_html(target: str) -> bytes:
         target_js=repr(target),
     ).encode("utf-8")
 
-ERROR_HTML = """<!doctype html>
+ERROR_HTML = b"""<!doctype html>
 <html lang="en">
   <head>
     <meta charset="utf-8" />
@@ -272,13 +270,13 @@ ERROR_HTML = """<!doctype html>
       </div>
     </div>
   </body>
-</html>""".encode("utf-8")
+</html>"""
 
 
 class _CallbackResult:
-    key: Optional[str] = None
-    state: Optional[str] = None
-    error: Optional[str] = None
+    key: str | None = None
+    state: str | None = None
+    error: str | None = None
 
 
 def _pick_free_port() -> int:
@@ -476,7 +474,7 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def main(argv: Optional[list] = None) -> int:
+def main(argv: list | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)
     return args.func(args)

plexus/client.py

@@ -24,12 +24,6 @@ Usage:
         ("pressure", 1013.25),
     ])
 
-    # Run recording
-    with px.run("motor-test-001"):
-        while True:
-            px.send("temperature", read_temp())
-            time.sleep(0.01)
-
 Note: Requires authentication. Run 'plexus init' or set PLEXUS_API_KEY.
 """
 
@@ -44,8 +38,8 @@ import threading
 import time
 import urllib.error
 import urllib.request
-from contextlib import contextmanager
-from typing import Any, Dict, Generator, List, Optional, Tuple, Union
+from collections.abc import Generator
+from typing import Any, Union
 
 from plexus._log import _say
 from plexus.buffer import BufferBackend, MemoryBuffer, SqliteBuffer
@@ -71,9 +65,9 @@ class _Response:
 
 class _Session:
     def __init__(self):
-        self.headers: Dict[str, str] = {}
+        self.headers: dict[str, str] = {}
 
-    def post(self, url: str, data: bytes = b"", headers: Optional[Dict[str, str]] = None, timeout: float = 10.0) -> "_Response":
+    def post(self, url: str, data: bytes = b"", headers: dict[str, str] | None = None, timeout: float = 10.0) -> "_Response":
         req_headers = {**self.headers, **(headers or {})}
         req = urllib.request.Request(url, data=data, headers=req_headers, method="POST")
         try:
@@ -85,7 +79,7 @@ class _Session:
             if isinstance(e.reason, socket.timeout):
                 raise _Timeout(str(e.reason))
             raise _ConnError(str(e.reason))
-        except (TimeoutError, socket.timeout) as e:
+        except TimeoutError as e:
             raise _Timeout(str(e))
 
     def close(self) -> None:
@@ -101,7 +95,7 @@ class _ConnError(OSError):
 
 
 # Flexible value type - supports any JSON-serializable value
-FlexValue = Union[int, float, str, bool, Dict[str, Any], List[Any]]
+FlexValue = Union[int, float, str, bool, dict[str, Any], list[Any]]
 
 _JPEG_SOI = b"\xff\xd8"
 _JPEG_EOI = b"\xff\xd9"
@@ -137,27 +131,72 @@ def read_mjpeg_frames(pipe, chunk: int = 65536) -> Generator[bytes, None, None]:
 class PlexusError(Exception):
     """Base exception for Plexus errors."""
 
-    pass
 
 
 class AuthenticationError(PlexusError):
     """Raised when API key is missing or invalid."""
 
-    pass
 
 
-_SOURCE_ID_RE = re.compile(r'^[a-z0-9][a-z0-9_-]{1,62}$')
+# The wire slug rule (gateway validate.go sourceIDPattern, max length =
+# MaxStringLen 256) — the old stricter local regex rejected dots, 1-char and
+# >63-char slugs that the gateway accepts. Uuid-shaped slugs are additionally
+# rejected (TypeScript SDK parity): the Plexus app resolves uuid-shaped refs
+# as internal ids, which would make such a source unreachable.
+_SOURCE_ID_RE = re.compile(r'^[a-z0-9][a-z0-9._-]*$')
+_SOURCE_ID_UUID_RE = re.compile(
+    r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
+)
+_SOURCE_ID_MAX_LEN = 256
 
 
 def _validate_source_id(source_id: str) -> None:
-    if not _SOURCE_ID_RE.match(source_id):
+    if (
+        not source_id
+        or len(source_id) > _SOURCE_ID_MAX_LEN
+        or not _SOURCE_ID_RE.match(source_id)
+        or _SOURCE_ID_UUID_RE.match(source_id)
+    ):
         raise ValueError(
             f"Invalid source_id {source_id!r}. "
-            "Must match ^[a-z0-9][a-z0-9_-]{1,62}$ "
-            "(lowercase letters, digits, hyphens, underscores; start with letter or digit)."
+            "Must match ^[a-z0-9][a-z0-9._-]*$ (max 256 chars; lowercase "
+            "letters, digits, dots, hyphens, underscores; start with a letter "
+            "or digit) and must not look like a UUID."
         )
 
 
+# Allowance for the {"type": "telemetry", "points": [...]} envelope when
+# estimating a WS frame's serialized size from the sum of its points.
+_WS_ENVELOPE_BYTES = 64
+
+
+def _split_ws_frames(
+    points: list[dict[str, Any]], byte_budget: int
+) -> list[list[dict[str, Any]]]:
+    """Split points into telemetry-frame chunks under byte_budget serialized.
+
+    The gateway enforces a 1MB read limit per WebSocket message and rejects
+    oversized frames server-side — after the local socket write has already
+    "succeeded". Frame size is estimated as the sum of each point's JSON
+    serialization plus a small envelope allowance. A single point larger than
+    the budget still goes out alone (nothing more can be done client-side).
+    """
+    chunks: list[list[dict[str, Any]]] = []
+    cur: list[dict[str, Any]] = []
+    cur_bytes = _WS_ENVELOPE_BYTES
+    for p in points:
+        p_bytes = len(json.dumps(p).encode("utf-8")) + 1  # +1 for the comma
+        if cur and cur_bytes + p_bytes > byte_budget:
+            chunks.append(cur)
+            cur = []
+            cur_bytes = _WS_ENVELOPE_BYTES
+        cur.append(p)
+        cur_bytes += p_bytes
+    if cur:
+        chunks.append(cur)
+    return chunks
+
+
 class Plexus:
     """
     Client for sending sensor data to Plexus.
@@ -177,15 +216,15 @@ class Plexus:
 
     def __init__(
         self,
-        api_key: Optional[str] = None,
-        endpoint: Optional[str] = None,
-        source_id: Optional[str] = None,
+        api_key: str | None = None,
+        endpoint: str | None = None,
+        source_id: str | None = None,
         timeout: float = 10.0,
-        retry_config: Optional[RetryConfig] = None,
+        retry_config: RetryConfig | None = None,
         max_buffer_size: int = 10000,
         persistent_buffer: bool = True,
-        buffer_path: Optional[str] = None,
-        ws_url: Optional[str] = None,
+        buffer_path: str | None = None,
+        ws_url: str | None = None,
     ):
         self.api_key = api_key or get_api_key()
         if not self.api_key:
@@ -202,15 +241,14 @@ class Plexus:
         self.retry_config = retry_config or RetryConfig()
         self._max_buffer_size = max_buffer_size
 
-        self._run_id: Optional[str] = None
-        self._session: Optional[_Session] = None
-        self._store_frames: bool = False
+        self._session: _Session | None = None
         self._cv2 = None
         self._pil_image = None  # lazy PIL.Image import
         self._fit_warned: bool = False
 
         self._ws_url = (ws_url or get_gateway_ws_url())
         self._ws = None  # lazily constructed in _ensure_ws()
+        self._ws_auth_waited = False  # first-send auth wait paid at most once
         self._clock_offset_ms: int = 0
 
         # Pluggable buffer backend for failed sends
@@ -250,7 +288,7 @@ class Plexus:
             self._session.headers["User-Agent"] = f"plexus-python/{__version__}"
         return self._session
 
-    def _normalize_ts_ms(self, timestamp: Optional[float] = None) -> int:
+    def _normalize_ts_ms(self, timestamp: float | None = None) -> int:
         """Normalize a timestamp to milliseconds.
 
         Accepts:
@@ -265,14 +303,24 @@ class Plexus:
             return int(timestamp * 1000)
         return int(timestamp)
 
+    @staticmethod
+    def _infer_class(value: FlexValue) -> str:
+        """Numbers are metrics; everything else (str/bool/dict/list) is an event.
+
+        Mirrors the gateway (ingest.go inferClass) and the TypeScript SDK
+        (wire.ts inferClass). bool is a subclass of int in Python, so it must
+        be excluded explicitly or True/False would wrongly become metrics.
+        """
+        return "metric" if isinstance(value, (int, float)) and not isinstance(value, bool) else "event"
+
     def _make_point(
         self,
         metric: str,
         value: FlexValue,
-        timestamp: Optional[float] = None,
-        tags: Optional[Dict[str, str]] = None,
-        data_class: str = "metric",
-    ) -> Dict[str, Any]:
+        timestamp: float | None = None,
+        tags: dict[str, str] | None = None,
+        data_class: str | None = None,
+    ) -> dict[str, Any]:
         """Create a data point dictionary.
 
         Value can be:
@@ -281,26 +329,42 @@ class Plexus:
             - bool: Binary flags, enabled/disabled states
             - dict: Complex objects, vectors, nested data
             - list: Arrays, coordinates, multi-value readings
+
+        When `data_class` is not given it is inferred from the value type.
+        The gateway rejects a non-numeric value on class="metric" and drops
+        the whole frame (taking buffered points with it), so inferring here —
+        and raising early on an explicit metric with a bad value — is what
+        makes the advertised flexible values actually work.
         """
+        cls = data_class if data_class is not None else self._infer_class(value)
+        if cls == "metric" and (
+            not isinstance(value, (int, float))
+            or isinstance(value, bool)
+            or value != value  # NaN
+            or value in (float("inf"), float("-inf"))
+        ):
+            raise PlexusError(
+                f'Metric "{metric}" requires a finite number value, got '
+                f'{type(value).__name__}. Pass data_class="event" for '
+                f"non-numeric values, or use px.event()."
+            )
         point = {
-            "class": data_class,
+            "class": cls,
             "metric": metric,
             "value": value,
             "timestamp": self._normalize_ts_ms(timestamp),
         }
         if tags:
             point["tags"] = tags
-        if self._run_id:
-            point["run_id"] = self._run_id
         return point
 
     def send(
         self,
         metric: str,
         value: FlexValue,
-        timestamp: Optional[float] = None,
-        tags: Optional[Dict[str, str]] = None,
-        data_class: str = "metric",
+        timestamp: float | None = None,
+        tags: dict[str, str] | None = None,
+        data_class: str | None = None,
     ) -> bool:
         """
         Send a single metric value to Plexus.
@@ -315,7 +379,9 @@ class Plexus:
                    - list: px.send("angles", [0.5, 1.2, -0.3])
             timestamp: Unix timestamp. If not provided, uses current time.
             tags: Optional key-value tags for the metric
-            data_class: Pipeline data class - "metric" (default) or "event"
+            data_class: Pipeline data class - "metric" or "event". If omitted,
+                inferred from the value type (numbers → metric, everything
+                else → event).
 
         Returns:
             True if successful
@@ -336,8 +402,8 @@ class Plexus:
         self,
         name: str,
         data: FlexValue,
-        timestamp: Optional[float] = None,
-        tags: Optional[Dict[str, str]] = None,
+        timestamp: float | None = None,
+        tags: dict[str, str] | None = None,
     ) -> bool:
         """
         Send a named event with text or structured data.
@@ -358,9 +424,9 @@ class Plexus:
 
     def send_batch(
         self,
-        points: List[Union[Tuple[str, FlexValue], Tuple[str, FlexValue, float]]],
-        timestamp: Optional[float] = None,
-        tags: Optional[Dict[str, str]] = None,
+        points: list[tuple[str, FlexValue] | tuple[str, FlexValue, float]],
+        timestamp: float | None = None,
+        tags: dict[str, str] | None = None,
     ) -> bool:
         """
         Send multiple metrics at once.
@@ -406,8 +472,8 @@ class Plexus:
         """Lazily construct and start the WebSocket transport."""
         if self._ws is not None:
             return self._ws
-        from plexus.ws import WebSocketTransport
         from plexus import __version__
+        from plexus.ws import WebSocketTransport
         self._ws = WebSocketTransport(
             api_key=self.api_key,
             source_id=self.source_id,
@@ -424,7 +490,7 @@ class Plexus:
     def _on_clock_synced(self, offset_ms: int) -> None:
         self._clock_offset_ms = offset_ms
 
-    def _encode_frame(self, frame, quality: int) -> Tuple[bytes, int, int]:
+    def _encode_frame(self, frame, quality: int) -> tuple[bytes, int, int]:
         """Normalize any supported frame type to (jpeg_bytes, width, height).
 
         Accepted inputs:
@@ -490,7 +556,7 @@ class Plexus:
                     ) from e
         return self._pil_image
 
-    def _pil_to_jpeg(self, img, quality: int) -> Tuple[bytes, int, int]:
+    def _pil_to_jpeg(self, img, quality: int) -> tuple[bytes, int, int]:
         import io
         if img.mode not in ("RGB", "L"):
             img = img.convert("RGB")
@@ -542,7 +608,7 @@ class Plexus:
         frame,
         camera_id: str = "camera:0",
         quality: int = 85,
-        timestamp: Optional[float] = None,
+        timestamp: float | None = None,
     ) -> bool:
         """Send a single video frame to Plexus (WebSocket transport only).
 
@@ -581,7 +647,7 @@ class Plexus:
         temps,
         camera_id: str = "thermal:0",
         quality: int = 85,
-        timestamp: Optional[float] = None,
+        timestamp: float | None = None,
     ) -> bool:
         """Send a thermal camera frame to Plexus (WebSocket transport only).
 
@@ -684,8 +750,9 @@ class Plexus:
         name: str,
         handler,
         *,
-        description: Optional[str] = None,
-        params: Optional[List[Dict[str, Any]]] = None,
+        description: str | None = None,
+        params: list[dict[str, Any]] | None = None,
+        concurrency: str = "accept",
     ) -> None:
         """Register a command handler (WebSocket transport only).
 
@@ -695,6 +762,12 @@ class Plexus:
 
         Must be called before the first send() so the command is advertised
         in the auth frame.
+
+        concurrency: "accept" (default) runs overlapping invocations of the
+            same command concurrently; "reject" refuses a new invocation with
+            an error result while a previous one is still running. Use
+            "reject" for handlers that drive exclusive hardware (e.g. a pump
+            init) so a retry or double-click can't start two at once.
         """
         ws = self._ensure_ws()
         if ws.is_authenticated:
@@ -704,50 +777,114 @@ class Plexus:
                 "Call on_command() before the first send().",
                 name,
             )
-        ws.register_command(name, handler, description=description, params=params)
+        ws.register_command(
+            name, handler, description=description, params=params,
+            concurrency=concurrency,
+        )
+
+    # Gateway hard limits (gateway gateway_config.go): 10k points per
+    # batch/frame and 1MB per WebSocket message. Sending in chunks well under
+    # both means a large local backlog can always drain, instead of one giant
+    # merged request drawing a non-retryable 400 that would wedge the client
+    # at exactly the buffer cap.
+    _SEND_CHUNK_POINTS = 5000
+    _WS_FRAME_BYTE_BUDGET = 900_000
 
-    def _send_points(self, points: List[Dict[str, Any]]) -> bool:
+    def _send_points(self, points: list[dict[str, Any]]) -> bool:
         """Send data points to the gateway with retry and buffering.
 
-        Tries WebSocket first; if not yet authenticated or the socket fails,
-        falls through to HTTP POST so points still land.
+        Any locally buffered backlog is drained together with the new points
+        in chunks of at most _SEND_CHUNK_POINTS, so a request never exceeds
+        the gateway's 10k-points-per-batch limit no matter how large the
+        backlog has grown. Each chunk tries WebSocket first and falls through
+        to HTTP POST so points still land.
 
         Retry behavior (HTTP path):
         - Retries on: Timeout, ConnectionError, HTTP 429, HTTP 5xx
         - No retry on: HTTP 401/403 (auth), HTTP 400/422 (bad request)
-        - After max retries: buffers points locally for next send attempt
+        - On failure: the unsent chunk and all not-yet-sent points are
+          buffered locally for the next send attempt, then the error is
+          raised. Nothing is dropped on the floor.
         """
         if not self.api_key:
             raise AuthenticationError(
                 "No API key configured. Run 'plexus init' or set PLEXUS_API_KEY"
             )
 
-        # Include any previously buffered points
-        all_points = self._get_buffered_points() + points
-
-        # Preferred path: WebSocket.
         ws = self._ensure_ws()
-        # Brief wait on first call so startup races don't dump every point
-        # into the HTTP fallback path.
-        if not ws.is_authenticated:
+        # Brief wait on the FIRST send only, so startup races don't dump the
+        # first points into the HTTP fallback path. Waiting on every send
+        # would stall an unauthenticated client ~5s per call; once the wait
+        # has been paid — or a reconnect backoff is already pending — sends
+        # proceed immediately and use HTTP until the socket authenticates.
+        if (
+            not ws.is_authenticated
+            and not self._ws_auth_waited
+            and not ws.reconnect_pending
+        ):
+            self._ws_auth_waited = True
             ws.wait_authenticated(timeout=min(self.timeout, 5.0))
-        if ws.send_points(all_points):
-            self._clear_buffer()
-            self._note_send(len(all_points), via="ws")
-            return True
+
+        pending_new = list(points)
+        while True:
+            # Oldest buffered points first, topped up with new points — the
+            # common no-backlog case still goes out as a single request.
+            batch, _remaining = self._buffer.drain(self._SEND_CHUNK_POINTS)
+            if len(batch) < self._SEND_CHUNK_POINTS and pending_new:
+                take = self._SEND_CHUNK_POINTS - len(batch)
+                batch.extend(pending_new[:take])
+                pending_new = pending_new[take:]
+            if not batch:
+                return True
+            try:
+                self._send_chunk(ws, batch)
+            except Exception:
+                # The chunk did not land (drain() already removed it from the
+                # buffer) — put it back along with every not-yet-sent point so
+                # nothing is lost, then surface the error.
+                self._add_to_buffer(batch)
+                if pending_new:
+                    self._add_to_buffer(pending_new)
+                if not self._announced_buffering:
+                    _say(
+                        f"⏸ Send failed, buffering points locally "
+                        f"({self.buffer_size()} queued). Will retry on next call."
+                    )
+                    self._announced_buffering = True
+                raise
+
+    def _send_chunk(self, ws, points: list[dict[str, Any]]) -> None:
+        """Send one bounded chunk (≤ _SEND_CHUNK_POINTS). Raises on failure.
+
+        WebSocket preferred. A ws.send_points() True only confirms the frame
+        reached the local socket — the gateway silently drops frames over its
+        1MB read limit server-side — so chunks are sub-split to stay under
+        _WS_FRAME_BYTE_BUDGET before being treated as delivered. If the
+        socket fails partway through, the whole chunk falls back to HTTP:
+        at-least-once delivery, duplicates preferred over loss.
+        """
+        if ws is not None and ws.is_authenticated:
+            subframes = _split_ws_frames(points, self._WS_FRAME_BYTE_BUDGET)
+            if all(ws.send_points(sub) for sub in subframes):
+                self._note_send(len(points), via="ws")
+                return
         # Socket unavailable → fall through to HTTP.
         if not self._announced_http_fallback:
             _say(
                 f"⚠ WebSocket unavailable, falling back to POST {self.gateway_url}/ingest"
             )
             self._announced_http_fallback = True
+        self._send_http(points)
+        self._note_send(len(points), via="http")
 
+    def _send_http(self, points: list[dict[str, Any]]) -> None:
+        """POST one chunk of points to /ingest with retries. Raises on failure."""
         url = f"{self.gateway_url}/ingest"
-        last_error: Optional[Exception] = None
+        last_error: Exception | None = None
 
         for attempt in range(self.retry_config.max_retries + 1):
             try:
-                payload = json.dumps({"source_id": self.source_id, "points": all_points})
+                payload = json.dumps({"source_id": self.source_id, "points": points})
                 payload_bytes = payload.encode("utf-8")
 
                 # Gzip compress payloads > 1KB for bandwidth efficiency
@@ -798,11 +935,9 @@ class Plexus:
                         continue
                     break
 
-                # Success - clear the buffer and return
+                # Success
                 elif response.status_code < 400:
-                    self._clear_buffer()
-                    self._note_send(len(all_points), via="http")
-                    return True
+                    return
 
                 # Other 4xx errors - don't retry
                 else:
@@ -824,15 +959,6 @@ class Plexus:
                     continue
                 break
 
-        # All retries failed - buffer the points for later
-        self._add_to_buffer(points)
-        if not self._announced_buffering:
-            _say(
-                f"⏸ Send failed, buffering points locally ({self.buffer_size()} queued). "
-                f"Will retry on next call."
-            )
-            self._announced_buffering = True
-
         if last_error:
             raise last_error
         raise PlexusError("Send failed after all retries")
@@ -855,11 +981,11 @@ class Plexus:
             _say("✓ Sending again (drained the local buffer).")
             self._announced_buffering = False
 
-    def _add_to_buffer(self, points: List[Dict[str, Any]]) -> None:
+    def _add_to_buffer(self, points: list[dict[str, Any]]) -> None:
         """Add points to the local buffer for later retry."""
         self._buffer.add(points)
 
-    def _get_buffered_points(self) -> List[Dict[str, Any]]:
+    def _get_buffered_points(self) -> list[dict[str, Any]]:
         """Get a copy of buffered points without clearing."""
         return self._buffer.get_all()
 
@@ -890,65 +1016,6 @@ class Plexus:
         # Send with empty new points list - will include buffered points
         return self._send_points([])
 
-    @contextmanager
-    def run(self, run_id: str, tags: Optional[Dict[str, str]] = None, store_frames: bool = False):
-        """
-        Context manager for recording a run.
-
-        All sends within this context will be tagged with the run ID,
-        making it easy to replay and analyze later.
-
-        Args:
-            run_id: Unique identifier for this run (e.g., "motor-test-001")
-            tags: Optional tags to apply to all points in this run
-            store_frames: If True, camera frames are uploaded to the Plexus API
-                         for persistent storage alongside the live WebSocket stream.
-
-        Example:
-            with px.run("motor-test-001", store_frames=True):
-                while True:
-                    px.send("temperature", read_temp())
-                    time.sleep(0.01)
-        """
-        self._run_id = run_id
-        self._store_frames = store_frames
-
-        # Notify API that run started
-        try:
-            self._get_session().post(
-                f"{self.endpoint}/api/runs",
-                data=json.dumps({
-                    "run_id": run_id,
-                    "source_id": self.source_id,
-                    "status": "started",
-                    "tags": tags,
-                    "timestamp": (int(time.time() * 1000) + self._clock_offset_ms) / 1000,
-                }).encode("utf-8"),
-                timeout=self.timeout,
-            )
-        except Exception as e:
-            logger.debug(f"Run start notification failed: {e}")
-
-        try:
-            yield
-        finally:
-            # Notify API that run ended
-            try:
-                self._get_session().post(
-                    f"{self.endpoint}/api/runs",
-                    data=json.dumps({
-                        "run_id": run_id,
-                        "source_id": self.source_id,
-                        "status": "ended",
-                        "timestamp": (int(time.time() * 1000) + self._clock_offset_ms) / 1000,
-                    }).encode("utf-8"),
-                    timeout=self.timeout,
-                )
-            except Exception as e:
-                logger.debug(f"Run end notification failed: {e}")
-            self._run_id = None
-            self._store_frames = False
-
     def close(self):
         """Close the client, flush any buffered points, and release resources."""
         if self.buffer_size() > 0:

plexus/config.py

@@ -9,7 +9,6 @@ import os
 import random
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
 
 
 @dataclass
@@ -49,8 +48,8 @@ CONFIG_DIR = Path.home() / ".plexus"
 CONFIG_FILE = CONFIG_DIR / "config.json"
 
 PLEXUS_ENDPOINT = "https://app.plexus.company"
-PLEXUS_GATEWAY_URL = "https://plexus-gateway.fly.dev"
-PLEXUS_GATEWAY_WS_URL = "wss://plexus-gateway.fly.dev"
+PLEXUS_GATEWAY_URL = "https://gateway.plexus.company"
+PLEXUS_GATEWAY_WS_URL = "wss://gateway.plexus.company"
 
 DEFAULT_CONFIG = {
     "api_key": None,
@@ -73,7 +72,7 @@ def load_config() -> dict:
             config = json.load(f)
             # Merge with defaults to handle missing keys
             return {**DEFAULT_CONFIG, **config}
-    except (json.JSONDecodeError, IOError):
+    except (OSError, json.JSONDecodeError):
         return DEFAULT_CONFIG.copy()
 
 
@@ -90,7 +89,7 @@ def save_config(config: dict) -> None:
     os.chmod(CONFIG_FILE, 0o600)
 
 
-def get_api_key() -> Optional[str]:
+def get_api_key() -> str | None:
     """Get API key from config or environment variable."""
     # Environment variable takes precedence
     env_key = os.environ.get("PLEXUS_API_KEY")
@@ -131,7 +130,7 @@ def get_gateway_ws_url() -> str:
     return (config.get("gateway_ws_url") or PLEXUS_GATEWAY_WS_URL).rstrip("/")
 
 
-def get_source_id() -> Optional[str]:
+def get_source_id() -> str | None:
     """Get the source ID, generating one if not set."""
     config = load_config()
     source_id = config.get("source_id")

plexus/ws.py

@@ -5,14 +5,13 @@ Wire-compatible with the C SDK (`plexus_ws.c`). Targets the gateway's
 `/ws/device` endpoint and exchanges the same JSON frames:
 
     client → {"type": "device_auth", "api_key": ..., "source_id": ...,
-              "install_id": ..., "platform": "python-sdk",
-              "agent_version": ..., "commands": [...]}
-    server → {"type": "authenticated", "source_id": ...}
-
-The server-returned `source_id` in the `authenticated` frame is
-authoritative: if the gateway auto-suffixed on a collision (e.g. the
-desired name was already claimed by a different install_id), the
-client's `source_id` is updated in place to match.
+              "platform": "python-sdk", "agent_version": ...,
+              "commands": [...]}
+    server → {"type": "authenticated", "source_id": ..., "server_time_ms": ...}
+
+The gateway echoes the declared `source_id` back unchanged; the client
+uses the `authenticated` frame only for the `server_time_ms` clock sync.
+(install_id and server-side source_id auto-suffixing were removed in 0.7.1.)
     client → {"type": "telemetry", "points": [...]}
     client → {"type": "heartbeat", "source_id": ..., "agent_version": ...}   # every 30s
     server → {"type": "typed_command", "id": ..., "command": ..., "params": {...}}
@@ -33,8 +32,9 @@ import random
 import struct
 import threading
 import time
+from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any
 
 try:
     import websocket  # websocket-client
@@ -53,18 +53,23 @@ HEARTBEAT_INTERVAL_S = 30.0
 BACKOFF_BASE_S = 1.0
 BACKOFF_MAX_S = 60.0
 
-CommandHandler = Callable[[str, Dict[str, Any]], Optional[Dict[str, Any]]]
+CommandHandler = Callable[[str, dict[str, Any]], dict[str, Any] | None]
 
 
 @dataclass
 class _RegisteredCommand:
     name: str
     handler: CommandHandler
-    description: Optional[str] = None
-    params: List[Dict[str, Any]] = field(default_factory=list)
-
-    def to_manifest(self) -> Dict[str, Any]:
-        m: Dict[str, Any] = {"name": self.name}
+    description: str | None = None
+    params: list[dict[str, Any]] = field(default_factory=list)
+    # "accept" (default): run overlapping invocations concurrently.
+    # "reject": refuse a new invocation with an error result while a
+    # previous one of the same command is still running.
+    concurrency: str = "accept"
+    _lock: threading.Lock = field(default_factory=threading.Lock, repr=False)
+
+    def to_manifest(self) -> dict[str, Any]:
+        m: dict[str, Any] = {"name": self.name}
         if self.description:
             m["description"] = self.description
         if self.params:
@@ -92,7 +97,7 @@ class WebSocketTransport:
         agent_version: str = "0.0.0",
         platform: str = "python-sdk",
         auto_reconnect: bool = True,
-        on_clock_synced: Optional[Callable[[int], None]] = None,
+        on_clock_synced: Callable[[int], None] | None = None,
     ):
         if not api_key:
             raise ValueError("api_key required")
@@ -107,16 +112,16 @@ class WebSocketTransport:
         self.auto_reconnect = auto_reconnect
         self._on_clock_synced = on_clock_synced
 
-        self._commands: Dict[str, _RegisteredCommand] = {}
-        self._ws: Optional[websocket.WebSocket] = None
+        self._commands: dict[str, _RegisteredCommand] = {}
+        self._ws: websocket.WebSocket | None = None
         self._ws_lock = threading.Lock()
         self._authenticated = threading.Event()
         self._stop = threading.Event()
-        self._thread: Optional[threading.Thread] = None
+        self._thread: threading.Thread | None = None
         self._backoff_attempt = 0
         self._clock_offset_ms: int = 0
-        self._video_queue: "queue.Queue[bytes]" = queue.Queue(maxsize=2)
-        self._video_thread: Optional[threading.Thread] = None
+        self._video_queue: queue.Queue[bytes] = queue.Queue(maxsize=2)
+        self._video_thread: threading.Thread | None = None
 
     # ------------------------------------------------------------------ public
 
@@ -125,13 +130,26 @@ class WebSocketTransport:
         name: str,
         handler: CommandHandler,
         *,
-        description: Optional[str] = None,
-        params: Optional[List[Dict[str, Any]]] = None,
+        description: str | None = None,
+        params: list[dict[str, Any]] | None = None,
+        concurrency: str = "accept",
     ) -> None:
         """Register a command handler. Must be called before start() to be
-        advertised in the auth frame."""
+        advertised in the auth frame.
+
+        concurrency controls what happens when a command arrives while a
+        previous invocation of the *same* command is still running:
+            "accept" (default) — run it concurrently on a new thread.
+            "reject"           — refuse it with an error result until the
+                                 in-flight invocation finishes.
+        """
+        if concurrency not in ("accept", "reject"):
+            raise ValueError(
+                f"concurrency must be 'accept' or 'reject', got {concurrency!r}"
+            )
         self._commands[name] = _RegisteredCommand(
-            name=name, handler=handler, description=description, params=params or []
+            name=name, handler=handler, description=description,
+            params=params or [], concurrency=concurrency,
         )
 
     def start(self) -> None:
@@ -169,11 +187,18 @@ class WebSocketTransport:
     def is_authenticated(self) -> bool:
         return self._authenticated.is_set()
 
+    @property
+    def reconnect_pending(self) -> bool:
+        """True after a failed connect while the transport is backing off /
+        retrying. Callers should not block waiting for auth in this state —
+        no connection attempt may even be in flight."""
+        return self._backoff_attempt > 0 and not self._authenticated.is_set()
+
     @property
     def clock_offset_ms(self) -> int:
         return self._clock_offset_ms
 
-    def send_points(self, points: List[Dict[str, Any]]) -> bool:
+    def send_points(self, points: list[dict[str, Any]]) -> bool:
         """Send a telemetry frame. Returns False if the socket is not
         authenticated — caller is expected to fall back to HTTP."""
         if not points:
@@ -205,7 +230,7 @@ class WebSocketTransport:
         except queue.Full:
             return False
 
-    def send_json_video_frame(self, msg: Dict[str, Any]) -> bool:
+    def send_json_video_frame(self, msg: dict[str, Any]) -> bool:
         """Send a JSON video_frame message. Used for frames that carry extra
         metadata (e.g. thermal cameras) that the binary format cannot express."""
         if not self._authenticated.is_set():
@@ -339,7 +364,7 @@ class WebSocketTransport:
                 continue
             self._dispatch(_safe_json(raw))
 
-    def _dispatch(self, msg: Dict[str, Any]) -> None:
+    def _dispatch(self, msg: dict[str, Any]) -> None:
         mtype = msg.get("type")
         if mtype == "typed_command":
             self._handle_command(msg)
@@ -347,7 +372,7 @@ class WebSocketTransport:
             logger.warning("plexus ws server error: %s", msg.get("detail") or msg)
         # ignore unknown types — forward-compat
 
-    def _handle_command(self, msg: Dict[str, Any]) -> None:
+    def _handle_command(self, msg: dict[str, Any]) -> None:
         cmd_id = msg.get("id") or ""
         command = msg.get("command") or ""
         params = msg.get("params") or {}
@@ -371,20 +396,50 @@ class WebSocketTransport:
             })
             return
 
+        # concurrency="reject": if an invocation is already running, refuse
+        # this one immediately rather than starting a second in parallel.
+        holds_lock = False
+        if reg.concurrency == "reject":
+            if not reg._lock.acquire(blocking=False):
+                self._send_frame({
+                    "type": "command_result",
+                    "id": cmd_id,
+                    "command": command,
+                    "event": "error",
+                    "error": f"command already in progress: {command}",
+                })
+                return
+            holds_lock = True
+
         # Run the handler off the read-loop thread so a slow handler doesn't
         # block heartbeats or other inbound frames.
-        threading.Thread(
-            target=self._run_handler,
-            args=(reg, cmd_id, command, params),
-            daemon=True,
-        ).start()
+        try:
+            threading.Thread(
+                target=self._run_handler,
+                args=(reg, cmd_id, command, params, holds_lock),
+                daemon=True,
+            ).start()
+        except Exception as e:
+            # Thread creation failed (e.g. resource exhaustion). Release the
+            # concurrency lock so the command isn't wedged as "in progress",
+            # and report the failure rather than leaving it silently un-acked.
+            if holds_lock:
+                reg._lock.release()
+            self._send_frame({
+                "type": "command_result",
+                "id": cmd_id,
+                "command": command,
+                "event": "error",
+                "error": f"failed to start command handler: {e}",
+            })
 
     def _run_handler(
         self,
         reg: _RegisteredCommand,
         cmd_id: str,
         command: str,
-        params: Dict[str, Any],
+        params: dict[str, Any],
+        holds_lock: bool = False,
     ) -> None:
         try:
             result = reg.handler(command, params)
@@ -397,6 +452,11 @@ class WebSocketTransport:
                 "error": str(e),
             })
             return
+        finally:
+            # Release the concurrency lock (if held) as soon as the handler
+            # returns, regardless of success or failure.
+            if holds_lock:
+                reg._lock.release()
         self._send_frame({
             "type": "command_result",
             "id": cmd_id,
@@ -405,7 +465,7 @@ class WebSocketTransport:
             "result": result if result is not None else {},
         })
 
-    def _send_frame(self, frame: Dict[str, Any]) -> bool:
+    def _send_frame(self, frame: dict[str, Any]) -> bool:
         with self._ws_lock:
             ws = self._ws
         if ws is None:
@@ -459,7 +519,7 @@ def _ensure_device_path(url: str) -> str:
     return url + "/ws/device"
 
 
-def _safe_json(raw: Any) -> Dict[str, Any]:
+def _safe_json(raw: Any) -> dict[str, Any]:
     if isinstance(raw, (bytes, bytearray)):
         raw = raw.decode("utf-8", errors="replace")
     if not isinstance(raw, str):

{plexus_python-0.7.1.dist-info → plexus_python-0.9.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: plexus-python
-Version: 0.7.1
+Version: 0.9.0
 Summary: Thin Python SDK for Plexus — send telemetry in one line
-Project-URL: Homepage, https://plexus.dev
-Project-URL: Documentation, https://docs.plexus.dev
+Project-URL: Homepage, https://plexus.company
+Project-URL: Documentation, https://docs.plexus.company
 Project-URL: Repository, https://github.com/plexus-oss/plexus-python
 Project-URL: Issues, https://github.com/plexus-oss/plexus-python/issues
-Author-email: Plexus <hello@plexus.dev>
+Author-email: Plexus <info@plexus.company>
 License-Expression: Apache-2.0
 License-File: LICENSE
 Keywords: fleet,hardware,iot,monitoring,observability,telemetry
@@ -27,7 +27,7 @@ Requires-Dist: numpy>=1.24; extra == 'dev'
 Requires-Dist: opencv-python-headless>=4.8; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest>=9.0.3; extra == 'dev'
-Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: ruff==0.15.12; extra == 'dev'
 Requires-Dist: websockets>=12; extra == 'dev'
 Provides-Extra: video
 Requires-Dist: numpy>=1.24; extra == 'video'
@@ -68,7 +68,7 @@ curl -sL https://app.plexus.company/setup | bash -s -- \
 
 The name must match `^[a-z0-9][a-z0-9_-]{1,62}$`. `setup.sh` refuses to run without `--name` (or without a TTY to prompt for one) — this is deliberate, because the previous `hostname` fallback silently merged telemetry from cloned SD-card images that all booted as `raspberrypi`.
 
-**If two devices end up requesting the same name**, the gateway auto-suffixes: the first connection gets `drone-01`, the second gets `drone-01_2`, the third `drone-01_3`, and so on. The SDK logs the rename at INFO and persists the assigned name to `~/.plexus/config.json` so the device keeps its identity across reboots. Under the hood, a per-installation UUID (`install_id`, lazily generated on first run) is what lets the gateway tell "same device reconnecting" from "different device claiming the same name."
+**Names are not auto-deduplicated.** The gateway echoes back whatever `source_id` you declare, unchanged — pick a unique name per device (that's what `--name` and `source_id=...` are for). Two devices that declare the same name write into the same source.
 
 In normal code, you usually just pass `source_id=...` explicitly to `Plexus(...)` and never have to think about it.
 
@@ -111,7 +111,7 @@ px.send_batch([
 ])
 ```
 
-`points` is a list of `(metric, value)` tuples. All points share the same timestamp (now, unless you pass `timestamp=t`). For independent timestamps per point, call `send()` in a loop instead.
+`points` is a list of `(metric, value)` tuples, or `(metric, value, timestamp)` 3-tuples when you need a per-point timestamp. Points without their own timestamp share the batch timestamp (now, unless you pass `timestamp=t`).
 
 ### `event(name, data)` — record a discrete occurrence
 
@@ -125,16 +125,6 @@ px.event("sensor_error", {"sensor": "imu", "code": 42}, tags={"motor": "A"})
 
 The platform displays events as markers overlaid on your telemetry charts, not as time-series lines.
 
-### `run(run_id)` — group data into a named recording
-
-```python
-with px.run("thermal-cycle-001"):
-    while running:
-        px.send("temperature", read_temp())
-```
-
-All `send()` calls inside the context are tagged with `run_id`, making it easy to isolate and replay that slice of data in the dashboard.
-
 ## Video streaming
 
 Two methods depending on whether you control the capture loop or just have a URL.
@@ -228,8 +218,8 @@ px.send("temperature", 72.5, timestamp=t)   # your timestamp, used as-is, no cor
 
 **Known limits:**
 - Clock sync refreshes on WebSocket (re)connect. A device with a drifting RTC that stays connected for many days accumulates uncorrected drift between reconnects.
-- HTTP-only transport (`transport="http"`) does not receive clock sync — timestamps default to the uncorrected device clock.
-- `send_batch()` shares one timestamp across the whole batch. For per-point timestamps, call `send()` in a loop.
+- The HTTP fallback path (used when the WebSocket is unavailable) does not receive clock sync — timestamps default to the uncorrected device clock.
+- `send_batch()` shares one timestamp across the batch by default; pass `(metric, value, timestamp)` 3-tuples for per-point timestamps.
 
 ## Transport
 
@@ -241,13 +231,12 @@ By default the SDK connects over a **WebSocket** to `/ws/device` on the gateway
 If the socket is unavailable, sends transparently fall back to `POST /ingest` so no data is lost.
 
 ```python
-# default — ws with http fallback
+# ws with transparent http fallback — this is the only mode
 px = Plexus()
-
-# force http (legacy)
-px = Plexus(transport="http")
 ```
 
+There is no transport selector: the SDK always prefers the WebSocket and falls back to `POST /ingest` on its own when the socket is unavailable.
+
 ### Handling commands
 
 Register a handler before the first `send()` so the command is advertised in the auth frame:
@@ -270,8 +259,8 @@ The SDK sends an `ack` frame before invoking the handler, then a `result` frame
 | Variable                | Description                  | Default                          |
 | ----------------------- | ---------------------------- | -------------------------------- |
 | `PLEXUS_API_KEY`        | API key (required)           | none                             |
-| `PLEXUS_GATEWAY_URL`    | HTTP ingest URL              | `https://plexus-gateway.fly.dev` |
-| `PLEXUS_GATEWAY_WS_URL` | WebSocket URL              | `wss://plexus-gateway.fly.dev`   |
+| `PLEXUS_GATEWAY_URL`    | HTTP ingest URL              | `https://gateway.plexus.company` |
+| `PLEXUS_GATEWAY_WS_URL` | WebSocket URL              | `wss://gateway.plexus.company`   |
 
 ## Architecture
 

plexus_python-0.9.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+plexus/__init__.py,sha256=bXzZn--_gT7vRM5tvRy36tMkWIPk-9NBHa7iFPArLUw,447
+plexus/_log.py,sha256=3fjXrHFZghQ_17umMcvDUjjTH6aTQB3J4SpVDBiH03w,335
+plexus/buffer.py,sha256=UNv_jEcrDwbkjJ6uhCehb7uBI2EuFEwO40waDpZn_5I,9579
+plexus/cli.py,sha256=yc3j-5kUHhdYJv3b87ch7A41JVu491xb-UYdkRNubhg,14165
+plexus/client.py,sha256=ku8znMnJlO9bMCWYIVwixAx5usVGcUsV0l5tKjyXJkk,39872
+plexus/config.py,sha256=RuDh5UdVGdVQld5kQlXZO6CVXO4tS0HBalyaoAlXNvc,4416
+plexus/ws.py,sha256=YmaxOwtEdYHOsc7E5AjEUlFTJhvn7X1xWqJKQKgHWYo,18942
+plexus/cameras/__init__.py,sha256=AVu1vE1xfYk9lz1cprHlTfi0ieHf84UhQh9Z92E05b8,490
+plexus/cameras/thermal.py,sha256=-klCEJQG5GlLtELaowWOPYomwMsLK8O5pmmX0PqUrTA,12022
+plexus_python-0.9.0.dist-info/METADATA,sha256=WRRIS6gnGMvCuH8PyhxZ1uSNAgzq9zhoGbUnx9li1EQ,11394
+plexus_python-0.9.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+plexus_python-0.9.0.dist-info/entry_points.txt,sha256=YlkOtTn_7Q_IGuJaKdvpU-90dCeBSPx2p_UTGMAz5Zs,43
+plexus_python-0.9.0.dist-info/licenses/LICENSE,sha256=nm3qP1F-JAGcfLpRVtIX24L20LMnRpxmZ2oKZzFpLVo,10755
+plexus_python-0.9.0.dist-info/RECORD,,

{plexus_python-0.7.1.dist-info → plexus_python-0.9.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.32.0
 Root-Is-Purelib: true
 Tag: py3-none-any

plexus_python-0.7.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-plexus/__init__.py,sha256=ZzZDGRCztNWGUtN-YF1EwwYzngxsZkU9zb_rW1Tfalg,447
-plexus/_log.py,sha256=3fjXrHFZghQ_17umMcvDUjjTH6aTQB3J4SpVDBiH03w,335
-plexus/buffer.py,sha256=0i6PLgoj904jFNv9RCrlskvPQsPSu_KNdYWMasFOvsg,9596
-plexus/cli.py,sha256=-2wvHXQzobx3_tDGTXpaE2PlHv884y93Mu29kZE8qZE,14214
-plexus/client.py,sha256=SZ4V9FN-bt3QKqVgp9S5QKdRXw934WXZxKlYUb7bWHw,35810
-plexus/config.py,sha256=RNym2Fon6JOCVi1rXPSRWjPFAdT8DSmokY5JPEljQOc,4450
-plexus/ws.py,sha256=9DiQchqCQU7O8r8-FuqotJh8vYAQBO7npJn4BFNzLAE,16242
-plexus/cameras/__init__.py,sha256=OvnU9KGKxkVtFLlk56H9x-ATa6UvpLI7PANa0HQO2cc,490
-plexus/cameras/thermal.py,sha256=7o33QsF1RiZLManTxZ2E36nO8lRAHppCDkS3zXBHCxs,12047
-plexus_python-0.7.1.dist-info/METADATA,sha256=OUDqqIIcHUaZms1QCwL7XdaFo6j11LeN0HZ3EipZEIM,11739
-plexus_python-0.7.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-plexus_python-0.7.1.dist-info/entry_points.txt,sha256=YlkOtTn_7Q_IGuJaKdvpU-90dCeBSPx2p_UTGMAz5Zs,43
-plexus_python-0.7.1.dist-info/licenses/LICENSE,sha256=nm3qP1F-JAGcfLpRVtIX24L20LMnRpxmZ2oKZzFpLVo,10755
-plexus_python-0.7.1.dist-info/RECORD,,