oep-client-python 0.0.4__tar.gz → 0.0.6__tar.gz

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 0.0.6
+- (EN) No default reset line (oep-if-debug §3): `Wire.attach_under_reset(channel, ...)` needs its channel, and `Wire.reset_channels()` reads the ones the probe allows (describe role_channels, role reset). The fake takes only those, and not one a plan holds.
+- (JA) 既定の reset 線は無くなった（oep-if-debug §3）: `Wire.attach_under_reset(channel, ...)` は channel が必須。probe が許す channel は `Wire.reset_channels()` で読む（describe の role_channels の role reset）。偽の probe はそれだけを受け、plan が持つ channel は断る。
+- (EN) The line's settings are the target's, passed by the host: `attach(..., idle_clock="low")` (rvswd, critical) and the probe.config slot's new max_speed / idle_clock fields (`oep config slot --max-speed --idle-clock`) for the probe's own attach. The slot item's layout changed.
+- (JA) 線の設定は target のもので、host が渡す: `attach(..., idle_clock="low")`（rvswd、critical）と、probe が自分で attach するための probe.config のスロットの max_speed / idle_clock（`oep config slot --max-speed --idle-clock`）。スロットの項目の形が変わった。
+- (EN) The fake probe keeps a plan the settings put in (oep-core §8): plan_release leaves it (n = 0 included) and plan_apply naming its fn is rejected unavailable.
+- (JA) 偽の probe は、設定が入れた plan を設定のものとして扱う（oep-core §8）: plan_release はそれを解かず（n = 0 でも）、その fn を挙げた plan_apply は rejected unavailable。
+
+## 0.0.5
+- (EN) USB (python-libusb1) streams close cleanly and at exit: the IN transfers are cancelled and taken back by the event thread before the handle and the context go. A program that ended without closing the link hung at exit, or libusb aborted.
+- (JA) USB（python-libusb1）の stream は、終了時にも片付いて閉じる: IN の転送を取り消し、event thread が取り戻してから handle と context を閉じる。link を閉じずに終わったプログラムが終了で固まったり、libusb が abort したりしていた。
+- (EN) `core.plan_apply` refused as unavailable names what holds the pins when the settings say so (`core.PinsTaken`: another fn's saved plan, a slot).
+- (JA) `core.plan_apply` が unavailable で断られたとき、設定から分かれば何がピンを持っているかを示す（`core.PinsTaken`: 別の fn の保存した plan、スロット）。
+- (EN) Fake probe: a read from the last mark of a kind that is not there starts now, not at the oldest byte (oep-if-common §1.2).
+- (JA) 偽の probe: その kind のマークが無いときの「最後のマークから」の read は、一番古い位置ではなく今から（oep-if-common §1.2）。
+
 ## 0.0.4
 - (EN) Fake serial port: a candidate that is only its 0x00 is not raw after the 200 ms gap (the probe firmware had the same bug: a stray 0x00 reached the target's console).
 - (JA) 偽のシリアルの口: 0x00 だけの候補は、200 ms の後も生のバイトにしない（probe の firmware にも同じバグがあり、target のコンソールに 0x00 が届いていた）。

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.4
+Version: 0.0.6
 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
@@ -43,7 +43,7 @@ uv run pytest                     # in a checkout
 `oep-client` is another project, so the distribution is named `oep-client-python`.
 
 Releases: run the GitHub Actions workflow Release (workflow_dispatch, version X.Y.Z or X.Y.ZbN). `tools/prepare_release.py`
-sets the version in pyproject.toml and `oep_client.__version__` and turns CHANGELOG.md's Unreleased into that version; after
+sets the version in pyproject.toml, uv.lock and `oep_client.__version__` and turns CHANGELOG.md's Unreleased into that version; after
 the tests and the build it commits, tags, makes the GitHub Release and publishes to PyPI (Trusted Publishing). Record changes
 under Unreleased in CHANGELOG.md, (EN) and (JA).
 

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/README.ja.md

@@ -18,7 +18,7 @@ uv run pytest                                                            # in a
 oep-spec から写す。PyPI の `oep-client` は別のプロジェクトなので、配布名は `oep-client-python`。
 
 リリースは GitHub Actions の Release（workflow_dispatch、version = X.Y.Z か X.Y.ZbN）: `tools/prepare_release.py` が
-pyproject.toml と `oep_client.__version__` を書き換え、CHANGELOG.md の Unreleased をその版にし、試験と build の後に commit と tag、
+pyproject.toml、uv.lock、`oep_client.__version__` を書き換え、CHANGELOG.md の Unreleased をその版にし、試験と build の後に commit と tag、
 GitHub Release、PyPI（Trusted Publishing）へ出す。変更は CHANGELOG.md の Unreleased に (EN) / (JA) で書き足しておく。
 
 ## モジュール（`oep_client`）

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/README.md

@@ -21,7 +21,7 @@ uv run pytest                     # in a checkout
 `oep-client` is another project, so the distribution is named `oep-client-python`.
 
 Releases: run the GitHub Actions workflow Release (workflow_dispatch, version X.Y.Z or X.Y.ZbN). `tools/prepare_release.py`
-sets the version in pyproject.toml and `oep_client.__version__` and turns CHANGELOG.md's Unreleased into that version; after
+sets the version in pyproject.toml, uv.lock and `oep_client.__version__` and turns CHANGELOG.md's Unreleased into that version; after
 the tests and the build it commits, tags, makes the GitHub Release and publishes to PyPI (Trusted Publishing). Record changes
 under Unreleased in CHANGELOG.md, (EN) and (JA).
 

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "oep-client-python"
-version = "0.0.4"
+version = "0.0.6"
 description = "Open Embedded Probe (OEP) v1 host: serial / USB / TCP transports, the session rules, the standard interfaces, and a fake probe"
 readme = "README.md"
 license = "MIT"

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/src/oep_client/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.0.4"
+__version__ = "0.0.6"

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/src/oep_client/__main__.py

@@ -64,6 +64,10 @@ def _config_parser(sub) -> None:
     slot.add_argument("--attach", choices=sorted(config.ATTACH), default="host")
     slot.add_argument("--retry", type=int, default=0, help="at-boot: try again every N s while absent (0: never)")
     slot.add_argument("--mechanism", choices=sorted(config.MECHANISM), default="dmseq")
+    slot.add_argument("--max-speed", type=int, default=0,
+                      help="the line's ceiling in Hz for the probe's own attach (0: none); the target's, e.g. 1000000")
+    slot.add_argument("--idle-clock", choices=sorted(config.IDLE_CLOCK), default="high",
+                      help="rvswd: SWCLK while the line rests (the target's: low on CH32L103 / V203)")
     slot.add_argument("--lock", help="MASK:VALUE (hex u32) the target_id (WCH DMI 0x7F) must match, e.g. ffffff0f:035e0600")
     slot.add_argument("--save", action="store_true", help="save after the change")
     bind = cs.add_parser("bind", help="what a serial port carries")
@@ -183,7 +187,7 @@ def _config(args) -> int:
                 mask, _, value = args.lock.partition(":")
                 lock = (1, struct.pack("<I", int(mask, 16)), struct.pack("<I", int(value, 16)))
             it = config.Slot(args.slot, fn, _pins(hst, fn, args.pins, args.wire), args.name, args.attach, args.retry,
-                             args.mechanism, lock)
+                             args.mechanism, lock, args.max_speed, args.idle_clock)
             _change(hst, cfg, [it], args.save)
         elif args.action == "bind":
             slots = {it.name: it.slot for it in cfg.items() if isinstance(it, config.Slot)}
@@ -250,6 +254,7 @@ def _show(hst, cfg, as_json: bool) -> int:
             s = by_slot.get(it.slot)
             pins = f"{it.pins[0]}" if it.pins[1] == 0xFFFF else f"{it.pins[0]},{it.pins[1]}"
             retry = f" retry {it.retry_s} s" if it.attach == "at-boot" else ""
+            retry += (f" max {it.max_speed} Hz" if it.max_speed else "") + (" idle-low" if it.idle_clock == "low" else "")
             lock = (f" lock {int.from_bytes(it.lock[1], 'little'):08x}:{int.from_bytes(it.lock[2], 'little'):08x}"
                     if it.lock else "")
             live = ""

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/src/oep_client/config.py

@@ -29,6 +29,7 @@ MECHANISM = {k: v for k, v in reg.TARGET_CONSOLE.enum["mechanism"].items()}
 SLOT_STATE = {v: k.replace("_", "-") for k, v in _CFG.enum["slot_state"].items()}
 BIND_FLOW = {v: k for k, v in _CFG.enum["bind_flow"].items()}
 IDLE = {k.replace("_", "-"): v for k, v in _CFG.enum["idle_mode"].items()}
+IDLE_CLOCK = dict(reg.WIRE_RVSWD.enum["idle_clock"])            # a slot's idle_clock (oep-if-debug §3)
 STORAGE_STATE = {v: k for k, v in _CFG.enum["storage_state"].items()}
 
 
@@ -79,12 +80,15 @@ class Slot:
     retry_s: int = 0               # at-boot: try again every retry_s while the target is not there (0: never)
     mechanism: str = "dmseq"       # sdi, dmdata, dmseq
     lock: tuple[int, bytes, bytes] | None = None
+    max_speed: int = 0             # the line's ceiling in Hz for the probe's own attach (0: none) - the target's
+    idle_clock: str = "high"       # rvswd: SWCLK while the line rests, high / low - the target's (oep-if-debug §3)
     TAG = ITEM["slot"]
 
     def value(self) -> bytes:
         name = self.name.encode()
-        v = struct.pack("<BHHHBHBB", self.slot, self.wire_fn, *self.pins, ATTACH[self.attach],
-                        self.retry_s if self.attach == "at-boot" else 0, MECHANISM[self.mechanism], len(name)) + name
+        v = struct.pack("<BHHHBHIBBB", self.slot, self.wire_fn, *self.pins, ATTACH[self.attach],
+                        self.retry_s if self.attach == "at-boot" else 0, self.max_speed, IDLE_CLOCK[self.idle_clock],
+                        MECHANISM[self.mechanism], len(name)) + name
         if self.lock is None:
             return v + b"\x00"
         scheme, mask, value = self.lock
@@ -127,15 +131,16 @@ def decode(tag: int, v: bytes):
         return Label(struct.unpack_from("<H", v)[0], v[2:].decode("utf-8", "replace"))
     if tag == ITEM["idle"] and len(v) == 3:
         return Idle(struct.unpack_from("<H", v)[0], _name(IDLE, v[2]))
-    if tag == ITEM["slot"] and len(v) >= 13:
-        n, wire_fn, swdio, swclk, attach, retry_s, mech, name_len = struct.unpack_from("<BHHHBHBB", v)
-        name = v[12:12 + name_len].decode("ascii", "replace")
-        rest = v[12 + name_len:]
+    if tag == ITEM["slot"] and len(v) >= 18:
+        n, wire_fn, swdio, swclk, attach, retry_s, max_speed, idle, mech, name_len = struct.unpack_from("<BHHHBHIBBB", v)
+        name = v[17:17 + name_len].decode("ascii", "replace")
+        rest = v[17 + name_len:]
         lock = None
         if rest and rest[0]:
             half = (len(rest) - 1) // 2
             lock = (rest[0], rest[1:1 + half], rest[1 + half:])
-        return Slot(n, wire_fn, (swdio, swclk), name, _name(ATTACH, attach), retry_s, _name(MECHANISM, mech), lock)
+        return Slot(n, wire_fn, (swdio, swclk), name, _name(ATTACH, attach), retry_s, _name(MECHANISM, mech), lock,
+                    max_speed, _name(IDLE_CLOCK, idle))
     if tag == ITEM["bind"] and len(v) >= 4:
         port, mode, selected, n = struct.unpack_from("<BBBB", v)
         streams = [(_name(STREAM, v[4 + 3 * k]), struct.unpack_from("<H", v, 5 + 3 * k)[0]) for k in range(n)]

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/src/oep_client/core.py

@@ -109,7 +109,47 @@ def plan_apply(hst: h.Host, assignments: list[tuple[int, int, int]]) -> None:
     all interfaces accept their roles or nothing changes. The plan is the
     session's resource: kept over an explicit end, released at a lease lapse or a force takeover (oep-core §9)."""
     tlv = b"".join(bytes([TAG_ROLE_ASSIGNMENT, 5]) + struct.pack("<HBH", fn, role, ch) for fn, role, ch in assignments)
-    hst.call(m.CORE_FN, OP_PLAN_APPLY, tlv)
+    try:
+        hst.call(m.CORE_FN, OP_PLAN_APPLY, tlv)
+    except h.Rejected as e:
+        if e.result.detail != m.UNAVAILABLE:
+            raise
+        why = _pin_holders(hst, assignments)
+        if why:
+            raise PinsTaken(e.result, why) from None
+        raise
+
+
+class PinsTaken(h.Rejected):
+    """plan_apply refused (unavailable) and the probe's settings say why: a pin kept by another fn's saved plan or by a
+    slot (oep.probe.config). `holders`: (channel, what holds it)."""
+
+    def __init__(self, result, holders: list[tuple[int, str]]):
+        super().__init__(result)
+        self.holders = holders
+
+    def __str__(self) -> str:
+        return "pins taken: " + "; ".join(f"channel {ch} by {who}" for ch, who in self.holders) + \
+            " (oep config show; oep config remove <probe> plan <fn> frees a saved plan)"
+
+
+def _pin_holders(hst: h.Host, assignments: list[tuple[int, int, int]]) -> list[tuple[int, str]]:
+    """What the settings keep on the channels asked for (best effort: an empty list when there is no oep.probe.config
+    or it cannot be read)."""
+    from . import config
+    try:
+        items = config.ProbeConfig(hst).items()
+    except (LookupError, h.OepError):
+        return []
+    fns = {fn for fn, _, _ in assignments}
+    out = []
+    for fn, role, ch in assignments:
+        for it in items:
+            if isinstance(it, config.Plan) and it.channel == ch and it.fn not in fns:
+                out.append((ch, f"the saved plan of fn {it.fn} (role {it.role})"))
+            elif isinstance(it, config.Slot) and ch in it.pins:
+                out.append((ch, f"slot {it.slot} {it.name}"))
+    return out
 
 
 def plan_release(hst: h.Host, fns: list[int] | tuple[int, ...] = ()) -> None:

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/src/oep_client/endpoint.py

@@ -60,6 +60,7 @@ WIRES = ("oep.wire.rvswd", "oep.wire.swio")
 OWNER = reg.CORE.tlv["open"]["owner"]
 SLOT_NAME = re.compile(r"[a-z0-9_-]{1,32}")
 NO_SLOT, NEVER = 0xFF, 0xFFFFFFFF
+PIN_ROLE_RESET = reg.WIRE_RVSWD.enum["pin_role"]["reset"]   # the channels attach_under_reset may take
 
 
 class Reject(Exception):
@@ -180,6 +181,7 @@ class Connection:
     speed: int = 4_000_000
     tid: int | None = None
     users: set = field(default_factory=set)            # "host" and/or ("slot", n)
+    idle_clock: int = 0                                # rvswd: SWCLK while the line rests, 0 high / 1 low
 
 
 @dataclass(frozen=True)
@@ -189,6 +191,8 @@ class Slot:
     pair: tuple[int, int]
     attach: int
     retry_s: int
+    max_speed: int                                     # 0: no ceiling (oep-if-debug §3: the target's, the host's to set)
+    idle_clock: int
     mechanism: int
     name: str
     lock: tuple[int, bytes, bytes] | None              # (scheme, mask, value)
@@ -249,9 +253,13 @@ class Endpoint:
         self.serial_ports = {i for i, k in enumerate(self.transports) if k in fake.SERIAL_KINDS}
         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)
         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]
