robotframework-parallelrunner 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

ParallelRunner/parallel_library.py

@@ -1,22 +1,50 @@
 import os
-import concurrent.futures
 import importlib
+import queue
+import threading
+import time
 from typing import Iterable, Any, List, Dict, Optional, Tuple, Union
 from robot.api import logger
+try:
+    from robot.errors import TimeoutExceeded
+except ImportError:  # Robot Framework < 7.0
+    from robot.errors import TimeoutError as TimeoutExceeded
 from robot.libraries.BuiltIn import BuiltIn
 
 from .version import __version__
 
 
+# Robot Framework log levels, in increasing severity. HTML and CONSOLE are
+# INFO messages (rendered as HTML / also written to the console).
+LOG_LEVELS = {"TRACE": 0, "DEBUG": 1, "INFO": 2, "HTML": 2, "CONSOLE": 2, "WARN": 3, "ERROR": 4}
+# Spellings from Python's `logging` module, mapped to the Robot level.
+LOG_LEVEL_ALIASES = {"WARNING": "WARN", "CRITICAL": "ERROR", "FATAL": "ERROR"}
+
+# How often the main thread checks whether the calls have finished. Waiting in
+# short sleeps (instead of blocking on a lock until the end) is what lets a
+# Robot `[Timeout]` interrupt the keyword: on Windows the timeout is raised
+# asynchronously and only arrives while Python code runs.
+_POLL_INTERVAL = 0.01
+
+
+def _normalize_level(level: Any) -> Optional[str]:
+    """Returns the Robot level name for ``level`` (any case, or a Python
+    ``logging`` alias), ``"IGNORE"``, or None if it's not a known level."""
+    name = str(level).strip().upper()
+    name = LOG_LEVEL_ALIASES.get(name, name)
+    return name if name in LOG_LEVELS or name == "IGNORE" else None
+
+
 class ParallelTaskError(RuntimeError):
     """
-    Raised when at least one parallel task failed and there is no meaningful
-    return value to hand back for it - by ``get_result_values``, and by
-    ``run_parallel_scenarios`` when called with ``return_values_only=True``.
+    Raised when at least one parallel task failed: by ``run_parallel_scenarios``
+    (unless called with ``fail_on_error=False``), and by ``get_result_values``,
+    which has no meaningful return value to hand back for a failed task.
 
-    Silently substituting `None` for a failed task's value would let a test
-    keep going with bad data instead of failing for the right reason, so
-    this is raised instead.
+    Returning normally after a failed call would let a test keep going (and
+    pass) with bad or missing data instead of failing for the right reason,
+    so this is raised instead - after every task has finished and all logs
+    have been replayed.
 
     Attributes:
         failures: the subset of result dicts with ``status == "FAIL"``,
@@ -46,7 +74,8 @@ class ParallelRunner:
 
     = How it works =
 
-    - Each call runs on a worker thread of a ``ThreadPoolExecutor``.
+    - Each call runs on one of a pool of worker threads (see
+      ``ROBOT_THREAD_WORKERS``), created for that keyword call.
       ``BuiltIn().run_keyword`` is *not* used inside threads (it is not
       thread-safe); the underlying Python method of the target library is
       called directly instead.
@@ -73,8 +102,8 @@ class ParallelRunner:
     |         ...
     |         return result
 
-    ``_logger(msg, level)`` accepts the levels ``INFO``, ``WARN``, ``ERROR``
-    and ``IGNORE`` (dropped). Any extra named argument given to
+    ``_logger(msg, level)`` accepts every Robot Framework log level (see
+    `Log levels`) plus ``IGNORE`` (dropped). Any extra named argument given to
     `Run Parallel Scenarios` is forwarded to every call as ``**kwargs``.
 
     Logging is made thread-safe for you; your keyword's own side effects are
@@ -91,9 +120,58 @@ class ParallelRunner:
     | result   | The return value of the call (only when ``status`` is ``PASS``). |
     | error    | The error message (only when ``status`` is ``FAIL``). |
 
-    A failing call does *not* fail the keyword; check ``status`` yourself,
-    or use ``return_values_only=True`` / `Get Result Values`, which fail
-    if any call failed.
+    = Failures =
+
+    If any call raises, `Run Parallel Scenarios` still waits for every other
+    call, replays all logs, and then *fails* with a ``ParallelTaskError``
+    that lists each failed item and its error, e.g.
+    ``2 of 5 parallel task(s) failed: item='4': ...; item='5': ...``.
+    One failed call is never hidden behind a passing keyword.
+
+    To inspect failures yourself instead, pass ``fail_on_error=False``: the
+    keyword then always returns the result list, failed calls get
+    ``status`` ``FAIL`` (their error is also logged at ``ERROR`` level), and
+    it is up to you to assert on them:
+
+    | ${results}= | Run Parallel Scenarios | keyword=Verify Agent Data | library=MyLibrary | for_loop_iterable=${agents} | fail_on_error=False |
+    | Should Be Equal | ${results}[1][status] | PASS |
+
+    ``return_values_only=True`` and `Get Result Values` always fail if any
+    call failed, because a failed call has no return value.
+
+    = Log levels =
+
+    The injected ``_logger`` accepts the same levels as Robot Framework's
+    ``logger.write``: ``TRACE``, ``DEBUG``, ``INFO``, ``HTML`` (an ``INFO``
+    message rendered as HTML), ``CONSOLE`` (an ``INFO`` message also written
+    to the console), ``WARN`` and ``ERROR``. Levels are case-insensitive, and
+    Python ``logging`` names are accepted too: ``WARNING`` is ``WARN``,
+    ``CRITICAL`` and ``FATAL`` are ``ERROR``. ``IGNORE`` drops the message.
+
+    Replayed messages go through Robot's normal filtering, so ``TRACE`` and
+    ``DEBUG`` messages only show up in ``log.html`` when the run uses a low
+    enough ``--loglevel`` (e.g. ``--loglevel DEBUG``), exactly as they would
+    from a normal keyword. ``thread_log_level`` filters the threads' messages
+    on top of that (by default it lets every level through).
+
+    A message with an unknown level is not lost: it is logged at ``INFO``
+    with the level as a prefix (``[VERBOSE] message``), and a warning names
+    the unknown level once per keyword call.
+
+    = Timeouts =
+
+    A Robot ``[Timeout]`` (test or keyword) interrupts `Run Parallel Scenarios`
+    as soon as it expires, not when the whole batch has finished. Before the
+    timeout failure is reported, the logs collected so far are replayed:
+    finished calls as usual, and every call that did not finish with its
+    partial logs and an ``ERROR`` saying it was interrupted.
+
+    Python threads can't be killed, so calls that are already running keep
+    running in the background until they return (possibly while the next test
+    runs); calls that had not started yet are not started. The worker threads
+    are daemon threads, so they never keep the Robot process alive after the
+    run. A keyword that may hang (e.g. network I/O) should set its own
+    timeouts (e.g. ``requests.get(url, timeout=10)``).
 
     = Custom logger mappers =
 
@@ -143,9 +221,10 @@ class ParallelRunner:
         for_loop_iterable: Optional[Iterable[Any]] = None,
         repeat: Optional[int] = None,
         remove_passing_logs: bool = False,
-        thread_log_level: str = "INFO",
+        thread_log_level: str = "TRACE",
         logger_mapper: Optional[Any] = None,
         return_values_only: bool = False,
+        fail_on_error: bool = True,
         **kwargs
     ) -> Union[List[Dict[str, Any]], Tuple[Any, ...]]:
         """Runs ``keyword`` from ``library`` concurrently, once per item or N times.
