oep-client-python 0.0.53__py3-none-any.whl → 0.0.54__py3-none-any.whl

oep_client/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.0.53"
+__version__ = "0.0.54"

oep_client/__main__.py

@@ -125,6 +125,17 @@ def main(argv=None) -> int:
     rs.add_argument("--reopen-s", type=float, default=0.0, metavar="S",
                     help="when the probe is not back within its restart_max_ms, open it again for up to S more seconds "
                          "(your reopen: a host where the device returns late, e.g. WSL re-attaching it through usbipd)")
+    ca = sub.add_parser("call", help="run any interface's op: by number with the request as hex bytes, or by the name and "
+                                     "fields its describe gives (core §7.4 op_name / op_field)")
+    ca.add_argument("probe", help="a probe: oep://UNIT_ID[?via=...], a serial port, tcp://HOST:PORT or usb")
+    ca.add_argument("interface", help="the interface's name (io.github.you.thing); its fn is looked up")
+    ca.add_argument("op", help="the op: a number (0x10) or its name")
+    ca.add_argument("args", nargs="*", help="NAME=VALUE per field (integers 10 or 0x, bools true / false, lists 1,2,3, "
+                                             "bytes hex, text as it is), or the request as hex bytes")
+    ca.add_argument("--text", action="store_true", help="the request is ARGS joined by spaces, as UTF-8 bytes")
+    ca.add_argument("--wait", type=float, metavar="S", help="the op is a job (oep::SimpleInterface::job): wait up to S "
+                                                            "seconds for it by the interface's status op, then show that")
+    ca.add_argument("--json", action="store_true")
     fd = sub.add_parser("find", help="probes on the local network that announce _oep._tcp (DNS-SD over mDNS)")
     fd.add_argument("--timeout", type=float, default=2.0, help="seconds to listen for answers (default 2)")
     fd.add_argument("--engine", choices=("auto", "zeroconf", "minimal"), default="auto",
@@ -157,6 +168,8 @@ def main(argv=None) -> int:
         return _restart_cmd(args)
     if args.command == "find":
         return _find_cmd(args)
+    if args.command == "call":
+        return _call_cmd(args)
 
     confirm = (0, 1)
     if args.virtual:
@@ -237,6 +250,82 @@ def _restart_cmd(args) -> int:
     return 0
 
 
+# ---- oep call -----------------------------------------------------------------------------------------------------
+
+def _field_value(field, text: str):
+    from . import call as c
+    t = field.type
+    if t & c.LIST:
+        items = [x for x in text.replace(" ", "").split(",") if x]
+        return [(x.lower() in ("1", "true")) if (t & ~c.LIST) == c.T["bool"] else int(x, 0) for x in items]
+    if t == c.T["bool"]:
+        if text.lower() not in ("0", "1", "true", "false"):
+            raise SystemExit(f"oep call: {field.name} takes true or false")
+        return text.lower() in ("1", "true")
+    if t == c.T["bytes"]:
+        return bytes.fromhex(text)
+    if t == c.T["text"]:
+        return text
+    return int(text, 0)
+
+
+def _call_cmd(args) -> int:
+    import json
+    from . import call as c
+    hst = _open_host(args.probe)
+    try:
+        forms = c.ops(hst, args.interface)
+    except c.NotOffered as e:
+        raise SystemExit(f"oep call: {e}") from None
+    op: int | str = int(args.op, 0) if args.op[:1].isdigit() else args.op
+    form = forms.get(op) if isinstance(op, int) else next((f for f in forms.values() if f.name == op), None)
+    payload, fields = None, {}
+    if args.text:
+        payload = " ".join(args.args).encode()
+    elif form is not None and form.form and (any("=" in a for a in args.args) or not args.args):
+        by_name = {f.name: f for f in form.request}
+        for item in args.args:
+            name, eq, value = item.partition("=")
+            if not eq or name not in by_name:
+                raise SystemExit(f"oep call: {form.signature()}: give NAME=VALUE for its fields ({item!r})")
+            fields[name] = _field_value(by_name[name], value)
+    else:
+        try:
+            payload = bytes.fromhex("".join(args.args))
+        except ValueError:
+            raise SystemExit("oep call: the request as hex bytes (its describe gives this op no fields)") from None
+    if not (form is not None and form.lock_free):
+        core.take(hst, 10000 + int((args.wait or 0) * 1000), owner="oep call")   # a job's wait inside the lease
+    try:
+        if args.wait is not None:
+            r = c.call_wait(hst, args.interface, op, payload, timeout=args.wait, **fields)
+        else:
+            r = c.call(hst, args.interface, op, payload, **fields)
+    except (c.JobFailed, c.JobCancelled, c.JobTimeout, c.ProbeRestarted) as e:
+        st = getattr(e, "status", {})
+        print(json.dumps({"result": type(e).__name__, "why": str(e), "status": st}, default=str) if args.json
+              else f"{type(e).__name__}  {e}")
+        return 1
+    except TypeError as e:
+        raise SystemExit(f"oep call: {e}") from None
+    except c.NotOffered as e:
+        raise SystemExit(f"oep call: {e}") from None
+    except c.CommandFailed as e:
+        out = {"result": "failed", "op": e.op, "fields": e.fields, "payload": e.payload.hex()}
+        print(json.dumps(out, default=str) if args.json else f"failed  {e}" + ("" if e.fields else f"  {e.payload.hex()}"))
+        return 1
+    except c.CommandRejected as e:
+        print(json.dumps({"result": "rejected", "op": e.op, "why": str(e)}) if args.json else f"rejected  {e}")
+        return 1
+    shown = {k: (v.hex() if isinstance(v, bytes) else v) for k, v in r.items()}
+    if args.json:
+        print(json.dumps({"result": "completed", "revision": r.revision, "fields": shown, "payload": r.payload.hex()}))
+    else:
+        body = "  ".join(f"{k}={v}" for k, v in shown.items()) if shown or (form and form.form) else r.payload.hex()
+        print(f"completed  rev {r.revision}  {body}".rstrip())
+    return 0
+
+
 # ---- oep pins -----------------------------------------------------------------------------------------------------
 
 def _pins_cmd(args) -> int:

oep_client/call.py

@@ -0,0 +1,284 @@
+"""Call any interface's op by its number, or by the name and fields its describe gives (oep-core §7.4 op_name /
+op_field) - an interface this host has no module for, such as a sketch's oep::SimpleInterface.
+
+    from oep_client import link, core
+    from oep_client.call import call
+    hst = link.open_host("/dev/ttyACM0")
+    core.take(hst, 10000, owner="my-test")
+    r = call(hst, "io.github.yourname.mine", "add", a=2, b=3)
+    r["sum"], r.sum, r.revision                     # the success fields by name; the interface's revision
+    call(hst, "io.github.yourname.mine", 0x10, b"\\x02\\0\\0\\0\\x03\\0\\0\\0").payload   # by number, the bytes as they are
+
+Errors: InterfaceMissing / RevisionMismatch / OpMissing (all NotOffered: a test can turn them into a skip),
+CommandRejected (the probe refused it: the reason), CommandFailed (completed failed: code and message when the op
+gives them).
+
+A job (oep::SimpleInterface::job: it starts work on the probe's worker and answers at once) and its status op:
+
+    st = call_wait(hst, "io.github.yourname.mine", "collect", count=3, timeout=10)
+    st.start_ns, st.end_ns                          # on the probe's clock (a capture's markers' one)
+    # wait=: a stream's wait (acquire.Request(during=...)) keeps the capture collecting while this waits
+
+JobFailed (the job's Worker::fail: code, message), JobCancelled, JobTimeout (cancel sent first), ProbeRestarted (its
+boot_id changed while the job ran)."""
+
+from __future__ import annotations
+
+import struct
+import time
+from typing import Any, Callable
+
+from . import catalog, core, host as h
+
+T = catalog.OP_FIELD_TYPES
+LIST = catalog.OP_FIELD_LIST
+_INT = {T["u8"]: "<B", T["u16"]: "<H", T["u32"]: "<I", T["u64"]: "<Q",
+        T["i8"]: "<b", T["i16"]: "<h", T["i32"]: "<i", T["i64"]: "<q", T["bool"]: "<B"}
+
+
+class NotOffered(LookupError):
+    """The probe does not offer what was asked: no such interface, another revision, no such op."""
+
+
+class InterfaceMissing(NotOffered):
+    pass
+
+
+class RevisionMismatch(NotOffered):
+    def __init__(self, interface: str, revision: int, wanted: int):
+        super().__init__(f"{interface} is revision {revision} on this probe, {wanted} asked")
+        self.revision, self.wanted = revision, wanted
+
+
+class OpMissing(NotOffered):
+    pass
+
+
+class CommandRejected(h.Rejected):
+    """The probe refused the op (resolution rejected): `result.detail` is the reason (core §4.3)."""
+
+    def __init__(self, op: str, result):
+        super().__init__(result)
+        self.op = op
+        self.args = (f"{op}: {result.describe()}",)
+
+
+class CommandFailed(h.Failed):
+    """The op ran and did not work (completed failed / partial): `fields` the failed part decoded (code, message for
+    an oep::SimpleInterface op), `payload` the bytes."""
+
+    def __init__(self, op: str, result, fields: dict | None):
+        why = f"{op}: {result.describe()}"
+        if fields and "code" in fields:
+            why += f" (code {fields['code']}" + (f": {fields['message']}" if fields.get("message") else "") + ")"
+        super().__init__(result, why)
+        self.op, self.fields, self.payload = op, fields or {}, result.payload
+        self.code, self.message = self.fields.get("code"), self.fields.get("message")
+
+
+class JobFailed(h.OepError):
+    """The job ended failed: `code` and `message` from its Worker::fail(), `status` the status op's fields."""
+
+    def __init__(self, op: str, status: dict):
+        super().__init__(f"{op}: failed (code {status.get('code')}"
+                         + (f": {status['message']}" if status.get("message") else "") + ")")
+        self.op, self.status, self.code, self.message = op, status, status.get("code"), status.get("message")
+
+
+class JobCancelled(h.OepError):
+    """The job stopped on a cancel (`status` the status op's fields)."""
+
+    def __init__(self, op: str, status: dict):
+        super().__init__(f"{op}: cancelled")
+        self.op, self.status = op, status
+
+
+class JobTimeout(h.OepError, TimeoutError):
+    """The job still ran at the timeout; a cancel was sent (`status` the last status op's fields)."""
+
+    def __init__(self, op: str, timeout: float, status: dict):
+        super().__init__(f"{op}: still running after {timeout} s (cancel sent)")
+        self.op, self.status = op, status
+
+
+class ProbeRestarted(h.OepError):
+    """The probe's boot_id changed while the job ran (core §6.5): it restarted, the job with it."""
+
+
+# The status op's state (oep::Worker::State): the firmware's convention, not the registry's
+JOB_STATES = {"idle": 0, "running": 1, "done": 2, "failed": 3, "cancelled": 4}
+
+
+class CallResult(dict):
+    """The success fields by name (a dict, and attributes), the raw payload, the interface's revision and the op."""
+
+    def __init__(self, fields: dict, payload: bytes, revision: int, op: catalog.OpForm | int):
+        super().__init__(fields)
+        self.payload, self.revision, self.op = payload, revision, op
+
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(name) from None
+
+
+def encode(fields: list[catalog.OpField], values: dict) -> bytes:
+    """A request's fixed part from values by field name (ints, bools, bytes, str, lists of ints / bools)."""
+    missing = [f.name for f in fields if f.name not in values]
+    extra = sorted(set(values) - {f.name for f in fields})
+    if missing or extra:
+        raise TypeError(f"fields {', '.join(f'{f.name}: {f.type_name}' for f in fields) or 'none'}"
+                        + (f"; missing {missing}" if missing else "") + (f"; not fields {extra}" if extra else ""))
+    out = b""
+    for f in fields:
+        v = values[f.name]
+        if f.type & LIST:
+            items = list(v)
+            out += struct.pack("<H", len(items)) + b"".join(struct.pack(_INT[f.type & ~LIST], int(x)) for x in items)
+        elif f.type == T["bytes"]:
+            b = bytes(v)
+            out += struct.pack("<H", len(b)) + b
+        elif f.type == T["text"]:
+            b = str(v).encode()
+            out += struct.pack("<H", len(b)) + b
+        elif f.type in _INT:
+            out += struct.pack(_INT[f.type], int(v))
+        else:
+            raise TypeError(f"{f.name}: type {f.type} unknown to this host")
+    return out
+
+
+def decode(fields: list[catalog.OpField], payload: bytes) -> tuple[dict, bytes]:
+    """A fixed part's fields by name, and what follows them (the TLVs)."""
+    out, at = {}, 0
+    for f in fields:
+        if f.type & LIST:
+            (n,) = struct.unpack_from("<H", payload, at)
+            fmt = _INT[f.type & ~LIST]
+            w = struct.calcsize(fmt)
+            vals = [struct.unpack_from(fmt, payload, at + 2 + i * w)[0] for i in range(n)]
+            out[f.name] = [bool(x) for x in vals] if (f.type & ~LIST) == T["bool"] else vals
+            at += 2 + n * w
+        elif f.type in (T["bytes"], T["text"]):
+            (n,) = struct.unpack_from("<H", payload, at)
+            if at + 2 + n > len(payload):
+                raise h.ShortPayload(f"{f.name}: {n} bytes, the answer ends before")
+            raw = payload[at + 2:at + 2 + n]
+            out[f.name] = raw.decode("utf-8", "replace") if f.type == T["text"] else raw
+            at += 2 + n
+        else:
+            fmt = _INT[f.type]
+            out[f.name] = struct.unpack_from(fmt, payload, at)[0]
+            if f.type == T["bool"]:
+                out[f.name] = bool(out[f.name])
+            at += struct.calcsize(fmt)
+    return out, payload[at:]
+
+
+def ops(hst: h.Host, interface: str | int) -> dict[int, catalog.OpForm]:
+    """The op_name / op_field an interface's describe gives (by op number; empty when it gives none)."""
+    fn = interface if isinstance(interface, int) else _fn(hst, interface)
+    return catalog.decode_description(b"".join(catalog.tlv(t, v) for t, v in core.describe(hst, fn))).op_forms
+
+
+def _fn(hst: h.Host, interface: str) -> int:
+    try:
+        return core.find(hst, interface)
+    except LookupError as e:
+        raise InterfaceMissing(str(e)) from None
+
+
+def call(hst: h.Host, interface: str, op: int | str, payload: bytes | None = None, *, locked: bool | None = None,
+         revision: int | None = None, expect_ms: int = 0, **fields) -> CallResult:
+    """Run `op` (a number, or a name from the describe's op_name) of `interface` on the session `hst` holds.
+    payload: the request as bytes (then no fields); otherwise the fields by name, packed as op_field says.
+    locked: send it in the session (default: unless op_name says lock_free). revision: the one expected."""
+    fn = _fn(hst, interface)
+    rev = core.revision(hst, interface, fn)
+    if revision is not None and rev != revision:
+        raise RevisionMismatch(interface, rev, revision)
+    forms = ops(hst, fn)
+    if isinstance(op, str):
+        form = next((f for f in forms.values() if f.name == op), None)
+        if form is None:
+            raise OpMissing(f"{interface} has no op named {op!r}" + (f" (it names {', '.join(f.name for f in forms.values())})"
+                                                                     if forms else " (its describe names none)"))
+        code = form.op
+    else:
+        code, form = op, forms.get(op)
+    label = form.name if form else f"0x{code:02x}"
+    if not core.offers(hst, fn, code):
+        raise OpMissing(f"{interface} does not offer op {label}")
+    if payload is None:
+        if fields:
+            if form is None or not form.form:
+                raise TypeError(f"{interface} {label}: its describe gives no fields; pass payload= as bytes")
+            payload = encode(form.request, fields)
+        elif form is not None and form.form and form.request:
+            payload = encode(form.request, fields)        # raises: the fields it needs
+        else:
+            payload = b""
+    elif fields:
+        raise TypeError("payload= or fields, not both")
+    if locked is None:
+        locked = not (form is not None and form.lock_free)
+    try:
+        r = hst.request(fn, code, payload, locked=locked, expect_ms=expect_ms)
+    except h.Rejected as e:
+        raise CommandRejected(label, e.result) from None
+    if r.succeeded:
+        got = decode(form.success, r.payload)[0] if form is not None and form.form else {}
+        return CallResult(got, r.payload, rev, form or code)
+    failed = None
+    if r.ran and form is not None and form.form and form.failed:
+        try:
+            failed = decode(form.failed, r.payload)[0]
+        except (struct.error, h.ShortPayload):
+            failed = None                                  # a failed answer without its fields (a firmware bug)
+    raise CommandFailed(label, r, failed)
+
+
+def call_wait(hst: h.Host, interface: str, op: int | str, payload: bytes | None = None, *, timeout: float,
+              wait: Callable[[float], None] | None = None, interval: float = 0.05, status: str = "status",
+              cancel: str = "cancel", revision: int | None = None, **fields) -> CallResult:
+    """Start the job `op` (as call()) and wait for it by its `status` op: the status's fields when it ended done.
+    wait(seconds) sleeps between the status reads (time.sleep by default; a stream's wait keeps a capture going)."""
+    boot = hst.clock().boot_id
+    started = call(hst, interface, op, payload, revision=revision, **fields)
+    code = started.op.op if isinstance(started.op, catalog.OpForm) else started.op
+    label = started.op.name if isinstance(started.op, catalog.OpForm) else f"0x{code:02x}"
+    pause = wait or time.sleep
+    deadline = time.monotonic() + timeout
+    while True:
+        try:
+            st = call(hst, interface, status)
+        except (h.OepError, OSError):
+            _restarted(hst, boot, label)
+            raise
+        if st["op"] != code or st["state"] == JOB_STATES["idle"]:
+            _restarted(hst, boot, label)
+            raise ProbeRestarted(f"{label}: the status names op {st['op']} in state {st['state']}, not this job")
+        if st["state"] != JOB_STATES["running"]:
+            break
+        if time.monotonic() >= deadline:
+            try:
+                call(hst, interface, cancel)
+            except (h.OepError, OSError):
+                pass                                       # the timeout is the error to report
+            raise JobTimeout(label, timeout, dict(st))
+        pause(interval)
+    if st["state"] == JOB_STATES["failed"]:
+        raise JobFailed(label, dict(st))
+    if st["state"] == JOB_STATES["cancelled"]:
+        raise JobCancelled(label, dict(st))
+    return st
+
+
+def _restarted(hst: h.Host, boot: int, label: str) -> None:
+    try:
+        now = hst.clock().boot_id
+    except (h.OepError, OSError):
+        return
+    if now != boot:
+        raise ProbeRestarted(f"{label}: the probe restarted while the job ran (boot_id {boot:#x} -> {now:#x})")

oep_client/catalog.py

@@ -32,6 +32,13 @@ MIN_CLOCK_HZ = _COMMON["min_clock_hz"]     # u32
 FEATURES = _COMMON["features"]             # u32, bits defined by the interface
 CHANNEL_GROUP = _COMMON["channel_group"]   # group(u8) n(u8) then n x (role(u8), channel(u16)): a fixed pin set
 OPS = _COMMON["ops"]                       # base(u8) bitmap: the ops this fn offers (core §1.2, §7.4)
+OP_NAME = _COMMON["op_name"]               # op(u8) flags(u8) name: an op's name (core §7.4, optional)
+OP_FIELD = _COMMON["op_field"]             # op(u8) part(u8) type(u8) name: one field of an op's fixed part (core §7.4)
+OP_NAME_FORM = reg.CORE.enum["op_name_flag"]["form"]
+OP_NAME_LOCK_FREE = reg.CORE.enum["op_name_flag"]["lock_free"]
+OP_FIELD_PARTS = reg.CORE.enum["op_field_part"]          # request / success / failed
+OP_FIELD_TYPES = reg.CORE.enum["op_field_type"]          # u8 ... text, and the list bit
+OP_FIELD_LIST = OP_FIELD_TYPES["list"]
 assert OPS == m.TAG_OPS
 CRITICAL = 0x80
 INTERFACE_TAG_FIRST = 0x40
@@ -197,6 +204,50 @@ def text(tag: int, s: str) -> bytes:
     return tlv(tag, s.encode("ascii"))
 
 
+class OpField:
+    """One field of an op's fixed part (core §7.4 op_field): its name and type (registry op_field_type)."""
+
+    def __init__(self, name: str, type: int):
+        self.name, self.type = name, type
+
+    @property
+    def type_name(self) -> str:
+        names = {v: k for k, v in OP_FIELD_TYPES.items() if k != "list"}
+        base = self.type & ~OP_FIELD_LIST
+        label = names.get(base, f"type{base}")
+        return label + "[]" if self.type & OP_FIELD_LIST else label
+
+    def __repr__(self) -> str:
+        return f"{self.name}: {self.type_name}"
+
+
+@dataclass
+class OpForm:
+    """An op's name and, with form, its request / success / failed fixed parts' fields (core §7.4)."""
+
+    op: int
+    name: str
+    flags: int
+    request: list[OpField] = field(default_factory=list)
+    success: list[OpField] = field(default_factory=list)
+    failed: list[OpField] = field(default_factory=list)
+
+    @property
+    def form(self) -> bool:
+        return bool(self.flags & OP_NAME_FORM)
+
+    @property
+    def lock_free(self) -> bool:
+        return bool(self.flags & OP_NAME_LOCK_FREE)
+
+    def signature(self) -> str:
+        """measure(mode: u8) -> temp: i32, hum: u32 (the name alone without form)"""
+        if not self.form:
+            return self.name
+        s = f"{self.name}({', '.join(map(repr, self.request))})"
+        return s + (" -> " + ", ".join(map(repr, self.success)) if self.success else "")
+
+
 @dataclass
 class Description:
     """Common tags decoded; interface-specific and unknown tags kept raw, in order."""
@@ -212,11 +263,13 @@ class Description:
     specific: list[tuple[int, bytes]] = field(default_factory=list)
     unknown_critical: list[int] = field(default_factory=list)
     broken: list[int] = field(default_factory=list)   # common tags whose value is not their defined length (not used)
+    op_forms: dict[int, OpForm] = field(default_factory=dict)   # op -> its op_name / op_field (core §7.4)
 
 
 def decode_description(data: bytes) -> Description:
     d = Description()
     seen: set[int] = set()
+    fields: list[tuple[int, int, int, str]] = []         # op_field (op, part, type, name), in the describe's order
     for tag, value in split_tlv(data):
         if tag & CRITICAL:
             continue                                # bit 7 in an answer: an unknown tag, skipped (core §2.2)
@@ -248,11 +301,28 @@ def decode_description(data: bytes) -> Description:
                 d.ops_invalid = why
             else:
                 d.ops = unpack_ops(value)
+        elif t == OP_NAME:
+            if len(value) < 3:
+                d.broken.append(tag)
+                continue
+            if value[0] in d.op_forms:
+                continue                                    # a second op_name for an op: the first is used
+            d.op_forms[value[0]] = OpForm(value[0], value[2:].decode("ascii", "replace"), value[1])
+        elif t == OP_FIELD:
+            if len(value) < 4:
+                d.broken.append(tag)
+                continue
+            fields.append((value[0], value[1], value[2], value[3:].decode("ascii", "replace")))
         elif t >= INTERFACE_TAG_FIRST:
             d.specific.append((tag, value))
         elif tag & CRITICAL:
             d.unknown_critical.append(tag)
         # an unknown non-critical common tag is skipped
+    parts = {OP_FIELD_PARTS["request"]: "request", OP_FIELD_PARTS["success"]: "success", OP_FIELD_PARTS["failed"]: "failed"}
+    for op, part, type_, name in fields:                   # only an op named with form takes its fields
+        form = d.op_forms.get(op)
+        if form is not None and form.form and part in parts:
+            getattr(form, parts[part]).append(OpField(name, type_))
     for role in d.roles:
         d.roles[role] = sorted(set(d.roles[role]))
     if d.ops_invalid:

oep_client/conformance/__init__.py

@@ -145,7 +145,7 @@ def checker_sources_sha256():
             for name in CHECKER_SOURCES}
 
 
