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

hpcflow/sdk/submission/types.py

@@ -0,0 +1,143 @@
+"""
+Types for the submission subsystem.
+"""
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
+from typing_extensions import NotRequired, TypeAlias, TypedDict
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from datetime import datetime
+    from numpy.typing import NDArray
+    from ..core.element import ElementResources
+
+
+class JobScriptDescriptor(TypedDict):
+    """
+    Descriptor for a jobscript.
+    """
+
+    #: Resources required by the jobscript.
+    resources: Any
+    #: Elements handled by the jobscript.
+    elements: dict[int, list[int]]
+    #: Dependencies of the jobscript.
+    dependencies: NotRequired[dict[int, ResolvedDependencies]]
+    #: Hash of resources.
+    resource_hash: NotRequired[str]
+
+
+class ResolvedDependencies(TypedDict):
+    """
+    The resolution of a dependency.
+    """
+
+    #: Mapping of jobscript elements.
+    js_element_mapping: dict[int, list[int]]
+    #: Whether this is an array mapping.
+    is_array: NotRequired[bool]
+
+
+class JobScriptCreationArguments(TypedDict):
+    """
+    Arguments to pass to create a :class:`Jobscript`.
+    """
+
+    #: The task insertion IDs.
+    task_insert_IDs: list[int]
+    #: The actions of the tasks.
+    task_actions: list[tuple[int, int, int]]
+    #: The elements of the tasks.
+    task_elements: dict[int, list[int]]
+    #: Element action run information.
+    EAR_ID: NDArray
+    #: Resources to use.
+    resources: ElementResources
+    #: Description of what loops are in play.
+    task_loop_idx: list[dict[str, int]]
+    #: Description of dependencies.
+    dependencies: dict[int, ResolvedDependencies]
+    #: When the jobscript was submitted, if known.
+    submit_time: NotRequired[datetime]
+    #: Where the jobscript was submitted, if known.
+    submit_hostname: NotRequired[str]
+    #: Description of what the jobscript was submitted to, if known.
+    submit_machine: NotRequired[str]
+    #: The command line used to do the commit, if known.
+    submit_cmdline: NotRequired[list[str]]
+    #: The job ID from the scheduler, if known.
+    scheduler_job_ID: NotRequired[str]
+    #: The process ID of the subprocess, if known.
+    process_ID: NotRequired[int]
+    #: Version info about the target system.
+    version_info: NotRequired[dict[str, str | list[str]]]
+    #: The name of the OS.
+    os_name: NotRequired[str]
+    #: The name of the shell.
+    shell_name: NotRequired[str]
+    #: The scheduler used.
+    scheduler_name: NotRequired[str]
+    #: Whether the jobscript is currently running.
+    running: NotRequired[bool]
+    #: Do not supply!
+    resource_hash: NotRequired[str]
+    #: Do not supply!
+    elements: NotRequired[dict[int, list[int]]]
+
+
+class SchedulerRef(TypedDict):
+    """
+    Scheduler reference descriptor.
+    """
+
+    #: Jobscript references.
+    js_refs: list  # Internal type is horrible and variable
+    #: Number of jobscript elements.
+    num_js_elements: int
+
+
+class SubmissionPart(TypedDict):
+    """
+    A part of a submission.
+    """
+
+    #: Timestamp for when this part was submitted.
+    submit_time: datetime
+    #: The jobscripts involved in this submission.
+    jobscripts: list[int]
+
+
+# This needs PEP 728 for a better type, alas
+#: Version data.
+VersionInfo: TypeAlias = "dict[str, str | list[str]]"
+
+
+# TODO: This really doesn't belong here?!
+class JobscriptHeaderArgs(TypedDict):
+    """
+    Keyword arguments to use when creating a job script from a
+    :class:`Jobscript`.
+    """
+
+    #: Application invocation. (Arguments, etc.)
+    app_invoc: str | Sequence[str]
+    #: Configuration directory.
+    config_dir: NotRequired[str]
+    #: Configuration key.
+    config_invoc_key: NotRequired[Any]
+    #: Name of EAR file.
+    EAR_file_name: NotRequired[str]
+    #: Name of file containing run directories.
+    element_run_dirs_file_path: NotRequired[str]
+    #: Environment setup.
+    env_setup: NotRequired[str]
+    #: Jobscript index.
+    js_idx: NotRequired[int]
+    #: Log file for the run.
+    run_log_file: NotRequired[str]
+    #: Submission index.
+    sub_idx: NotRequired[int]
+    #: Workflow application alias.
+    workflow_app_alias: NotRequired[str]
+    #: Path to workflow.
+    workflow_path: NotRequired[str]

