hpcflow-new2 0.2.0a144__tar.gz → 0.2.0a147__tar.gz

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hpcflow-new2
-Version: 0.2.0a144
+Version: 0.2.0a147
 Summary: Computational workflow management
 License: MIT
 Author: aplowman

hpcflow_new2-0.2.0a147/hpcflow/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0a147"

hpcflow_new2-0.2.0a147/hpcflow/data/scripts/main_script_test_direct_sub_param_in_direct_out.py

@@ -0,0 +1,6 @@
+def main_script_test_direct_sub_param_in_direct_out(a):
+    # process
+    p2 = a + 100
+
+    # return outputs
+    return {"p2": p2}

hpcflow_new2-0.2.0a147/hpcflow/data/scripts/main_script_test_json_sub_param_in_json_out_labels.py

@@ -0,0 +1,16 @@
+import json
+
+
+def main_script_test_json_sub_param_in_json_out_labels(_input_files, _output_files):
+    # read inputs
+    with _input_files["json"].open("rt") as fh:
+        inp_dat = json.load(fh)
+        a = int(inp_dat["a"])
+        p1_2 = int(inp_dat["p1[two]"])
+
+    # process
+    p2 = a + p1_2
+
+    # save outputs
+    with _output_files["json"].open("wt") as fh:
+        json.dump({"p2": p2}, fh)

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/sdk/core/actions.py

@@ -148,6 +148,7 @@ class ElementActionRun:
         skip: bool,
         exit_code: Union[int, None],
         metadata: Dict,
+        run_hostname: Union[str, None],
     ) -> None:
         self._id = id_
         self._is_pending = is_pending
@@ -163,6 +164,7 @@ class ElementActionRun:
         self._snapshot_end = snapshot_end
         self._exit_code = exit_code
         self._metadata = metadata
+        self._run_hostname = run_hostname
 
         # assigned on first access of corresponding properties:
         self._inputs = None
@@ -222,6 +224,10 @@ class ElementActionRun:
     def metadata(self):
         return self._metadata
 
+    @property
+    def run_hostname(self):
+        return self._run_hostname
+
     @property
     def start_time(self):
         return self._start_time
@@ -478,7 +484,7 @@ class ElementActionRun:
         Parameters
         ----------
         inputs
-            If specified, a list of input parameter types to include, of a dict whose keys
+            If specified, a list of input parameter types to include, or a dict whose keys
             are input parameter types to include. For schema inputs that have
             `multiple=True`, the input type should be labelled. If a dict is passed, and
             the key "all_iterations` is present and `True`, the return for that input
