hpcflow-new2 0.2.0a189__py3-none-any.whl → 0.2.0a190__py3-none-any.whl

hpcflow/tests/unit/test_persistence.py

@@ -1,49 +1,61 @@
+from __future__ import annotations
 from pathlib import Path
+from typing import cast, TYPE_CHECKING
 import numpy as np
-import zarr
+import zarr  # type: ignore
 import pytest
 from hpcflow.sdk.core.test_utils import make_test_data_YAML_workflow
-from hpcflow.sdk.persistence.base import StoreEAR, StoreElement, StoreElementIter
-from hpcflow.sdk.persistence.json import JSONPersistentStore
-
+from hpcflow.sdk.persistence.json import (
+    JSONPersistentStore,
+    JsonStoreElement,
+    JsonStoreElementIter,
+    JsonStoreEAR,
+)
 from hpcflow.app import app as hf
 
+if TYPE_CHECKING:
+    from hpcflow.sdk.persistence.zarr import ZarrPersistentStore
+
 
 @pytest.mark.skip("need to refactor `make_test_store_from_spec`")
-def test_store_pending_add_task(tmp_path):
+def test_store_pending_add_task(tmp_path: Path):
     """Check expected pending state after adding a task."""
 
     # make store: 0 tasks:
-    store = JSONPersistentStore.make_test_store_from_spec([], dir=tmp_path)
+    store = JSONPersistentStore.make_test_store_from_spec(hf, [], 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):
+def test_store_pending_add_element(tmp_path: 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(
+        elem_ID: JsonStoreElement(
             id_=elem_ID,
             is_pending=True,
-            element_idx=0,
+            es_idx=0,
             task_ID=0,
             iteration_IDs=[],
+            index=0,
+            seq_idx={},
+            src_idx={},
         )
     } 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):
