robotframework-pabot 5.2.0rc1__py3-none-any.whl → 5.2.0rc2__py3-none-any.whl

pabot/__init__.py

@@ -7,4 +7,4 @@ try:
 except ImportError:
     pass
 
-__version__ = "5.2.0rc1"
+__version__ = "5.2.0rc2"

pabot/arguments.py

@@ -236,7 +236,12 @@ def _parse_pabot_args(args):  # type: (List[str]) -> Tuple[List[str], Dict[str,
         if arg_name == "command":
             try:
                 end_index = args.index("--end-command", i)
-                pabot_args["command"] = args[i + 1 : end_index]
+                pabot_args["use_user_command"] = True
+                cmd_lines = args[i + 1 : end_index]
+                cmd = []
+                for line in cmd_lines:
+                    cmd.extend(line.split())
+                pabot_args["command"] = cmd
                 i = end_index + 1
                 continue
             except ValueError:

pabot/pabot.py

@@ -108,9 +108,11 @@ CTRL_C_PRESSED = False
 _PABOTLIBURI = "127.0.0.1:8270"
 _PABOTLIBPROCESS = None  # type: Optional[subprocess.Popen]
 _PABOTWRITER = None  # type: Optional[MessageWriter]
+_PABOTLIBTHREAD = None  # type: Optional[threading.Thread]
 _NUMBER_OF_ITEMS_TO_BE_EXECUTED = 0
 _ABNORMAL_EXIT_HAPPENED = False
 _PABOTCONSOLE = "verbose"  # type: str
+_USE_USER_COMMAND = False
 
 _COMPLETED_LOCK = threading.Lock()
 _NOT_COMPLETED_INDEXES = []  # type: List[int]