+                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]}
@@ -575,17 +583,18 @@ class Endpoint:
                     got.append(struct.unpack_from("<HBH", value))
                 elif tag & m.TAG_CRITICAL:
                     return m.REJECTED, m.UNSUPPORTED, bytes([tag])
-            self._check_plan(got)
             named = {fn for fn, _, _ in got}
+            if named & self.plan_from_config:                       # the settings' plan is the settings' (core §8)
+                raise Reject(m.UNAVAILABLE)
+            self._check_plan(got)
             self.plan = {a for a in self.plan if a[0] not in named} | set(got)
-            self.plan_from_config -= named
             return m.COMPLETED, m.SUCCESS, b""
         if op == m.OP_PLAN_RELEASE:                                 # n(u8) n x fn(u16); n = 0: every fn
             n = t.take("B")
             fns = {t.take("H") for _ in range(n)}
             t.tail()
-            for fn in {a[0] for a in self.plan if not fns or a[0] in fns}:
-                self._drop_plan(fn)
+            for fn in {a[0] for a in self.plan if not fns or a[0] in fns} - self.plan_from_config:
+                self._drop_plan(fn)                                 # the settings' plans stay, n = 0 too (core §8)
             return m.COMPLETED, m.SUCCESS, b""
         return m.REJECTED, m.UNKNOWN_OPERATION, b""
 
