hpcflow-new2 0.2.0a50__py3-none-any.whl → 0.2.0a52__py3-none-any.whl

hpcflow/sdk/submission/shells/powershell.py

@@ -1,6 +1,7 @@
 import subprocess
 from textwrap import dedent, indent
 from typing import Dict, Optional
+from hpcflow.sdk.core import ABORT_EXIT_CODE
 from hpcflow.sdk.submission.shells import Shell
 from hpcflow.sdk.submission.shells.os_version import get_OS_info_windows
 
@@ -21,6 +22,7 @@ class WindowsPowerShell(Shell):
         function {workflow_app_alias} {{
             & {{
         {env_setup}{app_invoc} `
+                    --with-config log_file_path "$pwd/{app_package_name}.log" `
                     --config-dir "{config_dir}" `
                     --config-invocation-key "{config_invoc_key}" `
                     $args
@@ -40,6 +42,16 @@ class WindowsPowerShell(Shell):
             return $path
         }}
 
+        function StartJobHere($block) {{
+            $jobInitBlock = [scriptblock]::Create(@"
+                Function wkflow_app {{ $function:wkflow_app }}
+                Function get_nth_line {{ $function:get_nth_line }}
+                Function JoinMultiPath {{ $function:JoinMultiPath }}
+                Set-Location '$pwd'
+        "@)
+            Start-Job -InitializationScript $jobInitBlock -Script $block
+        }}
+
         $WK_PATH = $(Get-Location)
         $SUB_IDX = {sub_idx}
         $JS_IDX = {js_idx}
@@ -56,13 +68,13 @@ class WindowsPowerShell(Shell):
     )
     JS_MAIN = dedent(
         """\
-        $elem_need_EARs = get_nth_line $EAR_ID_FILE $JS_elem_idx
+        $elem_EAR_IDs = get_nth_line $EAR_ID_FILE $JS_elem_idx
         $elem_run_dirs = get_nth_line $ELEM_RUN_DIR_FILE $JS_elem_idx
 
         for ($JS_act_idx = 0; $JS_act_idx -lt {num_actions}; $JS_act_idx += 1) {{
 
-            $need_EAR = ($elem_need_EARs -split "{EAR_files_delimiter}")[$JS_act_idx]
-            if ($need_EAR -eq 0) {{
+            $EAR_ID = ($elem_EAR_IDs -split "{EAR_files_delimiter}")[$JS_act_idx]
+            if ($EAR_ID -eq -1) {{
                 continue
             }}
 
@@ -70,11 +82,20 @@ class WindowsPowerShell(Shell):
             $run_dir_abs = "$WK_PATH\\$run_dir"
             Set-Location $run_dir_abs
 
-            {workflow_app_alias} internal workflow $WK_PATH write-commands $SUB_IDX $JS_IDX $JS_elem_idx $JS_act_idx
-            {workflow_app_alias} internal workflow $WK_PATH set-ear-start $SUB_IDX $JS_IDX $JS_elem_idx $JS_act_idx
+            $skip = {workflow_app_alias} internal workflow $WK_PATH get-ear-skipped $EAR_ID
+            if ($skip -eq "1") {{
+                continue
+            }}
+
+            {workflow_app_alias} internal workflow $WK_PATH write-commands $SUB_IDX $JS_IDX $JS_act_idx $EAR_ID
+            {workflow_app_alias} internal workflow $WK_PATH set-ear-start $EAR_ID
 
             . (Join-Path $run_dir_abs "{commands_file_name}")
-            {workflow_app_alias} internal workflow $WK_PATH set-ear-end $SUB_IDX $JS_IDX $JS_elem_idx $JS_act_idx
+            
+            $exit_code = $LASTEXITCODE
+            $global:LASTEXITCODE = $null
+
+            {workflow_app_alias} internal workflow $WK_PATH set-ear-end $EAR_ID $exit_code
 
         }}
     """
@@ -125,24 +146,74 @@ class WindowsPowerShell(Shell):
     def format_stream_assignment(self, shell_var_name, command):
         return f"${shell_var_name} = {command}"
 
-    def format_save_parameter(self, workflow_app_alias, param_name, shell_var_name):
+    def format_save_parameter(
+        self, workflow_app_alias, param_name, shell_var_name, EAR_ID
+    ):
         return (
             f"{workflow_app_alias}"
             f" internal workflow $WK_PATH save-parameter {param_name} ${shell_var_name}"
-            f" $SUB_IDX $JS_IDX $JS_elem_idx $JS_act_idx"
+            f" {EAR_ID}"
             f"\n"
         )
 
-    def wrap_in_subshell(self, commands: str) -> str:
+    def wrap_in_subshell(self, commands: str, abortable: bool) -> str:
         """Format commands to run within a child scope.
 
-        This assumes commands ends in a newline.
+        This assumes `commands` ends in a newline.
 
         """
         commands = indent(commands, self.JS_INDENT)
-        return dedent(
-            """\
-            & {{
-            {commands}}}
-        """
-        ).format(commands=commands)
+        if abortable:
+            # run commands as a background job, and poll a file to check for abort
+            # requests:
+            return dedent(
+                """\
+                $job = StartJobHere {{
+                    $WK_PATH = $using:WK_PATH
+                    $SUB_IDX = $using:SUB_IDX
+                    $JS_IDX = $using:JS_IDX
+                    $EAR_ID = $using:EAR_ID
+
+                {commands}
+                    if ($LASTEXITCODE -ne 0) {{
+                        throw
+                    }}
+                }}
+
+                $is_abort = $null
+                while ($true) {{
+                    $abort_file = JoinMultiPath $WK_PATH artifacts submissions $SUB_IDX abort_EARs.txt
+                    $is_abort = get_nth_line $abort_file $EAR_ID
+                    if ($job.State -ne "Running") {{
+                        break
+                    }}
+                    elseif ($is_abort -eq "1") {{
+                        Stop-Job -Job $job
+                        Wait-Job -Job $job
+                        break
+                    }}
+                    else {{
+                        Start-Sleep 1 # TODO: TEMP: increase for production
+                    }}
+                }}
+                $result = Receive-Job -job $job
+                Write-Host $result
+                if ($job.state -eq "Completed") {{
+                    exit 0
+                }}
+                elseif ($is_abort -eq "1") {{
+                    exit {abort_exit_code}
+                }}
+                else {{
+                    exit 1
+                }}
+            """
+            ).format(commands=commands, abort_exit_code=ABORT_EXIT_CODE)
+        else:
+            # run commands in "foreground":
+            return dedent(
+                """\
+                & {{
+                {commands}}}
+            """
+            ).format(commands=commands)

hpcflow/sdk/submission/submission.py

@@ -47,32 +47,23 @@ class Submission(JSONLike):
         self,
         index: int,
         jobscripts: List[app.Jobscript],
-        workflow: app.Workflow,
+        workflow: Optional[app.Workflow] = None,
         submission_attempts: Optional[List] = None,
         JS_parallelism: Optional[bool] = None,
     ):
         self._index = index
         self._jobscripts = jobscripts
-        self._workflow = workflow
         self._submission_attempts = submission_attempts or []
         self._JS_parallelism = JS_parallelism
 
+        if workflow:
+            self.workflow = workflow
+
         self._set_parent_refs()
 
         for js_idx, js in enumerate(self.jobscripts):
             js._index = js_idx
 
-        # if JS_parallelism explicitly requested but store doesn't support, raise:
-        supports_JS_para = self.workflow._store.features.jobscript_parallelism
-        if self.JS_parallelism:
-            if not supports_JS_para:
-                raise ValueError(
-                    f"Store type {self.workflow._store!r} does not support jobscript "
-                    f"parallelism."
-                )
-        elif self.JS_parallelism is None:
-            self._JS_parallelism = supports_JS_para
-
     def to_dict(self):
         dct = super().to_dict()
         del dct["_workflow"]
@@ -100,6 +91,20 @@ class Submission(JSONLike):
     def workflow(self) -> List:
         return self._workflow
 
+    @workflow.setter
+    def workflow(self, wk):
+        self._workflow = wk
+        # if JS_parallelism explicitly requested but store doesn't support, raise:
+        supports_JS_para = self.workflow._store._features.jobscript_parallelism
+        if self.JS_parallelism:
+            if not supports_JS_para:
+                raise ValueError(
+                    f"Store type {self.workflow._store!r} does not support jobscript "
+                    f"parallelism."
+                )
+        elif self.JS_parallelism is None:
+            self._JS_parallelism = supports_JS_para
+
     @property
     def jobscript_indices(self) -> Tuple[int]:
         """All associated jobscript indices."""
@@ -136,6 +141,23 @@ class Submission(JSONLike):
     def path(self):
         return self.workflow.submissions_path / str(self.index)
 
+    @property
+    def all_EAR_IDs(self):
+        return [i for js in self.jobscripts for i in js.EAR_ID.flatten()]
+
+    @property
+    def abort_EARs_file_name(self):
+        return f"abort_EARs.txt"
+
+    @property
+    def abort_EARs_file_path(self):
+        return self.path / self.abort_EARs_file_name
+
+    def _write_abort_EARs_file(self):
+        with self.abort_EARs_file_path.open(mode="wt", newline="\n") as fp:
+            # write a single line for each EAR currently in the workflow:
+            fp.write("\n".join("0" for _ in range(self.workflow.num_EARs)) + "\n")
+
     def get_unique_schedulers(self) -> Dict[Tuple[int], Scheduler]:
         """Get a unique schedulers and which jobscripts they correspond to."""
         js_idx = []
@@ -168,23 +190,23 @@ class Submission(JSONLike):
 
         return shell_js_idx
 
-    def prepare_EAR_submission_idx_update(self) -> List[Tuple[int, int, int, int]]:
-        """For all EARs in this submission (across all jobscripts), return a tuple of indices
-        that can be passed to `Workflow.set_EAR_submission_index`."""
-        indices = []
-        for js in self.jobscripts:
-            for ear_idx_i, ear_idx_j in js.EARs.items():
-                # task insert ID, iteration idx, action idx, run idx:
-                indices.append((ear_idx_i[0], ear_idx_j[0], ear_idx_j[1], ear_idx_j[2]))
-        return indices
-
-    def get_EAR_run_dirs(self) -> Dict[Tuple(int, int, int), Path]:
-        indices = []
-        for js in self.jobscripts:
-            for ear_idx_i, ear_idx_j in js.EARs.items():
-                # task insert ID, iteration idx, action idx, run idx:
-                indices.append((ear_idx_i[0], ear_idx_j[0], ear_idx_j[1], ear_idx_j[2]))
-        return indices
+    # def prepare_EAR_submission_idx_update(self) -> List[Tuple[int, int, int, int]]:
+    #     """For all EARs in this submission (across all jobscripts), return a tuple of indices
+    #     that can be passed to `Workflow.set_EAR_submission_index`."""
+    #     indices = []
+    #     for js in self.jobscripts:
+    #         for ear_idx_i, ear_idx_j in js.EARs.items():
+    #             # task insert ID, iteration idx, action idx, run idx:
+    #             indices.append((ear_idx_i[0], ear_idx_j[0], ear_idx_j[1], ear_idx_j[2]))
+    #     return indices
+
+    # def get_EAR_run_dirs(self) -> Dict[Tuple(int, int, int), Path]:
+    #     indices = []
+    #     for js in self.jobscripts:
+    #         for ear_idx_i, ear_idx_j in js.EARs.items():
+    #             # task insert ID, iteration idx, action idx, run idx:
+    #             indices.append((ear_idx_i[0], ear_idx_j[0], ear_idx_j[1], ear_idx_j[2]))
+    #     return indices
 
     def _raise_failure(self, submitted_js_idx, exceptions):
         msg = f"Some jobscripts in submission index {self.index} could not be submitted"
@@ -217,13 +239,12 @@ class Submission(JSONLike):
 
     def _append_submission_attempt(self, submitted_js_idx: List[int]):
         self._submission_attempts.append(submitted_js_idx)
-        self.workflow._store.append_submission_attempt(
+        self.workflow._store.add_submission_attempt(
             sub_idx=self.index, submitted_js_idx=submitted_js_idx
         )
 
     def submit(
         self,
-        task_artifacts_path,
         ignore_errors=False,
         print_stdout=False,
     ) -> List[int]:
@@ -248,8 +269,6 @@ class Submission(JSONLike):
                         js_vers_info[js_idx] = {}
                     js_vers_info[js_idx].update(vers_info)
 
-                    # self.jobscripts[js_idx]._set_version_info(vers_info)
-
         for js_indices, shell in self.get_unique_shells().items():
             try:
                 vers_info = shell.get_version_info()
@@ -267,7 +286,11 @@ class Submission(JSONLike):
         for js_idx, vers_info_i in js_vers_info.items():
             self.jobscripts[js_idx]._set_version_info(vers_info_i)
 
+        # TODO: a submission should only be "submitted" once shouldn't it?
         self.path.mkdir(exist_ok=True)
+        if not self.abort_EARs_file_path.is_file():
+            self._write_abort_EARs_file()
+
         scheduler_refs = {}  # map jobscript `index` to scheduler job IDs
         submitted_js_idx = []
         errs = []
@@ -285,10 +308,11 @@ class Submission(JSONLike):
 
             try:
                 scheduler_refs[js.index] = js.submit(
-                    task_artifacts_path,
                     scheduler_refs,
                     print_stdout=print_stdout,
                 )
+                # note: currently for direct exec, this is not reached, so submission_status
+                # stays as pending.
                 submitted_js_idx.append(js.index)
 
             except JobscriptSubmissionFailure as err:

hpcflow/tests/unit/test_element.py

@@ -1,6 +1,5 @@
 import pytest
 from hpcflow.app import app as hf
-from hpcflow.sdk.core.actions import ElementID
 from hpcflow.sdk.core.test_utils import make_schemas
 
 
@@ -44,10 +43,8 @@ def test_element_dependent_tasks(workflow_w1):
 def test_element_element_dependencies(workflow_w1):
     assert all(
         (
-            workflow_w1.tasks.t2.elements[0].get_element_dependencies()
-            == [ElementID(0, 0)],
-            workflow_w1.tasks.t2.elements[1].get_element_dependencies()
-            == [ElementID(0, 1)],
+            workflow_w1.tasks.t2.elements[0].get_element_dependencies() == [0],
+            workflow_w1.tasks.t2.elements[1].get_element_dependencies() == [1],
         )
     )
 
@@ -55,9 +52,7 @@ def test_element_element_dependencies(workflow_w1):
 def test_element_dependent_elements(workflow_w1):
     assert all(
         (
-            workflow_w1.tasks.t1.elements[0].get_dependent_elements()
-            == [ElementID(1, 0)],
-            workflow_w1.tasks.t1.elements[1].get_dependent_elements()
-            == [ElementID(1, 1)],
+            workflow_w1.tasks.t1.elements[0].get_dependent_elements() == [2],
+            workflow_w1.tasks.t1.elements[1].get_dependent_elements() == [3],
         )
     )

hpcflow/tests/unit/test_persistence.py

@@ -0,0 +1,218 @@
+import pytest
+from hpcflow.sdk.persistence.base import StoreEAR, StoreElement, StoreElementIter
+from hpcflow.sdk.persistence.json import JSONPersistentStore
+
+from hpcflow.app import app as hf
+
+
+@pytest.mark.skip("need to refactor `make_test_store_from_spec`")
+def test_store_pending_add_task(tmp_path):
+    """Check expected pending state after adding a task."""
+
+    # make store: 0 tasks:
+    store = JSONPersistentStore.make_test_store_from_spec([], dir=tmp_path)
+    task_ID = store.add_task()
+    assert store._pending.add_tasks == {task_ID: []}
+
+
+@pytest.mark.skip("need to refactor `make_test_store_from_spec`")
+def test_store_pending_add_element(tmp_path):
+    """Check expected pending state after adding an element."""
+
+    # make store: 1 task with 0 elements:
+    store = JSONPersistentStore.make_test_store_from_spec(app=hf, spec=[{}], dir=tmp_path)
+    elem_ID = store.add_element(task_ID=0)
+    assert store._pending.add_elements == {
+        elem_ID: StoreElement(
+            id_=elem_ID,
+            is_pending=True,
+            element_idx=0,
+            task_ID=0,
+            iteration_IDs=[],
+        )
+    } and store._pending.add_task_element_IDs == {0: [0]}
+
+
+@pytest.mark.skip("need to refactor `make_test_store_from_spec`")
+@pytest.mark.parametrize("elem_ID", [0, 1])
+def test_store_pending_add_element_iter(tmp_path, elem_ID):
+    """Check expected pending state after adding an element iteration."""
+
+    # make store: 1 task with 2 elements and 0 iterations:
+    store = JSONPersistentStore.make_test_store_from_spec(
+        [{"elements": [{}, {}]}],
+        dir=tmp_path,
+    )
+    iter_ID = store.add_element_iteration(
+        element_ID=elem_ID,
+        data_idx={},
+        schema_parameters=[],
+    )
+    assert store._pending.add_elem_iters == {
+        iter_ID: StoreElementIter(
+            id_=iter_ID,
+            is_pending=True,
+            element_ID=elem_ID,
+            EAR_IDs={},
+            data_idx={},
+            schema_parameters=[],
+        )
+    } and store._pending.add_elem_iter_IDs == {elem_ID: [iter_ID]}
+
+
+@pytest.mark.skip("need to refactor `make_test_store_from_spec`")
+def test_store_pending_add_EAR(tmp_path):
+    """Check expected pending state after adding an EAR."""
+
+    # make store: 1 task with 1 element and 1 iteration:
+    store = JSONPersistentStore.make_test_store_from_spec(
+        [{"elements": [{"iterations": [{}]}]}],
+        dir=tmp_path,
+    )
+    EAR_ID = store.add_EAR(
+        elem_iter_ID=0,
+        action_idx=0,
+        data_idx={},
+        metadata={},
+    )
+    assert store._pending.add_EARs == {
+        EAR_ID: StoreEAR(
+            id_=EAR_ID,
+            is_pending=True,
+            elem_iter_ID=0,
+            action_idx=0,
+            data_idx={},
+            metadata={},
+        )
+    }
+
+
+@pytest.mark.skip("need to refactor `make_test_store_from_spec`")
+def test_get_task_elements_task_is_pending(tmp_path):
+    """Check we get an empty list when getting all task elements of a pending task to
+    which no elements have been added."""
+    # make store: 0 tasks:
+    store = JSONPersistentStore.make_test_store_from_spec([], dir=tmp_path)
+    task_ID = store.add_task()
+    assert store.get_task_elements(task_ID, slice(0, None)) == []
+
+
+@pytest.mark.skip("need to refactor `make_test_store_from_spec`")
+def test_get_task_elements_single_element_is_pending(tmp_path):
+    """Check expected return when getting all task elements of a persistent task that has
+    a single pending element."""
+    # make store: 1 task
+    store = JSONPersistentStore.make_test_store_from_spec([{}], dir=tmp_path)
+    store.add_element(task_ID=0)
+    assert store.get_task_elements(0, slice(0, None)) == [
+        {
+            "id": 0,
+            "is_pending": True,
+            "element_idx": 0,
+            "iteration_IDs": [],
+            "task_ID": 0,
+            "iterations": [],
+        }
+    ]
+
+
+@pytest.mark.skip("need to refactor `make_test_store_from_spec`")
+def test_get_task_elements_multi_element_one_pending(tmp_path):
+    """Check expected return when getting all task elements of a persistent task that has
+    a persistent element and a pending element."""
+    # make store: 1 task with 1 element:
+    store = JSONPersistentStore.make_test_store_from_spec(
+        [{"elements": [{}]}], dir=tmp_path
+    )
+    store.add_element(task_ID=0)
+    assert store.get_task_elements(0, slice(0, None)) == [
+        {
+            "id": 0,
+            "is_pending": False,
+            "element_idx": 0,
+            "iteration_IDs": [],
+            "task_ID": 0,
+            "iterations": [],
+        },
+        {
+            "id": 1,
+            "is_pending": True,
+            "element_idx": 1,
+            "iteration_IDs": [],
+            "task_ID": 0,
+            "iterations": [],
+        },
+    ]
+
+
+@pytest.mark.skip("need to refactor `make_test_store_from_spec`")
+def test_get_task_elements_single_element_iter_pending(tmp_path):
+    """Check expected return when getting all task elements of a persistent task that has
+    a persistent element with a pending iteration."""
+    # make store: 1 task with 1 element:
+    store = JSONPersistentStore.make_test_store_from_spec(
+        [{"elements": [{}]}], dir=tmp_path
+    )
+    store.add_element_iteration(element_ID=0, data_idx={}, schema_parameters=[])
+    assert store.get_task_elements(0, slice(0, None)) == [
+        {
+            "id": 0,
+            "is_pending": False,
+            "element_idx": 0,
+            "iteration_IDs": [0],
+            "task_ID": 0,
+            "iterations": [
+                {
+                    "id": 0,
+                    "is_pending": True,
+                    "element_ID": 0,
+                    "EAR_IDs": {},
+                    "data_idx": {},
+                    "schema_parameters": [],
+                    "EARs": {},
+                }
+            ],
+        },
+    ]
+
+
+@pytest.mark.skip("need to refactor `make_test_store_from_spec`")
+def test_get_task_elements_single_element_iter_EAR_pending(tmp_path):
+    """Check expected return when getting all task elements of a persistent task that has
+    a persistent element with a persistent iteration and a pending EAR"""
+    # make store: 1 task with 1 element with 1 iteration:
+    store = JSONPersistentStore.make_test_store_from_spec(
+        [{"elements": [{"iterations": [{}]}]}], dir=tmp_path
+    )
+    store.add_EAR(elem_iter_ID=0, action_idx=0, data_idx={}, metadata={})
+    assert store.get_task_elements(0, slice(0, None)) == [
+        {
+            "id": 0,
+            "is_pending": False,
+            "element_idx": 0,
+            "iteration_IDs": [0],
+            "task_ID": 0,
+            "iterations": [
+                {
+                    "id": 0,
+                    "is_pending": False,
+                    "element_ID": 0,
+                    "EAR_IDs": {0: [0]},
+                    "data_idx": {},
+                    "schema_parameters": [],
+                    "EARs": {
+                        0: [
+                            {
+                                "id_": 0,
+                                "is_pending": True,
+                                "elem_iter_ID": 0,
+                                "action_idx": 0,
+                                "data_idx": {},
+                                "metadata": {},
+                            }
+                        ]
+                    },
+                },
+            ],
+        },
+    ]

hpcflow/tests/unit/test_task.py

@@ -1,7 +1,6 @@
 import copy
 import pytest
 from hpcflow.app import app as hf
-from hpcflow.sdk.core.actions import ElementID
 from hpcflow.sdk.core.errors import (
     MissingInputs,
     TaskTemplateInvalidNesting,
@@ -644,7 +643,7 @@ def test_task_element_dependencies(tmp_path):
         nesting_orders={1: {"inputs.p2": 0}},
         path=tmp_path,
     )
-    assert wk.tasks.t2.get_element_dependencies() == [ElementID(0, 0), ElementID(0, 1)]
+    assert wk.tasks.t2.get_element_dependencies() == [0, 1]
 
 
 def test_task_dependent_elements(tmp_path):
@@ -657,7 +656,7 @@ def test_task_dependent_elements(tmp_path):
         nesting_orders={1: {"inputs.p2": 0}},
         path=tmp_path,
     )
-    assert wk.tasks.t1.get_dependent_elements() == [ElementID(1, 0), ElementID(1, 1)]
+    assert wk.tasks.t1.get_dependent_elements() == [2, 3]
 
 
 def test_task_add_elements_without_propagation_expected_workflow_num_elements(
@@ -708,9 +707,9 @@ def test_task_add_elements_without_propagation_expected_new_data_index(
         nesting_orders={1: {"inputs.p2": 0}},
         path=tmp_path,
     )
-    data_index = [sorted(i.get_data_idx().keys()) for i in wk.tasks.t1.elements]
+    data_index = [sorted(i.get_data_idx().keys()) for i in wk.tasks.t1.elements[:]]
     wk.tasks.t1.add_elements(inputs=[hf.InputValue(param_p1, 103)])
-    data_index_new = [sorted(i.get_data_idx().keys()) for i in wk.tasks.t1.elements]
+    data_index_new = [sorted(i.get_data_idx().keys()) for i in wk.tasks.t1.elements[:]]
     new_elems = data_index_new[len(data_index) :]
     assert new_elems == [["inputs.p1", "outputs.p2", "resources.any"]]
 
@@ -1281,14 +1280,14 @@ def test_no_change_to_tasks_metadata_on_add_task_failure(tmp_path):
         local_inputs={0: ("p1",)},
         path=tmp_path,
     )
-    tasks_meta = copy.deepcopy(wk._store.get_all_tasks_metadata())
+    tasks_meta = copy.deepcopy(wk._store.get_tasks())
 
     s2 = make_schemas([[{"p1": None, "p3": None}, ()]])
     t2 = hf.Task(schemas=s2)
     with pytest.raises(MissingInputs) as exc_info:
         wk.add_task(t2)
 
-    assert wk._store.get_all_tasks_metadata() == tasks_meta
+    assert wk._store.get_tasks() == tasks_meta
 
 
 def test_no_change_to_parameter_data_on_add_task_failure(tmp_path, param_p2, param_p3):
@@ -1297,13 +1296,13 @@ def test_no_change_to_parameter_data_on_add_task_failure(tmp_path, param_p2, par
         local_inputs={0: ("p1",)},
         path=tmp_path,
     )
-    param_data = copy.deepcopy(wk.get_all_parameter_data())
+    param_data = copy.deepcopy(wk.get_all_parameters())
     s2 = make_schemas([[{"p1": None, "p2": None, "p3": None}, ()]])
     t2 = hf.Task(schemas=s2, inputs=[hf.InputValue(param_p2, 201)])
     with pytest.raises(MissingInputs) as exc_info:
         wk.add_task(t2)
 
-    assert wk.get_all_parameter_data() == param_data
+    assert wk.get_all_parameters() == param_data
 
 
 def test_expected_additional_parameter_data_on_add_task(tmp_path, param_p3):
@@ -1321,7 +1320,7 @@ def test_expected_additional_parameter_data_on_add_task(tmp_path, param_p3):
     param_data_new = wk.get_all_parameter_data()
 
     new_keys = set(param_data_new.keys()) - set(param_data.keys())
-    new_data = [param_data_new[k][1] for k in new_keys]
+    new_data = [param_data_new[k] for k in new_keys]
 
     # one new key for resources, one for param_p3 value
     res = {k: None for k in hf.ResourceSpec.ALLOWED_PARAMETERS}
@@ -1337,7 +1336,7 @@ def test_parameters_accepted_on_add_task(tmp_path, param_p3):
     s2 = make_schemas([[{"p1": None, "p3": None}, ()]])
     t2 = hf.Task(schemas=s2, inputs=[hf.InputValue(param_p3, 301)])
     wk.add_task(t2)
-    assert not wk._store._pending["parameter_data"]
+    assert not wk._store._pending.add_parameters
 
 
 def test_parameters_pending_during_add_task(tmp_path, param_p3):
@@ -1350,7 +1349,7 @@ def test_parameters_pending_during_add_task(tmp_path, param_p3):
     t2 = hf.Task(schemas=s2, inputs=[hf.InputValue(param_p3, 301)])
     with wk.batch_update():
         wk.add_task(t2)
-        assert wk._store._pending["parameter_data"]
+        assert wk._store._pending.add_parameters
 
 
 def test_add_task_after(workflow_w0):