-REVIEWED_CORE_SHA256 = '0408d232e728bb9692ab1c24cefa1fdbf109c35aeebd378034d86c0f4d19789a'   # oep-spec docs/oep-core.ja.md
+REVIEWED_CORE_SHA256 = '81cffc532f2626812b109d0aa5eef81636799011f410a8bc2fb9ea520fcbf4bc'   # oep-spec docs/oep-core.ja.md
 
 
 def require_reviewed_contract(registry, spec=None):

oep_client/conformance/core_smoke.py

@@ -8,7 +8,7 @@ import struct
 from . import ops, require, tlvs
 from .. import conformance as _helpers
 
-REVIEWED_CORE_SHA256 = '0408d232e728bb9692ab1c24cefa1fdbf109c35aeebd378034d86c0f4d19789a'  # oep-spec docs/oep-core.ja.md
+REVIEWED_CORE_SHA256 = '81cffc532f2626812b109d0aa5eef81636799011f410a8bc2fb9ea520fcbf4bc'  # oep-spec docs/oep-core.ja.md
 
 
 class CoreSmokeChecks:

oep_client/conformance/host_core.py

@@ -4,7 +4,7 @@ from pathlib import Path
 import struct
 from . import require,spec_identity
 
-REVIEWED_CORE_SHA256='0408d232e728bb9692ab1c24cefa1fdbf109c35aeebd378034d86c0f4d19789a'
+REVIEWED_CORE_SHA256='81cffc532f2626812b109d0aa5eef81636799011f410a8bc2fb9ea520fcbf4bc'
 CORE_OPS={'confirm':1,'list':2,'describe':3,'clock':4,'open':16,'end':17,'keepalive':18,'lock_state':19}
 # the settings' ops (core §13.5 / §13.7, transports §7.3): their numbers reviewed, their results not read here
 SETTINGS_OPS={'get':32,'set':33,'unset':34,'save':35,'state':36,'network':37}

