oep-client-python 0.0.7__py3-none-any.whl → 0.0.8__py3-none-any.whl

oep_client/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.0.7"
+__version__ = "0.0.8"

oep_client/endpoint.py

@@ -254,15 +254,26 @@ class Endpoint:
         self.pairs: dict[int, list[tuple[int, int]]] = {}  # wire fn -> allowed (swdio, swclk), declared order
         self.max_connections: dict[int, int] = {}
         self.reset_channels: dict[int, set[int]] = {}     # wire fn -> channels attach_under_reset may take (role 3)
+        self.pin_roles: dict[int, dict[int, set[int]]] = {}   # wire fn -> role -> candidates (role_channels wires)
         for fn, name in self.names.items():
             if name in WIRES:
                 self.pairs[fn] = [self._group_pair(name, t) for t in self.static[fn] if t[0] == catalog.CHANNEL_GROUP]
+                roles: dict[int, set[int]] = {}
+                for t in self.static[fn]:
+                    if t[0] == catalog.ROLE_CHANNELS and t[2] in (1, 2):
+                        roles.setdefault(t[2], set()).update(
+                            catalog.bitmap_to_channels(struct.unpack_from("<H", t, 3)[0], t[5:2 + t[1]]))
+                if roles:
+                    self.pin_roles[fn] = roles
                 self.reset_channels[fn] = {
                     c for t in self.static[fn] if t[0] == catalog.ROLE_CHANNELS and t[2] == PIN_ROLE_RESET
                     for c in catalog.bitmap_to_channels(struct.unpack_from("<H", t, 3)[0], t[5:2 + t[1]])}
                 self.max_connections[fn] = next((t[2] for t in self.static[fn] if t[0] == fake.MAX_CONNECTIONS), 1)
         self.targets: dict[tuple[int, tuple[int, int]], FakeTarget] = {
             (fn, p): FakeTarget() for fn in sorted(self.pairs) for p in self.pairs[fn]}
+        for fn in sorted(self.pin_roles):                          # any pair: one target, on the first pair
+            first = self._role_pairs(fn)[0]
+            self.targets[(fn, first)] = FakeTarget()
         self.target = next(iter(self.targets.values()), FakeTarget())
         self.mechanisms = set()
         for fn, name in self.names.items():
@@ -329,6 +340,38 @@ class Endpoint:
     def target_id(self, value: int | None) -> None:
         self.target.target_id = value
 