@@ -211,15 +213,18 @@ def extract_section(lines, start_marker="<!-- START DOCSTRING -->", end_marker="
         if end_marker in line:
             break
         if inside_section:
-            # Remove Markdown hyperlinks but keep text
-            line = re.sub(r'\[([^\]]+)\]\(https?://[^\)]+\)', r'\1', line)
-            # Remove Markdown section links but keep text
-            line = re.sub(r'\[([^\]]+)\]\(#[^\)]+\)', r'\1', line)
-            # Remove ** and backticks `
-            line = re.sub(r'(\*\*|`)', '', line)
             extracted_lines.append(line)
 
-    return "".join(extracted_lines).strip()
+    result = "".join(extracted_lines)
+
+    # Remove Markdown hyperlinks but keep text
+    result = re.sub(r'\[([^\]]+)\]\(https?://[^\)]+\)', r'\1', result)
+    # Remove Markdown section links but keep text
+    result = re.sub(r'\[([^\]]+)\]\(#[^\)]+\)', r'\1', result)
+    # Remove ** and backticks `
+    result = re.sub(r'(\*\*|`)', '', result)
+
+    return result.strip()
 
 
 class Color:
@@ -368,45 +373,63 @@ def _try_execute_and_wait(
     is_ignored = False
     if _pabotlib_in_use():
         plib = Remote(_PABOTLIBURI)
+
+    command_name = _get_command_name(run_cmd[0])
+    stdout_path = os.path.join(outs_dir, f"{command_name}_stdout.out")
+    stderr_path = os.path.join(outs_dir, f"{command_name}_stderr.out")
+
     try:
-        with open(os.path.join(outs_dir, run_cmd[-1] + "_stdout.out"), "w") as stdout:
-            with open(os.path.join(outs_dir, run_cmd[-1] + "_stderr.out"), "w") as stderr:
-                process, (rc, elapsed) = _run(
-                    run_cmd,
-                    run_options,
-                    stderr,
-                    stdout,
-                    item_name,
-                    verbose,
-                    pool_id,
-                    my_index,
-                    outs_dir,
-                    process_timeout,
-                    sleep_before_start
-                )
+        with open(stdout_path, "w", encoding="utf-8", buffering=1) as stdout, \
+             open(stderr_path, "w", encoding="utf-8", buffering=1) as stderr:
+
+            process, (rc, elapsed) = _run(
+                run_cmd,
+                run_options,
+                stderr,
+                stdout,
+                item_name,
+                verbose,
+                pool_id,
+                my_index,
+                outs_dir,
+                process_timeout,
+                sleep_before_start
+            )
+
+            # Ensure writing
+            stdout.flush()
+            stderr.flush()
+            os.fsync(stdout.fileno())
+            os.fsync(stderr.fileno())
+
+        if plib:
+            _increase_completed(plib, my_index)
+            is_ignored = _is_ignored(plib, caller_id)
+
+        # Thread-safe list append
+        _ALL_ELAPSED.append(elapsed)
+
+        _result_to_stdout(
+            elapsed=elapsed,
+            is_ignored=is_ignored,
+            item_name=item_name,
+            my_index=my_index,
+            pool_id=pool_id,
+            process=process,
+            rc=rc,
+            stderr=stderr_path,
+            stdout=stdout_path,
+            verbose=verbose,
+            show_stdout_on_failure=show_stdout_on_failure,
+        )
+
+        if is_ignored and os.path.isdir(outs_dir):
+            _rmtree_with_path(outs_dir)
+        return rc
+    
     except:
         _write(traceback.format_exc(), level="error")
-    if plib:
-        _increase_completed(plib, my_index)
-        is_ignored = _is_ignored(plib, caller_id)
-    # Thread-safe list append
-    _ALL_ELAPSED.append(elapsed)
-    _result_to_stdout(
-        elapsed,
-        is_ignored,
-        item_name,
-        my_index,
-        pool_id,
-        process,
-        rc,
-        stderr,
-        stdout,
-        verbose,
-        show_stdout_on_failure,
-    )
-    if is_ignored and os.path.isdir(outs_dir):
-        _rmtree_with_path(outs_dir)
-    return rc
+        return 252
 
 
 def _result_to_stdout(
@@ -603,7 +626,7 @@ def _run(
         _write(f"{timestamp} [{pool_id}] [ID:{item_index}] SLEEPING {sleep_before_start} SECONDS BEFORE STARTING {item_name}")
         time.sleep(sleep_before_start)
 
-    command_name = run_command[-1].replace(" ", "_")
+    command_name = _get_command_name(run_command[0])
     argfile_path = os.path.join(outs_dir, f"{command_name}_argfile.txt")
     _write_internal_argument_file(run_options, filename=argfile_path)
 
@@ -634,11 +657,11 @@ def _run(
 
 def _read_file(file_handle):
     try:
-        with open(file_handle.name, "r") as content_file:
+        with open(file_handle, "r") as content_file:
             content = content_file.read()
         return content
-    except:
-        return "Unable to read file %s" % file_handle
+    except Exception as e:
+        return "Unable to read file %s, error: %s" % (os.path.abspath(file_handle), e)
 
 
 def _execution_failed_message(suite_name, stdout, stderr, rc, verbose):
@@ -1262,6 +1285,7 @@ def generate_suite_names_with_builder(outs_dir, datasources, options):
     if ROBOT_VERSION >= "6.1":
         builder = TestSuiteBuilder(
             included_extensions=settings.extension,
+            included_files=settings.parse_include,
             rpa=settings.rpa,
             lang=opts.get("language"),
         )
@@ -1359,7 +1383,7 @@ def _options_for_dryrun(options, outs_dir):
     return _set_terminal_coloring_options(options)
 
 
-def _options_for_rebot(options, start_time_string, end_time_string):
+def _options_for_rebot(options, start_time_string, end_time_string, num_of_executions=0):
     rebot_options = options.copy()
     rebot_options["starttime"] = start_time_string
     rebot_options["endtime"] = end_time_string
@@ -1368,6 +1392,12 @@ def _options_for_rebot(options, start_time_string, end_time_string):
     rebot_options["test"] = []
     rebot_options["exclude"] = []
     rebot_options["include"] = []
+    rebot_options["metadata"].append(
+        f"Pabot Info:[https://pabot.org/?ref=log|Pabot] result from {num_of_executions} executions."
+    )
+    rebot_options["metadata"].append(
+        f"Pabot Version:{PABOT_VERSION}"
+    )
     if rebot_options.get("runemptysuite"):
         rebot_options["processemptysuite"] = True
     if ROBOT_VERSION >= "2.8":
@@ -1727,7 +1757,7 @@ def _copy_output_artifacts(options, timestamp_id=None, file_extensions=None, inc
     return copied_artifacts
 
 
-def _check_pabot_results_for_missing_xml(base_dir, command_name, output_xml_name):
+def _check_pabot_results_for_missing_xml(base_dir, command_name, output_xml_name='output.xml'):
     """
     Check for missing Robot Framework output XML files in pabot result directories,
     taking into account the optional timestamp added by the -T option.
@@ -1753,14 +1783,18 @@ def _check_pabot_results_for_missing_xml(base_dir, command_name, output_xml_name
                 # Check if any file matches the expected XML name or timestamped variant
                 has_xml = any(pattern.match(fname) for fname in os.listdir(subdir_path))
                 if not has_xml:
-                    sanitized_cmd = command_name.replace(" ", "_")
+                    sanitized_cmd = _get_command_name(command_name)
                     missing.append(os.path.join(subdir_path, f"{sanitized_cmd}_stderr.out"))
             break  # only check immediate subdirectories
     return missing
 
 
+def _get_command_name(command_name):
+    global _USE_USER_COMMAND
+    return "user_command" if _USE_USER_COMMAND else command_name
+
+
 def _report_results(outs_dir, pabot_args, options, start_time_string, tests_root_name):
-    output_xml_name = options.get("output") or "output.xml"
     if "pythonpath" in options:
         del options["pythonpath"]
     if ROBOT_VERSION < "4.0":
@@ -1778,33 +1812,34 @@ def _report_results(outs_dir, pabot_args, options, start_time_string, tests_root
     missing_outputs = []
     if pabot_args["argumentfiles"]:
         outputs = []  # type: List[str]
+        total_num_of_executions = 0
         for index, _ in pabot_args["argumentfiles"]:
             copied_artifacts = _copy_output_artifacts(
                 options, _get_timestamp_id(start_time_string, pabot_args["artifactstimestamps"]), pabot_args["artifacts"], pabot_args["artifactsinsubfolders"], index
             )
-            outputs += [
-                _merge_one_run(
-                    os.path.join(outs_dir, index),
-                    options,
-                    tests_root_name,
-                    stats,
-                    copied_artifacts,
-                    timestamp_id=_get_timestamp_id(start_time_string, pabot_args["artifactstimestamps"]),
-                    outputfile=os.path.join("pabot_results", "output%s.xml" % index),
-                )
-            ]
-            missing_outputs.extend(_check_pabot_results_for_missing_xml(os.path.join(outs_dir, index), pabot_args.get('command')[-1], output_xml_name))
+            output, num_of_executions = _merge_one_run(
+                os.path.join(outs_dir, index),
+                options,
+                tests_root_name,
+                stats,
+                copied_artifacts,
+                timestamp_id=_get_timestamp_id(start_time_string, pabot_args["artifactstimestamps"]),
+                outputfile=os.path.join("pabot_results", "output%s.xml" % index),
+            )
+            outputs += [output]
+            total_num_of_executions += num_of_executions
+            missing_outputs.extend(_check_pabot_results_for_missing_xml(os.path.join(outs_dir, index), pabot_args.get('command')))
         if "output" not in options:
             options["output"] = "output.xml"
         _write_stats(stats)
         stdout_writer = get_stdout_writer()
         stderr_writer = get_stderr_writer(original_stderr_name='Internal Rebot')
-        exit_code = rebot(*outputs, **_options_for_rebot(options, start_time_string, _now()), stdout=stdout_writer, stderr=stderr_writer)
+        exit_code = rebot(*outputs, **_options_for_rebot(options, start_time_string, _now(), total_num_of_executions), stdout=stdout_writer, stderr=stderr_writer)
     else:
         exit_code = _report_results_for_one_run(
             outs_dir, pabot_args, options, start_time_string, tests_root_name, stats
         )
-        missing_outputs.extend(_check_pabot_results_for_missing_xml(outs_dir, pabot_args.get('command')[-1], output_xml_name))
+        missing_outputs.extend(_check_pabot_results_for_missing_xml(outs_dir, pabot_args.get('command')))
     if missing_outputs:
         _write(("[ " + _wrap_with(Color.YELLOW, 'WARNING') + " ] "
                 "One or more subprocesses encountered an error and the "
@@ -1860,7 +1895,7 @@ def _report_results_for_one_run(
     copied_artifacts = _copy_output_artifacts(
         options, _get_timestamp_id(start_time_string, pabot_args["artifactstimestamps"]), pabot_args["artifacts"], pabot_args["artifactsinsubfolders"]
     )
-    output_path = _merge_one_run(
+    output_path, num_of_executions = _merge_one_run(
         outs_dir, options, tests_root_name, stats, copied_artifacts, _get_timestamp_id(start_time_string, pabot_args["artifactstimestamps"])
     )
     _write_stats(stats)
@@ -1881,7 +1916,7 @@ def _report_results_for_one_run(
         options["output"] = None  # Do not write output again with rebot
     stdout_writer = get_stdout_writer()
     stderr_writer = get_stderr_writer(original_stderr_name="Internal Rebot")
-    exit_code = rebot(output_path, **_options_for_rebot(options, start_time_string, ts), stdout=stdout_writer, stderr=stderr_writer)
+    exit_code = rebot(output_path, **_options_for_rebot(options, start_time_string, ts, num_of_executions), stdout=stdout_writer, stderr=stderr_writer)
     return exit_code
 
 
@@ -1892,7 +1927,7 @@ def _merge_one_run(
     output_path = os.path.abspath(
         os.path.join(options.get("outputdir", "."), outputfile)
     )
-    filename = options.get("output") or "output.xml"
+    filename = "output.xml"
     base_name, ext = os.path.splitext(filename)
     # Glob all candidates
     candidate_files = glob(os.path.join(outs_dir, "**", f"*{base_name}*{ext}"), recursive=True)
@@ -1905,7 +1940,7 @@ def _merge_one_run(
 
     if not files:
         _write('[ WARNING ]: No output files in "%s"' % outs_dir, Color.YELLOW, level="warning")
-        return ""
+        return "", 0
 
     def invalid_xml_callback():
         global _ABNORMAL_EXIT_HAPPENED
@@ -1921,7 +1956,7 @@ def _merge_one_run(
         resu.save(output_path, legacy_output=True)
     else:
         resu.save(output_path)
-    return output_path
+    return output_path, len(files)
 
 
 def _update_stats(result, stats):
@@ -1987,11 +2022,11 @@ def _get_free_port():
         return s.getsockname()[1]
 
 
-def _start_remote_library(pabot_args):  # type: (dict) -> Optional[subprocess.Popen]
+def _start_remote_library(pabot_args):  # type: (dict) -> Optional[Tuple[subprocess.Popen, threading.Thread]]
     global _PABOTLIBURI
     # If pabotlib is not enabled, do nothing
     if not pabot_args.get("pabotlib"):
-        return None
+        return None, None
 
     host = pabot_args.get("pabotlibhost", "127.0.0.1")
     port = pabot_args.get("pabotlibport", 8270)
@@ -2045,11 +2080,20 @@ def _start_remote_library(pabot_args):  # type: (dict) -> Optional[subprocess.Po
     process = subprocess.Popen(cmd, **kwargs)
 
     def _read_output(proc, writer):
-        for line in proc.stdout:
-            if line.strip():  # Skip empty lines
-                writer.write(line.rstrip('\n') + '\n', level="info")
-                writer.flush()
-        proc.stdout.close()
+        try:
+            for line in proc.stdout:
+                if line.strip():  # Skip empty lines
+                    try:
+                        writer.write(line.rstrip('\n') + '\n', level="info")
+                        writer.flush()
+                    except (RuntimeError, ValueError):
+                        # Writer/stdout already closed during shutdown
+                        break
+        finally:
+            try:
+                proc.stdout.close()
+            except Exception:
+                pass
 
     pabotlib_writer = ThreadSafeWriter(get_writer())
     thread = threading.Thread(
@@ -2059,7 +2103,7 @@ def _start_remote_library(pabot_args):  # type: (dict) -> Optional[subprocess.Po
     )
     thread.start()
 
-    return process
+    return process, thread
 
 
 def _stop_remote_library(process):  # type: (subprocess.Popen) -> None
@@ -2126,6 +2170,7 @@ class QueueItem(object):
             outs_dir.encode("utf-8") if PY2 and is_unicode(outs_dir) else outs_dir
         )
         self.options = options
+        self.options["output"] = "output.xml"  # This is hardcoded output.xml inside pabot_results, not the final output
         self.execution_item = (
             execution_item if not hive else HivedItem(execution_item, hive)
         )
@@ -2366,7 +2411,7 @@ def main(args=None):
 
 
 def main_program(args):
-    global _PABOTLIBPROCESS, _PABOTCONSOLE, _PABOTWRITER
+    global _PABOTLIBPROCESS, _PABOTCONSOLE, _PABOTWRITER, _PABOTLIBTHREAD, _USE_USER_COMMAND
     outs_dir = None
     args = args or sys.argv[1:]
     if len(args) == 0:
@@ -2383,13 +2428,14 @@ def main_program(args):
     original_signal_handler = signal.default_int_handler  # Save default handler in case of early exit
     try:
         options, datasources, pabot_args, opts_for_run = parse_args(args)
+        _USE_USER_COMMAND = pabot_args.get("use_user_command", False)
         _PABOTCONSOLE = pabot_args.get("pabotconsole", "verbose")
         if pabot_args["help"]:
             help_print = __doc__.replace(
                     "PLACEHOLDER_README.MD",
                     read_args_from_readme()
                 )
-            print(help_print.replace("[PABOT_VERSION]", PABOT_VERSION))
+            print(help_print.replace("[PABOT_VERSION]", PABOT_VERSION, 1))
             return 251
         if len(datasources) == 0:
             print("[ " + _wrap_with(Color.RED, "ERROR") + " ]: No datasources given.")
@@ -2402,7 +2448,7 @@ def main_program(args):
         _ensure_process_manager()
         _write(f"Initialized logging in {outs_dir}", level="info")
 
-        _PABOTLIBPROCESS = _start_remote_library(pabot_args)
+        _PABOTLIBPROCESS, _PABOTLIBTHREAD = _start_remote_library(pabot_args)
         # Set up signal handler to keep PabotLib alive during CTRL+C
         # This ensures graceful shutdown in the finally block
         original_signal_handler = signal.signal(signal.SIGINT, keyboard_interrupt)
@@ -2553,12 +2599,31 @@ def main_program(args):
                 _write(f"[ WARNING ] Failed to print elapsed time: {e}", Color.YELLOW, level="warning")
             else:
                 print(f"[ WARNING ] Failed to print elapsed time: {e}")
-        
+
+        # Ensure pabotlib output reader thread has finished
+        try:
+            if _PABOTLIBTHREAD:
+                _PABOTLIBTHREAD.join(timeout=5)
+                if _PABOTLIBTHREAD.is_alive():
+                    if _PABOTWRITER:
+                        _write(
+                            "[ WARNING ] PabotLib output thread did not finish before timeout",
+                            Color.YELLOW,
+                            level="warning"
+                        )
+                    else:
+                        print("[ WARNING ] PabotLib output thread did not finish before timeout")
+        except Exception as e:
+            if _PABOTWRITER:
+                _write(f"[ WARNING ] Could not join pabotlib output thread: {e}", Color.YELLOW, level="warning")
+            else:
+                print(f"[ WARNING ] Could not join pabotlib output thread: {e}")
+
         # Flush and stop writer
         try:
             if _PABOTWRITER:
-                _PABOTWRITER.flush()
                 _PABOTWRITER.write("Logs flushed successfully.", level="debug")
+                _PABOTWRITER.flush()
             else:
                 writer = get_writer()
                 if writer:

pabot/result_merger.py

@@ -290,12 +290,6 @@ def merge(
         rebot_options.get('legacyoutput')
     )
     if len(merged) == 1:
-        if not merged[0].suite.doc:
-            merged[
-                0
-            ].suite.doc = "[https://pabot.org/?ref=log|Pabot] result from %d executions." % len(
-                result_files
-            )
         return merged[0]
     else:
         return ResultsCombiner(merged)

pabot/writer.py

@@ -51,14 +51,21 @@ class BufferingWriter:
                 if line:  # Only write non-empty lines
                     if self.original_stderr_name:
                         line = f"From {self.original_stderr_name}: {line}"
-                    self._writer.write(line, level=self._level)
+                    try:
+                        self._writer.write(line, level=self._level)
+                    except (RuntimeError, ValueError):
+                        # Writer/stdout already closed
+                        break
 
             # If buffer ends with partial content (no newline), keep it buffered
     
     def flush(self):
         with self._lock:
             if self._buffer:
-                self._writer.write(self._buffer, level=self._level)
+                try:
+                    self._writer.write(self._buffer, level=self._level)
+                except (RuntimeError, ValueError):
+                    pass
                 self._buffer = ""
 
 
@@ -81,7 +88,7 @@ class ThreadSafeWriter:
 
 class MessageWriter:
     def __init__(self, log_file=None, console_type="verbose"):
-        self.queue = queue.Queue()
+        self.queue = queue.Queue(maxsize=10000)
         self.log_file = log_file
         self.console_type = console_type
         self.console = DottedConsole() if console_type == "dotted" else None
@@ -89,7 +96,7 @@ class MessageWriter:
             os.makedirs(os.path.dirname(log_file), exist_ok=True)
         self._stop_event = threading.Event()
         self.thread = threading.Thread(target=self._writer)
-        self.thread.daemon = True
+        self.thread.daemon = False
         self.thread.start()
 
     def _is_output_coloring_supported(self):
@@ -127,78 +134,102 @@ class MessageWriter:
         # verbose mode - print everything
         return True
 
-    def _writer(self):
-        while not self._stop_event.is_set():
-            try:
-                message, color, level = self.queue.get(timeout=0.1)
-            except queue.Empty:
-                continue
-            if message is None:
-                self.queue.task_done()
-                break
+    def _flush_batch(self, batch, log_f):
+        for message, color, level in batch:
+            # Log file
+            if log_f:
+                lvl = f"[{level.split('_')[0].upper()}]".ljust(9)
+                log_f.write(f"{lvl} {message}\n")
 
-            message = message.rstrip("\n")
-            # Always write to log file
-            if self.log_file:
-                with open(self.log_file, "a", encoding="utf-8") as f:
-                    lvl_msg = f"[{level.split('_')[0].upper()}]".ljust(9)
-                    f.write(f"{lvl_msg} {message}\n")
-            
-            # Print to console based on level
+            # Console
             if self._should_print_to_console(level=level):
-                if self.console is not None:
-                    # In dotted mode, only print single character messages directly
+                if self.console:
                     if level == "info_passed":
-                        self.console.dot(self._wrap_with(color, "."))  
+                        self.console.dot(self._wrap_with(color, "."))
                     elif level == "info_failed":
                         self.console.dot(self._wrap_with(color, "F"))
                     elif level in ("info_ignored", "info_skipped"):
                         self.console.dot(self._wrap_with(color, "s"))
                     else:
                         self.console.newline()
-                        print(self._wrap_with(color, message), flush=True)
+                        print(self._wrap_with(color, message))
                 else:
-                    print(self._wrap_with(color, message), flush=True)
-            
-            self.queue.task_done()
-
-    def write(self, message, color=None, level="info"):
-        self.queue.put((f"{message}", color, level))
+                    print(self._wrap_with(color, message))
+                    
+    def _writer(self):
+        log_f = None
+        try:
+            if self.log_file:
+                log_f = open(self.log_file, "a", encoding="utf-8", buffering=1)
 
-    def flush(self, timeout=5):
-        """
-        Wait until all queued messages have been written.
+            buffer = []
+            last_flush = time.time()
+            FLUSH_INTERVAL = 0.2       # secs
+            BATCH_SIZE = 50            # rows
 
-        :param timeout: Optional timeout in seconds. If None, wait indefinitely.
-        :return: True if queue drained before timeout (or no timeout), False if timed out.
-        """
-        start = time.time()
-        try:
-            # Loop until Queue reports no unfinished tasks
             while True:
-                # If writer thread died, break to avoid infinite loop
-                if not self.thread.is_alive():
-                    # Give one last moment for potential in-flight task_done()
-                    time.sleep(0.01)
-                    # If still unfinished, we can't do more
-                    return getattr(self.queue, "unfinished_tasks", 0) == 0
-
-                unfinished = getattr(self.queue, "unfinished_tasks", None)
-                if unfinished is None:
-                    # Fallback: call join once and return
-                    try:
-                        self.queue.join()
-                        return True
-                    except Exception:
-                        return False
+                try:
+                    item = self.queue.get(timeout=0.1)
+                except queue.Empty:
+                    # Timebased flush
+                    if buffer and (time.time() - last_flush) > FLUSH_INTERVAL:
+                        self._flush_batch(buffer, log_f)
+                        buffer.clear()
+                        last_flush = time.time()
+                    if self._stop_event.is_set():
+                        break
+                    continue
+
+                message, color, level = item
+
+                if message is None:
+                    self.queue.task_done()
+                    break
+
+                message = message.rstrip("\n")
+
+                buffer.append((message, color, level))
+                self.queue.task_done()
 
-                if unfinished == 0:
-                    return True
+                # Batch full → flush
+                if len(buffer) >= BATCH_SIZE:
+                    self._flush_batch(buffer, log_f)
+                    buffer.clear()
+                    last_flush = time.time()
+
+            # Final flush
+            if buffer:
+                self._flush_batch(buffer, log_f)
 
-                if timeout is not None and (time.time() - start) > timeout:
-                    return False
+        except Exception:
+            import traceback
+            traceback.print_exc()
 
+        finally:
+            if log_f:
+                try:
+                    log_f.flush()
+                    log_f.close()
+                except Exception:
+                    pass
+
+
+    def write(self, message, color=None, level="info"):
+        if self._stop_event.is_set():
+            return
+        try:
+            self.queue.put((f"{message}", color, level), timeout=0.1)
+        except queue.Full:
+            pass  # drop
+        
+    def flush(self, timeout=5):
+        end = time.time() + timeout
+        try:
+            while time.time() < end:
+                if self.queue.unfinished_tasks == 0:
+                    return True
                 time.sleep(0.05)
+            return False
         except KeyboardInterrupt:
             # Allow tests/cli to interrupt flushing
             return False
@@ -207,10 +238,12 @@ class MessageWriter:
         """
         Gracefully stop the writer thread and flush remaining messages.
         """
-        self.flush()
         self._stop_event.set()
-        self.queue.put((None, None, None))  # sentinel to break thread loop
-        self.thread.join(timeout=1.0)
+        try:
+            self.queue.put_nowait((None, None, None))
+        except queue.Full:
+            pass
+        self.thread.join(timeout=2)
 
 
 _writer_instance = None

{robotframework_pabot-5.2.0rc1.dist-info → robotframework_pabot-5.2.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-pabot
-Version: 5.2.0rc1
+Version: 5.2.0rc2
 Summary: Parallel test runner for Robot Framework
 Home-page: https://pabot.org
 Download-URL: https://pypi.python.org/pypi/robotframework-pabot
@@ -194,7 +194,7 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
 
 **--resourcefile [FILEPATH]**          
   Indicator for a file that can contain shared variables for distributing resources. This needs to be used together with 
-  pabotlib option. Resource file syntax is same as Windows ini files. Where a section is a shared set of variables.
+  pabotlib option. Resource file syntax is same as Windows ini files where a section is a shared set of variables.
 
 **--argumentfile[INTEGER] [FILEPATH]**          
   Run same suites with multiple [argumentfile](http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#argument-files) options.

{robotframework_pabot-5.2.0rc1.dist-info → robotframework_pabot-5.2.0rc2.dist-info}/RECORD

@@ -1,23 +1,23 @@
 pabot/ProcessManager.py,sha256=Y4SUOLJ-AmQCc1Y49IYjZS34uqRUnlDt-G2AGymAdHg,13627
 pabot/SharedLibrary.py,sha256=mIipGs3ZhKYEakKprcbrMI4P_Un6qI8gE7086xpHaLY,2552
-pabot/__init__.py,sha256=3MzL6YP6ocsJT8YWQWOMv3XsyC6HvKBZkA07ZtDHD2s,203
-pabot/arguments.py,sha256=IBxkqa63hz5RvdnSZxhLjykkuMs91q8AF30QOzmRl_U,12034
+pabot/__init__.py,sha256=Q8E5VA1T7yYCUTZrCg3pEtcKl4AAA1EhUA-PRA3RnRk,203
+pabot/arguments.py,sha256=UAJyCb3F1--4qpYTuG6SL7rafPC3lLtQIEr9zJ0JNwU,12229
 pabot/clientwrapper.py,sha256=yz7battGs0exysnDeLDWJuzpb2Q-qSjitwxZMO2TlJw,231
 pabot/coordinatorwrapper.py,sha256=nQQ7IowD6c246y8y9nsx0HZbt8vS2XODhPVDjm-lyi0,195
 pabot/execution_items.py,sha256=zDVGW0AAeVbM-scC3Yui2TxvIPx1wYyFKHTPU2BkJkY,13329
-pabot/pabot.py,sha256=rF20VvPfcsPO2_d9FyFGwmoRRqfpoS2EFuATMblOHsc,97383
+pabot/pabot.py,sha256=oHIvEHz1l27IIFjoAcU9bQw9Tf-m6o_v_mjAnTWKxKw,99944
 pabot/pabotlib.py,sha256=vHbqV7L7mIvDzXBh9UcdULrwhBHNn70EDXF_31MNFO4,22320
-pabot/result_merger.py,sha256=rRRSkQa6bdallwT4w9-jHJXvv7X866C1NwD0jdWdSaE,10177
+pabot/result_merger.py,sha256=eqsF5FBqU_7N1Ti34nD2mrjVAr0uWTk67Ix582vCOaE,9963
 pabot/robotremoteserver.py,sha256=BdeIni9Q4LJKVDBUlG2uJ9tiyAjrPXwU_YsPq1THWoo,23296
 pabot/workerwrapper.py,sha256=BdELUVDs5BmEkdNBcYTlnP22Cj0tUpZEunYQMAKyKWU,185
-pabot/writer.py,sha256=tRlPI1jH9NWIYy-VkDsb2odDxZwem7ZgccRBOXZvy4w,8861
+pabot/writer.py,sha256=91HrYV8fLOYYxGycTnO4h18EsCppLtwKTn2R4mfxKMk,9391
 pabot/py3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pabot/py3/client.py,sha256=Od9L4vZ0sozMHq_W_ITQHBBt8kAej40DG58wnxmbHGM,1434
 pabot/py3/coordinator.py,sha256=kBshCzA_1QX_f0WNk42QBJyDYSwSlNM-UEBxOReOj6E,2313
 pabot/py3/messages.py,sha256=7mFr4_0x1JHm5sW8TvKq28Xs_JoeIGku2bX7AyO0kng,2557
 pabot/py3/worker.py,sha256=5rfp4ZiW6gf8GRz6eC0-KUkfx847A91lVtRYpLAv2sg,1612
-robotframework_pabot-5.2.0rc1.dist-info/METADATA,sha256=qQ3V9OzAxIwAZGpUtL9Gi2cetHLXDsTzCPR2Wt1huVw,24792
-robotframework_pabot-5.2.0rc1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-robotframework_pabot-5.2.0rc1.dist-info/entry_points.txt,sha256=JpAIFADTeFOQWdwmn56KpAil8V3-41ZC5ICXCYm3Ng0,43
-robotframework_pabot-5.2.0rc1.dist-info/top_level.txt,sha256=t3OwfEAsSxyxrhjy_GCJYHKbV_X6AIsgeLhYeHvObG4,6
-robotframework_pabot-5.2.0rc1.dist-info/RECORD,,
+robotframework_pabot-5.2.0rc2.dist-info/METADATA,sha256=81x6M9TGs27yKenKnTkaloq8nUQS52kzVQF9SNvq_0Y,24791
+robotframework_pabot-5.2.0rc2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+robotframework_pabot-5.2.0rc2.dist-info/entry_points.txt,sha256=JpAIFADTeFOQWdwmn56KpAil8V3-41ZC5ICXCYm3Ng0,43
+robotframework_pabot-5.2.0rc2.dist-info/top_level.txt,sha256=t3OwfEAsSxyxrhjy_GCJYHKbV_X6AIsgeLhYeHvObG4,6
+robotframework_pabot-5.2.0rc2.dist-info/RECORD,,