BusySpinner() polishing

Author: OutlyingWest

src/jumper/kernel.py

@@ -802,10 +802,11 @@ async def scorep_execute(
         # e.g. tqdm for-loop progress bar
         self.cell_output("\0")
 
-        process_busy_spinner = BusySpinner()
+        stdout_lock = threading.Lock()
+        process_busy_spinner = BusySpinner(stdout_lock)
         process_busy_spinner.start('Process is running...')
 
-        multicellmode_timestamps = self.read_scorep_process_pipe(proc)
+        multicellmode_timestamps = self.read_scorep_process_pipe(proc, stdout_lock)
 
         process_busy_spinner.stop()
 
@@ -962,11 +963,12 @@ async def scorep_execute(
         return self.standard_reply()
 
 
-    def read_scorep_process_pipe(self, proc: subprocess.Popen[bytes]) -> list:
+    def read_scorep_process_pipe(self, proc: subprocess.Popen[bytes], stdout_lock: threading.Lock) -> list:
         """
         Reads and processes the output of a subprocess running with Score-P instrumentation.
         Args:
             proc (subprocess.Popen[bytes]): The subprocess whose output is being read.
+            stdout_lock (threading.Lock): Lock to avoid output overlapping
 
         Returns:
             list: A list of decoded strings containing "MCM_TS" timestamps.
@@ -977,6 +979,9 @@ def read_scorep_process_pipe(self, proc: subprocess.Popen[bytes]) -> list:
         sel.register(proc.stdout, selectors.EVENT_READ)
         sel.register(proc.stderr, selectors.EVENT_READ)
 
+        line_width = 50
+        clear_line = "\r" + " " * line_width + "\r"
+
         while True:
             # Select between stdout and stderr
             for key, val in sel.select():
@@ -988,11 +993,15 @@ def read_scorep_process_pipe(self, proc: subprocess.Popen[bytes]) -> list:
                 decoded_line = line.decode(sys.getdefaultencoding(), errors='ignore')
 
                 if key.fileobj is proc.stderr:
-                    self.log.warning(f'{decoded_line.strip()}')
+                    with stdout_lock:
+                        self.log.warning(f'{decoded_line.strip()}')
                 elif 'MCM_TS' in decoded_line:
                     multicellmode_timestamps.append(decoded_line)
                 else:
-                    self.cell_output(decoded_line)
+                    with stdout_lock:
+                        sys.stdout.write(clear_line)
+                        sys.stdout.flush()
+                        self.cell_output(decoded_line)
 
             # If both stdout and stderr empty -> out of loop
             if not sel.get_map():

src/jumper/userpersistence.py

@@ -121,7 +121,7 @@ def jupyter_dump(self):
             f"dump_variables({str(self.jupyter_variables)},globals(),"
             f"'{self.paths['jupyter']['var']}',"
             f"{self.marshaller})\n"
-            "spinner.stop('Data is loaded!')\n"
+            "spinner.stop('Data is loaded.')\n"
         )
 
         return jupyter_dump_
@@ -390,26 +390,9 @@ def magics_cleanup(code):
     return scorep_env, nomagic_code
 
 
-def start_busy_spinner():
-    pass
-
-def stop_busy_spinner():
-    pass
-
-
-def spinner_task(stop_event, message="Loading data..."):
-    spinner = ['|', '/', '-', '\\']
-    i = 0
-    while not stop_event.is_set():
-        sys.stdout.write(f'\r{message} {spinner[i % len(spinner)]}')
-        sys.stdout.flush()
-        time.sleep(0.1)
-        i += 1
-    sys.stdout.write('\rData is loaded to subprocess!            \n')
-
-
 class BusySpinner:
-    def __init__(self):
+    def __init__(self, lock=None):
+        self._lock = lock or threading.Lock()
         self._stop_event = threading.Event()
         self._thread = threading.Thread(target=self._spinner_task)
         self.working_message = ''
@@ -419,12 +402,14 @@ def _spinner_task(self):
         spinner_chars = "|/-\\"
         idx = 0
         while not self._stop_event.is_set():
-            sys.stdout.write(f"\r{self.working_message} {spinner_chars[idx % len(spinner_chars)]}")
-            sys.stdout.flush()
+            with self._lock:
+                sys.stdout.write(f"\r{self.working_message} {spinner_chars[idx % len(spinner_chars)]}")
+                sys.stdout.flush()
             time.sleep(0.1)
             idx += 1
-        sys.stdout.write(f"\r{self.done_message}")
-        sys.stdout.flush()
+        with self._lock:
+            sys.stdout.write(f"\r{self.done_message}{' ' * len(self.working_message)}\n")
+            sys.stdout.flush()
 
     def start(self, working_message='Working...'):
         self.working_message = working_message