ykcheungab
585 lines
20 KiB
Python
585 lines
20 KiB
Python
"""Tests for orisys.calibration load/parse/write and Sensor apply."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import shutil
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from orisys import Sensor
|
|
from orisys.calibration import (
|
|
CalibrationError,
|
|
CalSample,
|
|
build,
|
|
check,
|
|
filter_mismatches,
|
|
filters_fingerprint,
|
|
load,
|
|
load_for_device,
|
|
parse,
|
|
pipeline_from_sensor_json,
|
|
write,
|
|
)
|
|
|
|
|
|
def _box_cal_path() -> Path:
|
|
# Editable checkout: repo_root/sensors/box/force_calibration.json
|
|
here = Path(__file__).resolve()
|
|
candidate = here.parents[1] / "sensors" / "box" / "force_calibration.json"
|
|
assert candidate.is_file(), f"missing shipped cal: {candidate}"
|
|
return candidate
|
|
|
|
|
|
def test_parse_box_v1_piecewise():
|
|
cal = load(sensor_type="box")
|
|
assert cal is not None
|
|
assert cal.get("FN") is not None
|
|
assert cal.get("FN").convert(10000.0) == pytest.approx(0.377)
|
|
assert cal.get("FX").convert_component(36000.0) == pytest.approx(1.19)
|
|
assert cal.get("FX").convert_component(-36000.0) == pytest.approx(-1.19)
|
|
assert cal.get("FY").convert_component(36000.0) == pytest.approx(1.19)
|
|
|
|
|
|
def test_parse_v2_tmp_file(tmp_path: Path):
|
|
doc = {
|
|
"schema_version": 2,
|
|
"unit": "N",
|
|
"channels": {
|
|
"normal": {
|
|
"method": "piecewise_linear",
|
|
"points": [[0.0, 0.0], [1000.0, 1.0]],
|
|
"extrapolate": True,
|
|
"clamp_output_min": 0.0,
|
|
},
|
|
"shear_x": {
|
|
"method": "piecewise_linear",
|
|
"signed": True,
|
|
"points": [[0.0, 0.0], [500.0, 2.0]],
|
|
"extrapolate": True,
|
|
"clamp_output_min": 0.0,
|
|
},
|
|
"shear_y": {
|
|
"method": "piecewise_linear",
|
|
"signed": True,
|
|
"points": [[0.0, 0.0], [500.0, 3.0]],
|
|
"extrapolate": True,
|
|
"clamp_output_min": 0.0,
|
|
},
|
|
},
|
|
"meta": {"sensor_type": "box", "sn": "TEST-001"},
|
|
}
|
|
path = tmp_path / "force_calibration_v2.json"
|
|
path.write_text(json.dumps(doc), encoding="utf-8")
|
|
cal = load(path)
|
|
assert cal is not None
|
|
assert check(cal).ok
|
|
assert cal.convert(1000.0, 500.0, -500.0) == pytest.approx((1.0, 2.0, -3.0))
|
|
|
|
|
|
def test_build_write_load_roundtrip(tmp_path: Path):
|
|
samples = {
|
|
"fn": [
|
|
CalSample(weight_n=0.0, raw_mean=0.0, n=10),
|
|
CalSample(weight_n=1.0, raw_mean=1000.0, n=10),
|
|
],
|
|
"fx": [
|
|
CalSample(weight_n=0.0, raw_mean=0.0, n=10),
|
|
CalSample(weight_n=2.0, raw_mean=500.0, n=10),
|
|
],
|
|
"fy": [
|
|
CalSample(weight_n=0.0, raw_mean=0.0, n=10),
|
|
CalSample(weight_n=3.0, raw_mean=500.0, n=10),
|
|
],
|
|
}
|
|
cal = build(
|
|
samples,
|
|
identity={"sensor_type": "box", "sn": "RT-1"},
|
|
pipeline={"dis_mode": 1},
|
|
origin="user",
|
|
)
|
|
path = tmp_path / "out.json"
|
|
write(cal, path, overwrite=True)
|
|
loaded = load(path)
|
|
assert loaded is not None
|
|
assert loaded.convert(1000.0, 500.0, -500.0) == pytest.approx((1.0, 2.0, -3.0))
|
|
|
|
|
|
def test_check_rejects_bad_schema_and_short_points():
|
|
bad_schema = {"schema_version": 99, "channels": {"normal": {"method": "linear", "slope": 1, "offset": 0}}}
|
|
result = check(bad_schema)
|
|
assert not result.ok
|
|
assert any("schema_version" in e for e in result.errors)
|
|
|
|
short = {
|
|
"schema_version": 2,
|
|
"channels": {
|
|
"normal": {
|
|
"method": "piecewise_linear",
|
|
"points": [[0.0, 0.0]],
|
|
}
|
|
},
|
|
}
|
|
result2 = check(short)
|
|
assert not result2.ok
|
|
|
|
|
|
def test_sensor_cal_path_v2_applies_to_read_info(tmp_path: Path):
|
|
doc = {
|
|
"schema_version": 2,
|
|
"unit": "N",
|
|
"channels": {
|
|
"normal": {
|
|
"method": "piecewise_linear",
|
|
"points": [[0.0, 0.0], [100.0, 5.0]],
|
|
"extrapolate": True,
|
|
"clamp_output_min": 0.0,
|
|
},
|
|
"shear_x": {
|
|
"method": "piecewise_linear",
|
|
"signed": True,
|
|
"points": [[0.0, 0.0], [100.0, 7.0]],
|
|
"extrapolate": True,
|
|
"clamp_output_min": 0.0,
|
|
},
|
|
"shear_y": {
|
|
"method": "piecewise_linear",
|
|
"signed": True,
|
|
"points": [[0.0, 0.0], [100.0, 9.0]],
|
|
"extrapolate": True,
|
|
"clamp_output_min": 0.0,
|
|
},
|
|
},
|
|
}
|
|
path = tmp_path / "v2.json"
|
|
path.write_text(json.dumps(doc), encoding="utf-8")
|
|
sensor = Sensor(
|
|
"external",
|
|
config_name="box",
|
|
cal_path=str(path),
|
|
verbose=False,
|
|
backend="cpu",
|
|
)
|
|
try:
|
|
assert sensor.force_calibrated
|
|
assert sensor.force_unit == "N"
|
|
sensor._force_raw = (100.0, 100.0, -100.0)
|
|
sensor._apply_force_filter()
|
|
fn, fx, fy = sensor.read_info(
|
|
sensor.info.FNORMAL,
|
|
sensor.info.FSHEARX,
|
|
sensor.info.FSHEARY,
|
|
)
|
|
fn_raw, fx_raw, fy_raw = sensor.read_info(
|
|
sensor.info.FNORMAL_RAW,
|
|
sensor.info.FSHEARX_RAW,
|
|
sensor.info.FSHEARY_RAW,
|
|
)
|
|
assert (fn_raw, fx_raw, fy_raw) == pytest.approx((100.0, 100.0, -100.0))
|
|
assert (fn, fx, fy) == pytest.approx((5.0, 7.0, -9.0))
|
|
finally:
|
|
sensor.disconnect()
|
|
|
|
|
|
def test_set_calibration_swaps_curve(tmp_path: Path):
|
|
path_a = tmp_path / "a.json"
|
|
path_b = tmp_path / "b.json"
|
|
path_a.write_text(
|
|
json.dumps(
|
|
{
|
|
"schema_version": 2,
|
|
"channels": {
|
|
"normal": {
|
|
"method": "piecewise_linear",
|
|
"points": [[0.0, 0.0], [10.0, 1.0]],
|
|
}
|
|
},
|
|
}
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
path_b.write_text(
|
|
json.dumps(
|
|
{
|
|
"schema_version": 2,
|
|
"channels": {
|
|
"normal": {
|
|
"method": "piecewise_linear",
|
|
"points": [[0.0, 0.0], [10.0, 2.0]],
|
|
}
|
|
},
|
|
}
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
sensor = Sensor(
|
|
"external",
|
|
config_name="box",
|
|
cal_path=str(path_a),
|
|
verbose=False,
|
|
backend="cpu",
|
|
)
|
|
try:
|
|
sensor._force_raw = (10.0, 0.0, 0.0)
|
|
sensor._apply_force_filter()
|
|
assert sensor.fnormal == pytest.approx(1.0)
|
|
sensor.set_calibration(path_b)
|
|
sensor._apply_force_filter()
|
|
assert sensor.fnormal == pytest.approx(2.0)
|
|
finally:
|
|
sensor.disconnect()
|
|
|
|
|
|
def test_missing_cal_path_raises():
|
|
with pytest.raises(CalibrationError):
|
|
Sensor(
|
|
"external",
|
|
config_name="box",
|
|
cal_path="D:/no/such/force_calibration.json",
|
|
verbose=False,
|
|
backend="cpu",
|
|
)
|
|
|
|
|
|
def _device_file(root: Path, device_id: str, *, family: str = "box") -> Path:
|
|
path = root / family / f"{device_id}.json"
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
doc = json.loads(_box_cal_path().read_text(encoding="utf-8"))
|
|
doc["identity"] = {"sensor_type": family, "sn": device_id}
|
|
path.write_text(json.dumps(doc), encoding="utf-8")
|
|
return path
|
|
|
|
|
|
def test_device_calibration_selection_and_missing_raw(tmp_path: Path):
|
|
root = tmp_path / "calibrations"
|
|
root.mkdir()
|
|
selected = _device_file(root, "BOX-001")
|
|
assert load_for_device(root, "box", "BOX-001").source_path == selected.resolve()
|
|
assert load_for_device(root, "box", "BOX-002") is None
|
|
|
|
sensor = Sensor(
|
|
"external", config_name="box", calibration_dir=root,
|
|
device_id="BOX-001", verbose=False, backend="cpu",
|
|
)
|
|
try:
|
|
assert sensor.force_unit == "N"
|
|
assert sensor.calibration.source_path == selected.resolve()
|
|
other = _device_file(root, "BOX-003")
|
|
with pytest.raises(CalibrationError, match="identity mismatch"):
|
|
sensor.set_calibration(other)
|
|
assert sensor.calibration.source_path == selected.resolve()
|
|
finally:
|
|
sensor.disconnect()
|
|
|
|
sensor = Sensor(
|
|
"external", config_name="box", calibration_dir=root,
|
|
device_id="BOX-002", verbose=False, backend="cpu",
|
|
)
|
|
try:
|
|
assert sensor.force_unit == "raw"
|
|
assert sensor.device_calibration_missing
|
|
assert sensor.calibration is None
|
|
finally:
|
|
sensor.disconnect()
|
|
|
|
|
|
def test_device_calibration_rejects_wrong_identity_and_pipeline(tmp_path: Path):
|
|
root = tmp_path / "calibrations"
|
|
root.mkdir()
|
|
path = _device_file(root, "BOX-001")
|
|
doc = json.loads(path.read_text(encoding="utf-8"))
|
|
doc["identity"]["sn"] = "BOX-002"
|
|
path.write_text(json.dumps(doc), encoding="utf-8")
|
|
with pytest.raises(CalibrationError, match="identity mismatch"):
|
|
load_for_device(root, "box", "BOX-001")
|
|
with pytest.raises(CalibrationError, match="identity mismatch"):
|
|
Sensor(
|
|
"external", config_name="box", cal_path=path,
|
|
device_id="BOX-001", verbose=False, backend="cpu",
|
|
)
|
|
|
|
doc["identity"]["sn"] = "BOX-001"
|
|
doc["pipeline"] = {"dis_mode": 999}
|
|
path.write_text(json.dumps(doc), encoding="utf-8")
|
|
with pytest.raises(CalibrationError, match="pipeline mismatch"):
|
|
load_for_device(root, "box", "BOX-001", pipeline={"dis_mode": 1})
|
|
|
|
|
|
def test_device_calibration_rejects_partial_axes_and_unsafe_id(tmp_path: Path):
|
|
root = tmp_path / "calibrations"
|
|
root.mkdir()
|
|
path = _device_file(root, "BOX-001")
|
|
doc = json.loads(path.read_text(encoding="utf-8"))
|
|
del doc["channels"]["shear_y"]
|
|
path.write_text(json.dumps(doc), encoding="utf-8")
|
|
with pytest.raises(CalibrationError, match="requires FN, FX and FY"):
|
|
load_for_device(root, "box", "BOX-001")
|
|
with pytest.raises(CalibrationError, match="invalid device_id"):
|
|
load_for_device(root, "box", "../BOX-001")
|
|
|
|
|
|
def test_parse_shipped_box_file_directly():
|
|
cal = parse(json.loads(_box_cal_path().read_text(encoding="utf-8")), source_path=_box_cal_path())
|
|
assert cal.schema_version == 2
|
|
assert cal.convert(10000.0, 36000.0, -36000.0) == pytest.approx((0.377, 1.19, -1.19))
|
|
# The shipped file names both shear axes outright: no shared block, no clone.
|
|
assert set(cal.channels) == {"fn", "fx", "fy"}
|
|
fx, fy = cal.get("FX"), cal.get("FY")
|
|
assert fx is not None and fy is not None and fx is not fy
|
|
for curve in (fx, fy):
|
|
assert curve.signed is True
|
|
assert curve.extrapolate is True
|
|
assert curve.clamp_output_min == pytest.approx(0.0)
|
|
assert len(curve.points) == 3
|
|
assert fx.raw_key == "fshearx"
|
|
assert fy.raw_key == "fsheary"
|
|
|
|
|
|
def test_the_shipped_box_shear_axes_can_drift_apart(tmp_path: Path):
|
|
"""The whole point of the split: FX and FY are independent curves.
|
|
|
|
A document with the same shape as the shipped one but different per-axis
|
|
points must apply each axis's own curve. Re-collapsing the axes into one
|
|
shared ``shear`` block makes this fail.
|
|
"""
|
|
doc = {
|
|
"schema_version": 2,
|
|
"unit": "N",
|
|
"channels": {
|
|
"normal": {
|
|
"method": "piecewise_linear",
|
|
"points": [[0.0, 0.0], [1000.0, 1.0]],
|
|
},
|
|
"shear_x": {
|
|
"method": "piecewise_linear",
|
|
"signed": True,
|
|
"input": "components",
|
|
"extrapolate": True,
|
|
"clamp_output_min": 0.0,
|
|
"points": [[0.0, 0.0], [500.0, 2.0]],
|
|
},
|
|
"shear_y": {
|
|
"method": "piecewise_linear",
|
|
"signed": True,
|
|
"input": "components",
|
|
"extrapolate": True,
|
|
"clamp_output_min": 0.0,
|
|
"points": [[0.0, 0.0], [500.0, 3.0]],
|
|
},
|
|
},
|
|
}
|
|
path = tmp_path / "split.json"
|
|
path.write_text(json.dumps(doc), encoding="utf-8")
|
|
cal = load(path)
|
|
assert cal is not None
|
|
assert cal.convert(0.0, 500.0, 500.0)[1:] == pytest.approx((2.0, 3.0))
|
|
assert cal.convert(0.0, -500.0, 500.0)[1:] == pytest.approx((-2.0, 3.0))
|
|
|
|
|
|
def test_out_of_range_readings_extend_instead_of_being_dropped():
|
|
"""Outside the calibrated range the nearest segment is extended.
|
|
|
|
This pins the "extend, never ignore, never reuse a previous coefficient"
|
|
behaviour of the shipped box file, so flipping ``extrapolate`` has to be a
|
|
deliberate edit that fails this test first.
|
|
"""
|
|
cal = load(sensor_type="box")
|
|
assert cal is not None
|
|
fx, fy, fn = cal.get("FX"), cal.get("FY"), cal.get("FN")
|
|
assert fx is not None and fy is not None and fn is not None
|
|
# 136000 = 2 x the top raw break (68000 -> 2.06): the last segment's slope is
|
|
# applied again, so the value keeps growing past the calibrated range.
|
|
(r0, n0), (r1, n1) = fx.points[-2], fx.points[-1]
|
|
extended = n1 + (n1 - n0) / (r1 - r0) * (136000.0 - r1)
|
|
assert extended > n1
|
|
assert fx.convert_component(136000.0) == pytest.approx(extended)
|
|
assert fy.convert_component(136000.0) == pytest.approx(extended)
|
|
# A negative beyond the range keeps its sign.
|
|
assert fx.convert_component(-136000.0) == pytest.approx(-extended)
|
|
# Below the first point the normal channel floors at clamp_output_min.
|
|
assert fn.convert(500.0) == pytest.approx(0.0)
|
|
|
|
|
|
# ------------------------------------------------------- filter fingerprint
|
|
ALL_OFF_FILTERS = {
|
|
"flow_ema_alpha": 1.0,
|
|
"force_median_window": 1,
|
|
"force_lowpass_cutoff_hz": 0.0,
|
|
"force_lowpass_order": 2,
|
|
"force_lowpass_sample_rate_hz": "auto",
|
|
}
|
|
|
|
|
|
def _sensor_with_filters(tmp_path: Path, filters: dict) -> Sensor:
|
|
"""An external-frame Sensor whose bundle carries ``filters``."""
|
|
bundle = _box_cal_path().parent
|
|
copy = tmp_path / "box"
|
|
shutil.copytree(bundle, copy)
|
|
path = copy / "sensor.json"
|
|
cfg = json.loads(path.read_text(encoding="utf-8"))
|
|
cfg["filters"] = filters
|
|
path.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
|
|
return Sensor(
|
|
"external",
|
|
config_name=str(path),
|
|
cal_path=str(copy / "force_calibration.json"),
|
|
verbose=False,
|
|
backend="cpu",
|
|
)
|
|
|
|
|
|
def test_the_fingerprint_keeps_measurement_and_readout_apart():
|
|
"""A change to one group must not be confused with a change to the other."""
|
|
fp = filters_fingerprint(ALL_OFF_FILTERS)
|
|
assert fp["measurement"] == {"flow_ema_alpha": 1.0}
|
|
assert fp["readout"] == {
|
|
"force_median_window": 1,
|
|
"force_lowpass_cutoff_hz": 0.0,
|
|
"force_lowpass_order": 2,
|
|
"force_lowpass_rate_auto": True,
|
|
}
|
|
|
|
|
|
def test_a_preset_expands_without_inventing_anything():
|
|
fp = filters_fingerprint({"preset": "low_noise"})
|
|
assert fp["preset"] == "low_noise"
|
|
assert fp["measurement"] == {"flow_ema_alpha": 0.3}
|
|
assert fp["readout"] == {"force_median_window": 3, "force_lowpass_cutoff_hz": 10.0}
|
|
# An explicit key wins over the preset.
|
|
explicit = filters_fingerprint({"preset": "low_noise", "force_lowpass_cutoff_hz": 0.0})
|
|
assert explicit["readout"]["force_lowpass_cutoff_hz"] == 0.0
|
|
# Keys no source states are absent, never filled in from a default.
|
|
assert filters_fingerprint({}) == {}
|
|
assert filters_fingerprint(None) == {}
|
|
assert filters_fingerprint({"flow_ema_alpha": "not-a-number"}) == {}
|
|
|
|
|
|
def test_the_deprecated_master_switch_still_means_all_off():
|
|
fp = filters_fingerprint(dict(ALL_OFF_FILTERS, enabled=False, flow_ema_alpha=0.3))
|
|
assert fp["measurement"] == {"flow_ema_alpha": 1.0}
|
|
assert fp["readout"]["force_median_window"] == 1
|
|
assert fp["readout"]["force_lowpass_cutoff_hz"] == 0.0
|
|
|
|
|
|
def test_a_measurement_change_warns_and_a_readout_change_only_notes():
|
|
recorded = filters_fingerprint({"preset": "balanced"})
|
|
expected = filters_fingerprint({"preset": "low_noise"})
|
|
warns, notes = filter_mismatches(recorded, expected)
|
|
assert any("not comparable" in w and "flow_ema_alpha" in w for w in warns)
|
|
assert not any("flow_ema_alpha" in n for n in notes)
|
|
assert any("force_lowpass_cutoff_hz" in n for n in notes)
|
|
assert filter_mismatches(recorded, recorded) == ([], [])
|
|
|
|
|
|
def test_check_reports_the_two_groups_apart():
|
|
samples = {
|
|
key: [
|
|
CalSample(weight_n=0.0, raw_mean=0.0, n=10),
|
|
CalSample(weight_n=1.0, raw_mean=1000.0, n=10),
|
|
]
|
|
for key in ("fn", "fx", "fy")
|
|
}
|
|
doc = build(
|
|
samples,
|
|
identity={"sensor_type": "box", "sn": "FP-1"},
|
|
pipeline={"filters": filters_fingerprint({"preset": "balanced"})},
|
|
)
|
|
result = check(doc, pipeline={"filters": filters_fingerprint({"preset": "low_noise"})})
|
|
assert result.ok, "a filter difference must not refuse a calibration"
|
|
assert any("not comparable" in w for w in result.warnings)
|
|
assert any("readout" in n for n in result.notes)
|
|
assert not any("readout" in w for w in result.warnings)
|
|
|
|
|
|
def test_the_fingerprint_survives_a_write_and_read(tmp_path: Path):
|
|
samples = {
|
|
key: [
|
|
CalSample(weight_n=0.0, raw_mean=0.0, n=10),
|
|
CalSample(weight_n=1.0, raw_mean=1000.0, n=10),
|
|
]
|
|
for key in ("fn", "fx", "fy")
|
|
}
|
|
doc = build(
|
|
samples,
|
|
identity={"sensor_type": "box", "sn": "FP-2"},
|
|
pipeline={"filters": filters_fingerprint({"preset": "balanced"})},
|
|
)
|
|
path = tmp_path / "fp.json"
|
|
write(doc, path, overwrite=True)
|
|
raw = json.loads(path.read_text(encoding="utf-8"))
|
|
assert raw["meta"]["filters"]["measurement"] == {"flow_ema_alpha": 0.5}
|
|
# The flat keys stay for readers that look them up by name.
|
|
assert raw["meta"]["flow_ema_alpha"] == 0.5
|
|
|
|
loaded = load(path)
|
|
assert loaded.pipeline["filters"]["measurement"] == {"flow_ema_alpha": 0.5}
|
|
assert loaded.pipeline["filters"]["readout"]["force_median_window"] == 3
|
|
assert loaded.pipeline["filters"]["preset"] == "balanced"
|
|
assert loaded.to_dict()["meta"]["filters"] == doc.to_dict()["meta"]["filters"]
|
|
|
|
|
|
def test_a_legacy_flat_fingerprint_is_still_read_back(tmp_path: Path):
|
|
"""Documents written before the groups existed keep being comparable."""
|
|
samples = {
|
|
key: [
|
|
CalSample(weight_n=0.0, raw_mean=0.0, n=10),
|
|
CalSample(weight_n=1.0, raw_mean=1000.0, n=10),
|
|
]
|
|
for key in ("fn", "fx", "fy")
|
|
}
|
|
doc = build(samples, identity={"sensor_type": "box", "sn": "FP-3"})
|
|
legacy = json.loads(json.dumps(doc.to_dict()))
|
|
legacy["meta"].pop("filters", None)
|
|
legacy["meta"].update(
|
|
{"flow_ema_alpha": 0.3, "force_median_window": 3, "force_lowpass_cutoff_hz": 10.0}
|
|
)
|
|
path = tmp_path / "legacy.json"
|
|
path.write_text(json.dumps(legacy), encoding="utf-8")
|
|
loaded = load(path)
|
|
assert loaded.pipeline["filters"]["measurement"] == {"flow_ema_alpha": 0.3}
|
|
assert loaded.pipeline["filters"]["readout"]["force_median_window"] == 3
|
|
assert loaded.pipeline["filters"]["readout"]["force_lowpass_cutoff_hz"] == 10.0
|
|
|
|
|
|
def test_the_effective_state_beats_the_config_file(tmp_path: Path):
|
|
"""A file states an intent; the device states what it is doing."""
|
|
bundle_json = _box_cal_path().parent / "sensor.json"
|
|
from_file = pipeline_from_sensor_json(bundle_json)
|
|
assert from_file["filters"]["measurement"] == {"flow_ema_alpha": 1.0}
|
|
assert "flow_ema_alpha" not in from_file, "loose top-level filter keys are gone"
|
|
|
|
sensor = _sensor_with_filters(tmp_path, {"preset": "balanced"})
|
|
try:
|
|
from_state = pipeline_from_sensor_json(
|
|
bundle_json, filters_state=sensor.filters_state()
|
|
)
|
|
finally:
|
|
sensor.disconnect()
|
|
assert from_state["filters"]["measurement"] == {"flow_ema_alpha": 0.5}
|
|
assert from_state["filters"]["readout"]["force_median_window"] == 3
|
|
assert from_state["filters"]["source"] == "sensor.filters_state"
|
|
assert from_state["config_ref"] == str(bundle_json)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"preset, alpha, median, cutoff",
|
|
[
|
|
("off", 1.0, 1, 0.0),
|
|
("low_latency", 1.0, 3, 0.0),
|
|
("balanced", 0.5, 3, 0.0),
|
|
("low_noise", 0.3, 3, 10.0),
|
|
],
|
|
)
|
|
def test_every_preset_reports_what_it_does(
|
|
tmp_path: Path, preset: str, alpha: float, median: int, cutoff: float
|
|
):
|
|
sensor = _sensor_with_filters(tmp_path, {"preset": preset})
|
|
try:
|
|
fp = filters_fingerprint(sensor.filters_state())
|
|
finally:
|
|
sensor.disconnect()
|
|
assert fp["measurement"]["flow_ema_alpha"] == pytest.approx(alpha)
|
|
assert fp["readout"]["force_median_window"] == median
|
|
assert fp["readout"]["force_lowpass_cutoff_hz"] == pytest.approx(cutoff)
|