@@ -657,10 +666,14 @@ class Endpoint:
                 if method > 1:
                     raise Reject(m.UNSUPPORTED)
             else:
-                channel, _hold = t.take("HH")
-                if channel not in (0xFFFF, self._channel_named("NRST")):
+                channel, _hold = t.take("HH")                       # no default reset line (oep-if-debug §3)
+                if channel not in self.reset_channels.get(fn, set()) or any(a[2] == channel for a in self.plan):
                     raise Reject(m.UNAVAILABLE)
-            got, ignored = t.tail({0x01, 0x03})
+            rvswd = self.names[fn] == "oep.wire.rvswd"
+            got, ignored = t.tail({0x01, 0x03, 0x04} if rvswd else {0x01, 0x03})
+            if 0x04 in got and (len(got[0x04]) != 1 or got[0x04][0] > 1):
+                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)]
             speed = min(4_000_000, struct.unpack("<I", got[0x01])[0]) if 0x01 in got else 4_000_000
@@ -676,6 +689,7 @@ class Endpoint:
                 flags |= 2
                 self.conns[cid].speed = min(self.conns[cid].speed, speed)
             c = self.conns[cid]
+            c.idle_clock = idle_clock                              # an existing connection takes the new rest level
             c.users.add("host")
             for n, s in self.slots.items():                        # a new connection for an evicted slot: a new cue
                 if s.wire_fn == fn and s.pair == pair:
@@ -923,7 +937,7 @@ class Endpoint:
                 pos = s.end
             elif frm == 3:
                 hits = [mk for mk in s.marks if arg == 0 or mk[2] == arg]
-                pos = hits[-1][1] if hits else s.base
+                pos = hits[-1][1] if hits else s.end                 # no such mark: from now (common §1.2)
             else:
                 raise Reject(m.UNSUPPORTED)
             flags = 0
@@ -1218,7 +1232,7 @@ class Endpoint:
 
     def _parse_slot(self, v: bytes) -> Slot:
         t = Take(v)
-        n, wire_fn, swdio, swclk, attach, retry_s, mech, name_len = t.take("BHHHBHBB")
+        n, wire_fn, swdio, swclk, attach, retry_s, max_speed, idle_clock, mech, name_len = t.take("BHHHBHIBBB")
         name = t.bytes(name_len)
         scheme = t.take("B")
         rest = v[t.at:]
@@ -1226,6 +1240,8 @@ class Endpoint:
             raise Reject(m.MALFORMED)
         if retry_s and attach != SLOT_ATTACH["at_boot"]:
             raise Reject(m.MALFORMED)
+        if idle_clock > 1 or (idle_clock and self.names.get(wire_fn) != "oep.wire.rvswd"):
+            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, []):
@@ -1239,7 +1255,7 @@ class Endpoint:
             lock = (scheme, rest[:len(rest) // 2], rest[len(rest) // 2:])
         elif rest:
             raise Reject(m.MALFORMED)
-        return Slot(n, wire_fn, (swdio, swclk), attach, retry_s, mech, name.decode(), lock)
+        return Slot(n, wire_fn, (swdio, swclk), attach, retry_s, max_speed, idle_clock, mech, name.decode(), lock)
 
     def _parse_bind(self, v: bytes, slots: dict[int, Slot]) -> Bind:
         t = Take(v)
@@ -1291,7 +1307,9 @@ class Endpoint:
             if not tg.present:
                 return
             try:
-                cid = self._seat(s.wire_fn, s.pair, tg, 4_000_000, evict=False)   # automatic: never evicts
+                speed = min(4_000_000, s.max_speed) if s.max_speed else 4_000_000   # the slot's line settings
+                cid = self._seat(s.wire_fn, s.pair, tg, speed, evict=False)   # automatic: never evicts
+                self.conns[cid].idle_clock = s.idle_clock
             except Reject:
                 return
             tg.havereset = False

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/src/oep_client/fake.py

@@ -185,8 +185,8 @@ def esp32_v003() -> FakeProbe:
         _core("3.0.0", "esp32-d0wd", bytes.fromhex("0070070d9394"), 40, reserved, f"{NS}.esp32-v003",
               {16: "SWIO", 23: "NRST", 22: "DUT TX", 21: "DUT RX"},
               _transports([(TRANSPORT["uart_bridge"], 0xFF)])),
-        Offered(1, 1, "oep.wire.swio", (catalog.channel_group(1, [(1, 16)]), catalog.u8(IMPLEMENTATION, 1),
-                                        catalog.u8(MAX_CONNECTIONS, 1))),
+        Offered(1, 1, "oep.wire.swio", (catalog.channel_group(1, [(1, 16)]), catalog.role_channels(3, [23]),
+                                        catalog.u8(IMPLEMENTATION, 1), catalog.u8(MAX_CONNECTIONS, 1))),
         Offered(2, 1, "oep.target.riscv-dm", (catalog.u32(FEATURES, 0b0111), catalog.u8(IMPLEMENTATION, 1),
                                               catalog.u16(MAX_LENGTH, 40))),
         Offered(3, 1, "oep.target.console", (catalog.tlv(MECHANISMS, bytes([0, 1, 2])),)),

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/src/oep_client/fake_serve.py

@@ -77,8 +77,8 @@ def build(a: argparse.Namespace) -> endpoint.Endpoint:
         swdio, swclk = ep.pairs[wire][n]
         mech = 2 if 2 in ep.mechanisms else min(ep.mechanisms)
         raw = name.encode()
-        value = struct.pack("<BHHHBHBB", n, wire, swdio, swclk, reg.PROBE_CONFIG.enum["slot_attach"]["at_boot"], 1,
-                            mech, len(raw)) + raw + b"\x00"             # no lock
+        value = struct.pack("<BHHHBHIBBB", n, wire, swdio, swclk, reg.PROBE_CONFIG.enum["slot_attach"]["at_boot"], 1,
+                            0, 0, mech, len(raw)) + raw + b"\x00"       # no speed ceiling, rests high, no lock
         items.append(bytes([_ITEM["slot"], len(value)]) + value)
     if a.bind:
         streams = b"".join(struct.pack("<BH", reg.PROBE_CONFIG.enum["bind_stream"]["slot_console"], n)

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/src/oep_client/registry.py

@@ -2,7 +2,7 @@
 
 from types import SimpleNamespace as _NS
 
-REGISTRY_HASH = "7ba704094c2898d2"
+REGISTRY_HASH = "049bd156b4775990"
 SCHEMA = 1
 PROTOCOL_REVISION = 1
 CONFIRM_REQUEST_MAGIC = 'OEP?'
@@ -22,13 +22,13 @@ TIMING = {"resync_quiet_ms": 0x32, "probe_frame_gap_ms": 0xC8, "host_frame_pause
 
 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={})
+    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}, "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={})
+    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={})
 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={})
