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

hpcflow/tests/unit/test_command.py

@@ -1,4 +1,5 @@
-import re
+from __future__ import annotations
+from pathlib import Path
 import numpy as np
 import pytest
 from hpcflow.app import app as hf
@@ -9,7 +10,7 @@ from hpcflow.sdk.core.test_utils import (
 )
 
 
-def test_get_command_line(null_config, tmp_path):
+def test_get_command_line(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
@@ -40,7 +41,9 @@ def test_get_command_line(null_config, tmp_path):
 
 
 @pytest.mark.parametrize("shell_args", [("powershell", "nt"), ("bash", "posix")])
-def test_get_command_line_with_stdout(null_config, tmp_path, shell_args):
+def test_get_command_line_with_stdout(
+    null_config, tmp_path: Path, shell_args: tuple[str, str]
+):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
@@ -76,7 +79,7 @@ def test_get_command_line_with_stdout(null_config, tmp_path, shell_args):
         assert cmd_str == f"parameter_p2=`Write-Output ({p1_value} + 100)`"
 
 
-def test_get_command_line_single_labelled_input(null_config, tmp_path):
+def test_get_command_line_single_labelled_input(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"), labels={"one": {}})],
@@ -108,7 +111,7 @@ def test_get_command_line_single_labelled_input(null_config, tmp_path):
     assert cmd_str == f"Write-Output ({p1_value} + 100)"
 
 
-def test_get_command_line_multiple_labelled_input(null_config, tmp_path):
+def test_get_command_line_multiple_labelled_input(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[
@@ -151,7 +154,7 @@ def test_get_command_line_multiple_labelled_input(null_config, tmp_path):
     assert cmd_str == f"Write-Output ({p1_one_value} + {p1_two_value} + 100)"
 
 
-def test_get_command_line_sub_parameter(null_config, tmp_path):
+def test_get_command_line_sub_parameter(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
@@ -181,7 +184,7 @@ def test_get_command_line_sub_parameter(null_config, tmp_path):
     assert cmd_str == f"Write-Output ({p1_value['a']} + 100)"
 
 
-def test_get_command_line_sum(null_config, tmp_path):
+def test_get_command_line_sum(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
@@ -208,7 +211,7 @@ def test_get_command_line_sum(null_config, tmp_path):
     assert cmd_str == f"Write-Output ({sum(p1_value)} + 100)"
 
 
-def test_get_command_line_join(null_config, tmp_path):
+def test_get_command_line_join(null_config, tmp_path: Path):
     delim = ","
     s1 = hf.TaskSchema(
         objective="t1",
@@ -238,7 +241,7 @@ def test_get_command_line_join(null_config, tmp_path):
     assert cmd_str == f"Write-Output ({delim.join(str(i) for i in p1_value)} + 100)"
 
 
-def test_get_command_line_sum_sub_data(null_config, tmp_path):
+def test_get_command_line_sum_sub_data(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
@@ -295,7 +298,7 @@ def test_get_command_line_join_sub_data(null_config, tmp_path):
     assert cmd_str == f"Write-Output ({delim.join(str(i) for i in p1_value['a'])} + 100)"
 
 
-def test_get_command_line_parameter_value(null_config, tmp_path):
+def test_get_command_line_parameter_value(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1c"))],
@@ -325,7 +328,7 @@ def test_get_command_line_parameter_value(null_config, tmp_path):
     assert cmd_str == f"Write-Output ({p1_value.a} + 100)"
 
 
-def test_get_command_line_parameter_value_join(null_config, tmp_path):
+def test_get_command_line_parameter_value_join(null_config, tmp_path: Path):
     delim = ","
     cmd = (
         f"Write-Output "
@@ -349,14 +352,16 @@ def test_get_command_line_parameter_value_join(null_config, tmp_path):
         path=tmp_path,
         template_name="wk0",
     )
-    run = wk.tasks.t1.elements[0].iterations[0].action_runs[0]
-    cmd = run.action.commands[0]
+    t1 = wk.tasks.t1
+    assert isinstance(t1, hf.WorkflowTask)
+    run = t1.elements[0].iterations[0].action_runs[0]
+    command = run.action.commands[0]
     shell = ALL_SHELLS["powershell"]["nt"]()
-    cmd_str, _ = cmd.get_command_line(EAR=run, shell=shell, env=run.get_environment())
+    cmd_str, _ = command.get_command_line(EAR=run, shell=shell, env=run.get_environment())
     assert cmd_str == f"Write-Output 4,4,4,4"
 
 
-def test_get_command_line_parameter_value_custom_method(null_config, tmp_path):
+def test_get_command_line_parameter_value_custom_method(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1c"))],
@@ -386,7 +391,9 @@ def test_get_command_line_parameter_value_custom_method(null_config, tmp_path):
     assert cmd_str == f"Write-Output ({p1_value.a + 4} + 100)"
 
 
-def test_get_command_line_parameter_value_custom_method_with_args(null_config, tmp_path):
+def test_get_command_line_parameter_value_custom_method_with_args(
+    null_config, tmp_path: Path
+):
     add_val = 35
     s1 = hf.TaskSchema(
         objective="t1",
@@ -409,7 +416,9 @@ def test_get_command_line_parameter_value_custom_method_with_args(null_config, t
         template_name="wk0",
         overwrite=True,
     )
-    run = wk.tasks.t1.elements[0].iterations[0].action_runs[0]
+    t1 = wk.tasks.t1
+    assert isinstance(t1, hf.WorkflowTask)
+    run = t1.elements[0].iterations[0].action_runs[0]
     cmd = run.action.commands[0]
     shell = ALL_SHELLS["powershell"]["nt"]()
     cmd_str, _ = cmd.get_command_line(EAR=run, shell=shell, env=run.get_environment())
@@ -418,7 +427,7 @@ def test_get_command_line_parameter_value_custom_method_with_args(null_config, t
 
 
 def test_get_command_line_parameter_value_custom_method_with_two_args(
-    null_config, tmp_path
+    null_config, tmp_path: Path
 ):
     add_val = 35
     sub_val = 10
@@ -439,15 +448,17 @@ def test_get_command_line_parameter_value_custom_method_with_two_args(
         template_name="wk0",
         overwrite=True,
     )
-    run = wk.tasks.t1.elements[0].iterations[0].action_runs[0]
-    cmd = run.action.commands[0]
+    t1 = wk.tasks.t1
+    assert isinstance(t1, hf.WorkflowTask)
+    run = t1.elements[0].iterations[0].action_runs[0]
+    command = run.action.commands[0]
     shell = ALL_SHELLS["powershell"]["nt"]()
-    cmd_str, _ = cmd.get_command_line(EAR=run, shell=shell, env=run.get_environment())
+    cmd_str, _ = command.get_command_line(EAR=run, shell=shell, env=run.get_environment())
 
     assert cmd_str == f"Write-Output ({p1_value.a + add_val - sub_val} + 100)"
 
 
-def test_get_command_line_parameter_value_sub_object(null_config, tmp_path):
+def test_get_command_line_parameter_value_sub_object(null_config, tmp_path: Path):
     cmd = f"Write-Output (<<parameter:p1c.sub_param>> + 100)"
     s1 = hf.TaskSchema(
         objective="t1",
@@ -462,15 +473,18 @@ def test_get_command_line_parameter_value_sub_object(null_config, tmp_path):
         template_name="wk0",
         overwrite=True,
     )
-    run = wk.tasks.t1.elements[0].iterations[0].action_runs[0]
-    cmd = run.action.commands[0]
+    t1 = wk.tasks.t1
+    assert isinstance(t1, hf.WorkflowTask)
+    run = t1.elements[0].iterations[0].action_runs[0]
+    command = run.action.commands[0]
     shell = ALL_SHELLS["powershell"]["nt"]()
-    cmd_str, _ = cmd.get_command_line(EAR=run, shell=shell, env=run.get_environment())
+    cmd_str, _ = command.get_command_line(EAR=run, shell=shell, env=run.get_environment())
 
+    assert p1_value.sub_param is not None
     assert cmd_str == f"Write-Output ({p1_value.sub_param.e} + 100)"
 
 
-def test_get_command_line_parameter_value_sub_object_attr(null_config, tmp_path):
+def test_get_command_line_parameter_value_sub_object_attr(null_config, tmp_path: Path):
     cmd = f"Write-Output (" f"<<parameter:p1c.sub_param.e>> + 100)"
     s1 = hf.TaskSchema(
         objective="t1",
@@ -485,49 +499,52 @@ def test_get_command_line_parameter_value_sub_object_attr(null_config, tmp_path)
         template_name="wk0",
         overwrite=True,
     )
-    run = wk.tasks.t1.elements[0].iterations[0].action_runs[0]
-    cmd = run.action.commands[0]
+    t1 = wk.tasks.t1
+    assert isinstance(t1, hf.WorkflowTask)
+    run = t1.elements[0].iterations[0].action_runs[0]
+    command = run.action.commands[0]
     shell = ALL_SHELLS["powershell"]["nt"]()
-    cmd_str, _ = cmd.get_command_line(EAR=run, shell=shell, env=run.get_environment())
+    cmd_str, _ = command.get_command_line(EAR=run, shell=shell, env=run.get_environment())
 
+    assert p1_value.sub_param is not None
     assert cmd_str == f"Write-Output ({p1_value.sub_param.e} + 100)"
 
 
-def test_process_std_stream_int(null_config):
+def test_process_std_stream_int(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<int(parameter:p2)>>")
     assert cmd.process_std_stream(name="p2", value="101", stderr=False) == 101
 
 
-def test_process_std_stream_stderr_int(null_config):
+def test_process_std_stream_stderr_int(null_config) -> None:
     cmd = hf.Command(command="", stderr="<<int(parameter:p2)>>")
     assert cmd.process_std_stream(name="p2", value="101", stderr=True) == 101
 
 
-def test_process_std_stream_float(null_config):
+def test_process_std_stream_float(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<float(parameter:p2)>>")
     assert cmd.process_std_stream(name="p2", value="3.1415", stderr=False) == 3.1415
 
 
-def test_process_std_stream_bool_true(null_config):
+def test_process_std_stream_bool_true(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<bool(parameter:p2)>>")
     for value in ("true", "True", "1"):
         assert cmd.process_std_stream(name="p2", value=value, stderr=False) == True
 
 
-def test_process_std_stream_bool_false(null_config):
+def test_process_std_stream_bool_false(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<bool(parameter:p2)>>")
     for value in ("false", "False", "0"):
         assert cmd.process_std_stream(name="p2", value=value, stderr=False) == False
 
 
-def test_process_std_stream_bool_raise(null_config):
+def test_process_std_stream_bool_raise(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<bool(parameter:p2)>>")
     for value in ("hi", "120", "-1"):
         with pytest.raises(ValueError):
             cmd.process_std_stream(name="p2", value=value, stderr=False)
 
 
-def test_process_std_stream_list(null_config):
+def test_process_std_stream_list(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<list(parameter:p2)>>")
     assert cmd.process_std_stream(name="p2", value="1 2 3", stderr=False) == [
         "1",
@@ -536,12 +553,12 @@ def test_process_std_stream_list(null_config):
     ]
 
 
-def test_process_std_stream_list_int(null_config):
+def test_process_std_stream_list_int(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<list[item_type=int](parameter:p2)>>")
     assert cmd.process_std_stream(name="p2", value="1 2 3", stderr=False) == [1, 2, 3]
 
 
-def test_process_std_stream_list_delim(null_config):
+def test_process_std_stream_list_delim(null_config) -> None:
     cmd = hf.Command(command="", stdout='<<list[delim=","](parameter:p2)>>')
     assert cmd.process_std_stream(name="p2", value="1,2,3", stderr=False) == [
         "1",
@@ -550,14 +567,14 @@ def test_process_std_stream_list_delim(null_config):
     ]
 
 
-def test_process_std_stream_list_int_delim(null_config):
+def test_process_std_stream_list_int_delim(null_config) -> None:
     cmd = hf.Command(
         command="", stdout='<<list[item_type=int, delim=","](parameter:p2)>>'
     )
     assert cmd.process_std_stream(name="p2", value="1,2,3", stderr=False) == [1, 2, 3]
 
 
-def test_process_std_stream_list_float_delim_colon(null_config):
+def test_process_std_stream_list_float_delim_colon(null_config) -> None:
     cmd = hf.Command(
         command="", stdout='<<list[item_type=float, delim=":"](parameter:p2)>>'
     )
@@ -568,7 +585,7 @@ def test_process_std_stream_list_float_delim_colon(null_config):
     ]
 
 
-def test_process_std_stream_array(null_config):
+def test_process_std_stream_array(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<array(parameter:p2)>>")
     assert np.allclose(
         cmd.process_std_stream(name="p2", value="1 2 3", stderr=False),
@@ -576,7 +593,7 @@ def test_process_std_stream_array(null_config):
     )
 
 
-def test_process_std_stream_array_delim(null_config):
+def test_process_std_stream_array_delim(null_config) -> None:
     cmd = hf.Command(command="", stdout='<<array[delim=","](parameter:p2)>>')
     assert np.allclose(
         cmd.process_std_stream(name="p2", value="1,2,3", stderr=False),
@@ -584,19 +601,19 @@ def test_process_std_stream_array_delim(null_config):
     )
 
 
-def test_process_std_stream_array_dtype_int(null_config):
+def test_process_std_stream_array_dtype_int(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<array[item_type=int](parameter:p2)>>")
     arr = cmd.process_std_stream(name="p2", value="1 2 3", stderr=False)
     assert arr.dtype == np.dtype("int")
 
 
-def test_process_std_stream_array_dtype_float(null_config):
+def test_process_std_stream_array_dtype_float(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<array[item_type=float](parameter:p2)>>")
     arr = cmd.process_std_stream(name="p2", value="1 2 3", stderr=False)
     assert arr.dtype == np.dtype("float")
 
 
-def test_process_std_stream_object(null_config):
+def test_process_std_stream_object(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<parameter:p1c>>")
     a_val = 12
     assert cmd.process_std_stream(name="p1c", value=str(a_val), stderr=False) == P1(
@@ -604,7 +621,7 @@ def test_process_std_stream_object(null_config):
     )
 
 
-def test_process_std_stream_object_kwargs(null_config):
+def test_process_std_stream_object_kwargs(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<parameter:p1c.CLI_parse(double=true)>>")
     a_val = 12
     expected = 2 * a_val
@@ -613,48 +630,48 @@ def test_process_std_stream_object_kwargs(null_config):
     )
 
 
-def test_get_output_types(null_config):
+def test_get_output_types(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<parameter:p1_test_123>>")
     assert cmd.get_output_types() == {"stdout": "p1_test_123", "stderr": None}
 
 
-def test_get_output_types_int(null_config):
+def test_get_output_types_int(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<int(parameter:p1_test_123)>>")
     assert cmd.get_output_types() == {"stdout": "p1_test_123", "stderr": None}
 
 
-def test_get_output_types_object_with_args(null_config):
+def test_get_output_types_object_with_args(null_config) -> None:
     cmd = hf.Command(
         command="", stdout="<<parameter:p1_test_123.CLI_parse(double=true)>>"
     )
     assert cmd.get_output_types() == {"stdout": "p1_test_123", "stderr": None}
 
 
-def test_get_output_types_list(null_config):
+def test_get_output_types_list(null_config) -> None:
     cmd = hf.Command(
         command="", stdout="<<list[item_type=int, delim=" "](parameter:p1_test_123)>>"
     )
     assert cmd.get_output_types() == {"stdout": "p1_test_123", "stderr": None}
 
 
-def test_get_output_types_no_match(null_config):
+def test_get_output_types_no_match(null_config) -> None:
     cmd = hf.Command(command="", stdout="parameter:p1_test_123")
     assert cmd.get_output_types() == {"stdout": None, "stderr": None}
 
 
-def test_get_output_types_raise_with_extra_substring_start(null_config):
+def test_get_output_types_raise_with_extra_substring_start(null_config) -> None:
     cmd = hf.Command(command="", stdout="hello: <<parameter:p1_test_123>>")
     with pytest.raises(ValueError):
         cmd.get_output_types()
 
 
-def test_get_output_types_raise_with_extra_substring_end(null_config):
+def test_get_output_types_raise_with_extra_substring_end(null_config) -> None:
     cmd = hf.Command(command="", stdout="<<parameter:p1_test_123>> hello")
     with pytest.raises(ValueError):
         cmd.get_output_types()
 
 
-def test_extract_executable_labels(null_config):
+def test_extract_executable_labels(null_config) -> None:
     tests = {
         "<<executable:m1>> and <<executable:12>>": ["m1", "12"],
         "<<executable:m1>> hi": ["m1"],

hpcflow/tests/unit/test_config.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import pytest
 
@@ -5,55 +6,59 @@ from hpcflow.app import app as hf
 from hpcflow.sdk.config.errors import ConfigFileValidationError, ConfigItemCallbackError
 
 
-def test_reset_config(new_null_config):
-    cfg_dir = hf.config.get("config_directory")
-    machine_name = hf.config.get("machine")
+def test_reset_config(new_null_config) -> None:
+    cfg_dir = hf.config.config_directory
+    machine_name = hf.config.machine
     new_machine_name = machine_name + "123"
-    hf.config._set("machine", new_machine_name)
-    assert hf.config.get("machine") == new_machine_name
+    hf.config.machine = new_machine_name
+    assert hf.config.machine == new_machine_name
     hf.reset_config(config_dir=cfg_dir)
-    assert hf.config.get("machine") == machine_name
+    assert hf.config.machine == machine_name
 
 
-def test_raise_on_invalid_config_file(new_null_config):
+def test_raise_on_invalid_config_file(new_null_config) -> None:
     # make an invalid config file:
-    cfg_path = hf.config.get("config_file_path")
+    cfg_path = hf.config.config_file_path
     with cfg_path.open("at+") as f:
         f.write("something_invalid: 1\n")
 
     # try to load the invalid file:
-    cfg_dir = hf.config.get("config_directory")
+    cfg_dir = hf.config.config_directory
     with pytest.raises(ConfigFileValidationError):
         hf.reload_config(config_dir=cfg_dir, warn=False)
     hf.reset_config(config_dir=cfg_dir, warn=False)
     hf.unload_config()
 
 
-def test_reset_invalid_config(new_null_config):
+def test_reset_invalid_config(new_null_config) -> None:
     # make an invalid config file:
-    cfg_path = hf.config.get("config_file_path")
+    cfg_path = hf.config.config_file_path
     with cfg_path.open("at+") as f:
         f.write("something_invalid: 1\n")
 
     # check we can reset the invalid file:
-    cfg_dir = hf.config.get("config_directory")
+    cfg_dir = hf.config.config_directory
     hf.reset_config(config_dir=cfg_dir, warn=False)
     hf.unload_config()
 
 
-def test_raise_on_set_default_scheduler_not_in_schedulers_list_invalid_name(null_config):
+def test_raise_on_set_default_scheduler_not_in_schedulers_list_invalid_name(
+    null_config,
+) -> None:
     new_default = "invalid-scheduler"
     with pytest.raises(ConfigItemCallbackError):
         hf.config.default_scheduler = new_default
 
 
-def test_raise_on_set_default_scheduler_not_in_schedulers_list_valid_name(null_config):
+def test_raise_on_set_default_scheduler_not_in_schedulers_list_valid_name(
+    null_config,
+) -> None:
     new_default = "slurm"  # valid but unsupported (by default) scheduler
     with pytest.raises(ConfigItemCallbackError):
         hf.config.default_scheduler = new_default
 
 
-def test_without_callbacks_ctx_manager(null_config):
+def test_without_callbacks_ctx_manager(null_config) -> None:
     # set a new shell that would raise an error in the `callback_supported_shells`:
     new_default = "bash" if os.name == "nt" else "powershell"
 

hpcflow/tests/unit/test_config_file.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+from typing import Any
 import pytest
 from hpcflow.sdk.config.config_file import ConfigFile
 from hpcflow.sdk.config.errors import ConfigFileInvocationIncompatibleError
 
 
-def test_select_invocation_default_no_specified_matches():
-    configs = {
+def test_select_invocation_default_no_specified_matches() -> None:
+    configs: dict[str, Any] = {
         "default": {
             "invocation": {
                 "environment_setup": None,
@@ -12,17 +14,16 @@ def test_select_invocation_default_no_specified_matches():
             }
         }
     }
-    run_time_info = {}
     matched = ConfigFile.select_invocation(
         configs=configs,
-        run_time_info=run_time_info,
+        run_time_info={},
         path="/path/to/config.yaml",
     )
     assert matched == "default"
 
 
-def test_select_invocation_default_no_specified_matches_with_run_time_info():
-    configs = {
+def test_select_invocation_default_no_specified_matches_with_run_time_info() -> None:
+    configs: dict[str, Any] = {
         "default": {
             "invocation": {
                 "environment_setup": None,
@@ -39,8 +40,8 @@ def test_select_invocation_default_no_specified_matches_with_run_time_info():
     assert matched == "default"
 
 
-def test_select_invocation_single_specified_match():
-    configs = {
+def test_select_invocation_single_specified_match() -> None:
+    configs: dict[str, Any] = {
         "default": {
             "invocation": {
                 "environment_setup": None,
@@ -57,8 +58,8 @@ def test_select_invocation_single_specified_match():
     assert matched == "default"
 
 
-def test_select_invocation_single_specified_match_list_match_first():
-    configs = {
+def test_select_invocation_single_specified_match_list_match_first() -> None:
+    configs: dict[str, Any] = {
         "default": {
             "invocation": {
                 "environment_setup": None,
@@ -75,8 +76,8 @@ def test_select_invocation_single_specified_match_list_match_first():
     assert matched == "default"
 
 
-def test_select_invocation_single_specified_match_list_match_second():
-    configs = {
+def test_select_invocation_single_specified_match_list_match_second() -> None:
+    configs: dict[str, Any] = {
         "default": {
             "invocation": {
                 "environment_setup": None,
@@ -93,8 +94,8 @@ def test_select_invocation_single_specified_match_list_match_second():
     assert matched == "default"
 
 
-def test_select_invocation_raise_on_no_match():
-    configs = {
+def test_select_invocation_raise_on_no_match() -> None:
+    configs: dict[str, Any] = {
         "default": {
             "invocation": {
                 "environment_setup": None,
@@ -111,8 +112,8 @@ def test_select_invocation_raise_on_no_match():
         )
 
 
-def test_select_invocation_multiple_specified_higher_specificity_selected_first():
-    configs = {
+def test_select_invocation_multiple_specified_higher_specificity_selected_first() -> None:
+    configs: dict[str, Any] = {
         "specific": {
             "invocation": {
                 "environment_setup": None,
@@ -135,8 +136,10 @@ def test_select_invocation_multiple_specified_higher_specificity_selected_first(
     assert matched == "specific"
 
 
-def test_select_invocation_multiple_specified_higher_specificity_selected_second():
-    configs = {
+def test_select_invocation_multiple_specified_higher_specificity_selected_second() -> (
+    None
+):
+    configs: dict[str, Any] = {
         "default": {
             "invocation": {
                 "environment_setup": None,