+    def _role_pairs(self, fn: int) -> list[tuple[int, int]]:
+        """A role_channels wire's pairs in the count = 0 order (oep-if-debug §1): swdio ascending, then swclk."""
+        roles = self.pin_roles[fn]
+        if self.names[fn] == "oep.wire.swio":
+            return [(d, 0xFFFF) for d in sorted(roles.get(1, ()))]
+        return [(d, c) for d in sorted(roles.get(1, ())) for c in sorted(roles.get(2, ())) if d != c]
+
+    def _allowed_pairs(self, fn: int) -> list[tuple[int, int]]:
+        return self._role_pairs(fn) if fn in self.pin_roles else self.pairs.get(fn, [])
+
+    def _allows(self, fn: int, pair: tuple[int, int]) -> bool:
+        if fn in self.pin_roles:
+            roles = self.pin_roles[fn]
+            swio = self.names[fn] == "oep.wire.swio"
+            return pair[0] in roles.get(1, ()) and (pair[1] == 0xFFFF if swio else
+                                                    pair[1] in roles.get(2, ()) and pair[1] != pair[0])
+        return pair in self.pairs.get(fn, [])
+
+    def _held(self, fn: int | None = None, pair: tuple[int, int] | None = None) -> set[int]:
+        """Channels something holds (core §8.1): the plan, the slots' pairs, the live connections' pairs - except
+        wire `fn`'s own connection on `pair` (attaching there again, or scanning through it)."""
+        held = {a[2] for a in self.plan}
+        held |= {p for s in self.slots.values() for p in s.pair if p != 0xFFFF and not (s.wire_fn == fn and s.pair == pair)}
+        held |= {p for c in self.conns.values() for p in c.pair if p != 0xFFFF and not (c.fn == fn and c.pair == pair)}
+        return held
+
+    def _target(self, fn: int, pair: tuple[int, int]) -> FakeTarget:
+        tg = self.targets.get((fn, pair))
+        if tg is None:                                             # a pair nothing is wired to
+            tg = self.targets[(fn, pair)] = FakeTarget(present=False)
+        return tg
+
     @staticmethod
     def _group_pair(name: str, t: bytes) -> tuple[int, int]:
         roles = {t[3 + 3 * i]: struct.unpack_from("<H", t, 4 + 3 * i)[0] for i in range((t[1] - 1) // 3)}
@@ -603,6 +646,7 @@ class Endpoint:
         named = {fn for fn, _, _ in got}
         kept = {a for a in self.plan if a[0] not in named}
         slot_pins = {p for s in self.slots.values() for p in s.pair if p != 0xFFFF}
+        slot_pins |= {p for c in self.conns.values() for p in c.pair if p != 0xFFFF}   # a live connection's pins too
         for fn, role, ch in got:
             roles = {"oep.fixture.gpio": {1}, "oep.fixture.uart": {1, 2}}.get(self.names.get(fn, ""), set())
             if role not in roles or any(k[2] == ch for k in kept) or ch in slot_pins:
@@ -646,17 +690,24 @@ class Endpoint:
 
     # ---- oep.wire.rvswd / swio ------------------------------------------------------------------
     def _wire(self, fn: int, op: int, t: Take) -> tuple[int, int, bytes]:
-        allowed = self.pairs.get(fn, [])
         if op == 0x01:                                             # scan: count(u8) pairs -> tried count found...
             count = t.take("B")
             pairs = [t.take("HH") for _ in range(count)]
-            t.tail()
-            if any(p not in allowed for p in pairs):
-                raise Reject(m.UNAVAILABLE)
-            pairs = pairs or allowed
+            got, _ = t.tail({0x01})
+            if 0x01 in got and (count or len(got[0x01]) != 2):
+                raise Reject(m.MALFORMED)                          # skip goes with count 0 only
+            live = [c.pair for c in self.conns.values() if c.fn == fn]
+            full = len(live) >= self.max_connections.get(fn, 1)   # every seat taken: the live pairs only
+            if any(not self._allows(fn, p) or set(p) & self._held(fn, p) or (full and p not in live) for p in pairs):
+                raise Reject(m.UNAVAILABLE)                        # not allowed, held (§8.1), or no seat to try it on
+            if not pairs:                                          # the count-0 list, from `skip` on (oep-if-debug §1)
+                skip = struct.unpack("<H", got[0x01])[0] if 0x01 in got else 0
+                pairs = [p for p in self._allowed_pairs(fn)
+                         if not set(p) & self._held(fn, p) and (not full or p in live)][skip:]
+            pairs = pairs[:255]                                    # tried is a u8
             found = []
             for p in pairs:
-                tg = self.targets[(fn, p)]
+                tg = self._target(fn, p)
                 if tg.present:                                     # a live connection's pair: read over it, no restart
                     found.append(struct.pack("<BHHI", 1, *p, tg.dmstatus()))
             return m.COMPLETED, m.SUCCESS, struct.pack("<BB", len(pairs), len(found)) + b"".join(found)
@@ -675,7 +726,7 @@ class Endpoint:
                 raise Reject(m.MALFORMED)
             idle_clock = got[0x04][0] if 0x04 in got else 0
             pair = self._pick_pair(fn, got)
-            tg = self.targets[(fn, pair)]
+            tg = self._target(fn, pair)
             speed = min(4_000_000, struct.unpack("<I", got[0x01])[0]) if 0x01 in got else 4_000_000
             cid = self._conn_at(fn, pair)
             flags = 0
@@ -729,14 +780,14 @@ class Endpoint:
         return m.REJECTED, m.UNKNOWN_OPERATION, b""
 
     def _pick_pair(self, fn: int, got: dict[int, bytes]) -> tuple[int, int]:
-        allowed = self.pairs.get(fn, [])
         if 0x03 in got:
             if len(got[0x03]) != 4:
                 raise Reject(m.MALFORMED)
             pair = struct.unpack("<HH", got[0x03])
-            if pair not in allowed:
-                raise Reject(m.UNAVAILABLE)                        # a pair this probe does not allow
+            if not self._allows(fn, pair) or set(pair) & self._held(fn, pair):
+                raise Reject(m.UNAVAILABLE)                        # not allowed here, or its pins are held (§8.1)
             return pair
+        allowed = self._allowed_pairs(fn)
         if len(allowed) != 1:
             raise Reject(m.UNAVAILABLE)                            # the host chooses among several
         return allowed[0]
@@ -779,7 +830,7 @@ class Endpoint:
 
     def _target_of(self, cid: int) -> FakeTarget:
         c = self.conns[cid]
-        return self.targets[(c.fn, c.pair)]
+        return self._target(c.fn, c.pair)
 
     # ---- oep.target.riscv-dm --------------------------------------------------------------------
     @staticmethod
@@ -1181,7 +1232,7 @@ class Endpoint:
         places = [(s.wire_fn, s.pair) for s in slots.values()]
         if len(set(places)) != len(places):
             raise Reject(m.UNAVAILABLE)
-        for fn in self.pairs:
+        for fn in self.pairs:                                      # every wire (pin_roles wires have an empty list)
             if sum(1 for s in slots.values() if s.wire_fn == fn and s.attach == SLOT_ATTACH["at_boot"]) > \
                     self.max_connections.get(fn, 1):
                 raise Reject(m.UNAVAILABLE)
@@ -1244,7 +1295,7 @@ class Endpoint:
             raise Reject(m.MALFORMED)
         if not SLOT_NAME.fullmatch(name.decode("ascii", "replace")):
             raise Reject(m.MALFORMED)
-        if self.names.get(wire_fn) not in WIRES or (swdio, swclk) not in self.pairs.get(wire_fn, []):
+        if self.names.get(wire_fn) not in WIRES or not self._allows(wire_fn, (swdio, swclk)):
             raise Reject(m.UNAVAILABLE)
         if mech not in self.mechanisms:
             raise Reject(m.UNSUPPORTED)
@@ -1301,7 +1352,7 @@ class Endpoint:
         s = self.slots[n]
         rt = self.slot_rt[n]
         rt.last_try_ms = self.now()
-        tg = self.targets[(s.wire_fn, s.pair)]
+        tg = self._target(s.wire_fn, s.pair)
         cid = self._conn_at(s.wire_fn, s.pair)
         if cid is None:
             if not tg.present:

oep_client/fake.py

@@ -139,7 +139,8 @@ def _core(firmware: str, model: str, unit_id: bytes, channels: int, reserved: li
     return Offered(0, 0, "oep.core", (
         catalog.text(CORE_FIRMWARE, firmware), catalog.text(CORE_MODEL, model), catalog.tlv(CORE_UNIT_ID, unit_id),
         catalog.u16(CORE_CHANNELS, channels), catalog.tlv(CORE_RESERVED, struct.pack("<H", base) + bits),
-        catalog.text(CORE_PROFILE, profile)) + tuple(_label(c, n) for c, n in labels.items()) + extra)
+        ) + ((catalog.text(CORE_PROFILE, profile),) if profile else ()) + tuple(_label(c, n) for c, n in labels.items())
+        + extra)
 
 
 def p4_x035() -> FakeProbe:
@@ -230,4 +231,24 @@ def p4_bench() -> FakeProbe:
     ])
 
 