@@ -166,7 +245,9 @@ class ParallelRunner:
         - ``remove_passing_logs``: If true, logs of passing calls are not
           replayed into ``log.html``; only failed calls are shown.
         - ``thread_log_level``: Minimum level replayed from the threads:
-          ``INFO`` (default), ``WARN`` or ``ERROR``.
+          ``TRACE`` (default, every message), ``DEBUG``, ``INFO``, ``WARN``
+          or ``ERROR``. Robot's own ``--loglevel`` still applies on top of it
+          (see `Log levels`). An unknown value is ignored with a warning.
         - ``logger_mapper``: Optional callable ``mapper(msg, level)`` - or a
           ``module.function`` path to one, such as
           ``my_package.my_module.my_mapper`` - injected as ``_logger`` instead
@@ -178,17 +259,23 @@ class ParallelRunner:
           return value (in call order) instead of the result dictionaries.
           Fails with ``ParallelTaskError`` if any call failed. Same as calling
           `Get Result Values` on the default return value.
+        - ``fail_on_error``: If true (default), fail with ``ParallelTaskError``
+          when any call failed, after all calls have finished and their logs
+          have been replayed. If false, return the results anyway and leave
+          checking ``status`` to the caller. See `Failures`.
         - ``**kwargs``: Any other named argument is passed to every call.
 
         Returns a list of result dictionaries (see `Result format`), in call
         order: entry ``i`` belongs to ``for_loop_iterable[i]`` / repeat
