oep-client-python 0.0.1__py3-none-any.whl

oep_client/v1/message.py

@@ -0,0 +1,235 @@
+"""v1 messages (oep-spec docs/oep-core.ja.md §2-§5): the v0 request/result headers plus the session flag,
+and the §0 rules for what follows a payload's fixed part.
+
+  request : role(0x01) corr(u16) fn(u16) op(u8) payload
+            role(0x81) corr(u16) fn(u16) op(u8) session_id(u32) payload     role bit 7 = session_id present
+  result  : role(0x02) corr(u16) resolution(u8) detail(u8) payload
+
+§0 tails: after a result's fixed part (and any counted list) come TLVs (tag u8, len u8, value); the host skips tags it
+does not know and never rejects a longer result. A request may end with TLVs too; tag bit 7 = critical (the probe
+honours it or answers rejected unsupported with the tag), and the probe lists the non-critical tags it ignored in a
+result TLV 0x7F. Numbers come from `registry` (generated from oep-spec registry/oep-v1.toml).
+"""
+
+from __future__ import annotations
+
+import struct
+from dataclasses import dataclass, field
+
+from . import registry as reg
+
+ROLE_REQUEST, ROLE_RESULT = reg.ROLES["request"], reg.ROLES["result"]
+ROLE_EVENT, ROLE_DATA = reg.ROLES["event"], reg.ROLES["data"]
+ROLE_SESSION = reg.ROLE_SESSION_FLAG
+REQUEST_HEADER, RESULT_HEADER, SESSION_BYTES = 6, 5, 4
+
+REJECTED, COMPLETED, ACCEPTED = (reg.RESOLUTIONS[k] for k in ("rejected", "completed", "accepted"))
+SUCCESS, FAILED, PARTIAL = (reg.OUTCOMES[k] for k in ("success", "failed", "partial"))
+
+_R = reg.REJECT_REASONS
+UNKNOWN_FUNCTION = _R["unknown_function"]
+UNKNOWN_OPERATION = _R["unknown_operation"]
+MALFORMED = _R["malformed"]
+UNAVAILABLE = _R["unavailable"]
+BUSY = _R["busy"]                          # a long operation is running: answered at once
+WINDOW_EXCEEDED = _R["window_exceeded"]
+NO_SESSION = _R["no_session"]              # lock free, but this is not the last session id: open again
+LOCKED = _R["locked"]                      # another session holds the lock; payload = remaining ms (u32)
+SESSION_REQUIRED = _R["session_required"]  # a state-changing request came without a session id
+NO_CONNECTION = _R["no_connection"]        # the probe does not know the request's connection: attach again
+UNSUPPORTED = _R["unsupported"]            # a critical TLV (payload: its tag) or a fixed-part value it cannot handle
+RESULT_LOST = _R["result_lost"]            # a request sent again whose result the probe did not keep: read the state again
+CORR_REUSED = _R["corr_reused"]            # a request sent again with the same corr but another fn, op or payload
+
+REJECT_NAMES = {v: k.replace("_", " ") for k, v in _R.items()}
+REJECT_NAMES[MALFORMED] = "malformed payload"
+
+TAG_CRITICAL, TAG_IGNORED, TAG_INVALID = reg.TAG_CRITICAL, reg.TAG_IGNORED, reg.TAG_INVALID
+
+# core (fn 0) operations
+CORE_FN = 0
+_OP = reg.CORE.op
+OP_CONFIRM, OP_LIST, OP_DESCRIBE = _OP["confirm"], _OP["list"], _OP["describe"]
+OP_PLAN_APPLY, OP_PLAN_RELEASE = _OP["plan_apply"], _OP["plan_release"]
+OP_OPEN, OP_END, OP_KEEPALIVE, OP_LOCK_STATE = _OP["open"], _OP["end"], _OP["keepalive"], _OP["lock_state"]
+OP_SUBSCRIBE, OP_UNSUBSCRIBE = _OP["subscribe"], _OP["unsubscribe"]
+OP_LINK_SOURCE, OP_LINK_SINK = _OP["link_source"], _OP["link_sink"]
+
+CONFIRM_REQUEST = reg.CONFIRM_REQUEST_MAGIC.encode()
+CONFIRM_RESULT = reg.CONFIRM_RESULT_MAGIC.encode()
+
+
+class OepError(Exception):
+    """Anything the probe or the link said no to."""
+
+
+class ProtocolError(OepError, ValueError):
+    """A result that does not fit: wrong correlation, too short, a value this host does not know."""
+
+
+class ShortPayload(ProtocolError):
+    """A payload shorter than its fixed part, or a truncated TLV (a broken result, §0)."""
+
+
+@dataclass(frozen=True)
+class Request:
+    corr: int
+    fn: int
+    op: int
+    payload: bytes = b""
+    session: int | None = None
+
+    def pack(self) -> bytes:
+        if self.session is None:
+            return struct.pack("<BHHB", ROLE_REQUEST, self.corr, self.fn, self.op) + self.payload
+        return (struct.pack("<BHHBI", ROLE_REQUEST | ROLE_SESSION, self.corr, self.fn, self.op, self.session)
+                + self.payload)
+
+    @classmethod
+    def unpack(cls, data: bytes) -> Request:
+        if len(data) < REQUEST_HEADER:
+            raise ValueError("request shorter than its header")
+        role, corr, fn, op = struct.unpack_from("<BHHB", data)
+        if role & ~ROLE_SESSION != ROLE_REQUEST:
+            raise ValueError(f"not a request: role 0x{role:02x}")
+        if role & ROLE_SESSION:
+            if len(data) < REQUEST_HEADER + SESSION_BYTES:
+                raise ValueError("session flag set but no session id")
+            (session,) = struct.unpack_from("<I", data, REQUEST_HEADER)
+            return cls(corr, fn, op, data[REQUEST_HEADER + SESSION_BYTES:], session)
+        return cls(corr, fn, op, data[REQUEST_HEADER:], None)
+
+
+@dataclass(frozen=True)
+class Result:
+    corr: int
+    resolution: int
+    detail: int
+    payload: bytes = b""
+
+    def pack(self) -> bytes:
+        return struct.pack("<BHBB", ROLE_RESULT, self.corr, self.resolution, self.detail) + self.payload
+
+    @classmethod
+    def unpack(cls, data: bytes) -> Result:
+        if len(data) < RESULT_HEADER:
+            raise ShortPayload("result shorter than its header")
+        role, corr, resolution, detail = struct.unpack_from("<BHBB", data)
+        if role != ROLE_RESULT:
+            raise ValueError(f"not a result: role 0x{role:02x}")
+        return cls(corr, resolution, detail, data[RESULT_HEADER:])
+
+    @property
+    def succeeded(self) -> bool:
+        return self.resolution == COMPLETED and self.detail == SUCCESS
+
+    @property
+    def ran(self) -> bool:
+        """Completed with a known outcome (success, failed, partial): the payload has the op's result shape. An unknown
+        resolution or outcome is a failure whose payload means nothing (§0)."""
+        return self.resolution == COMPLETED and self.detail in (SUCCESS, FAILED, PARTIAL)
+
+    def describe(self) -> str:
+        if self.resolution == REJECTED:
+            return f"rejected: {REJECT_NAMES.get(self.detail, f'reason 0x{self.detail:02x}')}"
+        if self.resolution == ACCEPTED:
+            return "accepted"
+        if self.resolution != COMPLETED:
+            return f"unknown resolution 0x{self.resolution:02x}"
+        return {SUCCESS: "completed", FAILED: "failed", PARTIAL: "partial"}.get(self.detail,
+                                                                               f"unknown outcome 0x{self.detail:02x}")
+
+
+# ---- §0 TLV tails ------------------------------------------------------------------------------------------
+
+def tlv(tag: int, value: bytes, critical: bool = False) -> bytes:
+    """One TLV; `critical` sets tag bit 7 (a request argument the probe must honour or refuse)."""
+    if len(value) > 255:
+        raise ValueError(f"TLV 0x{tag:02x}: value of {len(value)} bytes does not fit")
+    if tag & 0x7F == TAG_IGNORED:
+        raise ValueError("tag 0x7F is reserved for the ignored list")
+    return bytes((tag | (TAG_CRITICAL if critical else 0), len(value))) + value
+
+
+def split_tlvs(data: bytes) -> list[tuple[int, bytes]]:
+    """TLVs in order. A truncated TLV raises ShortPayload (the result is broken)."""
+    pos, out = 0, []
+    while pos < len(data):
+        if pos + 2 > len(data):
+            raise ShortPayload("TLV: truncated header")
+        tag, n = data[pos], data[pos + 1]
+        if pos + 2 + n > len(data):
+            raise ShortPayload(f"TLV 0x{tag:02x}: truncated value")
+        out.append((tag, data[pos + 2:pos + 2 + n]))
+        pos += 2 + n
+    return out
+
+
+@dataclass
+class Tail:
+    """The TLVs after a result's known part: `tlvs` in order (unknown tags included, for whoever knows them), and
+    `ignored`, the non-critical request tags the probe said it ignored (TLV 0x7F)."""
+    tlvs: list[tuple[int, bytes]] = field(default_factory=list)
+    ignored: list[int] = field(default_factory=list)
+
+    def get(self, tag: int) -> bytes | None:
+        return next((v for t, v in self.tlvs if t == tag), None)
+
+    @classmethod
+    def parse(cls, data: bytes) -> Tail:
+        t = cls()
+        for tag, value in split_tlvs(data):
+            if tag == TAG_IGNORED:
+                t.ignored += list(value)
+            else:
+                t.tlvs.append((tag, value))
+        return t
+
+
+class Reader:
+    """Reads a result payload's fixed part front to back; too short -> ShortPayload. `tail()` then reads the rest as
+    §0 TLVs; `rest()` takes the rest as bytes (a result ending with a list of unknown length: nothing may follow)."""
+
+    def __init__(self, payload: bytes):
+        self.data, self.at = payload, 0
+
+    def take(self, fmt: str):
+        size = struct.calcsize("<" + fmt)
+        if self.at + size > len(self.data):
+            raise ShortPayload(f"payload of {len(self.data)} bytes: needs {self.at + size} for its fixed part")
+        values = struct.unpack_from("<" + fmt, self.data, self.at)
+        self.at += size
+        return values if len(values) > 1 else values[0]
+
+    def u8(self) -> int:
+        return self.take("B")
+
+    def u16(self) -> int:
+        return self.take("H")
+
+    def u32(self) -> int:
+        return self.take("I")
+
+    def bytes(self, n: int) -> bytes:
+        if self.at + n > len(self.data):
+            raise ShortPayload(f"payload of {len(self.data)} bytes: needs {self.at + n}")
+        out = self.data[self.at:self.at + n]
+        self.at += n
+        return out
+
+    def words(self, n: int) -> list[int]:
+        return list(struct.unpack(f"<{n}I", self.bytes(4 * n)))
+
+    def rest(self) -> bytes:
+        out = self.data[self.at:]
+        self.at = len(self.data)
+        return out
+
+    def tail(self) -> Tail:
+        return Tail.parse(self.rest())
+
+
+def serial_diff(a: int, b: int, bits: int = 32) -> int:
+    """a - b for values that wrap (positions u32, seq u16, µs u32): the difference as a signed number of `bits` (§0)."""
+    d = (a - b) & ((1 << bits) - 1)
+    return d - (1 << bits) if d >> (bits - 1) else d

