loop-sdk 0.1.0__py3-none-any.whl

loop_sdk/source/port/source_client.py

@@ -0,0 +1,49 @@
+"""Transport port: the Loop Source Bus connection the session drives.
+
+The service orchestrates the handshake and the send pipeline through this
+contract; the concrete gRPC implementation lives in ``outbound/``. Keeping the
+service behind this ABC keeps protobuf out of the application core (per the
+gRPC boundary rule).
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from loop_sdk.source.domain.frame import FrameSample
+from loop_sdk.source.domain.schema import SourceSchema
+from loop_sdk.source.domain.stats import SendStats
+
+
+class SourceClient(ABC):
+    """One client connection to the Loop Source Bus.
+
+    Owns the control plane (answer ``Describe`` from ``schema``, surface
+    ``Open`` / ``Close`` / ``Shutdown``), the data plane (deliver frames), the
+    background sender thread, reconnection, and delivery statistics. Translates
+    transport failures into domain ``SourceError`` subclasses.
+    """
+
+    @abstractmethod
+    def start(self, schema: SourceSchema) -> None:
+        """Open the connection and begin answering the server's commands from ``schema``."""
+
+    @abstractmethod
+    def submit(self, frame: FrameSample) -> None:
+        """Hand a frame to the send pipeline. Non-blocking; drops oldest under backpressure."""
+
+    @abstractmethod
+    def report_error(self, source_id: str, code: str, message: str = "") -> None:
+        """Report a per-source fault on the control plane (``ClientError``).
+
+        The Source Bus maps it to a per-source ``SourceEvent(FAILED)`` so a
+        consumer (e.g. the recorder) fails that source fast instead of waiting
+        for the whole connection to drop. Best-effort and non-blocking."""
+
+    @abstractmethod
+    def stats(self) -> SendStats:
+        """Return a snapshot of delivery and connection statistics."""
+
+    @abstractmethod
+    def close(self) -> None:
+        """Stop sending, tear the connection down, and join background threads."""

loop_sdk/source/port/source_reader.py