+    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={})
 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={})

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/src/oep_client/riscv.py

@@ -14,8 +14,8 @@ import struct
 import time
 from dataclasses import dataclass, field
 
-from . import host as h, message as m, registry as reg
-from .core import Interface
+from . import catalog, host as h, message as m, registry as reg
+from .core import Interface, describe
 from .fixture import Gpio
 
 STATUS = reg.STATUS
@@ -109,7 +109,9 @@ class WireBase(Interface):
 class Wire(WireBase):
     """oep.wire.rvswd / oep.wire.swio (CH32 debug links to a RISC-V debug module)."""
     NAME = "oep.wire.rvswd"
-    DEFAULT_RESET = 0xFFFF
+    ROLE_RESET = reg.WIRE_RVSWD.enum["pin_role"]["reset"]
+    TAG_IDLE_CLOCK = reg.WIRE_RVSWD.tlv["attach"]["idle_clock"]
+    IDLE_CLOCK = reg.WIRE_RVSWD.enum["idle_clock"]
     RUN, HALT = reg.WIRE_RVSWD.enum["attach_method"]["run"], reg.WIRE_RVSWD.enum["attach_method"]["halt"]
     TAG_TARGET_ID = reg.WIRE_RVSWD.tlv["attach_answer"]["target_id"]
     SCHEME_WCH_DMI_7F = reg.WIRE_RVSWD.enum["target_id_scheme"]["wch_dmi_7f"]
@@ -125,12 +127,28 @@ class Wire(WireBase):
         v = tail.get(self.TAG_TARGET_ID)
         self.target_id = (v[0], bytes(v[1:])) if v else None
 
-    def attach(self, halt: bool = True, max_speed: int | None = None, pins: tuple[int, int] | None = None) -> tuple[int, int]:
+    def _idle_tlv(self, idle_clock: str | None) -> bytes:
+        # rvswd only, critical: a probe that cannot rest the line that way must refuse (oep-if-debug §3)
+        return b"" if idle_clock is None else m.tlv(self.TAG_IDLE_CLOCK, bytes([self.IDLE_CLOCK[idle_clock]]), critical=True)
+
+    def reset_channels(self) -> list[int]:
+        """The channels attach_under_reset may take (describe role_channels, role reset). There is no default reset
+        line: the host names one every time (oep-if-debug §3)."""
+        out = set()
+        for tag, v in describe(self.host, self.fn):
+            if tag & ~m.TAG_CRITICAL == catalog.ROLE_CHANNELS and v[0] == self.ROLE_RESET:
+                out.update(catalog.bitmap_to_channels(struct.unpack_from("<H", v, 1)[0], v[3:]))
+        return sorted(out)
+
+    def attach(self, halt: bool = True, max_speed: int | None = None, pins: tuple[int, int] | None = None,
+               idle_clock: str | None = None) -> tuple[int, int]:
         """-> (connection, DMSTATUS). Attaching an attached wire returns its connection as it is (self.existing).
         self.had_reset: a pending havereset was acknowledged first (a V00x's DMSTATUS halt / run bits stay frozen
         until then); self.speed_hz: the speed the probe chose; max_speed: a ceiling the probe must keep (critical);
-        self.target_id: (scheme, value) of the target's identity when the probe could read one (oep-if-debug §1)."""
-        body = bytes([self.HALT if halt else self.RUN]) + self._speed_tlv(max_speed) + self._pins_tlv(pins)
+        idle_clock: "high" / "low", how rvswd rests SWCLK (critical). Both are the target's, known by the host
+        (oep-if-debug §3). self.target_id: (scheme, value) of the target's identity when the probe could read one."""
+        body = (bytes([self.HALT if halt else self.RUN]) + self._speed_tlv(max_speed) + self._pins_tlv(pins)
+                + self._idle_tlv(idle_clock))
         rd = m.Reader(self._call(self.ATTACH, body).payload)
         conn, status, flags, self.speed_hz = rd.take("HIBI")
         self.had_reset, self.existing = bool(flags & 1), bool(flags & 2)
