TST: carry #1177's interrupt tests onto the reseeded serial loop

The rebase onto develop was clean in three files and left one add/add
conflict in __run_in_serial: both sides bind a name before the try so the
handlers cannot meet it unbound. #1177 binds inputs_json for the
KeyboardInterrupt handler, this branch binds sim_idx for the Exception one.
Both are kept; dropping either puts back the UnboundLocalError the other
side had just removed.

Keeping both then pushed the function to 27 statements, two over
max-statements, so the error-file append the two handlers had copies of
moved into __record_failed_inputs. The guard travels with it: the error
file is created in __setup_files, so appending "" to it was already a
no-op, and the unconditional copy and the guarded one did the same thing.

What the merge could not show is that #1177's tests were written against
the loop this branch replaces:

- _InterruptingMonteCarlo stubs only what __run_in_serial touched, and the
  loop now also calls __seed_this_simulation, which reads models the double
  has none of. Stubbed, like the other name-mangled members; seeding is
  pinned by test_monte_carlo_seeding.py.
- Its rows carried no run_root, so the append test tripped the guard for
  studies written before that check existed instead of exercising the
  continuation. The double now writes the root the way the real row
  builders do, the inputs file whole and the outputs file by digest.
- _SimMonitor.keep_simulating is now claim_next_index, and one test
  monkeypatches it by name.
- Serial numbering now starts at zero, as the parallel path always did, so
  the three tests reading indices off disk expected 1, 2, 3 where a run
  writes 0, 1, 2.

tests/unit/simulation: 322 passed, 8 skipped. ruff clean, pylint 10.00.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Gui-FernandesBR

rocketpy/simulation/monte_carlo.py

@@ -656,6 +656,28 @@ def _append_simulation_record(self, inputs_json, outputs_json):
                 f.truncate(previous_output_size)
             raise
 
+    def __record_failed_inputs(self, inputs_json):
+        """
+        Appends an unpaired inputs row to the error file, if there is one.
+
+        A row reaches here when the simulation it belongs to was cut short
+        between the inputs being evaluated and the record being appended, so
+        it has no matching outputs row and cannot go to the inputs file.
+
+        Parameters
+        ----------
+        inputs_json : str
+            Serialized inputs row, or an empty string when the run was cut
+            short with no row in hand.
+
+        Returns
+        -------
+        None
+        """
+        if inputs_json:
+            with open(self._error_file, "a", encoding="utf-8") as f:
+                f.write(inputs_json)
+
     def __run_in_serial(self):
         """
         Runs the monte carlo simulation in serial mode.
@@ -692,15 +714,12 @@ def __run_in_serial(self):
 
         except KeyboardInterrupt:
             print("Keyboard interrupt received. Files saved.")
-            if inputs_json:
-                with open(self._error_file, "a", encoding="utf-8") as f:
-                    f.write(inputs_json)
+            self.__record_failed_inputs(inputs_json)
             raise
 
         except Exception as error:
             print(f"Error on iteration {sim_idx}: {error}")
-            with open(self._error_file, "a", encoding="utf-8") as f:
-                f.write(inputs_json)
+            self.__record_failed_inputs(inputs_json)
             raise error
 
     def __run_in_parallel(self, n_workers=None):

tests/unit/simulation/test_monte_carlo.py

@@ -797,7 +797,9 @@ class _InterruptingMonteCarlo(MonteCarlo):
 
     Only the attributes ``simulate`` and ``__run_in_serial`` touch are set, so no
     stochastic object graph or real flight is needed. The name-mangled overrides
-    stand in for the members ``MonteCarlo`` calls on itself.
+    stand in for the members ``MonteCarlo`` calls on itself, seeding included:
+    there are no models here to reseed, and what a seeded run draws is pinned
+    by ``tests/unit/simulation/test_monte_carlo_seeding.py``.
     """
 
     # pylint: disable=super-init-not-called,invalid-name,unused-argument
@@ -814,17 +816,46 @@ def __init__(self, filename, interrupt_after):
         self.interrupt_after = interrupt_after
         self.completed = 0
 
+    def _MonteCarlo__seed_this_simulation(self, sim_idx):
+        pass
+
     def _MonteCarlo__run_single_simulation(self):
         if self.completed >= self.interrupt_after:
             raise KeyboardInterrupt("ctrl-c")
         self.completed += 1
         return object()
 
     def _MonteCarlo__evaluate_flight_inputs(self, index):
