BUG: re-raise KeyboardInterrupt after an interrupted Monte Carlo run

simulate() returned normally after Ctrl-C. Both execution modes caught the
interrupt and neither re-raised it, so simulate() went on to
__terminate_simulation() and returned exactly as it does after a complete
study. A caller could not tell a partial run from a finished one without
opening the output file and counting rows.

__run_in_serial also appended inputs_json to the error file with that name
bound inside the loop body, so Ctrl-C during the first keep_simulating()
call reached the handler with nothing bound and the run died with
UnboundLocalError from inside the cleanup.

Bind inputs_json before the loop and re-raise in both handlers. The
parallel handler already signalled and joined the workers for both failure
kinds; only the re-raise was conditional, so a bare raise covers both and
drops the raise-error rebinding.

Catch the interrupt in simulate() so __terminate_simulation() still runs
before it leaves. That call reloads the logs through the file setters, and
set_num_of_loaded_sims is what the documented append=True continuation
reads; re-raising past it would leave the object disagreeing with its own
files. The ordinary exception path is unchanged.

Add six regression tests covering both modes, the early interrupt, the
preserved rows, the reload, and an interrupted run continued with
append=True. They run the real __terminate_simulation rather than a stub,
so they assert the state the reload produces instead of the fact that it
was called. The parallel one drives __run_in_parallel over stubs for
_import_multiprocess and _create_multiprocess_manager, so it starts no
processes and stays deterministic in the default suite.

Author: ting-hong-shieh

monte_carlo_test.errors.txt

