commit da3b062d89d269806d3390a878418410619bfcbb Author: Eiichi Shimazu Date: Mon Nov 16 11:19:58 2026 +0900 手教示の再生で送信のあとの 1.0 秒を daemon 0.2 秒 + Mac 0.8 秒に分ける形 (依頼 225・依頼 215 の案 F) のテストと集計の列を足す record_teach_demo.py (git の外) に --send-wait-on split (既定) を足した分のテスト pi05/test_send_wait_split.py と, teach_state_rate.py に 送信が無視された回・daemon の読みが返事なしの見込み・daemon 往復の中央と最大・待ちの形の列を足す. test_send_wait_mac.py は既定が split に替わった所だけ直す. 報告 claude_code_reports/20261116_225.txt Co-Authored-By: Claude Opus 5.5 diff --git a/claude_code_reports/20261116_225.txt b/claude_code_reports/20261116_225.txt new file mode 100644 index 0000000..b963ace --- /dev/null +++ b/claude_code_reports/20261116_225.txt @@ -0,0 +1,97 @@ +依頼225 Pi の pymycobot を 2.9.6 に戻して固定し、手教示の再生に案F(送ったあとの 1.0 秒を daemon 0.2 秒+Mac 0.8 秒に分ける)を入れる + +実機は動かしていない。Pi にはつながらなかった(下の 1)。 + +■ 1. pymycobot を 2.9.6 に戻す(Pi)… できていない +- Pi(ubuntu@192.168.2.1)に SSH も ping も届かなかった(2026-11-16 10:20 ごろと 11:40 ごろの 2 回。Mac に 192.168.2.x の口がなく、有線がつながっていないか Pi の電源が切れている見込み) +- そのため、いまの版・置き場所の確かめ、2.9.6 への入れ替え、import での確かめ、4.0.4 を誰が入れたかの手がかり読みは、どれもできていない +- 用意だけした: Mac で 2.9.6 の wheel を取ってきた + tools/pi/wheels/pymycobot-2.9.6-py3-none-any.whl(48,059 バイト・sha256 58a6a0c231505630d1896f0d6bfb6596f89aaa2e23df8cdb96a6702d4e6e0a6d。中の __version__ = "2.9.6"・必要なのは pyserial だけ) + git には入れていない +- Pi がつながったらやる手順(次の依頼かエイイチが流す。daemon は立ち上げ直さない。4.0.4 の whl は消さない) + 1) 確かめる(読むだけ) + ssh -i ~/.ssh/id_rsa_pi ubuntu@192.168.2.1 'python3.6 -c "import pymycobot;print(pymycobot.__version__, pymycobot.__file__)"; python3.6 -m pip show pymycobot; ls -la --time-style=full-iso /home/ubuntu/*.whl' + 2) 手がかり(読むだけ) + ssh ... 'grep -n pymycobot ~/.bash_history | tail -20; ls -la --time-style=full-iso ~/.cache/pip 2>/dev/null; grep -rl pymycobot ~/.cache/pip/log 2>/dev/null | head' + 3) 送って入れる + scp -i ~/.ssh/id_rsa_pi tools/pi/wheels/pymycobot-2.9.6-py3-none-any.whl ubuntu@192.168.2.1:/home/ubuntu/ + ssh ... 'python3.6 -m pip install --no-deps --force-reinstall /home/ubuntu/pymycobot-2.9.6-py3-none-any.whl' + (1 で置き場所が /usr/local など root のときは sudo が要る。--user で入っていたら --user を付ける。どちらかは 1 を見て決める) + 4) 確かめる: ssh ... 'python3.6 -c "import pymycobot;print(pymycobot.__version__)"' が 2.9.6 + 5) 固定: 戻したあと pip で上げ直されないよう、何かの requirements に pymycobot==2.9.6 を書くかどうかは決めてほしいこと(下) + +■ 2. 案F を入れた(record_teach_demo.py) +直す前の写し: dynamic_tracking_limits/drag_teaching/record_teach_demo.py.bak_pre_req225_20261116 +(teach_state_rate.py の写し pi05/teach_state_rate.py.bak_pre_req225_20261116) + +やったこと +- --send-wait-on に split を足し、既定にした(mac・daemon もこれまでどおり選べる) + - split: daemon に wait=0.2 で送る(daemon は 書き込み → 0.2 秒眠る → 1 回読む → 返事)。返事が来てから Mac で 0.8 秒待つ + - 秒数は --split-daemon-wait(既定 0.2)・--split-mac-wait(既定 0.8)で変えられる。合計が 1.0 秒より短い・daemon が 0 以下・Mac が負・数でない・split 以外で付けた、のときは動く前に止める(ABORT) + - Mac で待つ 0.8 秒は _sleep_open で電流の記録スレッドに知らせる(依頼213 と同じく角度を読める) + - daemon が待つ 0.2 秒は送信のやりとりの中(install_daemon_lock の鍵の中)なので、電流の記録スレッドは読まない(テストで送信の間に read_servo が入らないことを確かめた) + - ソケットの期限: visual_servo_pick の決まりどおり wait+3.0 = 3.2 秒(timeout_override は短くしかできないので渡さない。daemon の形の 4.0 秒より短いが、daemon の返事は 0.2 秒 + 書き込み + 読み 1 回 で約 0.23〜0.33 秒) + - 送信が例外でも待ってから例外を返す。0.2 秒を経ずに早く返った(すぐの例外など)ときは、送信の始めから合わせて 1.0 秒になるまで Mac で待つ(codex 1 回目 R1)。Ctrl-C は待たない(今までと同じ) +- 記録 + - 試行 JSON のいちばん上・params・区間ごとに send_wait_on と send_daemon_wait_sec(split は 0.2)・send_mac_wait_sec(0.8)。これは設定の値で、例外のときに延ばした実際の秒数ではない + - states.csv の stage 行の note に「send_wait_on=split daemon_wait=0.2 mac_wait=0.8」(mac は daemon_wait=0 mac_wait=1、daemon は daemon_wait=1 mac_wait=0)。列は足していない。電流スレッドの actual 行の note(source=current_thread)は今までどおり + - 区間ごとに send_daemon_failed(例外になった送信 "send" / "retry") +- 数えるもの + - 試行 JSON の send_ignored: 送信が無視された回(到達の待ちが切れて、動いた角度が 1.0° 未満で再送した回)の数・うち 0.00° の数・1 回ごとの区間と動いた角度・再送で届いたか。ログにも「送信が無視されたとみなして再送した回: N 回」と出す + - 試行 JSON の daemon_read_none_suspects: daemon.log の「send_angles 後の現在角度: None」の代わりの見込みの数。Pi の時計がずれていて daemon.log は秒単位なので、1 本ごとに Mac から確実に数える方法が無い。依頼215 で分かった「返事なしだと daemon の往復が約 0.1 秒長い」を使い、send_daemon_rtt_sec − daemon の wait が 0.08 秒以上の送信を数える(例外になった送信は skipped_send_error に別に数える)。ロック待ちや通信の遅れも混ざりうるので見込み + - pi05/teach_state_rate.py の本ごとの表に「無視」「うち0.00°」「無視の角度」「読みNone見込み」「daemon往復中央」「daemon往復最大」「待ち」(split は split 0.2+0.8)を足した。依頼225 より前の本は区間の retried から無視を数える(同じ決まり) +- 変えていないもの: 関節の目標・速さ・送る回数、到達と静止の確かめ、爪の前後で読みを止めること、爪の待ち、再送の決まり、tools/pi/mecharm_daemon.py(git の差分なし)。send_coords は使っていない(差分に無い)。CLAUDE.md の「time.sleep を短縮しない」: 合計 1.0 秒は縮めていない(daemon の中の time.sleep(0.2) と Mac 側の time.sleep(0.8) に分けただけで、早く返ったときは Mac 側を延ばす) + +テスト +- pi05/test_send_wait_split.py(新しく 27 件)OK: wait=0.2 で送ること・ソケットの期限の決まり・到達の確かめが始まるのは送信の始めから 1.043〜1.051 秒(daemon の形 1.038〜1.046 秒。縮んでいない)・0.2 秒の間に read_servo が入らない・0.8 秒の間に読む・命令の中身と順・到達/再送/静止の結果が daemon の形と同じ・JSON と states.csv の記録・無視の数え方(偽の daemon で 1 回無視させて 無視 1 回・0.00°・daemon 往復中央 0.242 秒)・早い例外で 1.0 秒まで延ばす・本物のソケットで 3.2 秒で切れて 0.8 秒待ち次はつなぎ直して通る・コマンドの既定と止める条件 +- pi05/test_send_wait_mac.py: 既定が split に替わった所(既定の確かめ・stage 行の note が形ごとに違う所)だけ直した。25 件 OK +- pi05/ のテスト 29 本: 27 本 OK。test_state_source は前から落ちる(依頼213 と同じ・今回と関係ない state_source の件)。test_teach_currents は一式で流したとき 1 件落ち(本体の get_angles の数が 1 回ずれる。依頼213 で書いた時刻のゆらぎ)、単独で流し直して 27 件 OK +- codex の指摘を直したあとに流し直した: test_send_wait_split 27 件 OK・test_send_wait_mac 25 件 OK・test_teach_current_actuals 21 件 OK・test_teach_currents 27 件 OK・test_power_ab 20 件 OK・test_no_step_confirm 17 件 OK +- ドライラン: python3 record_teach_demo.py run --teach drag_v2_20221013_152840_with_pos.json --teach-local drag_v2_20221013_152840_with_pos.json --grip-value 20 --power 5A + 「送信のあとの 1.0s の待ち: daemon 0.2s + Mac 0.8s に分ける」と出て、計画を出して止まった。合計 0.9 秒と、daemon の形に --split-mac-wait を付けたものは ABORT + +codex レビュー(codex exec -s read-only) +- 1 回目: 必須 1・推奨 2 + - R1 必須: すぐの例外・早い ok=False では合計 1.0 秒を割る → 送信の始めから 1.0 秒に届くまで Mac で延ばす形に直した + - R2: None の見込みに通信の失敗が混ざる → 例外になった送信を別に数える形に直した + - R3: 異常のときのテスト → 足した +- 2 回目: 必須なし。推奨 R2(先頭 HOME の 1 回目が通って再送が例外のときに混ざる)→ 4 か所すべてで例外になった送信を区間に残す形に直した。推奨 R3(本物のソケットで期限切れ)→ テストを足した +- 3 回目: 必須なし。推奨 2 は据え置き + - R1: 先頭 HOME の再送の例外を再生を通して確かめるテスト(今は 4 か所に入っていることをソースで、数え方を手作りの区間で確かめている) + - R2: 3.2 秒は 1 回の受信の期限で、つなぎ直しまで含めた送信全体の上限ではない(daemon の形の 4.0 秒も同じ作り。待ちが縮む話ではない) + +■ 3. 位置1〜5 を撮るときのコマンド(エイイチ) +Pi の pymycobot を 2.9.6 に戻すのは、daemon を立ち上げ直す前ならいつでもよい(今の daemon は 2.9.6 で動いている)。 +1. 位置 N の印にブロックを置いて測る + python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py measure +2. ドライラン(「daemon 0.2s + Mac 0.8s に分ける」と出るのを見る) + python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach drag_v2_20261109_094222.json --grip-value 20 --power 5A +3. 1 本撮る(既定が split。--send-wait-on split は付けても同じ) + python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach drag_v2_20261109_094222.json --grip-value 20 --power 5A --execute + (位置ごとの teach ファイルはこれまでのお手本の撮り方どおり) +4. 無視が出たら案A に切り替えて撮り続ける + python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach ... --grip-value 20 --power 5A --execute --send-wait-on daemon +5. 並べる(--out で CSV も残る) + python3 pi05/teach_state_rate.py --after run_0001_20261116_HHMMSS [ほかの本 ...] --out + +1 本ごとに見る所 +- 無視の回数: 実行の最後のログ「送信が無視されたとみなして再送した回: N 回」・試行 JSON の send_ignored(count・zero_move_count・events の retry_move_deg)・teach_state_rate.py の「無視」「うち0.00°」「無視の角度」。0.00° の無視が 1 回でも出たら案A へ +- 1 秒を超える抜け: teach_state_rate.py の「1秒超」(依頼213 の前の 2 本は 11。爪の待ちの分は残る)と「send中央」 +- send_daemon_rtt_sec が約 0.23 秒か: 表の「daemon往復中央」「daemon往復最大」。約 0.33 秒の送信は daemon の直後の読みが返事なしだった見込みで、「読みNone見込み」に数が出る(0.2 秒あとでも返事なしが多いかを見る所) +- daemon.log の None を本当に数えるとき(Pi の時計は Mac より約 2 時間 7 分遅い): ssh ... "grep -c 'send_angles 後の現在角度: None' ~/daemon.log" を撮る前と後で取って差を見る +- ほか今までどおり: 到達・再送(arrival_ok)、見込み超え(overruns)が 0 か、区間の長さ(segment_elapsed_sec) + +■ 変えたファイル +- dynamic_tracking_limits/drag_teaching/record_teach_demo.py(git の外。写し record_teach_demo.py.bak_pre_req225_20261116) +- pi05/teach_state_rate.py(写し pi05/teach_state_rate.py.bak_pre_req225_20261116) +- pi05/test_send_wait_mac.py +- pi05/test_send_wait_split.py(新しく) +- tools/pi/wheels/pymycobot-2.9.6-py3-none-any.whl(新しく・git の外) +- claude_code_reports/20261116_225.txt(この報告) +コミット: 報告の最後の行 + +■ 決めてほしいこと +1. Pi の pymycobot を 2.9.6 に戻す作業: Pi につながらずできていない。Pi をつないだあと、上の手順で次の依頼として流すか、エイイチが流すか +2. 2.9.6 の「固定」の形: pip で上げ直されないよう、Pi の requirements や手順書に pymycobot==2.9.6 を書くか(どこに書くか) +3. 位置1〜5 を撮るかどうかと、その時期(Pi を戻してから) +4. split のソケットの期限が 3.2 秒(daemon の形は 4.0 秒)になる。daemon の返事は 0.23〜0.33 秒の見込みなので足りるとみたが、4.0 秒にそろえたいなら visual_servo_pick.py を触ることになる(今回の範囲の外) diff --git a/pi05/teach_state_rate.py b/pi05/teach_state_rate.py index 1e02685..528b9bb 100644 --- a/pi05/teach_state_rate.py +++ b/pi05/teach_state_rate.py @@ -9,6 +9,9 @@ - 試行 JSON の segments: 動く区間ごとの送信の往復 (send_rtt_sec)・区間の長さ (segment_elapsed_sec)・再送・着いたか, 爪の前の静止の確かめ (still_check の reads・elapsed_sec・still) が直す前の本と同じ形かを見る. 合否の線は決めていない (表を出すだけ). +依頼 225: 本ごとに, 撮った形 (待ち. split は daemon と Mac の秒数)・送信が無視された回 (無視 = 到達の待ちが切れて +1.0° 未満で再送した回. うち 0.00°・そのときの角度)・daemon の送信のあとの読みが返事なしだった見込みの回数 +(試行 JSON の daemon_read_none_suspects. daemon.log の数そのものではない)・daemon だけの往復の中央と最大も出す. 入力: {runs_root}/{run}/{run}.json と {run}/recording/states.csv (runs_root の既定は KIOXIA の runs/run_pick_place) python3 pi05/teach_state_rate.py --before run_0001_20261109_094839 run_0001_20261109_095308 --after run_0001_20261116_... @@ -151,13 +154,39 @@ def measure(d): "send_rtt_sec": g.get("send_rtt_sec"), "segment_elapsed_sec": g.get("segment_elapsed_sec"), "send_daemon_rtt_sec": g.get("send_daemon_rtt_sec"), # 依頼 213: daemon とのやりとりだけ "retried": g.get("retried"), "arrival_ok": g.get("arrival_ok"), + "retry_move_deg": g.get("retry_move_deg"), # 依頼 225: 再送したときの動いた角度 "still_reads": sc.get("reads"), "still_elapsed_sec": sc.get("elapsed_sec"), "still": sc.get("still")}) out["still_reads_total"] = sum(s["still_reads"] or 0 for s in segs) out["retried_n"] = sum(1 for s in segs if s["retried"]) + # 依頼 225: 撮った形 (split は daemon と Mac の秒数も)・送信が無視された回・daemon の読みが返事なしの見込み + out["send_wait"] = wait_label(j) + ig = j.get("send_ignored") + if isinstance(ig, dict): + out["ignored_n"], out["ignored_zero_n"] = ig.get("count"), ig.get("zero_move_count") + moves = [e.get("retry_move_deg") for e in ig.get("events") or []] + else: # 依頼 225 より前の本は区間の retried から数える (同じ決まり: 到達の待ちが切れて 1.0° 未満で再送) + moves = [s["retry_move_deg"] for s in segs if s["retried"]] + out["ignored_n"] = len(moves) + out["ignored_zero_n"] = sum(1 for v in moves if isinstance(v, (int, float)) and abs(v) < 0.005) + out["ignored_moves"] = " ".join(fmt(v, 2) for v in moves) or None + ns = j.get("daemon_read_none_suspects") + out["read_none_suspects"] = ns.get("suspects") if isinstance(ns, dict) else None + rtts = [s["send_daemon_rtt_sec"] for s in segs + if isinstance(s["send_daemon_rtt_sec"], (int, float)) and not isinstance(s["send_daemon_rtt_sec"], bool)] + out["daemon_rtt_median"] = statistics.median(rtts) if rtts else None + out["daemon_rtt_max"] = max(rtts) if rtts else None return out, segs +def wait_label(j): + """依頼 225: 撮った形の表示. split は 'split 0.2+0.8'. 項目がない本 (依頼 213 より前) は None.""" + w = j.get("send_wait_on") + if w == "split": + return "split {:g}+{:g}".format(j.get("send_daemon_wait_sec") or 0, j.get("send_mac_wait_sec") or 0) + return w + + def fmt(v, nd=3): if v is None: return "-" @@ -170,7 +199,10 @@ RUN_COLS = [("run", "run"), ("n_actual", "actual"), ("n_current_thread", "うち ("all_p90", "90%"), ("all_long_n", "1秒超"), ("all_poll_median", "poll中央"), ("all_send_median", "send中央"), ("main_median", "本体だけ中央"), ("main_p90", "本体90%"), ("cur_median", "電流だけ中央"), ("order_reversed", "逆順"), ("late_current_thread", "送らず"), ("overruns", "見込み超え"), - ("still_reads_total", "静止reads"), ("retried_n", "再送"), ("send_wait_on", "待ち"), ("result", "結果")] + ("still_reads_total", "静止reads"), ("retried_n", "再送"), + ("ignored_n", "無視"), ("ignored_zero_n", "うち0.00°"), ("ignored_moves", "無視の角度"), + ("read_none_suspects", "読みNone見込み"), ("daemon_rtt_median", "daemon往復中央"), + ("daemon_rtt_max", "daemon往復最大"), ("send_wait", "待ち"), ("result", "結果")] def print_group(label, ms): @@ -183,7 +215,7 @@ def print_group(label, ms): v = [m[k] for m in ms if isinstance(m.get(k), (int, float))] return statistics.median(v) if v else None print(" (本ごとの中央値) " + " | ".join( - f"{h} {fmt(med(k))}" for k, h in RUN_COLS[1:] if k not in ("result", "send_wait_on"))) + f"{h} {fmt(med(k))}" for k, h in RUN_COLS[1:] if k not in ("result", "send_wait", "ignored_moves"))) def print_segments(groups): diff --git a/pi05/test_send_wait_mac.py b/pi05/test_send_wait_mac.py index 5ea86dd..5b3b4fb 100644 --- a/pi05/test_send_wait_mac.py +++ b/pi05/test_send_wait_mac.py @@ -9,7 +9,7 @@ 本物の tools/pi/mecharm_daemon.py と同じ形にする: 書き込み → wait 秒眠る → 角度を 1 回読む → 返事. 確かめること: - - --send-wait-on mac (既定): daemon へは wait=0・ソケットの期限 4.0 秒 (wait+3.0 と同じ) で送り, 返ってから + - --send-wait-on mac (依頼 225 で既定は split に替わった. split は test_send_wait_split.py): daemon へは wait=0・ソケットの期限 4.0 秒 (wait+3.0 と同じ) で送り, 返ってから Mac 側で 1.0 秒待つ. この間に電流の記録スレッドが read_servo で読み, states.csv の actual 行になる - 到達の確かめ (本体の最初の get_angles) が始まる時刻は送信の始めから 1.0 秒 + 書き込みと読み 1 回 のあと (daemon で待つときと同じ. 縮んでいない) @@ -20,7 +20,7 @@ - --send-wait-on daemon は依頼 202 までと同じ (wait=1.0 を daemon へ. Mac 側で待たない. その間は読まない) - 区間と試行 JSON に send_wait_on・send_daemon_rtt_sec が残る. teach_state_rate.py が待ちの列を出す - _send_angles_guarded: 送信が例外でも 1.0 秒待ってから例外を返す・Ctrl-C は待たない・姿勢検査で弾いたら送らず待たない - - コマンドの --send-wait-on の既定は mac・ほかの値は受け付けない + - コマンドの --send-wait-on の既定は split (依頼 225)・mac / daemon も選べる・ほかの値は受け付けない - (codex R1) 窓の終わりぎわの read_servo が長引くと本体の次の読みはその分遅れる (早まらない・overruns に数える) - (codex R3) 送信が 4.0 秒で返らなければ切れて, 1.0 秒待ってから例外. 次の命令はつなぎ直して通る KIOXIA にもアームにも触らない (一時フォルダと 127.0.0.1 だけ). @@ -197,7 +197,9 @@ class TestReplaySendWait(unittest.TestCase): (g.get("still_check") or {}).get("still"), (g.get("still_check") or {}).get("reads")) for g in lr["segments"]] self.assertEqual(summary(self.mac["lr"]), summary(self.dmn["lr"])) - no_act = lambda r: [k for k in tca.main_kinds(r["sent"]) if k[0] != "actual"] # noqa: E731 + # 依頼 225: stage 行の note は撮った形 (send_wait_on=...) なので形ごとに違う. それ以外は同じ + no_act = lambda r: [k[:3] + ((None,) if k[0] == "stage" else k[3:]) # noqa: E731 + for k in tca.main_kinds(r["sent"]) if k[0] != "actual"] self.assertEqual(no_act(self.mac), no_act(self.dmn)) # stage・爪の通知の並びと中身は同じ n_act = lambda r: sum(1 for k in tca.main_kinds(r["sent"]) if k[0] == "actual") # noqa: E731 self.assertLessEqual(abs(n_act(self.mac) - n_act(self.dmn)), 1) # 本体の actual (= 本体の読み) は上と同じ扱い @@ -435,8 +437,10 @@ class TestCli(unittest.TestCase): rtd.main() return got["a"] - def test_default_mac(self): - self.assertEqual(self._parse(["run", "--teach", "x.json"]).send_wait_on, "mac") + def test_default_split(self): + # 依頼 225: 既定は split. mac / daemon も選べる + self.assertEqual(self._parse(["run", "--teach", "x.json"]).send_wait_on, "split") + self.assertEqual(self._parse(["run", "--teach", "x.json", "--send-wait-on", "mac"]).send_wait_on, "mac") self.assertEqual(self._parse(["run", "--teach", "x.json", "--send-wait-on", "daemon"]).send_wait_on, "daemon") def test_bad_value(self): @@ -453,11 +457,11 @@ class TestCli(unittest.TestCase): self.assertEqual(src.count('"send_wait_on": SEND_WAIT_ON'), 2) # いちばん上と params def test_cmd_run_rejects_bad_value(self): - """cmd_run を直接呼ぶ形でも mac / daemon 以外は止める (グローバルは変えない).""" + """cmd_run を直接呼ぶ形でも split / mac / daemon 以外は止める (グローバルは変えない).""" a = mock.Mock(grip_value=None, power=None, send_wait_on="pi", no_currents=False, no_record=False) with mock.patch("sys.stdout", new=io.StringIO()), self.assertRaises(SystemExit): rtd.cmd_run(a) - self.assertEqual(rtd.SEND_WAIT_ON, "mac") + self.assertEqual(rtd.SEND_WAIT_ON, "split") if __name__ == "__main__": diff --git a/pi05/test_send_wait_split.py b/pi05/test_send_wait_split.py new file mode 100644 index 0000000..0665d4a --- /dev/null +++ b/pi05/test_send_wait_split.py @@ -0,0 +1,440 @@ +#!/usr/bin/env python3 +"""test_send_wait_split.py — 手教示の再生で, 送信のあとの 1.0 秒を daemon 0.2 秒 + Mac 0.8 秒に分ける形 +(依頼 225. 依頼 215 の案 F) を偽の daemon で確かめる (アームなし・Pi なし. 2026-11-16). + + python3 pi05/test_send_wait_split.py # 全部 (再生を 3 回通すので 1 分半ほど) + python3 pi05/test_send_wait_split.py -v + +偽の daemon は test_send_wait_mac.WaitDaemon (本物の send_angles と同じ: 書き込み → wait 秒眠る → 1 回読む → 返事). + +確かめること: + - --send-wait-on split (既定): daemon へは wait=0.2 で送る (ソケットの期限は wait+3.0 の決まりどおり. + timeout_override は渡さない). 返ってから Mac 側で 0.8 秒待つ. 合わせて 1.0 秒で, 到達の確かめが始まるのは + 送信の始めから 1.0 秒 + 書き込み + 読み 1 回 のあと (daemon で待つときと同じ. 縮んでいない) + - daemon が眠っている 0.2 秒 (送信のやりとりの中) に read_servo は入らない. Mac で待つ 0.8 秒には入る + - 本体が daemon に送る命令 (関節の目標・速さ・爪) と順, 到達・再送・静止の確かめは daemon で待つときと同じ + (違うのは send_angles の wait だけ) + - 区間と試行 JSON に send_wait_on・send_daemon_wait_sec・send_mac_wait_sec が残る. states.csv の stage 行の note に + send_wait_on=split daemon_wait=0.2 mac_wait=0.8 が残る + - 送信が無視された回 (send_ignored) と daemon の読みが返事なしの見込み (daemon_read_none_suspects) を試行 JSON に出し, + teach_state_rate.py の表に出す (依頼 225 より前の本は区間の retried から数える) + - _send_angles_guarded: 送信が例外でも 0.8 秒待ってから例外を返す・Ctrl-C は待たない・秒数はグローバルで変わる + - コマンド: 既定 split・--split-daemon-wait / --split-mac-wait (既定 0.2 / 0.8). 合計 1.0 秒未満・daemon 0 以下・ + split 以外での指定は止める +KIOXIA にもアームにも触らない (一時フォルダと 127.0.0.1 だけ). +""" +import csv +import io +import json +import sys +import tempfile +import time +import unittest +from pathlib import Path +from unittest import mock + +_HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(_HERE)) +sys.path.insert(0, str(_HERE.parent / "dynamic_tracking_limits" / "drag_teaching")) + +import test_send_wait_mac as tswm # noqa: E402 (WaitDaemon・replay) +import test_teach_current_actuals as tca # noqa: E402 +import policy_recorder as pr # noqa: E402 +import visual_servo_pick as vsp # noqa: E402 +import record_teach_demo as rtd # noqa: E402 +import teach_state_rate as tsr # noqa: E402 + +SPLIT_NOTE = "send_wait_on=split daemon_wait=0.2 mac_wait=0.8" + + +class TestReplaySplit(unittest.TestCase): + """再生を 2 回 (split / daemon) 通して比べる.""" + + @classmethod + def setUpClass(cls): + cls.td = Path(tempfile.mkdtemp()) + pr.install_daemon_lock() + cls.spl = tswm.replay("split", cls.td / "run_0001_20991116_000001") + cls.dmn = tswm.replay("daemon", cls.td / "run_0002_20991116_000002") + root = cls.td / "states" + cls.st_spl = tca.write_states(root, "run_0001_20991116_000001", cls.spl["sent"]) + + def test_completed(self): + self.assertEqual((self.spl["result"], self.dmn["result"]), ("completed", "completed")) + + def test_wait_sent_to_daemon(self): + """split は wait=0.2, daemon は wait=1.0 を送る. ほかの中身 (目標・速さ) と順は同じ.""" + ws = {s[3].get("wait") for s in tswm.sends(self.spl["d"])} + wd = {s[3].get("wait") for s in tswm.sends(self.dmn["d"])} + self.assertEqual((ws, wd), ({0.2}, {rtd.SEND_WAIT_SEC})) + strip = lambda d: [(s[0], {k: v for k, v in s[3].items() if k != "wait"}) # noqa: E731 + for s in d.spans if s[0] in ("send_angles", "set_gripper", "set_gripper_value", + "set_fresh_mode")] + self.assertEqual(strip(self.spl["d"]), strip(self.dmn["d"])) + + def test_socket_timeout_rule(self): + """split は timeout_override を渡さない (visual_servo_pick の wait+3.0 = 3.2 秒になる).""" + seen = [] + + def spy(cmd_obj, timeout_override=None, **k): + seen.append((cmd_obj.get("wait"), timeout_override)) + return {"ok": True, "elapsed_ms": 1.0} + with mock.patch.object(vsp, "_daemon_request", spy), mock.patch.object(rtd, "SEND_WAIT_ON", "split"), \ + mock.patch.object(rtd.time, "sleep", lambda s: None): + rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t") + self.assertEqual(seen, [(0.2, None)]) + + def test_arrival_start_not_earlier(self): + """本体の到達の確かめが始まるのは, どちらも送信の始めから 1.0 秒 + 書き込み + 読み 1 回 のあと.""" + lo = rtd.SEND_WAIT_SEC + tswm.WRITE_SEC + tswm.READ_ONCE_SEC + delays = {} + for name, r in (("split", self.spl), ("daemon", self.dmn)): + ds = [tswm.next_main_get(r["d"], s[2]) - s[1] for s in tswm.sends(r["d"])] + delays[name] = ds + self.assertGreaterEqual(min(ds), lo - 0.002, name) + for a, b in zip(delays["split"], delays["daemon"]): + self.assertLess(abs(a - b), 0.08) + print(f"\n送信の始め → 到達の確かめの始め (秒): split {[round(x, 3) for x in delays['split']]}" + f" / daemon {[round(x, 3) for x in delays['daemon']]}") + + def test_no_reads_during_daemon_wait(self): + """daemon が眠る 0.2 秒 (送信のやりとりの中) に read_servo は入らない. 返事のあとの 0.8 秒には入る.""" + d = self.spl["d"] + rs = [x for x in d.spans if x[0] == "read_servo"] + n_after = 0 + for s in tswm.sends(d): + inside = [x for x in rs if s[1] - 0.001 <= x[1] < s[2] or s[1] < x[2] <= s[2]] + self.assertEqual(inside, [], "送信の間に read_servo") + self.assertGreaterEqual(s[2] - s[1], 0.2) # daemon の中で 0.2 秒眠っている + first = [x[1] for x in rs if x[1] >= s[2]] + if first and first[0] < s[2] + rtd.SEND_SPLIT_MAC_WAIT_SEC: + n_after += 1 + self.assertGreaterEqual(first[0] - s[1], 0.2) # 書き込みから 0.2 秒より後 + self.assertGreaterEqual(n_after, len(tswm.sends(d)) - 1) + + def test_same_checks_as_daemon(self): + def summary(lr): + return [(g.get("kind"), g.get("arrival_ok"), g.get("retried"), tuple(g.get("warnings") or ()), + (g.get("still_check") or {}).get("still"), (g.get("still_check") or {}).get("reads")) + for g in lr["segments"]] + self.assertEqual(summary(self.spl["lr"]), summary(self.dmn["lr"])) + no_act = lambda r: [k[:3] for k in tca.main_kinds(r["sent"]) if k[0] != "actual"] # noqa: E731 + self.assertEqual(no_act(self.spl), no_act(self.dmn)) + self.assertEqual(self.spl["lr"]["currents"]["overruns"], 0) + + def test_segment_records(self): + moves = [g for g in self.spl["lr"]["segments"] if "send_rtt_sec" in g] + self.assertGreater(len(moves), 3) + for g in moves: + self.assertEqual((g["send_wait_on"], g["send_daemon_wait_sec"], g["send_mac_wait_sec"]), + ("split", 0.2, 0.8)) + self.assertGreaterEqual(g["send_rtt_sec"], rtd.SEND_WAIT_SEC) + self.assertGreaterEqual(g["send_daemon_rtt_sec"], 0.2) + self.assertLess(g["send_daemon_rtt_sec"], 0.5) + dm = [g for g in self.dmn["lr"]["segments"] if "send_rtt_sec" in g] + self.assertEqual({(g["send_daemon_wait_sec"], g["send_mac_wait_sec"]) for g in dm}, + {(rtd.SEND_WAIT_SEC, 0.0)}) + + def test_ignored_summary_zero(self): + lr = self.spl["lr"] + self.assertEqual((lr["send_ignored"]["count"], lr["send_ignored"]["zero_move_count"]), (0, 0)) + self.assertEqual(lr["daemon_read_none_suspects"]["suspects"], 0) + self.assertEqual(lr["daemon_read_none_suspects"]["daemon_wait_sec"], 0.2) + self.assertGreater(lr["daemon_read_none_suspects"]["sends"], 3) + + def test_stage_note_in_states_csv(self): + stage_notes = {p.get("note") for p in self.spl["sent"] if p["type"] == "stage"} + self.assertEqual(stage_notes, {SPLIT_NOTE}) + with self.st_spl.open() as f: + rows = list(csv.DictReader(f)) + st = [r for r in rows if r["event_type"] == "stage"] + self.assertTrue(st) + self.assertTrue(all(r["note"] == SPLIT_NOTE for r in st)) + # 電流スレッドの行の note は今までどおり + self.assertTrue(any(r["note"] == rtd.CURRENT_THREAD_NOTE for r in rows if r["event_type"] == "actual")) + dn = {p.get("note") for p in self.dmn["sent"] if p["type"] == "stage"} + self.assertEqual(dn, {"send_wait_on=daemon daemon_wait=1 mac_wait=0"}) + + def test_rate_table(self): + m, segs = tsr.measure(self.st_spl.parent.parent) + self.assertEqual(m["order_reversed"], 0) + self.assertGreater(m["n_current_thread"], 0) + + +class TestRetrySplit(unittest.TestCase): + """送信無視 → 5 秒待って再送の経路も split で通り, 無視の回が数えられる.""" + + def test_retry_counted(self): + pr.install_daemon_lock() + td = Path(tempfile.mkdtemp()) + r = tswm.replay("split", td / "run_0003_20991116_000003", ignore_sends=(1,)) + self.assertEqual(r["result"], "completed") + seg = [g for g in r["lr"]["segments"] if g.get("retried")] + self.assertEqual(len(seg), 1) + self.assertGreaterEqual(seg[0]["send_daemon_rtt_retry_sec"], 0.2) + self.assertEqual({s[3].get("wait") for s in tswm.sends(r["d"])}, {0.2}) + ig = r["lr"]["send_ignored"] + self.assertEqual(ig["count"], 1) + self.assertEqual(ig["zero_move_count"], 1 if seg[0]["retry_move_deg"] < 0.005 else 0) + self.assertEqual(ig["events"][0]["retry_move_deg"], seg[0]["retry_move_deg"]) + # teach_state_rate.py の表 + st = tca.write_states(td / "states", "run_0003_20991116_000003", r["sent"]) + run = st.parent.parent + (run / f"{run.name}.json").write_text(json.dumps(r["lr"], default=str)) + m, _ = tsr.measure(run) + self.assertEqual((m["ignored_n"], m["send_wait"]), (1, None)) # 再生だけなので いちばん上の send_wait_on はない + self.assertIsNotNone(m["ignored_moves"]) + self.assertEqual(m["read_none_suspects"], 0) + print(f"\nsplit の再送: 無視 {m['ignored_n']} 回 (角度 {m['ignored_moves']}) daemon 往復中央 " + f"{m['daemon_rtt_median']:.3f} 秒") + + +class TestSplitSocketTimeout(unittest.TestCase): + """codex 2 回目 R3: 本物の通信 (127.0.0.1) で, split の送信が wait+3.0 = 3.2 秒で切れ, そのあと Mac で 0.8 秒待って + から例外を返す. 次の命令はつなぎ直して通る.""" + + def test_timeout_real_socket(self): + d = tswm.SlowTailDaemon(send_extra=3.2 + 0.6) + vsp.close_daemon_socket() + try: + with mock.patch.object(vsp, "DAEMON_HOST", "127.0.0.1"), mock.patch.object(vsp, "DAEMON_PORT", d.port), \ + mock.patch.object(rtd, "SEND_WAIT_ON", "split"), mock.patch("sys.stdout", new=io.StringIO()): + t0 = time.monotonic() + with self.assertRaises(Exception): + rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t") + el = time.monotonic() - t0 + rtt = rtd._LAST_SEND["daemon_rtt_sec"] + time.sleep(1.5) # 偽の daemon が遅れた返事を書き終えるまで + a = vsp.daemon_get_angles() + finally: + vsp.close_daemon_socket() + d.close() + self.assertAlmostEqual(rtt, 3.2, delta=0.3) + self.assertGreaterEqual(el, 3.2 + rtd.SEND_SPLIT_MAC_WAIT_SEC - 0.05) + self.assertLess(el, 3.2 + rtd.SEND_SPLIT_MAC_WAIT_SEC + 0.5) + self.assertEqual(len(a), 6) + + +class TestSummaries(unittest.TestCase): + def test_none_suspects(self): + segs = [{"send_daemon_rtt_sec": 0.23}, {"send_daemon_rtt_sec": 0.33, "send_daemon_rtt_retry_sec": 0.22}, + {"kind": "gripper"}, {"send_daemon_rtt_sec": None}] + with mock.patch.object(rtd, "SEND_WAIT_ON", "split"): + r = rtd._daemon_read_none_suspects(segs) + self.assertEqual((r["sends"], r["suspects"], r["skipped_send_error"]), (3, 1, 0)) + with mock.patch.object(rtd, "SEND_WAIT_ON", "split"): # codex 1 回目 R2: 送信が例外の区間は別に数える + r = rtd._daemon_read_none_suspects([ + {"send_daemon_rtt_sec": 3.2, "send_daemon_failed": ["send"]}, + {"send_daemon_rtt_sec": 0.23, "send_daemon_failed": []}, + # codex 2 回目 R2: 1 回目は通って再送が例外 (先頭 HOME でも同じ項目) + {"send_daemon_rtt_sec": 0.33, "send_daemon_rtt_retry_sec": 3.2, "send_daemon_failed": ["retry"]}]) + self.assertEqual((r["sends"], r["suspects"], r["skipped_send_error"]), (2, 1, 2)) + with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"): # mac は wait=0: 0.03 / 0.13 (依頼 215) + r = rtd._daemon_read_none_suspects([{"send_daemon_rtt_sec": 0.03}, {"send_daemon_rtt_sec": 0.13}]) + self.assertEqual(r["suspects"], 1) + + def test_ignored_summary(self): + segs = [{"kind": "move", "step": 1, "retried": True, "retry_move_deg": 0.0, "to_name": "HOME"}, + {"kind": "move", "retried": False}, {"kind": "gripper"}, + {"kind": "move", "step": 4, "retried": True, "retry_move_deg": 0.4}] + r = rtd._send_ignored_summary(segs) + self.assertEqual((r["count"], r["zero_move_count"], r["move_segments"]), (2, 1, 3)) + self.assertEqual([e["step"] for e in r["events"]], [1, 4]) + + def test_rate_table_old_json(self): + """依頼 225 より前の本 (send_ignored がない) は区間の retried から数える. 待ちの列は mac / daemon のまま.""" + td = Path(tempfile.mkdtemp()) + run = td / "run_0009_20991116_000009" + (run / "recording").mkdir(parents=True) + (run / "recording" / "states.csv").write_text( + "ts,event_type,stage,j0,j1,j2,j3,j4,j5,speed,gripper_state,ts_send,ts_arrival,attempt,arrived,note\n" + "1.0,stage,HOME,,,,,,,,,,,,,\n1.1,actual,HOME,0,0,0,0,0,0,,,,,,,\n") + (run / f"{run.name}.json").write_text(json.dumps({"send_wait_on": "mac", "segments": [ + {"step": 1, "kind": "move", "to_name": "HOME", "send_rtt_sec": 1.05, "send_daemon_rtt_sec": 0.13, + "retried": True, "retry_move_deg": 0.0}, + {"step": 2, "kind": "move", "to_name": "A", "send_rtt_sec": 1.03, "send_daemon_rtt_sec": 0.03}]})) + m, _ = tsr.measure(run) + self.assertEqual((m["ignored_n"], m["ignored_zero_n"], m["ignored_moves"]), (1, 1, "0.00")) + self.assertEqual((m["send_wait"], m["read_none_suspects"]), ("mac", None)) + self.assertAlmostEqual(m["daemon_rtt_median"], 0.08) + self.assertEqual(m["daemon_rtt_max"], 0.13) + + def test_rate_table_split_label(self): + self.assertEqual(tsr.wait_label({"send_wait_on": "split", "send_daemon_wait_sec": 0.2, + "send_mac_wait_sec": 0.8}), "split 0.2+0.8") + self.assertEqual(tsr.wait_label({"send_wait_on": "daemon"}), "daemon") + self.assertIsNone(tsr.wait_label({})) + m = {"run": "r", "send_wait": "split 0.2+0.8", "ignored_n": 0, "ignored_zero_n": 0, + "ignored_moves": None, "read_none_suspects": 0} + with mock.patch("sys.stdout", new=io.StringIO()) as out: + tsr.print_group("後", [m, dict(m)]) + for h in ("無視", "うち0.00°", "読みNone見込み", "split 0.2+0.8"): + self.assertIn(h, out.getvalue()) + + +class _Rec(object): + def __init__(self): + self.windows = [] + + def currents_window(self, sec): + self.windows.append(sec) + + +class TestGuardedSplit(unittest.TestCase): + def setUp(self): + self.calls, self.slept, self.exc = [], [], None + self.clock = [100.0] # 偽の時計. 偽の送信は本物と同じく wait + 0.03 秒かかる (例外のときはすぐ返る) + self.p = [mock.patch.object(rtd.time, "sleep", lambda s: self.slept.append(s)), + mock.patch.object(rtd.time, "monotonic", lambda: self.clock[0]), + mock.patch.object(rtd, "daemon_send_angles", self._send), + mock.patch.object(rtd, "SEND_WAIT_ON", "split")] + for p in self.p: + p.start() + + def tearDown(self): + for p in self.p: + p.stop() + + def _send(self, pose, speed, wait=0, timeout_override=None): + self.calls.append((list(pose), speed, wait, timeout_override, list(self.slept))) + if self.exc is not None: + raise self.exc + self.clock[0] += wait + 0.03 + return {"ok": True} + + def test_split_waits_after_send(self): + rec = _Rec() + rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec) + self.assertEqual(self.calls, [(list(rtd.HOME_ANGLES), 20, 0.2, None, [])]) + self.assertEqual(self.slept, [0.8]) + self.assertEqual(rec.windows, [0.8]) # Mac の 0.8 秒だけ電流の記録に知らせる + self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"]) + + def test_split_without_recorder(self): + rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t") + self.assertEqual(self.slept, [0.8]) + + def test_split_other_seconds(self): + with mock.patch.object(rtd, "SEND_SPLIT_DAEMON_WAIT_SEC", 0.3), \ + mock.patch.object(rtd, "SEND_SPLIT_MAC_WAIT_SEC", 0.7): + rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=_Rec()) + self.assertEqual(rtd._send_wait_note(), "send_wait_on=split daemon_wait=0.3 mac_wait=0.7") + self.assertEqual((self.calls[0][2], self.slept), (0.3, [0.7])) + + def test_split_send_error_still_waits(self): + """codex 1 回目 R1・R3: 送信がすぐ例外になっても, 送信の始めから合わせて 1.0 秒まで待ってから例外を返す.""" + self.exc = RuntimeError("daemon error") + rec = _Rec() + with self.assertRaises(RuntimeError): + rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec) + self.assertEqual(self.slept, [1.0]) # すぐ返ったので 0.8 ではなく 1.0 + self.assertEqual(rec.windows, self.slept) # 延ばした分も電流の記録に知らせる + self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"]) + + def test_split_fast_return_padded(self): + """daemon が 0.2 秒眠らずに早く返った (ok の返事でも) ときも合わせて 1.0 秒にする. 0.2 秒以上かかれば 0.8 秒.""" + clock = self.clock + if True: + def send(pose, speed, wait=0, timeout_override=None): + clock[0] += 0.05 + return {"ok": True} + with mock.patch.object(rtd, "daemon_send_angles", send): + rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t") + self.assertAlmostEqual(self.slept[-1], 0.95) + + def send2(pose, speed, wait=0, timeout_override=None): + clock[0] += 0.23 + return {"ok": True} + with mock.patch.object(rtd, "daemon_send_angles", send2): + rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t") + self.assertEqual(self.slept[-1], 0.8) + + def send3(pose, speed, wait=0, timeout_override=None): + clock[0] += 3.2 + raise RuntimeError("socket timeout") + with mock.patch.object(rtd, "daemon_send_angles", send3), self.assertRaises(RuntimeError): + rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t") + self.assertEqual(self.slept[-1], 0.8) # 期限切れでも Mac の 0.8 秒は縮めない + + def test_split_ctrl_c_not_waited(self): + self.exc = KeyboardInterrupt() + with self.assertRaises(KeyboardInterrupt): + rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=_Rec()) + self.assertEqual(self.slept, []) + + def test_backstop_no_send_no_wait(self): + bad = list(rtd.HOME_ANGLES) + bad[0] = float("nan") + with self.assertRaises(rtd._Aborted): + rtd._send_angles_guarded(bad, 20, "t", recorder=_Rec()) + self.assertEqual((self.calls, self.slept), ([], [])) + + +class TestCliSplit(unittest.TestCase): + def setUp(self): + self.saved = (rtd.SEND_WAIT_ON, rtd.SEND_SPLIT_DAEMON_WAIT_SEC, rtd.SEND_SPLIT_MAC_WAIT_SEC) + + def tearDown(self): + rtd.SEND_WAIT_ON, rtd.SEND_SPLIT_DAEMON_WAIT_SEC, rtd.SEND_SPLIT_MAC_WAIT_SEC = self.saved + + def _parse(self, argv): + got = {} + with mock.patch.object(rtd, "cmd_run", lambda a: got.setdefault("a", a) and 0), \ + mock.patch.object(sys, "argv", ["record_teach_demo.py"] + argv): + rtd.main() + return got["a"] + + def test_defaults(self): + self.assertEqual(rtd.SEND_WAIT_ON_CHOICES, ("split", "mac", "daemon")) + self.assertEqual((rtd.SEND_SPLIT_DAEMON_WAIT_SEC, rtd.SEND_SPLIT_MAC_WAIT_SEC), (0.2, 0.8)) + a = self._parse(["run", "--teach", "x.json"]) + self.assertEqual((a.send_wait_on, a.split_daemon_wait, a.split_mac_wait), ("split", None, None)) + a = self._parse(["run", "--teach", "x.json", "--split-daemon-wait", "0.3", "--split-mac-wait", "0.7"]) + self.assertEqual((a.split_daemon_wait, a.split_mac_wait), (0.3, 0.7)) + self.assertEqual(self._parse(["run", "--teach", "x.json", "--send-wait-on", "daemon"]).send_wait_on, "daemon") + + def _cmd_run(self, **kw): + base = dict(grip_value=None, power=None, send_wait_on="split", split_daemon_wait=None, + split_mac_wait=None, no_currents=False, no_record=False, teach_local=None, execute=False, + teach="dir/x.json") # 秒数の確かめのあと, --teach のディレクトリで止まる (Pi・カメラに触らない) + base.update(kw) + with mock.patch("sys.stdout", new=io.StringIO()) as out, self.assertRaises(SystemExit): + rtd.cmd_run(mock.Mock(**base)) + return out.getvalue() + + def test_cmd_run_rejects(self): + for kw in ({"split_daemon_wait": 0.1, "split_mac_wait": 0.8}, # 合計 0.9 < 1.0 + {"split_daemon_wait": 0.0, "split_mac_wait": 1.0}, # daemon 0 (wait=0 は mac の形) + {"split_mac_wait": -0.1}, + {"split_daemon_wait": float("nan")}, + {"send_wait_on": "mac", "split_mac_wait": 0.8}): # split 以外では使えない + out = self._cmd_run(**kw) + self.assertIn("--split", out, kw) + self.assertEqual(rtd.SEND_WAIT_ON, self.saved[0], kw) # 止めたときはグローバルを変えない + self.assertEqual(rtd.SEND_SPLIT_DAEMON_WAIT_SEC, 0.2, kw) + + def test_cmd_run_sets_split(self): + out = self._cmd_run() + self.assertEqual((rtd.SEND_WAIT_ON, rtd.SEND_SPLIT_DAEMON_WAIT_SEC, rtd.SEND_SPLIT_MAC_WAIT_SEC), + ("split", 0.2, 0.8)) + self.assertIn("daemon 0.2s + Mac 0.8s", out) + self._cmd_run(split_daemon_wait=0.3, split_mac_wait=0.7) + self.assertEqual((rtd.SEND_SPLIT_DAEMON_WAIT_SEC, rtd.SEND_SPLIT_MAC_WAIT_SEC), (0.3, 0.7)) + self._cmd_run(send_wait_on="daemon") + self.assertEqual(rtd.SEND_WAIT_ON, "daemon") + + def test_trial_json_fields(self): + import inspect + src = inspect.getsource(rtd.cmd_run) + self.assertEqual(src.count('"send_daemon_wait_sec": _send_wait_daemon_sec()'), 2) # いちばん上と params + rsrc = inspect.getsource(rtd._replay) + self.assertIn('log_record["send_ignored"] = _send_ignored_summary(segments_log)', rsrc) + self.assertEqual(rsrc.count('"send_mac_wait_sec": _send_wait_mac_sec()'), 2) # 先頭 HOME と各区間 + # codex 2 回目 R2: 例外になった送信は 4 か所 (先頭 HOME・その再送・各区間・その再送) すべてで残す + self.assertEqual(rsrc.count('_failed.append("send")'), 2) + self.assertEqual(rsrc.count('_failed.append("retry")'), 2) + self.assertEqual(rsrc.count('"send_daemon_failed": list('), 2) + + +if __name__ == "__main__": + unittest.main()