-        return json.dumps({"index": index}) + "\n"
+        # The root goes in because an append reads it back to check the rows
+        # it is continuing were drawn by the same stream; a row without it is
+        # what a study written before that check looks like, and is refused.
+        return (
+            json.dumps(
+                {
+                    "index": index,
+                    mc_module._SIMULATION_ROOT_KEY: (
+                        mc_module._root_written_into_a_row(self._MonteCarlo__root_state)
+                    ),
+                }
+            )
+            + "\n"
+        )
 
     def _MonteCarlo__evaluate_flight_outputs(self, flight, index):
-        return json.dumps({"index": index, "apogee": 1000.0 + index}) + "\n"
+        # The outputs rows name the same root by its digest, which is what
+        # an append checks them against.
+        return (
+            json.dumps(
+                {
+                    "index": index,
+                    "apogee": 1000.0 + index,
+                    mc_module._SIMULATION_ROOT_KEY: mc_module._root_digest(
+                        mc_module._root_written_into_a_row(self._MonteCarlo__root_state)
+                    ),
+                }
+            )
+            + "\n"
+        )
 
 
 def test_interrupted_serial_run_reaches_the_caller(tmp_path):
@@ -871,7 +902,7 @@ def test_interrupted_serial_run_still_reloads_the_logs(tmp_path):
     assert mc.num_of_loaded_sims == 2
     assert len(mc.inputs_log) == 2
     assert len(mc.outputs_log) == 2
-    assert mc.results["apogee"] == pytest.approx([1001.0, 1002.0])
+    assert mc.results["apogee"] == pytest.approx([1000.0, 1001.0])
 
 
 def test_an_interrupted_run_can_be_continued_with_append(tmp_path):
@@ -892,23 +923,23 @@ def test_an_interrupted_run_can_be_continued_with_append(tmp_path):
     mc.simulate(number_of_simulations=10, append=True, parallel=False)
 
     rows = pathlib.Path(stem + ".outputs.txt").read_text(encoding="utf-8").splitlines()
-    assert [json.loads(row)["index"] for row in rows] == list(range(1, 11))
+    assert [json.loads(row)["index"] for row in rows] == list(range(10))
 
 
 def test_ctrl_c_before_the_first_simulation_is_still_the_interrupt(
     tmp_path, monkeypatch
 ):
     """The handler appends ``inputs_json``, which used to be unbound this early.
 
-    Ctrl-C during the first ``keep_simulating()`` call reached the handler
+    Ctrl-C during the first ``claim_next_index()`` call reached the handler
     before the loop body had bound the name, so the run died with
     ``UnboundLocalError`` from inside the cleanup instead of with the interrupt.
     """
 
     def interrupt(self):
         raise KeyboardInterrupt("ctrl-c before the first simulation")
 
-    monkeypatch.setattr(mc_module._SimMonitor, "keep_simulating", interrupt)
+    monkeypatch.setattr(mc_module._SimMonitor, "claim_next_index", interrupt)
     mc = _InterruptingMonteCarlo(str(tmp_path / "run"), interrupt_after=0)
 
     with pytest.raises(KeyboardInterrupt):
@@ -1131,7 +1162,7 @@ def interrupt_third_outputs_append(*args, **kwargs):
     ]
     # The simulation that was cut short is recorded where errors go, so the
     # rolled-back row is preserved rather than lost.
-    assert [json.loads(row)["index"] for row in errors] == [3]
+    assert [json.loads(row)["index"] for row in errors] == [2]
     assert mc.num_of_loaded_sims == 2
 
 
@@ -1141,7 +1172,7 @@ def test_ctrl_c_in_the_progress_print_leaves_the_error_file_empty(tmp_path):
     After ``_append_simulation_record`` returns, the pair is on disk. The
     handler used to write ``inputs_json`` to the error file anyway when the
     interrupt landed in ``print_update_status()`` — or in the next
-    ``keep_simulating()`` call — because the name still held the committed row.
+    ``claim_next_index()`` call — because the name still held the committed row.
     """
     stem = str(tmp_path / "run")
     mc = _InterruptingMonteCarlo(stem, interrupt_after=10)
@@ -1226,5 +1257,5 @@ def torn_third_outputs_append(*args, **kwargs):
     assert len(outputs) == 2, "the torn outputs row was not rolled back"
     for row in inputs + outputs:
         json.loads(row)  # every surviving row must still parse
-    assert [json.loads(row)["index"] for row in errors] == [3]
+    assert [json.loads(row)["index"] for row in errors] == [2]
     assert mc.num_of_loaded_sims == 2