From c62452ec4bee165f0e87dfbea4df665c8f34cb93 Mon Sep 17 00:00:00 2001 From: ykcheungab Date: Tue, 15 Sep 2026 09:53:47 +0800 Subject: [PATCH] =?UTF-8?q?=E6=8B=86=E5=88=86=E6=94=B6=E5=B0=BE=EF=BC=9A?= =?UTF-8?q?=E6=A0=87=E5=AE=9A=E5=BD=92=E5=B1=9E=E8=A7=84=E5=88=99=E7=A7=BB?= =?UTF-8?q?=E5=85=A5=20CalibrationService=EF=BC=88app=5Fwindow=202340?= =?UTF-8?q?=E2=86=922304=20=E8=A1=8C=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - What: `apps/studio/src/orisys_studio/calibration_service.py` 新增三条**无状态**规则， 它们原来长在窗口里：`identity_of(path)`（这份系数文件声称属于哪台设备——用 SDK 自己的 解析器读，与设备将要加载的是同一份文档；读不出来就什么都不声称）、`same_path(a, b)` （同一个配置路径的不同写法不算不一致；两个空值也不算）、 `target_mismatch(path, *, sensor_type, config_ref)`（在确认框之前就说清楚"这份标定 看起来不属于这台设备"的理由）。服务本来就是这个文件工作的所有者，规则回到了它这里， 并且不需要窗口就能测。 - What: 窗口保留 `calibration_identity` / `calibration_target_mismatch` 两个转发 （tests 与 tools/ui_check.py 通过窗口驱动它们），删除 `_same_path`。 `_on_calibration_apply` 仍留在窗口：它要弹确认框、要把路径交给采集 worker，那是交互 与会话，不是关于文件的规则；`_calibration_summary`、`_drain_calibration_events`、 `_drain_reset_events`、`_on_calibration_point/cancelled/exported` 同理（面板与状态栏 的胶水）。 - What: 新增 apps/studio/tests/test_calibration_service.py：4 个用例——身份读出 sensor_type/sn/config_ref、读不出来的文件既无身份也无"不匹配"指控（不能把"不知道" 当成"不一致"）、另一台设备/另一份配置会被逐条报出而同一台不会、同一路径的不同写法 不算不一致而非路径值算。 - Why: 这是 app_window 拆分计划里最后一块「有独立规则可搬」的部分。搬完之后 "这份标定是谁的"只有一处实现，窗口只剩对话与转发。 - Verification: pytest shared/tests apps/studio/tests（offscreen）636 passed / 0 failed / 15 skipped（原 632 + 新增 4）；apps/studio/tools/ui_check.py 587 项检查 0 失败； .repro/locale_check.py 0 缺失。行为等价（同一份实现 + 一层转发）。 - Not in this change: 预览（_start_preview/_stop_preview/_on_preview_tick）与 2D 渲染 （_render_run_image/_show_image_frame/_depth_range）仍留在窗口——它们是面板与相机的 胶水，不属于任何一个已拆出的变更驱动；已知缺陷（本次未修，另行处理）：worker 的 on_reset_applied 从未接到 recording.note_reset，真机上按"清零"不会记录确认事件。 --- apps/studio/src/orisys_studio/app_window.py | 56 +++---------- .../src/orisys_studio/calibration_service.py | 64 +++++++++++++++ apps/studio/tests/test_calibration_service.py | 81 +++++++++++++++++++ 3 files changed, 155 insertions(+), 46 deletions(-) create mode 100644 apps/studio/tests/test_calibration_service.py diff --git a/apps/studio/src/orisys_studio/app_window.py b/apps/studio/src/orisys_studio/app_window.py index 161e70f..828b3fd 100644 --- a/apps/studio/src/orisys_studio/app_window.py +++ b/apps/studio/src/orisys_studio/app_window.py @@ -46,6 +46,7 @@ from orisys_app_shared.record.sample import to_record_sample from orisys_studio.recording import RecordingCoordinator, record_config_from_prefs from orisys_studio.replay import ReplayEngine from orisys_studio.replay_controller import ReplayController +from orisys_studio.calibration_service import CalibrationService from orisys_studio.display_prefs import DisplayPrefsController from orisys_studio.view_layout import ViewLayoutController from orisys_studio import session_metadata @@ -1509,57 +1510,20 @@ class StudioMainWindow(QMainWindow): self.recorder.log_event("calibration_exported", str(path)) self.statusBar().showMessage(t("cal.export_only", path=Path(path).name)) + # ------------------------------------------------- calibration (forwards) + # "What does this coefficient file claim, and does it match the bench?" lives in + # ``CalibrationService`` (with the rest of the calibration file work, and without + # Qt). The dialog and the worker hand-over stay here: they are interaction, not a + # rule about files. def calibration_identity(self, path: str) -> dict: - """What device a coefficient file says it belongs to. - - Read with the SDK's own parser so the check sees the same document the - device would load. A file that cannot be read yields no identity, and the - caller then applies it without a mismatch claim. - """ - try: - import orisys.calibration as sdk_calibration - - document = sdk_calibration.load(path, strict=True) - except Exception: # noqa: BLE001 - reported by the apply path itself - logger.exception("Could not read calibration identity from %s", path) - return {} - identity = dict(getattr(document, "identity", {}) or {}) - pipeline = dict(getattr(document, "pipeline", {}) or {}) - return { - "sensor_type": str(identity.get("sensor_type") or ""), - "sn": str(identity.get("sn") or ""), - "config_ref": str(pipeline.get("config_ref") or ""), - } - - @staticmethod - def _same_path(first: str, second: str) -> bool: - if not first or not second: - return True # nothing to compare: not a mismatch - if first == second: - return True - try: - return Path(first).resolve() == Path(second).resolve() - except Exception: # noqa: BLE001 - a non-path value simply differs - return False + return CalibrationService.identity_of(path) def calibration_target_mismatch( self, path: str, *, sensor_type: str, config_ref: str ) -> list[str]: - """Reasons this calibration does not obviously belong to this device. - - Applying coefficients that were measured on a different sensor silently - changes what every recorded newton value means, so the mismatch is stated - before the confirmation, not discovered later. - """ - recorded = self.calibration_identity(path) - reasons: list[str] = [] - recorded_type = recorded.get("sensor_type") or "" - if recorded_type and sensor_type and recorded_type != sensor_type: - reasons.append(f"sensor_type: {recorded_type} != {sensor_type}") - recorded_config = recorded.get("config_ref") or "" - if recorded_config and not self._same_path(recorded_config, config_ref): - reasons.append(f"config_ref: {recorded_config} != {config_ref}") - return reasons + return CalibrationService.target_mismatch( + path, sensor_type=sensor_type, config_ref=config_ref + ) def _on_calibration_apply(self, path: str) -> None: """Push freshly exported coefficients into the device — on confirmation. diff --git a/apps/studio/src/orisys_studio/calibration_service.py b/apps/studio/src/orisys_studio/calibration_service.py index 690f2ad..4d9fac7 100644 --- a/apps/studio/src/orisys_studio/calibration_service.py +++ b/apps/studio/src/orisys_studio/calibration_service.py @@ -128,3 +128,67 @@ class CalibrationService: sensor_type=str(sensor_type or "box"), local_bundle_dir=local_bundle_dir, ) + + # ------------------------------------------------- who a file belongs to + # The rules below take no state: they answer "what does this file claim, and does it + # match what is on the bench?" — which is the question the *apply* path has to settle + # before coefficients measured on another sensor silently change every newton value. + @staticmethod + def identity_of(path: str | Path) -> dict: + """What device a coefficient file says it belongs to. + + Read with the SDK's own parser so the check sees the same document the device + would load. A file that cannot be read yields no identity, and the caller then + applies it without a mismatch claim. + """ + try: + import orisys.calibration as sdk_calibration + + document = sdk_calibration.load(str(path), strict=True) + except Exception: # noqa: BLE001 - reported by the apply path itself + logger.exception("Could not read calibration identity from %s", path) + return {} + identity = dict(getattr(document, "identity", {}) or {}) + pipeline = dict(getattr(document, "pipeline", {}) or {}) + return { + "sensor_type": str(identity.get("sensor_type") or ""), + "sn": str(identity.get("sn") or ""), + "config_ref": str(pipeline.get("config_ref") or ""), + } + + @staticmethod + def same_path(first: str, second: str) -> bool: + """Whether two configuration references name the same file. + + Two empty values are "the same" on purpose: nothing to compare is not a + mismatch, and refusing to apply an unlabelled calibration would be inventing a + disagreement. + """ + if not first or not second: + return True + if first == second: + return True + try: + return Path(first).resolve() == Path(second).resolve() + except Exception: # noqa: BLE001 - a non-path value simply differs + return False + + @classmethod + def target_mismatch( + cls, path: str | Path, *, sensor_type: str, config_ref: str + ) -> list[str]: + """Reasons this calibration does not obviously belong to this device. + + Applying coefficients that were measured on a different sensor silently changes + what every recorded newton value means, so the mismatch is stated before the + confirmation, not discovered later. + """ + recorded = cls.identity_of(path) + reasons: list[str] = [] + recorded_type = recorded.get("sensor_type") or "" + if recorded_type and sensor_type and recorded_type != sensor_type: + reasons.append(f"sensor_type: {recorded_type} != {sensor_type}") + recorded_config = recorded.get("config_ref") or "" + if recorded_config and not cls.same_path(recorded_config, config_ref): + reasons.append(f"config_ref: {recorded_config} != {config_ref}") + return reasons diff --git a/apps/studio/tests/test_calibration_service.py b/apps/studio/tests/test_calibration_service.py new file mode 100644 index 0000000..54f7e69 --- /dev/null +++ b/apps/studio/tests/test_calibration_service.py @@ -0,0 +1,81 @@ +"""Acceptance for the calibration service's rules about *whose* a file is. + +The window used to own these: reading a coefficient file's claimed identity and deciding +whether it obviously belongs to the device on the bench. They are pure rules about files, +so they now live with the rest of the calibration file work — and can be tested without +building a window. The end-to-end apply path is still covered by ``test_ui_smoke``. +""" + +from __future__ import annotations + +import json +from pathlib import Path + +from orisys_app_shared.force.calibration_io import ( + CalSample, + CalSessionStore, + build_export_model, +) +from orisys_studio.calibration_service import CalibrationService + + +def _calibration_file(directory: Path, *, sensor_type: str, config_ref: str) -> Path: + """A coefficient document that names the device it was measured on.""" + store = CalSessionStore() + store.aggregate("fn", CalSample(weight_n=0.0, raw_mean=0.0, n=10)) + store.aggregate("fn", CalSample(weight_n=5.0, raw_mean=500.0, n=10)) + model = build_export_model({key: store.channel(key) for key in ("fn", "fx", "fy")}) + document = model.to_dict() + document["identity"] = {"sensor_type": sensor_type, "sn": "SN-A"} + document["pipeline"] = {"config_ref": config_ref} + path = directory / f"{sensor_type}_calibration.json" + path.write_text(json.dumps(document), encoding="utf-8") + return path + + +def test_the_identity_names_the_sensor_and_the_configuration(tmp_path): + path = _calibration_file(tmp_path, sensor_type="box", config_ref="D:/lab/a/sensor.json") + + identity = CalibrationService.identity_of(path) + assert identity["sensor_type"] == "box" + assert identity["sn"] == "SN-A" + assert identity["config_ref"] == "D:/lab/a/sensor.json" + + +def test_a_file_that_cannot_be_read_claims_nothing(tmp_path): + """No identity must mean "no mismatch claim", not "mismatch".""" + broken = tmp_path / "not-a-calibration.json" + broken.write_text("this is not a coefficient document\n", encoding="utf-8") + + assert CalibrationService.identity_of(broken) == {} + assert CalibrationService.target_mismatch( + broken, sensor_type="finger", config_ref="D:/lab/b/sensor.json" + ) == [] + + +def test_another_devices_calibration_is_reported_with_its_reasons(tmp_path): + path = _calibration_file(tmp_path, sensor_type="box", config_ref="D:/lab/a/sensor.json") + + reasons = CalibrationService.target_mismatch( + path, sensor_type="finger", config_ref="D:/lab/b/sensor.json" + ) + assert any("sensor_type" in reason for reason in reasons), reasons + assert any("config_ref" in reason for reason in reasons), reasons + + # The same device and configuration is not a mismatch. + assert ( + CalibrationService.target_mismatch( + path, sensor_type="box", config_ref="D:/lab/a/sensor.json" + ) + == [] + ) + + +def test_the_same_configuration_named_differently_is_not_a_mismatch(tmp_path): + """A path is compared as a path: the apply path must not cry wolf over spelling.""" + assert CalibrationService.same_path("", "D:/lab/a/sensor.json") is True + assert CalibrationService.same_path("D:/lab/a/sensor.json", "") is True + assert CalibrationService.same_path("D:/lab/a/sensor.json", "D:/lab/./a/sensor.json") + + # ...but it does have to be a path: a non-path value simply differs. + assert CalibrationService.same_path("D:/lab/a/sensor.json", "not a path\x00") is False