oep_client/v1/names.py

@@ -0,0 +1,86 @@
+"""Interface names (oep-spec docs/capability-identification-comparison.ja.md, draft).
+
+A name is dot-separated labels of lowercase ASCII letters, digits and '-', at most 48 bytes. The
+first label says which kind of namespace it is:
+
+  oep.                      the OEP standard (reserved; `oep` is not a real top-level domain)
+  local.                    bench-only experiments, never published, no interoperability promise
+  uuid.<32 hex>.            an author with no domain who still wants a unique namespace
+  <tld>.<domain>...         reverse DNS of a domain the author owns, including hosting domains
+                            such as io.github.<name> (GitHub gives <name>.github.io to one owner)
+"""
+
+from __future__ import annotations
+
+import re
+
+MAX_NAME = 48
+_LABEL = re.compile(r"[a-z0-9-]+\Z")
+_TLD = re.compile(r"[a-z]{2,63}\Z")
+_UUID = re.compile(r"[0-9a-f]{32}\Z")
+
+
+class InvalidName(ValueError):
+    pass
+
+
+def kind(name: str) -> str:
+    """'standard', 'local', 'uuid' or 'domain' - after validate()."""
+    first = name.split(".", 1)[0]
+    return {"oep": "standard", "local": "local", "uuid": "uuid"}.get(first, "domain")
+
+
+def validate(name: str) -> str:
+    """Return the name, or raise InvalidName saying which rule it breaks."""
+    raw = name.encode("ascii", "strict") if name.isascii() else None
+    if raw is None:
+        raise InvalidName(f"{name!r}: not ASCII")
+    if len(raw) > MAX_NAME:
+        raise InvalidName(f"{name!r}: {len(raw)} bytes, the limit is {MAX_NAME}")
+    labels = name.split(".")
+    if len(labels) < 2:
+        raise InvalidName(f"{name!r}: needs a namespace and at least one more label")
+    for label in labels:
+        if not _LABEL.match(label):
+            raise InvalidName(f"{name!r}: label {label!r} is not [a-z0-9-]+")
+    first = labels[0]
+    if first == "uuid":
+        if len(labels) < 3 or not _UUID.match(labels[1]):
+            raise InvalidName(f"{name!r}: uuid. must be followed by 32 lowercase hex digits and a name")
+    elif first not in ("oep", "local"):
+        if not _TLD.match(first):
+            raise InvalidName(f"{name!r}: {first!r} is not a top-level domain (reverse DNS expected)")
+        if len(labels) < 3:
+            raise InvalidName(f"{name!r}: reverse DNS needs <tld>.<domain>.<name>")
+    return name
+
+
+# Hosting services whose domain is often written wrongly as a top level. Whether a first label
+# is a real top-level domain is not checked (that needs the IANA list); these are the common slips.
+_HOSTING = {"github": "io.github", "gitlab": "io.gitlab", "codeberg": "page.codeberg",
+            "bitbucket": "io.bitbucket"}
+
+
+def lint(name: str) -> list[str]:
+    """Warnings for names that are well-formed but break the namespace rules in spirit."""
+    labels = name.split(".")
+    out = []
+    if labels[0] in _HOSTING:
+        out.append(f"{labels[0]!r} is not a top-level domain; a {labels[0]} account's namespace is "
+                   f"{_HOSTING[labels[0]]}.{labels[1] if len(labels) > 1 else '<name>'}")
+    if labels[0] == "com" and len(labels) > 1 and labels[1] in _HOSTING:
+        out.append(f"com.{labels[1]} is not given to accounts; use {_HOSTING[labels[1]]}.<name>")
+    return out
+
+
+def matches(name: str, prefix: str, exact: bool) -> bool:
+    """List filtering: an empty prefix matches everything; otherwise match on label boundaries.
+
+    oep.fixture.uart matches oep.fixture.uart and oep.fixture.uart.stream, not oep.fixture.uart2;
+    with exact, only oep.fixture.uart itself.
+    """
+    if not prefix:
+        return not exact
+    if exact:
+        return name == prefix
+    return name == prefix or name.startswith(prefix + ".")

