Use type+index matching for checkpoints instead of UUIDs

milanofthe · milanofthe · commit 0f6a970f43da · 2026-03-17T09:20:36.000+01:00
diff --git a/src/pathsim/blocks/_block.py b/src/pathsim/blocks/_block.py
@@ -530,11 +530,13 @@ def state(self, val):
 
     # checkpoint methods ----------------------------------------------------------------
 
-    def to_checkpoint(self, recordings=False):
+    def to_checkpoint(self, prefix, recordings=False):
         """Serialize block state for checkpointing.
 
         Parameters
         ----------
+        prefix : str
+            key prefix for NPZ arrays (assigned by simulation)
         recordings : bool
             include recording data (for Scope blocks)
 
@@ -545,10 +547,7 @@ def to_checkpoint(self, recordings=False):
         npz_data : dict
             numpy arrays keyed by path
         """
-        prefix = self.id
-
         json_data = {
-            "id": self.id,
             "type": self.__class__.__name__,
             "active": self._active,
         }
@@ -567,27 +566,28 @@ def to_checkpoint(self, recordings=False):
         #internal events
         if self.events:
             evt_jsons = []
-            for event in self.events:
-                e_json, e_npz = event.to_checkpoint()
+            for i, event in enumerate(self.events):
+                evt_prefix = f"{prefix}/evt_{i}"
+                e_json, e_npz = event.to_checkpoint(evt_prefix)
                 evt_jsons.append(e_json)
                 npz_data.update(e_npz)
             json_data["events"] = evt_jsons
 
         return json_data, npz_data
 
 
-    def load_checkpoint(self, json_data, npz):
+    def load_checkpoint(self, prefix, json_data, npz):
         """Restore block state from checkpoint.
 
         Parameters
         ----------
+        prefix : str
+            key prefix for NPZ arrays (assigned by simulation)
         json_data : dict
             block metadata from checkpoint JSON
         npz : dict-like
             numpy arrays from checkpoint NPZ
         """
