cardio 2026.1.0__tar.gz → 2026.1.2__tar.gz

{cardio-2026.1.0 → cardio-2026.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cardio
-Version: 2026.1.0
+Version: 2026.1.2
 Summary: A simple web-based viewer for 3D and 4D ('cine') medical imaging data.
 Keywords: Medical,Imaging,3D,4D,Visualization
 Author: Davis Marc Vigneault
@@ -60,8 +60,8 @@ Description-Content-Type: text/markdown
 built primarily on [trame](https://github.com/kitware/trame),
 [vtk](https://github.com/kitware/vtk), and
 [itk](https://github.com/insightsoftwareconsortium/itk).  `cardio` can render sequences
-of mesh files (e.g., `\*.obj` files), segmentation files (e.g., `\*nii.gz` files with
-discrete labels) and volume renderings of grayscale images (e.g., `\*.nii.gz` files with
+of mesh files (e.g., `*.obj` files), segmentation files (e.g., `*.nii.gz` files with
+discrete labels) and volume renderings of grayscale images (e.g., `*.nii.gz` files with
 continuous values).  `cardio` is launched from the commandline and may be configured via
 commandline arguments, a static TOML configuration file, or a combination of the two.
 
@@ -75,7 +75,7 @@ $ uv init
 $ uv add cardio
 $ . ./.venv/bin/activate
 (project) cardio --version
-cardio 2026.1.0
+cardio 2026.1.2
 ```
 
 ### Developing

{cardio-2026.1.0 → cardio-2026.1.2}/README.md

@@ -4,8 +4,8 @@
 built primarily on [trame](https://github.com/kitware/trame),
 [vtk](https://github.com/kitware/vtk), and
 [itk](https://github.com/insightsoftwareconsortium/itk).  `cardio` can render sequences
-of mesh files (e.g., `\*.obj` files), segmentation files (e.g., `\*nii.gz` files with
-discrete labels) and volume renderings of grayscale images (e.g., `\*.nii.gz` files with
+of mesh files (e.g., `*.obj` files), segmentation files (e.g., `*.nii.gz` files with
+discrete labels) and volume renderings of grayscale images (e.g., `*.nii.gz` files with
 continuous values).  `cardio` is launched from the commandline and may be configured via
 commandline arguments, a static TOML configuration file, or a combination of the two.
 
@@ -19,7 +19,7 @@ $ uv init
 $ uv add cardio
 $ . ./.venv/bin/activate
 (project) cardio --version
-cardio 2026.1.0
+cardio 2026.1.2
 ```
 
 ### Developing

{cardio-2026.1.0 → cardio-2026.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "cardio"
-version = "2026.1.0"
+version = "2026.1.2"
 authors = [
     {name = "Davis Marc Vigneault", email = "davis.vigneault@gmail.com"}
 ]
@@ -62,7 +62,7 @@ repository = "https://github.com/sudomakeinstall/cardio"
 profile = "black"
 
 [tool.bumpver]
-current_version = "2026.1.0"
+current_version = "2026.1.2"
 version_pattern = "YYYY.MM.INC0"
 commit_message = "ENH: Bump version from {old_version} => {new_version}"
 commit = true

{cardio-2026.1.0 → cardio-2026.1.2}/src/cardio/__init__.py

@@ -26,4 +26,4 @@ __all__ = [
     "window_level",
 ]
 
-__version__ = "2026.1.0"
+__version__ = "2026.1.2"

{cardio-2026.1.0 → cardio-2026.1.2}/src/cardio/logic.py

@@ -9,7 +9,13 @@ from .screenshot import Screenshot
 
 class Logic:
     def _get_visible_rotation_data(self):
-        """Get rotation sequence and angles for visible rotations only."""
+        """Get rotation sequence and angles for visible rotations only.
+
+        Returns data in ITK convention, as required by VTK.
+        Converts from current convention if necessary.
+        """
+        from .orientation import IndexOrder
+
         rotation_data = getattr(
             self.server.state, "mpr_rotation_data", {"angles_list": []}
         )
@@ -26,6 +32,17 @@ class Logic:
                 rotation_angles[visible_index] = rotation["angles"][0]
                 visible_index += 1
 
+        # CRITICAL: VTK always needs rotations in ITK convention
+        # Convert from current convention to ITK if necessary
+        current_convention = self.scene.mpr_rotation_sequence.metadata.index_order
+        if current_convention == IndexOrder.ROMA:
+            # Convert ROMA to ITK: X→Z, Y→Y, Z→X, angle→-angle
+            rotation_sequence = [
+                {"axis": {"X": "Z", "Y": "Y", "Z": "X"}[rot["axis"]]}
+                for rot in rotation_sequence
+            ]
+            rotation_angles = {idx: -angle for idx, angle in rotation_angles.items()}
+
         return rotation_sequence, rotation_angles
 
     def __init__(self, server, scene: Scene):
@@ -48,7 +65,7 @@ class Logic:
         ]
 
         # Initialize axis convention items for dropdown
-        self.server.state.axis_convention_items = [
+        self.server.state.index_order_items = [
             {"text": "ITK (X=L, Y=P, Z=S)", "value": "itk"},
             {"text": "Roma (X=S, Y=P, Z=L)", "value": "roma"},
         ]
@@ -71,7 +88,7 @@ class Logic:
         self.server.state.change("mpr_window_level_preset")(self.update_mpr_preset)
         self.server.state.change("mpr_rotation_data")(self.update_mpr_rotation)
         self.server.state.change("angle_units")(self.sync_angle_units)
-        self.server.state.change("axis_convention")(self.sync_axis_convention)
+        self.server.state.change("index_order")(self.sync_index_order)
 
         # Initialize visibility state variables
         for m in self.scene.meshes:
@@ -189,8 +206,12 @@ class Logic:
             self.scene.mpr_rotation_sequence.to_dict_for_ui()
         )
 
-        self.server.state.angle_units = self.scene.angle_units.value
-        self.server.state.axis_convention = self.scene.axis_convention.value
+        self.server.state.angle_units = (
+            self.scene.mpr_rotation_sequence.metadata.angle_units.value
+        )
+        self.server.state.index_order = (
+            self.scene.mpr_rotation_sequence.metadata.index_order.value
+        )
 
         # Initialize MPR presets data
         try:
@@ -326,7 +347,7 @@ class Logic:
             origin,
             rotation_sequence,
             rotation_angles,
-            self.scene.angle_units,
+            self.scene.mpr_rotation_sequence.metadata.angle_units,
         )
 
         # Apply window/level
@@ -517,16 +538,21 @@ class Logic:
         )
         rotation_seq = RotationSequence.from_ui_dict(rotation_data, active_volume_label)
 
+        mpr_origin = getattr(self.server.state, "mpr_origin", [0.0, 0.0, 0.0])
+        rotation_seq.mpr_origin = list(mpr_origin)
+
         rotation_seq.metadata.timestamp = timestamp.isoformat()
         rotation_seq.metadata.volume_label = active_volume_label
         rotation_seq.metadata.coordinate_system = self.scene.coordinate_system
+        rotation_seq.metadata.index_order = (
+            self.scene.mpr_rotation_sequence.metadata.index_order
+        )
+        rotation_seq.metadata.angle_units = (
+            self.scene.mpr_rotation_sequence.metadata.angle_units
+        )
 
         output_path = save_dir / f"{timestamp_str}.toml"
-        rotation_seq.to_file(
-            output_path,
-            target_convention=self.scene.axis_convention,
-            target_units=self.scene.angle_units,
-        )
+        rotation_seq.to_file(output_path)
 
     def reset_all(self):
         self.server.state.frame = 0
@@ -560,9 +586,9 @@ class Logic:
         from .orientation import AngleUnits
 
         # Get current units before changing
-        old_units = self.scene.angle_units
+        old_units = self.scene.mpr_rotation_sequence.metadata.angle_units
 
-        # Update the scene's angle_units field based on UI selection
+        # Update based on UI selection
         new_units = None
         if angle_units == "degrees":
             new_units = AngleUnits.DEGREES
@@ -592,16 +618,48 @@ class Logic:
 
             self.server.state.mpr_rotation_data = updated_data
 
-        self.scene.angle_units = new_units
+        self.scene.mpr_rotation_sequence.metadata.angle_units = new_units
+
+    def sync_index_order(self, index_order, **kwargs):
+        """Sync index order selection - converts existing rotations and updates scene."""
+        import copy
+
+        from .orientation import IndexOrder
 
-    def sync_axis_convention(self, axis_convention, **kwargs):
-        """Sync axis convention selection - updates the scene configuration."""
-        from .orientation import AxisConvention
+        old_convention = self.scene.mpr_rotation_sequence.metadata.index_order
 
-        if axis_convention == "itk":
-            self.scene.axis_convention = AxisConvention.ITK
-        elif axis_convention == "roma":
-            self.scene.axis_convention = AxisConvention.ROMA
+        # Convert string input to enum
+        if isinstance(index_order, str):
+            match index_order.lower():
+                case "itk":
+                    new_convention = IndexOrder.ITK
+                case "roma":
+                    new_convention = IndexOrder.ROMA
+                case _:
+                    raise ValueError(f"Unrecognized index order: {index_order}")
+        else:
+            new_convention = index_order
+
+        if old_convention == new_convention:
+            return
+
+        rotation_data = getattr(
+            self.server.state, "mpr_rotation_data", {"angles_list": []}
+        )
+        if rotation_data.get("angles_list"):
+            updated_data = copy.deepcopy(rotation_data)
+
+            for rotation in updated_data["angles_list"]:
+                current_axis = rotation.get("axes")
+                current_angle = rotation.get("angles", [0])[0]
+
+                # Conversion is the same for both ITK<->ROMA directions
+                rotation["axes"] = {"X": "Z", "Y": "Y", "Z": "X"}[current_axis]
+                rotation["angles"][0] = -current_angle
+
+            self.server.state.mpr_rotation_data = updated_data
+
+        self.scene.mpr_rotation_sequence.metadata.index_order = new_convention
 
     def _initialize_clipping_state(self):
         """Initialize clipping state variables for all objects."""
@@ -793,7 +851,7 @@ class Logic:
             origin,
             rotation_sequence,
             rotation_angles,
-            self.scene.angle_units,
+            self.scene.mpr_rotation_sequence.metadata.angle_units,
         )
 
         # Update all views
@@ -892,7 +950,7 @@ class Logic:
             origin,
             rotation_sequence,
             rotation_angles,
-            self.scene.angle_units,
+            self.scene.mpr_rotation_sequence.metadata.angle_units,
         )
 
         # Update all views
@@ -984,6 +1042,9 @@ class Logic:
             self.sync_active_volume(self._pending_active_volume)
             delattr(self, "_pending_active_volume")
 
+        # Apply loaded rotation data to MPR views
+        self.update_mpr_rotation()
+
     @asynchronous.task
     async def close_application(self):
         """Close the application by stopping the server."""

{cardio-2026.1.0 → cardio-2026.1.2}/src/cardio/orientation.py

@@ -1,22 +1,22 @@
-from enum import Enum
+import enum
 
 import itk
 import numpy as np
 
 
 # DICOM LPS canonical orientation vector mappings
-class EulerAxis(Enum):
+class EulerAxis(enum.StrEnum):
     X = "X"
     Y = "Y"
     Z = "Z"
 
 
-class AxisConvention(Enum):
+class IndexOrder(enum.StrEnum):
     ITK = "itk"  # X=Left, Y=Posterior, Z=Superior
     ROMA = "roma"  # X=Superior, Y=Posterior, Z=Left
 
 
-class AngleUnits(Enum):
+class AngleUnits(enum.StrEnum):
     DEGREES = "degrees"
     RADIANS = "radians"
 

cardio-2026.1.2/src/cardio/rotation.py

@@ -0,0 +1,146 @@
+# System
+import datetime as dt
+import pathlib as pl
+import typing as ty
+
+# Third Party
+import numpy as np
+import pydantic as pc
+import tomlkit as tk
+
+# Internal
+from .orientation import AngleUnits, IndexOrder
+
+
+class RotationStep(pc.BaseModel):
+    """Single rotation step.
+
+    Both angles and axes are stored in the current convention/units.
+    - Angles: stored in units specified by parent metadata.angle_units
+    - Axes: stored in convention specified by parent metadata.index_order
+    """
+
+    axes: ty.Literal["X", "Y", "Z"]
+    angle: float = 0.0
+    visible: bool = True
+    name: str = ""
+    name_editable: bool = True
+    deletable: bool = True
+
+    @pc.model_validator(mode="before")
+    @classmethod
+    def handle_legacy_format(cls, data):
+        """Handle legacy 'angles' list format and 'axis' field."""
+        if isinstance(data, dict):
+            if "angles" in data and "angle" not in data:
+                angles = data["angles"]
+                if isinstance(angles, list) and len(angles) > 0:
+                    data["angle"] = angles[0]
+                else:
+                    data["angle"] = angles
+            if "axis" in data and "axes" not in data:
+                data["axes"] = data["axis"]
+        return data
+
+
+class RotationMetadata(pc.BaseModel):
+    """Metadata for TOML files."""
+
+    coordinate_system: ty.Literal["LPS"] = "LPS"
+    index_order: IndexOrder = IndexOrder.ITK
+    angle_units: AngleUnits = AngleUnits.RADIANS
+    timestamp: str = pc.Field(default_factory=lambda: dt.datetime.now().isoformat())
+    volume_label: str = ""
+
+
+class RotationSequence(pc.BaseModel):
+    """Complete rotation sequence.
+
+    Both angles and axes are always stored in the current convention/units:
+    - Angles: stored in units specified by metadata.angle_units
+    - Axes: stored in convention specified by metadata.index_order
+
+    When convention/units change in the UI, all existing rotations are converted.
+    """
+
+    model_config = pc.ConfigDict(frozen=False)
+
+    metadata: RotationMetadata = pc.Field(default_factory=RotationMetadata)
+    angles_list: list[RotationStep] = pc.Field(default_factory=list)
+    mpr_origin: list[float] = pc.Field(
+        default_factory=lambda: [0.0, 0.0, 0.0],
+        description="MPR origin position [x, y, z] in LPS coordinates",
+    )
+
+    @pc.field_validator("mpr_origin")
+    @classmethod
+    def validate_mpr_origin(cls, v):
+        """Ensure mpr_origin is a 3-element list of floats."""
+        if not isinstance(v, list) or len(v) != 3:
+            raise ValueError("mpr_origin must be a 3-element list [x, y, z]")
+        return [float(x) for x in v]
+
+    @pc.field_validator("angles_list", mode="before")
+    @classmethod
+    def convert_legacy_list(cls, v):
+        """Convert legacy list of dicts to list of RotationStep."""
+        if isinstance(v, list) and len(v) > 0 and isinstance(v[0], dict):
+            return [RotationStep(**item) for item in v]
+        return v
+
+    def to_dict_for_ui(self) -> dict:
+        """Convert to UI format.
+
+        Angles are passed through in their current units (metadata.angle_units).
+        UI expects 'angles' as a list for backward compatibility.
+        """
+        return {
+            "angles_list": [
+                {
+                    "axes": step.axes,
+                    "angles": [step.angle],
+                    "visible": step.visible,
+                    "name": step.name,
+                    "name_editable": step.name_editable,
+                    "deletable": step.deletable,
+                }
+                for step in self.angles_list
+            ],
+            "mpr_origin": self.mpr_origin,
+        }
+
+    @classmethod
+    def from_ui_dict(cls, data: dict, volume_label: str = "") -> "RotationSequence":
+        """Create from UI format.
+
+        Angles from UI are stored as-is (in current UI units).
+        Caller should set metadata.angle_units to match the UI's current units.
+        """
+        angles_list = [RotationStep(**step) for step in data.get("angles_list", [])]
+        metadata = RotationMetadata(volume_label=volume_label)
+        mpr_origin = data.get("mpr_origin", [0.0, 0.0, 0.0])
+        return cls(metadata=metadata, angles_list=angles_list, mpr_origin=mpr_origin)
+
+    def to_toml(self) -> str:
+        """Serialize to TOML using stored serialization preferences."""
+        data = self.model_dump(mode="json")
+        return tk.dumps(data)
+
+    @classmethod
+    def from_toml(cls, toml_content: str) -> "RotationSequence":
+        """Deserialize from TOML (no conversions - loads as-is)."""
+        doc = tk.loads(toml_content)
+        data = dict(doc)
+        return cls(**data)
+
+    @classmethod
+    def from_file(cls, path: pl.Path) -> "RotationSequence":
+        """Load from TOML file."""
+        with open(path, "r") as f:
+            return cls.from_toml(f.read())
+
+    def to_file(self, path: pl.Path):
+        """Save to TOML file using stored serialization preferences."""
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            f.write(self.to_toml())

{cardio-2026.1.0 → cardio-2026.1.2}/src/cardio/scene.py

@@ -8,7 +8,7 @@ import pydantic_settings as ps
 import vtk
 
 from .mesh import Mesh
-from .orientation import AngleUnits, AxisConvention
+from .orientation import AngleUnits, IndexOrder
 from .rotation import RotationSequence
 from .segmentation import Segmentation
 from .types import RGBColor
@@ -137,17 +137,9 @@ class Scene(ps.BaseSettings):
         default=20,
         description="Maximum number of MPR rotations supported",
     )