-        index ``i``, regardless of which thread finished first.
+        index ``i``, regardless of which thread finished first. With the
+        default ``fail_on_error=True`` it only returns when every call passed.
 
         Examples:
         | ${agents}=    | Create List            | 1                         | 2                       | 3 |
         | ${results}=   | Run Parallel Scenarios | keyword=Verify Agent Data | library=MyLibrary       | for_loop_iterable=${agents} |
         | ${results}=   | Run Parallel Scenarios | keyword=Check Health      | library=MyLibrary       | repeat=8 | agent_id=1 |
         | ${id1}    ${id2}    ${id3}= | Run Parallel Scenarios | keyword=Seed Record | library=MyLibrary | repeat=3 | return_values_only=True |
+        | ${results}=   | Run Parallel Scenarios | keyword=Verify Agent Data | library=MyLibrary       | for_loop_iterable=${agents} | fail_on_error=False |
         """
         # Determine items to process. NOTE: `repeat or 1` would be wrong here -
         # 0 is falsy in Python, so an explicit repeat=0 would silently fall
@@ -206,28 +293,22 @@ class ParallelRunner:
         if effective_mapper is None:
             effective_mapper = self._load_mapper_from_environment()
 
-        with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
-            # We map the execution.
-            # Note: We must call the underlying Python method, not BuiltIn().run_keyword
-            # because run_keyword is not thread-safe.
-            lib_instance = self._get_library_instance_owning_keyword(keyword, library)
-            method = getattr(lib_instance, keyword.replace(" ", "_").lower())
-
-            # Submit every task up front so they all start running concurrently,
-            # then collect results in submission order (NOT as_completed order) -
-            # tasks[i].result() blocks only until the i-th task finishes, it
-            # doesn't force tasks to run one at a time.
-            tasks = [
-                executor.submit(self._execute_and_capture, method, item, effective_mapper, **kwargs)
-                for item in items
-            ]
-            results = [task.result() for task in tasks]
+        min_level = self._resolve_thread_log_level(thread_log_level)
+
+        # Note: We must call the underlying Python method, not BuiltIn().run_keyword
+        # because run_keyword is not thread-safe.
+        lib_instance = self._get_library_instance_owning_keyword(keyword, library)
+        method = getattr(lib_instance, keyword.replace(" ", "_").lower())
+
+        results = self._run_in_threads(method, list(items), effective_mapper, remove_passing_logs, min_level, kwargs)
 
         # Step: Re-play logs into Robot Framework sequentially
-        self._replay_logs(results, remove_passing_logs, thread_log_level)
+        self._replay_logs(results, remove_passing_logs, min_level)
 
         if return_values_only:
             return self.get_result_values(results)
+        if fail_on_error:
+            self._raise_if_any_failed(results)
         return results
 
     def get_result_values(self, results: List[Dict[str, Any]]) -> Tuple[Any, ...]:
@@ -238,7 +319,9 @@ class ParallelRunner:
 
         Passing ``return_values_only=True`` to `Run Parallel Scenarios` does
         the same in one step; use this keyword when you want to inspect the
-        full results first (e.g. assert on ``status`` or ``logs``).
+        full results first (e.g. assert on ``status`` or ``logs``). Such a
+        result list may only contain failed calls if it came from a run with
+        ``fail_on_error=False``.
 
         Fails with ``ParallelTaskError`` if any entry has status ``FAIL`` -
         a failed call has no return value to put in its slot.
@@ -247,10 +330,13 @@ class ParallelRunner:
         | ${results}=                 | Run Parallel Scenarios | keyword=Seed Record | library=MyLibrary | repeat=3 |
         | ${id1}    ${id2}    ${id3}= | Get Result Values      | ${results}          |
         """