hpcflow/sdk/typing.py

@@ -1,18 +1,169 @@
 """
 Common type aliases.
 """
-from typing import Tuple, TypeVar
+from __future__ import annotations
+from dataclasses import InitVar
+from typing import ClassVar, Final, TypeVar, cast, TYPE_CHECKING
+from typing_extensions import NotRequired, TypeAlias, TypedDict
 from pathlib import Path
+import re
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from datetime import datetime
+    from .core.object_list import (
+        CommandFilesList,
+        EnvironmentsList,
+        ParametersList,
+        TaskSchemasList,
+    )
+    from .submission.enums import JobscriptElementState
+    from .submission.submission import Submission
 
 #: Type of a value that can be treated as a path.
-PathLike = TypeVar("PathLike", str, Path, None)  # TODO: maybe don't need TypeVar?
-
-#: Type of an element index:
-#: (task_insert_ID, element_idx)
-E_idx_type = Tuple[int, int]
-#: Type of an element iteration index:
-#: (task_insert_ID, element_idx, iteration_idx)
-EI_idx_type = Tuple[int, int, int]
-#: Type of an element action run index:
-#: (task_insert_ID, element_idx, iteration_idx, action_idx, run_idx)
-EAR_idx_type = Tuple[int, int, int, int, int]
+PathLike: TypeAlias = "str | Path | None"
+
+
+class ParamSource(TypedDict):
+    """
+    A parameter source descriptor.
+    """
+
+    #: Parameter type name.
+    type: NotRequired[str]
+    #: EAR ID.
+    EAR_ID: NotRequired[int]
+    #: Task insertion ID.
+    task_insert_ID: NotRequired[int]
+    #: Action index.
+    action_idx: NotRequired[int]
+    #: Element index.
+    element_idx: NotRequired[int]
+    #: Element set index.
+    element_set_idx: NotRequired[int]
+    #: Element action run index.
+    run_idx: NotRequired[int]
+    #: Sequence index.
+    sequence_idx: NotRequired[int]
+    #: Task index.
+    task_idx: NotRequired[int]
+    #: Name of method used to create the parameter's value(s).
+    value_class_method: NotRequired[str]
+
+
+class KnownSubmission(TypedDict):
+    """
+    Describes a known submission.
+    """
+
+    #: Local ID.
+    local_id: int
+    #: Workflow global ID.
+    workflow_id: str
+    #: Whether the submission is active.
+    is_active: bool
+    #: Submission index.
+    sub_idx: int
+    #: Submission time.
+    submit_time: str
+    #: Path to submission.
+    path: str
+    #: Start time.
+    start_time: str
+    #: Finish time.
+    end_time: str
+
+
+class KnownSubmissionItem(TypedDict):
+    """
+    Describes a known submission.
+    """
+
+    #: Local ID.
+    local_id: int
+    #: Workflow global ID.
+    workflow_id: str
+    #: Path to the workflow.
+    workflow_path: str
+    #: Time of submission.
+    submit_time: str
+    #: Parsed time of submission.
+    submit_time_obj: NotRequired[datetime | None]
+    #: Time of start.
+    start_time: str
+    #: Parsed time of start.
+    start_time_obj: datetime | None
+    #: Time of finish.
+    end_time: str
+    #: Parsed time of finish.
+    end_time_obj: datetime | None
+    #: Submission index.
+    sub_idx: int
+    #: Jobscripts in submission.
+    jobscripts: list[int]
+    #: Active jobscript state.
+    active_jobscripts: Mapping[int, Mapping[int, JobscriptElementState]]
+    #: Whether this is deleted.
+    deleted: bool
+    #: Whether this is unloadable.
+    unloadable: bool
+    #: Expanded submission object.
+    submission: NotRequired[Submission]
+
+
+class TemplateComponents(TypedDict):
+    """
+    Components loaded from templates.
+    """
+
+    #: Parameters loaded from templates.
+    parameters: NotRequired[ParametersList]
+    #: Command files loaded from templates.
+    command_files: NotRequired[CommandFilesList]
+    #: Execution environments loaded from templates.
+    environments: NotRequired[EnvironmentsList]
+    #: Task schemas loaded from templates.
+    task_schemas: NotRequired[TaskSchemasList]
+    #: Scripts discovered by templates.
+    scripts: NotRequired[dict[str, Path]]
+
+
+#: Simplification of :class:`TemplateComponents` to allow some types of
+#: internal manipulations.
+BasicTemplateComponents: TypeAlias = "dict[str, list[dict]]"
+
+
+DataIndex: TypeAlias = "dict[str, int | list[int]]"
+"""
+The type of indices to data. These are *normally* dictionaries of integers,
+but can have leaves being lists of integers when dealing with element groups
+(i.e., when a downstream element uses outputs from multiple upstream elements,
+rather than just a single upstream element).
+"""
+
+
+_T = TypeVar("_T")
+
+_CLASS_VAR_RE: Final = re.compile(r"ClassVar\[(.*)\]")
+_INIT_VAR_RE: Final = re.compile(r"InitVar\[(.*)\]")
+
+
+def hydrate(cls: type[_T]) -> type[_T]:
+    """
+    Partially hydrates the annotations on fields in a class, so that a @dataclass
+    annotation can recognise that ClassVar-annotated fields are class variables.
+    """
+    anns = {}
+    for f, a in cls.__annotations__.items():
+        if isinstance(a, str):
+            m = _CLASS_VAR_RE.match(a)
+            if m:
+                anns[f] = ClassVar[m[1]]
+                continue
+            m = _INIT_VAR_RE.match(a)
+            if m:
+                anns[f] = InitVar(cast(type, m[1]))
+                continue
+        anns[f] = a
+    cls.__annotations__ = anns
+    return cls

