hpcflow 0.1.15__py3-none-any.whl → 0.2.0a271__py3-none-any.whl

hpcflow/tests/unit/test_command.py

@@ -0,0 +1,377 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import Any, Sequence, TYPE_CHECKING
+import numpy as np
+import pytest
+from hpcflow.app import app as hf
+from hpcflow.sdk.core.test_utils import (
+    P1_parameter_cls as P1,
+    P1_sub_parameter_cls as P1_sub,
+    command_line_test,
+)
+
+
+def test_get_command_line(null_config, tmp_path: Path):
+    p1_value = 1
+    cmd_str = "Write-Output (<<parameter:p1>> + 100)"
+    expected = f"Write-Output ({p1_value} + 100)"
+    command_line_test(cmd_str, expected, {"p1": p1_value}, tmp_path)
+
+
+@pytest.mark.parametrize("shell_args", [("powershell", "nt"), ("bash", "posix")])
+def test_get_command_line_with_stdout(
+    null_config, tmp_path: Path, shell_args: tuple[str, str]
+):
+    p1_value = 1
+    expected = {
+        ("powershell", "nt"): f"$parameter_p2 = Write-Output ({p1_value} + 100)",
+        ("bash", "posix"): f"parameter_p2=`Write-Output ({p1_value} + 100)`",
+    }
+    command_line_test(
+        cmd_str="Write-Output (<<parameter:p1>> + 100)",
+        cmd_stdout="<<parameter:p2>>",
+        expected=expected[shell_args],
+        inputs={"p1": p1_value},
+        outputs=("p2",),
+        shell_args=shell_args,
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_single_labelled_input(null_config, tmp_path: Path):
+    p1_value = 1
+    command_line_test(
+        cmd_str="Write-Output (<<parameter:p1[one]>> + 100)",
+        expected=f"Write-Output ({p1_value} + 100)",
+        schema_inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"), labels={"one": {}})],
+        inputs=[hf.InputValue("p1", label="one", value=p1_value)],
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_multiple_labelled_input(null_config, tmp_path: Path):
+    p1_one_value = 1
+    p1_two_value = 2
+    command_line_test(
+        cmd_str="Write-Output (<<parameter:p1[one]>> + <<parameter:p1[two]>> + 100)",
+        expected=f"Write-Output ({p1_one_value} + {p1_two_value} + 100)",
+        schema_inputs=[
+            hf.SchemaInput(
+                parameter=hf.Parameter("p1"), multiple=True, labels={"one": {}, "two": {}}
+            )
+        ],
+        inputs=[
+            hf.InputValue("p1", label="one", value=p1_one_value),
+            hf.InputValue("p1", label="two", value=p1_two_value),
+        ],
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_sub_parameter(null_config, tmp_path: Path):
+    p1_value = {"a": 1}
+    command_line_test(
+        cmd_str="Write-Output (<<parameter:p1.a>> + 100)",
+        expected=f"Write-Output ({p1_value['a']} + 100)",
+        inputs={"p1": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_sum(null_config, tmp_path: Path):
+    p1_value = [1, 2, 3]
+    command_line_test(
+        cmd_str="Write-Output (<<sum(parameter:p1)>> + 100)",
+        expected=f"Write-Output ({sum(p1_value)} + 100)",
+        inputs={"p1": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_join(null_config, tmp_path: Path):
+    p1_value = [1, 2, 3]
+    delim = ","
+    command_line_test(
+        cmd_str=f'Write-Output (<<join[delim="{delim}"](parameter:p1)>> + 100)',
+        expected=f"Write-Output ({delim.join(str(i) for i in p1_value)} + 100)",
+        inputs={"p1": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_sum_sub_data(null_config, tmp_path: Path):
+    p1_value = {"a": [1, 2, 3]}
+    command_line_test(
+        cmd_str="Write-Output (<<sum(parameter:p1.a)>> + 100)",
+        expected=f"Write-Output ({sum(p1_value['a'])} + 100)",
+        inputs={"p1": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_join_sub_data(null_config, tmp_path):
+    delim = ","
+    p1_value = {"a": [1, 2, 3]}
+    command_line_test(
+        cmd_str=f'Write-Output (<<join[delim="{delim}"](parameter:p1.a)>> + 100)',
+        expected=f"Write-Output ({delim.join(str(i) for i in p1_value['a'])} + 100)",
+        inputs={"p1": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_parameter_value(null_config, tmp_path: Path):
+    p1_value = P1(a=1)  # has a `CLI_format` method defined which returns `str(a)`
+    command_line_test(
+        cmd_str="Write-Output (<<parameter:p1c>> + 100)",
+        expected=f"Write-Output ({p1_value.a} + 100)",
+        inputs={"p1c": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_parameter_value_join(null_config, tmp_path: Path):
+    delim = ","
+    p1_value = P1(a=4)
+    command_line_test(
+        cmd_str=(
+            f"Write-Output "
+            f'<<join[delim="{delim}"](parameter:p1c.custom_CLI_format_prep(reps=4))>>'
+        ),
+        expected="Write-Output 4,4,4,4",
+        inputs={"p1c": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_parameter_value_custom_method(null_config, tmp_path: Path):
+    p1_value = P1(a=1)
+    command_line_test(
+        cmd_str="Write-Output (<<parameter:p1c.custom_CLI_format()>> + 100)",
+        expected=f"Write-Output ({p1_value.a + 4} + 100)",
+        inputs={"p1c": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_parameter_value_custom_method_with_args(
+    null_config, tmp_path: Path
+):
+    p1_value = P1(a=1)
+    add_val = 35
+    command_line_test(
+        cmd_str=f"Write-Output (<<parameter:p1c.custom_CLI_format(add={add_val})>> + 100)",
+        expected=f"Write-Output ({p1_value.a + add_val} + 100)",
+        inputs={"p1c": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_parameter_value_custom_method_with_two_args(
+    null_config, tmp_path: Path
+):
+    add_val = 35
+    sub_val = 10
+    p1_value = P1(a=1)
+    command_line_test(
+        cmd_str=(
+            f"Write-Output ("
+            f"<<parameter:p1c.custom_CLI_format(add={add_val}, sub={sub_val})>> + 100)"
+        ),
+        expected=f"Write-Output ({p1_value.a + add_val - sub_val} + 100)",
+        inputs={"p1c": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_parameter_value_sub_object(null_config, tmp_path: Path):
+    p1_value = P1(a=1, sub_param=P1_sub(e=5))
+    assert p1_value.sub_param
+    command_line_test(
+        cmd_str=f"Write-Output (<<parameter:p1c.sub_param>> + 100)",
+        expected=f"Write-Output ({p1_value.sub_param.e} + 100)",
+        inputs={"p1c": p1_value},
+        path=tmp_path,
+    )
+
+
+def test_get_command_line_parameter_value_sub_object_attr(null_config, tmp_path: Path):
+    p1_value = P1(a=1, sub_param=P1_sub(e=5))
+    assert p1_value.sub_param
+    command_line_test(
+        cmd_str=f"Write-Output (" f"<<parameter:p1c.sub_param.e>> + 100)",
+        expected=f"Write-Output ({p1_value.sub_param.e} + 100)",
+        inputs={"p1c": p1_value},
+        path=tmp_path,
+    )
+
+
+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) -> 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) -> 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) -> 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) -> 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) -> 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) -> None:
+    cmd = hf.Command(command="", stdout="<<list(parameter:p2)>>")
+    assert cmd.process_std_stream(name="p2", value="1 2 3", stderr=False) == [
+        "1",
+        "2",
+        "3",
+    ]
+
+
+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) -> None:
+    cmd = hf.Command(command="", stdout='<<list[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_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) -> None:
+    cmd = hf.Command(
+        command="", stdout='<<list[item_type=float, delim=":"](parameter:p2)>>'
+    )
+    assert cmd.process_std_stream(name="p2", value="1.1:2.2:3.3", stderr=False) == [
+        1.1,
+        2.2,
+        3.3,
+    ]
+
+
+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),
+        np.array([1, 2, 3]),
+    )
+
+
+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),
+        np.array([1, 2, 3]),
+    )
+
+
+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) -> 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) -> 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(
+        a=a_val
+    )
+
+
+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
+    assert cmd.process_std_stream(name="p1c", value=str(a_val), stderr=False) == P1(
+        a=expected
+    )
+
+
+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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> None:
+    tests = {
+        "<<executable:m1>> and <<executable:12>>": ["m1", "12"],
+        "<<executable:m1>> hi": ["m1"],
+        "<<executable:m1": [],
+    }
+    for k, v in tests.items():
+        assert hf.Command._extract_executable_labels(k) == v

hpcflow/tests/unit/test_config.py

@@ -0,0 +1,195 @@
+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,
+    ConfigNonConfigurableError,
+    ConfigReadOnlyError,
+)
+
+
+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.machine = new_machine_name
+    assert hf.config.machine == new_machine_name
+    hf.reset_config(config_dir=cfg_dir)
+    assert hf.config.machine == machine_name
+
+
+def test_raise_on_invalid_config_file(new_null_config) -> None:
+    # make an invalid config file:
+    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.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) -> None:
+    # make an invalid config file:
+    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.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,
+) -> 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,
+) -> 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) -> None:
+    # set a new shell that would raise an error in the `callback_supported_shells`:
+    new_default = "bash" if os.name == "nt" else "powershell"
+
+    with hf.config._without_callbacks("callback_supported_shells"):
+        hf.config.default_shell = new_default
+        assert hf.config.default_shell == new_default
+
+    # outside the context manager, the callback is reinstated, which should raise:
+    with pytest.raises(ConfigItemCallbackError):
+        hf.config.default_shell
+
+    # 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()