oep-client-python 0.0.24__tar.gz → 0.0.26__tar.gz

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## 0.0.26
+- (EN) A request that may take long on the probe is waited for that long (core §6.1: the probe does not count the lease while it runs one): `Host.expecting(ms)` (and `request(..., expect_ms=)` / `call(..., expect_ms=)`) makes the link wait at least that and 0.5 s (`link.EXPECT_MARGIN_S`) for each answer, at any rate - so the raised-rate wait of a quarter of the lease applies to ordinary requests only. Passed down by riscv-dm run (`timeout_ms`), dmi (its wait_us and poll_us steps, `riscv.dmi_wait_ms`), attach with a reset (`hold_ms`, riscv and arm), capture start (the configured `blocking_ms`; a group's the longest of its tracks) and probe.config save (`config.SAVE_EXPECT_MS`, 2 s). Such a request that times out at a raised rate still falls back. The link's own confirms, keepalives, the step down's revert and `pump` never wait longer. Fix: the keepalive a raised link sends after 1 s of quiet now goes out before the request takes its corr (`Host.before_request`); it used to go out with a higher corr first, so the probe took the request for an old one (rejected result_lost).
+- (JA) probe で長くかかりうる要求はその間待つ（core §6.1: probe は要求の実行中 lease を数えない）: `Host.expecting(ms)`（と `request(..., expect_ms=)` / `call(..., expect_ms=)`）で、link はどの速さでも応答ごとに少なくともその時間と 0.5 秒（`link.EXPECT_MARGIN_S`）待つ。上げた速さでの lease の 4 分の 1 の待ちは普通の要求だけに掛かる。riscv-dm の run（`timeout_ms`）、dmi（wait_us と poll_us の step の和、`riscv.dmi_wait_ms`）、reset 付きの attach（`hold_ms`、riscv と arm）、capture の start（configure の `blocking_ms`。組はトラックの最長）、probe.config の save（`config.SAVE_EXPECT_MS`、2 秒）が渡す。そうした要求も上げた速さで時間切れなら戻る。link 自身の confirm・keepalive・降りるときの戻す・`pump` は長く待たない。修正: 上げた link が 1 秒黙った後に送る keepalive を、要求が corr を取る前に送るようにした（`Host.before_request`）。これまでは大きい corr で先に出ていたため、probe が要求を古いものとみなした（rejected result_lost）。
+- (EN) port_speed (core §3.5 items 3 and 7), after a V003 jig (classic ESP32 + CH340) passed 921600 each way alone but broke a frame every ~0.5 s under sustained duplex use, the probe reverted by itself and the session's lease lapsed: `raise_speed` adds a duplex phase after the in / out phases - link_source and link_sink (max_frame) interleaved, pipelined at the in-flight that passed, for `duplex_s` (1.0) and at least `duplex_frames` (64); a broken frame fails the rate ("broke both ways at once"). `SpeedTrial.duplex_bytes` / `duplex_kb_s` / `broken_duplex`, `SpeedReport.duplex_kb_s`, a duplex column in `to_text()`, `oep speed --duplex-s`. In use: while a raised rate is in force, the link counts broken frames and resends; 3 within 5 s (`STRIKE_MAX`, `STRIKE_WINDOW_S`) step down - port_speed step 2 at the raised rate (0.2 s, never sent again), the boot speed, a confirm, the request again there. A request at a raised rate that gets no answer at all keeps the old fallback (back, confirm, once more there), but each wait is now at most a quarter of the lease (at least 0.3 s), so it ends well inside the lease. Either way the rate is not used again in that session (`SpeedReport.stepped_down`, `.down_why`, a line in `to_text()`; `raise_speed` skips it, "stepped down from earlier in this session"). Fake: `BrokenRate(duplex=True)` breaks only while a request of `min_size` comes in with such an answer still unread (the request towards the probe, that answer towards the host), `BrokenRate(every=N)` only every Nth frame; `fake_serve --broken-rate RATE[:MIN][:in|out][:duplex][:everyN]`.
+- (JA) port_speed（core §3.5 の 3 と 7）。V003 のジグ（classic ESP32 + CH340）で 921600 が向きごとには通ったのに、両方向を続けて使うと約 0.5 秒ごとにフレームが壊れ、probe が自分で戻り、セッションの lease が切れたため: `raise_speed` は in / out の後に両方向同時の確かめを足した - link_source と link_sink（max_frame）を交互に、通った同時の数で並べ、`duplex_s`（1.0）かつ `duplex_frames`（64）以上。1 つでも壊れればその速さは使わない（"broke both ways at once"）。`SpeedTrial.duplex_bytes` / `duplex_kb_s` / `broken_duplex`、`SpeedReport.duplex_kb_s`、`to_text()` に duplex の列、`oep speed --duplex-s`。使っている間: 上げた速さの間、link は壊れたフレームと送り直しを数え、5 秒の内に 3 つ（`STRIKE_MAX`、`STRIKE_WINDOW_S`）で降りる - 上げた速さで port_speed の step 2（0.2 秒、送り直さない）、起動時の速さ、confirm、要求をそこでもう一度。上げた速さで応答がまったく来ない要求はこれまでの戻り方（戻る、confirm、そこでもう一度）のままだが、待つ 1 回を lease の 4 分の 1（最短 0.3 秒）までにしたので lease の内に十分収まる。どちらでもその速さはそのセッションの間使わない（`SpeedReport.stepped_down`、`.down_why`、`to_text()` に 1 行。`raise_speed` は飛ばす: "stepped down from earlier in this session"）。偽の probe: `BrokenRate(duplex=True)` は `min_size` 以上の要求が、同じ大きさの応答が読まれないうちに来たときだけ壊す（probe へはその要求、host へはその応答）、`BrokenRate(every=N)` は N 個に 1 つだけ壊す。`fake_serve --broken-rate RATE[:MIN][:in|out][:duplex][:everyN]`。
+
+## 0.0.25
+- (EN) port_speed's idle limit (oep-spec 877cf01, core §3.5 items 5 and 6; registry synced, `port_speed_idle_max_ms` = 3000): a committed rate goes back after at most 3 s with no good frame, so a host that raised the speed and died leaves it no longer than that. The fake clamps idle_ms the same way (0 and anything longer: the maximum; 0 used to mean never). `raise_speed`'s `idle_ms` defaults to the maximum (0 or more than it: the maximum). While raised, the link sends a keepalive before a request (or a pipelined exchange, or inside a long `pump`) when it has been quiet for 1 s; `SerialLink.keep_alive()` does the same for a caller that sits idle for long (no background thread). `open_host` on a serial port (COBS) retries its first confirm for about 4 s (`OPEN_RETRY_S`, the idle maximum and a second; 0.5 s each) to wait out a rate left over, then raises TimeoutError; other transports keep their timeout.
+- (JA) port_speed の黙りの上限（oep-spec 877cf01、core §3.5 の 5 と 6。registry を写し直した。`port_speed_idle_max_ms` = 3000）: 決めた速さは正しいフレームが来ないまま最長 3 秒で戻るので、速さを上げた host が落ちてもそれより長くは残らない。fake も idle_ms を同じに切り詰める（0 とそれより長い値は最長。0 はこれまで戻らないだった）。`raise_speed` の `idle_ms` の既定は最長（0 と最長より長い値も最長）。上げている間、link は 1 秒黙っていれば要求の前（並べた送り、長い `pump` の中も）に keepalive を送る。長く黙る呼び出し側は `SerialLink.keep_alive()` で同じことをする（裏のスレッドは無い）。シリアルの口（COBS）の `open_host` は最初の confirm を約 4 秒（`OPEN_RETRY_S`、黙りの最長と 1 秒。1 回 0.5 秒）繰り返して残った速さが戻るのを待ち、それでも答えが無ければ TimeoutError。ほかの経路の時間切れは変わらない。
+
 ## 0.0.24
 - (EN) A serial link whose port a session holds sends a request again as soon as a broken frame arrives, instead of after the timeout: the probe sends no raw bytes on a held port (oep-core §3.4), so the broken frame was the reply, and the repeat is answered from the probe's retry table. A 60 KB logic capture read on an M5Stack ATOM went from 4.0 to 8.3 KB/s at 115200 and runs at 76 KB/s at 1.5 Mbaud (dogfooding port_speed, 2026-10-01).
 - (JA) セッションが口を持っているシリアルの経路では、壊れたフレームが来たら時間切れを待たずにすぐ送り直す: 持たれている口には probe が生のバイトを送らない（oep-core §3.4）ので、壊れたフレームは応答で、送り直しには probe の送り直しの表が答える。M5Stack ATOM で 60 KB のロジックのキャプチャの読み出しが 115200 で 4.0 → 8.3 KB/s、1.5 Mbaud で 76 KB/s になった（port_speed のドッグフーディング、2026-10-01）。

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.24
+Version: 0.0.26
 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
@@ -122,15 +122,23 @@ print(hst.link.speed.to_text())             # every rate tried: actual, in / out
 
 Each rate in order: `try` (answered at the speed now, then the probe switches) -> the host switches -> a verify both ways
 with max_frame-sized frames (link_source / link_sink, pipelined) for `verify_bytes` or `verify_s`, counting broken frames
-and measuring KB/s each way -> `commit` when nothing broke, else revert and back to the boot speed, confirmed there (a
+and measuring KB/s each way -> both ways at once at the in-flight that passed (link_source and link_sink interleaved,
+about 1 s and at least 64 frames, `duplex_kb_s`; a line that carries each way alone can still break under duplex use - a
+CH340 at 921600 did) -> `commit` when nothing broke, else revert and back to the boot speed, confirmed there (a
 probe whose revert was lost waits out its `verify_ms`). The first rate that passes is kept; a rate the probe's UART cannot
 make is skipped. Which rates pass depends on the bridge chip and its driver (an FTDI took only 3 MHz / n, a CH340 921600
 but not 1500000 towards the host: oep-spec docs/uart-speed-negotiation.ja.md), so the host chooses them. The report
 (`link.speed`: `rate`, `chosen`, `in_kb_s` / `out_kb_s`, `trials`) is there to budget a capture or a write.
 
 The probe goes back to the boot speed by itself when the session ends (`end`, a lapse, a force), when frames break or the
-line goes quiet (`idle_ms`): the link follows an `end` at once, and a request that goes unanswered at a raised rate (its
-resend too) takes the link back to the boot speed, confirmed, and goes once more there - it never wedges. A probe
+line goes quiet (`idle_ms`, at most `port_speed_idle_max_ms` = 3 s; a host that died leaves the rate no longer than
+that): while raised the link sends a keepalive before a request when it has been quiet for 1 s, and `hst.link.keep_alive()`
+does the same for a caller that sits idle for long; opening a serial port retries its first confirm for about 4 s to
+wait out a rate left over. The link follows an `end` at once, and a request that goes unanswered at a raised rate (its
+resend too) takes the link back to the boot speed, confirmed, and goes once more there - it never wedges; while raised
+each wait for an answer is at most a quarter of the lease, so this ends well inside it. In use, 3 broken frames or
+resends within 5 s step the link down: port_speed revert at the raised rate, the boot speed, a confirm, the request
+again there. A rate left either way is not used again in that session (`speed.stepped_down`, `speed.down_why`). A probe
 without the feature answers `not supported` and stays at its speed. Behind a broker (TCP) the broker does this, not the
 client. Serial ports are also opened in the driver's low-latency mode where it has one (an FTDI's latency timer 16 -> 1 ms
 tripled a UART bridge's throughput). `open_host(..., baud=)` names the boot speed when the board's profile is not 115200.

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/README.ja.md

@@ -95,14 +95,19 @@ print(hst.link.speed.to_text())             # 試した速さごとに、実際
 
 速さごとに順に: `試す`（今の速さで応答してから probe が切り替える）→ host も切り替える → 両方向に max_frame の大きさのフレームで
 （link_source / link_sink、パイプライン）`verify_bytes` か `verify_s` の分だけ確かめ、壊れたフレームを数え、それぞれの向きの KB/s を
-測る → 何も壊れなければ `決める`、壊れれば戻して起動時の速さに戻り、そこで confirm し直す（戻すが届かなかった probe は `verify_ms`
+測る → 通った同時の数で両方向を同時に（link_source と link_sink を交互に、約 1 秒、64 フレーム以上。`duplex_kb_s`。向きごとには
+通っても同時に流すと壊れる線がある。921600 の CH340 がそうだった）流す → 何も壊れなければ `決める`、壊れれば戻して起動時の速さに戻り、そこで confirm し直す（戻すが届かなかった probe は `verify_ms`
 を待って戻る）。最初に通った速さを使う。probe の UART が作れない速さは飛ばす。通る速さは変換チップとドライバで決まる（FTDI は
 3 MHz ÷ n だけ、CH340 は 921600 は通り 1500000 は probe → host が壊れた: oep-spec docs/uart-speed-negotiation.ja.md）ので、速さは
 host が選ぶ。結果（`link.speed`: `rate`、`chosen`、`in_kb_s` / `out_kb_s`、`trials`）はキャプチャや書き込みの予算を立てるのに使う。
 
-probe はセッションが終わったとき（`end`、lease の期限切れ、force）、フレームが壊れたとき、線が黙ったとき（`idle_ms`）に自分で
-起動時の速さに戻る: link は `end` にはすぐ合わせ、上げた速さで応答の来ない要求（送り直しも）があれば、起動時の速さに戻って
-confirm し、そこでもう一度送る（固まらない）。機能の無い probe は `not supported` で、速さは変わらない。ブローカー（TCP）の後ろでは
+probe はセッションが終わったとき（`end`、lease の期限切れ、force）、フレームが壊れたとき、線が黙ったとき（`idle_ms`、最長
+`port_speed_idle_max_ms` = 3 秒。落ちた host の速さもそれより長くは残らない）に自分で起動時の速さに戻る: 上げている間、link は
+1 秒黙っていれば要求の前に keepalive を送り、長く黙る呼び出し側は `hst.link.keep_alive()` で同じことをする。シリアルの口を開くと
+最初の confirm を約 4 秒繰り返して、残った速さが戻るのを待つ。link は `end` にはすぐ合わせ、上げた速さで応答の来ない要求（送り直しも）があれば、起動時の速さに戻って
+confirm し、そこでもう一度送る（固まらない）。上げている間は応答を待つ 1 回が lease の 4 分の 1 までなので、lease の内に十分収まる。
+使っている間に 5 秒の内に 3 回フレームが壊れるか送り直すと、上げた速さで port_speed の戻すを送り、起動時の速さに戻って confirm し、
+要求をそこで送る。どちらで離れた速さもそのセッションの間は使わない（`speed.stepped_down`、`speed.down_why`）。機能の無い probe は `not supported` で、速さは変わらない。ブローカー（TCP）の後ろでは
 client ではなくブローカーが行う。シリアルの口は、ドライバにあれば low-latency のモードで開く（FTDI の latency timer 16 → 1 ms で
 UART bridge の速度が 3 倍になった）。ボードの起動時の速さが 115200 でなければ `open_host(..., baud=)` で渡す。
 

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/README.md

@@ -100,15 +100,23 @@ print(hst.link.speed.to_text())             # every rate tried: actual, in / out
 
 Each rate in order: `try` (answered at the speed now, then the probe switches) -> the host switches -> a verify both ways
 with max_frame-sized frames (link_source / link_sink, pipelined) for `verify_bytes` or `verify_s`, counting broken frames
-and measuring KB/s each way -> `commit` when nothing broke, else revert and back to the boot speed, confirmed there (a
+and measuring KB/s each way -> both ways at once at the in-flight that passed (link_source and link_sink interleaved,
+about 1 s and at least 64 frames, `duplex_kb_s`; a line that carries each way alone can still break under duplex use - a
+CH340 at 921600 did) -> `commit` when nothing broke, else revert and back to the boot speed, confirmed there (a
 probe whose revert was lost waits out its `verify_ms`). The first rate that passes is kept; a rate the probe's UART cannot
 make is skipped. Which rates pass depends on the bridge chip and its driver (an FTDI took only 3 MHz / n, a CH340 921600
 but not 1500000 towards the host: oep-spec docs/uart-speed-negotiation.ja.md), so the host chooses them. The report
 (`link.speed`: `rate`, `chosen`, `in_kb_s` / `out_kb_s`, `trials`) is there to budget a capture or a write.
 
 The probe goes back to the boot speed by itself when the session ends (`end`, a lapse, a force), when frames break or the
-line goes quiet (`idle_ms`): the link follows an `end` at once, and a request that goes unanswered at a raised rate (its
-resend too) takes the link back to the boot speed, confirmed, and goes once more there - it never wedges. A probe
+line goes quiet (`idle_ms`, at most `port_speed_idle_max_ms` = 3 s; a host that died leaves the rate no longer than
+that): while raised the link sends a keepalive before a request when it has been quiet for 1 s, and `hst.link.keep_alive()`
+does the same for a caller that sits idle for long; opening a serial port retries its first confirm for about 4 s to
+wait out a rate left over. The link follows an `end` at once, and a request that goes unanswered at a raised rate (its
+resend too) takes the link back to the boot speed, confirmed, and goes once more there - it never wedges; while raised
+each wait for an answer is at most a quarter of the lease, so this ends well inside it. In use, 3 broken frames or
+resends within 5 s step the link down: port_speed revert at the raised rate, the boot speed, a confirm, the request
+again there. A rate left either way is not used again in that session (`speed.stepped_down`, `speed.down_why`). A probe
 without the feature answers `not supported` and stays at its speed. Behind a broker (TCP) the broker does this, not the
 client. Serial ports are also opened in the driver's low-latency mode where it has one (an FTDI's latency timer 16 -> 1 ms
 tripled a UART bridge's throughput). `open_host(..., baud=)` names the boot speed when the board's profile is not 115200.

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "oep-client-python"
-version = "0.0.24"
+version = "0.0.26"
 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.24 → oep_client_python-0.0.26}/src/oep_client/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.0.24"
+__version__ = "0.0.26"

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/src/oep_client/__main__.py

@@ -36,6 +36,7 @@ def main(argv=None) -> int:
     sp.add_argument("--baud", type=int, default=link.BASE_BAUD, help="the boot speed (default 115200)")
     sp.add_argument("--verify-bytes", type=int, default=32768)
     sp.add_argument("--verify-s", type=float, default=1.0)
+    sp.add_argument("--duplex-s", type=float, default=1.0, help="both ways at once for this long (default 1)")
     sp.add_argument("--json", action="store_true")
     d = sub.add_parser("dump", help="list and describe every interface a probe offers")
     src = d.add_mutually_exclusive_group(required=True)
@@ -69,7 +70,8 @@ def _speed(args) -> int:
     hst = link.open_host(args.probe, baud=args.baud)
     try:
         core.take(hst, 5000, owner="oep speed")
-        report = link.raise_speed(hst, rates, verify_bytes=args.verify_bytes, verify_s=args.verify_s)
+        report = link.raise_speed(hst, rates, verify_bytes=args.verify_bytes, verify_s=args.verify_s,
+                                   duplex_s=args.duplex_s)
         if args.json:
             sys.stdout.write(json.dumps(dataclasses.asdict(report), indent=2) + "\n")
         else:

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/src/oep_client/arm.py

@@ -37,7 +37,7 @@ class SwdWire(WireBase):
         body = bytes([0]) + self._speed_tlv(self._speed_or_default(max_speed)) + self._pins_tlv(pins) + self._reset_tlv(reset)
         if targetsel is not None:
             body += m.tlv(self.TAG_TARGETSEL, struct.pack("<I", targetsel), critical=True)
-        rd = m.Reader(self._call(self.ATTACH, body).payload)
+        rd = m.Reader(self._call(self.ATTACH, body, expect_ms=reset[1] if reset else 0).payload)
         conn, dpidr, self.flags, self.speed_hz = rd.take("HIBI")
         self.existing = bool(self.flags & self.FLAGS["existing"])
         rd.tail()

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/src/oep_client/capture.py

@@ -335,7 +335,7 @@ class LogicCapture(Interface):
 
     def start(self) -> int:
         """-> blocking_ms (0: the probe keeps answering while it captures). self.generation: the new capture's."""
-        rd = m.Reader(self._call(self.START).payload)
+        rd = m.Reader(self._call(self.START, expect_ms=self.config.blocking_ms if self.config else 0).payload)
         blocking, self.generation = rd.take("II")
         rd.tail()
         self.armed_s = time.monotonic()
@@ -576,7 +576,8 @@ class CaptureGroup(Interface):
     def start(self, tracks: list[LogicCapture] = ()) -> tuple[int, int]:
         """-> (blocking_ms, the group's start_ns). `tracks`: whose armed_s and generation to set (the answer's TLV
         generations names each track's new generation; self.generations keeps them by fn)."""
-        rd = m.Reader(self._call(self.START).payload)
+        rd = m.Reader(self._call(self.START, expect_ms=max([t.config.blocking_ms for t in tracks if t.config] or [0]))
+                      .payload)
         blocking, start_ns = rd.take("IQ")
         gens = rd.tail().get(GROUP_GENERATIONS) or b""
         self.generations = {fn: g for fn, g in struct.iter_unpack("<HI", gens[:len(gens) // 6 * 6])}

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/src/oep_client/config.py

@@ -292,6 +292,8 @@ class State:
     binds: list[BindState] = field(default_factory=list)
 
 
+SAVE_EXPECT_MS = 2000   # a save writes the probe's flash: the link waits at least this (Host.expecting)
+
 class ProbeConfig(Interface):
     NAME = "oep.probe.config"
     REVISION = 1
@@ -346,7 +348,7 @@ class ProbeConfig(Interface):
 
     def save(self) -> int:
         """Save the current settings (a probe with storage; the whole is replaced). -> the hash saved."""
-        return self._hash_answer(self._call(self.SAVE))
+        return self._hash_answer(self._call(self.SAVE, expect_ms=SAVE_EXPECT_MS))
 
     def erase(self) -> None:
         self._call(self.ERASE)

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/src/oep_client/core.py

@@ -4,6 +4,8 @@ entry, and calls that raise unless they worked)."""
 
 from __future__ import annotations
 
+import contextlib
+
 import struct
 
 from . import catalog, host as h, message as m, registry as reg
@@ -196,12 +198,20 @@ class Interface:
                 raise UnsupportedRevision(f"{self.name} (fn {self.fn}) is revision {rev} on this probe; this client "
                                           f"speaks revision {self.REVISION} only")
 
-    def _call(self, op: int, body: bytes = b"", *, locked: bool = True) -> m.Result:
-        return self.host.call(self.fn, op, self.prefix + body, locked=locked)
+    def _expecting(self, ms: int):
+        """Host.expecting(ms) when the host has it (a stand-in host may not)."""
+        expecting = getattr(self.host, "expecting", None) if ms else None
+        return expecting(ms) if expecting else contextlib.nullcontext()
+
+    def _call(self, op: int, body: bytes = b"", *, locked: bool = True, expect_ms: int = 0) -> m.Result:
+        with self._expecting(expect_ms):
+            return self.host.call(self.fn, op, self.prefix + body, locked=locked)
 
-    def _request(self, op: int, body: bytes = b"", *, locked: bool = True) -> m.Result:
-        """Rejections raise; completed results of any outcome come back for the caller to decode."""
-        return self.host.request(self.fn, op, self.prefix + body, locked=locked)
+    def _request(self, op: int, body: bytes = b"", *, locked: bool = True, expect_ms: int = 0) -> m.Result:
+        """Rejections raise; completed results of any outcome come back for the caller to decode. expect_ms: how
+        long it may take on the probe (Host.expecting)."""
+        with self._expecting(expect_ms):
+            return self.host.request(self.fn, op, self.prefix + body, locked=locked)
 
     def request(self, op: int, body: bytes = b"") -> tuple[int, int, bytes]:
         """The raw (fn, op, payload) of one operation, for Host.pipeline / pipeline_calls."""

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/src/oep_client/endpoint.py

@@ -36,9 +36,11 @@ define:
 - port_speed (core §3.5, optional): on when the profile's describe declares it (`port_speed_base`, the boot speed;
   None = off: the op is unknown_operation). try / commit / revert on the UART bridge the request came in on (else
   unavailable cause 6), a rate the fake UART cannot make (outside 300..5000000) unsupported; a try reverts after
-  verify_ms without a commit or at a broken candidate, a commit after idle_ms with no good frame or 3 broken
+  verify_ms without a commit or at a broken candidate, a commit after idle_ms (at most port_speed_idle_max_ms, 3000;
+  0 and anything longer count as that maximum) with no good frame or 3 broken
   candidates within 1 s, the session's end reverts after its answer. The line itself is modelled by `broken_rates`
-  (rate -> BrokenRate): frames at such a rate break, from a size and in the directions given (`fake_serial` applies it).
+  (rate -> BrokenRate): frames at such a rate break, from a size and in the directions given, only both ways at once
+  (`duplex`), only every Nth (`every`) (`fake_serial` applies it).
 
 Every other non-core fn gets two stand-in operations so the session rules can be exercised - FAKE ONLY, they mean
 nothing on a real probe:  0x01 write(u32) changes state, 0x02 read -> u32 needs no lock.
@@ -316,11 +318,22 @@ class BrokenRate:
     min_size: int = 0
     to_host: bool = True
     to_probe: bool = True
+    duplex: bool = False       # only while both ways carry such frames at once (a request of min_size and more comes in
+                               # while an answer of min_size and more is still unread): the request breaks (to_probe),
+                               # the unread answer breaks (to_host)
+    every: int = 1             # of the frames that would break, only every Nth does (1: all)
+    seen: int = 0              # the frames that would have broken so far (`every` counts these)
+
+    def hit(self) -> bool:
+        """One more frame that would break: True when this one does (`every`)."""
+        self.seen += 1
+        return self.seen % max(1, self.every) == 0
 
 
 PORT_SPEED_TAG = reg.CORE.tlv["describe"]["port_speed"]
 OP_PORT_SPEED = reg.CORE.op["port_speed"]
 SPEED_STEP = reg.CORE.enum["port_speed_step"]
+SPEED_IDLE_MAX_MS = reg.TIMING["port_speed_idle_max_ms"]   # committed: idle_ms at most this (0 and longer: this)
 SPEED_BAD_MAX, SPEED_BAD_WINDOW_MS = 3, 1000       # committed: this many broken candidates within the window revert
 SPEED_RATES = (300, 5_000_000)                     # what the fake's UART makes (anything between, exactly)
 
@@ -472,7 +485,7 @@ class Endpoint:
         self.speed_rate = 0                            # the rate it runs at
         self.speed_asked = 0                           # the baud the try asked (the commit names it again)
         self.speed_until_ms = 0                        # try: the commit's deadline (verify_ms)
-        self.speed_idle_ms = 0                         # committed: revert after this long with no good frame (0 never)
+        self.speed_idle_ms = 0                         # committed: revert after this long with no good frame
         self.speed_good_ms = 0                         # the last good frame on that port
         self.speed_bad: list[int] = []                 # committed: the times of the recent broken candidates
         self.speed_pending: tuple | None = None        # ("switch", port, baud, verify_ms) / ("revert",): after the answer
@@ -1203,7 +1216,7 @@ class Endpoint:
             if self.speed_state == "base" or port != self.speed_port or baud != self.speed_asked:
                 raise unavailable("wrong_state")                   # nothing tried, or another baud
             self.speed_state = "committed"
-            self.speed_idle_ms = idle_ms
+            self.speed_idle_ms = idle_ms if 0 < idle_ms <= SPEED_IDLE_MAX_MS else SPEED_IDLE_MAX_MS
             self.speed_good_ms = self.now()
             self.speed_bad.clear()
             return self._answer(struct.pack("<I", self.speed_rate), ignored)
@@ -1216,10 +1229,19 @@ class Endpoint:
             return self.speed_rate
         return self.port_speed_base or 115200
 
-    def breaks(self, port: int, size: int, to_host: bool) -> bool:
-        """The line model: a frame of `size` bytes on `port` at its rate now breaks (`broken_rates`)."""
+    def breaks(self, port: int, size: int, to_host: bool, duplex: bool = False) -> bool:
+        """The line model: a frame of `size` bytes on `port` at its rate now breaks (`broken_rates`). duplex: the other
+        way carries a frame of the rate's min_size or more at the same time (a BrokenRate with `duplex` breaks only
+        then)."""
+        b = self.broken_rates.get(self.port_baud(port))
+        if b is None or size < b.min_size or not (b.to_host if to_host else b.to_probe) or (b.duplex and not duplex):
+            return False
+        return b.hit()
+
+    def duplex_rate(self, port: int) -> BrokenRate | None:
+        """The rate `port` runs at now when it breaks only both ways at once (fake_serial checks the unread answers)."""
         b = self.broken_rates.get(self.port_baud(port))
-        return b is not None and size >= b.min_size and (b.to_host if to_host else b.to_probe)
+        return b if b is not None and b.duplex else None
 
     def speed_after_answer(self) -> None:
         """The answer that asked for a switch or a revert is out (at the old speed): now do it."""
@@ -1264,7 +1286,7 @@ class Endpoint:
         now = self.now()
         if self.speed_state == "try" and now >= self.speed_until_ms:
             self._speed_revert()                                   # no commit within verify_ms
-        elif self.speed_state == "committed" and self.speed_idle_ms and now - self.speed_good_ms >= self.speed_idle_ms:
+        elif self.speed_state == "committed" and now - self.speed_good_ms >= self.speed_idle_ms:
             self._speed_revert()
 
     def _page(self, tlvs: list[bytes], first: int) -> bytes:

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/src/oep_client/fake_serial.py

@@ -17,7 +17,8 @@ bytes to send, or None to send nothing (fault injection for tests).
 port_speed (core §3.5): every closed candidate tells the endpoint whether it was a frame (`Endpoint.speed_frame`), a
 switch or revert a request asked for happens once its answer is queued (at the old speed), and the endpoint's
 `broken_rates` break frames at the port's rate now: a candidate from the host is then not a frame, an answer or push
-goes out with a spoiled CRC. `FakeSerialStream` is the port as a pyserial-shaped stream for an in-process host, with
+goes out with a spoiled CRC (a `duplex` one only while a request of its size comes in with such an answer still
+unread: the request, or that answer, breaks). `FakeSerialStream` is the port as a pyserial-shaped stream for an in-process host, with
 the host's own `baudrate`: while it differs from the probe's, every byte either way arrives garbled.
 """
 
@@ -40,6 +41,7 @@ class FakeSerialPort:
         self.frames: list[bytes] = []                # framed answers waiting to go out
         self.answers = 0
         self.garble: Callable[[bytes, int], bytes] | None = None   # (frame, the rate it goes at) -> what arrives
+        self.spoiled: set[int] = set()               # the waiting answers a duplex BrokenRate already broke
 
     def feed(self, data: bytes) -> None:
         now = self.ep.now()
@@ -65,8 +67,10 @@ class FakeSerialPort:
         self.cand = None
         if not body:
             return                                   # 0x00 0x00: an empty frame
+        size = len(body) + 2
+        duplex = self._both_ways(size)
         try:
-            if self.ep.breaks(self.index, len(body) + 2, to_host=False):
+            if self.ep.breaks(self.index, size, to_host=False, duplex=duplex):
                 raise cobs.CorruptFrame("the line's rate breaks this frame")
             msg = cobs.unframe(body)
         except cobs.CorruptFrame:
@@ -90,6 +94,22 @@ class FakeSerialPort:
             self.frames.append(self._line(wire))
         self.ep.speed_after_answer()                 # port_speed: switch (or revert) now the answer is out
 
+    def _both_ways(self, size: int) -> bool:
+        """A request of `size` bytes came in: with a BrokenRate that breaks only both ways at once (`duplex`), whether
+        an answer of its min_size or more is still unread (both ways busy) - and then that answer breaks if the rate
+        breaks frames towards the host."""
+        b = self.ep.duplex_rate(self.index)
+        if b is None or size < b.min_size:
+            return False
+        big = [k for k, f in enumerate(self.frames) if len(f) >= b.min_size]
+        if not big:
+            return False
+        k = big[-1]                                  # the answer on the line now (the latest); never spoiled twice
+        if k not in self.spoiled and self.ep.breaks(self.index, len(self.frames[k]), to_host=True, duplex=True):
+            self.frames[k] = _spoil(self.frames[k])
+            self.spoiled.add(k)
+        return True
+
     def _gap(self, now: int) -> None:
         if self.cand is not None and now - self.last_ms >= GAP_MS:
             raw, self.cand = bytes(self.cand), None
@@ -109,9 +129,7 @@ class FakeSerialPort:
     def _line(self, wire: bytes) -> bytes:
         """A framed message as the line delivers it at the port's rate now (`Endpoint.broken_rates`, `garble`)."""
         if self.ep.breaks(self.index, len(wire), to_host=True):
-            body = bytearray(cobs.decode(wire[1:-1]))
-            body[-1] ^= 0xFF                         # the CRC's high byte
-            wire = b"\x00" + cobs.encode(bytes(body)) + b"\x00"
+            wire = _spoil(wire)
         return self.garble(wire, self.ep.port_baud(self.index)) if self.garble else wire
 
     def output(self, room: int = 4096) -> bytes:
@@ -119,6 +137,7 @@ class FakeSerialPort:
         out = bytearray()
         while self.frames and len(out) + len(self.frames[0]) <= max(room, len(self.frames[0])):
             out += self.frames.pop(0)
+            self.spoiled = {k - 1 for k in self.spoiled if k}
             if len(out) >= room:
                 return bytes(out)
         while len(out) < room:
@@ -129,6 +148,16 @@ class FakeSerialPort:
         return bytes(out)
 
 
+def _spoil(wire: bytes) -> bytes:
+    """A framed message with its CRC's high byte spoiled (a frame the line broke); bytes that are no frame as they are."""
+    try:
+        body = bytearray(cobs.decode(wire[1:-1]))
+    except cobs.CorruptFrame:
+        return wire
+    body[-1] ^= 0xFF
+    return b"\x00" + cobs.encode(bytes(body)) + b"\x00"
+
+
 def _garble(data: bytes) -> bytes:
     """Bytes sent at one rate and read at another: a different byte for every byte, 0x00s among them (so the reader
     sees broken candidates, not silence)."""

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/src/oep_client/fake_serve.py

@@ -30,9 +30,10 @@ Options:
                         "DUT RX" labels when the profile has them, else the first free channels); configure then works
   --uart-rx TEXT        what arrives on that UART's RX every --every ms once it is configured (%d = a counter)
   --no-port-speed       the profile's port_speed (core §3.5; esp32-v003 has it) off: the op is unknown_operation
-  --broken-rate SPEC    port_speed's line model: frames at RATE break (repeatable). SPEC is RATE[:MIN_SIZE][:in|out]:
-                        only frames of MIN_SIZE bytes and more on the wire (default every frame), only towards the
-                        host (in) or the probe (out) (default both). The fake cannot see the host's own rate (a pty,
+  --broken-rate SPEC    port_speed's line model: frames at RATE break (repeatable). SPEC is
+                        RATE[:MIN_SIZE][:in|out][:duplex][:everyN]: only frames of MIN_SIZE bytes and more on the wire
+                        (default every frame), only towards the host (in) or the probe (out) (default both), only
+                        while both ways carry such frames at once (duplex), only every Nth of them (everyN). The fake cannot see the host's own rate (a pty,
                         TCP): only the probe's rate decides
   --run-hook SPEC       what riscv-dm run does on every target: SPEC is module:function or path/file.py:function,
                         called as function(target, pc, regs) -> (stopped, dpc, elapsed_us). `target` is the
@@ -83,7 +84,9 @@ def build(a: argparse.Namespace) -> endpoint.Endpoint:
         rate, *rest = spec.split(":")
         size = next((int(x) for x in rest if x.isdigit()), 0)
         way = next((x for x in rest if x in ("in", "out")), None)
-        ep.broken_rates[int(rate)] = endpoint.BrokenRate(size, to_host=way != "out", to_probe=way != "in")
+        every = next((int(x[5:]) for x in rest if x.startswith("every") and x[5:].isdigit()), 1)
+        ep.broken_rates[int(rate)] = endpoint.BrokenRate(size, to_host=way != "out", to_probe=way != "in",
+                                                         duplex="duplex" in rest, every=every)
     for n in a.absent:
         ep.targets[(wire, ep.pairs[wire][n])].present = False
     items = []

{oep_client_python-0.0.24 → oep_client_python-0.0.26}/src/oep_client/host.py

@@ -15,6 +15,7 @@ opens again (host guide §2.5).
 
 from __future__ import annotations
 
+import contextlib
 import random
 import struct
 from dataclasses import dataclass, field
@@ -194,14 +195,32 @@ class Host:
     _revisions: dict = field(default_factory=dict)   # fn -> interface revision from list
     _describes: dict = field(default_factory=dict)   # fn -> its describe TLVs (declarations: valid for one boot_id)
     _boot_id: int | None = None
+    expect_ms: int = 0                     # how long the request going out now may take on the probe (`expecting`)
+    # Called before a request takes its corr (the link's keepalive at a raised port_speed rate): what it sends first
+    # must carry the lower corr, or the probe takes the request for an old one (core §4.1)
+    before_request: Callable[[], None] | None = None
+
+    @contextlib.contextmanager
+    def expecting(self, ms: int):
+        """Requests sent inside take up to `ms` on the probe (a run's timeout_ms, a dmi list's waits, an attach's
+        hold_ms, a capture's blocking, a save; core §6.1: the probe does not count the lease meanwhile). The link waits
+        at least that and a margin for each answer - also at a raised port_speed rate, where an ordinary request waits
+        a quarter of the lease. Nested: the longest holds."""
+        saved = self.expect_ms
+        self.expect_ms = max(saved, int(ms or 0))
+        try:
+            yield
+        finally:
+            self.expect_ms = saved
 
     def next_corr(self) -> int:
         self._corr = self._corr % 0xFFFF + 1
         return self._corr
 
-    def call(self, fn: int, op: int, payload: bytes = b"", *, locked: bool = True) -> m.Result:
+    def call(self, fn: int, op: int, payload: bytes = b"", *, locked: bool = True, expect_ms: int = 0) -> m.Result:
         """request() that also raises Failed unless the probe says it worked: what every operation wants."""
-        r = self.request(fn, op, payload, locked=locked)
+        with self.expecting(expect_ms):
+            r = self.request(fn, op, payload, locked=locked)
         if not r.succeeded:
             raise Failed(r)
         return r
@@ -212,11 +231,15 @@ class Host:
         self.require_v1()
         return self.session
 
-    def request(self, fn: int, op: int, payload: bytes = b"", *, locked: bool = True) -> m.Result:
+    def request(self, fn: int, op: int, payload: bytes = b"", *, locked: bool = True, expect_ms: int = 0) -> m.Result:
         """locked=True sends the session id (role 0x81) once a session is open; lock-free requests may leave it off.
-        Rejections raise; any other answer is returned (Result.succeeded / .ran say what it was)."""
+        expect_ms: how long this request may take on the probe (`expecting`). Rejections raise; any other answer is
+        returned (Result.succeeded / .ran say what it was)."""
+        if self.before_request is not None:
+            self.before_request()
         req = m.Request(self.next_corr(), fn, op, payload, self._session_for(locked))
-        result = m.Result.unpack(self.send(req.pack()))
+        with self.expecting(expect_ms):
+            result = m.Result.unpack(self.send(req.pack()))
         if result.corr != req.corr:
             raise ProtocolError(f"result for correlation {result.corr}, expected {req.corr}")
         if result.resolution == m.REJECTED:
@@ -253,6 +276,8 @@ class Host:
         """Several requests in flight (`exchange` keeps the probe's in-flight and window limits); results in
         order, rejects NOT raised - the caller looks at each result. Without `exchange`, one at a time."""
         session = self._session_for(locked)
+        if self.before_request is not None:
+            self.before_request()
         reqs = [m.Request(self.next_corr(), fn, op, payload, session) for fn, op, payload in requests]
         packed = [r.pack() for r in reqs]
         exchange = exchange or self.exchange