-    angle_units: AngleUnits = pc.Field(
-        default=AngleUnits.RADIANS,
-        description="Units for angle measurements in rotation serialization",
-    )
     coordinate_system: str = pc.Field(
         default="LPS", description="Coordinate system orientation (e.g., LPS, RAS, LAS)"
     )
-    axis_convention: AxisConvention = pc.Field(
-        default=AxisConvention.ITK,
-        description="Axis convention for saved rotations (ITK: X=L,Y=P,Z=S; Roma: X=S,Y=P,Z=L)",
-    )
     mpr_crosshairs_enabled: bool = pc.Field(
         default=True, description="Show crosshair lines indicating slice intersections"
     )
@@ -200,6 +192,9 @@ class Scene(ps.BaseSettings):
                     self.mpr_rotation_sequence.metadata.volume_label
                 )
 
+            if self.mpr_rotation_sequence.mpr_origin:
+                self.mpr_origin = list(self.mpr_rotation_sequence.mpr_origin)
+
         return self
 
     # VTK objects as private attributes

{cardio-2026.1.0 → cardio-2026.1.2}/src/cardio/ui.py

@@ -660,8 +660,8 @@ class UI:
                             vuetify.VLabel("Convention:")
                         with vuetify.VCol(cols="8"):
                             vuetify.VSelect(
-                                v_model=("axis_convention", "itk"),
-                                items=("axis_convention_items", []),
+                                v_model=("index_order", "itk"),
+                                items=("index_order_items", []),
                                 item_title="text",
                                 item_value="value",
                                 dense=True,

cardio-2026.1.0/src/cardio/rotation.py

@@ -1,211 +0,0 @@
-# System
-import datetime as dt
-import pathlib as pl
-import typing as ty
-
-# Third Party
-import numpy as np
-import pydantic as pc
-import tomlkit as tk
-
-# Internal
-from .orientation import AngleUnits, AxisConvention
-
-
-class RotationStep(pc.BaseModel):
-    """Single rotation step (stored in ITK convention, radians)."""
-
-    axes: ty.Literal["X", "Y", "Z"]
-    angle: float = 0.0
-    visible: bool = True
-    name: str = ""
-    name_editable: bool = True
-    deletable: bool = True
-
-    @pc.model_validator(mode="before")
-    @classmethod
-    def handle_legacy_format(cls, data):
-        """Handle legacy 'angles' list format and 'axis' field."""
-        if isinstance(data, dict):
-            if "angles" in data and "angle" not in data:
-                angles = data["angles"]
-                if isinstance(angles, list) and len(angles) > 0:
-                    data["angle"] = angles[0]
-                else:
-                    data["angle"] = angles
-            if "axis" in data and "axes" not in data:
-                data["axes"] = data["axis"]
-        return data
-
-    def to_convention(
-        self, convention: AxisConvention, units: AngleUnits
-    ) -> tuple[str, float]:
-        """Convert to target convention/units for serialization."""
-        axis = self.axes
-        angle = self.angle
-
-        if convention == AxisConvention.ROMA:
-            axis = {"X": "Z", "Y": "Y", "Z": "X"}[axis]
-            angle = -angle
-
-        if units == AngleUnits.DEGREES:
-            angle = np.degrees(angle)
-
-        return axis, angle
-
-    @classmethod
-    def from_convention(
-        cls,
-        axes: str,
-        angle: float,
-        convention: AxisConvention,
-        units: AngleUnits,
-        **kwargs,
-    ) -> "RotationStep":
-        """Create from target convention/units (for deserialization)."""
-        if units == AngleUnits.DEGREES:
-            angle = np.radians(angle)
-
-        if convention == AxisConvention.ROMA:
-            axes = {"X": "Z", "Y": "Y", "Z": "X"}[axes]
-            angle = -angle
-
-        return cls(axes=axes, angle=angle, **kwargs)
-
-
-class RotationMetadata(pc.BaseModel):
-    """Metadata for TOML files."""
-
-    coordinate_system: ty.Literal["LPS"] = "LPS"
-    axis_convention: AxisConvention = AxisConvention.ITK
-    units: AngleUnits = AngleUnits.RADIANS
-    timestamp: str = pc.Field(default_factory=lambda: dt.datetime.now().isoformat())
-    volume_label: str = ""
-
-
-class RotationSequence(pc.BaseModel):
-    """Complete rotation sequence (stored in ITK convention, radians)."""
-
-    model_config = pc.ConfigDict(frozen=False)
-
-    metadata: RotationMetadata = pc.Field(default_factory=RotationMetadata)
-    angles_list: list[RotationStep] = pc.Field(default_factory=list)
-
-    @pc.field_validator("angles_list", mode="before")
-    @classmethod
-    def convert_legacy_list(cls, v):
-        """Convert legacy list of dicts to list of RotationStep."""
-        if isinstance(v, list) and len(v) > 0 and isinstance(v[0], dict):
-            return [RotationStep(**item) for item in v]
-        return v
-
-    def to_dict_for_ui(self) -> dict:
-        """Convert to UI format (always ITK/radians internally).
-
-        Note: UI expects 'angles' as a list for backward compatibility.
-        """
-        return {
-            "angles_list": [
-                {
-                    "axes": step.axes,
-                    "angles": [step.angle],
-                    "visible": step.visible,
-                    "name": step.name,
-                    "name_editable": step.name_editable,
-                    "deletable": step.deletable,
-                }
-                for step in self.angles_list
-            ]
-        }
-
-    @classmethod
-    def from_ui_dict(cls, data: dict, volume_label: str = "") -> "RotationSequence":
-        """Create from UI format (assumes ITK/radians)."""
-        angles_list = [RotationStep(**step) for step in data.get("angles_list", [])]
-        metadata = RotationMetadata(volume_label=volume_label)
-        return cls(metadata=metadata, angles_list=angles_list)
-
-    def to_toml(
-        self, target_convention: AxisConvention, target_units: AngleUnits
-    ) -> str:
-        """Serialize to TOML with conversions."""
-        doc = tk.document()
-
-        metadata_table = tk.table()
-        metadata_table["coordinate_system"] = self.metadata.coordinate_system
-        metadata_table["axis_convention"] = target_convention.value
-        metadata_table["units"] = target_units.value
-        metadata_table["timestamp"] = self.metadata.timestamp
-        metadata_table["volume_label"] = self.metadata.volume_label
-        doc["metadata"] = metadata_table
-
-        rotations_array = tk.aot()
-        for step in self.angles_list:
-            rotation = tk.table()
-            converted_axis, converted_angle = step.to_convention(
-                target_convention, target_units
-            )
-            rotation["axes"] = converted_axis
-            rotation["angle"] = converted_angle
-            rotation["visible"] = step.visible
-            rotation["name"] = step.name
-            rotation["name_editable"] = step.name_editable
-            rotation["deletable"] = step.deletable
-            rotations_array.append(rotation)
-
-        doc["angles_list"] = rotations_array
-
-        return tk.dumps(doc)
-
-    @classmethod
-    def from_toml(cls, toml_content: str) -> "RotationSequence":
-        """Deserialize from TOML with conversions."""
-        doc = tk.loads(toml_content)
-
-        metadata_dict = doc.get("metadata", {})
-        convention = AxisConvention(metadata_dict.get("axis_convention", "itk"))
-        units = AngleUnits(metadata_dict.get("units", "radians"))
-
-        metadata = RotationMetadata(
-            coordinate_system=metadata_dict.get("coordinate_system", "LPS"),
-            axis_convention=convention,
-            units=units,
-            timestamp=metadata_dict.get("timestamp", dt.datetime.now().isoformat()),
-            volume_label=metadata_dict.get("volume_label", ""),
-        )
-
-        angles_list_data = doc.get("angles_list", [])
-        angles_list = []
-        for item in angles_list_data:
-            axes = item.get("axes", "X")
-            angle = item.get("angle", 0.0)
-            step = RotationStep.from_convention(
-                axes=axes,
-                angle=angle,
-                convention=convention,
-                units=units,
-                visible=item.get("visible", True),
-                name=item.get("name", ""),
-                name_editable=item.get("name_editable", True),
-                deletable=item.get("deletable", True),
-            )
-            angles_list.append(step)
-
-        return cls(metadata=metadata, angles_list=angles_list)
-
-    @classmethod
-    def from_file(cls, path: pl.Path) -> "RotationSequence":
-        """Load from TOML file."""
-        with open(path, "r") as f:
-            return cls.from_toml(f.read())
-
-    def to_file(
-        self,
-        path: pl.Path,
-        target_convention: AxisConvention,
-        target_units: AngleUnits,
-    ):
-        """Save to TOML file."""
-        path.parent.mkdir(parents=True, exist_ok=True)
-        with open(path, "w") as f:
-            f.write(self.to_toml(target_convention, target_units))