+def test_store_pending_add_element_iter(tmp_path: Path, elem_ID: int):
     """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(
+        hf,
         [{"elements": [{}, {}]}],
         dir=tmp_path,
     )
@@ -53,23 +65,25 @@ def test_store_pending_add_element_iter(tmp_path, elem_ID):
         schema_parameters=[],
     )
     assert store._pending.add_elem_iters == {
-        iter_ID: StoreElementIter(
+        iter_ID: JsonStoreElementIter(
             id_=iter_ID,
             is_pending=True,
             element_ID=elem_ID,
             EAR_IDs={},
             data_idx={},
             schema_parameters=[],
+            EARs_initialised=False,
         )
     } 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):
+def test_store_pending_add_EAR(tmp_path: 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(
+        hf,
         [{"elements": [{"iterations": [{}]}]}],
         dir=tmp_path,
     )
@@ -81,7 +95,7 @@ def test_store_pending_add_EAR(tmp_path):
         metadata={},
     )
     assert store._pending.add_EARs == {
-        EAR_ID: StoreEAR(
+        EAR_ID: JsonStoreEAR(
             id_=EAR_ID,
             is_pending=True,
             elem_iter_ID=0,
@@ -94,21 +108,21 @@ def test_store_pending_add_EAR(tmp_path):
 
 
 @pytest.mark.skip("need to refactor `make_test_store_from_spec`")
-def test_get_task_elements_task_is_pending(tmp_path):
+def test_get_task_elements_task_is_pending(tmp_path: 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)
+    store = JSONPersistentStore.make_test_store_from_spec(hf, [], 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):
+def test_get_task_elements_single_element_is_pending(tmp_path: 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 = JSONPersistentStore.make_test_store_from_spec(hf, [{}], dir=tmp_path)
     store.add_element(task_ID=0)
     assert store.get_task_elements(0, slice(0, None)) == [
         {
@@ -123,12 +137,12 @@ def test_get_task_elements_single_element_is_pending(tmp_path):
 
 
 @pytest.mark.skip("need to refactor `make_test_store_from_spec`")
-def test_get_task_elements_multi_element_one_pending(tmp_path):
+def test_get_task_elements_multi_element_one_pending(tmp_path: 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
+        hf, [{"elements": [{}]}], dir=tmp_path
     )
     store.add_element(task_ID=0)
     assert store.get_task_elements(0, slice(0, None)) == [
@@ -152,12 +166,12 @@ def test_get_task_elements_multi_element_one_pending(tmp_path):
 
 
 @pytest.mark.skip("need to refactor `make_test_store_from_spec`")
-def test_get_task_elements_single_element_iter_pending(tmp_path):
+def test_get_task_elements_single_element_iter_pending(tmp_path: 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
+        hf, [{"elements": [{}]}], dir=tmp_path
     )
     store.add_element_iteration(element_ID=0, data_idx={}, schema_parameters=[])
     assert store.get_task_elements(0, slice(0, None)) == [
@@ -183,12 +197,12 @@ def test_get_task_elements_single_element_iter_pending(tmp_path):
 
 
 @pytest.mark.skip("need to refactor `make_test_store_from_spec`")
-def test_get_task_elements_single_element_iter_EAR_pending(tmp_path):
+def test_get_task_elements_single_element_iter_EAR_pending(tmp_path: 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
+        hf, [{"elements": [{"iterations": [{}]}]}], dir=tmp_path
     )
     store.add_EAR(elem_iter_ID=0, action_idx=0, commands_idx=[], data_idx={}, metadata={})
     assert store.get_task_elements(0, slice(0, None)) == [
@@ -225,7 +239,7 @@ def test_get_task_elements_single_element_iter_EAR_pending(tmp_path):
     ]
 
 
-def test_make_zarr_store_zstd_compressor(null_config, tmp_path):
+def test_make_zarr_store_zstd_compressor(null_config, tmp_path: Path):
     wk = make_test_data_YAML_workflow(
         workflow_name="workflow_1.yaml",
         path=tmp_path,
@@ -234,7 +248,7 @@ def test_make_zarr_store_zstd_compressor(null_config, tmp_path):
     )
 
 
-def test_make_zarr_store_no_compressor(null_config, tmp_path):
+def test_make_zarr_store_no_compressor(null_config, tmp_path: Path):
     wk = make_test_data_YAML_workflow(
         workflow_name="workflow_1.yaml",
         path=tmp_path,
@@ -244,7 +258,7 @@ def test_make_zarr_store_no_compressor(null_config, tmp_path):
 
 
 @pytest.mark.integration
-def test_zarr_rechunk_data_equivalent(null_config, tmp_path):
+def test_zarr_rechunk_data_equivalent(null_config, tmp_path: Path):
     t1 = hf.Task(
         schema=hf.task_schemas.test_t1_conditional_OS,
         inputs={"p1": 101},
@@ -259,7 +273,7 @@ def test_zarr_rechunk_data_equivalent(null_config, tmp_path):
     wk.submit(wait=True, status=False, add_to_known=False)
     wk.rechunk_runs(backup=True, status=False, chunk_size=None)  # None -> one chunk
 
-    arr = wk._store._get_EARs_arr()
+    arr = cast("ZarrPersistentStore", wk._store)._get_EARs_arr()
     assert arr.chunks == arr.shape
 
     bak_path = (Path(wk.path) / arr.path).with_suffix(".bak")
@@ -275,7 +289,7 @@ def test_zarr_rechunk_data_equivalent(null_config, tmp_path):
 
 
 @pytest.mark.integration
-def test_zarr_rechunk_data_equivalent_custom_chunk_size(null_config, tmp_path):
+def test_zarr_rechunk_data_equivalent_custom_chunk_size(null_config, tmp_path: Path):
     t1 = hf.Task(
         schema=hf.task_schemas.test_t1_conditional_OS,
         inputs={"p1": 101},
@@ -290,7 +304,7 @@ def test_zarr_rechunk_data_equivalent_custom_chunk_size(null_config, tmp_path):
     wk.submit(wait=True, status=False, add_to_known=False)
     wk.rechunk_runs(backup=True, status=False, chunk_size=2)
 
-    arr = wk._store._get_EARs_arr()
+    arr = cast("ZarrPersistentStore", wk._store)._get_EARs_arr()
     assert arr.chunks == (2,)
 
     bak_path = (Path(wk.path) / arr.path).with_suffix(".bak")
@@ -303,7 +317,7 @@ def test_zarr_rechunk_data_equivalent_custom_chunk_size(null_config, tmp_path):
 
 
 @pytest.mark.integration
-def test_zarr_rechunk_data_no_backup_load_runs(null_config, tmp_path):
+def test_zarr_rechunk_data_no_backup_load_runs(null_config, tmp_path: Path):
     t1 = hf.Task(
         schema=hf.task_schemas.test_t1_conditional_OS,
         inputs={"p1": 101},
@@ -318,7 +332,7 @@ def test_zarr_rechunk_data_no_backup_load_runs(null_config, tmp_path):
     wk.submit(wait=True, status=False, add_to_known=False)
     wk.rechunk_runs(backup=False, status=False)
 
-    arr = wk._store._get_EARs_arr()
+    arr = cast("ZarrPersistentStore", wk._store)._get_EARs_arr()
 
     bak_path = (Path(wk.path) / arr.path).with_suffix(".bak")
     assert not bak_path.is_file()
@@ -331,7 +345,7 @@ def test_zarr_rechunk_data_no_backup_load_runs(null_config, tmp_path):
 
 
 @pytest.mark.integration
-def test_zarr_rechunk_data_no_backup_load_parameter_base(null_config, tmp_path):
+def test_zarr_rechunk_data_no_backup_load_parameter_base(null_config, tmp_path: Path):
     t1 = hf.Task(
         schema=hf.task_schemas.test_t1_conditional_OS,
         inputs={"p1": 101},
@@ -346,13 +360,12 @@ def test_zarr_rechunk_data_no_backup_load_parameter_base(null_config, tmp_path):
     wk.submit(wait=True, status=False, add_to_known=False)
     wk.rechunk_parameter_base(backup=False, status=False)
 
-    arr = wk._store._get_parameter_base_array()
+    arr = cast("ZarrPersistentStore", wk._store)._get_parameter_base_array()
 
     bak_path = (Path(wk.path) / arr.path).with_suffix(".bak")
     assert not bak_path.is_file()
 
     # check we can load parameters:
-    params = wk.get_all_parameters()
     param_IDs = []
-    for i in params:
+    for i in wk.get_all_parameters():
         param_IDs.append(i.id_)

hpcflow/tests/unit/test_resources.py

@@ -1,16 +1,18 @@
+from __future__ import annotations
 import os
+from pathlib import Path
 import pytest
 from hpcflow.app import app as hf
 from hpcflow.sdk.core.errors import UnsupportedSchedulerError
 
 
-def test_init_scope_equivalence_simple():
+def test_init_scope_equivalence_simple() -> None:
     rs1 = hf.ResourceSpec(scope=hf.ActionScope.any(), num_cores=1)
     rs2 = hf.ResourceSpec(scope="any", num_cores=1)
     assert rs1 == rs2
 
 
-def test_init_scope_equivalence_with_kwargs():
+def test_init_scope_equivalence_with_kwargs() -> None:
     rs1 = hf.ResourceSpec(
         scope=hf.ActionScope.input_file_generator(file="my_file"), num_cores=1
     )
@@ -18,32 +20,32 @@ def test_init_scope_equivalence_with_kwargs():
     assert rs1 == rs2
 
 
-def test_init_no_args():
+def test_init_no_args() -> None:
     rs1 = hf.ResourceSpec()
     rs2 = hf.ResourceSpec(scope="any")
     assert rs1 == rs2
 
 
-def test_resource_list_raise_on_identical_scopes():
+def test_resource_list_raise_on_identical_scopes() -> None:
     with pytest.raises(ValueError):
         hf.ResourceList.normalise([{"scope": "any"}, {"scope": "any"}])
 
 
-def test_merge_other_same_scope():
+def test_merge_other_same_scope() -> None:
     res_lst_1 = hf.ResourceList.from_json_like({"any": {"num_cores": 1}})
     res_lst_2 = hf.ResourceList.from_json_like({"any": {}})
     res_lst_2.merge_other(res_lst_1)
     assert res_lst_2 == hf.ResourceList.from_json_like({"any": {"num_cores": 1}})
 
 
-def test_merge_other_same_scope_no_overwrite():
+def test_merge_other_same_scope_no_overwrite() -> None:
     res_lst_1 = hf.ResourceList.from_json_like({"any": {"num_cores": 1}})
     res_lst_2 = hf.ResourceList.from_json_like({"any": {"num_cores": 2}})
     res_lst_2.merge_other(res_lst_1)
     assert res_lst_2 == hf.ResourceList.from_json_like({"any": {"num_cores": 2}})
 
 
-def test_merge_other_multi_scope():
+def test_merge_other_multi_scope() -> None:
     res_lst_1 = hf.ResourceList.from_json_like({"any": {"num_cores": 1}})
     res_lst_2 = hf.ResourceList.from_json_like({"any": {}, "main": {"num_cores": 3}})
     res_lst_2.merge_other(res_lst_1)
@@ -53,7 +55,7 @@ def test_merge_other_multi_scope():
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_merge_other_persistent_workflow_reload(null_config, tmp_path, store):
+def test_merge_other_persistent_workflow_reload(null_config, tmp_path: Path, store: str):
     wkt = hf.WorkflowTemplate(
         name="test_load",
         resources={"any": {"num_cores": 2}},
@@ -70,7 +72,7 @@ def test_merge_other_persistent_workflow_reload(null_config, tmp_path, store):
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_use_persistent_resource_spec(null_config, tmp_path, store):
+def test_use_persistent_resource_spec(null_config, tmp_path: Path, store: str):
     # create a workflow from which we can use a resource spec in a new workflow:
     num_cores_check = 2
     wk_base = hf.Workflow.from_template_data(
@@ -104,7 +106,7 @@ def test_use_persistent_resource_spec(null_config, tmp_path, store):
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_use_persistent_resource_list(null_config, tmp_path, store):
+def test_use_persistent_resource_list(null_config, tmp_path: Path, store: str):
     # create a workflow from which we can use the resource list in a new workflow:
     num_cores_check = 2
     wk_base = hf.Workflow.from_template_data(
@@ -138,7 +140,7 @@ def test_use_persistent_resource_list(null_config, tmp_path, store):
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_default_scheduler_set(new_null_config, tmp_path, store):
+def test_default_scheduler_set(new_null_config, tmp_path: Path, store: str):
     wk = hf.Workflow.from_template_data(
         template_name="wk",
         path=tmp_path,
@@ -154,21 +156,21 @@ def test_default_scheduler_set(new_null_config, tmp_path, store):
     assert wk.submissions[0].jobscripts[0].scheduler_name == hf.config.default_scheduler
 
 
-def test_scheduler_case_insensitive(null_config):
+def test_scheduler_case_insensitive(null_config) -> None:
     rs1 = hf.ResourceSpec(scheduler="direct")
     rs2 = hf.ResourceSpec(scheduler="dIrEcT")
     assert rs1 == rs2
     assert rs1.scheduler == rs2.scheduler == "direct"
 
 
-def test_scheduler_strip(null_config):
+def test_scheduler_strip(null_config) -> None:
     rs1 = hf.ResourceSpec(scheduler="  direct ")
     rs2 = hf.ResourceSpec(scheduler="direct")
     assert rs1 == rs2
     assert rs1.scheduler == rs2.scheduler == "direct"
 
 
-def test_shell_case_insensitive(null_config):
+def test_shell_case_insensitive(null_config) -> None:
     shell_name = "bash" if os.name == "posix" else "powershell"
     shell_name_title = shell_name
     n = shell_name_title[0]
@@ -180,7 +182,7 @@ def test_shell_case_insensitive(null_config):
     assert rs1.shell == rs2.shell == shell_name
 
 
-def test_shell_strip(null_config):
+def test_shell_strip(null_config) -> None:
     shell_name = "bash" if os.name == "posix" else "powershell"
     rs1 = hf.ResourceSpec(shell=f"  {shell_name} ")
     rs2 = hf.ResourceSpec(shell=shell_name)
@@ -195,14 +197,14 @@ def test_os_name_case_insensitive(null_config):
     assert rs1.os_name == rs2.os_name == "nt"
 
 
-def test_os_name_strip(null_config):
+def test_os_name_strip(null_config) -> None:
     rs1 = hf.ResourceSpec(os_name="  nt ")
     rs2 = hf.ResourceSpec(os_name="nt")
     assert rs1 == rs2
     assert rs1.os_name == rs2.os_name == "nt"
 
 
-def test_raise_on_unsupported_scheduler(new_null_config, tmp_path):
+def test_raise_on_unsupported_scheduler(new_null_config, tmp_path: Path):
     # slurm not supported by default config file:
     wk = hf.Workflow.from_template_data(
         template_name="wk1",
@@ -219,7 +221,7 @@ def test_raise_on_unsupported_scheduler(new_null_config, tmp_path):
         wk.add_submission()
 
 
-def test_can_use_non_default_scheduler(new_null_config, tmp_path):
+def test_can_use_non_default_scheduler(new_null_config, tmp_path: Path):
     # for either OS choose a compatible scheduler not set by default:
     if os.name == "nt":
         opt_scheduler = "direct_posix"  # i.e for WSL

hpcflow/tests/unit/test_run.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+from pathlib import Path
 from hpcflow.app import app as hf
 
 
-def test_compose_commands_no_shell_var(null_config, tmp_path):
+def test_compose_commands_no_shell_var(null_config, tmp_path: Path):
     ts = hf.TaskSchema(
         objective="test_compose_commands",
         actions=[hf.Action(commands=[hf.Command(command="Start-Sleep 10")])],
@@ -12,13 +14,14 @@ def test_compose_commands_no_shell_var(null_config, tmp_path):
         tasks=[hf.Task(schema=ts)],
     )
     sub = wk.add_submission()
+    assert sub is not None
     js = sub.jobscripts[0]
     run = wk.tasks[0].elements[0].iterations[0].action_runs[0]
     _, shell_vars = run.compose_commands(jobscript=js, JS_action_idx=0)
     assert shell_vars == {0: []}
 
 
-def test_compose_commands_single_shell_var(null_config, tmp_path):
+def test_compose_commands_single_shell_var(null_config, tmp_path: Path):
     ts = hf.TaskSchema(
         objective="test_compose_commands",
         inputs=[hf.SchemaInput("p1")],
@@ -40,13 +43,14 @@ def test_compose_commands_single_shell_var(null_config, tmp_path):
         tasks=[hf.Task(schema=ts, inputs={"p1": 101})],
     )
     sub = wk.add_submission()
+    assert sub is not None
     js = sub.jobscripts[0]
     run = wk.tasks[0].elements[0].iterations[0].action_runs[0]
     _, shell_vars = run.compose_commands(jobscript=js, JS_action_idx=0)
     assert shell_vars == {0: [("outputs.p1", "parameter_p1", "stdout")]}
 
 
-def test_compose_commands_multi_single_shell_var(null_config, tmp_path):
+def test_compose_commands_multi_single_shell_var(null_config, tmp_path: Path):
     ts = hf.TaskSchema(
         objective="test_compose_commands",
         inputs=[hf.SchemaInput("p1")],
@@ -69,6 +73,7 @@ def test_compose_commands_multi_single_shell_var(null_config, tmp_path):
         tasks=[hf.Task(schema=ts, inputs={"p1": 101})],
     )
     sub = wk.add_submission()
+    assert sub is not None
     js = sub.jobscripts[0]
     run = wk.tasks[0].elements[0].iterations[0].action_runs[0]
     _, shell_vars = run.compose_commands(jobscript=js, JS_action_idx=0)

hpcflow/tests/unit/test_runtime.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
 from hpcflow.app import app as hf
 
 
-def test_in_pytest_if_not_frozen():
+def test_in_pytest_if_not_frozen() -> None:
     """This is to check we can get the correct invocation command when running non-frozen
     tests (when frozen the invocation command is just the executable file)."""
     if not hf.run_time_info.is_frozen:

hpcflow/tests/unit/test_schema_input.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+from pathlib import Path
 import pytest
 
 from hpcflow.app import app as hf
@@ -11,19 +13,19 @@ def null_config(tmp_path):
         hf.load_config(config_dir=tmp_path)
 
 
-def test_null_default_value(null_config):
+def test_null_default_value(null_config) -> None:
     p1 = hf.Parameter("p1")
     p1_inp = hf.SchemaInput(parameter=p1)
     assert "default_value" not in p1_inp.labels[""]
 
 
-def test_null_default_value_property(null_config):
+def test_null_default_value_property(null_config) -> None:
     p1 = hf.Parameter("p1")
     p1_inp = hf.SchemaInput(parameter=p1)
     assert p1_inp.default_value is NullDefault.NULL
 
 
-def test_none_default_value(null_config):
+def test_none_default_value(null_config) -> None:
     """A `None` default value is set with a value of `None`"""
     p1 = hf.Parameter("p1")
     p1_inp = hf.SchemaInput(parameter=p1, default_value=None)
@@ -32,7 +34,7 @@ def test_none_default_value(null_config):
     assert p1_inp.labels[""]["default_value"].value == def_val_exp.value
 
 
-def test_from_json_like_labels_and_default(null_config):
+def test_from_json_like_labels_and_default(null_config) -> None:
     json_like = {
         "parameter": "p1",
         "labels": {"0": {}},
@@ -45,7 +47,7 @@ def test_from_json_like_labels_and_default(null_config):
     assert inp.labels["0"]["default_value"].value == None
 
 
-def test_element_get_removes_schema_param_trivial_label(null_config, tmp_path):
+def test_element_get_removes_schema_param_trivial_label(null_config, tmp_path: Path):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -61,7 +63,7 @@ def test_element_get_removes_schema_param_trivial_label(null_config, tmp_path):
     assert wk.tasks[0].elements[0].get("inputs") == {"p1": p1_val}
 
 
-def test_element_inputs_removes_schema_param_trivial_label(null_config, tmp_path):
+def test_element_inputs_removes_schema_param_trivial_label(null_config, tmp_path: Path):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -91,7 +93,9 @@ def test_element_inputs_removes_schema_param_trivial_label(null_config, tmp_path
     assert element.iterations[0].action_runs[0].inputs._get_prefixed_names() == ["p1"]
 
 
-def test_element_get_does_not_removes_multiple_schema_param_label(null_config, tmp_path):
+def test_element_get_does_not_removes_multiple_schema_param_label(
+    null_config, tmp_path: Path
+):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -109,7 +113,7 @@ def test_element_get_does_not_removes_multiple_schema_param_label(null_config, t
 
 
 def test_element_inputs_does_not_remove_multiple_schema_param_label(
-    null_config, tmp_path
+    null_config, tmp_path: Path
 ):
     p1_val = 101
     label = "my_label"
@@ -142,7 +146,9 @@ def test_element_inputs_does_not_remove_multiple_schema_param_label(
     ]
 
 
-def test_get_input_values_for_multiple_schema_input_single_label(null_config, tmp_path):
+def test_get_input_values_for_multiple_schema_input_single_label(
+    null_config, tmp_path: Path
+):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -170,7 +176,7 @@ def test_get_input_values_for_multiple_schema_input_single_label(null_config, tm
     assert run.get_input_values() == {"p2": 201, "p1": 101}
 
 
-def test_get_input_values_subset(null_config, tmp_path):
+def test_get_input_values_subset(null_config, tmp_path: Path):
     p1_val = 101
     s1 = hf.TaskSchema(
         objective="t1",
@@ -195,7 +201,7 @@ def test_get_input_values_subset(null_config, tmp_path):
     assert run.get_input_values(inputs=("p1",)) == {"p1": 101}
 
 
-def test_get_input_values_subset_labelled_label_dict_False(null_config, tmp_path):
+def test_get_input_values_subset_labelled_label_dict_False(null_config, tmp_path: Path):
     p1_val = 101
     s1 = hf.TaskSchema(
         objective="t1",
@@ -229,7 +235,7 @@ def test_get_input_values_subset_labelled_label_dict_False(null_config, tmp_path
     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):
+def test_get_input_values_subset_labelled_label_dict_True(null_config, tmp_path: Path):
     p1_val = 101
     s1 = hf.TaskSchema(
         objective="t1",
@@ -265,7 +271,7 @@ def test_get_input_values_subset_labelled_label_dict_True(null_config, tmp_path)
     }
 
 
-def test_get_input_values_for_multiple_schema_input(null_config, tmp_path):
+def test_get_input_values_for_multiple_schema_input(null_config, tmp_path: Path):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -293,7 +299,9 @@ def test_get_input_values_for_multiple_schema_input(null_config, tmp_path):
     assert run.get_input_values() == {"p2": 201, "p1": {label: 101}}
 
 
-def test_get_input_values_for_multiple_schema_input_with_object(null_config, tmp_path):
+def test_get_input_values_for_multiple_schema_input_with_object(
+    null_config, tmp_path: Path
+):
     p1_val = P1(a=101)
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -324,7 +332,7 @@ def test_get_input_values_for_multiple_schema_input_with_object(null_config, tmp
 
 
 @pytest.mark.integration
-def test_get_input_values_all_iterations(null_config, tmp_path):
+def test_get_input_values_all_iterations(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],

hpcflow/tests/unit/test_shell.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
 from hpcflow.sdk.submission.shells import ALL_SHELLS
 
 
-def test_process_JS_header_args_app_invoc_windows_powershell():
+def test_process_JS_header_args_app_invoc_windows_powershell() -> None:
     """
     Three types of invocation commands exist:
       1. the frozen app executable
@@ -40,7 +41,7 @@ def test_process_JS_header_args_app_invoc_windows_powershell():
         assert processed["app_invoc"] == j
 
 
-def test_process_JS_header_args_app_invoc_bash():
+def test_process_JS_header_args_app_invoc_bash() -> None:
     """
     Three types of invocation commands exist:
       1. the frozen app executable