BUG: re-raise KeyboardInterrupt after an interrupted Monte Carlo run (#1177)

* 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.

Five more holes sat next to that one, found in review and in the
interrupt-point audit it prompted:

- __run_in_serial bound inputs_json 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.
- It also never cleared inputs_json after a successful append, so Ctrl-C
  landing in the progress print — or in the next keep_simulating() call —
  wrote the row that had just committed into the error file as though it
  never finished.
- _append_simulation_record rolled back on Exception, and
  KeyboardInterrupt does not derive from Exception, so Ctrl-C between the
  two appends left a one-sided record.
- Its rollback also only truncated the inputs file, so an interrupt inside
  either write left a torn partial row for the reload to die on with
  JSONDecodeError instead of the interrupt.
- The parallel cleanup began only after every worker had started, so
  Ctrl-C during the startup loop left the already-started workers running
  with nobody signalling or joining them.

Bind inputs_json before the loop and clear it after each committed append,
roll both files back on BaseException best-effort, cover the startup loop
with the same cleanup path over a started-workers list, and re-raise in
both handlers. Catch the interrupt in simulate() so
__terminate_simulation() still runs before it leaves: it reloads the logs
through the file setters, and set_num_of_loaded_sims is what the
documented append=True continuation reads.

The shutdown join stays unbounded, and the docstring now says so: the
interrupt propagates once every worker finishes the simulation it is in
and exits on its own. A worker stuck inside one simulation blocks the
interrupt as it already blocked the run; killing it here could tear a
half-written row into logs it holds the mutex for, and the bounded fleet
shutdown belongs to #1054. The ordinary exception path is unchanged.

Add ten regression tests covering both modes, the early interrupt, the
preserved rows, the reload, an interrupted run continued with append=True,
the between-appends rollback, the torn-write rollback, the committed row
staying out of the error file, and the startup-loop cleanup. They run the
real __terminate_simulation and assert the state it produces; all fail on
develop, and each fix was also reverted individually with only its own
test failing.

* BUG: preserve interrupted Monte Carlo cleanup

---------

Co-authored-by: Gui-FernandesBR <guilherme_fernandes@usp.br>

Author: ting-hong-shieh

rocketpy/simulation/monte_carlo.py

@@ -321,6 +321,11 @@ def simulate(
             that reports a failure, and logs that do not hold every simulation
             asked for are each refused, since a run that lost work must not be
             reported as one that completed.
+        KeyboardInterrupt
+            If the run is interrupted. The logs written so far are kept and
+            reloaded first, so the object agrees with its own files and the
+            run can be continued with ``append=True``, but the interrupt then
+            reaches the caller rather than being reported as a finished study.
 
         Notes
         -----
@@ -349,12 +354,13 @@ def simulate(
 
         self.__setup_files(append)
 
-        if parallel:
-            self.__run_in_parallel(n_workers)
-        else:
-            self.__run_in_serial()
-
-        self.__terminate_simulation()
+        try:
+            if parallel:
+                self.__run_in_parallel(n_workers)
+            else:
+                self.__run_in_serial()
+        finally:
+            self.__terminate_simulation()
 
     def __setup_files(self, append):
         """
@@ -410,16 +416,22 @@ def _append_simulation_record(self, inputs_json, outputs_json):
             previous_input_size = os.path.getsize(input_path)
         except OSError:
             previous_input_size = 0
+        try:
+            previous_output_size = os.path.getsize(output_path)
+        except OSError:
+            previous_output_size = 0
 
         with open(input_path, "a", encoding="utf-8") as f:
             f.write(inputs_json)
 
         try:
             with open(output_path, "a", encoding="utf-8") as f:
                 f.write(outputs_json)
-        except Exception:
+        except BaseException:
             with open(input_path, "rb+") as f:
                 f.truncate(previous_input_size)
+            with open(output_path, "rb+") as f:
+                f.truncate(previous_output_size)
             raise
 
     def __run_in_serial(self):
@@ -435,6 +447,7 @@ def __run_in_serial(self):
             n_simulations=self.number_of_simulations,
             start_time=time(),
         )
+        inputs_json = ""
         try:
             while sim_monitor.keep_simulating():
                 sim_monitor.increment()
@@ -445,15 +458,18 @@ def __run_in_serial(self):
                 outputs_json = self.__evaluate_flight_outputs(flight, sim_monitor.count)
 
                 self._append_simulation_record(inputs_json, outputs_json)
+                inputs_json = ""
 
                 sim_monitor.print_update_status()
 
             sim_monitor.print_final_status()
 
         except KeyboardInterrupt:
             print("Keyboard interrupt received. Files saved.")
-            with open(self._error_file, "a", encoding="utf-8") as f:
-                f.write(inputs_json)
+            if inputs_json:
+                with open(self._error_file, "a", encoding="utf-8") as f:
+                    f.write(inputs_json)
+            raise
 
         except Exception as error:
             print(f"Error on iteration {sim_monitor.count}: {error}")
@@ -530,16 +546,15 @@ 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:
+            # Handle error from the main process. Re-raising unconditionally
+            # is what makes an interrupted run tell the caller it was cut
+            # short instead of reporting itself as a finished study.
+            except (Exception, KeyboardInterrupt):
                 # Bounded here too. An unbounded join undid the bound above.
                 _stop_the_workers_still_running(
                     processes, simulation_error_event, _SHUTDOWN_GRACE_SECONDS
                 )
-
-                if not isinstance(error, KeyboardInterrupt):
-                    raise error
+                raise
 
     def __validate_number_of_workers(self, n_workers):
         if n_workers is None or n_workers > os.cpu_count():