@@ -139,12 +157,13 @@ class Wire(WireBase):
         self._take_target_id(tail)
         return conn, status
 
-    def attach_under_reset(self, channel: int | None = None, hold_ms: int = 20,
-                           max_speed: int | None = None, pins: tuple[int, int] | None = None) -> tuple[int, int]:
-        """Hold the target in reset through `channel` (None: the probe's default reset line), attach, release and
-        halt it at once - the way back from firmware that turns the debug pins into GPIOs. -> (connection, dpc)"""
-        body = (struct.pack("<HH", self.DEFAULT_RESET if channel is None else channel, hold_ms) + self._speed_tlv(max_speed)
-                + self._pins_tlv(pins))
+    def attach_under_reset(self, channel: int, hold_ms: int = 20, max_speed: int | None = None,
+                           pins: tuple[int, int] | None = None, idle_clock: str | None = None) -> tuple[int, int]:
+        """Hold the target in reset through `channel` (always named: there is no default reset line; the probe
+        allows reset_channels()), attach, release and halt it at once - the way back from firmware that turns the
+        debug pins into GPIOs. -> (connection, dpc)"""
+        body = (struct.pack("<HH", channel, hold_ms) + self._speed_tlv(max_speed) + self._pins_tlv(pins)
+                + self._idle_tlv(idle_clock))
         rd = m.Reader(self._call(self.ATTACH_UNDER_RESET, body).payload)
         conn, dpc, self.speed_hz = rd.take("HII")
         self._take_target_id(rd.tail())

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/src/oep_client/usb_stream.py

@@ -10,6 +10,7 @@ transfer; if its timeout hits first, pyusb raises and the bytes already received
 
 from __future__ import annotations
 
+import atexit
 import threading
 import time
 
@@ -114,15 +115,21 @@ class UsbAsyncStream:
         self.timeout = 0.05
         self._buffer = bytearray()
         self._cond = threading.Condition()
-        self._closed = False
+        self._closed = False           # no more resubmits (close() started)
+        self._stop = False             # the event thread ends (every transfer is back)
         self._transfers = []
+        self._active = 0               # transfers submitted and not yet back for good
         for _ in range(self.DEPTH):
             t = handle.getTransfer()
             t.setBulk(endpoint_in, self.URB_SIZE, callback=self._done, timeout=0)
             t.submit()
             self._transfers.append(t)
+            self._active += 1
         self._events = threading.Thread(target=self._run, daemon=True)
         self._events.start()
+        # Closed at exit too: left to usb1's own finalizers, the context went while the event thread was inside
+        # handleEventsTimeout with transfers out - the process hung at exit or libusb aborted (usbi_mutex_destroy).
+        atexit.register(self.close)
 
     @classmethod
     def open(cls, vid: int, pid: int, serial: str | None = None) -> "UsbAsyncStream":
@@ -158,14 +165,23 @@ class UsbAsyncStream:
                     self._buffer += data
                     self._cond.notify_all()
         if not self._closed and status in (usb1.TRANSFER_COMPLETED, usb1.TRANSFER_TIMED_OUT):
-            transfer.submit()
+            try:
+                transfer.submit()
+                return
+            except usb1.USBError:
+                pass
+        with self._cond:
+            self._active -= 1          # back for good (cancelled, failed, or closing)
+            self._cond.notify_all()
 
     def _run(self) -> None:
-        while not self._closed:
+        while not self._stop:
             try:
                 self.context.handleEventsTimeout(0.1)
             except self._usb1.USBErrorInterrupted:
                 continue
+            except self._usb1.USBError:
+                break
 
     @property
     def in_waiting(self) -> int:
@@ -195,15 +211,27 @@ class UsbAsyncStream:
             self._buffer.clear()
 
     def close(self) -> None:
+        """Cancel the IN transfers and let the event thread take them back before the handle and the context go
+        (closing with transfers still out hung the process or aborted libusb). Safe to call twice (atexit)."""
+        if self._closed:
+            return
         self._closed = True
+        atexit.unregister(self.close)
         for t in self._transfers:
             try:
                 t.cancel()
             except self._usb1.USBError:
                 pass
-        self._events.join(timeout=0.5)
+        deadline = time.monotonic() + 1.0
+        with self._cond:
+            while self._active > 0 and self._events.is_alive() and time.monotonic() < deadline:
+                self._cond.wait(0.05)
+        self._stop = True
+        self._events.join(timeout=1.0)
         try:
             self.handle.releaseInterface(self.interface)
+        except self._usb1.USBError:
+            pass
         finally:
             self.handle.close()
             self.context.close()

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/tests/test_config.py

@@ -2,7 +2,9 @@
 
 import struct
 
-from oep_client import __main__ as cli, config, endpoint, fake, host as h
+import pytest
+
+from oep_client import __main__ as cli, config, endpoint, fake, host as h, message as m
 
 
 class Clock:
@@ -97,3 +99,55 @@ def test_slot_takes_the_only_wire_by_default(monkeypatch):
     assert cli.main(["config", "slot", "x", "--name", "v003", "--attach", "at-boot", "--retry", "1"]) == 0
     (slot,) = [i for i in config.ProbeConfig(hst).items() if isinstance(i, config.Slot)]
     assert slot.wire_fn == 1 and slot.pins == (16, 0xFFFF)
