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

pabot/result_merger.py

@@ -32,6 +32,7 @@ except ImportError:
     from robot.result.testsuite import TestSuite
 
 from robot.model import SuiteVisitor
+from .writer import get_writer
 
 
 class ResultMerger(SuiteVisitor):
@@ -45,6 +46,7 @@ class ResultMerger(SuiteVisitor):
         self._out_dir = out_dir
         self.legacy_output = legacy_output
         self.timestamp_id = timestamp_id
+        self.writer = get_writer()
 
         self._patterns = []
         regexp_template = (
@@ -62,7 +64,10 @@ class ResultMerger(SuiteVisitor):
             if self.errors != merged.errors:
                 self.errors.add(merged.errors)
         except:
-            print("Error while merging result %s" % merged.source)
+            if self.writer:
+                self.writer.write("Error while merging result %s" % merged.source, level="error")
+            else:
+                print("Error while merging result %s" % merged.source)
             raise
 
     def _set_prefix(self, source):
@@ -214,12 +219,17 @@ def prefix(source, timestamp_id):
 
 def group_by_root(results, critical_tags, non_critical_tags, invalid_xml_callback):
     groups = {}
+    writer = get_writer()
     for src in results:
         try:
             res = ExecutionResult(src)
         except DataError as err:
-            print(err.message)
-            print("Skipping '%s' from final result" % src)
+            if writer:
+                writer.write(err.message, level="error")
+                writer.write("Skipping '%s' from final result" % src, level="warning")
+            else:
+                print(err.message)
+                print("Skipping '%s' from final result" % src)
             invalid_xml_callback()
             continue
         if ROBOT_VERSION < "4.0":
@@ -280,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

@@ -12,15 +12,91 @@ class Color:
     SUPPORTED_OSES = {"posix"}  # Only Unix terminals support ANSI colors
 
 
+class DottedConsole:
+    def __init__(self):
+        self._on_line = False
+
+    def dot(self, char):
+        print(char, end="", flush=True)
+        self._on_line = True
+
+    def newline(self):
+        if self._on_line:
+            print()
+            self._on_line = False
+
+
+class BufferingWriter:
+    """
+    Buffers partial writes until a newline is encountered.
+    Useful for handling output that comes in fragments (e.g., from stderr).
+    """
+    def __init__(self, writer, level="info", original_stderr_name=None):
+        self._writer = writer
+        self._level = level
+        self.original_stderr_name = original_stderr_name
+        self._buffer = ""
+        self._lock = threading.Lock()
+
+    def write(self, msg):
+        with self._lock:
+            if not msg:
+                return
+            
+            self._buffer += msg
+            
+            # Check if buffer contains newline(s)
+            while "\n" in self._buffer:
+                line, self._buffer = self._buffer.split("\n", 1)
+                if line:  # Only write non-empty lines
+                    if self.original_stderr_name:
+                        line = f"From {self.original_stderr_name}: {line}"
+                    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:
+                try:
+                    self._writer.write(self._buffer, level=self._level)
+                except (RuntimeError, ValueError):
+                    pass
+                self._buffer = ""
+
+
+class ThreadSafeWriter:
+    def __init__(self, writer, level="info"):
+        self._writer = writer
+        self._lock = threading.Lock()
+        self._level = level  # Default level for this writer instance
+
+    def write(self, msg, level=None):
+        # Use provided level or fall back to instance default
+        msg_level = level if level is not None else self._level
+        with self._lock:
+            self._writer.write(msg, level=msg_level)
+
+    def flush(self):
+        with self._lock:
+            self._writer.flush()
+
+
 class MessageWriter:
-    def __init__(self, log_file=None):
-        self.queue = queue.Queue()
+    def __init__(self, log_file=None, console_type="verbose"):
+        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
         if log_file:
             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):
@@ -31,59 +107,129 @@ class MessageWriter:
             return f"{color}{message}{Color.ENDC}"
         return message
 
-    def _writer(self):
-        while not self._stop_event.is_set():
-            try:
-                message, color = self.queue.get(timeout=0.1)
-            except queue.Empty:
-                continue
-            if message is None:
-                self.queue.task_done()
-                break
-            print(self._wrap_with(color, message))
-            sys.stdout.flush()
-            if self.log_file:
-                with open(self.log_file, "a", encoding="utf-8") as f:
-                    f.write(message + "\n")
-            self.queue.task_done()
-
-    def write(self, message, color=None):
-        self.queue.put((f"{message}", color))
 
-    def flush(self, timeout=5):
+    def _should_print_to_console(self, console_type=None, level="debug"):
         """
-        Wait until all queued messages have been written.
-
-        :param timeout: Optional timeout in seconds. If None, wait indefinitely.
-        :return: True if queue drained before timeout (or no timeout), False if timed out.
+        Determine if message should be printed to console based on console_type and level.
+        Always write to log file.
+        
+        Args:
+            console_type: The console type mode. If None, uses instance default.
+            level: Message level (debug, info, warning, error, and spesial results infos: info_passed, info_failed, info_skipped, info_ignored). Defaults to debug.
         """