+        self._raise_if_any_failed(results)
+        return tuple(entry["result"] for entry in results)
+
+    def _raise_if_any_failed(self, results: List[Dict[str, Any]]) -> None:
         failures = [entry for entry in results if entry.get("status") == "FAIL"]
         if failures:
             raise ParallelTaskError(failures, len(results))
-        return tuple(entry["result"] for entry in results)
 
     def _resolve_mapper(self, mapper: Optional[Any], source: str = "logger_mapper") -> Optional[Any]:
         """
@@ -313,44 +399,167 @@ class ParallelRunner:
             return lib_instance
         raise ValueError(f"Keyword '{keyword_name}' not found in library '{library}'")
 
-    def _execute_and_capture(self, method, item, logger_mapper: Optional[Any] = None, **kwargs) -> Dict[str, Any]:
-        """Worker wrapper to capture logs and results."""
-        log_buffer = []
-        
+    def _resolve_thread_log_level(self, thread_log_level: Any) -> int:
+        """Returns the numeric minimum level for ``thread_log_level``. Not
+        given (None, empty, "None") means every level; an unknown value is
+        ignored with a warning instead of silently filtering by INFO."""
+        if thread_log_level is None or str(thread_log_level).strip().upper() in ("", "NONE"):
+            return LOG_LEVELS["TRACE"]
+        level = _normalize_level(thread_log_level)
+        if level in LOG_LEVELS:
+            return LOG_LEVELS[level]
+        logger.warn(
+            f"Ignoring thread_log_level {thread_log_level!r}: expected TRACE, DEBUG, INFO, WARN or ERROR. "
+            "Replaying every level."
+        )
+        return LOG_LEVELS["TRACE"]
+
+    def _run_in_threads(
+        self,
+        method,
+        items: List[Any],
+        logger_mapper: Optional[Any],
+        remove_passing_logs: bool,
+        min_level: int,
+        kwargs: Dict[str, Any],
+    ) -> List[Dict[str, Any]]:
+        """
+        Runs ``method`` once per item on up to ``max_workers`` daemon threads
+        and returns the result dicts in call order (NOT completion order).
+
+        If the wait is interrupted (mostly by a Robot ``[Timeout]``), the
+        workers stop starting new calls, the logs collected so far are
+        replayed and the exception is re-raised. Calls already running can't
+        be stopped: they finish in the background. The threads are daemon
+        threads (unlike the ones of ``ThreadPoolExecutor``), so a call that
+        never returns can't keep the Robot process alive at exit.
+        """
+        if self.max_workers < 1:
+            raise ValueError(f"ROBOT_THREAD_WORKERS must be at least 1, got {self.max_workers}.")
+
+        # Created here, not in the workers, so the logs of calls that are still
+        # running can be replayed if the keyword is interrupted.
+        log_buffers: List[list] = [[] for _ in items]
+        results: List[Optional[Dict[str, Any]]] = [None] * len(items)
+        started = [False] * len(items)
+        pending = queue.SimpleQueue()
+        for index in range(len(items)):
+            pending.put(index)
+        stop = threading.Event()
+
+        def worker():
+            while not stop.is_set():
+                try:
+                    index = pending.get_nowait()
+                except queue.Empty:
+                    return
+                started[index] = True
+                results[index] = self._execute_and_capture(
+                    method, items[index], logger_mapper, log_buffers[index], kwargs
+                )
+
+        try:
+            for number in range(min(self.max_workers, len(items))):
+                threading.Thread(target=worker, name=f"ParallelRunner-worker-{number + 1}", daemon=True).start()
+            # Deliberately no lock, Event or Future wait here: a timeout raised
+            # asynchronously while such a wait holds an internal lock could
+            # leave it locked forever. Short sleeps and plain reads are safe.
+            for index in range(len(items)):
+                while results[index] is None:
+                    time.sleep(_POLL_INTERVAL)
+        except BaseException as error:
+            stop.set()
+            self._replay_interrupted(items, results, started, log_buffers, error, remove_passing_logs, min_level)
+            raise
+        return results
+
+    def _replay_interrupted(self, items, results, started, log_buffers, error, remove_passing_logs, min_level):
+        """Replays what the calls logged before the keyword was interrupted.
+        Calls that never started are only counted, not listed one by one."""
+        # On Windows Robot raises the timeout as a bare class, without message.
+        reason = str(error) or ("Robot timeout exceeded" if isinstance(error, TimeoutExceeded) else type(error).__name__)
+        partial = []
+        running = not_started = 0
+        for index, item in enumerate(items):
+            # Read the result before `started`: a call that finishes in between
+            # is then reported as still running, never as not started.
+            result = results[index]
+            if result is not None:
+                partial.append(result)
+            elif started[index]:
+                running += 1
+                logs = list(log_buffers[index])
+                logs.append(("ERROR", f"Call for item {item} did not finish: still running when the keyword was interrupted ({reason})"))
+                partial.append({"status": "FAIL", "item": item, "logs": logs, "error": f"Did not finish: interrupted ({reason})"})
+            else:
+                not_started += 1
+        logger.info(
+            f"Run Parallel Scenarios was interrupted ({reason}): {len(partial) - running} call(s) finished, "
+            f"{running} still running (left running in the background), {not_started} not started."
+        )
+        self._replay_logs(partial, remove_passing_logs, min_level)
+
+    def _execute_and_capture(
+        self, method, item, logger_mapper: Optional[Any], log_buffer: list, kwargs: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Worker wrapper to capture logs and results.
+
+        ``kwargs`` is a dict, not ``**kwargs``, so a keyword argument that
+        happens to be called ``method``, ``item`` or ``log_buffer`` can't clash
+        with this method's own parameters.
+        """
         # Injection of a custom logger into the thread
         def thread_log(msg, level="INFO"):