oep_client/conformance/host_deadline.py

@@ -9,8 +9,8 @@ from pathlib import Path
 from . import require,spec_identity
 
 
-REVIEWED={'docs/oep-core.ja.md':'0408d232e728bb9692ab1c24cefa1fdbf109c35aeebd378034d86c0f4d19789a',
-          'docs/oep-transports.ja.md':'2e99bf8039a3d8f5b55c80b66ac97ac40ddf7ad4711079177ffc947c5790103f'}
+REVIEWED={'docs/oep-core.ja.md':'81cffc532f2626812b109d0aa5eef81636799011f410a8bc2fb9ea520fcbf4bc',
+          'docs/oep-transports.ja.md':'a22754ee25997058be0e698bd62ea132537627914f38a06caffd48e3d79f096e'}
 QUICK_MS=1000  # core_quick_op_max_ms
 
 

oep_client/conformance/host_requests.py

@@ -12,11 +12,11 @@ from . import require, spec_identity
 REVIEWED = {
     'interfaces/oep-if-plan.ja.md': 'da8bd60af53499573c07bc33dbd8c4df93eb61a93b91dc57907f26620ae36bbf',
     'interfaces/oep-if-fixture.ja.md': '777a972349a14d1efa6e4575d3118b4e0566b81a6f22320401d529e4dca585f1',
-    'docs/oep-core.ja.md': '0408d232e728bb9692ab1c24cefa1fdbf109c35aeebd378034d86c0f4d19789a',
+    'docs/oep-core.ja.md': '81cffc532f2626812b109d0aa5eef81636799011f410a8bc2fb9ea520fcbf4bc',
     'interfaces/oep-if-debug.ja.md': '6f21171b494e67d50bfc78b4da9e16949033c9e24d960efb42887335da021681',
     'interfaces/oep-if-capture.ja.md': 'f1035dc14cf469d929d782dbe710fc2c1e1567006da41a001abe3c5c25761324',
 }
