oopsie-data-tools 0.2.0__py3-none-any.whl

oopsie_data_tools/test/test_migrate_taxonomy_v2.py

@@ -0,0 +1,255 @@
+"""The v1 -> v2 migration, and the read-time upcast it has to agree with.
+
+Two paths turn a v1 file into v2 data: reading it (which upcasts in memory and leaves the
+file alone) and migrating it (which rewrites the attrs). If they ever disagreed, the same
+episode would mean different things depending on whether anyone had run the migration —
+so the central test here is that the two produce identical results.
+"""
+
+from __future__ import annotations
+
+import json
+
+import h5py
+import pytest
+
+from oopsie_data_tools.annotation_tool.annotation_schema import (
+    ANNOTATION_SCHEMA_V2,
+    SIDE_EFFECT_CATEGORIES,
+    TAXONOMY_SCHEMA_V2,
+    V1_CATEGORY_TO_SLUG,
+    read_annotation_attrs,
+)
+from oopsie_data_tools.test.fixtures.make_valid import write_valid_episode
+from oopsie_data_tools.utils.migrate_taxonomy_v2 import (
+    migrate_annotation_attrs,
+    migrate_h5_file,
+    migrate_tree,
+)
+from oopsie_data_tools.utils.validation.validation_utils import validate_h5_file
+
+
+def _v1_attrs(
+    *,
+    success: float = 0.0,
+    failure_description: str = "",
+    failure_category=(),
+    severity: str = "",
+    success_category: str = "",
+) -> dict:
+    taxonomy: dict = {
+        "failure_category": list(failure_category),
+        "severity": severity,
+    }
+    if success_category:
+        taxonomy["success_category"] = success_category
+    return {
+        "schema": "oopsie_failure_taxonomy_v1",
+        "source": "human",
+        "timestamp": "2026-04-21T10:00:00+00:00",
+        "success": success,
+        "failure_description": failure_description,
+        "taxonomy_schema": "oopsiedata_taxonomy_schema_v1",
+        "taxonomy": json.dumps(taxonomy),
+        "additional_notes": "",
+    }
+
+
+def _outcome_of(attrs: dict) -> str:
+    return json.loads(attrs["taxonomy"])["outcome"]
+
+
+# ── The outcome mapping ───────────────────────────────────────────────────────
+
+
+@pytest.mark.parametrize(
+    "success,success_category,expected",
+    [
+        (1.0, "", "success"),
+        (1.0, "Clean success", "success"),
+        (1.0, "Suboptimal execution", "success_suboptimal"),
+        (1.0, "Success with side-effects", "success_side_effect"),
+        (0.0, "", "failure"),
+        # A qualified-success label on a failure is nonsense; the float wins.
+        (0.0, "Clean success", "failure"),
+    ],
+)
+def test_outcome_is_derived_from_success_and_category(success, success_category, expected):
+    out = migrate_annotation_attrs(
+        _v1_attrs(success=success, success_category=success_category)
+    )
+    assert _outcome_of(out) == expected
+
+
+@pytest.mark.parametrize("prose,slug", sorted(V1_CATEGORY_TO_SLUG.items()))
+def test_every_v1_category_maps_to_a_known_slug(prose, slug):
+    """Parametrized over the whole table, so a new category cannot be added untested."""
+    out = migrate_annotation_attrs(_v1_attrs(failure_category=[prose]))
+
+    assert json.loads(out["taxonomy"])["side_effect_category"] == [slug]
+    assert slug in SIDE_EFFECT_CATEGORIES
+
+
+@pytest.mark.parametrize(
+    "prose,slug",
+    [
+        ("Low severity - no damage, can be reset and reattempted", "low"),
+        (
+            "Medium severity - some damage or risk of damage or significant reset "
+            "required, but can be reattempted",
+            "medium",
+        ),
+        (
+            "Catastrophic - significant damage or risk of damage, cannot be "
+            "reattempted without repair",
+            "catastrophic",
+        ),
+        ("", ""),
+    ],
+)
+def test_severity_prose_maps_to_a_slug(prose, slug):
+    out = migrate_annotation_attrs(_v1_attrs(severity=prose))
+    assert json.loads(out["taxonomy"])["severity"] == slug
+
+
+def test_description_is_renamed_and_the_old_key_removed():
+    out = migrate_annotation_attrs(_v1_attrs(failure_description="dropped it"))
+
+    assert out["episode_description"] == "dropped it"
+    # Leaving both would force every reader to decide which one wins.
+    assert "failure_description" not in out
+
+
+def test_schema_strings_are_bumped():
+    out = migrate_annotation_attrs(_v1_attrs())
+
+    assert out["schema"] == ANNOTATION_SCHEMA_V2
+    assert out["taxonomy_schema"] == TAXONOMY_SCHEMA_V2
+
+
+def test_unmapped_values_are_preserved_verbatim():
+    """Stale labels stay visible rather than being guessed into ``other``."""
+    out = migrate_annotation_attrs(
+        _v1_attrs(failure_category=["grasp_failure", "transport_failure"], severity="major")
+    )
+    taxonomy = json.loads(out["taxonomy"])
+
+    assert taxonomy["side_effect_category"] == ["grasp_failure", "transport_failure"]
+    assert taxonomy["severity"] == "major"
+
+
+# ── Nothing-to-do cases ───────────────────────────────────────────────────────
+
+
+def test_an_already_v2_annotation_is_left_alone():
+    v2 = migrate_annotation_attrs(_v1_attrs(success=1.0))
+    assert migrate_annotation_attrs(v2) is None
+
+
+def test_a_subgroup_that_is_not_an_annotation_is_skipped():
+    """No success and no taxonomy: inventing one would make an invalid file pass."""
+    assert migrate_annotation_attrs({"source": "human"}) is None
+
+
+# ── Whole files ───────────────────────────────────────────────────────────────
+
+
+def test_migration_and_read_time_upcast_agree(tmp_path):
+    """The load-bearing test: migrating must not change what the file already means."""
+    h5_path = write_valid_episode(tmp_path, stem="ep")
+    with h5py.File(h5_path, "r+") as f:
+        g = f["episode_annotations"]["test_annotator"]
+        for key in list(g.attrs):
+            del g.attrs[key]
+        for key, value in _v1_attrs(
+            success=0.0,
+            failure_description="Gripper closed early.",
+            failure_category=["Grasp failure (at contact)", "Collision failure"],
+            severity="Low severity - no damage, can be reset and reattempted",
+        ).items():
+            g.attrs[key] = value
+
+    with h5py.File(h5_path, "r") as f:
+        before = read_annotation_attrs(f["episode_annotations"]["test_annotator"].attrs)
+
+    migrate_h5_file(h5_path, apply=True)
+
+    with h5py.File(h5_path, "r") as f:
+        after = read_annotation_attrs(f["episode_annotations"]["test_annotator"].attrs)
+
+    assert before == after
+    assert after["outcome"] == "failure"
+    assert after["side_effect_category"] == ["grasp", "collision"]
+    assert after["severity"] == "low"
+
+
+def test_a_dry_run_writes_nothing(tmp_path):
+    h5_path = write_valid_episode(tmp_path, stem="ep")
+    with h5py.File(h5_path, "r+") as f:
+        g = f["episode_annotations"]["test_annotator"]
+        for key in list(g.attrs):
+            del g.attrs[key]
+        for key, value in _v1_attrs(success=1.0).items():
+            g.attrs[key] = value
+    before = h5_path.read_bytes()
+
+    report = migrate_h5_file(h5_path, apply=False)
+
+    assert report["migrated"] == ["test_annotator"]
+    assert h5_path.read_bytes() == before
+
+
+def test_migration_is_idempotent(tmp_path):
+    h5_path = write_valid_episode(tmp_path, stem="ep")
+    with h5py.File(h5_path, "r+") as f:
+        g = f["episode_annotations"]["test_annotator"]
+        for key in list(g.attrs):
+            del g.attrs[key]
+        for key, value in _v1_attrs(success=1.0).items():
+            g.attrs[key] = value
+
+    first = migrate_h5_file(h5_path, apply=True)
+    after_first = h5_path.read_bytes()
+    second = migrate_h5_file(h5_path, apply=True)
+
+    assert first["migrated"] == ["test_annotator"]
+    assert second["migrated"] == []
+    assert second["skipped"]["test_annotator"] == "already v2"
+    assert h5_path.read_bytes() == after_first
+
+
+def test_a_v2_file_is_untouched(tmp_path):
+    """write_valid_episode already writes v2, so there is nothing to do."""
+    h5_path = write_valid_episode(tmp_path, stem="ep")
+    before = h5_path.read_bytes()
+
+    report = migrate_h5_file(h5_path, apply=True)
+
+    assert report["migrated"] == []
+    assert h5_path.read_bytes() == before
+
+
+def test_a_migrated_file_still_validates(tmp_path):
+    h5_path = write_valid_episode(tmp_path, stem="ep")
+    with h5py.File(h5_path, "r+") as f:
+        g = f["episode_annotations"]["test_annotator"]
+        for key in list(g.attrs):
+            del g.attrs[key]
+        for key, value in _v1_attrs(
+            success=0.0, failure_description="dropped it", severity="major"
+        ).items():
+            g.attrs[key] = value
+
+    migrate_h5_file(h5_path, apply=True)
+
+    assert validate_h5_file(str(h5_path), strict_annotation_check=True) is True
+
+
+def test_migrate_tree_reports_one_entry_per_file(tmp_path):
+    write_valid_episode(tmp_path, stem="a")
+    write_valid_episode(tmp_path, stem="b")
+
+    reports = migrate_tree(tmp_path, apply=False)
+
+    assert len(reports) == 2
+    assert all(r["error"] is None for r in reports)