@@ -0,0 +1,34 @@
+"""Transport port: the Loop Source Bus read connection a consumer drives.
+
+The mirror of ``SourceClient`` (the produce side). The facade subscribes through
+this contract; the concrete gRPC implementation lives in ``outbound/``. Keeping
+the consumer behind this ABC keeps protobuf out of the application core (per the
+gRPC boundary rule).
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+
+from loop_sdk.source.domain.frame import FrameSample
+
+
+class SourceReader(ABC):
+    """One client connection that reads a source's samples back off the bus.
+
+    Owns the gRPC channel and the server-streaming ``Subscribe`` call. Translates
+    transport failures and per-source faults into domain ``SourceError`` subclasses.
+    """
+
+    @abstractmethod
+    def subscribe(self, source_id: str, session_id: str = "") -> Iterator[FrameSample]:
+        """Stream one already-open source's samples as domain frames.
+
+        Yields frames until the source stops cleanly (iteration ends) and raises
+        ``SubscriptionFailedError`` if the bus reports the source faulted.
+        """
+
+    @abstractmethod
+    def close(self) -> None:
+        """Cancel any in-flight subscription and tear the connection down."""

loop_sdk/source/robot_step_sender.py

@@ -0,0 +1,410 @@
+"""High-level robot-step sender: the four-call surface a control loop wants.
+
+``RobotStepSender`` is the ergonomic front door over the low-level
+``SourceProducer``. With loop-sdk installed, a control loop needs one class and
+four calls::
+
+    sender = RobotStepSender(loop_addr, source_id, options=..., apply_config=...)
+    sender.connect()                       # prepare to stream
+    sender.declare(channels)               # fix the channel layout ONCE, open the source
+    sender.send(timestamp_us, step)        # one named-channel reading dict per tick
+    sender.disconnect()                    # tear the connection down
+
+Everything generic about streaming a robot onto the Source Bus lives here:
+connection lifecycle, a layout declared once and held fixed, per-tick sequence
+numbering, "no reading this tick" handling (``None``/``NaN`` → omitted on the
+wire), config-negotiation, and an optional consistency-logging hook.
+
+**Config negotiation.** A robot advertises the configs it can open with via
+``options`` (a ``RobotConfigOptions``). At Open the Source Bus selects one config
+per axis and hands it back; ``RobotStepSender`` then (1) validates the selection
+against what was advertised — rejecting an impossible config so the source fails
+fast instead of opening misconfigured — and (2) calls your ``apply_config``
+callback to reconfigure the device (e.g. set the control rate) before streaming.
+``apply_config`` returns the config it actually applied (or ``None`` for "as
+requested"); raising from it signals the source cannot open. Omit ``options`` for
+no negotiation.
+
+**What this class does NOT do** is interpret your robot's data. ``send`` takes a
+flat ``dict[str, RobotStateValue]`` of named readings; you name the channels and
+produce the readings. The SDK never guesses which field is an "action" or how a
+categorical maps to a number — that domain mapping is yours. ``flatten_step`` is
+a generic structural helper for nested inputs, but column semantics stay with you.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+import os
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any
+
+from loop_sdk.source.client import SourceProducer
+from loop_sdk.source.domain.config import RobotConfig, RobotConfigOptions
+from loop_sdk.source.domain.frame import RobotStateValue
+from loop_sdk.source.domain.schema import ChannelSpec, RobotStreamSchema, SourceSchema
+from loop_sdk.source.setup.config import SourceConfig
+
+logger = logging.getLogger(__name__)
+
+# Sensible turnkey defaults: point at the Source Bus via the LOOP_ADDR env var
+# (falling back to localhost), and name the source "robot-step". Pass explicit
+# values to override.
+_DEFAULT_LOOP_ADDR = os.getenv("LOOP_ADDR", "localhost:50051")
+_DEFAULT_SOURCE_ID = "robot-step"
+
+# Called after each successful send for consistency logging / metrics. Kept as a
+# plain callback so the SDK does not depend on any particular logger.
+OnSent = Callable[..., None]
+
+# Called at Open with the config the Source Bus selected; reconfigures the device
+# and returns the config actually applied (``None`` = applied as requested).
+# Raising signals the source cannot open with that config.
+ApplyRobotConfig = Callable[[RobotConfig], "RobotConfig | None"]
+
+# What a declared layout may be given as.
+ChannelLayout = Sequence[str] | Sequence[ChannelSpec] | Mapping[str, Any]
+
+# Config axes the Source Bus negotiates: control_hz + action_space are the
+# required runtime axes (validated explicitly); these are the optional identity /
+# compatibility gates (mirrors RobotConfig / RobotConfigOptions).
+_OPTIONAL_AXES = ("gripper_type", "finger_type", "robot_type", "robot_firmware_version", "teleoperation_version")
+
+
+def flatten_step(step: Mapping[str, Any], *, separator: str = ".") -> dict[str, RobotStateValue]:
+    """Structurally flatten a nested step dict into ``{dotted.key: value}``.
+
+    A *generic* convenience for callers whose data is nested — it flattens
+    structure only, it does NOT interpret meaning:
+
+      * nested ``dict`` → dotted keys (``a`` + ``b`` → ``a.b``)
+      * a list/tuple of plain numbers → kept whole as a ``list[float]`` vector
+        channel (the Source Bus stores vectors natively)
+      * a list/tuple containing non-numbers → indexed keys (``a[0]``, ``a[1]``)
+      * scalars / bool / str / ``None`` → passed through unchanged
+
+    Column *identity* is still yours: the keys come verbatim from your dict.
+
+    Caveat: flattening joins keys with ``separator`` (``.``), so a literal dotted
+    key (``{"a.b": ...}``) and a nested one (``{"a": {"b": ...}}``) collapse to the
+    same flat key — last write wins. Keep your nesting and key names from
+    colliding on the separator.
+    """
+    flat: dict[str, RobotStateValue] = {}
+    _flatten_into(flat, "", step, separator)
+    return flat
+
+
+def _is_number(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def _flatten_into(out: dict[str, RobotStateValue], prefix: str, value: Any, sep: str) -> None:
+    if isinstance(value, Mapping):
+        for key, sub in value.items():
+            child = f"{prefix}{sep}{key}" if prefix else str(key)
+            _flatten_into(out, child, sub, sep)
+        return
+    if isinstance(value, (list, tuple)):
+        if all(_is_number(item) for item in value):
+            out[prefix] = [float(item) for item in value]  # whole vector channel
+            return
+        for index, item in enumerate(value):
+            _flatten_into(out, f"{prefix}[{index}]", item, sep)
+        return
+    out[prefix] = value
+
+
+def _normalize_value(value: RobotStateValue) -> RobotStateValue:
+    """Map a reading to its wire form: ``NaN`` → ``None`` ("no reading"); everything
+    else (scalar/bool/str/vector) passes through untouched."""
+    if value is None:
+        return None
+    if isinstance(value, float) and math.isnan(value):
+        return None
+    return value
+
+
+def _candidate_axes(options: RobotConfigOptions) -> dict[str, tuple[Any, ...]]:
+    """The advertised candidate list per config axis, from the declared options."""
+    return {
+        "control_hz": options.control_hz,
+        "action_space": options.action_space,
+        "gripper_type": options.gripper_type,
+        "finger_type": options.finger_type,
+        "robot_type": options.robot_type,
+        "robot_firmware_version": options.robot_firmware_version,
+        "teleoperation_version": options.teleoperation_version,
+    }
+
+
+def _require_advertised(
+    field: str, requested: Any, candidates: dict[str, tuple[Any, ...]], *, allow_empty: bool
+) -> None:
+    """Reject a selected config value that was never advertised for ``field``."""
+    if allow_empty and requested in ("", 0):
+        return
+    options = candidates.get(field, ())
+    if options:
+        if requested not in options:
+            raise ValueError(f"unsupported robot config {field}={requested!r}; available={options!r}")
+        return
+    if requested not in ("", 0):
+        raise ValueError(f"unsupported robot config {field}={requested!r}; no values advertised")
+
+
+class RobotStepSender:
+    """Stream one robot source onto the Loop Source Bus with a four-call surface."""
+
+    def __init__(
+        self,
+        loop_addr: str = _DEFAULT_LOOP_ADDR,
+        source_id: str = _DEFAULT_SOURCE_ID,
+        *,
+        name: str = "",
+        options: RobotConfigOptions | None = None,
+        apply_config: ApplyRobotConfig | None = None,
+        on_sent: OnSent | None = None,
+        config: SourceConfig | None = None,
+        client_id: str | None = None,
+        connect_producer: Callable[..., Any] | None = None,
+    ) -> None:
+        """Configure (but do not yet open) a sender for one robot source. **Build once
+        at startup**, before the control loop runs.
+
+        ``loop_addr`` defaults to the ``LOOP_ADDR`` env var (else ``localhost:50051``)
+        and ``source_id`` to ``"robot-step"`` — pass explicit values to override.
+        ``name`` is free-form source metadata persisted by the recorder. ``options``
+        advertises the configs the source can open with; when set, the Source Bus
+        negotiates one and ``RobotStepSender`` validates it against ``options`` and
+        calls ``apply_config`` to reconfigure the device. ``on_sent`` is called
+        ``(sequence, timestamp_us, source_id, n_values)`` after each successful send.
+        ``connect_producer`` is a seam for tests (defaults to ``SourceProducer.connect``).
+
+        Call order over a session::
+
+            connect()               # startup
+            send(timestamp_us, ...) # every tick; the FIRST send declares the layout
+                                    #   from its keys (make the first frame complete)
+            disconnect()            # shutdown only — NOT for pauses
+
+        ``declare(channels)`` is optional — call it explicitly after ``connect()``
+        only when you want the layout fixed and the config negotiated *before* the
+        first ``send`` (e.g. to apply ``control_hz`` to the device before streaming).
+        """
+        self.loop_addr = loop_addr
+        self.source_id = source_id
+        self.name = name
+        self._options = options
+        self._apply_config = apply_config
+        self._on_sent = on_sent
+        self._config = config
+        self._client_id = client_id
+        self._connect_producer = connect_producer or SourceProducer.connect
+
+        self._producer: SourceProducer | None = None
+        self._order: list[str] | None = None
+        self._seq = 0
+        self._unknown_keys: set[str] = set()
+        self._warned_disconnected = False
+        self.connected = False
+        self.total_sent = 0
+        self.total_failed = 0
+
+    # -- lifecycle ---------------------------------------------------------
+
+    def connect(self) -> bool:
+        """**Step 1 — at startup.** Mark intent to stream. After this, just call
+        ``send()`` in your loop — the first ``send`` declares the layout and opens the
+        transport (the Source Bus needs the schema at open time). Returns ``True``."""
+        self.connected = True
+        self._warned_disconnected = False
+        logger.info("RobotStepSender: ready to stream to %s (source=%s)", self.loop_addr, self.source_id)
+        return True
+
+    def declare(
+        self,
+        channels: ChannelLayout,
+        *,
+        name: str | None = None,
+        options: RobotConfigOptions | None = None,
+    ) -> bool:
+        """**Optional — the first ``send()`` does this for you** from its own keys.
+        Call ``declare`` explicitly only to fix the layout and open the source
+        *before* the first send — i.e. so the Source Bus negotiates the config (your
+        ``apply_config`` fires at Open) before you start streaming, rather than on the
+        first tick.
+
+        ``channels`` is the authoritative, COMPLETE set of channel keys this source
+        will ever carry — channel keys, full ``ChannelSpec``s, or a representative
+        step dict (its flattened keys become the layout). The layout is fixed here:
+        later ``send()`` calls may omit a key (→ "no reading") but may not introduce
+        new keys. Idempotent once the source is open.
+        """
+        if not self.connected:
+            self.connect()
+        if self._producer is not None:
+            return True
+        if options is not None:
+            self._options = options
+        if name is not None:
+            self.name = name
+
+        specs = self._resolve_specs(channels)
+        if not specs:
+            logger.warning("RobotStepSender: empty channel layout; not opening source %s", self.source_id)
+            return False
+        self._order = [spec.key for spec in specs]
+        schema = SourceSchema(
+            robot=(
+                RobotStreamSchema(
+                    source_id=self.source_id,
+                    name=self.name,
+                    channels=tuple(specs),
+                    available_options=self._options or RobotConfigOptions(),
+                ),
+            )
+        )
+        self._producer = self._connect_producer(
+            self.loop_addr,
+            schema,
+            config=self._config,
+            client_id=self._client_id,
+            on_select=self._on_select,
+        )
+        logger.info(
+            "RobotStepSender: source %s open on %s (%d channels)", self.source_id, self.loop_addr, len(self._order)
+        )
+        return True
+
+    def send(
+        self,
+        timestamp_us: int,
+        step: Mapping[str, RobotStateValue],
+        *,
+        sequence: int | None = None,
+    ) -> bool:
+        """**Step 2 — every control tick.** Non-blocking. The **first call declares the
+        channel layout from this step's keys** (no separate ``declare`` needed) and
+        opens the source; so make your first frame COMPLETE — include every channel
+        you will ever send (give "no reading" ones a ``None``/``NaN``), because keys
+        absent from that first frame become undeclared and are dropped later.
+
+        Start calling this *before* the operator hits "start recording" and keep
+        calling it — then capture is already live when recording begins; the recorder
+        decides what to keep, you just stream the freshest state. Pausing is safe:
+        stop calling and resume later (don't ``disconnect()`` for a pause).
+
+        ``step`` maps channel keys to readings (scalar/bool/str/float-vector) and may
+        be nested — it is flattened the same way ``declare`` flattens. A declared key
+        that is absent or maps to ``None``/``NaN`` is sent as "no reading this tick"
+        (omitted on the wire); a key outside the declared layout is dropped with a
+        one-time warning. ``sequence`` overrides the auto-incrementing per-source
+        counter. Returns ``True`` on success.
+        """
+        if not self.connected:
+            if not self._warned_disconnected:
+                self._warned_disconnected = True
+                logger.warning("RobotStepSender: send() before connect()/declare() (or after disconnect); dropping")
+            return False
+        flat = flatten_step(step)
+        try:
+            if self._producer is None and not self.declare(flat):
+                return False
+            assert self._order is not None and self._producer is not None
+            self._warn_unknown_keys(flat)
+            state = {key: _normalize_value(flat.get(key)) for key in self._order}
+            seq = self._seq if sequence is None else sequence
+            self._producer.send_robot(self.source_id, timestamp_us, seq, state)
+        except Exception as error:  # transport/SDK error — never break the control loop
+            self.total_failed += 1
+            if self.total_failed % 200 == 1:  # rate-limit (~once per 10s at 20Hz)
+                logger.warning("RobotStepSender: send failed (%d total): %s", self.total_failed, error)
+            return False
+
+        # Success bookkeeping + consistency hook, OUTSIDE the transport try so a
+        # buggy on_sent callback is not miscounted as a transport failure.
+        self._seq = seq + 1
+        self.total_sent += 1
+        if self._on_sent is not None:
+            self._on_sent(sequence=seq, timestamp_us=timestamp_us, source_id=self.source_id, n_values=len(state))
+        return True
+
+    def disconnect(self) -> None:
+        """**Step 4 — on shutdown only.** Stop sending and tear the connection down.
+        Do NOT call this for a pause — keep the sender open and just stop calling
+        ``send()``; the link stays alive (keepalive) and streaming resumes when you
+        call ``send()`` again."""
+        if self._producer is not None:
+            try:
+                self._producer.close()
+            except Exception as error:
+                logger.warning("RobotStepSender: close failed: %s", error)
+        self._producer = None
+        self._order = None
+        self._seq = 0
+        self._unknown_keys.clear()
+        self.connected = False
+        logger.info("RobotStepSender: disconnected (sent=%d failed=%d)", self.total_sent, self.total_failed)
+
+    def stats(self) -> Any:
+        """Delivery/connection statistics from the underlying producer, or ``None``
+        before the source is open."""
+        return self._producer.stats() if self._producer is not None else None
+
+    def __enter__(self) -> RobotStepSender:
+        self.connect()
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.disconnect()
+
+    # -- config negotiation ------------------------------------------------
+
+    def _on_select(self, source_id: str, requested: RobotConfig) -> RobotConfig | None:
+        """Source Bus selected ``requested`` for ``source_id``: validate it against
+        the advertised options, then apply it to the device. Raising fails the
+        source (the SDK converts it to a per-source FAILED event)."""
+        self._validate_selection(source_id, requested)
+        applied = self._apply_config(requested) if self._apply_config is not None else None
+        logger.info("RobotStepSender: applied robot config for %s: %s", source_id, applied or requested)
+        return applied
+
+    def _validate_selection(self, source_id: str, requested: RobotConfig) -> None:
+        if source_id != self.source_id:
+            raise ValueError(f"unknown robot source {source_id!r}; expected {self.source_id!r}")
+        if self._options is None:
+            raise ValueError("robot config selected but no options were advertised")
+        candidates = _candidate_axes(self._options)
+        hz = int(getattr(requested, "control_hz", 0) or 0)
+        action_space = str(getattr(requested, "action_space", "") or "")
+        _require_advertised("control_hz", hz, candidates, allow_empty=False)
+        _require_advertised("action_space", action_space, candidates, allow_empty=False)
+        for field in _OPTIONAL_AXES:
+            _require_advertised(field, str(getattr(requested, field, "") or ""), candidates, allow_empty=True)
+
+    # -- internals ---------------------------------------------------------
+
+    @staticmethod
+    def _resolve_specs(channels: ChannelLayout) -> list[ChannelSpec]:
+        if isinstance(channels, Mapping):
+            return [ChannelSpec(key=key) for key in flatten_step(channels)]
+        specs: list[ChannelSpec] = []
+        for item in channels:
+            specs.append(item if isinstance(item, ChannelSpec) else ChannelSpec(key=str(item)))
+        return specs
+
+    def _warn_unknown_keys(self, step: Mapping[str, RobotStateValue]) -> None:
+        """Surface (never silently accept) keys not in the declared layout — they
+        are dropped, since the layout is fixed at declare time."""
+        assert self._order is not None
+        new = set(step) - set(self._order) - self._unknown_keys
+        if new:
+            self._unknown_keys |= new
+            logger.warning(
+                "RobotStepSender: %d key(s) not in the declared layout are NOT sent "
+                "(layout fixed at declare): %s",
+                len(new),
+                sorted(new),
+            )

loop_sdk/source/service/producer_session.py

@@ -0,0 +1,81 @@
+"""Producer session: validate frames against the schema and drive the send pipeline.
+
+This is the transport-free application core. It owns the rule that a frame must
+match the source it names (right kind, right vector length); it delegates all
+transport — handshake, streaming, reconnection — to the ``SourceClient`` port.
+It never references protobuf or threads.
+"""
+
+from __future__ import annotations
+
+from loop_sdk.source.domain.frame import FrameSample, RobotFrame, TactileFrame
+from loop_sdk.source.domain.schema import SourceSchema
+from loop_sdk.source.domain.source_exception import (
+    SchemaMismatchError,
+    UnknownSourceError,
+)
+from loop_sdk.source.domain.source_kind import SourceKind
+from loop_sdk.source.domain.stats import SendStats
+from loop_sdk.source.port.source_client import SourceClient
+
+
+class ProducerSession:
+    """Orchestrate frame validation and delivery for one declared schema."""
+
+    def __init__(self, schema: SourceSchema, client: SourceClient) -> None:
+        self._schema = schema
+        self._client = client
+
+    def start(self) -> None:
+        """Open the Source Bus connection and begin answering its commands."""
+        self._client.start(self._schema)
+
+    def send(self, frame: FrameSample) -> None:
+        """Validate ``frame`` against the schema and hand it to the send pipeline.
+
+        Non-blocking: validation is cheap and the SDK drops oldest under
+        backpressure. Raises a domain error if the frame contradicts the schema.
+        """
+        self._validate(frame)
+        self._client.submit(frame)
+
+    def report_error(self, source_id: str, code: str, message: str = "") -> None:
+        """Report a per-source fault to the Source Bus. Best-effort, non-blocking.
+
+        Not validated against the schema: a fault must be reportable even for a
+        source that failed to enumerate or stopped matching its layout."""
+        self._client.report_error(source_id, code, message)
+
+    def stats(self) -> SendStats:
+        return self._client.stats()
+
+    def close(self) -> None:
+        self._client.close()
+
+    def _validate(self, frame: FrameSample) -> None:
+        declared = self._kind_for(frame.source_id)
+        if declared != frame.kind:
+            raise SchemaMismatchError(
+                frame.source_id,
+                f"declared {declared.value}, got {frame.kind.value}",
+            )
+        if isinstance(frame, RobotFrame):
+            self._validate_robot(frame)
+            return
+        if isinstance(frame, TactileFrame) and not frame.channels:
+            raise SchemaMismatchError(frame.source_id, "tactile frame has no channels")
+
+    def _validate_robot(self, frame: RobotFrame) -> None:
+        declared = self._schema.robot_channel_keys(frame.source_id)
+        unknown = frame.state.keys() - declared
+        if unknown:
+            raise SchemaMismatchError(
+                frame.source_id,
+                f"state carries keys not in the declared channel layout: {sorted(unknown)}",
+            )
+
+    def _kind_for(self, source_id: str) -> SourceKind:
+        try:
+            return self._schema.kind_of(source_id)
+        except KeyError as error:
+            raise UnknownSourceError(source_id) from error

loop_sdk/source/setup/config.py

@@ -0,0 +1,30 @@
+"""Source SDK configuration, read from ``LOOP_SOURCE_*`` environment variables."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+_DISTRIBUTION = "loop-sdk"
+
+
+def _client_version() -> str:
+    """``loop-sdk/<installed version>`` — the SDK's self-reported version on
+    ``ClientReady``. Tracks the pip-installed distribution version (set from git
+    tags by hatch-vcs); falls back when running from an uninstalled source tree."""
+    try:
+        return f"{_DISTRIBUTION}/{version(_DISTRIBUTION)}"
+    except PackageNotFoundError:
+        return f"{_DISTRIBUTION}/unknown"
+
+
+class SourceConfig(BaseSettings):
+    """Tunables for the SDK send pipeline and reconnection behavior."""
+
+    model_config = SettingsConfigDict(env_prefix="LOOP_SOURCE_")
+
+    reconnect_backoff_seconds: float = Field(default=0.5, gt=0)
+    reconnect_backoff_max_seconds: float = Field(default=10.0, gt=0)
+    client_version: str = Field(default_factory=_client_version)

loop_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: loop-sdk
+Version: 0.1.0
+Summary: Customer-side gRPC client SDK for the Loop Source Bus.
+Requires-Python: >=3.10
+Requires-Dist: grpcio>=1.81.1
+Requires-Dist: protobuf>=7.35.1
+Requires-Dist: pydantic-settings>=2.13.0
+Requires-Dist: pydantic>=2.12.0

loop_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+loop_sdk/__init__.py,sha256=Pw36uCwsTds_a4Xr6TBMvYPmeuM4fYDSmU-vxVoSyRg,2345
+loop_sdk/gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loop_sdk/gen/__init__.pyi,sha256=lXuz5z0bL5TXqVdaXxiVr-4zF_Q1IZ8kPEkuYGb5eB0,17
+loop_sdk/gen/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loop_sdk/gen/v1/__init__.pyi,sha256=ZB39-fKcvB-NOu0mP4hzuwEPAg2aHm_05ujLkC2YJyk,32
+loop_sdk/gen/v1/source_ingest_pb2.py,sha256=8tMD1vroTw7OYEAJDOWdjCsaPmrQliJsYj0O-2iC5AE,16814
+loop_sdk/gen/v1/source_ingest_pb2.pyi,sha256=iC8EPNlK4FCblJhMCa2BgsIrxLOLDHTDgz2nYuIbsFY,22688
+loop_sdk/gen/v1/source_ingest_pb2_grpc.py,sha256=duVbns_Ek0wJYTiJuEAaMjGDnT9lIdpBb9lFfgGu1zE,12543
+loop_sdk/source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loop_sdk/source/client.py,sha256=eJ_h3V_LI5m-EqJTtkko3bAMEFX81pKw_YQoIqwCNqU,4638
+loop_sdk/source/consumer.py,sha256=5NJAWvFblt80ZvEATN_JSBo2-guXhpyNz8rD8dmrEy8,1989
+loop_sdk/source/robot_step_sender.py,sha256=tzTvA4M723d7cCi4IusxP5-Tpsok-CyzaHORNvrd0qQ,19097
+loop_sdk/source/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loop_sdk/source/domain/config.py,sha256=7wpF6SHNooYOjcCYFqdN6w4O4ISy1HEj9NLI8_WzGWk,2458
+loop_sdk/source/domain/frame.py,sha256=8jXIX8rySsKiin6a4frnphbsvvLAvfkWRF5dvq5-mO0,3196
+loop_sdk/source/domain/schema.py,sha256=GbirnZMG4mgPlA7qKnMpepL6nz0GcePeAMZPUjdpAQU,6951
+loop_sdk/source/domain/source_exception.py,sha256=8RLo4HKQ1_YtuOPtBujyT8gpOa7as3WtFMWPMF_jrZQ,1684
+loop_sdk/source/domain/source_kind.py,sha256=qWkGqdTh5C5qQXQXmdL4SNHCiF_0M5qejNHrdBQ8Bvg,488
+loop_sdk/source/domain/stats.py,sha256=ne3f108hpKfgPmjbn1pKo__ZiOT5CvDy7SssoebD_wU,583
+loop_sdk/source/outbound/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loop_sdk/source/outbound/frame_queue.py,sha256=8QXd6YFT_Yk9x4Wq7NYgURKVb2IOcuSkI-DCerlg3_8,3056
+loop_sdk/source/outbound/grpc_source_client.py,sha256=4189bB6Tn20U_jbeE_ygZ7biFZjupccstOtSZQFu9io,15114
+loop_sdk/source/outbound/grpc_source_reader.py,sha256=JTaPrVgg5xxHis9bgWSYpNnw3O0ZOLlAoQ8WuWLN6RQ,3390
+loop_sdk/source/outbound/proto_mapping.py,sha256=FjuNTPrxhz42wsGq3rgcBZ-U7l7JcXdJNj9V6zVKjF4,9035
+loop_sdk/source/port/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loop_sdk/source/port/source_client.py,sha256=jfaf9Y2xF5dAgBZxJteguisPw4ks5lRHI2d59E38MVk,1944
+loop_sdk/source/port/source_reader.py,sha256=mNme2_18wrFa9Dk9D9Eb6PnuHHeGy8yTa67Wp3pU6Ek,1262
+loop_sdk/source/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loop_sdk/source/service/producer_session.py,sha256=XTAzjQibGwrNsCmge1uFVZfGdd1jBydHbK-FuATQwLI,3221
+loop_sdk/source/setup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loop_sdk/source/setup/config.py,sha256=PlR-txHA_n9P-PVBhhxgBtZXU_NwPnusREn2Z9AHTDs,1092
+loop_sdk-0.1.0.dist-info/METADATA,sha256=xeFRXv6Ji618e-1gWPsQGoe6piVZjGLUkb2DPeu4Qvk,275
+loop_sdk-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+loop_sdk-0.1.0.dist-info/RECORD,,

loop_sdk-0.1.0.dist-info/WHEEL

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