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

hpcflow/tests/unit/test_element.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+from pathlib import Path
 from textwrap import dedent
+from typing import Any, TYPE_CHECKING
 import pytest
 from hpcflow.app import app as hf
 from hpcflow.sdk.core.errors import UnsetParameterDataError
@@ -8,14 +11,15 @@ from hpcflow.sdk.core.test_utils import (
     P1_sub_parameter_cls as P1_sub,
 )
 
+if TYPE_CHECKING:
+    from hpcflow.sdk.core.workflow import Workflow
+
 
 @pytest.fixture
-def workflow_w1(null_config, tmp_path):
+def workflow_w1(null_config, tmp_path: Path) -> Workflow:
     s1, s2 = make_schemas(
-        [
-            [{"p1": None}, ("p2",), "t1"],
-            [{"p2": None}, (), "t2"],
-        ]
+        ({"p1": None}, ("p2",), "t1"),
+        ({"p2": None}, (), "t2"),
     )
 
     t1 = hf.Task(
@@ -28,38 +32,30 @@ def workflow_w1(null_config, tmp_path):
     return hf.Workflow.from_template(wkt, path=tmp_path)
 
 
-def test_element_task_dependencies(workflow_w1):
+def test_element_task_dependencies(workflow_w1: Workflow):
     assert workflow_w1.tasks.t2.elements[0].get_task_dependencies(as_objects=True) == [
         workflow_w1.tasks.t1
     ]
 
 
-def test_element_dependent_tasks(workflow_w1):
+def test_element_dependent_tasks(workflow_w1: Workflow):
     assert workflow_w1.tasks.t1.elements[0].get_dependent_tasks(as_objects=True) == [
         workflow_w1.tasks.t2
     ]
 
 
-def test_element_element_dependencies(workflow_w1):
-    assert all(
-        (
-            workflow_w1.tasks.t2.elements[0].get_element_dependencies() == [0],
-            workflow_w1.tasks.t2.elements[1].get_element_dependencies() == [1],
-        )
-    )
+def test_element_element_dependencies(workflow_w1: Workflow):
+    assert workflow_w1.tasks.t2.elements[0].get_element_dependencies() == {0}
+    assert workflow_w1.tasks.t2.elements[1].get_element_dependencies() == {1}
 
 
-def test_element_dependent_elements(workflow_w1):
-    assert all(
-        (
-            workflow_w1.tasks.t1.elements[0].get_dependent_elements() == [2],
-            workflow_w1.tasks.t1.elements[1].get_dependent_elements() == [3],
-        )
-    )
+def test_element_dependent_elements(workflow_w1: Workflow):
+    assert workflow_w1.tasks.t1.elements[0].get_dependent_elements() == {2}
+    assert workflow_w1.tasks.t1.elements[1].get_dependent_elements() == {3}
 
 
 def test_equivalence_single_labelled_schema_input_element_get_label_and_non_label(
-    new_null_config, tmp_path
+    new_null_config, tmp_path: Path
 ):
     s1 = hf.TaskSchema(
         objective="t1",
@@ -83,7 +79,7 @@ def test_equivalence_single_labelled_schema_input_element_get_label_and_non_labe
     )
 
 
-def test_element_dependencies_inputs_only_schema(new_null_config, tmp_path):
+def test_element_dependencies_inputs_only_schema(new_null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
@@ -115,12 +111,12 @@ def test_element_dependencies_inputs_only_schema(new_null_config, tmp_path):
         path=tmp_path,
         template_name="wk0",
     )
-    assert wk.tasks.t1.elements[0].get_dependent_elements() == [1]
-    assert wk.tasks.t2.elements[0].get_element_dependencies() == [0]
-    assert wk.tasks.t2.elements[0].get_EAR_dependencies() == [0]
+    assert wk.tasks.t1.elements[0].get_dependent_elements() == {1}
+    assert wk.tasks.t2.elements[0].get_element_dependencies() == {0}
+    assert wk.tasks.t2.elements[0].get_EAR_dependencies() == {0}
 
 
-def test_element_get_empty_path_single_labelled_input(null_config, tmp_path):
+def test_element_get_empty_path_single_labelled_input(null_config, tmp_path: Path):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -138,7 +134,7 @@ def test_element_get_empty_path_single_labelled_input(null_config, tmp_path):
     }
 
 