-            # Filter out IGNORE (sv=0) level logs
-            if level != "IGNORE":
+            # Filter out IGNORE (sv=0) level logs. Other levels are kept as
+            # given and checked when the logs are replayed.
+            if _normalize_level(level) != "IGNORE":
                 log_buffer.append((level, msg))
-        
+
         # Use mapper if provided, otherwise use thread_log
         effective_logger = logger_mapper if logger_mapper else thread_log
 
         try:
-            # We pass the custom logger as an extra kwarg if the method supports it
-            # or rely on the method returning its own logs.
             result = method(item, _logger=effective_logger, **kwargs)
             return {"status": "PASS", "item": item, "logs": log_buffer, "result": result}
-        except Exception as e:
+        # BaseException, not Exception: whatever the call raises (even
+        # SystemExit), the worker must report a result, or the main thread
+        # would wait for this call forever.
+        except BaseException as e:
             thread_log(f"Thread failed for item {item}: {str(e)}", "ERROR")
             return {"status": "FAIL", "item": item, "logs": log_buffer, "error": str(e)}
 
-    def _replay_logs(self, results: List[Dict[str, Any]], remove_passing_logs: bool = False, thread_log_level: str = "INFO"):
-        """Sequential dump to the real RF Logger. Filters out IGNORE level logs."""
-        level_order = {"INFO": 1, "WARN": 2, "ERROR": 3}
-        min_level = level_order.get(thread_log_level, 1)
+    def _replay_logs(self, results: List[Dict[str, Any]], remove_passing_logs: bool = False, min_level: int = 0):
+        """Sequential dump to the real RF Logger, in call order.
+
+        Every Robot level goes through ``logger.write``, so Robot's
+        ``--loglevel`` filters it as usual. IGNORE messages and levels below
+        ``min_level`` are skipped. A message with an unknown level is kept at
+        INFO, prefixed with its level, plus one warning per unknown level.
+        (Before 0.3.1 only INFO/WARN/ERROR were written; everything else,
+        DEBUG included, was dropped silently.)
+        """
+        unknown_levels = []
         for entry in results:
             if remove_passing_logs and entry['status'] == 'PASS':
                 continue
             logger.info(f"--- Logs for Item: {entry['item']} ---")