+
+
+def test_a_plan_refused_for_a_saved_plan_names_the_holder():
+    import pytest
+    from oep_client import core
+    ep, hst = open_bench()
+    cfg = config.ProbeConfig(hst)
+    cfg.set([config.Plan(5, 1, 20), config.Plan(5, 2, 21)])        # fixture.uart keeps 20 / 21 as a setting
+    with pytest.raises(core.PinsTaken) as e:
+        core.plan_apply(hst, [(4, 1, 21)])                          # gpio wants 21
+    assert e.value.holders == [(21, "the saved plan of fn 5 (role 2)")] and "fn 5" in str(e.value)
+
+
+def test_a_settings_plan_is_not_the_sessions():
+    """core §8: plan_release leaves a plan the settings put in (n = 0 too); plan_apply naming its fn is refused."""
+    ep, hst = open_bench()
+    config.ProbeConfig(hst).set([config.Plan(5, 1, 20), config.Plan(5, 2, 21)])
+    assert 5 in ep.plan_from_config
+    with pytest.raises(h.Rejected) as e:
+        hst.call(m.CORE_FN, m.OP_PLAN_APPLY, m.tlv(0x90, struct.pack("<HBH", 5, 1, 22)))
+    assert e.value.result.detail == m.UNAVAILABLE
+    hst.call(m.CORE_FN, m.OP_PLAN_RELEASE, b"\x00")
+    assert {(5, 1, 20), (5, 2, 21)} <= ep.plan and 5 in ep.plan_from_config
+
+
+def test_reset_channels_and_a_named_reset_line():
+    """oep-if-debug §3: the host reads the reset channels the probe allows and names one; there is no default."""
+    from oep_client import target
+    ep = endpoint.Endpoint(fake.esp32_v003(), Clock())
+    hst = h.Host(lambda b: ep.handle(b, 0))
+    hst.open(3000)
+    wire = target.Wire(hst, "oep.wire.swio")
+    assert wire.reset_channels() == [23]
+    conn, _dpc = wire.attach_under_reset(23)
+    assert conn in ep.conns
+
+
+def test_slot_line_settings_from_the_command(capsys, monkeypatch):
+    ep, hst = open_bench()
+
+    class FakeLink:
+        def close(self):
+            pass
+    hst.link = FakeLink()
+    hst.end()
+    monkeypatch.setattr(cli.link, "open_host", lambda target: hst)
+    assert cli.main(["config", "slot", "x", "--name", "l103", "--pins", "2,3", "--attach", "at-boot", "--retry", "1",
+                     "--max-speed", "1000000", "--idle-clock", "low"]) == 0
+    (slot,) = [i for i in config.ProbeConfig(hst).items() if isinstance(i, config.Slot)]
+    assert (slot.max_speed, slot.idle_clock) == (1_000_000, "low")
+    assert cli.main(["config", "show", "x"]) == 0
+    assert "max 1000000 Hz idle-low" in capsys.readouterr().out

{oep_client_python-0.0.4 → oep_client_python-0.0.6}/tests/test_fake_spec.py

@@ -49,10 +49,10 @@ class Host:
         return r.payload
 
 
-def slot_item(n, wire, pair, attach=ATTACH["at_boot"], retry=1, mech=2, name=None, lock=None):
+def slot_item(n, wire, pair, attach=ATTACH["at_boot"], retry=1, mech=2, name=None, lock=None, max_speed=0, idle=0):
     raw = (name or f"s{n}").encode()
-    value = struct.pack("<BHHHBHBB", n, wire, *pair, attach, retry if attach == ATTACH["at_boot"] else 0, mech,
-                        len(raw)) + raw
+    value = struct.pack("<BHHHBHIBBB", n, wire, *pair, attach, retry if attach == ATTACH["at_boot"] else 0, max_speed,
+                        idle, mech, len(raw)) + raw
     value += b"\x00" if lock is None else bytes([1]) + lock[0] + lock[1]
     return m.tlv(ITEM["slot"], value)
 
@@ -198,7 +198,7 @@ def test_too_many_at_boot_slots_are_refused():
 def test_slot_names_are_url_safe(name):
     ep, h = bench()
     assert h.raw(6, 0x02, slot_item(0, 1, ep.pairs[1][0], name=name or None) if name else
-                 m.tlv(ITEM["slot"], struct.pack("<BHHHBHBB", 0, 1, *ep.pairs[1][0], 1, 1, 2, 0) + b"\x00")).detail == m.MALFORMED
+                 m.tlv(ITEM["slot"], struct.pack("<BHHHBHIBBB", 0, 1, *ep.pairs[1][0], 1, 1, 0, 0, 2, 0) + b"\x00")).detail == m.MALFORMED
 
 
 # ---- binds and the serial port ---------------------------------------------------------------------------
@@ -383,3 +383,51 @@ def test_the_closing_0x00_of_a_frame_is_not_raw_after_the_gap():
     port.tick()
     sid = ep.stream_keys[(ep._conn_at(1, p[0]), 2)]
     assert bytes(ep.streams[sid].written) == b""                   # no stray 0x00 at the target