-REVIEWED_REGISTRY_SHA256='82456b04874c4d20775744d2bde3398d7a748d955d73b8f295a5e8e889a46477'
+REVIEWED_REGISTRY_SHA256='183922c36d78c0173cedece530410478dc3f1de0094d1922d3a960e752863d1e'
 
 
 def reviewed_identity(spec):

oep_client/conformance/host_wait.py

@@ -6,8 +6,8 @@ from .. import registry as _reg
 SAVE=_reg.CORE.op['save']  # fn 0's save (core §13.7)
 
 
-REVIEWED={'docs/oep-core.ja.md':'0408d232e728bb9692ab1c24cefa1fdbf109c35aeebd378034d86c0f4d19789a',
-          'docs/oep-transports.ja.md':'2e99bf8039a3d8f5b55c80b66ac97ac40ddf7ad4711079177ffc947c5790103f'}
+REVIEWED={'docs/oep-core.ja.md':'81cffc532f2626812b109d0aa5eef81636799011f410a8bc2fb9ea520fcbf4bc',
+          'docs/oep-transports.ja.md':'a22754ee25997058be0e698bd62ea132537627914f38a06caffd48e3d79f096e'}
 QUICK_MS=1000  # core_quick_op_max_ms
 
 

oep_client/dump.py

@@ -179,7 +179,11 @@ def describe_offer(o: Offer) -> dict:
         if getattr(d, key) is not None:
             out[key] = getattr(d, key)
     if d.ops is not None:
-        out["ops"] = interfaces.op_names(name, d.ops)
+        out["ops"] = [d.op_forms[op].name if op in d.op_forms else n
+                      for op, n in zip(sorted(d.ops), interfaces.op_names(name, d.ops))]
+    forms = [f.signature() for op, f in sorted(d.op_forms.items()) if f.form]
+    if forms:
+        out["op_forms"] = forms
     if d.features is not None:
         out["features"] = _features(d.features, known.features if known else {})
     specific = {}
@@ -241,6 +245,8 @@ def to_text(caps: Capabilities) -> str:
                 lines.append(f"{pad}  " + ", ".join(limits))
             if "ops" in r:
                 lines.append(f"{pad}  ops: " + (", ".join(r["ops"]) or "none"))
+            for sig in r.get("op_forms", []):
+                lines.append(f"{pad}    {sig}")
             if r.get("features"):
                 lines.append(f"{pad}  features: " + ", ".join(r["features"]))
             for k, v in r.get("declares", {}).items():

oep_client/registry.py

@@ -3,7 +3,7 @@
 
 from types import SimpleNamespace as _NS
 
-REGISTRY_HASH = "82456b04874c4d20"
+REGISTRY_HASH = "183922c36d78c017"
 SCHEMA = 1
 PROTOCOL_REVISION = 1
 CONFIRM_REQUEST_MAGIC = 'OEP?'
@@ -19,16 +19,16 @@ RESOLUTIONS = {"rejected": 0x00, "completed": 0x01}
 OUTCOMES = {"success": 0x00, "failed": 0x01, "partial": 0x02}
 REJECT_REASONS = {"unknown_function": 0x01, "unknown_operation": 0x02, "malformed": 0x03, "unavailable": 0x04, "window_exceeded": 0x06, "no_session": 0x07, "locked": 0x08, "session_required": 0x09, "no_resource": 0x0A, "unsupported": 0x0B, "result_lost": 0x0C}
 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": 0x04, "features": 0x05, "channel_group": 0x06, "ops": 0x07, "setting": 0x08, "setting_choice": 0x09}