@@ -300,6 +300,13 @@ def simulate(
         -------
         None
 
+        Raises
+        ------
+        KeyboardInterrupt
+            If the run is interrupted. The completed simulations are saved and
+            loaded first, then the interrupt is re-raised so that the caller can
+            tell a partial run from a complete one.
+
         Notes
         -----
         If you need to stop the simulations after starting them, you can
@@ -327,10 +334,19 @@ def simulate(
 
         self.__setup_files(append)
 
-        if parallel:
-            self.__run_in_parallel(n_workers)
-        else:
-            self.__run_in_serial()
+        try:
+            if parallel:
+                self.__run_in_parallel(n_workers)
+            else:
+                self.__run_in_serial()
+        except KeyboardInterrupt:
+            # The rows that finished are already on disk. Load them before
+            # leaving, so this object agrees with the files and the documented
+            # append=True path can continue from them, then let the interrupt
+            # reach the caller rather than returning as though every requested
+            # simulation had run.
+            self.__terminate_simulation()
+            raise
 
         self.__terminate_simulation()
 
@@ -413,6 +429,9 @@ def __run_in_serial(self):
             n_simulations=self.number_of_simulations,
             start_time=time(),
         )
+        # Bound before the loop: Ctrl-C during the first keep_simulating() or
+        # increment() call reaches the handler below, which reads this name.
+        inputs_json = ""
         try:
             while sim_monitor.keep_simulating():
                 sim_monitor.increment()
@@ -432,6 +451,8 @@ def __run_in_serial(self):
             print("Keyboard interrupt received. Files saved.")
             with open(self._error_file, "a", encoding="utf-8") as f:
                 f.write(inputs_json)
+            # Bare, so the handler's own line does not join the traceback.
+            raise
 
         except Exception as error:
             print(f"Error on iteration {sim_monitor.count}: {error}")
@@ -499,15 +520,17 @@ def __run_in_parallel(self, n_workers=None):
                 sim_monitor.print_final_status()
 
             # Handle error from the main process
-            # pylint: disable=broad-except
-            except (Exception, KeyboardInterrupt) as error:
+            except (Exception, KeyboardInterrupt):
                 simulation_error_event.set()
 
                 for sim_producer in processes:
                     sim_producer.join()
 
-                if not isinstance(error, KeyboardInterrupt):
-                    raise error
+                # Ctrl-C is re-raised alongside the other failures now that the
+                # workers have been signalled and joined. Swallowing it left
+                # simulate() returning as though the run had completed.
+                # Bare, so the handler's own line does not join the traceback.
+                raise
 
     def __validate_number_of_workers(self, n_workers):
         if n_workers is None or n_workers > os.cpu_count():

monte_carlo_test.inputs.txt

@@ -12,6 +12,7 @@
 import pytest
 
 from rocketpy.simulation import MonteCarlo
+from rocketpy.simulation import monte_carlo as mc_module
 from rocketpy.simulation.monte_carlo import (
     _refuse_logs_this_run_cannot_write,
 )
@@ -789,3 +790,230 @@ def test_two_names_for_a_file_that_does_not_exist_yet_are_still_one_file(tmp_pat
     assert not pathlib.Path(missing).exists()
     with pytest.raises(ValueError, match="same file"):
         _refuse_logs_this_run_cannot_write(missing, same_by_another_name, errors)
+
+
+class _InterruptingMonteCarlo(MonteCarlo):
+    """A MonteCarlo that raises ``KeyboardInterrupt`` where Ctrl-C would land.
+
+    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.
+    """
+
+    # pylint: disable=super-init-not-called,invalid-name,unused-argument
+
+    def __init__(self, filename, interrupt_after):
+        self.filename = filename
+        self._input_file = filename + ".inputs.txt"
+        self._output_file = filename + ".outputs.txt"
+        self._error_file = filename + ".errors.txt"
+        self.num_of_loaded_sims = 0
+        self.number_of_simulations = 0
+        self._export_config = {}
+        self._initial_sim_idx = 0
+        self.interrupt_after = interrupt_after
+        self.completed = 0
+
+    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"
+
+    def _MonteCarlo__evaluate_flight_outputs(self, flight, index):
+        return json.dumps({"index": index, "apogee": 1000.0 + index}) + "\n"
+
+
+def test_interrupted_serial_run_reaches_the_caller(tmp_path):
+    """``simulate`` used to return normally after Ctrl-C.
+
+    A caller could not tell a partial run from a complete one without opening
+    the output file and counting rows.
+    """
+    mc = _InterruptingMonteCarlo(str(tmp_path / "run"), interrupt_after=2)
+
+    with pytest.raises(KeyboardInterrupt):
+        mc.simulate(number_of_simulations=10, parallel=False)
+
+
+def test_interrupted_serial_run_keeps_the_rows_that_finished(tmp_path):
+    """The two simulations that completed stay readable and paired."""
+    mc = _InterruptingMonteCarlo(str(tmp_path / "run"), interrupt_after=2)
+
+    with pytest.raises(KeyboardInterrupt):
+        mc.simulate(number_of_simulations=10, parallel=False)
+
+    inputs = (tmp_path / "run.inputs.txt").read_text(encoding="utf-8").splitlines()
+    outputs = (tmp_path / "run.outputs.txt").read_text(encoding="utf-8").splitlines()
+
+    assert len(inputs) == 2
+    assert len(outputs) == 2
+    assert [json.loads(row)["index"] for row in inputs] == [
+        json.loads(row)["index"] for row in outputs
+    ]
+
+
+def test_interrupted_serial_run_still_reloads_the_logs(tmp_path):
+    """``__terminate_simulation`` runs before the interrupt leaves ``simulate``.
+
+    It is what reloads the logs through the file setters. Asserting on the
+    state those setters produce, rather than on the call, is what shows the
+    reload actually happened.
+    """
+    mc = _InterruptingMonteCarlo(str(tmp_path / "run"), interrupt_after=2)
+
+    with pytest.raises(KeyboardInterrupt):
+        mc.simulate(number_of_simulations=10, parallel=False)
+
+    assert mc.num_of_loaded_sims == 2
+    assert len(mc.inputs_log) == 2
+    assert len(mc.outputs_log) == 2
+    assert mc.results["apogee"] == [1001.0, 1002.0]
+
+
+def test_an_interrupted_run_can_be_continued_with_append(tmp_path):
+    """The behavior the ``simulate`` docstring promises after an interrupt.
+
+    ``set_num_of_loaded_sims`` is what ``append=True`` reads to decide where to
+    resume, and it is only set by the reload above. This runs the whole path:
+    interrupt, then continue, and check the indices on disk have no gap and no
+    repeat.
+    """
+    stem = str(tmp_path / "run")
+    mc = _InterruptingMonteCarlo(stem, interrupt_after=2)
+
+    with pytest.raises(KeyboardInterrupt):
+        mc.simulate(number_of_simulations=10, parallel=False)
+
+    mc.interrupt_after = 10
+    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))
+
+
+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
+    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)
+    mc = _InterruptingMonteCarlo(str(tmp_path / "run"), interrupt_after=0)
+
+    with pytest.raises(KeyboardInterrupt):
+        mc.simulate(number_of_simulations=5, parallel=False)
+
+
+class _FakeWorker:
+    """Stands in for a ``multiprocess.Process`` without starting anything."""
+
+    def __init__(self, interrupt_on_first_join=False):
+        self.starts = 0
+        self.joins = 0
+        self._interrupt_on_first_join = interrupt_on_first_join
+
+    def start(self):
+        self.starts += 1
+
+    def join(self):
+        self.joins += 1
+        if self._interrupt_on_first_join and self.joins == 1:
+            raise KeyboardInterrupt("ctrl-c while waiting for the workers")
+
+
+class _FakeManager:
+    """The subset of the multiprocess manager that ``__run_in_parallel`` uses."""
+
+    # pylint: disable=invalid-name
+
+    def __init__(self):
+        self.event = _FakeEvent()
+        self.monitor = _FakeSimMonitor()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_exc):
+        return False
+
+    def Lock(self):
+        return object()
+
+    def Event(self):
+        return self.event
+
+    def _SimMonitor(self, **_kwargs):
+        return self.monitor
+
+
+class _FakeEvent:
+    def __init__(self):
+        self._set = False
+
+    def set(self):
+        self._set = True
+
+    def is_set(self):
+        return self._set
+
+
+class _FakeSimMonitor:
+    def __init__(self, **_kwargs):
+        self.final_status_calls = 0
+
+    def print_final_status(self):
+        self.final_status_calls += 1
+
+
+def test_interrupted_parallel_run_signals_joins_and_reaches_the_caller(
+    tmp_path, monkeypatch
+):
+    """Ctrl-C while waiting on the workers must not end as a successful run.
+
+    The handler already signalled and joined the workers, but it then swallowed
+    the interrupt, so ``simulate`` went on to report the study as finished.
+    """
+    manager = _FakeManager()
+    workers = []
+
+    class _FakeMultiprocess:
+        # pylint: disable=invalid-name
+        @staticmethod
+        def Process(target=None, args=()):  # pylint: disable=unused-argument
+            worker = _FakeWorker(interrupt_on_first_join=not workers)
+            workers.append(worker)
+            return worker
+
+    monkeypatch.setattr(
+        mc_module, "_import_multiprocess", lambda: (_FakeMultiprocess, None)
+    )
+    monkeypatch.setattr(
+        mc_module, "_create_multiprocess_manager", lambda *_args: manager
+    )
+    mc = _InterruptingMonteCarlo(str(tmp_path / "run"), interrupt_after=0)
+
+    with pytest.raises(KeyboardInterrupt):
+        mc.simulate(number_of_simulations=4, parallel=True, n_workers=2)
+
+    assert len(workers) == 2
+    assert all(worker.starts == 1 for worker in workers)
+    assert manager.event.is_set(), "the workers were never told to stop"
+    assert workers[0].joins == 2, (
+        "the interrupted join was not retried after signalling"
+    )
+    assert workers[1].joins == 1, "the second worker was never joined"
+    assert manager.monitor.final_status_calls == 0, "a partial run reported completion"
+    # __init__ above never sets inputs_log; only the reload in
+    # __terminate_simulation does, so its presence is what shows it ran.
+    assert hasattr(mc, "inputs_log"), "the reload did not run on the interrupted path"