robotframework-pabot 4.1.1__py3-none-any.whl → 4.3.0__py3-none-any.whl

pabot/__init__.py

@@ -1,5 +1,10 @@
 from __future__ import absolute_import
 
-from .pabotlib import PabotLib
+# Avoid import errors during setup/build
+try:
+    from .pabotlib import PabotLib
+    __all__ = ["PabotLib"]
+except ImportError:
+    pass
 
-__version__ = "4.1.1"
+__version__ = "4.3.0"

pabot/arguments.py

@@ -1,5 +1,9 @@
+import atexit
 import multiprocessing
+import os
+import glob
 import re
+import tempfile
 from typing import Dict, List, Optional, Tuple
 
 from robot import __version__ as ROBOT_VERSION
@@ -16,6 +20,7 @@ from .execution_items import (
     SuiteItem,
     TestItem,
     WaitItem,
+    SleepItem,
 )
 
 ARGSMATCHER = re.compile(r"--argumentfile(\d+)")
@@ -65,9 +70,72 @@ def parse_args(
         options_for_subprocesses["name"] = "Suites"
     opts = _delete_none_keys(options)
     opts_sub = _delete_none_keys(options_for_subprocesses)
+    _replace_arg_files(pabot_args, opts_sub)
     return opts, datasources, pabot_args, opts_sub
 
 
+# remove options from argumentfile according to different scenarios.
+# -t/--test/--task shall be removed if --testlevelsplit options exists
+# -s/--suite shall be removed if --testlevelsplit options does not exist
+def _replace_arg_files(pabot_args, opts_sub):
+    _cleanup_old_pabot_temp_files()
+    if not opts_sub.get('argumentfile') or not opts_sub['argumentfile']:
+        return
+    arg_file_list = opts_sub['argumentfile']
+    temp_file_list = []
+    test_level = pabot_args.get('testlevelsplit')
+
+    for arg_file_path in arg_file_list:
+        with open(arg_file_path, 'r') as arg_file:
+            arg_file_lines = arg_file.readlines()
+        if not arg_file_lines:
+            continue
+
+        fd, temp_path = tempfile.mkstemp(prefix="pabot_temp_", suffix=".txt")
+        with os.fdopen(fd, 'wb') as temp_file:
+            for line in arg_file_lines:
+                if test_level and _is_test_option(line):
+                    continue
+                elif not test_level and _is_suite_option(line):
+                    continue
+                temp_file.write(line.encode('utf-8'))
+
+        temp_file_list.append(temp_path)
+
+    opts_sub['argumentfile'] = temp_file_list
+    atexit.register(cleanup_temp_file, temp_file_list)
+
+
+def _is_suite_option(line):
+    return line.startswith('-s ') or line.startswith('--suite ')
+
+
+def _is_test_option(line):
+    return line.startswith('-t ') or line.startswith('--test ') or line.startswith('--task ')
+
+
+# clean the temp argument files before exiting the pabot process
+def cleanup_temp_file(temp_file_list):
+    for temp_file in temp_file_list:
+        if os.path.exists(temp_file):
+            try:
+                os.remove(temp_file)
+            except Exception:
+                pass
+
+
+# Deletes all possible pabot_temp_ files from os temp directory
+def _cleanup_old_pabot_temp_files():
+    temp_dir = tempfile.gettempdir()
+    pattern = os.path.join(temp_dir, "pabot_temp_*.txt")
+    old_files = glob.glob(pattern)
+    for file_path in old_files:
+        try:
+            os.remove(file_path)
+        except Exception:
+            pass
+
+
 def _parse_shard(arg):
     # type: (str) -> Tuple[int, int]
     parts = arg.split("/")
@@ -91,6 +159,7 @@ def _parse_pabot_args(args):  # type: (List[str]) -> Tuple[List[str], Dict[str,
         "shardindex": 0,
         "shardcount": 1,
         "chunk": False,
+        "no-rebot": False,
     }
     # Explicitly define argument types for validation
     flag_args = {
@@ -100,6 +169,7 @@ def _parse_pabot_args(args):  # type: (List[str]) -> Tuple[List[str], Dict[str,
         "pabotlib",
         "artifactsinsubfolders",
         "chunk",
+        "no-rebot"
     }
     value_args = {
         "hive": str,
@@ -217,6 +287,8 @@ def parse_execution_item_line(text):  # type: (str) -> ExecutionItem
     if text.startswith("DYNAMICTEST"):
         suite, test = text[12:].split(" :: ")
         return DynamicTestItem(test, suite)
+    if text.startswith("#SLEEP "):
+        return SleepItem(text[7:])
     if text == "#WAIT":
         return WaitItem()
     if text == "{":

pabot/execution_items.py

@@ -7,11 +7,46 @@ from robot.utils import PY2, is_unicode
 
 import re
 
+
+def create_dependency_tree(items):  
+    # type: (List[ExecutionItem]) -> List[List[ExecutionItem]]
+    independent_tests = list(filter(lambda item: not item.depends, items))
+    dependency_tree = [independent_tests]
+    dependent_tests = list(filter(lambda item: item.depends, items))
+    unknown_dependent_tests = dependent_tests
+    while len(unknown_dependent_tests) > 0:
+        run_in_this_stage, run_later = [], []
+        for d in unknown_dependent_tests:
+            stage_indexes = []
+            for i, stage in enumerate(dependency_tree):
+                for test in stage:
+                    if test.name in d.depends:
+                        stage_indexes.append(i)
+            # All #DEPENDS test are already run:
+            if len(stage_indexes) == len(d.depends):
+                run_in_this_stage.append(d)
+            else:
+                run_later.append(d)
+        unknown_dependent_tests = run_later
+        if len(run_in_this_stage) == 0:
+            text = "There are circular or unmet dependencies using #DEPENDS. Check this/these test(s): " + str(run_later)
+            raise DataError(text)
+        else:
+            dependency_tree.append(run_in_this_stage)
+    flattened_dependency_tree = sum(dependency_tree, [])
+    if len(flattened_dependency_tree) != len(items):
+        raise DataError(
+            "Invalid test configuration: Circular or unmet dependencies detected between test suites. Please check your #DEPENDS definitions."
+        )
+    return dependency_tree
+
+
 @total_ordering
 class ExecutionItem(object):
     isWait = False
     type = None  # type: str
     name = None  # type: str
+    sleep = 0  # type: int
 
     def top_name(self):
         # type: () -> str
@@ -29,6 +64,14 @@ class ExecutionItem(object):
         # type: () -> str
         return ""
 
+    def set_sleep(self, sleep_time):
+        # type: (int) -> None
+        self.sleep = sleep_time
+
+    def get_sleep(self):
+        # type: () -> int
+        return self.sleep
+
     def modify_options_for_executor(self, options):
         options[self.type] = self.name
 
@@ -69,7 +112,7 @@ class GroupItem(ExecutionItem):
     type = "group"
 
     def __init__(self):
-        self.name = "Group_"
+        self.name = "Group"
         self._items = []
         self._element_type = None
 
@@ -82,11 +125,26 @@ class GroupItem(ExecutionItem):
             )
         if len(self._items) > 0:
             self.name += "_"