oopsie_data_tools/test/test_new_profile.py

@@ -0,0 +1,84 @@
+"""Tests for ``oopsie-data new-profile``.
+
+The command replaces the old "copy configs/robot_profiles/template.yaml" instruction,
+which only worked from a source checkout. Nothing is read out of the installed package,
+so the template text lives in Python.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from oopsie_data_tools import cli
+from oopsie_data_tools.utils import paths
+from oopsie_data_tools.utils.robot_profile.robot_profile import load_robot_profile
+from oopsie_data_tools.utils.robot_profile.template import PROFILE_TEMPLATE
+
+
+@pytest.fixture
+def project(tmp_path, monkeypatch):
+    """A project directory with no profiles, as the working directory."""
+    monkeypatch.delenv(paths.ENV_PROFILES_DIR, raising=False)
+    monkeypatch.chdir(tmp_path)
+    return tmp_path
+
+
+def test_checked_in_template_matches_the_python_source():
+    """configs/robot_profiles/template.yaml is a copy for browsing; it must not drift."""
+    repo_config = paths.repo_config_dir()
+    assert repo_config is not None, "this test runs from a checkout"
+    checked_in = repo_config / paths.PROFILES_DIR_NAME / "template.yaml"
+
+    assert checked_in.read_text(encoding="utf-8") == PROFILE_TEMPLATE, (
+        "configs/robot_profiles/template.yaml has drifted from "
+        "oopsie_data_tools/utils/robot_profile/template.py, which is the source of truth. "
+        "Regenerate the checked-in copy from PROFILE_TEMPLATE."
+    )
+
+
+def test_writes_into_project_local_robot_profiles(project):
+    assert cli.main(["new-profile"]) == 0
+
+    written = project / paths.PROFILES_DIR_NAME / "robot_profile.yaml"
+    assert written.is_file()
+    assert written.read_text(encoding="utf-8") == PROFILE_TEMPLATE
+
+
+def test_honours_name_and_dir(project):
+    assert cli.main(["new-profile", "--name", "yam_pro", "--dir", str(project / "cfg")]) == 0
+
+    assert (project / "cfg" / "yam_pro.yaml").is_file()
+    assert not (project / paths.PROFILES_DIR_NAME).exists()
+
+
+def test_refuses_to_clobber_without_force(project, caplog):
+    assert cli.main(["new-profile"]) == 0
+    written = project / paths.PROFILES_DIR_NAME / "robot_profile.yaml"
+    written.write_text("policy_name: mine\n", encoding="utf-8")
+
+    assert cli.main(["new-profile"]) == 1
+    assert written.read_text(encoding="utf-8") == "policy_name: mine\n", "must not overwrite"
+    assert "already exists" in caplog.text
+
+    assert cli.main(["new-profile", "--force"]) == 0
+    assert written.read_text(encoding="utf-8") == PROFILE_TEMPLATE
+
+
+def test_emitted_profile_does_not_load_until_filled_in(project):
+    """The skeleton must fail loudly rather than record placeholder metadata."""
+    assert cli.main(["new-profile"]) == 0
+    written = project / paths.PROFILES_DIR_NAME / "robot_profile.yaml"
+
+    # Which check fires first is an ordering detail of robot_profile_from_raw; all that
+    # matters here is that a blank skeleton is rejected rather than silently loaded.
+    with pytest.raises(ValueError, match="Invalid action_space|robot state keys|missing keys"):
+        load_robot_profile(written)
+
+
+def test_written_profile_is_not_picked_up_from_site_packages(project):
+    """The profile lookup must resolve to the project, never to the installed package."""
+    assert cli.main(["new-profile"]) == 0
+
+    resolved = paths.robot_profiles_dir()
+    assert resolved == project / paths.PROFILES_DIR_NAME
+    assert "site-packages" not in str(resolved)

oopsie_data_tools/test/test_paths.py

@@ -0,0 +1,137 @@
+"""Tests for config path resolution (``oopsie_data_tools/utils/paths.py``).
+
+Credentials and robot profiles are resolved through separate chains: credentials are
+per-user, profiles live next to the robot code and never in the user config directory.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from oopsie_data_tools.utils import paths
+
+
+@pytest.fixture
+def isolated_home(tmp_path, monkeypatch):
+    """Point the user config dir at a scratch directory and clear both env overrides."""
+    monkeypatch.delenv(paths.ENV_CONFIG_DIR, raising=False)
+    monkeypatch.delenv(paths.ENV_PROFILES_DIR, raising=False)
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg"))
+    return tmp_path / "xdg" / "oopsie-data"
+
+
+# ── credentials ───────────────────────────────────────────────────────────────
+
+
+def test_user_config_dir_follows_xdg(isolated_home):
+    assert paths.user_config_dir() == isolated_home
+
+
+# The repo-fallback leg of the credential chain is deliberately not tested here: it only
+# triggers when configs/contributor_config.yaml exists, and that file is gitignored (it holds
+# a token), so any such test passes or fails according to whether the developer happens to
+# have created one. What the chain does with a config that *is* present is covered below.
+
+
+def test_user_dir_wins_over_repo_for_credentials(isolated_home):
+    isolated_home.mkdir(parents=True)
+    (isolated_home / "contributor_config.yaml").write_text("lab_id: UserLab\n")
+
+    assert paths.contributor_config_path() == isolated_home / "contributor_config.yaml"
+    assert paths.config_dir_source() == "user config dir"
+
+
+def test_env_var_wins_when_it_holds_the_config(isolated_home, tmp_path, monkeypatch):
+    env_dir = tmp_path / "explicit"
+    env_dir.mkdir()
+    (env_dir / "contributor_config.yaml").write_text("lab_id: EnvLab\n")
+    isolated_home.mkdir(parents=True)
+    (isolated_home / "contributor_config.yaml").write_text("lab_id: UserLab\n")
+    monkeypatch.setenv(paths.ENV_CONFIG_DIR, str(env_dir))
+
+    assert paths.contributor_config_path() == env_dir / "contributor_config.yaml"
+    assert paths.write_config_dir() == env_dir
+    assert paths.config_dir_source() == f"${paths.ENV_CONFIG_DIR}"
+
+
+def test_env_var_is_the_write_target_but_reads_still_fall_back(
+    isolated_home, tmp_path, monkeypatch
+):
+    """An override that does not hold a config yet still reads the one that exists."""
+    env_dir = tmp_path / "explicit"
+    env_dir.mkdir()
+    isolated_home.mkdir(parents=True)
+    (isolated_home / "contributor_config.yaml").write_text("lab_id: UserLab\n")
+    monkeypatch.setenv(paths.ENV_CONFIG_DIR, str(env_dir))
+
+    assert paths.write_config_dir() == env_dir
+    assert paths.contributor_config_path() == isolated_home / "contributor_config.yaml"
+
+
+def test_write_config_dir_defaults_to_user_dir(isolated_home):
+    assert paths.write_config_dir() == isolated_home
+
+
+# ── robot profiles ────────────────────────────────────────────────────────────
+
+
+def test_profiles_never_resolve_to_the_user_config_dir(isolated_home, tmp_path, monkeypatch):
+    """Credentials live in ~/.config; profiles must not be expected there."""
+    profiles_in_user_dir = isolated_home / paths.PROFILES_DIR_NAME
+    profiles_in_user_dir.mkdir(parents=True)
+    monkeypatch.chdir(tmp_path)
+
+    assert paths.robot_profiles_dir() != profiles_in_user_dir
+    assert profiles_in_user_dir not in paths.profiles_search_dirs()
+
+
+def test_project_local_profiles_win(isolated_home, tmp_path, monkeypatch):
+    project = tmp_path / "my_robot_code"
+    (project / paths.PROFILES_DIR_NAME).mkdir(parents=True)
+    monkeypatch.chdir(project)
+
+    assert paths.robot_profiles_dir() == project / paths.PROFILES_DIR_NAME
+
+
+def test_project_configs_subdir_is_also_searched(isolated_home, tmp_path, monkeypatch):
+    project = tmp_path / "my_robot_code"
+    (project / "configs" / paths.PROFILES_DIR_NAME).mkdir(parents=True)
+    monkeypatch.chdir(project)
+
+    assert paths.robot_profiles_dir() == project / "configs" / paths.PROFILES_DIR_NAME
+
+
+def test_profiles_fall_back_to_the_checkout(isolated_home, tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)  # nothing project-local here
+
+    assert paths.robot_profiles_dir() == paths.repo_config_dir() / paths.PROFILES_DIR_NAME
+
+
+def test_profiles_env_override_wins(isolated_home, tmp_path, monkeypatch):
+    override = tmp_path / "shared_profiles"
+    override.mkdir()
+    project = tmp_path / "my_robot_code"
+    (project / paths.PROFILES_DIR_NAME).mkdir(parents=True)
+    monkeypatch.chdir(project)
+    monkeypatch.setenv(paths.ENV_PROFILES_DIR, str(override))
+
+    assert paths.robot_profiles_dir() == override
+    assert paths.write_profiles_dir() == override
+
+
+def test_write_profiles_dir_is_project_local_by_default(isolated_home, tmp_path, monkeypatch):
+    project = tmp_path / "my_robot_code"
+    project.mkdir()
+    monkeypatch.chdir(project)
+
+    assert paths.write_profiles_dir() == project / paths.PROFILES_DIR_NAME
+
+
+def test_config_dir_override_does_not_move_profiles(isolated_home, tmp_path, monkeypatch):
+    """$OOPSIE_CONFIG_DIR is about credentials only."""
+    env_dir = tmp_path / "explicit"
+    (env_dir / paths.PROFILES_DIR_NAME).mkdir(parents=True)
+    monkeypatch.setenv(paths.ENV_CONFIG_DIR, str(env_dir))
+    monkeypatch.chdir(tmp_path)
+
+    assert paths.robot_profiles_dir() == paths.repo_config_dir() / paths.PROFILES_DIR_NAME