-def test_element_get_labelled_non_labelled_equivalence(null_config, tmp_path):
+def test_element_get_labelled_non_labelled_equivalence(null_config, tmp_path: Path):
     p1_val = 101
     label = "my_label"
     s1 = hf.TaskSchema(
@@ -156,7 +152,7 @@ def test_element_get_labelled_non_labelled_equivalence(null_config, tmp_path):
 
 
 @pytest.fixture
-def element_get_wk(null_config, tmp_path):
+def element_get_wk(null_config, tmp_path: Path) -> Workflow:
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter="p1"), hf.SchemaInput(parameter="p1c")],
@@ -191,62 +187,62 @@ def element_get_wk(null_config, tmp_path):
     return wk
 
 
-def test_element_get_simple(element_get_wk):
+def test_element_get_simple(element_get_wk: Workflow):
     assert element_get_wk.tasks.t1.elements[0].get("inputs.p1") == 100
     assert element_get_wk.tasks.t1.elements[1].get("inputs.p1") == 100
 
 
-def test_element_get_obj(element_get_wk):
+def test_element_get_obj(element_get_wk: Workflow):
     obj_0 = P1(a=20, sub_param=P1_sub(e=5))
     obj_1 = P1(a=30, sub_param=P1_sub(e=5))
     assert element_get_wk.tasks.t1.elements[0].get("inputs.p1c") == obj_0
     assert element_get_wk.tasks.t1.elements[1].get("inputs.p1c") == obj_1
 
 
-def test_element_get_sub_obj(element_get_wk):
+def test_element_get_sub_obj(element_get_wk: Workflow):
     sub_obj = P1_sub(e=5)
     assert element_get_wk.tasks.t1.elements[0].get("inputs.p1c.sub_param") == sub_obj
     assert element_get_wk.tasks.t1.elements[1].get("inputs.p1c.sub_param") == sub_obj
 
 
-def test_element_get_sub_obj_attr(element_get_wk):
+def test_element_get_sub_obj_attr(element_get_wk: Workflow):
     assert element_get_wk.tasks.t1.elements[0].get("inputs.p1c.sub_param.e") == 5
     assert element_get_wk.tasks.t1.elements[1].get("inputs.p1c.sub_param.e") == 5
 
 
-def test_element_get_sub_obj_property(element_get_wk):
+def test_element_get_sub_obj_property(element_get_wk: Workflow):
     assert element_get_wk.tasks.t1.elements[0].get("inputs.p1c.sub_param.twice_e") == 10
     assert element_get_wk.tasks.t1.elements[1].get("inputs.p1c.sub_param.twice_e") == 10
 
 
-def test_element_get_obj_no_raise_missing_attr(element_get_wk):
+def test_element_get_obj_no_raise_missing_attr(element_get_wk: Workflow):
     assert element_get_wk.tasks.t1.elements[0].get("inputs.p1c.b") is None
 
 
-def test_element_get_obj_raise_missing_attr(element_get_wk):
+def test_element_get_obj_raise_missing_attr(element_get_wk: Workflow):
     with pytest.raises(ValueError):
         element_get_wk.tasks.t1.elements[0].get("inputs.p1c.b", raise_on_missing=True)
 
 
-def test_element_get_obj_raise_missing_nested_attr(element_get_wk):
+def test_element_get_obj_raise_missing_nested_attr(element_get_wk: Workflow):
     with pytest.raises(ValueError):
         element_get_wk.tasks.t1.elements[0].get("inputs.p1c.a.b", raise_on_missing=True)
 
 
-def test_element_get_raise_missing_root(element_get_wk):
+def test_element_get_raise_missing_root(element_get_wk: Workflow):
     with pytest.raises(ValueError):
         element_get_wk.tasks.t1.elements[0].get("blah", raise_on_missing=True)
 
 
-def test_element_get_no_raise_missing_root(element_get_wk):
+def test_element_get_no_raise_missing_root(element_get_wk: Workflow):
     assert element_get_wk.tasks.t1.elements[0].get("blah") is None
 
 
-def test_element_get_expected_default(element_get_wk):
+def test_element_get_expected_default(element_get_wk: Workflow):
     assert element_get_wk.tasks.t1.elements[0].get("blah", default={}) == {}
 
 
-def test_element_get_part_unset(null_config, tmp_path):
+def test_element_get_part_unset(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter="p1")],
@@ -299,7 +295,7 @@ def test_element_get_part_unset(null_config, tmp_path):
         wk.tasks.t2.elements[0].get("inputs.p2", raise_on_unset=True)
 
 