+        if self.get_sleep() < item.get_sleep():
+            self.set_sleep(item.get_sleep())
         self.name += item.name
         self._element_type = item.type
         self._items.append(item)
+    
+    def change_items_order_by_depends(self):
+        ordered_name = "Group"
+        dependency_tree = create_dependency_tree(self._items)
+        ordered = [item for sublist in dependency_tree for item in sublist]
+        for item in ordered:
+            ordered_name += f"_{item.name}"
+        self.name = ordered_name
+        self._items = ordered
 
     def modify_options_for_executor(self, options):
+        # Since a GroupItem contains either tests or suites, options are cleared
+        # and only the Group's content is used to avoid duplicate execution.
+        options['suite'] = []
+        options['test'] = []
         for item in self._items:
             if item.type not in options:
                 options[item.type] = []
@@ -120,6 +178,7 @@ class RunnableItem(ExecutionItem):
             if len(depends_indexes) == 0
             else line_name[0:depends_indexes[0]].strip()
         )
+        assert len(self.name) != 0, f"Suite or test name cannot be empty and then contain #DEPENDS like: {name}"
         self.depends = (
             self._split_dependencies(line_name, depends_indexes)
             if len(depends_indexes) != 0
@@ -197,6 +256,8 @@ class TestItem(RunnableItem):
         def modify_options_for_executor(self, options):
             if "rerunfailed" in options:
                 del options["rerunfailed"]
+            if "rerunfailedsuites" in options:
+                del options["rerunfailedsuites"]
             name = self.name
             for char in ["[", "?", "*"]:
                 name = name.replace(char, "[" + char + "]")
@@ -207,6 +268,8 @@ class TestItem(RunnableItem):
         def modify_options_for_executor(self, options):
             if "rerunfailed" in options:
                 del options["rerunfailed"]
+            if "rerunfailedsuites" in options:
+                del options["rerunfailedsuites"]
 
     def difference(self, from_items):
         # type: (List[ExecutionItem]) -> List[ExecutionItem]
@@ -274,6 +337,23 @@ class WaitItem(ExecutionItem):
         return self.name
 
 
+class SleepItem(ExecutionItem):
+    type = "sleep"
+
+    def __init__(self, time):
+        try:
+            assert 3600 >= int(time) >= 0  # 1 h max.
+            self.name = time
+            self.sleep = int(time)
+        except ValueError:
+            raise ValueError("#SLEEP value %s is not integer" % time)
+        except AssertionError:
+            raise ValueError("#SLEEP value %s is not in between 0 and 3600" % time)
+
+    def line(self):
+        return "#SLEEP " + self.name
+
+
 class GroupStartItem(ExecutionItem):
     type = "group"
 

pabot/pabot.py

@@ -41,6 +41,7 @@ import threading
 import time
 import traceback
 import uuid
+import copy
 from collections import namedtuple
 from contextlib import closing
 from glob import glob
@@ -78,6 +79,8 @@ from .execution_items import (
     SuiteItems,
     TestItem,
     RunnableItem,
+    SleepItem,
+    create_dependency_tree,
 )
 from .result_merger import merge
 
@@ -262,6 +265,7 @@ def execute_and_wait_with(item):
                 item.index,
                 item.execution_item.type != "test",
                 process_timeout=item.timeout,
+                sleep_before_start=item.sleep_before_start
             )
         outputxml_preprocessing(
             item.options, outs_dir, name, item.verbose, _make_id(), caller_id
@@ -287,7 +291,9 @@ def _create_command_for_execution(caller_id, datasources, is_last, item, outs_di
             item.last_level,
             item.processes,
         )
-        + datasources
+        # If the datasource ends with a backslash '\', it is deleted to ensure 
+        # correct handling of the escape character later on.
+        + [os.path.normpath(s) for s in datasources]
     )
     return _mapOptionalQuote(cmd)
 
