hpcflow-new2 0.2.0a189__py3-none-any.whl → 0.2.0a199__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,59 +1,70 @@
+from __future__ import annotations
 import os
+import time
 import pytest
 
 from hpcflow.app import app as hf
-from hpcflow.sdk.config.errors import ConfigFileValidationError, ConfigItemCallbackError
+from hpcflow.sdk.config.errors import (
+    ConfigFileValidationError,
+    ConfigItemCallbackError,
+    ConfigNonConfigurableError,
+    ConfigReadOnlyError,
+)
 
 
-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"
 
@@ -67,3 +78,118 @@ def test_without_callbacks_ctx_manager(null_config):
 
     # unload the modified config so it's not reused by other tests
     hf.unload_config()
+
+
+@pytest.mark.xfail(reason="Might occasionally fail.")
+def test_cache_faster_than_no_cache(null_config):
+    n = 10_000
+    tic = time.perf_counter()
+    for _ in range(n):
+        _ = hf.config.machine
+    toc = time.perf_counter()
+    elapsed_no_cache = toc - tic
+
+    with hf.config.cached_config():
+        tic = time.perf_counter()
+        for _ in range(n):
+            _ = hf.config.machine
+        toc = time.perf_counter()
+    elapsed_cache = toc - tic
+
+    assert elapsed_cache < elapsed_no_cache
+
+
+def test_cache_read_only(new_null_config):
+    """Check we cannot modify the config when using the cache"""
+
+    # check we can set an item first:
+    hf.machine = "abc"
+    assert hf.machine == "abc"
+
+    with pytest.raises(ConfigReadOnlyError):
+        with hf.config.cached_config():
+            hf.config.set("machine", "123")
+
+    with pytest.raises(ConfigReadOnlyError):
+        with hf.config.cached_config():
+            hf.config.machine = "456"
+
+
+def test_workflow_template_config_validation(new_null_config, tmp_path):
+    wkt = hf.WorkflowTemplate(
+        tasks=[],
+        config={"log_file_level": "debug"},
+        name="test_workflow_config_validation",
+    )
+    assert wkt.config == {"log_file_level": "debug"}
+
+
+def test_workflow_template_config_validation_raises(unload_config, tmp_path):
+    with pytest.raises(ConfigNonConfigurableError):
+        hf.WorkflowTemplate(
+            tasks=[],
+            config={"bad_key": "debug"},
+            name="test_workflow_config_validation_raises",
+        )
+
+    # workflow template config validation should not need to load the whole config:
+    assert not hf.is_config_loaded
+
+
+def test_config_with_updates(new_null_config):
+    level_1 = hf.config.get("log_console_level")
+    with hf.config._with_updates({"log_console_level": "debug"}):
+        level_2 = hf.config.get("log_console_level")
+    level_3 = hf.config.get("log_console_level")
+    assert level_1 == level_3 != level_2
+    hf.reload_config()
+
+
+@pytest.mark.integration
+def test_workflow_template_config_set(new_null_config, tmp_path):
+    """Test we can set a workflow-level config item and that it is correctly applied
+    during execution."""
+
+    t1 = hf.Task(
+        schema=hf.task_schemas.test_t1_conditional_OS,
+        inputs={"p1": 101},
+    )
+    log_path = tmp_path / "log.log"
+    hf.config.set("log_file_level", "warning")
+    hf.config.set("log_file_path", log_path)
+
+    log_str_1 = "this should not appear in the log file"
+    hf.submission_logger.debug(log_str_1)
+
+    log_str_2 = "this should appear in the log file"
+    hf.submission_logger.warning(log_str_2)
+
+    assert log_path.is_file()
+    log_file_contents = log_path.read_text()
+    assert log_str_1 not in log_file_contents
+    assert log_str_2 in log_file_contents
+
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1],
+        config={"log_file_level": "debug"},
+        resources={"any": {"write_app_logs": True}},
+        workflow_name="test_workflow_config",
+        template_name="test_workflow_config",
+        path=tmp_path,
+    )
+    wk.submit(wait=True, status=False, add_to_known=False)
+
+    # check some DEBUG messages present in the run logs
+    debug_str = " DEBUG hpcflow.persistence:"
+
+    run = wk.get_EARs_from_IDs([0])[0]
+    run_log_path = run.get_app_log_path()
+    assert run_log_path.is_file()
+
+    run_log_contents = run_log_path.read_text()
+    assert debug_str in run_log_contents
+
+    # log file level should not have changed:
+    assert hf.config.get("log_file_level") == "warning"
+
+    hf.reload_config()