hpcflow/tests/conftest.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+from pathlib import Path
 import pytest
 from hpcflow.app import app as hf
 
 
-def pytest_addoption(parser):
+def pytest_addoption(parser: pytest.Parser):
     parser.addoption(
         "--slurm",
         action="store_true",
@@ -29,7 +31,7 @@ def pytest_addoption(parser):
     )
 
 
-def pytest_configure(config):
+def pytest_configure(config: pytest.Config):
     config.addinivalue_line("markers", "slurm: mark test as slurm to run")
     config.addinivalue_line("markers", "wsl: mark test as wsl to run")
     config.addinivalue_line(
@@ -42,7 +44,7 @@ def pytest_configure(config):
     hf.run_time_info.in_pytest = True
 
 
-def pytest_collection_modifyitems(config, items):
+def pytest_collection_modifyitems(config: pytest.Config, items: list[pytest.Item]):
     if config.getoption("--slurm"):
         # --slurm given in cli: only run slurm tests
         for item in items:
@@ -84,19 +86,19 @@ def pytest_collection_modifyitems(config, items):
                 )
 
 
-def pytest_unconfigure(config):
+def pytest_unconfigure(config: pytest.Config):
     hf.run_time_info.in_pytest = False
 
 
 @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)
     hf.run_time_info.in_pytest = True
 
 
 @pytest.fixture
-def new_null_config(tmp_path):
+def new_null_config(tmp_path: Path):
     hf.load_config(config_dir=tmp_path, warn=False)
     hf.load_template_components(warn=False)
     hf.run_time_info.in_pytest = True