@@ -320,8 +326,9 @@ def _try_execute_and_wait(
     my_index=-1,
     show_stdout_on_failure=False,
     process_timeout=None,
+    sleep_before_start=0
 ):
-    # type: (List[str], str, str, bool, int, str, int, bool, Optional[int]) -> None
+    # type: (List[str], str, str, bool, int, str, int, bool, Optional[int], int) -> None
     plib = None
     is_ignored = False
     if _pabotlib_in_use():
@@ -339,6 +346,7 @@ def _try_execute_and_wait(
                     my_index,
                     outs_dir,
                     process_timeout,
+                    sleep_before_start
                 )
     except:
         _write(traceback.format_exc())
@@ -521,8 +529,16 @@ def _run(
     item_index,
     outs_dir,
     process_timeout,
+    sleep_before_start,
 ):
-    # type: (List[str], IO[Any], IO[Any], str, bool, int, int, str, Optional[int]) -> Tuple[Union[subprocess.Popen[bytes], subprocess.Popen], Tuple[int, float]]
+    # type: (List[str], IO[Any], IO[Any], str, bool, int, int, str, Optional[int], int) -> Tuple[Union[subprocess.Popen[bytes], subprocess.Popen], Tuple[int, float]]
+    timestamp = datetime.datetime.now()
+    if sleep_before_start > 0:
+        _write(
+            "%s [%s] [ID:%s] SLEEPING %s SECONDS BEFORE STARTING %s"
+            % (timestamp, pool_id, item_index, sleep_before_start, item_name),
+        )
+        time.sleep(sleep_before_start)
     timestamp = datetime.datetime.now()
     cmd = " ".join(command)
     if PY2:
@@ -748,6 +764,7 @@ def _options_to_cli_arguments(opts):  # type: (dict) -> List[str]
 
 
 def _group_by_groups(tokens):
+    # type: (List[ExecutionItem]) -> List[ExecutionItem]
     result = []
     group = None
     for token in tokens:
@@ -757,6 +774,7 @@ def _group_by_groups(tokens):
                     "Ordering: Group can not contain a group. Encoutered '{'"
                 )
             group = GroupItem()
+            group.set_sleep(token.get_sleep())
             result.append(group)
             continue
         if isinstance(token, GroupEndItem):
@@ -764,6 +782,7 @@ def _group_by_groups(tokens):
                 raise DataError(
                     "Ordering: Group end tag '}' encountered before start '{'"
                 )
+            group.change_items_order_by_depends()
             group = None
             continue
         if group is not None:
@@ -935,6 +954,13 @@ def solve_suite_names(outs_dir, datasources, options, pabot_args):
             )
             execution_item_lines = [parse_execution_item_line(l) for l in lines[4:]]
             if corrupted or h != file_h or file_hash != hash_of_file or pabot_args.get("pabotprerunmodifier"):