+DESCRIBE_COMMON = {"role_channels": 0x01, "max_clock_hz": 0x02, "max_length": 0x03, "min_clock_hz": 0x04, "features": 0x05, "channel_group": 0x06, "ops": 0x07, "setting": 0x08, "setting_choice": 0x09, "op_name": 0x0A, "op_field": 0x0B}
 TIMING = {"probe_frame_gap_ms": 0xC8, "uart_bridge_boot_baud": 0x1C200, "port_speed_idle_ms": 0xBB8, "host_wait_add_ms": 0x3E8, "core_quick_op_max_ms": 0x3E8, "notify_pending_max_frames": 0x02, "port_speed_switch_wait_ms": 0x14}
 USB = {"project_vid": 0x1209, "project_pid": 0x4F45, "vendor_bulk_class": 0xFF, "vendor_bulk_subclass": 0x4F, "vendor_bulk_protocol": 0x45, "hid_usage_page": 0xFF4F, "hid_usage": 0x45}
-LIMITS = {"request_header_bytes": 0x0A, "result_header_bytes": 0x05, "corr_max": 0xFFFF, "corr_half_range": 0x8000, "resource_id_bytes": 0x04, "resource_id_max": 0xFFFFFFFF, "lease_min_ms": 0x3E8, "lease_max_ms": 0xEA60, "owner_max_bytes": 0x20, "unit_id_max_bytes": 0x20, "wifi_ssid_max_bytes": 0x20, "wifi_min_max_frame": 0x52, "label_max_bytes": 0x20, "setting_name_max_bytes": 0x30, "setting_choice_name_max_bytes": 0x10, "channel_name_max_bytes": 0x10, "setting_get_overhead_bytes": 0x12, "interface_name_max_bytes": 0x30, "port_speed_tolerance_pct": 0x02, "uart_baud_tolerance_pct": 0x05, "max_op_ms_max": 0x927C0}
+LIMITS = {"request_header_bytes": 0x0A, "result_header_bytes": 0x05, "corr_max": 0xFFFF, "corr_half_range": 0x8000, "resource_id_bytes": 0x04, "resource_id_max": 0xFFFFFFFF, "lease_min_ms": 0x3E8, "lease_max_ms": 0xEA60, "owner_max_bytes": 0x20, "unit_id_max_bytes": 0x20, "wifi_ssid_max_bytes": 0x20, "wifi_min_max_frame": 0x52, "label_max_bytes": 0x20, "setting_name_max_bytes": 0x30, "op_name_max_bytes": 0x18, "setting_choice_name_max_bytes": 0x10, "channel_name_max_bytes": 0x10, "setting_get_overhead_bytes": 0x12, "interface_name_max_bytes": 0x30, "port_speed_tolerance_pct": 0x02, "uart_baud_tolerance_pct": 0x05, "max_op_ms_max": 0x927C0}
 COMMON = _NS(enum={"target_id_scheme": {"dmi_7f": 0x01, "dpidr": 0x02}, "read_from": {"position": 0x00, "oldest": 0x01, "now": 0x02, "last_mark": 0x03}, "read_flags": {"more": 0x01, "gap": 0x02}, "mark_kind": {"lost": 0x01, "clear": 0x02, "host": 0x03}, "mark_detail_lost": {"overflow": 0x01, "framing": 0x02, "parity": 0x03}})
 
 INTERFACES = {}
 CORE = _NS(op={"confirm": 0x01, "list": 0x02, "describe": 0x03, "clock": 0x04, "open": 0x10, "end": 0x11, "keepalive": 0x12, "lock_state": 0x13, "get": 0x20, "set": 0x21, "unset": 0x22, "save": 0x23, "state": 0x24, "network": 0x25}, lock_free={0x01, 0x02, 0x03, 0x04, 0x10, 0x13, 0x20, 0x24, 0x25},
-    tlv={"confirm_answer": {"transport": 0x01}, "open": {"owner": 0x01}, "lock_state_answer": {"owner": 0x01}, "locked_payload": {"owner": 0x01}, "unavailable_payload": {"cause": 0x01, "channel": 0x02, "item": 0x03, "fn": 0x05}, "unsupported_payload": {"supported": 0x01, "channel": 0x02, "item": 0x03, "fn": 0x05}, "describe": {"firmware": 0x40, "model": 0x41, "unit_id": 0x42, "channels": 0x43, "channel_name": 0x44, "netif": 0x45, "transport": 0x49, "chip": 0x4C, "max_op_ms": 0x4D}}, event={}, enum={"unavailable_cause": {"pin_in_use": 0x01, "limit": 0x02, "storage_full": 0x03, "bound_in_group": 0x04, "held_by_settings": 0x05, "wrong_state": 0x06, "policy_denied": 0x07}, "transport_kind": {"uart_bridge": 0x01, "usb_cdc": 0x02, "usb_serial_jtag": 0x03, "vendor_bulk": 0x04, "hid": 0x05, "tcp": 0x06}, "route_kind": {"bridge": 0x01, "cdc": 0x02, "usj": 0x03, "bulk": 0x04, "hid": 0x05, "tcp": 0x06}, "setting_form": {"bytes": 0x01, "text": 0x02, "u32": 0x03, "ipv4": 0x04, "bool": 0x05, "enum": 0x06, "channel": 0x07, "transport": 0x08, "fn": 0x09}, "setting_key_kind": {"none": 0x00, "channel": 0x01, "index": 0x02, "transport": 0x03, "netif": 0x04}, "setting_flag": {"secret": 0x01, "restart": 0x02}, "storage_state": {"none": 0x00, "applied": 0x01, "unreadable": 0x02, "partial": 0x03}, "storage_reason": {"none": 0x00, "form": 0x01, "item": 0x02, "capacity": 0x03}, "channel_idle": {"hi_z": 0x00, "pull_up": 0x01, "pull_down": 0x02, "low": 0x03, "high": 0x04}, "ipv4_mode": {"dhcp": 0x00, "static": 0x01}, "network_state": {"off": 0x00, "connecting": 0x01, "up": 0x02, "waiting": 0x03}, "network_reason": {"none": 0x00, "not_found": 0x01, "auth": 0x02, "no_address": 0x03, "other": 0x04}}, own={},
-    line_names={'swdio': 'the debug data line (2 wires: rvswd, swd) (Host only)', 'swclk': 'the debug clock line (2 wires: rvswd, swd) (Host only)', 'swio': 'the one debug wire (swio) (Host only)', 'rx': 'the fixture UART receive, wired to the target TX (Host only)', 'tx': 'the fixture UART transmit, wired to the target RX (Host only)', 'nrst': 'the target reset line (Host only)', 'power_hi': 'target power on when high (Host only)', 'power_lo': 'target power on when low (Host only)'}, names={'netif': {'wifi': 'Wi-Fi station', 'ethernet': 'wired Ethernet'}}, settings={'channel.{}.label': "text 1-32, channel; the pin's label (NRST)", 'channel.{}.idle': 'enum channel_idle, channel; the idle state (core §8)', 'channel.{}.disable': 'bool, channel; true: the probe neither drives nor configures the pin', 'wifi.{}.ssid': "text 1-32, index (entry); the network's name", 'wifi.{}.passphrase': 'text 8-64, index (entry), secret; 8-63 printable passphrase or 64 hex digits', 'ipv4.{}.mode': 'enum ipv4_mode, netif; dhcp when absent', 'ipv4.{}.address': 'ipv4, netif; static address', 'ipv4.{}.prefix': 'u32 1-32, netif; static prefix length', 'ipv4.{}.gateway': 'ipv4, netif; static gateway, none when absent', 'ipv4.{}.dns': 'ipv4, netif; static DNS server, none when absent'})
+    tlv={"confirm_answer": {"transport": 0x01}, "open": {"owner": 0x01}, "lock_state_answer": {"owner": 0x01}, "locked_payload": {"owner": 0x01}, "unavailable_payload": {"cause": 0x01, "channel": 0x02, "item": 0x03, "fn": 0x05}, "unsupported_payload": {"supported": 0x01, "channel": 0x02, "item": 0x03, "fn": 0x05}, "describe": {"firmware": 0x40, "model": 0x41, "unit_id": 0x42, "channels": 0x43, "channel_name": 0x44, "netif": 0x45, "transport": 0x49, "chip": 0x4C, "max_op_ms": 0x4D}}, event={}, enum={"unavailable_cause": {"pin_in_use": 0x01, "limit": 0x02, "storage_full": 0x03, "bound_in_group": 0x04, "held_by_settings": 0x05, "wrong_state": 0x06, "policy_denied": 0x07}, "transport_kind": {"uart_bridge": 0x01, "usb_cdc": 0x02, "usb_serial_jtag": 0x03, "vendor_bulk": 0x04, "hid": 0x05, "tcp": 0x06}, "route_kind": {"bridge": 0x01, "cdc": 0x02, "usj": 0x03, "bulk": 0x04, "hid": 0x05, "tcp": 0x06}, "setting_form": {"bytes": 0x01, "text": 0x02, "u32": 0x03, "ipv4": 0x04, "bool": 0x05, "enum": 0x06, "channel": 0x07, "transport": 0x08, "fn": 0x09}, "setting_key_kind": {"none": 0x00, "channel": 0x01, "index": 0x02, "transport": 0x03, "netif": 0x04}, "setting_flag": {"secret": 0x01, "restart": 0x02}, "op_name_flag": {"form": 0x01, "lock_free": 0x02}, "op_field_part": {"request": 0x00, "success": 0x01, "failed": 0x02}, "op_field_type": {"u8": 0x01, "u16": 0x02, "u32": 0x03, "u64": 0x04, "i8": 0x05, "i16": 0x06, "i32": 0x07, "i64": 0x08, "bool": 0x09, "bytes": 0x0A, "text": 0x0B, "list": 0x80}, "storage_state": {"none": 0x00, "applied": 0x01, "unreadable": 0x02, "partial": 0x03}, "storage_reason": {"none": 0x00, "form": 0x01, "item": 0x02, "capacity": 0x03}, "channel_idle": {"hi_z": 0x00, "pull_up": 0x01, "pull_down": 0x02, "low": 0x03, "high": 0x04}, "ipv4_mode": {"dhcp": 0x00, "static": 0x01}, "network_state": {"off": 0x00, "connecting": 0x01, "up": 0x02, "waiting": 0x03}, "network_reason": {"none": 0x00, "not_found": 0x01, "auth": 0x02, "no_address": 0x03, "other": 0x04}}, own={},
+    line_names={'swdio': 'the debug data line (2 wires: rvswd, swd) (Host only)', 'swclk': 'the debug clock line (2 wires: rvswd, swd) (Host only)', 'swio': 'the one debug wire (swio) (Host only)', 'rx': 'the fixture UART receive, wired to the target TX (Host only)', 'tx': 'the fixture UART transmit, wired to the target RX (Host only)', 'nrst': 'the target reset line (Host only)', 'power_hi': 'target power on when high (Host only)', 'power_lo': 'target power on when low (Host only)'}, names={'netif': {'wifi': 'Wi-Fi station', 'ethernet': 'wired Ethernet'}}, settings={'channel.{}.label': "text 1-32, channel; the pin's label (NRST)", 'channel.{}.idle': 'enum channel_idle, channel; the idle state (core §8)', 'channel.{}.disable': 'bool, channel; true: the probe neither drives nor configures the pin', 'wifi.{}.ssid': "text 1-32, index (entry); the network's name", 'wifi.{}.passphrase': 'text 8-64, index (entry), secret; 8-63 printable passphrase or 64 hex digits', 'ipv4.{}.mode': 'enum ipv4_mode, netif; dhcp when absent', 'ipv4.{}.address': 'ipv4, netif; static address', 'ipv4.{}.prefix': 'u32 1-32, netif; static prefix length', 'ipv4.{}.gateway': 'ipv4, netif; static gateway, none when absent', 'ipv4.{}.dns': 'ipv4, netif; static DNS server, none when absent', 'usb.transports': "enum (the probe's choices: transport short names in describe order joined by -, a count after a repeated one: bulk-hid-cdc2), restart; the OEP transports the probe's own USB device offers after a restart, its default set when absent (transports §3.1)"})
 PROBE_PLAN = _NS(name="oep.probe.plan", revision=1, target=None, op={"plan_apply": 0x10, "plan_release": 0x11}, lock_free=set(),
     tlv={"plan_apply": {"role_assignment": 0x10}, "describe": {"plan_roles": 0x40}}, event={}, enum={}, own={},
     line_names={}, names={}, settings={})