-        prefix = json_data["id"]
-
         #verify type
         if json_data["type"] != self.__class__.__name__:
             raise ValueError(
@@ -611,8 +611,8 @@ def load_checkpoint(self, json_data, npz):
 
         #restore internal events
         if self.events and "events" in json_data:
-            for event, evt_data in zip(self.events, json_data["events"]):
-                event.load_checkpoint(evt_data, npz)
+            for i, (event, evt_data) in enumerate(zip(self.events, json_data["events"])):
+                event.load_checkpoint(f"{prefix}/evt_{i}", evt_data, npz)
 
 
     # methods for block output and state updates ----------------------------------------
diff --git a/src/pathsim/blocks/delay.py b/src/pathsim/blocks/delay.py
@@ -142,10 +142,9 @@ def reset(self):
             self._ring.extend([0.0] * self._n)
 
 
-    def to_checkpoint(self, recordings=False):
+    def to_checkpoint(self, prefix, recordings=False):
         """Serialize Delay state including buffer data."""
-        json_data, npz_data = super().to_checkpoint(recordings=recordings)
-        prefix = self.id
+        json_data, npz_data = super().to_checkpoint(prefix, recordings=recordings)
 
         json_data["sampling_period"] = self.sampling_period
 
@@ -160,10 +159,9 @@ def to_checkpoint(self, recordings=False):
         return json_data, npz_data
 
 
-    def load_checkpoint(self, json_data, npz):
+    def load_checkpoint(self, prefix, json_data, npz):
         """Restore Delay state including buffer data."""
-        super().load_checkpoint(json_data, npz)
-        prefix = json_data["id"]
+        super().load_checkpoint(prefix, json_data, npz)
 
         if self.sampling_period is None:
             #continuous mode
diff --git a/src/pathsim/blocks/scope.py b/src/pathsim/blocks/scope.py
@@ -448,10 +448,9 @@ def save(self, path="scope.csv"):
                 wrt.writerow(sample)
 
 
-    def to_checkpoint(self, recordings=False):
+    def to_checkpoint(self, prefix, recordings=False):
         """Serialize Scope state including optional recording data."""
-        json_data, npz_data = super().to_checkpoint(recordings=recordings)
-        prefix = self.id
+        json_data, npz_data = super().to_checkpoint(prefix, recordings=recordings)
 
         json_data["_incremental_idx"] = self._incremental_idx
         if hasattr(self, '_sample_next_timestep'):
@@ -464,10 +463,9 @@ def to_checkpoint(self, recordings=False):
         return json_data, npz_data
 
 
-    def load_checkpoint(self, json_data, npz):
+    def load_checkpoint(self, prefix, json_data, npz):
         """Restore Scope state including optional recording data."""
-        super().load_checkpoint(json_data, npz)
-        prefix = json_data["id"]
+        super().load_checkpoint(prefix, json_data, npz)
 
         self._incremental_idx = json_data.get("_incremental_idx", 0)
         if hasattr(self, '_sample_next_timestep'):
@@ -479,9 +477,6 @@ def load_checkpoint(self, json_data, npz):
         if rt_key in npz and rd_key in npz:
             self.recording_time = npz[rt_key].tolist()
             self.recording_data = [row for row in npz[rd_key]]
-        else:
-            self.recording_time = []
-            self.recording_data = []
 
 
     def update(self, t):
diff --git a/src/pathsim/blocks/spectrum.py b/src/pathsim/blocks/spectrum.py
@@ -283,19 +283,19 @@ def step(self, t, dt):
         return True, 0.0, None
 
 
-    def to_checkpoint(self, recordings=False):
+    def to_checkpoint(self, prefix, recordings=False):
         """Serialize Spectrum state including integration time."""
-        json_data, npz_data = super().to_checkpoint(recordings=recordings)
+        json_data, npz_data = super().to_checkpoint(prefix, recordings=recordings)
 
         json_data["time"] = self.time
         json_data["t_sample"] = self.t_sample
 
         return json_data, npz_data
 
 
-    def load_checkpoint(self, json_data, npz):
+    def load_checkpoint(self, prefix, json_data, npz):
         """Restore Spectrum state including integration time."""
-        super().load_checkpoint(json_data, npz)
+        super().load_checkpoint(prefix, json_data, npz)
 
         self.time = json_data.get("time", 0.0)
         self.t_sample = json_data.get("t_sample", 0.0)
diff --git a/src/pathsim/blocks/switch.py b/src/pathsim/blocks/switch.py
@@ -82,13 +82,13 @@ def select(self, switch_state=0):
         self.switch_state = switch_state
 
 
-    def to_checkpoint(self, recordings=False):
-        json_data, npz_data = super().to_checkpoint(recordings=recordings)
+    def to_checkpoint(self, prefix, recordings=False):
+        json_data, npz_data = super().to_checkpoint(prefix, recordings=recordings)
         json_data["switch_state"] = self.switch_state
         return json_data, npz_data
 
-    def load_checkpoint(self, json_data, npz):
-        super().load_checkpoint(json_data, npz)
+    def load_checkpoint(self, prefix, json_data, npz):
+        super().load_checkpoint(prefix, json_data, npz)
         self.switch_state = json_data.get("switch_state", None)
 
     def update(self, t):
diff --git a/src/pathsim/events/_event.py b/src/pathsim/events/_event.py
@@ -211,25 +211,27 @@ def resolve(self, t):
 
     # checkpoint methods ----------------------------------------------------------------
 
-    def to_checkpoint(self):
+    def to_checkpoint(self, prefix):
         """Serialize event state for checkpointing.
 
+        Parameters
+        ----------
+        prefix : str
+            key prefix for NPZ arrays (assigned by simulation)
+
         Returns
         -------
         json_data : dict
             JSON-serializable metadata
         npz_data : dict
             numpy arrays keyed by path
         """
-        prefix = self.id
-
         #extract history eval value
         hist_eval, hist_time = self._history
         if hist_eval is not None and hasattr(hist_eval, 'item'):
             hist_eval = float(hist_eval)
 
         json_data = {
-            "id": self.id,
             "type": self.__class__.__name__,
             "active": self._active,
             "history_eval": hist_eval,
@@ -243,18 +245,18 @@ def to_checkpoint(self):
         return json_data, npz_data
 
 
-    def load_checkpoint(self, json_data, npz):
+    def load_checkpoint(self, prefix, json_data, npz):
         """Restore event state from checkpoint.
 
         Parameters
         ----------
+        prefix : str
+            key prefix for NPZ arrays (assigned by simulation)
         json_data : dict
             event metadata from checkpoint JSON
         npz : dict-like
             numpy arrays from checkpoint NPZ
         """
-        prefix = json_data["id"]
-
         self._active = json_data["active"]
         self._history = json_data["history_eval"], json_data["history_time"]
 
diff --git a/src/pathsim/simulation.py b/src/pathsim/simulation.py
@@ -338,11 +338,34 @@ def plot(self, *args, **kwargs):
 
     # checkpoint methods ----------------------------------------------------------
 
+    @staticmethod
+    def _checkpoint_key(type_name, type_counts):
+        """Generate a deterministic checkpoint key from block/event type
+        and occurrence index (e.g. 'Integrator_0', 'Scope_1').
+
+        Parameters
+        ----------
+        type_name : str
+            class name of the block or event
+        type_counts : dict
+            running counter per type name, mutated in place
+
+        Returns
+        -------
+        key : str
+            deterministic checkpoint key
+        """
+        idx = type_counts.get(type_name, 0)
+        type_counts[type_name] = idx + 1
+        return f"{type_name}_{idx}"
+
+
     def save_checkpoint(self, path, recordings=False):
         """Save simulation state to checkpoint files (JSON + NPZ).
 
         Creates two files: {path}.json (structure/metadata) and
-        {path}.npz (numerical data).
+        {path}.npz (numerical data). Blocks and events are keyed by
+        type and insertion order for deterministic cross-instance matching.
 
         Parameters
         ----------
@@ -371,22 +394,28 @@ def save_checkpoint(self, path, recordings=False):
                 "tolerance_fpi": self.tolerance_fpi,
                 "iterations_max": self.iterations_max,
             },
-            "blocks": {},
-            "events": {},
+            "blocks": [],
+            "events": [],
         }
 
         npz_data = {}
 
-        #checkpoint all blocks (keyed by UUID)
+        #checkpoint all blocks (keyed by type + insertion index)
+        type_counts = {}
         for block in self.blocks:
-            b_json, b_npz = block.to_checkpoint(recordings=recordings)
-            checkpoint["blocks"][block.id] = b_json
+            key = self._checkpoint_key(block.__class__.__name__, type_counts)
+            b_json, b_npz = block.to_checkpoint(key, recordings=recordings)
+            b_json["_key"] = key
+            checkpoint["blocks"].append(b_json)
             npz_data.update(b_npz)
 
-        #checkpoint external events (keyed by UUID)
+        #checkpoint external events (keyed by type + insertion index)
+        type_counts = {}
         for event in self.events:
-            e_json, e_npz = event.to_checkpoint()
-            checkpoint["events"][event.id] = e_json
+            key = self._checkpoint_key(event.__class__.__name__, type_counts)
+            e_json, e_npz = event.to_checkpoint(key)
+            e_json["_key"] = key
+            checkpoint["events"].append(e_json)
             npz_data.update(e_npz)
 
         #write files
@@ -400,8 +429,9 @@ def load_checkpoint(self, path):
         """Load simulation state from checkpoint files (JSON + NPZ).
 
         Restores simulation time and all block/event states from a
-        previously saved checkpoint. The simulation must have the same
-        blocks and events as when the checkpoint was saved.
+        previously saved checkpoint. Matching is based on block/event
+        type and insertion order, so the simulation must be constructed
+        with the same block types in the same order.
 
         Parameters
         ----------
@@ -444,26 +474,32 @@ def load_checkpoint(self, path):
                     f"current solver '{self.Solver.__name__}'"
                 )
 
-            #restore blocks
-            block_data = checkpoint.get("blocks", {})
+            #index checkpoint blocks by key
+            block_data = {b["_key"]: b for b in checkpoint.get("blocks", [])}
+
+            #restore blocks by type + insertion order
+            type_counts = {}
             for block in self.blocks:
-                if block.id in block_data:
-                    block.load_checkpoint(block_data[block.id], npz)
+                key = self._checkpoint_key(block.__class__.__name__, type_counts)
+                if key in block_data:
+                    block.load_checkpoint(key, block_data[key], npz)
                 else:
                     warnings.warn(
-                        f"Block {block.__class__.__name__} (id={block.id[:8]}...) "
-                        f"not found in checkpoint"
+                        f"Block '{key}' not found in checkpoint"
                     )
 
-            #restore external events
-            event_data = checkpoint.get("events", {})
+            #index checkpoint events by key
+            event_data = {e["_key"]: e for e in checkpoint.get("events", [])}
+
+            #restore external events by type + insertion order
+            type_counts = {}
             for event in self.events:
-                if event.id in event_data:
-                    event.load_checkpoint(event_data[event.id], npz)
+                key = self._checkpoint_key(event.__class__.__name__, type_counts)
+                if key in event_data:
+                    event.load_checkpoint(key, event_data[key], npz)
                 else:
                     warnings.warn(
-                        f"Event {event.__class__.__name__} (id={event.id[:8]}...) "
-                        f"not found in checkpoint"
+                        f"Event '{key}' not found in checkpoint"
                     )
 
         finally:
diff --git a/tests/pathsim/test_checkpoint.py b/tests/pathsim/test_checkpoint.py