-PROFILES = {"p4-x035": p4_x035, "esp32-v003": esp32_v003, "p4-bench": p4_bench}
+def rp2350_pins() -> FakeProbe:
+    """A board firmware whose wire takes its pins from the host (oep-if-debug §1, role_channels): any two of GP0-GP29
+    but GP19 (the Pro Micro RP2350's PSRAM CS) are an RVSWD pair, a reset line or fixture pins. USB CDC (serial port 0).
+    The fake target answers on (0, 1), the first pair."""
+    reserved = [19]
+    pins = [p for p in range(30) if p not in reserved]
+    return FakeProbe("rp2350-pins", 1024, [
+        _core("3.0.0", "sparkfun-promicro-rp2350", bytes.fromhex("e66138935f2b1f2c"), 30, reserved, "",
+              {}, _transports([(TRANSPORT["usb_cdc"], 0)])),
+        Offered(1, 1, "oep.wire.rvswd", _roles({1: pins, 2: pins, 3: pins}) + (
+            catalog.u32(MAX_CLOCK_HZ, 5_000_000), catalog.u8(IMPLEMENTATION, 1), catalog.u8(MAX_CONNECTIONS, 1))),
+        Offered(2, 1, "oep.target.riscv-dm", (catalog.u32(FEATURES, 0b1111), catalog.u8(IMPLEMENTATION, 1),
+                                              catalog.u16(MAX_LENGTH, 1000))),
+        Offered(3, 1, "oep.target.console", (catalog.tlv(MECHANISMS, bytes([0, 1, 2])),)),
+        Offered(4, 2, "oep.fixture.gpio", _roles({1: pins})),
+        Offered(5, 3, "oep.fixture.uart", _roles({1: pins, 2: pins}) + (
+            catalog.u32(MAX_CLOCK_HZ, 3_000_000), catalog.u8(IMPLEMENTATION, 2))),
+    ])
+
+
+PROFILES = {"p4-x035": p4_x035, "esp32-v003": esp32_v003, "p4-bench": p4_bench, "rp2350-pins": rp2350_pins}