-        start = time.time()
+        ct = console_type if console_type is not None else self.console_type
+
+        # Map levels to importance: debug < info_passed/info_ignored/info_skipped < info_failed < info < warning < error
+        level_map = {"debug": 0, "info_passed": 1, "info_ignored": 1, "info_skipped": 1, "info_failed": 2, "info": 3, "warning": 4, "error": 5}
+        message_level = level_map.get(level, 0)  # default to debug
+        
+        if ct == "none":
+            return False
+        elif ct == "quiet":
+            # In quiet mode, show only warning and error level messages
+            return message_level >= 3
+        elif ct == "dotted":
+            # In dotted mode, show test result indicators (info_passed/failed/skipped/ignored) and warnings/errors
+            return message_level >= 1
+        # verbose mode - print everything
+        return True
+
+    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")
+
+            # Console
+            if self._should_print_to_console(level=level):
+                if self.console:
+                    if level == "info_passed":
+                        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))
+                else:
+                    print(self._wrap_with(color, message))
+                    
+    def _writer(self):
+        log_f = None
         try:
-            # Loop until Queue reports no unfinished tasks
+            if self.log_file:
+                log_f = open(self.log_file, "a", encoding="utf-8", buffering=1)
+
+            buffer = []
+            last_flush = time.time()
+            FLUSH_INTERVAL = 0.2       # secs
+            BATCH_SIZE = 50            # rows
+
             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
 
-                if unfinished == 0:
-                    return True
+                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()
+
+                # Batch full → flush
+                if len(buffer) >= BATCH_SIZE:
+                    self._flush_batch(buffer, log_f)
+                    buffer.clear()
+                    last_flush = time.time()
 
-                if timeout is not None and (time.time() - start) > timeout:
-                    return False
+            # Final flush
+            if buffer:
+                self._flush_batch(buffer, log_f)
 
+        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
@@ -92,19 +238,31 @@ class MessageWriter:
         """
         Gracefully stop the writer thread and flush remaining messages.
         """
-        self.flush()
         self._stop_event.set()