+                if file_h is not None and file_h[0] != h[0] and file_h[2] == h[2]:
+                    suite_names = _levelsplit(
+                        generate_suite_names_with_builder(outs_dir, datasources, options),
+                        pabot_args,
+                    )
+                    store_suite_names(h, suite_names)
+                    return suite_names
                 return _regenerate(
                     file_h,
                     h,
@@ -964,7 +990,8 @@ def _levelsplit(
 
 
 def _group_by_wait(lines):
-    suites = [[]]  # type: List[List[ExecutionItem]]
+    # type: (List[ExecutionItem]) -> List[List[ExecutionItem]]
+    suites = [[]]
     for suite in lines:
         if not suite.isWait:
             if suite:
@@ -1067,8 +1094,6 @@ def _fix_items(items):  # type: (List[ExecutionItem]) -> List[ExecutionItem]
     _remove_empty_groups(result)
     if result and result[0].isWait:
         result = result[1:]
-    if result and result[-1].isWait:
-        result = result[:-1]
     return result
 
 
@@ -1313,6 +1338,8 @@ def _options_for_rebot(options, start_time_string, end_time_string):
     rebot_options["test"] = []
     rebot_options["exclude"] = []
     rebot_options["include"] = []
+    if rebot_options.get("runemptysuite"):
+        rebot_options["processemptysuite"] = True
     if ROBOT_VERSION >= "2.8":
         options["monitormarkers"] = "off"
     for key in [
@@ -1337,6 +1364,7 @@ def _options_for_rebot(options, start_time_string, end_time_string):
         "randomize",
         "runemptysuite",
         "rerunfailed",
+        "rerunfailedsuites",
         "skip",
         "skiponfailure",
         "skipteardownonexit",
@@ -1455,6 +1483,19 @@ def _copy_output_artifacts(options, file_extensions=None, include_subfolders=Fal
     return copied_artifacts
 
 
+def _check_pabot_results_for_missing_xml(base_dir):
+    missing = []
+    for root, dirs, _ in os.walk(base_dir):
+        if root == base_dir:
+            for subdir in dirs:
+                subdir_path = os.path.join(base_dir, subdir)
+                has_xml = any(fname.endswith('.xml') for fname in os.listdir(subdir_path))
+                if not has_xml:
+                    missing.append(os.path.join(subdir_path, 'robot_stderr.out'))
+            break
+    return missing
+
+
 def _report_results(outs_dir, pabot_args, options, start_time_string, tests_root_name):
     if "pythonpath" in options:
         del options["pythonpath"]
@@ -1470,6 +1511,7 @@ def _report_results(outs_dir, pabot_args, options, start_time_string, tests_root
             "failed": 0,
             "skipped": 0,
         }
+    missing_outputs = []
     if pabot_args["argumentfiles"]:
         outputs = []  # type: List[str]
         for index, _ in pabot_args["argumentfiles"]:
@@ -1486,14 +1528,27 @@ def _report_results(outs_dir, pabot_args, options, start_time_string, tests_root
                     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)))
         if "output" not in options:
             options["output"] = "output.xml"
         _write_stats(stats)
-        return rebot(*outputs, **_options_for_rebot(options, start_time_string, _now()))
+        exit_code = rebot(*outputs, **_options_for_rebot(options, start_time_string, _now()))
     else:
-        return _report_results_for_one_run(
+        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))
+    if missing_outputs:
+        _write(("[ " + _wrap_with(Color.YELLOW, 'WARNING') + " ] "
+                "One or more subprocesses encountered an error and the "
+                "internal .xml files could not be generated. Please check the "
+                "following stderr files to identify the cause:"))
+        for missing in missing_outputs:
+            _write(repr(missing))
+        _write((f"[ " + _wrap_with(Color.RED, 'ERROR') + " ] "
+                "The output, log and report files produced by Pabot are "
+                "incomplete and do not contain all test cases."))
+    return exit_code if not missing_outputs else 252
 
 
 def _write_stats(stats):
@@ -1528,9 +1583,9 @@ def _report_results_for_one_run(
     _write_stats(stats)
     if (
         "report" in options
-        and options["report"] == "NONE"
+        and options["report"].upper() == "NONE"
         and "log" in options
-        and options["log"] == "NONE"
+        and options["log"].upper() == "NONE"
     ):
         options[
             "output"
@@ -1735,6 +1790,7 @@ class QueueItem(object):
         self.hive = hive
         self.processes = processes
         self.timeout = timeout
+        self.sleep_before_start = execution_item.get_sleep()
 
     @property
     def index(self):
@@ -1845,19 +1901,28 @@ def _chunk_items(items, chunk_size):
         base_item = chunked_items[0]
         if not base_item:
             continue
-        execution_items = SuiteItems([item.execution_item for item in chunked_items])
-        chunked_item = QueueItem(
-            base_item.datasources,
-            base_item.outs_dir,
-            base_item.options,
-            execution_items,
-            base_item.command,
-            base_item.verbose,
-            (base_item.argfile_index, base_item.argfile),
-            processes=base_item.processes,
-            timeout=base_item.timeout,
-        )
-        yield chunked_item
+        if isinstance(base_item.execution_item, TestItem):
+            for item in chunked_items:
+                chunked_item = _queue_item(base_item, item.execution_item)
+                yield chunked_item
+        else:
+            execution_items = SuiteItems([item.execution_item for item in chunked_items])
+            chunked_item = _queue_item(base_item, execution_items)
+            yield chunked_item
+
+
+def _queue_item(base_item, execution_items):
+    return QueueItem(
+        base_item.datasources,
+        base_item.outs_dir,
+        base_item.options,
+        execution_items,
+        base_item.command,
+        base_item.verbose,
+        (base_item.argfile_index, base_item.argfile),
+        processes=base_item.processes,
+        timeout=base_item.timeout,
+    )
 
 
 def _find_ending_level(name, group):
@@ -1969,8 +2034,8 @@ def main_program(args):
         options, datasources, pabot_args, opts_for_run = parse_args(args)
         if pabot_args["help"]:
             help_print = __doc__.replace(
-                "PLACEHOLDER_README.MD",
-                read_args_from_readme()
+                    "PLACEHOLDER_README.MD",
+                    read_args_from_readme()
                 )
             print(help_print.replace("[PABOT_VERSION]", PABOT_VERSION))
             return 0
@@ -2002,6 +2067,14 @@ def main_program(args):
                 opts_for_run,
                 pabot_args,
             )
+        if pabot_args["no-rebot"]:
+            _write((
+                "All tests were executed, but the --no-rebot argument was given, "
+                "so the results were not compiled, and no summary was generated. "
+                f"All results have been saved in the {outs_dir} folder."
+            ))
+            _write("===================================================")
+            return 0 if not _ABNORMAL_EXIT_HAPPENED else 252
         result_code = _report_results(
             outs_dir,
             pabot_args,
@@ -2039,19 +2112,40 @@ def _parse_ordering(filename):  # type: (str) -> List[ExecutionItem]
         with open(filename, "r") as orderingfile:
             return [
                 parse_execution_item_line(line.strip())
-                for line in orderingfile.readlines()
+                for line in orderingfile.readlines() if line.strip() != ""
             ]
     except FileNotFoundError:
         raise DataError("Error: File '%s' not found." % filename)
-    except:
+    except (ValueError, AssertionError) as e:
+        raise DataError("Error in ordering file: %s: %s" % (filename, e))
+    except Exception:
         raise DataError("Error parsing ordering file '%s'" % filename)
 
 
+def _check_ordering(ordering_file, suite_names):  # type: (List[ExecutionItem], List[ExecutionItem]) -> None
+    list_of_suite_names = [s.name for s in suite_names]
+    number_of_tests_or_suites = 0
+    if ordering_file:
+        for item in ordering_file:
+            if item.type in ['suite', 'test']:
+                if not any((s == item.name or s.endswith("." + item.name)) for s in list_of_suite_names):
+                    # If test name is too long, it gets name ' Invalid', so skip that
+                    if item.name != ' Invalid':
+                        raise DataError("%s item '%s' in --ordering file does not match suite or test names in .pabotsuitenames file.\nPlease verify content of --ordering file." % (item.type.title(), item.name))
+                number_of_tests_or_suites += 1
+        if number_of_tests_or_suites > len(list_of_suite_names):
+            raise DataError('Ordering file contains more tests and/or suites than exists. Check that there is no duplicates etc. in ordering file and that to .pabotsuitenames.')
+
+
 def _group_suites(outs_dir, datasources, options, pabot_args):
     suite_names = solve_suite_names(outs_dir, datasources, options, pabot_args)
     _verify_depends(suite_names)
     ordering_arg = _parse_ordering(pabot_args.get("ordering")) if (pabot_args.get("ordering")) is not None else None
-    ordered_suites = _preserve_order(suite_names, ordering_arg)
+    if ordering_arg:
+        _verify_depends(ordering_arg)
+        _check_ordering(ordering_arg, suite_names)
+    ordering_arg_with_sleep = _set_sleep_times(ordering_arg)
+    ordered_suites = _preserve_order(suite_names, ordering_arg_with_sleep)
     shard_suites = solve_shard_suites(ordered_suites, pabot_args)
     grouped_suites = (
         _chunked_suite_names(shard_suites, pabot_args["processes"])
@@ -2062,6 +2156,29 @@ def _group_suites(outs_dir, datasources, options, pabot_args):
     return grouped_by_depend
 
 
+def _set_sleep_times(ordering_arg):
+    # type: (List[ExecutionItem]) -> List[ExecutionItem]
+    set_sleep_value = 0
+    in_group = False
+    output = copy.deepcopy(ordering_arg)
+    if output is not None:
+        if len(output) >= 2:
+            for i in range(len(output) - 1):
+                if isinstance(output[i], SleepItem):
+                    set_sleep_value = output[i].get_sleep()
+                else:
+                    set_sleep_value = 0
+                if isinstance(output[i], GroupStartItem):
+                    in_group = True
+                if isinstance(output[i], GroupEndItem):
+                    in_group = False
+                if isinstance(output[i + 1], GroupStartItem) and set_sleep_value > 0:
+                    output[i + 1].set_sleep(set_sleep_value)
+                if isinstance(output[i + 1], RunnableItem) and set_sleep_value > 0 and not in_group:
+                    output[i + 1].set_sleep(set_sleep_value)
+    return output
+
+
 def _chunked_suite_names(suite_names, processes):
     q, r = divmod(len(suite_names), processes)
     result = []
@@ -2086,7 +2203,7 @@ def _verify_depends(suite_names):
     suites_with_found_dependencies = list(
         filter(
             lambda suite: any(
-                runnable_suite.name == suite.depends
+                runnable_suite.name in suite.depends
                 for runnable_suite in runnable_suites
             ),
             suites_with_depends,
@@ -2097,63 +2214,31 @@ def _verify_depends(suite_names):
             "Invalid test configuration: Some test suites have dependencies (#DEPENDS) that cannot be found."
         )
     suites_with_circular_dependencies = list(
-        filter(lambda suite: suite.depends == suite.name, suites_with_depends)
+        filter(lambda suite: suite.name in suite.depends, suites_with_depends)
     )
     if suites_with_circular_dependencies:
         raise DataError(
             "Invalid test configuration: Test suites cannot depend on themselves."
         )
-    grouped_suites = list(
-        filter(lambda suite: isinstance(suite, GroupItem), suite_names)
-    )
-    if grouped_suites and suites_with_depends:
-        raise DataError(
-            "Invalid test configuration: Cannot use both #DEPENDS and grouped suites."
-        )
 
 
 def _group_by_depend(suite_names):
+    # type: (List[ExecutionItem]) -> List[List[ExecutionItem]]
     group_items = list(filter(lambda suite: isinstance(suite, GroupItem), suite_names))
     runnable_suites = list(
         filter(lambda suite: isinstance(suite, RunnableItem), suite_names)
     )
-    if group_items or not runnable_suites:
-        return [suite_names]
-    independent_tests = list(filter(lambda suite: not suite.depends, runnable_suites))
-    dependency_tree = [independent_tests]
-    dependent_tests = list(filter(lambda suite: suite.depends, runnable_suites))
-    unknown_dependent_tests = dependent_tests
-    while len(unknown_dependent_tests) > 0:
-        run_in_this_stage, run_later = [], []
-        for d in unknown_dependent_tests:
-            stage_indexes = []
-            for i, stage in enumerate(dependency_tree):
-                for test in stage:
-                    if test.name in d.depends:
-                        stage_indexes.append(i)
-            # All #DEPENDS test are already run:
-            if len(stage_indexes) == len(d.depends):
-                run_in_this_stage.append(d)
-            else:
-                run_later.append(d)
-        unknown_dependent_tests = run_later
-        if len(run_in_this_stage) == 0:
-            text = "There are circular or unmet dependencies using #DEPENDS. Check this/these test(s): " + str(run_later)
-            raise DataError(text)
-        else:
-            dependency_tree.append(run_in_this_stage)
-    flattened_dependency_tree = sum(dependency_tree, [])
-    if len(flattened_dependency_tree) != len(runnable_suites):
-        raise DataError(
-            "Invalid test configuration: Circular or unmet dependencies detected between test suites. Please check your #DEPENDS definitions."
-        )
+    dependency_tree = create_dependency_tree(runnable_suites)
+    # Since groups cannot depend on others, they are placed at the beginning.
+    dependency_tree[0][0:0] = group_items
     return dependency_tree
 
 
 def _all_grouped_suites_by_depend(grouped_suites):
+    # type: (List[List[ExecutionItem]]) -> List[List[ExecutionItem]]
     grouped_by_depend = []
-    for group_suite in grouped_suites:
-        grouped_by_depend += _group_by_depend(group_suite)
+    for group_suite in grouped_suites:  # These groups are divided by #WAIT
+        grouped_by_depend.extend(_group_by_depend(group_suite))
     return grouped_by_depend
 
 

{robotframework_pabot-4.1.1.dist-info → robotframework_pabot-4.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: robotframework-pabot
-Version: 4.1.1
+Version: 4.3.0
 Summary: Parallel test runner for Robot Framework
 Home-page: https://pabot.org
 Download-URL: https://pypi.python.org/pypi/robotframework-pabot
@@ -22,6 +22,7 @@ Requires-Dist: robotframework>=3.2
 Requires-Dist: robotframework-stacktrace>=0.4.1
 Requires-Dist: natsort>=8.2.0
 Dynamic: download-url
+Dynamic: license-file
 
 # Pabot
 
@@ -88,9 +89,10 @@ pabot [--verbose|--testlevelsplit|--command .. --end-command|
         --processtimeout num|
         --shard i/n|
         --artifacts extensions|--artifactsinsubfolders|
-        --resourcefile file|--argumentfile[num] file|--suitesfrom file|--ordering file
-        --chunk
-        --pabotprerunmodifier modifier
+        --resourcefile file|--argumentfile[num] file|--suitesfrom file|--ordering file|
+        --chunk|
+        --pabotprerunmodifier modifier|
+        --no-rebot|
         --help|--version]
       [robot options] [path ...]
 
@@ -154,7 +156,7 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
   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.
 
---argumentfile [INTEGER] [FILEPATH]          
+--argumentfile[INTEGER] [FILEPATH]          
   Run same suites with multiple [argumentfile](http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#argument-files) options.
 
   For example:
@@ -178,11 +180,16 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
   pabot subprocesses. Depending on the intended use, this may be desirable as well as more efficient. Can be used, for 
   example, to modify the list of tests to be performed.
 
- --help             
- Print usage instructions.
+--no-rebot    
+  If specified, the tests will execute as usual, but Rebot will not be called to merge the logs. This option is designed 
+  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.
+
+--help             
+  Print usage instructions.
  
- --version                
- Print version information.
+--version                
+  Print version information.
 
 Example usages:
 
@@ -259,14 +266,18 @@ After this come the suite names.
 
 With ```--ordering FILENAME``` you can have a list that controls order also. The syntax is same as .pabotsuitenames file syntax but does not contain 4 hash rows that are present in .pabotsuitenames. 
 
+Note: The `--ordering` file is intended only for defining the execution order of suites and tests. The actual selection of what to run must still be done using options like `--test`, `--suite`, `--include`, or `--exclude`.
+
 There different possibilities to influence the execution:
 
   * The order of suites can be changed.
   * If a directory (or a directory structure) should be executed sequentially, add the directory suite name to a row as a ```--suite``` option.
   * If the base suite name is changing with robot option [```--name / -N```](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#setting-the-name) you can also give partial suite name without the base suite.
-  * You can add a line with text `#WAIT` to force executor to wait until all previous suites have been executed.
-  * You can group suites and tests together to same executor process by adding line `{` before the group and `}`after.
-  * You can introduce dependencies using the word `#DEPENDS` after a test declaration. Can be used several times if it is necessary to refer to several different tests. Please take care that in case of circular dependencies an exception will be thrown. An example could be.
+  * You can add a line with text  to force executor to wait until all previous suites have been executed.
+  * You can group suites and tests together to same executor process by adding line `{` before the group and `}` after. Note that `#WAIT` cannot be used inside a group.
+  * You can introduce dependencies using the word `#DEPENDS` after a test declaration. This keyword can be used several times if it is necessary to refer to several different tests. Please take care that in case of circular dependencies an exception will be thrown. Note that each `#WAIT` splits suites into separate execution blocks, and it's not possible to define dependencies for suites or tests that are inside another `#WAIT` block or inside another `{}` brackets.
+  * Note: Within a group `{}`, neither execution order nor the `#DEPENDS` keyword currently works. This is due to limitations in Robot Framework, which is invoked within Pabot subprocesses. These limitations may be addressed in a future release of Robot Framework. For now, tests or suites within a group will be executed in the order Robot Framework discovers them — typically in alphabetical order.
+  * An example could be:
 
 ```
 --test robotTest.1 Scalar.Test With Environment Variables #DEPENDS robotTest.1 Scalar.Test with BuiltIn Variables of Robot Framework
@@ -274,8 +285,10 @@ There different possibilities to influence the execution:
 --test robotTest.2 Lists.Test with Keywords and a list
 #WAIT
 --test robotTest.2 Lists.Test with a Keyword that accepts multiple arguments
+{
 --test robotTest.2 Lists.Test with some Collections keywords
 --test robotTest.2 Lists.Test to access list entries
+}
 --test robotTest.3 Dictionary.Test that accesses Dictionaries
 --test robotTest.3 Dictionary.Dictionaries for named arguments #DEPENDS robotTest.3 Dictionary.Test that accesses Dictionaries
 --test robotTest.1 Scalar.Test Case With Variables #DEPENDS robotTest.3 Dictionary.Test that accesses Dictionaries
@@ -284,6 +297,51 @@ There different possibilities to influence the execution:
 --test robotTest.1 Scalar.Test With Arguments and Return Values
 --test robotTest.3 Dictionary.Test with Dictionaries as Arguments
 --test robotTest.3 Dictionary.Test with FOR loops and Dictionaries #DEPENDS robotTest.1 Scalar.Test Case with Return Values
+```
+
+  * By using the command `#SLEEP X`, where `X` is an integer in the range [0-3600] (in seconds), you can 
+  define a startup delay for each subprocess. `#SLEEP` affects the next line unless the next line starts a 
+  group with `{`, in which case the delay applies to the entire group. If the next line begins with `--test` 
+  or `--suite`, the delay is applied to that specific item. Any other occurrences of `#SLEEP` are ignored. 
+  Note that `#SLEEP` has no effect within a group, i.e., inside a subprocess.
+
+The following example clarifies the behavior:
+
+```sh
+pabot --processes 2 --ordering order.txt data_1
+```
+
+where order.txt is:
+
+```
+#SLEEP 1
+{
+#SLEEP 2
+--suite Data 1.suite A
+#SLEEP 3
+--suite Data 1.suite B
+#SLEEP 4
+}
+#SLEEP 5
+#SLEEP 6
+--suite Data 1.suite C
+#SLEEP 7
+--suite Data 1.suite D
+#SLEEP 8
+```
+
+prints something like this:
+
+```
+2025-02-15 19:15:00.408321 [0] [ID:1] SLEEPING 6 SECONDS BEFORE STARTING Data 1.suite C
+2025-02-15 19:15:00.408321 [1] [ID:0] SLEEPING 1 SECONDS BEFORE STARTING Group_Data 1.suite A_Data 1.suite B
+2025-02-15 19:15:01.409389 [PID:52008] [1] [ID:0] EXECUTING Group_Data 1.suite A_Data 1.suite B
+2025-02-15 19:15:06.409024 [PID:1528] [0] [ID:1] EXECUTING Data 1.suite C
+2025-02-15 19:15:09.257564 [PID:52008] [1] [ID:0] PASSED Group_Data 1.suite A_Data 1.suite B in 7.8 seconds
+2025-02-15 19:15:09.259067 [1] [ID:2] SLEEPING 7 SECONDS BEFORE STARTING Data 1.suite D
+2025-02-15 19:15:09.647342 [PID:1528] [0] [ID:1] PASSED Data 1.suite C in 3.2 seconds
+2025-02-15 19:15:16.260432 [PID:48156] [1] [ID:2] EXECUTING Data 1.suite D
+2025-02-15 19:15:18.696420 [PID:48156] [1] [ID:2] PASSED Data 1.suite D in 2.4 seconds
 ```
 
 ### Programmatic use

{robotframework_pabot-4.1.1.dist-info → robotframework_pabot-4.3.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 pabot/SharedLibrary.py,sha256=mIipGs3ZhKYEakKprcbrMI4P_Un6qI8gE7086xpHaLY,2552
-pabot/__init__.py,sha256=KIz2lUOAX4LIQ5wjdtv4z7UJ4g2DDn7QCTslKSdY4NA,94
-pabot/arguments.py,sha256=XBaWujhuw_5dnZnEwAJcl4mArgzMkjNfNHBty6jqZRo,6842
+pabot/__init__.py,sha256=uuwf2W7FsicbiL8y-0LayoZ4Ztsqa2N2yJAgcz2EUoE,200
+pabot/arguments.py,sha256=m38y8mXKJ5BHlxSrsEI0gXlkzR5hv88G9i-FL_BouQ4,9168
 pabot/clientwrapper.py,sha256=yz7battGs0exysnDeLDWJuzpb2Q-qSjitwxZMO2TlJw,231
 pabot/coordinatorwrapper.py,sha256=nQQ7IowD6c246y8y9nsx0HZbt8vS2XODhPVDjm-lyi0,195
-pabot/execution_items.py,sha256=qs15SZjGE5CQAO0UpNuVWZ60wTLdWGDK1CkbBz7JtfQ,8892
-pabot/pabot.py,sha256=WrQsrgUVQZmzmfYLu0m01c2nbyc_Aj-Kz8sTpPo2jC8,70522
+pabot/execution_items.py,sha256=HCd54LsIEZJjnL0TZC_tuac2DSVL4JHes6veJlpCE94,12058
+pabot/pabot.py,sha256=GtoxhW3NTIE7It8IXtl-m6t0x0GkuT9kx2YkQs4OWhE,74910
 pabot/pabotlib.py,sha256=FRZKaKy1ybyRkE-0SpaCsUWzxZAzNNU5dAywSm1QoPk,22324
 pabot/result_merger.py,sha256=8iIptBn5MdgiW-OdhwVR2DZ0hUYuQeQXwIHAEPkMTuw,9095
 pabot/robotremoteserver.py,sha256=L3O2QRKSGSE4ux5M1ip5XJMaelqaxQWJxd9wLLdtpzM,22272
@@ -14,9 +14,9 @@ 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-4.1.1.dist-info/LICENSE.txt,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-robotframework_pabot-4.1.1.dist-info/METADATA,sha256=5cHJ-pp3VvOWIjwvrCbBdcVt2_wtBdZHnBvXlD_x-aw,13484
-robotframework_pabot-4.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-robotframework_pabot-4.1.1.dist-info/entry_points.txt,sha256=JpAIFADTeFOQWdwmn56KpAil8V3-41ZC5ICXCYm3Ng0,43
-robotframework_pabot-4.1.1.dist-info/top_level.txt,sha256=t3OwfEAsSxyxrhjy_GCJYHKbV_X6AIsgeLhYeHvObG4,6
-robotframework_pabot-4.1.1.dist-info/RECORD,,
+robotframework_pabot-4.3.0.dist-info/licenses/LICENSE.txt,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+robotframework_pabot-4.3.0.dist-info/METADATA,sha256=coN7rNN_R3aY76vawuow6gGITRFi1Jc3nOeobID27gw,16410
+robotframework_pabot-4.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+robotframework_pabot-4.3.0.dist-info/entry_points.txt,sha256=JpAIFADTeFOQWdwmn56KpAil8V3-41ZC5ICXCYm3Ng0,43
+robotframework_pabot-4.3.0.dist-info/top_level.txt,sha256=t3OwfEAsSxyxrhjy_GCJYHKbV_X6AIsgeLhYeHvObG4,6
+robotframework_pabot-4.3.0.dist-info/RECORD,,

{robotframework_pabot-4.1.1.dist-info → robotframework_pabot-4.3.0.dist-info}/WHEEL

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