oep_client/registry.py

@@ -2,7 +2,7 @@
 
 from types import SimpleNamespace as _NS
 
-REGISTRY_HASH = "dd6d527421bb6206"
+REGISTRY_HASH = "08b7d1656bf59269"
 SCHEMA = 1
 PROTOCOL_REVISION = 1
 CONFIRM_REQUEST_MAGIC = 'OEP?'
@@ -25,13 +25,13 @@ CORE = _NS(name="oep.core", revision=1, op={"confirm": 0x01, "list": 0x02, "desc
     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, "plan_roles": 0x4B}}, 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, "idle_clock": 0x04}, "attach_under_reset": {"max_speed": 0x01, "pins": 0x03, "idle_clock": 0x04}, "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, "reset": 0x03}, "idle_clock": {"high": 0x00, "low": 0x01}}, own={})
+    closed_tail={}, tlv={"describe": {"max_connections": 0x40}, "scan": {"skip": 0x01}, "detach": {"force": 0x01}, "attach": {"max_speed": 0x01, "pins": 0x03, "idle_clock": 0x04}, "attach_under_reset": {"max_speed": 0x01, "pins": 0x03, "idle_clock": 0x04}, "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, "reset": 0x03}, "idle_clock": {"high": 0x00, "low": 0x01}}, 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, "reset": 0x03}}, own={})
+    closed_tail={}, tlv={"describe": {"max_connections": 0x40}, "scan": {"skip": 0x01}, "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, "reset": 0x03}}, 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={})
+    closed_tail={}, tlv={"describe": {"max_connections": 0x40}, "scan": {"skip": 0x01}, "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": {}, "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={})

oep_client/riscv.py

@@ -76,23 +76,36 @@ class WireBase(Interface):
     TAG_MAX_SPEED = 0x01
     TAG_PINS = 0x03          # swdio(u16) swclk(u16, 0xFFFF on one wire), critical (oep-if-debug §1)
 
+    TAG_SKIP = 0x01          # scan, count 0 only: pairs of the count-0 list to skip (oep-if-debug §1)
+
     def scan(self, pairs: list[tuple[int, int]] | None = None) -> list[Found]:
-        """Try `pairs` of (swdio, swclk); None = every pair the probe allows (describe's channel_group /
-        role_channels). A pair the probe does not allow refuses the whole scan (rejected unavailable). The probe stops
-        when its answer would not fit one frame and says how many pairs it tried; the rest go again (oep-if-debug §1)."""
-        pairs = list(pairs or [])
+        """Try `pairs` of (swdio, swclk); None = every pair the probe allows and nothing holds (describe's
+        channel_group / role_channels, oep-if-debug §1). A pair the probe does not allow, or one whose pins something
+        holds, refuses the whole scan (rejected unavailable). The probe tries at most 255 pairs a request and stops early
+        when its answer would not fit one frame; this goes on until every pair is tried (count 0: with skip until
+        tried = 0)."""
         out = []
+        pairs = list(pairs or [])
+        skip = 0
         while True:
-            body = bytes([len(pairs)]) + b"".join(struct.pack("<HH", d, c) for d, c in pairs)
+            chunk = pairs[:255]
+            body = bytes([len(chunk)]) + b"".join(struct.pack("<HH", d, c) for d, c in chunk)
+            if not pairs and skip:
+                body += m.tlv(self.TAG_SKIP, struct.pack("<H", skip))
             rd = m.Reader(self._call(self.SCAN, body).payload)
             tried, count = rd.take("BB")
             for _ in range(count):
                 kind, dio, clk, status = rd.take("BHHI")
                 out.append(Found(kind, (dio, clk), status))
             rd.tail()
-            if not pairs or tried >= len(pairs) or tried == 0:
+            if tried == 0:
                 return out
-            pairs = pairs[tried:]
+            if pairs:
+                pairs = pairs[tried:]
+                if not pairs:
+                    return out
+            else:
+                skip += tried
 
     def detach(self, conn: int) -> None:
         self._call(self.DETACH, struct.pack("<H", conn))

{oep_client_python-0.0.7.dist-info → oep_client_python-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.7
+Version: 0.0.8
 Summary: Open Embedded Probe (OEP) v1 host: serial / USB / TCP transports, the session rules, the standard interfaces, and a fake probe
 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.7.dist-info → oep_client_python-0.0.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-oep_client/__init__.py,sha256=Eo4zAyMLP7Kn4ZVfKG_wGeLWVvEnMO3lQdewP4ORx6k,163
+oep_client/__init__.py,sha256=6mobCxy7gb0xBip7N4wVAbSsDJZjvzzWtMDUU5jpXu8,163
 oep_client/__main__.py,sha256=qtVGdpAHULBtLY2SedabJf-uwDZZhMf_YmrbqRzM57U,14669
 oep_client/arm.py,sha256=JLyUhLSPcmsk73schZcaJYoOKuHzrvnU8kPmfrEvVuo,12331
 oep_client/capture.py,sha256=hs8mQU1gE1P67GOivxw2C2Ur8wimWqCdhtk1nqGN71Q,18092
@@ -10,9 +10,9 @@ oep_client/console.py,sha256=YYcuc9Qxe3kihla8wynYbDaLVr7wBLEvswrM-cMK3Tk,6859
 oep_client/core.py,sha256=Cyyaknjipkg6tS76dZe5GMqjmOoQjlfeP0WFtMHkJNs,10403
 oep_client/decode.py,sha256=M-bRARrA2qGZLoJn0BdXeTb4WjL_2Hb2nk_g1IGXIw4,2382
 oep_client/dump.py,sha256=GAnmu2abuDmGmbWcbbEfC3EUuPp5Hady9vQVNcQ-724,6743
-oep_client/endpoint.py,sha256=tRx9ZUIiFN0J9NS3OwZ89NorIV7XqmZbYeUMnvJb6bE,74082
+oep_client/endpoint.py,sha256=Cmzrjsrv--70cUu2UVNpJ0RZVJesV9DNJweg1jOYe0s,77818
 oep_client/esp32_targets.py,sha256=b8tNH-nb2KC-XgNfWg5l3TO0cyhZOF-gJajaVxNVSGQ,4988
-oep_client/fake.py,sha256=TJpzwSCFDSco-3HCE2ZHzusMx0r0dtrD1bkGn6aos90,13136
+oep_client/fake.py,sha256=oaEMn0cjIalcQKPQ2mZ5KL-E6U_43Ppr3-dj96dS7Q0,14513
 oep_client/fake_serial.py,sha256=uKl0UNcifhdeykQtm8gnRRhqV7TT4vPwBFuBhbf-9BI,4504
 oep_client/fake_serve.py,sha256=Ke_hGRiOayCyut-uYOa0PaOFzy-zlvPHGwjs4HEZkAQ,14644
 oep_client/fixture.py,sha256=653hCD-Iz0Lfs8dT4Hdg3QyubbbOGs1_xjq_3nb8foU,5564
@@ -23,14 +23,14 @@ oep_client/interfaces.py,sha256=TNvof5blyLjO1Mc0OentKcMVBD_5e4riRG18UgEh2ZE,5380
 oep_client/link.py,sha256=J9VtBWfTgNoIgUQuj8SsH9hHesQM2uEN545IoxKVS8E,19406
 oep_client/message.py,sha256=MEM1UT6KFM7AsT56jvBLt_FJK_6SJ7O_nGAiipW0_zo,9912
 oep_client/names.py,sha256=ztCZFWs__aR-a5G14TnJP-Q4YfLhbyrzvOVOMJuG93k,3653
-oep_client/registry.py,sha256=uO9Ilx_pPPhLD-17TosgXH9QfI11DymYNIR-EacaZOw,9984
-oep_client/riscv.py,sha256=PNeo_HXlq08b4h083olOOrGxqejD6ggQ7QzVqkIHEMA,22621
+oep_client/registry.py,sha256=6FVVEs1b6krGygH21zma84mmMB_B65dh8S7PrjYrME0,10056
+oep_client/riscv.py,sha256=H9kE_oUsnaBzqdTXDAVgDQkDvsrn5ZwsVi8dF1W_BDM,23117
 oep_client/rp2350.py,sha256=7OMyj270k3AY1e3-ljicPwOjf9jOlokbT6QNkA0b0yY,4227
 oep_client/target.py,sha256=R8BvYfFfYNhZF0MysJkNb8b69YgBlmeGXNX8ReZIe5k,1068
 oep_client/uiapduino.py,sha256=IEPG3LbZPksi8g3wmAf6T0CRWSfYKW1_qrH_GBVQdxY,6090
 oep_client/usb_stream.py,sha256=VJMCxsOlQCk005FcS92pqTh33fRSFBizoL__L0VbUMA,10242
-oep_client_python-0.0.7.dist-info/METADATA,sha256=Shg-dYEbV4747Sl1HZlRz-AxoIdVQ2Z9LzszmjCTdnY,7368
-oep_client_python-0.0.7.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-oep_client_python-0.0.7.dist-info/entry_points.txt,sha256=h6_8QX89Ww1ogALEGG5g4kspT3IOV6O51lwKqf5BWco,49
-oep_client_python-0.0.7.dist-info/licenses/LICENSE,sha256=ntlalztb3L1OaNAxmQdHlubu5fVhjMc9oRZi3PeQhXg,1076
-oep_client_python-0.0.7.dist-info/RECORD,,
+oep_client_python-0.0.8.dist-info/METADATA,sha256=TKbEmCwYIw03I3j7Rt-N1El8OQdlAvTQcLtVvb2mNMY,7368
+oep_client_python-0.0.8.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+oep_client_python-0.0.8.dist-info/entry_points.txt,sha256=h6_8QX89Ww1ogALEGG5g4kspT3IOV6O51lwKqf5BWco,49
+oep_client_python-0.0.8.dist-info/licenses/LICENSE,sha256=ntlalztb3L1OaNAxmQdHlubu5fVhjMc9oRZi3PeQhXg,1076
+oep_client_python-0.0.8.dist-info/RECORD,,