-def test_element_get_unset_object(null_config, tmp_path):
+def test_element_get_unset_object(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter="p1")],
@@ -328,7 +324,7 @@ def test_element_get_unset_object(null_config, tmp_path):
     assert wk.tasks.t1.elements[0].get("outputs.p1c") == None
 
 
-def test_element_get_unset_sub_object(null_config, tmp_path):
+def test_element_get_unset_sub_object(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter="p1")],
@@ -357,7 +353,7 @@ def test_element_get_unset_sub_object(null_config, tmp_path):
     assert wk.tasks.t1.elements[0].get("outputs.p1c.sub_param") == None
 
 
-def test_element_get_unset_object_group(null_config, tmp_path):
+def test_element_get_unset_object_group(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter="p1c")],
@@ -397,7 +393,7 @@ def test_element_get_unset_object_group(null_config, tmp_path):
     assert wk.tasks.t2.elements[0].get("inputs.p1c") == [None, None]
 
 
-def test_element_get_unset_sub_object_group(null_config, tmp_path):
+def test_element_get_unset_sub_object_group(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter="p1c")],
@@ -437,7 +433,7 @@ def test_element_get_unset_sub_object_group(null_config, tmp_path):
     assert wk.tasks.t2.elements[0].get("inputs.p1c.sub_param") == [None, None]
 
 