-        self.queue.put((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
 
-def get_writer(log_dir=None):
+def get_writer(log_dir=None, console_type="verbose"):
     global _writer_instance
     if _writer_instance is None:
         if log_dir:
             os.makedirs(log_dir, exist_ok=True)
         log_file = os.path.join(log_dir or ".", "pabot_manager.log")
-        _writer_instance = MessageWriter(log_file=log_file)
+        _writer_instance = MessageWriter(log_file=log_file, console_type=console_type)
     return _writer_instance
+
+def get_stdout_writer(log_dir=None, console_type="verbose"):
+    """Get a writer configured for stdout with 'info' level"""
+    return ThreadSafeWriter(get_writer(log_dir, console_type), level="info")
+
+def get_stderr_writer(log_dir=None, console_type="verbose", original_stderr_name: str = None):
+    """Get a writer configured for stderr with 'error' level, buffered to handle partial writes"""
+    # Use BufferingWriter to combine fragments that come without newlines
+    buffering_writer = BufferingWriter(get_writer(log_dir, console_type), level="error", original_stderr_name=original_stderr_name)
+    return buffering_writer

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-pabot
-Version: 5.2.0b1
+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
@@ -118,10 +118,11 @@ pabot [--verbose|--testlevelsplit|--command .. --end-command|
         --shard i/n|
         --artifacts extensions|--artifactsinsubfolders|
         --resourcefile file|--argumentfile[num] file|--suitesfrom file
-        --ordering <FILENAME> [static|dynamic] [skip|run_all]|
+        --ordering file [static|dynamic] [skip|run_all]|
         --chunk|
         --pabotprerunmodifier modifier|
         --no-rebot|
+        --pabotconsole [verbose|dotted|quiet|none]|
         --help|--version]
       [robot options] [path ...]
 ```
@@ -193,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.
@@ -206,10 +207,10 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
   Optionally read suites from output.xml file. Failed suites will run first and longer running ones will be executed 
   before shorter ones.
 
-**--ordering [FILE PATH] [MODE] [FAILURE POLICY]**   
+**--ordering [FILEPATH] [MODE] [FAILURE POLICY]**   
   Optionally give execution order from a file. See README.md section: [Controlling execution order, mode and level of parallelism](#controlling-execution-order-mode-and-level-of-parallelism)
-  - MODE (optional): [static (default)|dynamic]
-  - FAILURE POLICY (optional, only in dynamic mode): [skip|run_all (default)]
+  - MODE (optional): [ static (default) | dynamic ]
+  - FAILURE POLICY (optional, only in dynamic mode): [ skip | run_all (default) ]
 
 **--chunk**   
   Optionally chunk tests to PROCESSES number of robot runs. This can save time because all the suites will share the same 
@@ -226,6 +227,28 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
   for scenarios where Rebot should be run later due to large log files, ensuring better memory and resource availability. 
   Subprocess results are stored in the pabot_results folder.
 
+**--pabotconsole [MODE]**
+  The --pabotconsole option controls how much output is printed to the console.
+  Note that all Pabot’s own messages are always logged to pabot_manager.log, regardless of the selected console mode.
+
+  The available options are:
+  - verbose (default):
+    Prints all messages to the console, corresponding closely to what is written to the log file.
+  - dotted:
+    Prints important messages, warnings, and errors to the console, along with execution progress using the following notation:
+
+      - PASS = .
+      - FAIL = F
+      - SKIP = s
+    
+    Note that each Robot Framework process is represented by a single character. 
+    Depending on the execution parameters, individual tests may not have their own status character; 
+    instead, the status may represent an entire suite or a group of tests.
+  - quiet:
+    Similar to dotted, but suppresses execution progress output.
+  - none:
+    Produces no console output at all.
+
 **--help**             
   Print usage instructions.
  
@@ -491,7 +514,7 @@ pabot_results/
 │       ├── robot_stdout.out
 │       ├── robot_stderr.out
 │       └── artifacts...
-pabot_manager.log            # Pabot's own main log. Basically same than prints in console
+└── pabot_manager.log        # Pabot's own main log.
 ```
 
 Each `PABOTQUEUEINDEX` folder contains as default:

robotframework_pabot-5.2.0rc2.dist-info/RECORD

@@ -0,0 +1,23 @@
+pabot/ProcessManager.py,sha256=Y4SUOLJ-AmQCc1Y49IYjZS34uqRUnlDt-G2AGymAdHg,13627
+pabot/SharedLibrary.py,sha256=mIipGs3ZhKYEakKprcbrMI4P_Un6qI8gE7086xpHaLY,2552
+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=oHIvEHz1l27IIFjoAcU9bQw9Tf-m6o_v_mjAnTWKxKw,99944
+pabot/pabotlib.py,sha256=vHbqV7L7mIvDzXBh9UcdULrwhBHNn70EDXF_31MNFO4,22320
+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=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.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,,

{robotframework_pabot-5.2.0b1.dist-info → robotframework_pabot-5.2.0rc2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pabot/skip_listener.py

@@ -1,7 +0,0 @@
-ROBOT_LISTENER_API_VERSION = 3
-
-def end_test(data, result):
-    # data: TestCase object
-    # result: TestCaseResult object
-    result.status = 'SKIP'
-    result.message = "Pabot skip logic: this test was skipped due to dependencies and failure policy."

pabot/timeout_listener.py

@@ -1,5 +0,0 @@
-ROBOT_LISTENER_API_VERSION = 3
-
-def end_test(data, result):
-    result.status = 'FAIL'
-    result.message = "Pabot's --processtimeout option has been reached."

robotframework_pabot-5.2.0b1.dist-info/RECORD

@@ -1,25 +0,0 @@
-pabot/ProcessManager.py,sha256=w3dgtEKGhn4rj3nQ1EEQFAPeiIv6OF-KU6R3WZwQxPs,11739
-pabot/SharedLibrary.py,sha256=mIipGs3ZhKYEakKprcbrMI4P_Un6qI8gE7086xpHaLY,2552
-pabot/__init__.py,sha256=KuCXsD2BDgEFiQAxVRLN3SXkkyCULXtW06tTTqCEuRo,202
-pabot/arguments.py,sha256=6MBXKnbDgWNdu7NnRqqd2_GNOs-u8QOxCz9wHhyfUVI,11404
-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=hfMZdMYmeZEo3mNAVrvmuPU9vGhKpIBEVq5R8BI5ovE,87438
-pabot/pabotlib.py,sha256=vHbqV7L7mIvDzXBh9UcdULrwhBHNn70EDXF_31MNFO4,22320
-pabot/result_merger.py,sha256=g4mm-BhhMK57Z6j6dpvfL5El1g5onOtfV4RByNrO8g0,9744
-pabot/robotremoteserver.py,sha256=BdeIni9Q4LJKVDBUlG2uJ9tiyAjrPXwU_YsPq1THWoo,23296
-pabot/skip_listener.py,sha256=xv7wH-yB_nfc_AT1oZh3C0iu8hS67g5a28x8hwSrYsE,254
-pabot/timeout_listener.py,sha256=twZFiJEyn9tAqI1K6JDBGaZrxRqVLFDVWvyxa6d8Lb0,160
-pabot/workerwrapper.py,sha256=BdELUVDs5BmEkdNBcYTlnP22Cj0tUpZEunYQMAKyKWU,185
-pabot/writer.py,sha256=_sRN_EqIhaMwPYmTkN4NzO2Mj6tggcaxgYkqJKatb_c,3639
-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.0b1.dist-info/METADATA,sha256=_7b2wWKxeuFlEbRCz_sHwmrWQCwp85v-rl9HX-mScyo,23811
-robotframework_pabot-5.2.0b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-robotframework_pabot-5.2.0b1.dist-info/entry_points.txt,sha256=JpAIFADTeFOQWdwmn56KpAil8V3-41ZC5ICXCYm3Ng0,43
-robotframework_pabot-5.2.0b1.dist-info/top_level.txt,sha256=t3OwfEAsSxyxrhjy_GCJYHKbV_X6AIsgeLhYeHvObG4,6
-robotframework_pabot-5.2.0b1.dist-info/RECORD,,