oep_client/virtual_bench.py

@@ -320,7 +320,9 @@ NETWORK_ITEMS = (Item("wifi.{}.ssid", "text", "index", WIFI_ENTRIES, reg.LIMITS[
                  Item("ipv4.{}.mode", "enum", "netif", choices=tuple(choices_of(reg.CORE.enum["ipv4_mode"]).items())),
                  Item("ipv4.{}.address", "ipv4", "netif"), Item("ipv4.{}.prefix", "u32", "netif"),
                  Item("ipv4.{}.gateway", "ipv4", "netif"), Item("ipv4.{}.dns", "ipv4", "netif"))
-assert {i.name for i in CORE_ITEMS + NETWORK_ITEMS} == set(_CS), "the core's items as the registry names them"
+# transports §3.1: a probe whose own USB device can start more than one set of transports (none of the profiles here)
+USB_ITEMS = (Item("usb.transports", "enum", flags=FLAG["restart"], choices=((0, "bulk-hid-cdc"), (1, "bulk-hid"))),)
+assert {i.name for i in CORE_ITEMS + NETWORK_ITEMS + USB_ITEMS} == set(_CS), "the core's items as the registry names them"
 HOLD = Item("channel.{}.hold", "bool", "channel")
 REST = Item("channel.{}.rest", "enum", "channel", choices=tuple(choices_of(reg.WIRE_RVSWD.enum["rest"]).items()))
 
@@ -672,6 +674,16 @@ def rp2350_pins() -> VirtualProbe:
 
 
 STAND_IN = f"{NS}.stand-in"
+# The stand-in ops' names and fields (core §7.4 op_name / op_field): write(value: u32), read() -> value: u32 (lock-free)
+_OPN, _OPF = reg.DESCRIBE_COMMON["op_name"], reg.DESCRIBE_COMMON["op_field"]
+_FLAG, _PART, _TYPE = (reg.CORE.enum[k] for k in ("op_name_flag", "op_field_part", "op_field_type"))
+_WRITE, _READ = STAND_IN_OPS
+STAND_IN_FORMS = (
+    catalog.tlv(_OPN, bytes([_WRITE, _FLAG["form"]]) + b"write"),
+    catalog.tlv(_OPF, bytes([_WRITE, _PART["request"], _TYPE["u32"]]) + b"value"),
+    catalog.tlv(_OPN, bytes([_READ, _FLAG["form"] | _FLAG["lock_free"]]) + b"read"),
+    catalog.tlv(_OPF, bytes([_READ, _PART["success"], _TYPE["u32"]]) + b"value"),
+)
 
 
 def _again(probe: VirtualProbe, offered: list[Offered]) -> VirtualProbe:
@@ -731,7 +743,7 @@ def with_stand_in(probe: VirtualProbe) -> VirtualProbe:
     """The profile plus one fn (the next number) the endpoint does not simulate: it answers only the two stand-in
     operations (endpoint.TOY_WRITE / TOY_READ), for tests of the session rules. VIRTUAL BENCH ONLY."""
     fn = max(o.fn for o in probe.offered) + 1
-    return _again(probe, list(probe.offered) + [Offered(fn, 0, STAND_IN)])
+    return _again(probe, list(probe.offered) + [Offered(fn, 0, STAND_IN, STAND_IN_FORMS)])
 
 
 ATTACH_HALT = reg.WIRE_RVSWD.enum["features"]["attach_halt"]   # attach method 1 (debug §3)

{oep_client_python-0.0.53.dist-info → oep_client_python-0.0.54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.53
+Version: 0.0.54
 Summary: Open Embedded Probe (OEP) v1 host: serial / USB / TCP transports, the session rules, the standard interfaces, and a virtual bench
 Project-URL: Homepage, https://github.com/Open-Embedded-Probe/oep-client-python
 Project-URL: Repository, https://github.com/Open-Embedded-Probe/oep-client-python

{oep_client_python-0.0.53.dist-info → oep_client_python-0.0.54.dist-info}/RECORD

@@ -1,16 +1,17 @@
-oep_client/__init__.py,sha256=h7kpeApyfQHsMxED1_KZ6bWVGpyXHIWTutC3cmwSr7o,164
-oep_client/__main__.py,sha256=kbXBtEmFdhRXbVqXEbWCO-_5aDa-KyqMcW2HLZb5fjc,31510
+oep_client/__init__.py,sha256=xps99W-P4elEjl5RY8jG6Pr_sjJfRFSzMeiUo3p0pco,164
+oep_client/__main__.py,sha256=SMeCK8A4Ru8tvCW3u4cXV1oFI_eUyEUJnBZukCZeVNg,36319
 oep_client/acquire.py,sha256=CXjK5s-kjdCoGg9Yt_46rr4te6T2fbX4tl89PjOnURA,102541
 oep_client/arm.py,sha256=zsgq4jsGzroE_9yF5D48rJF7dAe07MR8RY4RMCgjiwc,16411
+oep_client/call.py,sha256=4h8jGv_12CaTIfjOVlNXJYcu_ZCiPpPAwGdvbUv86Vc,12806
 oep_client/capture.py,sha256=92ZznVWu2i3_5mIk0bMSIeqNqJ0LpjbMi3JRb2qrYrs,75848
 oep_client/capture_blocks.py,sha256=B8T2dKozQfGTWg4noG0cZ0DZ9KrrfiFFdbTrBKWfWhY,17330
-oep_client/catalog.py,sha256=WkaksNn9cFvkTRnvtX4I9g1AvkFoldEiNQaKiyPQ7_E,10772
+oep_client/catalog.py,sha256=aWzWWLAzeGcpNqTz8ZM2AupTNLY1jsADr3CjHrzx-_0,13960
 oep_client/ch32_flash.py,sha256=lY_HKxf2foSfhNda91lcWefgRnY9ebTljsg4zJEj-Ks,12885
 oep_client/cobs.py,sha256=RbdPrqgzD3SukxOIXX9m2dZpVTud8xAYYEhm3rcW2nA,2513
 oep_client/console.py,sha256=hDxoaXDCzk6KiOo-Y3RqC4yZuLPkCXOVi886_C4xXaE,12910
 oep_client/core.py,sha256=o7qJjZc68RS9p91TfV3aLsLcTq-jWBO1atB9kGL_tkA,22188
 oep_client/discovery.py,sha256=oES0_NkR1Hc9E_cgPcfW8qfevQcVuYmayMaHuqufdO8,20180
-oep_client/dump.py,sha256=9rfO07q1EOY4aLFZkm_9RO8awjxNQa75DIDeKAoF_ac,12995
+oep_client/dump.py,sha256=ic3Nv_ZX1iLjgSkjyFwgXVkjCnPwClnkqZnagQY9N-c,13317
 oep_client/endpoint.py,sha256=A4fCeCwMCXOpsY4zeVy1LG_rG5SvYfImKRP153dIC5I,237768
 oep_client/fixture.py,sha256=gMc6TRAlXBEMBFg6aCBkGGJvbIJsGBSfUdk0genD_Y8,34397
 oep_client/frames.py,sha256=FM1AGn5NY_e-r1yKBsDkEEOqNrk5XTrlKA5Mq6Ycqiw,4984
@@ -28,7 +29,7 @@ oep_client/pins.py,sha256=iXswbqvze0KED1WNHLnjG5sn-_SjoJrIvcjj84LU_jU,53670
 oep_client/probe_log.py,sha256=gAamfON2M7lMH3xOn4Wpmes_Wp0H4c2EBNbpXjIvCMM,4927
 oep_client/pytest_conformance.py,sha256=-bcJU2E1UE4xjQ7HZjaIgtp0l65cIibBTNFnaW2tews,2929
 oep_client/pytest_rp2040_peer.py,sha256=9buM_lpXx9lhi-H-tIWAfS5xyDmgGUBwfHlOkBG3jiA,2873
-oep_client/registry.py,sha256=1oFMpnbys1Iqih592ueUn8kru56O4eTCYNhdIQfDIP0,22706
+oep_client/registry.py,sha256=yzp4URjmECxBlbl6vt2KaeB4v-93hQFy-brsT7_17II,23339
 oep_client/riscv.py,sha256=1QloF51Uci2-6gonkBxQNh9XleF6yCvKG-L7XNm4sgI,60460
 oep_client/rp2040.py,sha256=m_3eOWxrZOTWB7TGYv2_OmtfHREBdwCfdoVXjP_Qq0A,3392
 oep_client/rp2040_peer.py,sha256=BQc6H79wPhjEcj0sl4O5mDPH_YZIHB2FbrZ8vMdxdg8,14505
@@ -39,7 +40,7 @@ oep_client/stimulus.py,sha256=pfX4xLjyG3UWIJRWUHnkg9c1ueL1MeozHj3CnlJ7dpA,6072
 oep_client/targets.py,sha256=vEXPyhI1UNeaZKIpbNIVf-XsmpvnV9r0pPyXYb3Ddaw,7994
 oep_client/uiapduino.py,sha256=oafP1SyKPO3cox-2RYbWUZusy4vc6NsEVC7Z-Y1sjWI,6337
 oep_client/usb_stream.py,sha256=zRGGHkvtOme6lIZ-gkrCe2xKn9hC62JGqmc7pKQDAJI,23540
-oep_client/virtual_bench.py,sha256=tLPjfVy19CtcRwQIhYYx4xzQ5JIHXhFnRvUVwFj_sVE,50273
+oep_client/virtual_bench.py,sha256=YekAy5xxchLUOMarWMvdgshTVnFMe9VJZcib0Cpz4Y8,51203
 oep_client/virtual_bench_capture.py,sha256=KxnXoCZ71qy9WwujyMt43jDJLsU4xHicBlS16NJMwkg,101716
 oep_client/virtual_bench_mdns.py,sha256=cnJNBKg5zTduXUcH-wqN_ZBDGl7DyL-tL3CBn2jro0E,13305
 oep_client/virtual_bench_serial.py,sha256=EvbdOYeGrM6CRti2b90I0PzpmmherfoJRaAg4v7Iq9Y,13205
@@ -49,7 +50,7 @@ oep_client/virtual_bench_usb.py,sha256=cnewgbsl30b0PgwkfebwSf3xjKyPg9y8vTd5Jew5r
 oep_client/virtual_core.py,sha256=F-UxtQIld4eE04_M8j4ANMlQ12jXANzfTnfn59kUWHk,10716
 oep_client/virtual_fixture_drive.py,sha256=3i5ss_bxIJFsRDb5S-GJ0Nb9QDyOBv_SwF9CDP6nPfE,21844
 oep_client/virtual_names.py,sha256=p72ME65R9Jy56xmVYnVCtapK3Id8iFpAdI5xLe2tNZ0,1449
-oep_client/conformance/__init__.py,sha256=P_RyiWnULdDQMKyo0eCnE7VLv3v7Ps7lnVCY1hfOjdA,64739
+oep_client/conformance/__init__.py,sha256=r3xk9VyzN4LgETYlN0E3pyA-b1uI9Km0TXra-Bl-ShY,64739
 oep_client/conformance/allocator.py,sha256=dYR5ZcCVW-LjoZVx4W9Ad76L8Ol8Pu1aOkj78A9UY1E,6251
 oep_client/conformance/allocator_model.py,sha256=j6l1E1Hlju1jNeFQ_N0a2mDaegaTeyk6iScqzMpvvTc,1563
 oep_client/conformance/allocator_sample.py,sha256=xtiXuZa3VDTilrZArIWOiRyOkuXJ98_rY2M65sIVvpo,855
@@ -84,7 +85,7 @@ oep_client/conformance/clock.py,sha256=bDqBjih71zg_mhkgCSryzKI_N8FEoGoGv9jO4PMYD
 oep_client/conformance/clock_model.py,sha256=jyB8oTVR5sqbzeJCCWxdQBnzNNl4_uITLLYQ-yx8pRU,2568
 oep_client/conformance/clock_sample.py,sha256=x24mSpQoOamrXrinmnF_Tk4NPk76LwS6ZhfuK2SCwCo,673
 oep_client/conformance/core_fixed_fields.py,sha256=LRFP9yGOjDHQM1diX1HMdwXh9jMgAOY6xIC-woCikSk,6297
-oep_client/conformance/core_smoke.py,sha256=np7SZ3yVdD0imiFyjBjAT_J8KK_EmtUiJAeplUNpYR8,10815
+oep_client/conformance/core_smoke.py,sha256=6fvQ6JYX1PTFGKtpCTffKigzKF5ejsYLffMFXxOCVQE,10815
 oep_client/conformance/corr.py,sha256=P6ljdsXpBq-vyEXRWOB1MqACQjT6HRBXgfAxgkyPjl4,6552
 oep_client/conformance/cut.py,sha256=4B8szd6_QtcGtYMWgP86ABsXUDOFVgwWaWCpTWMDO80,7942
 oep_client/conformance/cut_model.py,sha256=bHPnK8vKoInKVslW0KlJXRRgpGK-7ktIVGUEXo60X34,4791
@@ -119,21 +120,21 @@ oep_client/conformance/gpio_lifecycle_model.py,sha256=K0nzlXf-43kj3jsfaAuzEWOftO
 oep_client/conformance/gpio_lifecycle_sample.py,sha256=Yk1WENQ-2tbPCM2yUY4Yk9dgWkjIfL42VtUSpx1qhhM,369
 oep_client/conformance/gpio_model.py,sha256=CXy42K8cdRSTBxLC44h-gTYhjh3HrduSehsgsbvmDpo,5633
 oep_client/conformance/gpio_sample.py,sha256=JHsOrjkYcM738IGSzP5q7v5vANETwKT6-csCTxH55MQ,490
-oep_client/conformance/host_core.py,sha256=RaCD86ehLC1w35hjXu0ekQ6hKTtoljdnReYTttll4KE,12634
+oep_client/conformance/host_core.py,sha256=7yaDKXpam5qBKuAl41a0eBHq4ijspQIpQhk-JKNvFoQ,12634
 oep_client/conformance/host_core_sample.py,sha256=egU8Xw-f3eHx_CmUooN1yW1lzltOam6IsJbnD8uOx9I,3803
-oep_client/conformance/host_deadline.py,sha256=P0Yh3lZrq35_zQkEPhXjjX2aORXGkpPJvgxWtfNPvFM,6978
+oep_client/conformance/host_deadline.py,sha256=uGm6LhWDsv-HsO7M80MROhjGYEmd12qjEKk8B-aT2Mg,6978
 oep_client/conformance/host_deadline_sample.py,sha256=G471jEc2HxDIu52Acw_aHDSxFAEC72OBCuvn2YQtAdU,5136
 oep_client/conformance/host_notifications.py,sha256=LGRJhOS66_36MYG8fHLcyHroXtoZRQVJgammDieVhQY,9307
 oep_client/conformance/host_notifications_sample.py,sha256=auze2DdWtUOdQMHnfDF8WXLAiETv3OuODR6y77VmsTQ,1788
 oep_client/conformance/host_request_sample.py,sha256=Oq60q350EhDxhe2FESnUF04YhJ6HDjDSHTe4FR55H9M,1848
-oep_client/conformance/host_requests.py,sha256=y6QClQaVB1Bo6G1k49Ce9iizFomqJZZJEemIiellVwA,10718
+oep_client/conformance/host_requests.py,sha256=Z_gaT55iel6jGgYHytGWQpph78xbhTScvFoWpbsZyEs,10718
 oep_client/conformance/host_resend.py,sha256=P8tFWtr6TwQ33ph-JO0l8EXyJGxSjC6fBeyKQ4AhqxU,5519
 oep_client/conformance/host_resend_sample.py,sha256=nwaru9ZVcxpcTi1OEritp8PSF6Qfic_IRGuutH2aBA4,4808
 oep_client/conformance/host_tlv.py,sha256=h5SZT9r3DCsxMLcRacdyKOoZNQHSL8DzRgT1VPu_86A,6140
 oep_client/conformance/host_tlv_sample.py,sha256=V6ORb5E2i76dc8O73Bew0eO2CbjG-ZPc02JLi6w5vmY,743
 oep_client/conformance/host_values.py,sha256=VnjEB5TQbI34fuyAx0OGVbiyfI2ZH_of9I4TLT7Dyyk,4742
 oep_client/conformance/host_values_sample.py,sha256=7C58mSP9jjrkNSgSb3uNK44VrdPXOznof_oe5UCcZro,1532
-oep_client/conformance/host_wait.py,sha256=B9h0mjhIbo8DH9LwUwP8OXL1weeKkPOOeW_YGU4H-CA,5591
+oep_client/conformance/host_wait.py,sha256=N7Aj70EIE5A8mg849kbQ192BPG1gXj6fHAHz-rF2MSw,5591
 oep_client/conformance/host_wait_sample.py,sha256=7SkJ8H_9ScMv8gLnT85xBKj_GXciPvAzmH-KxfMWYCg,3257
 oep_client/conformance/i2c.py,sha256=fNDweyCLlCsv7fCwmmQMC7di5AG1HzDCflW0miWwcjc,18041
 oep_client/conformance/i2c_model.py,sha256=HLYqRKdKMvlCGMcgYxSS3dy50Zf7aPojN_gO5fBvy6U,9759
@@ -259,8 +260,8 @@ oep_client/conformance/writer_lease_model.py,sha256=FxhDqqzdFOa_SSHSvjdQFh49Wn3Y
 oep_client/conformance/writer_lease_sample.py,sha256=oowRwYUNAE4f6rEE2HmYlSS9dDWE0TGegkcsqVH8Nak,455
 oep_client/pyserial/__init__.py,sha256=JSsbRkLYgFVN8V4H9ovdqyDr6JW3P3qi4RYoElg050o,121
 oep_client/pyserial/protocol_oep.py,sha256=3dC8nbtddNG2lfonLUkbBTKfsfJoNHFfabuedn0n7Ho,2497
-oep_client_python-0.0.53.dist-info/METADATA,sha256=M2NZFKa5D1kJLOC8gBnV2OxzEnq0klAORQTOKBYaFxI,55222
-oep_client_python-0.0.53.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-oep_client_python-0.0.53.dist-info/entry_points.txt,sha256=XEt39Jz7oQyU9Hfg_tV6eDGofNxWYrjSfslxKP-fh70,135
-oep_client_python-0.0.53.dist-info/licenses/LICENSE,sha256=ntlalztb3L1OaNAxmQdHlubu5fVhjMc9oRZi3PeQhXg,1076
-oep_client_python-0.0.53.dist-info/RECORD,,
+oep_client_python-0.0.54.dist-info/METADATA,sha256=26-ib8waK12oL_vgWAHFD-j7voBa-hsBbAPksQg5LXE,55222
+oep_client_python-0.0.54.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+oep_client_python-0.0.54.dist-info/entry_points.txt,sha256=XEt39Jz7oQyU9Hfg_tV6eDGofNxWYrjSfslxKP-fh70,135
+oep_client_python-0.0.54.dist-info/licenses/LICENSE,sha256=ntlalztb3L1OaNAxmQdHlubu5fVhjMc9oRZi3PeQhXg,1076
+oep_client_python-0.0.54.dist-info/RECORD,,