-def test_iter(new_null_config, tmp_path):
+def test_iter(new_null_config, tmp_path: Path):
     wkt = hf.WorkflowTemplate(
         name="test",
         tasks=[
@@ -452,7 +448,7 @@ def test_iter(new_null_config, tmp_path):
         assert elem_i.index == idx
 
 
-def test_slice(new_null_config, tmp_path):
+def test_slice(new_null_config, tmp_path: Path):
     wkt = hf.WorkflowTemplate(
         name="test",
         tasks=[
@@ -469,7 +465,7 @@ def test_slice(new_null_config, tmp_path):
     assert elems[1].index == 2
 
 
-def test_element_get_with_list_index_sequence(null_config, tmp_path):
+def test_element_get_with_list_index_sequence(null_config, tmp_path: Path):
     wkt_yaml = dedent(
         """\
         name: test_list_idx_sequence
@@ -487,7 +483,7 @@ def test_element_get_with_list_index_sequence(null_config, tmp_path):
     assert wk.tasks[0].elements[0].get("inputs.p1") == [9, 1]
 
 
-def test_element_get_with_list_index_sequence_two_parts(null_config, tmp_path):
+def test_element_get_with_list_index_sequence_two_parts(null_config, tmp_path: Path):
     wkt_yaml = dedent(
         """\
         name: test_list_idx_sequence
@@ -515,7 +511,7 @@ def test_element_get_with_list_index_sequence_two_parts(null_config, tmp_path):
     ]
 
 
-def test_element_get_group_sequence(null_config, tmp_path):
+def test_element_get_group_sequence(null_config, tmp_path: Path):
     wkt_yaml = dedent(
         """\
         name: test_list_idx_sequence
@@ -553,7 +549,7 @@ def test_element_get_group_sequence(null_config, tmp_path):
     ]
 
 
-def test_element_get_group_sequence_obj(new_null_config, tmp_path):
+def test_element_get_group_sequence_obj(new_null_config, tmp_path: Path):
     wkt_yaml = dedent(
         """\
         name: test_list_idx_sequence
@@ -607,29 +603,28 @@ def test_element_get_group_sequence_obj(new_null_config, tmp_path):
     ]
 
 
-def test_element_resources_get_jobscript_hash_equal_empty():
+def test_element_resources_get_jobscript_hash_equal_empty() -> None:
     assert (
         hf.ElementResources().get_jobscript_hash()
         == hf.ElementResources().get_jobscript_hash()
     )
 
 
-def test_element_resources_get_jobscript_hash_unequal_num_cores():
+def test_element_resources_get_jobscript_hash_unequal_num_cores() -> None:
     assert (
         hf.ElementResources(num_cores=1).get_jobscript_hash()
         != hf.ElementResources(num_cores=2).get_jobscript_hash()
     )
 
 
-def test_element_resources_get_jobscript_hash_equal_num_cores():
+def test_element_resources_get_jobscript_hash_equal_num_cores() -> None:
     assert (
         hf.ElementResources(num_cores=1).get_jobscript_hash()
         == hf.ElementResources(num_cores=1).get_jobscript_hash()
     )
 
 
-def test_element_resources_get_jobscript_hash_unequal_scheduler_args_empty():
-
+def test_element_resources_get_jobscript_hash_unequal_scheduler_args_empty() -> None:
     assert (
         hf.ElementResources().get_jobscript_hash()
         != hf.ElementResources(
@@ -638,16 +633,16 @@ def test_element_resources_get_jobscript_hash_unequal_scheduler_args_empty():
     )
 
 
-def test_element_resources_get_jobscript_hash_equal_non_truthy_scheduler_args():
-
+def test_element_resources_get_jobscript_hash_equal_non_truthy_scheduler_args() -> None:
     assert (
         hf.ElementResources().get_jobscript_hash()
         == hf.ElementResources(scheduler_args={}).get_jobscript_hash()
     )
 
 
-def test_element_resources_get_jobscript_hash_unequal_scheduler_args_diff_options():
-
+def test_element_resources_get_jobscript_hash_unequal_scheduler_args_diff_options() -> (
+    None
+):
     assert (
         hf.ElementResources(
             scheduler_args={"options": {"--time": "02:00:00"}}
@@ -658,8 +653,9 @@ def test_element_resources_get_jobscript_hash_unequal_scheduler_args_diff_option
     )
 
 
-def test_element_resources_get_jobscript_hash_unequal_scheduler_args_same_options():
-
+def test_element_resources_get_jobscript_hash_unequal_scheduler_args_same_options() -> (
+    None
+):
     assert (
         hf.ElementResources(
             scheduler_args={"options": {"--time": "02:00:00"}}

hpcflow/tests/unit/test_element_iteration.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+from pathlib import Path
 import pytest
 from hpcflow.app import app as hf
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_decode(null_config, tmp_path, store):
+def test_decode(null_config, tmp_path: Path, store: str):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],

hpcflow/tests/unit/test_element_set.py

@@ -1,31 +1,41 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
 import pytest
 from hpcflow.app import app as hf
 from hpcflow.sdk.core.errors import MalformedNestingOrderPath
 
+if TYPE_CHECKING:
+    from pathlib import Path
+    from hpcflow.sdk.core.parameters import Parameter
+    from hpcflow.sdk.core.types import ResourceSpecArgs
+    from hpcflow.sdk.core.workflow import Workflow
+
 
 @pytest.fixture
-def null_config(tmp_path):
+def null_config(tmp_path: Path):
     if not hf.is_config_loaded:
         hf.load_config(config_dir=tmp_path)
 
 
 @pytest.fixture
-def param_p1():
+def param_p1() -> Parameter:
     return hf.Parameter("p1")
 
 
 @pytest.fixture
-def param_p2():
+def param_p2() -> Parameter:
     return hf.Parameter("p2")
 
 
 @pytest.fixture
-def param_p3():
+def param_p3() -> Parameter:
     return hf.Parameter("p3")
 
 
 @pytest.fixture
-def workflow_w1(null_config, tmp_path, param_p1, param_p2):
+def workflow_w1(
+    null_config, tmp_path: Path, param_p1: Parameter, param_p2: Parameter
+) -> Workflow:
     s1 = hf.TaskSchema("t1", actions=[], inputs=[param_p1], outputs=[param_p2])
     s2 = hf.TaskSchema("t2", actions=[], inputs=[param_p2])
 
@@ -40,45 +50,45 @@ def workflow_w1(null_config, tmp_path, param_p1, param_p2):
 
 
 @pytest.fixture
-def workflow_w2(workflow_w1):
+def workflow_w2(workflow_w1: Workflow) -> Workflow:
     """Add another element set to the second task."""
     workflow_w1.tasks.t2.add_elements(nesting_order={"inputs.p2": 1})
     return workflow_w1
 
 
-def test_resources_init_equivalence_dict_list_of_obj():
+def test_resources_init_equivalence_dict_list_of_obj() -> None:
     es1 = hf.ElementSet(resources={"any": {"num_cores": 1}})
     es2 = hf.ElementSet(resources=[hf.ResourceSpec(scope="any", num_cores=1)])
     assert es1 == es2
 
 
-def test_resources_init_equivalence_list_list_of_obj():
-    res_1_kwargs = {"scope": "any", "num_cores": 1}
+def test_resources_init_equivalence_list_list_of_obj() -> None:
+    res_1_kwargs: ResourceSpecArgs = {"scope": "any", "num_cores": 1}
     es1 = hf.ElementSet(resources=[res_1_kwargs])
     es2 = hf.ElementSet(resources=[hf.ResourceSpec(**res_1_kwargs)])
     assert es1 == es2
 
 
-def test_resources_init_equivalence_list_of_obj_resource_list_obj():
-    res_1_kwargs = {"scope": "any", "num_cores": 1}
+def test_resources_init_equivalence_list_of_obj_resource_list_obj() -> None:
+    res_1_kwargs: ResourceSpecArgs = {"scope": "any", "num_cores": 1}
     es1 = hf.ElementSet(resources=[hf.ResourceSpec(**res_1_kwargs)])
     es2 = hf.ElementSet(resources=hf.ResourceList([hf.ResourceSpec(**res_1_kwargs)]))
     assert es1 == es2
 
 
-def test_repeats_single_int_equivalence(null_config):
+def test_repeats_single_int_equivalence(null_config) -> None:
     es1 = hf.ElementSet(repeats=2)
     es2 = hf.ElementSet(repeats=[{"name": "", "number": 2, "nesting_order": 0}])
     assert es1 == es2
 
 
-def test_merge_envs(null_config):
+def test_merge_envs(null_config) -> None:
     envs = {"my_env": {"version": "1.0"}}
     es = hf.ElementSet(environments=envs)
     assert es.resources.get(scope=hf.ActionScope.any()).environments == envs
 
 
-def test_merge_envs_existing_any_resources(null_config):
+def test_merge_envs_existing_any_resources(null_config) -> None:
     envs = {"my_env": {"version": "1.0"}}
     num_cores = 2
     es = hf.ElementSet(resources={"any": {"num_cores": num_cores}}, environments=envs)
@@ -86,28 +96,28 @@ def test_merge_envs_existing_any_resources(null_config):
     assert es.resources.get(scope=hf.ActionScope.any()).num_cores == num_cores
 
 
-def test_merge_envs_resource_envs_precedence(null_config):
+def test_merge_envs_resource_envs_precedence(null_config) -> None:
     envs = {"my_env": {"version": "1.0"}}
     res_envs = {"other_env": {"version": "2.0"}}
     es = hf.ElementSet(resources={"any": {"environments": res_envs}}, environments=envs)
     assert es.resources.get(scope=hf.ActionScope.any()).environments == res_envs
 
 
-def test_merge_envs_no_envs_with_resource_envs(null_config):
+def test_merge_envs_no_envs_with_resource_envs(null_config) -> None:
     envs = {"my_env": {"version": "1.0"}}
     es = hf.ElementSet(resources={"any": {"environments": envs}})
     assert es.resources.get(scope=hf.ActionScope.any()).environments == envs
 
 
-def test_raise_env_and_envs_specified(null_config):
+def test_raise_env_and_envs_specified(null_config) -> None:
     with pytest.raises(ValueError):
         hf.ElementSet(env_preset="my_preset", environments={"my_env": {"version": 1}})
 
 
-def test_nesting_order_paths_raise(null_config):
+def test_nesting_order_paths_raise(null_config) -> None:
     with pytest.raises(MalformedNestingOrderPath):
         hf.ElementSet(nesting_order={"bad_path.p1": 1})
 
 
-def test_nesting_order_paths_no_raise(null_config):
+def test_nesting_order_paths_no_raise(null_config) -> None:
     hf.ElementSet(nesting_order={"inputs.p1": 1, "resources.any": 2, "repeats": 3})

hpcflow/tests/unit/test_group.py

@@ -1,9 +1,11 @@
+from __future__ import annotations
+from pathlib import Path
 import pytest
 from hpcflow.app import app as hf
 from hpcflow.sdk.core.errors import MissingElementGroup
 
 
-def test_group_simple(null_config, tmp_path):
+def test_group_simple(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -48,7 +50,7 @@ def test_group_simple(null_config, tmp_path):
     assert len(wk.tasks.t2.elements[0].get_data_idx("inputs.p2")["inputs.p2"]) == 3
 
 
-def test_group_raise_no_elements(null_config, tmp_path):
+def test_group_raise_no_elements(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],