-            for level, msg in entry['logs']:
-                # Skip IGNORE level and logs below minimum level
-                if level == "IGNORE" or level_order.get(level, 1) < min_level:
+            # A copy: after an interruption, a call still running may append to it.
+            for level, msg in list(entry['logs']):
+                name = _normalize_level(level)
+                if name == "IGNORE":
                     continue
-                if level == "INFO": logger.info(msg)
-                elif level == "WARN": logger.warn(msg)
-                elif level == "ERROR": logger.error(msg)
+                if name is None:
+                    if level not in unknown_levels:
+                        unknown_levels.append(level)
+                    name, msg = "INFO", f"[{level}] {msg}"
+                if LOG_LEVELS[name] >= min_level:
+                    logger.write(msg, name)
             logger.info(f"Status: {entry['status']}")
+        for level in unknown_levels:
+            logger.warn(
+                f"Unknown log level {level!r} used with _logger: its messages were logged as INFO, "
+                "prefixed with the level. Use TRACE, DEBUG, INFO, HTML, CONSOLE, WARN, ERROR or IGNORE."
+            )
 
 # Backwards-compatible name: the class was called ParallelLibrary before the
 # package was renamed to ParallelRunner (imported as `Library    ParallelRunner`).

{robotframework_parallelrunner-0.2.1.dist-info → robotframework_parallelrunner-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-parallelrunner
-Version: 0.2.1
+Version: 0.3.1
 Summary: Run a keyword in parallel inside a single Robot Framework test case, with one clean, ordered log.html.
 License-Expression: MIT
 License-File: LICENSE
@@ -118,6 +118,10 @@ threading, buffering, and replay logic stay out of your `.robot` files.
   8 workers (see [Using It Together With pabot](#using-it-together-with-pabot)).
 - **Integrity.** Your `log.html` remains the single source of truth — no
   broken XML tags from concurrent writes.
+- **No hidden failures.** If any call fails, the keyword fails too (after all
+  calls finish and their logs are replayed), with a message listing every
+  failed item. Pass `fail_on_error=False` to get a `PASS`/`FAIL` status per
+  item and check them yourself.
 - **Flexibility.** Pass `repeat=10` to stress-test a single endpoint, or
   `for_loop_iterable=${items}` for batch validation of a whole list.
 - **Ergonomics.** Results come back in call order (not completion order), so
@@ -151,7 +155,7 @@ Concretely:
   that needs to do the same kind of work many times (loop over a list of IDs,
   or repeat something N times) — how do I parallelize the body of that loop
   without corrupting the log or needing to merge anything?" It uses a
-  `ThreadPoolExecutor` inside a single process, and produces one
+  pool of threads inside a single process, and produces one
   already-merged, already-ordered log for that test case.
 - Because ParallelRunner uses **threads**, not processes, it shares memory and
   is subject to the GIL — it is a good fit for **I/O-bound** work (network
@@ -179,7 +183,7 @@ pabot --processes 4 --pythonpath . atest/
 pabot --processes 4 --testlevelsplit --pythonpath . atest/
 ```
 
-Both commands pass the full acceptance suite of this repository (41 tests;
+Both commands pass the full acceptance suite of this repository (52 tests;
 checked with pabot 5.2.2).
 
 How much time each one saves, from the offline
@@ -226,9 +230,11 @@ Things to keep in mind:
   made thread-safe for you; your own keyword's side effects are not. If it
   writes to a shared variable, file, or object without a lock, running it
   concurrently can race the same way any multi-threaded code can.
-- **You need per-item retries or a timeout.** Not implemented yet (see
-  [ROADMAP.md](https://github.com/cristiangarciavd/robotframework-parallelrunner/blob/main/ROADMAP.md)) — one hung call currently blocks the whole batch
-  from returning.
+- **You need per-item retries or a per-item timeout.** Not implemented yet
+  (see [ROADMAP.md](https://github.com/cristiangarciavd/robotframework-parallelrunner/blob/main/ROADMAP.md)). A Robot `[Timeout]` on the test or keyword does
+  interrupt the whole batch when it expires and replays the logs collected so
+  far, but calls that are already running can't be stopped: they keep running
+  in the background until they return.
 - **You need process-level isolation** (a crash in one call shouldn't be
   able to affect another) or cross-machine parallelism — that's pabot's
   domain, not this library's.
@@ -238,7 +244,7 @@ Things to keep in mind:
 ```
 robotframework-parallelrunner/
 ├── src/ParallelRunner/     # The installable library (do not depend on internals prefixed with `_`)
-├── examples/               # Example libraries used by the tests, plus the pabot timing demo
+├── examples/               # Example libraries used by the tests, plus the pabot and log levels demos
 ├── atest/                  # Robot Framework acceptance suites
 ├── utest/                  # pytest unit tests
 ├── docs/                   # INSTALLATION, QUICKSTART, API_REFERENCE, generated keyword docs

{robotframework_parallelrunner-0.2.1.dist-info → robotframework_parallelrunner-0.3.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
 ParallelRunner/__init__.py,sha256=ifsoO1rXf4kL3i75NokrD_KHxnlvE3IuH69Fb-ByfNg,641
-ParallelRunner/parallel_library.py,sha256=wOBvPLPLC0GSc9el7O_bcVHfl5NuGKaiWGXdZKTH6do,17380
+ParallelRunner/parallel_library.py,sha256=wF-gIBbVl2D0qD9GGL5dnC49KpGl1Sfy_fq50kKMHyQ,28018
 ParallelRunner/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ParallelRunner/version.py,sha256=W8E8ymdTLqfKl_1qBIOrjGpO8kSbqPw30aYZpqYUNMk,632
 parallelrunner.py,sha256=2oyKOVeKlOaZUZ3f2i_l5xCAYFKVm11bSQZOtzSSJO8,1132
-robotframework_parallelrunner-0.2.1.dist-info/METADATA,sha256=9VmBqhZ3dMGu9_onf6S8afWTGbr-130YVHWuDHWZJ0M,14053
-robotframework_parallelrunner-0.2.1.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
-robotframework_parallelrunner-0.2.1.dist-info/licenses/LICENSE,sha256=xxQh3uvlk5jC1i0eoH5Nyo9cDz2Fzu0DqOzAZw8XxFs,1072
-robotframework_parallelrunner-0.2.1.dist-info/RECORD,,
+robotframework_parallelrunner-0.3.1.dist-info/METADATA,sha256=qkPgEByTDt4P8tbArMmtXEuTmqmczGrBPJDTUFdj5iM,14501
+robotframework_parallelrunner-0.3.1.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
+robotframework_parallelrunner-0.3.1.dist-info/licenses/LICENSE,sha256=xxQh3uvlk5jC1i0eoH5Nyo9cDz2Fzu0DqOzAZw8XxFs,1072
+robotframework_parallelrunner-0.3.1.dist-info/RECORD,,