hpcflow/tests/schedulers/slurm/test_slurm_submission.py

@@ -1,11 +1,14 @@
+from pathlib import Path
 import pytest
 from hpcflow.app import app as hf
 from hpcflow.sdk.core.test_utils import make_test_data_YAML_workflow
 
 
 @pytest.mark.slurm
-def test_workflow_1(tmp_path, null_config):
+def test_workflow_1(tmp_path: Path, null_config):
     hf.config.add_scheduler("slurm")
     wk = make_test_data_YAML_workflow("workflow_1_slurm.yaml", path=tmp_path)
     wk.submit(wait=True, add_to_known=False)
-    assert wk.tasks[0].elements[0].outputs.p2.value == "201"
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == "201"

hpcflow/tests/scripts/test_main_scripts.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 import time
 import pytest
 
@@ -10,7 +11,7 @@ from hpcflow.sdk.core.test_utils import P1_parameter_cls as P1
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_direct_in_direct_out(null_config, tmp_path):
+def test_script_direct_in_direct_out(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
@@ -34,12 +35,14 @@ def test_script_direct_in_direct_out(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == p1_val + 100
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == p1_val + 100
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_direct_sub_param_in_direct_out(null_config, tmp_path):
+def test_script_direct_sub_param_in_direct_out(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
@@ -63,12 +66,14 @@ def test_script_direct_sub_param_in_direct_out(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == p1_val["a"] + 100
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == p1_val["a"] + 100
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_direct_in_direct_out_single_label(null_config, tmp_path):
+def test_script_direct_in_direct_out_single_label(null_config, tmp_path: Path):
     """This uses the same test script as the `test_script_direct_in_direct_out` test;
     single labels are trivial and need not be referenced in the script."""
     p1_label = "one"
@@ -95,12 +100,14 @@ def test_script_direct_in_direct_out_single_label(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == p1_val + 100
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == p1_val + 100
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_direct_in_direct_out_labels(null_config, tmp_path):
+def test_script_direct_in_direct_out_labels(null_config, tmp_path: Path):
     p1_label_1 = "one"
     p1_label_2 = "two"
     s1 = hf.TaskSchema(
@@ -139,12 +146,14 @@ def test_script_direct_in_direct_out_labels(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == p1_1_val + p1_2_val
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == p1_1_val + p1_2_val
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_json_in_json_out(null_config, tmp_path):
+def test_script_json_in_json_out(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
@@ -168,12 +177,14 @@ def test_script_json_in_json_out(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == p1_val + 100
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == p1_val + 100
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_json_in_json_out_labels(null_config, tmp_path):
+def test_script_json_in_json_out_labels(null_config, tmp_path: Path):
     p1_label_1 = "one"
     p1_label_2 = "two"
     s1 = hf.TaskSchema(
@@ -212,12 +223,14 @@ def test_script_json_in_json_out_labels(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == p1_1_val + p1_2_val
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == p1_1_val + p1_2_val
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_json_sub_param_in_json_out_labels(null_config, tmp_path):
+def test_script_json_sub_param_in_json_out_labels(null_config, tmp_path: Path):
     p1_label_1 = "one"
     p1_label_2 = "two"
     s1 = hf.TaskSchema(
@@ -256,12 +269,14 @@ def test_script_json_sub_param_in_json_out_labels(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == a_val + p1_2_val
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == a_val + p1_2_val
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_json_and_direct_in_json_out(null_config, tmp_path):
+def test_script_json_and_direct_in_json_out(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[
@@ -289,12 +304,14 @@ def test_script_json_and_direct_in_json_out(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p3.value == p1_val + p2_val
+    p3 = wk.tasks[0].elements[0].outputs.p3
+    assert isinstance(p3, hf.ElementParameter)
+    assert p3.value == p1_val + p2_val
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_json_in_json_and_direct_out(null_config, tmp_path):
+def test_script_json_in_json_and_direct_out(null_config, tmp_path: Path):
     s1 = hf.TaskSchema(
         objective="t1",
         inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
@@ -321,13 +338,17 @@ def test_script_json_in_json_and_direct_out(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == p1_val + 100
-    assert wk.tasks[0].elements[0].outputs.p3.value == p1_val + 200
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    p3 = wk.tasks[0].elements[0].outputs.p3
+    assert isinstance(p3, hf.ElementParameter)
+    assert p2.value == p1_val + 100
+    assert p3.value == p1_val + 200
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_json_in_obj(null_config, tmp_path):
+def test_script_json_in_obj(null_config, tmp_path: Path):
     """Use a custom JSON dumper defined in the P1 class."""
     s1 = hf.TaskSchema(
         objective="t1",
@@ -353,12 +374,14 @@ def test_script_json_in_obj(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == a_val + 100
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == a_val + 100
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_hdf5_in_obj(null_config, tmp_path):
+def test_script_hdf5_in_obj(null_config, tmp_path: Path):
     """Use a custom HDF5 dumper defined in the P1 class."""
     s1 = hf.TaskSchema(
         objective="t1",
@@ -384,12 +407,14 @@ def test_script_hdf5_in_obj(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == a_val + 100
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == a_val + 100
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_json_out_obj(null_config, tmp_path):
+def test_script_json_out_obj(null_config, tmp_path: Path):
     """Use a custom JSON saver defined in the P1 class."""
     s1 = hf.TaskSchema(
         objective="t1",
@@ -415,12 +440,14 @@ def test_script_json_out_obj(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p1c.value == P1(a=p1_val + 100)
+    p1c = wk.tasks[0].elements[0].outputs.p1c
+    assert isinstance(p1c, hf.ElementParameter)
+    assert p1c.value == P1(a=p1_val + 100)
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_hdf5_out_obj(null_config, tmp_path):
+def test_script_hdf5_out_obj(null_config, tmp_path: Path):
     """Use a custom HDF5 saver defined in the P1 class."""
     s1 = hf.TaskSchema(
         objective="t1",
@@ -446,13 +473,14 @@ def test_script_hdf5_out_obj(null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p1c.value == P1(a=p1_val + 100)
+    p1c = wk.tasks[0].elements[0].outputs.p1c
+    assert isinstance(p1c, hf.ElementParameter)
+    assert p1c.value == P1(a=p1_val + 100)
 
 
 @pytest.mark.integration
 @pytest.mark.skipif("hf.run_time_info.is_frozen")
-def test_script_direct_in_pass_env_spec(new_null_config, tmp_path):
-
+def test_script_direct_in_pass_env_spec(new_null_config, tmp_path: Path):
     vers_spec = {"version": "1.2"}
     env = hf.Environment(
         name="python_env_with_specifiers",
@@ -503,7 +531,9 @@ def test_script_direct_in_pass_env_spec(new_null_config, tmp_path):
     # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
     # to be later Python versions):
     time.sleep(10)
-    assert wk.tasks[0].elements[0].outputs.p2.value == {
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == {
         "name": "python_env_with_specifiers",
         **vers_spec,
     }

hpcflow/tests/shells/wsl/test_wsl_submission.py

@@ -1,14 +1,16 @@
 import time
-
+from pathlib import Path
 import pytest
-
+from hpcflow.app import app as hf
 from hpcflow.sdk.core.test_utils import make_test_data_YAML_workflow
 
 
 @pytest.mark.wsl
-def test_workflow_1(tmp_path, null_config):
+def test_workflow_1(tmp_path: Path, null_config):
     wk = make_test_data_YAML_workflow("workflow_1_wsl.yaml", path=tmp_path)
     wk.submit(wait=True, add_to_known=False)
     time.sleep(20)  # TODO: bug! for some reason the new parameter isn't actually written
     # to disk when using WSL until several seconds after the workflow has finished!
-    assert wk.tasks[0].elements[0].outputs.p2.value == "201"
+    p2 = wk.tasks[0].elements[0].outputs.p2
+    assert isinstance(p2, hf.ElementParameter)
+    assert p2.value == "201"