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

hpcflow/tests/unit/test_loop.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
+from pathlib import Path
 import pytest
 
-from valida.conditions import Value
-
+from valida.conditions import Value  # type: ignore
 
 from hpcflow.app import app as hf
 from hpcflow.sdk.core.errors import LoopAlreadyExistsError, LoopTaskSubsetError
@@ -9,9 +10,9 @@ from hpcflow.sdk.core.test_utils import P1_parameter_cls, make_workflow
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_loop_tasks_obj_insert_ID_equivalence(tmp_path, store):
+def test_loop_tasks_obj_insert_ID_equivalence(tmp_path: Path, store: str):
     wk_1 = make_workflow(
-        schemas_spec=[[{"p1": None}, ("p1",), "t1"]],
+        schemas_spec=[({"p1": None}, ("p1",), "t1")],
         local_inputs={0: ("p1",)},
         path=tmp_path,
         store=store,
@@ -21,9 +22,9 @@ def test_loop_tasks_obj_insert_ID_equivalence(tmp_path, store):
     assert lp_0.task_insert_IDs == lp_1.task_insert_IDs
 
 
-def test_raise_on_add_loop_same_name(tmp_path):
+def test_raise_on_add_loop_same_name(tmp_path: Path):
     wk = make_workflow(
-        schemas_spec=[[{"p1": None}, ("p1",), "t1"], [{"p2": None}, ("p2",), "t2"]],
+        schemas_spec=[({"p1": None}, ("p1",), "t1"), ({"p2": None}, ("p2",), "t2")],
         local_inputs={0: ("p1",), 1: ("p2",)},
         path=tmp_path,
         store="json",
@@ -38,10 +39,10 @@ def test_raise_on_add_loop_same_name(tmp_path):
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
 def test_wk_loop_data_idx_single_task_single_element_single_parameter_three_iters(
-    tmp_path, store
+    tmp_path: Path, store: str
 ):
     wk = make_workflow(
-        schemas_spec=[[{"p1": None}, ("p1",), "t1"]],
+        schemas_spec=[({"p1": None}, ("p1",), "t1")],
         local_inputs={0: ("p1",)},
         path=tmp_path,
         store=store,
@@ -59,10 +60,10 @@ def test_wk_loop_data_idx_single_task_single_element_single_parameter_three_iter
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
 def test_wk_loop_EARs_initialised_single_task_single_element_single_parameter_three_iters(
-    tmp_path, store
+    tmp_path: Path, store: str
 ):
     wk = make_workflow(
-        schemas_spec=[[{"p1": None}, ("p1",), "t1"]],
+        schemas_spec=[({"p1": None}, ("p1",), "t1")],
         local_inputs={0: ("p1",)},
         path=tmp_path,
         store=store,
@@ -74,10 +75,10 @@ def test_wk_loop_EARs_initialised_single_task_single_element_single_parameter_th
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
 def test_wk_loop_data_idx_single_task_multi_element_single_parameter_three_iters(
-    tmp_path, store
+    tmp_path: Path, store: str
 ):
     wk = make_workflow(
-        schemas_spec=[[{"p1": None}, ("p1",), "t1"]],
+        schemas_spec=[({"p1": None}, ("p1",), "t1")],
         local_sequences={0: [("inputs.p1", 2, 0)]},
         path=tmp_path,
         store=store,
@@ -106,13 +107,13 @@ def test_wk_loop_data_idx_single_task_multi_element_single_parameter_three_iters
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
 def test_wk_loop_data_idx_multi_task_single_element_single_parameter_two_iters(
-    tmp_path, store
+    tmp_path: Path, store: str
 ):
     wk = make_workflow(
         schemas_spec=[
-            [{"p1": None}, ("p1",), "t1"],
-            [{"p1": None}, ("p1",), "t2"],
-            [{"p1": None}, ("p1",), "t3"],
+            ({"p1": None}, ("p1",), "t1"),
+            ({"p1": None}, ("p1",), "t2"),
+            ({"p1": None}, ("p1",), "t3"),
         ],
         local_inputs={0: ("p1",)},
         path=tmp_path,
@@ -149,10 +150,10 @@ def test_wk_loop_data_idx_multi_task_single_element_single_parameter_two_iters(
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
 def test_wk_loop_data_idx_single_task_single_element_single_parameter_three_iters_non_iterable_param(
-    tmp_path, store
+    tmp_path: Path, store: str
 ):
     wk = make_workflow(
-        schemas_spec=[[{"p1": None}, ("p1",), "t1"]],
+        schemas_spec=[({"p1": None}, ("p1",), "t1")],
         local_inputs={0: ("p1",)},
         path=tmp_path,
         store=store,
@@ -171,12 +172,12 @@ def test_wk_loop_data_idx_single_task_single_element_single_parameter_three_iter
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_wk_loop_iterable_parameters(tmp_path, store):
+def test_wk_loop_iterable_parameters(tmp_path: Path, store: str):
     wk = make_workflow(
         schemas_spec=[
-            [{"p1": None, "p2": None}, ("p1", "p2"), "t1"],
-            [{"p1": None}, ("p1",), "t2"],
-            [{"p1": None, "p2": None}, ("p1", "p2"), "t3"],
+            ({"p1": None, "p2": None}, ("p1", "p2"), "t1"),
+            ({"p1": None}, ("p1",), "t2"),
+            ({"p1": None, "p2": None}, ("p1", "p2"), "t3"),
         ],
         local_inputs={0: ("p1", "p2"), 1: ("p1",)},
         path=tmp_path,
@@ -190,12 +191,14 @@ def test_wk_loop_iterable_parameters(tmp_path, store):
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_wk_loop_input_sources_including_local_single_element_two_iters(tmp_path, store):
+def test_wk_loop_input_sources_including_local_single_element_two_iters(
+    tmp_path: Path, store: str
+):
     wk = make_workflow(
         schemas_spec=[
-            [{"p1": None, "p2": None}, ("p1", "p2"), "t1"],
-            [{"p1": None}, ("p1",), "t2"],
-            [{"p1": None, "p2": None}, ("p1", "p2"), "t3"],
+            ({"p1": None, "p2": None}, ("p1", "p2"), "t1"),
+            ({"p1": None}, ("p1",), "t2"),
+            ({"p1": None, "p2": None}, ("p1", "p2"), "t3"),
         ],
         local_inputs={0: ("p1", "p2"), 1: ("p1",)},
         path=tmp_path,
@@ -228,10 +231,10 @@ def test_wk_loop_input_sources_including_local_single_element_two_iters(tmp_path
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
 def test_get_iteration_task_pathway_single_task_single_element_three_iters(
-    tmp_path, store
+    tmp_path: Path, store: str
 ):
     wk = make_workflow(
-        schemas_spec=[[{"p1": None}, ("p1",), "t1"]],
+        schemas_spec=[({"p1": None}, ("p1",), "t1")],
         local_inputs={0: ("p1",)},
         path=tmp_path,
         store=store,
@@ -245,7 +248,7 @@ def test_get_iteration_task_pathway_single_task_single_element_three_iters(
     ]
 
 
-def test_get_iteration_task_pathway_nested_loops_multi_iter(null_config, tmp_path):
+def test_get_iteration_task_pathway_nested_loops_multi_iter(null_config, tmp_path: Path):
     ts1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -288,7 +291,9 @@ def test_get_iteration_task_pathway_nested_loops_multi_iter(null_config, tmp_pat
 @pytest.mark.skip(
     reason="second set of asserts fail; need to re-source inputs on adding iterations."
 )
-def test_get_iteration_task_pathway_nested_loops_multi_iter_jagged(null_config, tmp_path):
+def test_get_iteration_task_pathway_nested_loops_multi_iter_jagged(
+    null_config, tmp_path: Path
+):
     ts1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -347,7 +352,7 @@ def test_get_iteration_task_pathway_nested_loops_multi_iter_jagged(null_config,
 
 
 def test_get_iteration_task_pathway_nested_loops_multi_iter_add_outer_iter(
-    null_config, tmp_path
+    null_config, tmp_path: Path
 ):
     ts1 = hf.TaskSchema(
         objective="t1",
@@ -395,7 +400,7 @@ def test_get_iteration_task_pathway_nested_loops_multi_iter_add_outer_iter(
 @pytest.mark.skip(
     reason="second set of asserts fail; need to re-source inputs on adding iterations."
 )
-def test_get_iteration_task_pathway_unconnected_loops(null_config, tmp_path):
+def test_get_iteration_task_pathway_unconnected_loops(null_config, tmp_path: Path):
     ts1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -448,7 +453,9 @@ def test_get_iteration_task_pathway_unconnected_loops(null_config, tmp_path):
     assert pathway[4][2][0]["inputs.p1"] == pathway[3][2][0]["outputs.p1"]
 
 
-def test_wk_loop_input_sources_including_non_iteration_task_source(null_config, tmp_path):
+def test_wk_loop_input_sources_including_non_iteration_task_source(
+    null_config, tmp_path: Path
+):
     act_env = hf.ActionEnvironment("null_env")
     ts1 = hf.TaskSchema(
         objective="t1",
@@ -522,7 +529,7 @@ def test_wk_loop_input_sources_including_non_iteration_task_source(null_config,
     assert t2_iter_1["inputs.p3"] == t3_iter_0["outputs.p3"]
 
 
-def test_wk_loop_input_sources_default(null_config, tmp_path):
+def test_wk_loop_input_sources_default(null_config, tmp_path: Path):
     act_env = hf.ActionEnvironment("null_env")
     ts1 = hf.TaskSchema(
         objective="t1",
@@ -552,7 +559,7 @@ def test_wk_loop_input_sources_default(null_config, tmp_path):
     assert t1_iter_0["inputs.p2"] == t1_iter_1["inputs.p2"]
 
 
-def test_wk_loop_input_sources_iterable_param_default(null_config, tmp_path):
+def test_wk_loop_input_sources_iterable_param_default(null_config, tmp_path: Path):
     act_env = hf.ActionEnvironment("null_env")
     ts1 = hf.TaskSchema(
         objective="t1",
@@ -589,7 +596,7 @@ def test_wk_loop_input_sources_iterable_param_default(null_config, tmp_path):
 
 
 def test_wk_loop_input_sources_iterable_param_default_conditional_action(
-    null_config, tmp_path
+    null_config, tmp_path: Path
 ):
     act_env = hf.ActionEnvironment("null_env")
     ts1 = hf.TaskSchema(
@@ -637,7 +644,7 @@ def test_wk_loop_input_sources_iterable_param_default_conditional_action(
 
 
 def test_wk_loop_input_sources_including_non_iteration_task_source_with_groups(
-    null_config, tmp_path
+    null_config, tmp_path: Path
 ):
     act_env = hf.ActionEnvironment("null_env")
     ts1 = hf.TaskSchema(
@@ -733,7 +740,7 @@ def test_wk_loop_input_sources_including_non_iteration_task_source_with_groups(
     ]
 
 
-def test_loop_local_sub_parameters(null_config, tmp_path):
+def test_loop_local_sub_parameters(null_config, tmp_path: Path):
     act_env = hf.ActionEnvironment("null_env")
     ts1 = hf.TaskSchema(
         objective="t1",
@@ -796,7 +803,7 @@ def test_loop_local_sub_parameters(null_config, tmp_path):
     assert t1_iter_0["inputs.p1c.d"] == t1_iter_1["inputs.p1c.d"]
 
 
-def test_nested_loop_iter_loop_idx(null_config, tmp_path):
+def test_nested_loop_iter_loop_idx(null_config, tmp_path: Path):
     ts1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -828,7 +835,7 @@ def test_nested_loop_iter_loop_idx(null_config, tmp_path):
     }
 
 
-def test_schema_input_with_group_sourced_from_prev_iteration(null_config, tmp_path):
+def test_schema_input_with_group_sourced_from_prev_iteration(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -907,7 +914,7 @@ def test_schema_input_with_group_sourced_from_prev_iteration(null_config, tmp_pa
     ] == [wk.tasks.t2.elements[0].iterations[1].get_data_idx()["outputs.p3"]] * 3
 
 
-def test_loop_downstream_tasks(null_config, tmp_path):
+def test_loop_downstream_tasks(null_config, tmp_path: Path):
     ts1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -951,11 +958,11 @@ def test_loop_downstream_tasks(null_config, tmp_path):
             hf.Loop(name="my_loop", tasks=[1, 2], num_iterations=2),
         ],
     )
-    assert wk.loops.my_loop.downstream_tasks == [wk.tasks[3]]
-    assert wk.loops.my_loop.upstream_tasks == [wk.tasks[0]]
+    assert list(wk.loops.my_loop.downstream_tasks) == [wk.tasks[3]]
+    assert list(wk.loops.my_loop.upstream_tasks) == [wk.tasks[0]]
 
 
-def test_raise_loop_task_subset_error(null_config, tmp_path):
+def test_raise_loop_task_subset_error(null_config, tmp_path: Path):
     ts1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -986,7 +993,7 @@ def test_raise_loop_task_subset_error(null_config, tmp_path):
         )
 
 
-def test_raise_downstream_task_with_iterable_parameter(null_config, tmp_path):
+def test_raise_downstream_task_with_iterable_parameter(null_config, tmp_path: Path):
     ts1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -1017,7 +1024,7 @@ def test_raise_downstream_task_with_iterable_parameter(null_config, tmp_path):
         )
 
 
-def test_adjacent_loops_iteration_pathway(null_config, tmp_path):
+def test_adjacent_loops_iteration_pathway(null_config, tmp_path: Path):
     ts1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -1071,7 +1078,7 @@ def test_adjacent_loops_iteration_pathway(null_config, tmp_path):
     ]
 
 
-def test_get_child_loops_ordered_by_depth(null_config, tmp_path):
+def test_get_child_loops_ordered_by_depth(null_config, tmp_path: Path):
     ts1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -1104,7 +1111,7 @@ def test_get_child_loops_ordered_by_depth(null_config, tmp_path):
     assert wk.loops.outer.get_child_loops() == [wk.loops.middle, wk.loops.inner]
 
 
-def test_multi_nested_loops(null_config, tmp_path):
+def test_multi_nested_loops(null_config, tmp_path: Path):
     ts1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput("p1")],
@@ -1161,14 +1168,14 @@ def test_multi_nested_loops(null_config, tmp_path):
     ]
 
 
-def test_nested_loop_input_from_parent_loop_task(null_config, tmp_path):
+def test_nested_loop_input_from_parent_loop_task(null_config, tmp_path: Path):
     """Test that an input in a nested-loop task is correctly sourced from latest
     iteration of the parent loop."""
     wk = make_workflow(
         schemas_spec=[
-            [{"p1": None}, ("p2", "p3")],
-            [{"p2": None}, ("p4",)],
-            [{"p4": None, "p3": None}, ("p2", "p1")],  # testing p3 source
+            ({"p1": None}, ("p2", "p3")),
+            ({"p2": None}, ("p4",)),
+            ({"p4": None, "p3": None}, ("p2", "p1")),  # testing p3 source
         ],
         path=tmp_path,
         local_inputs={0: {"p1": 101}},
@@ -1186,16 +1193,16 @@ def test_nested_loop_input_from_parent_loop_task(null_config, tmp_path):
     assert p3_inp_idx == [p3_out_idx[0]] * 3 + [p3_out_idx[1]] * 3
 
 
-def test_doubly_nested_loop_input_from_parent_loop_task(null_config, tmp_path):
+def test_doubly_nested_loop_input_from_parent_loop_task(null_config, tmp_path: Path):
     """Test that an input in a doubly-nested-loop task is correctly sourced from latest
     iteration of the parent loop."""
     # test source of p6 in final task:
     wk = make_workflow(
         schemas_spec=[
-            [{"p5": None}, ("p6", "p1")],
-            [{"p1": None}, ("p2", "p3")],
-            [{"p2": None}, ("p4",)],
-            [{"p4": None, "p3": None, "p6": None}, ("p2", "p1", "p5")],
+            ({"p5": None}, ("p6", "p1")),
+            ({"p1": None}, ("p2", "p3")),
+            ({"p2": None}, ("p4",)),
+            ({"p4": None, "p3": None, "p6": None}, ("p2", "p1", "p5")),
         ],
         path=tmp_path,
         local_inputs={0: {"p5": 101}},
@@ -1216,7 +1223,7 @@ def test_doubly_nested_loop_input_from_parent_loop_task(null_config, tmp_path):
     assert p6_inp_idx == [p6_out_idx[0]] * 9 + [p6_out_idx[1]] * 9 + [p6_out_idx[2]] * 9
 
 
-def test_loop_non_input_task_input_from_element_group(null_config, tmp_path):
+def test_loop_non_input_task_input_from_element_group(null_config, tmp_path: Path):
     """Test correct sourcing of an element group input within a loop, for a task that is
     not that loop's "input task" with respect to that parameter."""
     s1 = hf.TaskSchema(

hpcflow/tests/unit/test_object_list.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
 from dataclasses import dataclass
-
+from typing_extensions import TypedDict
 import pytest
 
 from hpcflow.app import app as hf
@@ -18,43 +19,47 @@ class MyObj:
     data: int
 
 
+class SimpleObjectList(TypedDict):
+    objects: list[MyObj]
+    object_list: DotAccessObjectList
+
+
 @pytest.fixture
-def simple_object_list(null_config):
+def simple_object_list(null_config) -> SimpleObjectList:
     my_objs = [MyObj(name="A", data=1), MyObj(name="B", data=2)]
     obj_list = DotAccessObjectList(my_objs, access_attribute="name")
-    out = {"objects": my_objs, "object_list": obj_list}
-    return out
+    return {"objects": my_objs, "object_list": obj_list}
 
 
-def test_get_item(simple_object_list):
+def test_get_item(simple_object_list: SimpleObjectList):
     objects = simple_object_list["objects"]
     obj_list = simple_object_list["object_list"]
 
     assert obj_list[0] == objects[0] and obj_list[1] == objects[1]
 
 
-def test_get_dot_notation(simple_object_list):
+def test_get_dot_notation(simple_object_list: SimpleObjectList):
     objects = simple_object_list["objects"]
     obj_list = simple_object_list["object_list"]
 
     assert obj_list.A == objects[0] and obj_list.B == objects[1]
 
 
-def test_add_obj_to_end(simple_object_list):
+def test_add_obj_to_end(simple_object_list: SimpleObjectList):
     obj_list = simple_object_list["object_list"]
     new_obj = MyObj("C", 3)
     obj_list.add_object(new_obj)
     assert obj_list[-1] == new_obj
 
 
-def test_add_obj_to_start(simple_object_list):
+def test_add_obj_to_start(simple_object_list: SimpleObjectList):
     obj_list = simple_object_list["object_list"]
     new_obj = MyObj("C", 3)
     obj_list.add_object(new_obj, 0)
     assert obj_list[0] == new_obj
 
 
-def test_add_obj_to_middle(simple_object_list):
+def test_add_obj_to_middle(simple_object_list: SimpleObjectList):
     obj_list = simple_object_list["object_list"]
     new_obj = MyObj("C", 3)
     obj_list.add_object(new_obj, 1)
@@ -80,12 +85,12 @@ def test_get_obj_attr_custom_callable(null_config):
     assert o1.get(c1=2) == o1[0]
 
 
-def test_get_with_missing_key(null_config):
+def test_get_with_missing_key(null_config) -> None:
     o1 = ObjectList([{"a": 1}, {"b": 2}])
     assert o1.get(a=1) == {"a": 1}
 
 
-def test_parameters_list_get_equivalence(null_config):
+def test_parameters_list_get_equivalence(null_config) -> None:
     p_name = "p12334567898765432101"
     hf.parameters.add_object(hf.Parameter(p_name))
     assert p_name in hf.parameters.list_attrs()
@@ -97,7 +102,7 @@ def test_parameters_list_get_equivalence(null_config):
     )
 
 
-def test_parameters_list_get_equivalence_non_existent(new_null_config):
+def test_parameters_list_get_equivalence_non_existent(new_null_config) -> None:
     # non-existent parameters should be created, unlike other ObjectList sub-classes,
     # which raise
     hf.reload_template_components()

hpcflow/tests/unit/test_parameter.py

@@ -1,19 +1,24 @@
+from __future__ import annotations
 from dataclasses import dataclass
+from pathlib import Path
 import random
 import string
 import sys
 from textwrap import dedent
+from typing import ClassVar
 
 import pytest
 import requests
 
 from hpcflow.app import app as hf
+from hpcflow.sdk.typing import hydrate
 from hpcflow.sdk.core.parameters import ParameterValue
 
 
 @dataclass
+@hydrate
 class MyParameterP1(ParameterValue):
-    _typ = "p1_test"
+    _typ: ClassVar[str] = "p1_test"
     a: int
 
     def CLI_format(self):
@@ -22,7 +27,9 @@ class MyParameterP1(ParameterValue):
 
 @pytest.mark.integration
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_submission_with_specified_parameter_class_module(null_config, tmp_path, store):
+def test_submission_with_specified_parameter_class_module(
+    null_config, tmp_path: Path, store: str
+):
     """Test we can use a ParameterValue subclass that is defined separately from the main
     code (i.e. not automatically imported on app init)."""
 
@@ -84,7 +91,7 @@ def test_submission_with_specified_parameter_class_module(null_config, tmp_path,
 
 
 @pytest.mark.parametrize("store", ["json", "zarr"])
-def test_unseen_parameter(null_config, tmp_path, store):
+def test_unseen_parameter(null_config, tmp_path: Path, store: str):
     """Test we can generate a workflow that uses an unseen parameter type."""
 
     random_str = "".join(random.choice(string.ascii_letters) for _ in range(10))
@@ -116,7 +123,7 @@ def test_unseen_parameter(null_config, tmp_path, store):
     assert wk.tasks[0].elements[0].get(f"inputs.{p_type}") == 5
 
 
-def test_iter(new_null_config, tmp_path):
+def test_iter(new_null_config, tmp_path: Path):
     values = [1, 2, 3]
     wkt = hf.WorkflowTemplate(
         name="test",
@@ -132,7 +139,7 @@ def test_iter(new_null_config, tmp_path):
         assert param_p1_i.value == values[idx]
 
 
-def test_slice(new_null_config, tmp_path):
+def test_slice(new_null_config, tmp_path: Path):
     values = [1, 2, 3]
     wkt = hf.WorkflowTemplate(
         name="test",
@@ -158,7 +165,7 @@ def test_slice(new_null_config, tmp_path):
         "retrieving demo data from GitHub."
     ),
 )
-def test_demo_data_substitution_param_value_class_method(new_null_config, tmp_path):
+def test_demo_data_substitution_param_value_class_method(new_null_config, tmp_path: Path):
     yaml_str = dedent(
         """\
         name: temp
@@ -189,7 +196,9 @@ def test_demo_data_substitution_param_value_class_method(new_null_config, tmp_pa
         "retrieving demo data from GitHub."
     ),
 )
-def test_demo_data_substitution_value_sequence_class_method(new_null_config, tmp_path):
+def test_demo_data_substitution_value_sequence_class_method(
+    new_null_config, tmp_path: Path
+):
     yaml_str = dedent(
         """\
         name: temp