oopsie_data_tools/test/test_python38_compat.py

@@ -0,0 +1,79 @@
+"""Guard the Python 3.8 floor against runtime-only annotation breakage.
+
+Ruff's ``target-version`` only tunes autofixes; it does not reject newer syntax, and it
+cannot see runtime-only breakage at all. tyro (used by the ``examples/``) resolves dataclass
+field annotations at runtime via ``typing.get_type_hints``, which raises ``TypeError`` on 3.8
+for a PEP 604 union (``str | None``) *even under* ``from __future__ import annotations``.
+
+The check is static rather than an import test because the examples import ``droid`` and
+``openpi_client``, neither of which is on PyPI, so CI cannot import them.
+"""
+
+import ast
+from pathlib import Path
+
+import pytest
+
+_REPO_ROOT = Path(__file__).resolve().parents[2]
+_PACKAGE_DIR = _REPO_ROOT / "oopsie_data_tools"
+_EXAMPLES_DIR = _REPO_ROOT / "examples"
+
+
+def _decorator_name(node):
+    """Last dotted component of a decorator, without ast.unparse (absent on 3.8)."""
+    while isinstance(node, ast.Call):
+        node = node.func
+    while isinstance(node, ast.Attribute):
+        node = node.attr if isinstance(node.attr, str) else node.value
+        return node if isinstance(node, str) else ""
+    return node.id if isinstance(node, ast.Name) else ""
+
+
+def _scan(root: Path):
+    """Return ``(offenders, dataclasses_inspected)`` for every .py file under *root*."""
+    offenders = []
+    inspected = 0
+    for path in sorted(root.rglob("*.py")):
+        if "__pycache__" in path.parts:
+            continue
+        tree = ast.parse(path.read_text(encoding="utf-8"))
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.ClassDef):
+                continue
+            if not any("dataclass" in _decorator_name(d) for d in node.decorator_list):
+                continue
+            inspected += 1
+            for stmt in node.body:
+                if not isinstance(stmt, ast.AnnAssign):
+                    continue
+                if isinstance(stmt.annotation, ast.BinOp) and isinstance(
+                    stmt.annotation.op, ast.BitOr
+                ):
+                    field = stmt.target.id if isinstance(stmt.target, ast.Name) else "?"
+                    rel = path.relative_to(_REPO_ROOT)
+                    offenders.append(f"{rel}:{stmt.lineno}  {node.name}.{field}")
+    return offenders, inspected
+
+
+@pytest.mark.parametrize(
+    "root",
+    [
+        pytest.param(_PACKAGE_DIR, id="package"),
+        pytest.param(_EXAMPLES_DIR, id="examples"),
+    ],
+)
+def test_no_pep604_in_dataclass_fields(root: Path) -> None:
+    if not root.is_dir():
+        # examples/ is not shipped in the wheel; nothing to scan from an installed package.
+        pytest.skip(f"{root.name}/ not present")
+
+    offenders, inspected = _scan(root)
+
+    # Without this the test passes trivially if the scan ever stops finding dataclasses —
+    # exactly how the original version of this check silently reported success.
+    assert inspected > 0, f"no dataclasses found under {root}; the scan is not working"
+    assert not offenders, (
+        "PEP 604 union in a dataclass field. tyro resolves these via typing.get_type_hints, "
+        "which raises TypeError on the Python 3.8 floor. Use Optional[X] instead:\n  "
+        + "\n  ".join(offenders)
+    )