oep_client/v1/registry.py

@@ -0,0 +1,59 @@
+"""Generated by oep-spec tools/oepgen1.py from registry/oep-v1.toml - do not edit."""
+
+from types import SimpleNamespace as _NS
+
+REGISTRY_HASH = "7ba704094c2898d2"
+SCHEMA = 1
+PROTOCOL_REVISION = 1
+CONFIRM_REQUEST_MAGIC = 'OEP?'
+CONFIRM_RESULT_MAGIC = 'OEP!'
+ROLE_SESSION_FLAG = 0x80
+TAG_CRITICAL = 0x80
+TAG_IGNORED = 0x7F
+TAG_INVALID = 0xFF
+MIN_MAX_FRAME = 0x40
+ROLES = {"request": 0x01, "result": 0x02, "event": 0x05, "data": 0x06}
+RESOLUTIONS = {"rejected": 0x00, "completed": 0x01, "accepted": 0x02}
+OUTCOMES = {"success": 0x00, "failed": 0x01, "partial": 0x02}
+REJECT_REASONS = {"unknown_function": 0x01, "unknown_operation": 0x02, "malformed": 0x03, "unavailable": 0x04, "busy": 0x05, "window_exceeded": 0x06, "no_session": 0x07, "locked": 0x08, "session_required": 0x09, "no_connection": 0x0A, "unsupported": 0x0B, "result_lost": 0x0C, "corr_reused": 0x0D}
+STATUS = {"ok": 0x00, "wait": 0x01, "line": 0x02, "fault": 0x03, "timeout": 0x04, "state": 0x05}
+DESCRIBE_COMMON = {"role_channels": 0x01, "max_clock_hz": 0x02, "max_length": 0x03, "min_clock_hz": 0x05, "features": 0x06, "implementation": 0x07, "channel_group": 0x08}
+TIMING = {"resync_quiet_ms": 0x32, "probe_frame_gap_ms": 0xC8, "host_frame_pause_max_ms": 0x64, "heartbeat_default_ms": 0x3E8}
+
+INTERFACES = {}
+CORE = _NS(name="oep.core", revision=1, op={"confirm": 0x01, "list": 0x02, "describe": 0x03, "plan_apply": 0x04, "plan_release": 0x05, "open": 0x10, "end": 0x11, "keepalive": 0x12, "lock_state": 0x13, "subscribe": 0x30, "unsubscribe": 0x32, "link_source": 0x40, "link_sink": 0x41}, lock_free={0x01, 0x02, 0x03, 0x10, 0x13, 0x40, 0x41},
+    closed_tail={0x40}, tlv={"plan_apply": {"role_assignment": 0x90}, "open": {"owner": 0x01}, "lock_state_answer": {"owner": 0x01}, "locked_payload": {"owner": 0x01}, "describe": {"firmware": 0x40, "model": 0x41, "unit_id": 0x42, "channels": 0x43, "reserved": 0x44, "profile": 0x45, "label": 0x46, "resets_on_open": 0x47, "transport": 0x49, "oep_pid": 0x4A}}, event={"heartbeat": 0x01}, enum={"transport_kind": {"uart_bridge": 0x01, "usb_cdc": 0x02, "usb_serial_jtag": 0x03, "vendor_bulk": 0x04, "hid": 0x05, "tcp": 0x06}}, own={})
+INTERFACES["oep.core"] = CORE
+WIRE_RVSWD = _NS(name="oep.wire.rvswd", revision=1, op={"scan": 0x01, "attach": 0x02, "detach": 0x03, "attach_under_reset": 0x04, "connections": 0x05}, lock_free={0x05},
+    closed_tail={}, tlv={"describe": {"max_connections": 0x40}, "detach": {"force": 0x01}, "attach": {"max_speed": 0x01, "pins": 0x03}, "attach_under_reset": {"max_speed": 0x01, "pins": 0x03}, "attach_answer": {"target_id": 0x10}}, event={}, enum={"connection_users": {"host_session": 0x01, "slot": 0x02}, "target_id_scheme": {"wch_dmi_7f": 0x01}, "attach_method": {"run": 0x00, "halt": 0x01}, "pin_role": {"swdio": 0x01, "swclk": 0x02}}, own={})
+INTERFACES["oep.wire.rvswd"] = WIRE_RVSWD
+WIRE_SWIO = _NS(name="oep.wire.swio", revision=1, op={"scan": 0x01, "attach": 0x02, "detach": 0x03, "attach_under_reset": 0x04, "connections": 0x05}, lock_free={0x05},
+    closed_tail={}, tlv={"describe": {"max_connections": 0x40}, "detach": {"force": 0x01}, "attach": {"max_speed": 0x01, "pins": 0x03}, "attach_under_reset": {"max_speed": 0x01, "pins": 0x03}, "attach_answer": {"target_id": 0x10}}, event={}, enum={"connection_users": {"host_session": 0x01, "slot": 0x02}, "target_id_scheme": {"wch_dmi_7f": 0x01}, "attach_method": {"run": 0x00, "halt": 0x01}, "pin_role": {"swdio": 0x01}}, own={})
+INTERFACES["oep.wire.swio"] = WIRE_SWIO
+WIRE_SWD = _NS(name="oep.wire.swd", revision=1, op={"scan": 0x01, "attach": 0x02, "detach": 0x03, "connections": 0x05}, lock_free={0x05},
+    closed_tail={}, tlv={"describe": {"max_connections": 0x40}, "detach": {"force": 0x01}, "attach": {"max_speed": 0x01, "targetsel": 0x02, "pins": 0x03}}, event={}, enum={"connection_users": {"host_session": 0x01, "slot": 0x02}, "pin_role": {"swdio": 0x01, "swclk": 0x02}}, own={})
+INTERFACES["oep.wire.swd"] = WIRE_SWD
+TARGET_RISCV_DM = _NS(name="oep.target.riscv-dm", revision=1, op={"dmi": 0x01, "halt": 0x02, "resume": 0x03, "reset": 0x04, "read_block": 0x05, "write_block": 0x06, "run": 0x07, "step": 0x08}, lock_free={},
+    closed_tail={}, tlv={"describe": {"clobbers": 0x40}, "reset": {"method": 0x01}}, event={}, enum={"dmi_step": {"write": 0x01, "read": 0x02, "poll_reads": 0x03, "wait_us": 0x04, "poll_us": 0x05}, "reset_mode": {"run": 0x00, "run_verified": 0x01, "halt_at_reset": 0x02}, "reset_method": {"probe_default": 0x00, "ndmreset": 0x01, "system_reset": 0x02}}, own={})
+INTERFACES["oep.target.riscv-dm"] = TARGET_RISCV_DM
+TARGET_ARM_ADI = _NS(name="oep.target.arm-adi", revision=1, op={"transfer": 0x01, "read_block": 0x02, "write_block": 0x03}, lock_free={},
+    closed_tail={}, tlv={}, event={}, enum={}, own={})
+INTERFACES["oep.target.arm-adi"] = TARGET_ARM_ADI
+TARGET_CONSOLE = _NS(name="oep.target.console", revision=1, op={"open": 0x01, "read": 0x02, "marks": 0x03, "clear": 0x04, "mark": 0x05, "write": 0x06, "close": 0x07}, lock_free={0x02, 0x03},
+    closed_tail={0x02}, tlv={"describe": {"mechanisms": 0x40}}, event={}, enum={"mechanism": {"sdi": 0x00, "dmdata": 0x01, "dmseq": 0x02}, "read_from": {"position": 0x00, "oldest": 0x01, "now": 0x02, "last_mark": 0x03}, "mark_kind": {"reset": 0x01, "restart": 0x02, "attach": 0x03, "detach": 0x04, "lost": 0x05, "clear": 0x06, "host": 0x07, "link_lost": 0x08}}, own={})
+INTERFACES["oep.target.console"] = TARGET_CONSOLE
+FIXTURE_GPIO = _NS(name="oep.fixture.gpio", revision=1, op={"set": 0x01, "read": 0x02}, lock_free={0x02},
+    closed_tail={}, tlv={"describe": {"modes": 0x40}}, event={}, enum={"role": {"line": 0x01}, "mode": {"input": 0x00, "input_pullup": 0x01, "input_pulldown": 0x02, "output_low": 0x03, "output_high": 0x04, "open_drain_low": 0x05, "open_drain_release": 0x06, "input_pullup_pulldown": 0x07}}, own={})
+INTERFACES["oep.fixture.gpio"] = FIXTURE_GPIO
+FIXTURE_UART = _NS(name="oep.fixture.uart", revision=1, op={"configure": 0x01, "read": 0x02, "marks": 0x03, "clear": 0x04, "mark": 0x05, "write": 0x06}, lock_free={0x02, 0x03},
+    closed_tail={0x02}, tlv={"configure": {"format": 0x01}, "describe": {"formats": 0x40}}, event={}, enum={"role": {"rx": 0x01, "tx": 0x02}}, own={})
+INTERFACES["oep.fixture.uart"] = FIXTURE_UART
+FIXTURE_CAPTURE = _NS(name="oep.fixture.capture", revision=1, op={"configure": 0x01, "start": 0x02, "stop": 0x03, "force": 0x04, "status": 0x05, "read": 0x06, "segments": 0x07, "release": 0x08, "query": 0x09}, lock_free={0x05, 0x06, 0x07, 0x09},
+    closed_tail={0x06}, tlv={"configure": {"mode": 0x40, "rate": 0x42, "samples": 0x43, "segments": 0x44, "trigger": 0x45, "pretrigger": 0x46, "frontend": 0x47}, "configure_answer": {"actual_rate": 0x50, "layout": 0x51, "actual_samples": 0x52, "actual_segments": 0x53, "timing": 0x54, "scale": 0x55, "blocking_ms": 0x56, "skew": 0x57}, "describe": {"mode": 0x40, "rate_range": 0x41, "rate_list": 0x42, "rate_limit": 0x43, "channels": 0x44, "trigger": 0x45, "frontend": 0x46, "max_read": 0x47, "segment_ring": 0x48, "frontend_shared": 0x49}}, event={"segment": 0x01, "stopped": 0x02, "triggered": 0x03}, enum={"mode": {"one_shot": 0x01, "repeat": 0x02, "streaming": 0x03}, "trigger": {"immediate": 0x00, "level": 0x01, "edge": 0x02, "cross_up": 0x03, "cross_down": 0x04}, "state": {"unconfigured": 0x00, "configured": 0x01, "waiting": 0x02, "capturing": 0x03, "done": 0x04, "paused": 0x05, "error": 0x06}, "stopped_reason": {"complete": 0x00, "host": 0x01, "no_free_segment": 0x02, "error": 0x03}, "segment_flag": {"gap": 0x01, "short": 0x02, "slipped": 0x04}}, own={})
+INTERFACES["oep.fixture.capture"] = FIXTURE_CAPTURE
+FIXTURE_ANALOG = _NS(name="oep.fixture.analog", revision=1, op={"configure": 0x01, "start": 0x02, "stop": 0x03, "force": 0x04, "status": 0x05, "read": 0x06, "segments": 0x07, "release": 0x08, "query": 0x09}, lock_free={0x05, 0x06, 0x07, 0x09},
+    closed_tail={0x06}, tlv={"configure": {"mode": 0x40, "rate": 0x42, "samples": 0x43, "segments": 0x44, "trigger": 0x45, "pretrigger": 0x46, "frontend": 0x47}, "configure_answer": {"actual_rate": 0x50, "layout": 0x51, "actual_samples": 0x52, "actual_segments": 0x53, "timing": 0x54, "scale": 0x55, "blocking_ms": 0x56, "skew": 0x57}, "describe": {"mode": 0x40, "rate_range": 0x41, "rate_list": 0x42, "rate_limit": 0x43, "channels": 0x44, "trigger": 0x45, "frontend": 0x46, "max_read": 0x47, "segment_ring": 0x48, "frontend_shared": 0x49}}, event={"segment": 0x01, "stopped": 0x02, "triggered": 0x03}, enum={"mode": {"one_shot": 0x01, "repeat": 0x02, "streaming": 0x03}, "trigger": {"immediate": 0x00, "level": 0x01, "edge": 0x02, "cross_up": 0x03, "cross_down": 0x04}, "state": {"unconfigured": 0x00, "configured": 0x01, "waiting": 0x02, "capturing": 0x03, "done": 0x04, "paused": 0x05, "error": 0x06}, "stopped_reason": {"complete": 0x00, "host": 0x01, "no_free_segment": 0x02, "error": 0x03}, "segment_flag": {"gap": 0x01, "short": 0x02, "slipped": 0x04}}, own={})
+INTERFACES["oep.fixture.analog"] = FIXTURE_ANALOG
+PROBE_CONFIG = _NS(name="oep.probe.config", revision=1, op={"get": 0x01, "set": 0x02, "save": 0x03, "erase": 0x04}, lock_free={0x01},
+    closed_tail={}, tlv={"item": {"plan": 0x01, "label": 0x02, "idle": 0x03, "slot": 0x04, "bind": 0x05}, "describe": {"storage": 0x40, "items": 0x41, "slots_max": 0x42, "bind_modes": 0x43, "slot_state": 0x44, "bind_state": 0x45}}, event={}, enum={"idle_mode": {"hi_z": 0x00, "pull_up": 0x01, "pull_down": 0x02}, "slot_attach": {"host": 0x00, "at_boot": 0x01}, "slot_state": {"connected": 0x00, "absent": 0x01, "lock_mismatch": 0x02, "no_target_id": 0x03}, "bind_mode": {"last_reset": 0x00, "manual": 0x01, "mixed": 0x02}, "bind_stream": {"slot_console": 0x01, "fixture_uart": 0x02}, "bind_flow": {"idle": 0x00, "streaming": 0x01, "held": 0x02}, "storage_state": {"none": 0x00, "applied": 0x01, "unreadable": 0x02}}, own={})
+INTERFACES["oep.probe.config"] = PROBE_CONFIG