euler-train 2.4.1__tar.gz → 2.6.0__tar.gz

{euler_train-2.4.1 → euler_train-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-train
-Version: 2.4.1
+Version: 2.6.0
 Summary: Lightweight file-based experiment logger for PyTorch
 Requires-Python: >=3.9
 Requires-Dist: numpy

{euler_train-2.4.1 → euler_train-2.6.0}/euler_train/outputs.py

@@ -18,7 +18,7 @@ def save_output_tree(
     format_overrides: dict[str, str],
     visualization_overrides: dict[str, Any],
     output_type: str,
-) -> None:
+) -> dict[str, Any]:
     """Persist all slots (pred, gt, input, aux/…) for one *output_type*.
 
     *slots* example::
@@ -28,7 +28,10 @@ def save_output_tree(
             "gt":   array,
             "aux":  {"transmission": array, "attention": array},
         }
+
+    Returns a dict mapping slot keys to their manifest entries.
     """
+    manifest: dict[str, Any] = {}
     for slot_name, data in slots.items():
         if data is None:
             continue
@@ -36,7 +39,7 @@ def save_output_tree(
             for aux_name, aux_data in data.items():
                 if aux_data is None:
                     continue
-                _save_slot(
+                manifest[f"aux/{aux_name}"] = _save_slot(
                     type_dir / "aux" / aux_name,
                     aux_data,
                     output_type,
@@ -45,7 +48,7 @@ def save_output_tree(
                     visualization_overrides,
                 )
         else:
-            _save_slot(
+            manifest[slot_name] = _save_slot(
                 type_dir / slot_name,
                 data,
                 output_type,
@@ -53,6 +56,7 @@ def save_output_tree(
                 format_overrides,
                 visualization_overrides,
             )
+    return manifest
 
 
 # ---------------------------------------------------------------------------
@@ -66,15 +70,30 @@ def _save_slot(
     leaf_name: str,
     format_overrides: dict[str, str],
     visualization_overrides: dict[str, Any],
-) -> None:
+) -> dict[str, Any]:
+    """Save items for one slot and return a manifest entry."""
     slot_dir.mkdir(parents=True, exist_ok=True)
-    items = _unpack(data)
     visualization = _resolve_visualization(
         output_type, leaf_name, visualization_overrides,
     )
+
+    # Dict with string keys → named outputs (e.g. {"scene_042": img}).
+    if isinstance(data, dict):
+        files: list[dict[str, Any]] = []
+        for name, raw in data.items():
+            item = _prepare(raw)
+            fmt = _resolve_format(item, output_type, leaf_name, format_overrides)
+            _save_item(slot_dir / f"{name}.{fmt}", item, fmt, visualization)
+            files.append({"sample_id": name, "filename": f"{name}.{fmt}", "format": fmt})
+        return {"id_mode": "named", "files": files}
+
+    items = _unpack(data)
+    files = []
     for idx, item in enumerate(items):
         fmt = _resolve_format(item, output_type, leaf_name, format_overrides)
         _save_item(slot_dir / f"{idx:04d}.{fmt}", item, fmt, visualization)
+        files.append({"sample_id": idx, "filename": f"{idx:04d}.{fmt}", "format": fmt})
+    return {"id_mode": "indexed", "files": files}
 
 
 # ---- normalisation -------------------------------------------------------

{euler_train-2.4.1 → euler_train-2.6.0}/euler_train/run.py

@@ -361,6 +361,7 @@ class Run:
         *,
         epoch: int | None = None,
         step: int | None = None,
+        metadata: dict[str, Any] | None = None,
         **output_types: dict[str, Any],
     ) -> Path:
         """Save prediction / ground-truth / auxiliary arrays to disk.
@@ -375,11 +376,34 @@ class Run:
                             aux=dict(transmission=t_map)),
             )
 
+        Slot values can also be dicts mapping custom string IDs to
+        items, producing named files instead of sequential indices::
+
+            run.save_outputs(
+                epoch=1, step=500,
+                rgb=dict(pred={"scene_042": img_a, "scene_117": img_b}),
+            )
+
+        An optional *metadata* dict attaches source context (dataset,
+        split, etc.) to the manifest.  The ``dataset`` key is required
+        when *metadata* is provided::
+
+            run.save_outputs(
+                epoch=1, step=500,
+                metadata={"dataset": "vkitti2", "split": "val"},
+                rgb=dict(pred=pred_img),
+            )
+
         Accepted slot keys: ``pred``, ``gt``, ``input``, ``aux``.
         ``aux`` expects a sub-dict of named arrays.
 
         Returns the directory that was written to.
         """
+        if metadata is not None:
+            if not isinstance(metadata.get("dataset"), str) or not metadata["dataset"].strip():
+                raise ValueError(
+                    "metadata must include a non-empty 'dataset' string"
+                )
         parts: list[str] = []
         if epoch is not None:
             parts.append(f"epoch_{epoch}")
@@ -388,21 +412,38 @@ class Run:
         dirname = "_".join(parts) or "unspecified"
         base = self.dir / "outputs" / dirname
 
+        manifest_types: dict[str, Any] = {}
         for output_type, slots in output_types.items():
             if slots is None:
                 continue
-            save_output_tree(
+            slot_manifest = save_output_tree(
                 base / output_type,
                 slots,
                 self._output_formats,
                 self._output_visualization,
                 output_type,
             )
+            if slot_manifest:
+                manifest_types[output_type] = slot_manifest
+        if manifest_types:
+            manifest: dict[str, Any] = {
+                "version": 1,
+                "epoch": epoch,
+                "step": step,
+                "output_types": manifest_types,
+                "format_overrides": dict(self._output_formats),
+                "visualization_overrides": {
+                    k: dict(v) if isinstance(v, Mapping) else v
+                    for k, v in self._output_visualization.items()
+                } if self._output_visualization else {},
+            }
+            if metadata is not None:
+                manifest["metadata"] = metadata
+            write_json(base / "manifest.json", manifest)
         if base.exists():
             self._record_artifact_update(base)
             self._flush_meta()
-            snapshot = self._build_output_snapshot(epoch, step, output_types)
-            if snapshot is not None:
+            if manifest_types and epoch is not None and step is not None:
                 self._emit_stream_event(
                     {
                         "type": "output_snapshot",
@@ -411,7 +452,13 @@ class Run:
                             epoch,
                             step,
                         ),
-                        "snapshot": snapshot,
+                        "snapshot": {
+                            "version": 1,
+                            "epoch": epoch,
+                            "step": step,
+                            "output_types": manifest_types,
+                            **({"metadata": metadata} if metadata is not None else {}),
+                        },
                     },
                 )
         return base
@@ -880,44 +927,6 @@ class Run:
         ]
         return tags or None
 
-    def _build_output_snapshot(
-        self,
-        epoch: int | None,
-        step: int | None,
-        output_types: dict[str, Any],
-    ) -> dict[str, Any] | None:
-        if epoch is None or step is None:
-            return None
-
-        snapshot_types: dict[str, list[str]] = {}
-        for output_type, slots in output_types.items():
-            if slots is None or not isinstance(slots, Mapping):
-                continue
-
-            categories: list[str] = []
-            for slot_name, data in slots.items():
-                if data is None:
-                    continue
-                if slot_name == "aux" and isinstance(data, Mapping):
-                    for aux_name, aux_value in data.items():
-                        if aux_value is None:
-                            continue
-                        categories.append(f"aux/{aux_name}")
-                else:
-                    categories.append(str(slot_name))
-
-            if categories:
-                snapshot_types[str(output_type)] = sorted(set(categories))
-
-        if not snapshot_types:
-            return None
-
-        return {
-            "epoch": epoch,
-            "step": step,
-            "types": snapshot_types,
-        }
-
     def _build_finish_patch(self) -> dict[str, Any]:
         patch = {
             "end_time": self._meta.get("end_time"),

{euler_train-2.4.1 → euler_train-2.6.0}/euler_train.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-train
-Version: 2.4.1
+Version: 2.6.0
 Summary: Lightweight file-based experiment logger for PyTorch
 Requires-Python: >=3.9
 Requires-Dist: numpy

{euler_train-2.4.1 → euler_train-2.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "euler-train"
-version = "2.4.1"
+version = "2.6.0"
 description = "Lightweight file-based experiment logger for PyTorch"
 requires-python = ">=3.9"
 dependencies = ["numpy", "euler-dataset-contract"]

{euler_train-2.4.1 → euler_train-2.6.0}/tests/test_runlog.py

@@ -1444,6 +1444,42 @@ class TestSaveOutputsVariants:
         assert path.name == "epoch_2_step_500"
         run.finish()
 
+    def test_dict_slot_produces_named_files(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        a = np.zeros((4, 4, 3), dtype=np.uint8)
+        b = np.ones((4, 4, 3), dtype=np.uint8) * 128
+        run.save_outputs(epoch=0, step=0, rgb=dict(pred={"scene_a": a, "scene_b": b}))
+
+        pred_dir = run.dir / "outputs" / "epoch_0_step_0" / "rgb" / "pred"
+        names = sorted(f.name for f in pred_dir.iterdir())
+        assert names == ["scene_a.png", "scene_b.png"]
+        run.finish()
+
+    def test_dict_slot_in_aux(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        m1 = np.ones((4, 4), dtype=np.float32)
+        m2 = np.zeros((4, 4), dtype=np.float32)
+        run.save_outputs(
+            epoch=0, step=0,
+            depth=dict(aux=dict(attn={"head_0": m1, "head_1": m2})),
+        )
+
+        attn_dir = run.dir / "outputs" / "epoch_0_step_0" / "depth" / "aux" / "attn"
+        names = sorted(f.name for f in attn_dir.iterdir())
+        assert names == ["head_0.npy", "head_1.npy"]
+        run.finish()
+
+    def test_mixed_dict_and_array_slots(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        a = np.zeros((4, 4, 3), dtype=np.uint8)
+        run.save_outputs(epoch=0, step=0, rgb=dict(pred={"frame_x": a}, gt=a))
+
+        pred_dir = run.dir / "outputs" / "epoch_0_step_0" / "rgb" / "pred"
+        gt_dir = run.dir / "outputs" / "epoch_0_step_0" / "rgb" / "gt"
+        assert sorted(f.name for f in pred_dir.iterdir()) == ["frame_x.png"]
+        assert sorted(f.name for f in gt_dir.iterdir()) == ["0000.png"]
+        run.finish()
+
     def test_returns_output_base_path(self, tmp_path):
         run = euler_train.init(dir=str(tmp_path / "r"), config={})
         arr = np.zeros((4, 4, 3), dtype=np.uint8)
@@ -1452,6 +1488,162 @@ class TestSaveOutputsVariants:
         run.finish()
 
 
+# ═══════════════════════════════════════════════════════════════════════════
+#  Output manifest
+# ═══════════════════════════════════════════════════════════════════════════
+
+class TestSaveOutputsManifest:
+    def test_manifest_written_for_basic_save(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        arr = np.zeros((4, 4, 3), dtype=np.uint8)
+        run.save_outputs(epoch=1, step=500, rgb=dict(pred=arr))
+
+        m = _read_json(run.dir / "outputs" / "epoch_1_step_500" / "manifest.json")
+        assert m["version"] == 1
+        assert m["epoch"] == 1
+        assert m["step"] == 500
+        assert "rgb" in m["output_types"]
+        assert "pred" in m["output_types"]["rgb"]
+        run.finish()
+
+    def test_manifest_indexed_files(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        imgs = [np.zeros((4, 4, 3), dtype=np.uint8) for _ in range(3)]
+        run.save_outputs(epoch=0, step=0, rgb=dict(pred=imgs))
+
+        slot = _read_json(
+            run.dir / "outputs" / "epoch_0_step_0" / "manifest.json",
+        )["output_types"]["rgb"]["pred"]
+        assert slot["id_mode"] == "indexed"
+        assert len(slot["files"]) == 3
+        assert slot["files"][0] == {"sample_id": 0, "filename": "0000.png", "format": "png"}
+        assert slot["files"][2]["sample_id"] == 2
+        run.finish()
+
+    def test_manifest_named_files(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        a = np.zeros((4, 4, 3), dtype=np.uint8)
+        run.save_outputs(epoch=0, step=0, rgb=dict(pred={"scene_a": a, "scene_b": a}))
+
+        slot = _read_json(
+            run.dir / "outputs" / "epoch_0_step_0" / "manifest.json",
+        )["output_types"]["rgb"]["pred"]
+        assert slot["id_mode"] == "named"
+        ids = [f["sample_id"] for f in slot["files"]]
+        assert "scene_a" in ids
+        assert "scene_b" in ids
+        run.finish()
+
+    def test_manifest_aux_slots(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        arr = np.ones((4, 4), dtype=np.float32)
+        run.save_outputs(epoch=0, step=0, depth=dict(aux=dict(transmission=arr)))
+
+        m = _read_json(run.dir / "outputs" / "epoch_0_step_0" / "manifest.json")
+        assert "aux/transmission" in m["output_types"]["depth"]
+        run.finish()
+
+    def test_manifest_none_slots_excluded(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        arr = np.zeros((4, 4, 3), dtype=np.uint8)
+        run.save_outputs(epoch=0, step=0, rgb=dict(pred=arr, gt=None))
+
+        slots = _read_json(
+            run.dir / "outputs" / "epoch_0_step_0" / "manifest.json",
+        )["output_types"]["rgb"]
+        assert "pred" in slots
+        assert "gt" not in slots
+        run.finish()
+
+    def test_manifest_records_format_overrides(self, tmp_path):
+        run = euler_train.init(
+            dir=str(tmp_path / "r"), config={},
+            output_formats={"depth": "npz"},
+        )
+        arr = np.ones((4, 4), dtype=np.float32)
+        run.save_outputs(epoch=0, step=0, depth=dict(pred=arr))
+
+        m = _read_json(run.dir / "outputs" / "epoch_0_step_0" / "manifest.json")
+        assert m["format_overrides"] == {"depth": "npz"}
+        assert m["output_types"]["depth"]["pred"]["files"][0]["format"] == "npz"
+        run.finish()
+
+    def test_manifest_mixed_named_and_indexed(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        arr = np.zeros((4, 4, 3), dtype=np.uint8)
+        run.save_outputs(epoch=0, step=0, rgb=dict(pred={"x": arr}, gt=arr))
+
+        slots = _read_json(
+            run.dir / "outputs" / "epoch_0_step_0" / "manifest.json",
+        )["output_types"]["rgb"]
+        assert slots["pred"]["id_mode"] == "named"
+        assert slots["gt"]["id_mode"] == "indexed"
+        run.finish()
+
+    def test_manifest_metadata(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        arr = np.zeros((4, 4, 3), dtype=np.uint8)
+        run.save_outputs(
+            epoch=0, step=0,
+            metadata={"dataset": "vkitti2", "split": "val"},
+            rgb=dict(pred=arr),
+        )
+
+        m = _read_json(run.dir / "outputs" / "epoch_0_step_0" / "manifest.json")
+        assert m["metadata"] == {"dataset": "vkitti2", "split": "val"}
+        run.finish()
+
+    def test_manifest_metadata_absent_when_not_provided(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        arr = np.zeros((4, 4, 3), dtype=np.uint8)
+        run.save_outputs(epoch=0, step=0, rgb=dict(pred=arr))
+
+        m = _read_json(run.dir / "outputs" / "epoch_0_step_0" / "manifest.json")
+        assert "metadata" not in m
+        run.finish()
+
+    def test_manifest_metadata_requires_dataset(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        arr = np.zeros((4, 4, 3), dtype=np.uint8)
+        with pytest.raises(ValueError, match="dataset"):
+            run.save_outputs(
+                epoch=0, step=0,
+                metadata={"split": "val"},
+                rgb=dict(pred=arr),
+            )
+        run.finish()
+
+    def test_manifest_metadata_rejects_empty_dataset(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        arr = np.zeros((4, 4, 3), dtype=np.uint8)
+        with pytest.raises(ValueError, match="dataset"):
+            run.save_outputs(
+                epoch=0, step=0,
+                metadata={"dataset": "  "},
+                rgb=dict(pred=arr),
+            )
+        run.finish()
+
+    def test_no_manifest_when_all_none(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        run.save_outputs(epoch=0, step=0, rgb=None, depth=None)
+
+        manifest_path = run.dir / "outputs" / "epoch_0_step_0" / "manifest.json"
+        assert not manifest_path.exists()
+        run.finish()
+
+    def test_manifest_multiple_output_types(self, tmp_path):
+        run = euler_train.init(dir=str(tmp_path / "r"), config={})
+        img = np.zeros((4, 4, 3), dtype=np.uint8)
+        dep = np.ones((4, 4), dtype=np.float32)
+        run.save_outputs(epoch=0, step=0, rgb=dict(pred=img), depth=dict(pred=dep))
+
+        m = _read_json(run.dir / "outputs" / "epoch_0_step_0" / "manifest.json")
+        assert m["output_types"]["rgb"]["pred"]["files"][0]["format"] == "png"
+        assert m["output_types"]["depth"]["pred"]["files"][0]["format"] == "npy"
+        run.finish()
+
+
 # ═══════════════════════════════════════════════════════════════════════════
 #  init_checkpoint_dir
 # ═══════════════════════════════════════════════════════════════════════════
@@ -1730,14 +1922,13 @@ class TestStreaming:
         assert "elapsed_sec" not in val_event["records"][0]
 
         snapshot_event = consumer.events[5]
-        assert snapshot_event["snapshot"] == {
-            "epoch": 0,
-            "step": 1,
-            "types": {
-                "depth": ["aux/transmission"],
-                "rgb": ["gt", "pred"],
-            },
-        }
+        snapshot = snapshot_event["snapshot"]
+        assert snapshot["version"] == 1
+        assert snapshot["epoch"] == 0
+        assert snapshot["step"] == 1
+        assert set(snapshot["output_types"]) == {"rgb", "depth"}
+        assert set(snapshot["output_types"]["rgb"]) == {"pred", "gt"}
+        assert "aux/transmission" in snapshot["output_types"]["depth"]
 
         checkpoint_event = consumer.events[6]
         assert checkpoint_event["checkpoint"] == {