oopsie_data_tools/test/test_record_step_purity.py

@@ -0,0 +1,127 @@
+"""``record_step`` must not modify the dicts the caller passes in.
+
+It used to: ``_check_step_data`` wrote the quaternion-converted pose back into the caller's
+``action``/``robot_state``, and ``record_step`` then read those same dicts to fill its
+buffer. The mutation was therefore load-bearing — the conversion reached the recording
+buffer through it — so "just copy the dict" would have silently recorded raw euler values
+labelled as quaternions. These tests pin down both halves: the caller's data is untouched,
+*and* the conversion still lands in the episode.
+"""
+
+from __future__ import annotations
+
+import copy
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import pytest
+from scipy.spatial.transform import Rotation as R
+
+from oopsie_data_tools.annotation_tool.episode_recorder import EpisodeRecorder
+from oopsie_data_tools.utils.robot_profile.robot_profile import RobotProfile
+
+EULER = [0.3, -0.5, 1.1]
+POSITION = [0.1, -0.2, 0.3]
+
+
+def _cartesian_profile(**overrides) -> RobotProfile:
+    defaults = dict(
+        policy_name="p",
+        robot_name="r",
+        is_biarm=False,
+        uses_mobile_base=False,
+        gripper_name="g",
+        control_freq=10,
+        camera_names=["left"],
+        robot_state_keys=["joint_position", "gripper_position", "cartesian_position"],
+        robot_state_joint_names=["j1", "j2"],
+        action_space=["cartesian_position", "gripper_position"],
+        orientation_representation="euler_xyz",
+        robot_state_orientation_representation="euler_xyz",
+    )
+    defaults.update(overrides)
+    return RobotProfile(**defaults)
+
+
+@pytest.fixture
+def recorder():
+    with tempfile.TemporaryDirectory() as tmp:
+        rec = EpisodeRecorder(
+            robot_profile=_cartesian_profile(),
+            data_root_dir=Path(tmp),
+            operator_name="op",
+        )
+        rec.reset_episode_recorder()
+        yield rec
+
+
+def _observation() -> dict:
+    return {
+        "robot_state": {
+            "joint_position": np.zeros(2, dtype=np.float32),
+            "gripper_position": np.zeros(1, dtype=np.float32),
+            "cartesian_position": np.array(POSITION + EULER, dtype=np.float32),
+        },
+        "image_observation": {"left": np.zeros((64, 64, 3), dtype=np.uint8)},
+    }
+
+
+def _action() -> dict:
+    return {
+        "cartesian_position": np.array(POSITION + EULER, dtype=np.float32),
+        "gripper_position": np.zeros(1, dtype=np.float32),
+    }
+
+
+def test_caller_dicts_are_not_mutated(recorder):
+    observation, action = _observation(), _action()
+    observation_before = copy.deepcopy(observation)
+    action_before = copy.deepcopy(action)
+
+    recorder.record_step(observation=observation, action=action)
+
+    np.testing.assert_array_equal(
+        action["cartesian_position"],
+        action_before["cartesian_position"],
+        err_msg="record_step rewrote the caller's action dict",
+    )
+    np.testing.assert_array_equal(
+        observation["robot_state"]["cartesian_position"],
+        observation_before["robot_state"]["cartesian_position"],
+        err_msg="record_step rewrote the caller's robot_state dict",
+    )
+    assert action["cartesian_position"].shape == (6,), "still euler, not converted in place"
+
+
+def test_conversion_still_reaches_the_buffer(recorder):
+    """The half that a naive de-mutation would have broken, silently."""
+    recorder.record_step(observation=_observation(), action=_action())
+
+    buffered_action = recorder.timesteps[0]["action_dict"]["cartesian_position"]
+    buffered_state = recorder.timesteps[0]["robot_state"]["cartesian_position"]
+
+    assert buffered_action.shape == (7,), "euler must have been converted to a quaternion"
+    assert buffered_state.shape == (7,)
+    np.testing.assert_allclose(buffered_action[:3], POSITION, rtol=1e-6)
+    np.testing.assert_allclose(
+        R.from_quat(buffered_action[3:]).as_matrix(),
+        R.from_euler("xyz", EULER).as_matrix(),
+        atol=1e-6,
+    )
+
+
+def test_the_same_action_dict_can_be_reused_across_steps(recorder):
+    """A caller reusing one preallocated dict must not accumulate conversions."""
+    observation, action = _observation(), _action()
+
+    for _ in range(3):
+        recorder.record_step(observation=observation, action=action)
+
+    assert recorder.num_steps == 3
+    for step in recorder.timesteps:
+        np.testing.assert_allclose(
+            step["action_dict"]["cartesian_position"],
+            recorder.timesteps[0]["action_dict"]["cartesian_position"],
+            err_msg="repeated conversion of an already-converted pose",
+        )