+
+
+def test_read_from_a_last_mark_that_is_not_there_is_from_now():
+    ep, h = bench()
+    p = ep.pairs[1][0]
+    r = h.raw(1, 0x02, bytes([0]) + m.tlv(0x03, struct.pack("<HH", *p), critical=True))
+    uart_fn = 5
+    h.ok(0, m.OP_PLAN_APPLY, m.tlv(0x90, struct.pack("<HBH", uart_fn, 1, 20)) + m.tlv(0x90, struct.pack("<HBH", uart_fn, 2, 21)))
+    h.ok(uart_fn, 0x01, struct.pack("<I", 115200))
+    ep.uart_rx(uart_fn, b"old output")
+    reset = reg.TARGET_CONSOLE.enum["mark_kind"]["reset"]
+    got = h.raw(uart_fn, 0x02, struct.pack("<BQH", 3, reset, 64), session=False).payload
+    assert struct.unpack_from("<Q", got)[0] == 10 and got[9:] == b""   # no reset mark: from now, not the old bytes
+
+
+def test_no_default_reset_line_only_the_declared_channels():
+    """oep-if-debug §3: attach_under_reset names its channel; the probe takes only role 3 (reset) channels, and not
+    one a plan holds."""
+    ep = endpoint.Endpoint(fake.esp32_v003(), Clock())
+    h = Host(ep)
+    h.open()
+    assert ep.reset_channels[1] == {23}
+    for channel in (0xFFFF, 22):                                    # no default; 22 is not a reset line
+        assert h.raw(1, 0x04, struct.pack("<HH", channel, 20)).detail == m.UNAVAILABLE
+    h.ok(1, 0x04, struct.pack("<HH", 23, 20))
+    h.ok(0, m.OP_PLAN_APPLY, m.tlv(0x90, struct.pack("<HBH", 4, 1, 23)))   # fixture.gpio takes NRST
+    assert h.raw(1, 0x04, struct.pack("<HH", 23, 20)).detail == m.UNAVAILABLE
+
+
+def test_idle_clock_is_rvswd_s_and_a_slot_carries_the_line_settings():
+    ep, h = bench()
+    pair = ep.pairs[1][0]
+    idle_low = m.tlv(0x04, b"\x01", critical=True)
+    h.ok(1, 0x02, b"\x01" + m.tlv(0x03, struct.pack("<HH", *pair), critical=True) + idle_low)
+    assert ep.conns[ep._conn_at(1, pair)].idle_clock == 1
+    assert h.raw(1, 0x02, b"\x01" + m.tlv(0x03, struct.pack("<HH", *pair), critical=True)
+                 + m.tlv(0x04, b"\x02", critical=True)).detail == m.MALFORMED
+    ep2, h2 = bench()
+    p2 = ep2.pairs[1][1]
+    h2.ok(6, 0x02, slot_item(0, 1, p2, name="l103", max_speed=1_000_000, idle=1))
+    c = ep2.conns[ep2._conn_at(1, p2)]
+    assert (c.speed, c.idle_clock) == (1_000_000, 1)                 # the probe's own attach uses the slot's settings
+    v003 = endpoint.Endpoint(fake.esp32_v003(), Clock())
+    hv = Host(v003)
+    hv.open()
+    assert hv.raw(9, 0x02, slot_item(0, 1, v003.pairs[1][0], idle=1)).detail == m.MALFORMED   # swio has no idle_clock
+    r = hv.raw(1, 0x02, b"\x01" + idle_low)
+    assert r.resolution == m.REJECTED and r.detail == m.UNSUPPORTED  # an unknown critical TLV on swio

oep_client_python-0.0.6/tests/test_usb_stream.py

@@ -0,0 +1,96 @@
+"""UsbAsyncStream closes cleanly: the IN transfers are cancelled and taken back by the event thread before the handle and
+the context go (closing with transfers out hung the process at exit or aborted libusb), and close is hooked to exit."""
+
+import atexit
+import sys
+import threading
+import types
+
+import pytest
+
+
+class FakeUsb1(types.ModuleType):
+    TRANSFER_COMPLETED, TRANSFER_TIMED_OUT, TRANSFER_CANCELLED = 0, 2, 3
+
+    class USBError(Exception):
+        pass
+
+    class USBErrorInterrupted(USBError):
+        pass
+
+
+usb1 = FakeUsb1("usb1")
+
+
+class Transfer:
+    def __init__(self, ctx):
+        self.ctx, self.status, self.out = ctx, None, False
+
+    def setBulk(self, ep, size, callback, timeout):
+        self.callback = callback
+
+    def submit(self):
+        self.out = True
+
+    def cancel(self):
+        self.ctx.pending.append(self)                  # comes back as cancelled on a later event pass, like libusb
+
+    def getStatus(self):
+        return self.status
+
+
+class Context:
+    def __init__(self):
+        self.pending, self.lock, self.closed = [], threading.Lock(), False
+
+    def handleEventsTimeout(self, t):
+        import time
+        time.sleep(0.005)
+        while self.pending:
+            tr = self.pending.pop(0)
+            tr.out, tr.status = False, usb1.TRANSFER_CANCELLED
+            tr.callback(tr)
+
+    def close(self):
+        self.closed = True
+
+
+class Handle:
+    def __init__(self, ctx):
+        self.ctx, self.transfers, self.closed_with_out = ctx, [], None
+
+    def getTransfer(self):
+        t = Transfer(self.ctx)
+        self.transfers.append(t)
+        return t
+
+    def releaseInterface(self, n):
+        pass
+
+    def close(self):
+        self.closed_with_out = sum(t.out for t in self.transfers)
+
+
+@pytest.fixture
+def stream(monkeypatch):
+    monkeypatch.setitem(sys.modules, "usb1", usb1)
+    from oep_client import usb_stream
+    ctx = Context()
+    h = Handle(ctx)
+    s = usb_stream.UsbAsyncStream(ctx, h, 0x81, 0x01, 0)
+    return s, ctx, h
+
+
+def test_close_takes_every_transfer_back_before_the_handle_goes(stream):
+    s, ctx, h = stream
+    s.close()
+    assert h.closed_with_out == 0 and ctx.closed and not s._events.is_alive()
+    s.close()                                          # twice (atexit after an explicit close): nothing more
+
+
+def test_close_is_hooked_to_exit(stream, monkeypatch):
+    s, ctx, h = stream
+    calls = []
+    monkeypatch.setattr(atexit, "unregister", lambda f: calls.append(f))
+    s.close()
+    assert calls == [s.close]                          # it was registered, and an explicit close takes it off