@@ -489,10 +495,11 @@ class ElementActionRun:
             keys.
 
         """
+        if not inputs:
+            inputs = self.get_parameter_names("inputs")
+
         out = {}
-        for inp_name in self.get_parameter_names("inputs"):
-            if inputs and inp_name not in inputs:
-                continue
+        for inp_name in inputs:
             path_i, label_i = split_param_label(inp_name)
 
             try:
@@ -512,12 +519,20 @@ class ElementActionRun:
             else:
                 val_i = self.get(f"inputs.{inp_name}")
 
+            key = inp_name
+            if label_dict and label_i:
+                key = path_i  # exclude label from key
+
+            if "." in key:
+                # for sub-parameters, take only the final part as the dict key:
+                key = key.split(".")[-1]
+
             if label_dict and label_i:
-                if path_i not in out:
-                    out[path_i] = {}
-                out[path_i][label_i] = val_i
+                if key not in out:
+                    out[key] = {}
+                out[key][label_i] = val_i
             else:
-                out[inp_name] = val_i
+                out[key] = val_i
 
         return out
 
@@ -1163,8 +1178,8 @@ class Action(JSONLike):
         # validation:
         allowed_keys = ("format", "all_iterations")
         for k, v in all_params.items():
-            # validate parameter name:
-            if k not in param_names:
+            # validate parameter name (sub-parameters are allowed):
+            if k.split(".")[0] not in param_names:
                 raise UnknownScriptDataParameter(
                     f"Script data parameter {k!r} is not a known parameter of the "
                     f"action. Parameters ({prefix}) are: {param_names!r}."

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/sdk/core/element.py

@@ -274,7 +274,7 @@ class ElementResources(JSONLike):
     def get_env_instance_filterable_attributes() -> Tuple[str]:
         """Get a tuple of resource attributes that are used to filter environment
         executable instances at submit- and run-time."""
-        return ("num_cores", "parallel_mode")
+        return ("num_cores",)  # TODO: filter on `parallel_mode` later
 
     @staticmethod
     def get_default_os_name():

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/sdk/core/loop.py

@@ -423,7 +423,15 @@ class WorkflowLoop:
 
                         elif orig_inp_src.source_type is InputSourceType.DEFAULT:
                             # keep default value from original element
-                            inp_dat_idx = element.iterations[0].get_data_idx()[inp_key]
+                            inp_dat_idx_iter_0 = element.iterations[0].get_data_idx()
+                            try:
+                                inp_dat_idx = inp_dat_idx_iter_0[inp_key]
+                            except KeyError:
+                                # if this input is required by a conditional action, and
+                                # that condition is not met, then this input will not
+                                # exist in the action-run data index, so use the initial
+                                # iteration data index:
+                                inp_dat_idx = element.iterations[0].data_idx[inp_key]
 
                         elif orig_inp_src.source_type is InputSourceType.TASK:
                             if orig_inp_src.task_ref not in self.task_insert_IDs:
@@ -486,7 +494,16 @@ class WorkflowLoop:
                 inp_status_inps = set([f"inputs.{i}" for i in inp_statuses])
                 sub_params = inp_status_inps - set(new_data_idx.keys())
                 for sub_param_i in sub_params:
-                    sub_param_data_idx = element.iterations[0].get_data_idx()[sub_param_i]
+                    sub_param_data_idx_iter_0 = element.iterations[0].get_data_idx()
+                    try:
+                        sub_param_data_idx = sub_param_data_idx_iter_0[sub_param_i]
+                    except KeyError:
+                        # as before, if this input is required by a conditional action,
+                        # and that condition is not met, then this input will not exist in
+                        # the action-run data index, so use the initial iteration data
+                        # index:
+                        sub_param_data_idx = element.iterations[0].data_idx[sub_param_i]
+
                     new_data_idx[sub_param_i] = sub_param_data_idx
 
                 for out in task.template.all_schema_outputs:

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/sdk/persistence/base.py

@@ -10,6 +10,7 @@ import enum
 import os
 from pathlib import Path
 import shutil
+import socket
 import time
 from typing import Any, Dict, Iterable, List, Optional, Tuple, TypeVar, Union
 
@@ -306,6 +307,7 @@ class StoreEAR:
     snapshot_end: Optional[Dict] = None
     exit_code: Optional[int] = None
     metadata: Dict[str, Any] = None
+    run_hostname: Optional[str] = None
 
     @staticmethod
     def _encode_datetime(dt: Union[datetime, None], ts_fmt: str) -> str:
@@ -331,6 +333,7 @@ class StoreEAR:
             "snapshot_end": self.snapshot_end,
             "exit_code": self.exit_code,
             "metadata": self.metadata,
+            "run_hostname": self.run_hostname,
         }
 
     @classmethod
@@ -365,6 +368,7 @@ class StoreEAR:
             "snapshot_end": self.snapshot_end,
             "exit_code": self.exit_code,
             "metadata": self.metadata,
+            "run_hostname": self.run_hostname,
         }
 
     def update(
@@ -377,6 +381,7 @@ class StoreEAR:
         snapshot_start: Optional[Dict] = None,
         snapshot_end: Optional[Dict] = None,
         exit_code: Optional[int] = None,
+        run_hostname: Optional[str] = None,
     ) -> AnySEAR:
         """Return a shallow copy, with specified data updated."""
 
@@ -388,6 +393,7 @@ class StoreEAR:
         snap_s = snapshot_start if snapshot_start is not None else self.snapshot_start
         snap_e = snapshot_end if snapshot_end is not None else self.snapshot_end
         exit_code = exit_code if exit_code is not None else self.exit_code
+        run_hn = run_hostname if run_hostname is not None else self.run_hostname
 
         return self.__class__(
             id_=self.id_,
@@ -404,6 +410,7 @@ class StoreEAR:
             snapshot_start=snap_s,
             snapshot_end=snap_e,
             exit_code=exit_code,
+            run_hostname=run_hn,
         )
 
 
@@ -961,7 +968,8 @@ class PersistentStore(ABC):
         snapshot = JSONLikeDirSnapShot()
         snapshot.take(".")
         ss_js = snapshot.to_json_like()
-        self._pending.set_EAR_starts[EAR_ID] = (dt, ss_js)
+        run_hostname = socket.gethostname()
+        self._pending.set_EAR_starts[EAR_ID] = (dt, ss_js, run_hostname)
         if save:
             self.save()
         return dt
@@ -1419,7 +1427,7 @@ class PersistentStore(ABC):
             pend_end = self._pending.set_EAR_ends.get(EAR_i.id_)
             pend_skip = True if EAR_i.id_ in self._pending.set_EAR_skips else None
 
-            p_st, p_ss = pend_start if pend_start else (None, None)
+            p_st, p_ss, p_hn = pend_start if pend_start else (None, None, None)
             p_et, p_se, p_ex, p_sx = pend_end if pend_end else (None, None, None, None)
 
             updates = {
@@ -1431,6 +1439,7 @@ class PersistentStore(ABC):
                 "snapshot_start": p_ss,
                 "snapshot_end": p_se,
                 "exit_code": p_ex,
+                "run_hostname": p_hn,
             }
             if any(i is not None for i in updates.values()):
                 EAR_i = EAR_i.update(**updates)

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/sdk/persistence/json.py

@@ -232,10 +232,11 @@ class JSONPersistentStore(PersistentStore):
         with self.using_resource("metadata", action="update") as md:
             md["runs"][EAR_id]["submission_idx"] = sub_idx
 
-    def _update_EAR_start(self, EAR_id: int, s_time: datetime, s_snap: Dict):
+    def _update_EAR_start(self, EAR_id: int, s_time: datetime, s_snap: Dict, s_hn: str):
         with self.using_resource("metadata", action="update") as md:
             md["runs"][EAR_id]["start_time"] = s_time.strftime(self.ts_fmt)
             md["runs"][EAR_id]["snapshot_start"] = s_snap
+            md["runs"][EAR_id]["run_hostname"] = s_hn
 
     def _update_EAR_end(
         self, EAR_id: int, e_time: datetime, e_snap: Dict, ext_code: int, success: bool

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/sdk/persistence/pending.py

@@ -59,7 +59,7 @@ class PendingChanges:
         self.set_EARs_initialised: List[int] = None
         self.set_EAR_submission_indices: Dict[int, int] = None
         self.set_EAR_skips: List[int] = None
-        self.set_EAR_starts: Dict[int, Tuple[datetime, Dict]] = None
+        self.set_EAR_starts: Dict[int, Tuple[datetime, Dict], str] = None
         self.set_EAR_ends: Dict[int, Tuple[datetime, Dict, int, bool]] = None
 
         self.set_js_metadata: Dict[int, Dict[int, Any]] = None
@@ -286,12 +286,12 @@ class PendingChanges:
 
     def commit_EAR_starts(self) -> None:
         # TODO: could be batched up?
-        for EAR_id, (time, snap) in self.set_EAR_starts.items():
+        for EAR_id, (time, snap, hostname) in self.set_EAR_starts.items():
             self.logger.debug(
-                f"commit: adding pending start time ({time!r}) and "
-                f"directory snapshot to EAR ID {EAR_id!r}."
+                f"commit: adding pending start time ({time!r}), run hostname "
+                f"({hostname!r}), and directory snapshot to EAR ID {EAR_id!r}."
             )
-            self.store._update_EAR_start(EAR_id, time, snap)
+            self.store._update_EAR_start(EAR_id, time, snap, hostname)
         self.clear_set_EAR_starts()
 
     def commit_EAR_ends(self) -> None:

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/sdk/persistence/zarr.py

@@ -230,6 +230,7 @@ class ZarrStoreEAR(StoreEAR):
             self.snapshot_end,
             self.exit_code,
             self.metadata,
+            self.run_hostname,
         ]
         return EAR_enc
 
@@ -250,6 +251,7 @@ class ZarrStoreEAR(StoreEAR):
             "snapshot_end": EAR_dat[10],
             "exit_code": EAR_dat[11],
             "metadata": EAR_dat[12],
+            "run_hostname": EAR_dat[13],
         }
         return cls(is_pending=False, **obj_dat)
 
@@ -598,7 +600,7 @@ class ZarrPersistentStore(PersistentStore):
         if attrs != attrs_orig:
             arr.attrs.put(attrs)
 
-    def _update_EAR_start(self, EAR_id: int, s_time: datetime, s_snap: Dict):
+    def _update_EAR_start(self, EAR_id: int, s_time: datetime, s_snap: Dict, s_hn: str):
         arr = self._get_EARs_arr(mode="r+")
         attrs_orig = arr.attrs.asdict()
         attrs = copy.deepcopy(attrs_orig)
@@ -607,6 +609,7 @@ class ZarrPersistentStore(PersistentStore):
         EAR_i = EAR_i.update(
             start_time=s_time,
             snapshot_start=s_snap,
+            run_hostname=s_hn,
         )
         arr[EAR_id] = EAR_i.encode(attrs, self.ts_fmt)
 

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/sdk/submission/schedulers/__init__.py

@@ -10,7 +10,6 @@ class NullScheduler:
 
     def __init__(
         self,
-        submit_cmd=None,
         shell_args=None,
         shebang_args=None,
         options=None,
@@ -19,6 +18,10 @@ class NullScheduler:
         self.shell_args = shell_args or self.DEFAULT_SHELL_ARGS
         self.options = options or []
 
+    @property
+    def unique_properties(self):
+        return (self.__class__.__name__,)
+
     def __eq__(self, other) -> bool:
         if type(self) != type(other):
             return False
@@ -64,6 +67,10 @@ class Scheduler(NullScheduler):
         self.array_switch = array_switch or self.DEFAULT_ARRAY_SWITCH
         self.array_item_var = array_item_var or self.DEFAULT_ARRAY_ITEM_VAR
 
+    @property
+    def unique_properties(self):
+        return (self.__class__.__name__, self.submit_cmd, self.show_cmd, self.del_cmd)
+
     def format_switch(self, switch):
         return f"{self.js_cmd} {switch}"
 

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/sdk/submission/schedulers/slurm.py

@@ -416,7 +416,11 @@ class SlurmPosix(Scheduler):
                 _arr_idx = []
                 for i_range_str in arr_idx.strip("[]").split(","):
                     if "-" in i_range_str:
-                        i_args = [int(j) - 1 for j in i_range_str.split("-")]
+                        range_parts = i_range_str.split("-")
+                        if "%" in range_parts[1]:
+                            # indicates max concurrent array items; not needed
+                            range_parts[1] = range_parts[1].split("%")[0]
+                        i_args = [int(j) - 1 for j in range_parts]
                         _arr_idx.extend(list(range(i_args[0], i_args[1] + 1)))
                     else:
                         _arr_idx.append(int(i_range_str) - 1)

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/sdk/submission/submission.py

@@ -123,7 +123,12 @@ class Submission(JSONLike):
                     filter_exec = {j: getattr(js_j.resources, j) for j in filterable}
                     exec_instances = exec_i.filter_instances(**filter_exec)
                     if not exec_instances:
-                        raise MissingEnvironmentExecutableInstanceError
+                        raise MissingEnvironmentExecutableInstanceError(
+                            f"No matching executable instances found for executable "
+                            f"{exec_i_lab!r} of environment {env_lab!r} for jobscript "
+                            f"index {js_idx_j!r} with requested resources "
+                            f"{filter_exec!r}."
+                        )
 
         # save env definitions to the environments attribute:
         self._environments = self.app.EnvironmentsList(envs)
@@ -327,14 +332,24 @@ class Submission(JSONLike):
     def get_unique_schedulers_of_jobscripts(
         jobscripts: List[Jobscript],
     ) -> Dict[Tuple[Tuple[int, int]], Scheduler]:
-        """Get unique schedulers and which of the passed jobscripts they correspond to."""
+        """Get unique schedulers and which of the passed jobscripts they correspond to.
+
+        Uniqueness is determines only by the `Scheduler.unique_properties` tuple.
+
+        """
         js_idx = []
         schedulers = []
+
+        # list of tuples of scheduler properties we consider to determine "uniqueness",
+        # with the first string being the scheduler type (class name):
+        seen_schedulers = []
+
         for js in jobscripts:
-            if js.scheduler not in schedulers:
+            if js.scheduler.unique_properties not in seen_schedulers:
+                seen_schedulers.append(js.scheduler.unique_properties)
                 schedulers.append(js.scheduler)
                 js_idx.append([])
-            sched_idx = schedulers.index(js.scheduler)
+            sched_idx = seen_schedulers.index(js.scheduler.unique_properties)
             js_idx[sched_idx].append((js.submission.index, js.index))
 
         sched_js_idx = dict(zip((tuple(i) for i in js_idx), schedulers))

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/tests/scripts/test_main_scripts.py

@@ -33,6 +33,32 @@ def test_script_direct_in_direct_out(null_config, tmp_path):
     assert wk.tasks[0].elements[0].outputs.p2.value == p1_val + 100
 
 
+@pytest.mark.integration
+@pytest.mark.skipif("hf.run_time_info.is_frozen")
+def test_script_direct_sub_param_in_direct_out(null_config, tmp_path):
+    s1 = hf.TaskSchema(
+        objective="t1",
+        inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
+        outputs=[hf.SchemaOutput(parameter=hf.Parameter("p2"))],
+        actions=[
+            hf.Action(
+                script="<<script:main_script_test_direct_sub_param_in_direct_out.py>>",
+                script_data_in={"p1.a": "direct"},
+                script_data_out="direct",
+                script_exe="python_script",
+                environments=[hf.ActionEnvironment(environment="python_env")],
+            )
+        ],
+    )
+    p1_val = {"a": 101}
+    t1 = hf.Task(schema=s1, inputs={"p1": p1_val})
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1], template_name="main_script_test", path=tmp_path
+    )
+    wk.submit(wait=True, add_to_known=False)
+    assert wk.tasks[0].elements[0].outputs.p2.value == p1_val["a"] + 100
+
+
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
 def test_script_direct_in_direct_out_single_label(null_config, tmp_path):
@@ -170,6 +196,47 @@ def test_script_json_in_json_out_labels(null_config, tmp_path):
     assert wk.tasks[0].elements[0].outputs.p2.value == p1_1_val + p1_2_val
 
 
+@pytest.mark.integration
+@pytest.mark.skipif("hf.run_time_info.is_frozen")
+def test_script_json_sub_param_in_json_out_labels(null_config, tmp_path):
+    p1_label_1 = "one"
+    p1_label_2 = "two"
+    s1 = hf.TaskSchema(
+        objective="t1",
+        inputs=[
+            hf.SchemaInput(
+                parameter=hf.Parameter("p1"),
+                labels={p1_label_1: {}, p1_label_2: {}},
+                multiple=True,
+            )
+        ],
+        outputs=[hf.SchemaOutput(parameter=hf.Parameter("p2"))],
+        actions=[
+            hf.Action(
+                script="<<script:main_script_test_json_sub_param_in_json_out_labels.py>>",
+                script_data_in={"p1[one].a": "json", "p1[two]": "json"},
+                script_data_out="json",
+                script_exe="python_script",
+                environments=[hf.ActionEnvironment(environment="python_env")],
+            )
+        ],
+    )
+    a_val = 101
+    p1_2_val = 201
+    t1 = hf.Task(
+        schema=s1,
+        inputs={
+            f"p1[{p1_label_1}]": {"a": a_val},
+            f"p1[{p1_label_2}]": p1_2_val,
+        },
+    )
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1], template_name="main_script_test", path=tmp_path
+    )
+    wk.submit(wait=True, add_to_known=False)
+    assert wk.tasks[0].elements[0].outputs.p2.value == a_val + p1_2_val
+
+
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
 def test_script_json_and_direct_in_json_out(null_config, tmp_path):

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/tests/unit/test_loop.py

@@ -1,4 +1,8 @@
 import pytest
+
+from valida.conditions import Value
+
+
 from hpcflow.app import app as hf
 from hpcflow.sdk.core.errors import LoopAlreadyExistsError
 from hpcflow.sdk.core.test_utils import P1_parameter_cls, make_workflow
@@ -381,6 +385,54 @@ def test_wk_loop_input_sources_iterable_param_default(null_config, tmp_path):
     assert t1_iter_2["inputs.p1"] == t1_iter_1["outputs.p1"]
 
 
+def test_wk_loop_input_sources_iterable_param_default_conditional_action(
+    null_config, tmp_path
+):
+    act_env = hf.ActionEnvironment("null_env")
+    ts1 = hf.TaskSchema(
+        objective="t1",
+        inputs=[
+            hf.SchemaInput("p1", default_value=1),
+            hf.SchemaInput("p2", default_value=None),
+        ],
+        outputs=[hf.SchemaOutput("p1")],
+        actions=[
+            hf.Action(
+                commands=[
+                    hf.Command(
+                        "Write-Output ((<<parameter:p1>> + 10))",
+                        stdout="<<int(parameter:p1)>>",
+                    )
+                ],
+                environments=[act_env],
+            ),
+            hf.Action(
+                commands=[hf.Command("Write-Output ((<<parameter:p2>> + 10))")],
+                environments=[act_env],
+                rules=[
+                    hf.ActionRule(path="inputs.p2", condition=Value.not_equal_to(None))
+                ],
+            ),
+        ],
+    )
+    wk = hf.Workflow.from_template_data(
+        template_name="test_loop",
+        path=tmp_path,
+        tasks=[hf.Task(schema=ts1, inputs={"p1": 101})],
+    )
+    wk.add_loop(hf.Loop(tasks=[0], num_iterations=3))
+    # first iteration should be the default value, second and third iterations should
+    # be from previous iteration outputs:
+    t1_iter_0 = wk.tasks.t1.elements[0].iterations[0].get_data_idx()
+    t1_iter_1 = wk.tasks.t1.elements[0].iterations[1].get_data_idx()
+    t1_iter_2 = wk.tasks.t1.elements[0].iterations[2].get_data_idx()
+
+    assert t1_iter_0["inputs.p1"] != t1_iter_1["inputs.p1"]
+    assert t1_iter_1["inputs.p1"] != t1_iter_2["inputs.p1"]
+    assert t1_iter_1["inputs.p1"] == t1_iter_0["outputs.p1"]
+    assert t1_iter_2["inputs.p1"] == t1_iter_1["outputs.p1"]
+
+
 def test_wk_loop_input_sources_including_non_iteration_task_source_with_groups(
     null_config, tmp_path
 ):

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/tests/unit/test_schema_input.py

@@ -192,7 +192,7 @@ def test_get_input_values_subset(null_config, tmp_path):
         template_name="temp",
     )
     run = wk.tasks[0].elements[0].iterations[0].action_runs[0]
-    assert run.get_input_values(inputs=("p1")) == {"p1": 101}
+    assert run.get_input_values(inputs=("p1",)) == {"p1": 101}
 
 
 def test_get_input_values_subset_labelled_label_dict_False(null_config, tmp_path):
@@ -226,7 +226,7 @@ def test_get_input_values_subset_labelled_label_dict_False(null_config, tmp_path
         template_name="temp",
     )
     run = wk.tasks[0].elements[0].iterations[0].action_runs[0]
-    assert run.get_input_values(inputs=("p1[one]"), label_dict=False) == {"p1[one]": 101}
+    assert run.get_input_values(inputs=("p1[one]",), label_dict=False) == {"p1[one]": 101}
 
 
 def test_get_input_values_subset_labelled_label_dict_True(null_config, tmp_path):
@@ -260,7 +260,7 @@ def test_get_input_values_subset_labelled_label_dict_True(null_config, tmp_path)
         template_name="temp",
     )
     run = wk.tasks[0].elements[0].iterations[0].action_runs[0]
-    assert run.get_input_values(inputs=("p1[one]"), label_dict=True) == {
+    assert run.get_input_values(inputs=("p1[one]",), label_dict=True) == {
         "p1": {"one": 101}
     }
 

{hpcflow_new2-0.2.0a144 → hpcflow_new2-0.2.0a147}/hpcflow/tests/unit/test_slurm.py

@@ -25,3 +25,14 @@ def test_parse_job_ID_array_simple_mixed_range():
         "30627658",
         [4, 7, 8, 9],
     )
+
+
+def test_parse_job_ID_array_simple_range_with_max_concurrent():
+    assert SlurmPosix._parse_job_IDs("3397752_[9-11%2]") == ("3397752", [8, 9, 10])
+
+
+def test_parse_job_ID_array_simple_multiple_range_max_concurrent():
+    assert SlurmPosix._parse_job_IDs("49203_[3-5%1,9-11%2]") == (
+        "49203",
+        [2, 3, 4, 8, 9, 10],
+    )