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

hpcflow/sdk/core/command_files.py

@@ -4,65 +4,104 @@ Model of files that hold commands.
 
 from __future__ import annotations
 import copy
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, InitVar
 from pathlib import Path
 from textwrap import dedent
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Protocol, cast, overload, TYPE_CHECKING
+from typing_extensions import Final, override
 
-from hpcflow.sdk import app
+from hpcflow.sdk.typing import PathLike, hydrate, ParamSource
 from hpcflow.sdk.core.json_like import ChildObjectSpec, JSONLike
-from hpcflow.sdk.core.environment import Environment
 from hpcflow.sdk.core.utils import search_dir_files_by_regex
 from hpcflow.sdk.core.zarr_io import zarr_decode
 from hpcflow.sdk.core.parameters import _process_demo_data_strings
 
+if TYPE_CHECKING:
+    import os
+    from collections.abc import Mapping
+    from typing import Any, ClassVar
+    from typing_extensions import Self
+    from .actions import Action, ActionRule
+    from .environment import Environment
+    from .object_list import CommandFilesList
+    from .parameters import Parameter
+    from .task import ElementSet
+    from .workflow import Workflow
 
-@dataclass
+
+class FileNamePart(Protocol):
+    """
+    A filename or piece of filename that can be expanded.
+    """
+
+    def value(self, directory: str | os.PathLike = ".") -> str | list[str]:
+        """
+        Get the part of the file, possibly with directory specified.
+        Implementations of this may ignore the directory.
+        If a pattern, the expanded value may be a list of strings.
+        """
+
+
+@dataclass(init=False)
+@hydrate
 class FileSpec(JSONLike):
     """
     A specification of a file handled by a workflow.
     """
 
-    _app_attr = "app"
-
-    _validation_schema = "files_spec_schema.yaml"
-    _child_objects = (ChildObjectSpec(name="name", class_name="FileNameSpec"),)
+    _validation_schema: ClassVar[str] = "files_spec_schema.yaml"
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
+        ChildObjectSpec(name="name", class_name="FileNameSpec"),
+    )
 
     #: Label for this file specification.
-    label: str
+    label: Final[str]
     #: The name of the file.
-    name: str
+    name: Final[FileNameSpec]
     #: Documentation for the file specification.
-    doc: str = ""
-    _hash_value: Optional[str] = field(default=None, repr=False)
+    doc: Final[str]
+    _hash_value: str | None = field(default=None, repr=False)
 
-    def __post_init__(self):
-        self.name = (
-            self.app.FileNameSpec(self.name) if isinstance(self.name, str) else self.name
-        )
-
-    def value(self, directory="."):
+    def __init__(
+        self,
+        label: str,
+        name: str | FileNameSpec,
+        doc: str = "",
+        _hash_value: str | None = None,
+    ) -> None:
+        self.label = label
+        self.name = self._app.FileNameSpec(name) if isinstance(name, str) else name
+        self.doc = doc
+        self._hash_value = _hash_value
+        self.__hash = hash((label, self.name))
+
+    def value(self, directory: str | os.PathLike = ".") -> str:
         """
         The path to a file, optionally resolved with respect to a particular directory.
         """
-        return self.name.value(directory)
+        return cast("str", self.name.value(directory))
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, self.__class__):
             return False
-        if self.label == other.label and self.name == other.name:
-            return True
-        return False
+        return self.label == other.label and self.name == other.name
+
+    def __hash__(self) -> int:
+        return self.__hash
+
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        d.pop("_FileSpec__hash")
+        return d
 
     @property
-    def stem(self):
+    def stem(self) -> FileNameStem:
         """
         The stem of the file name.
         """
         return self.name.stem
 
     @property
-    def ext(self):
+    def ext(self) -> FileNameExt:
         """
         The extension of the file name.
         """
@@ -80,6 +119,7 @@ class FileSpec(JSONLike):
         return repr(self)
 
 
+@hydrate
 class FileNameSpec(JSONLike):
     """
     The name of a file handled by a workflow, or a pattern that matches multiple files.
@@ -95,15 +135,19 @@ class FileNameSpec(JSONLike):
         If true, the name is used as a regex to search for actual files.
     """
 
-    _app_attr = "app"
-
-    def __init__(self, name, args=None, is_regex=False):
+    def __init__(
+        self,
+        name: str,
+        args: list[FileNamePart] | None = None,
+        is_regex: bool = False,
+    ) -> None:
         #: The name or pattern.
-        self.name = name
+        self.name: Final[str] = name
         #: Positional arguments to use when formatting the name.
-        self.args = args
+        self.args: Final[tuple[FileNamePart, ...]] = tuple(args or [])
         #: Whether the name is used as a regex to search for actual files.
-        self.is_regex = is_regex
+        self.is_regex: Final[bool] = is_regex
+        self.__hash = hash((name, self.args, is_regex))
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, self.__class__):
@@ -114,37 +158,44 @@ class FileNameSpec(JSONLike):
             and self.is_regex == other.is_regex
         )
 
+    def __hash__(self) -> int:
+        return self.__hash
+
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        d.pop("_FileNameSpec__hash")
+        return d
+
     @property
-    def stem(self):
+    def stem(self) -> FileNameStem:
         """
         The stem of the name or pattern.
         """
-        return self.app.FileNameStem(self)
+        return self._app.FileNameStem(self)
 
     @property
-    def ext(self):
+    def ext(self) -> FileNameExt:
         """
         The extension of the name or pattern.
         """
-        return self.app.FileNameExt(self)
+        return self._app.FileNameExt(self)
 
-    def value(self, directory="."):
+    def value(self, directory: str | os.PathLike = ".") -> list[str] | str:
         """
         Get the template-resolved name of the file
         (or files matched if the name is a regex pattern).
 
         Parameters
         ----------
-        directory: str
+        directory: PathLike
             Where to resolve values with respect to.
         """
-        format_args = [i.value(directory) for i in self.args or []]
+        format_args = [arg.value(Path(directory)) for arg in self.args]
         value = self.name.format(*format_args)
         if self.is_regex:
-            value = search_dir_files_by_regex(value, group=0, directory=directory)
+            return search_dir_files_by_regex(value, directory=directory)
         return value
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.name})"
 
 
@@ -155,13 +206,17 @@ class FileNameStem(JSONLike):
     """
 
     #: The file specification this is derived from.
-    file_name: app.FileNameSpec
+    file_name: FileNameSpec
 
-    def value(self, directory=None):
+    def value(self, directory: str | os.PathLike = ".") -> str:
         """
         Get the stem, possibly with directory specified.
         """
-        return Path(self.file_name.value(directory)).stem
+        d = self.file_name.value(directory)
+        if self.file_name.is_regex:
+            raise ValueError("cannot get the stem of a regex match")
+        assert not isinstance(d, list)
+        return Path(d).stem
 
 
 @dataclass
@@ -171,16 +226,21 @@ class FileNameExt(JSONLike):
     """
 
     #: The file specification this is derived from.
-    file_name: app.FileNameSpec
+    file_name: FileNameSpec
 
-    def value(self, directory=None):
+    def value(self, directory: str | os.PathLike = ".") -> str:
         """
         Get the extension.
         """
-        return Path(self.file_name.value(directory)).suffix
+        d = self.file_name.value(directory)
+        if self.file_name.is_regex:
+            raise ValueError("cannot get the extension of a regex match")
+        assert not isinstance(d, list)
+        return Path(d).suffix
 
 
 @dataclass
+@hydrate
 class InputFileGenerator(JSONLike):
     """
     Represents a script that is run to generate input files for an action.
@@ -204,9 +264,7 @@ class InputFileGenerator(JSONLike):
         User-specified rules for whether to run the generator.
     """
 
-    _app_attr = "app"
-
-    _child_objects = (
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
         ChildObjectSpec(
             name="input_file",
             class_name="FileSpec",
@@ -230,88 +288,35 @@ class InputFileGenerator(JSONLike):
     )
 
     #: The file to generate.
-    input_file: app.FileSpec
+    input_file: FileSpec
     #: The input parameters to the generator.
-    inputs: List[app.Parameter]
+    inputs: list[Parameter]
     #: The script that generates the inputs.
-    script: str = None
+    script: str | None = None
     #: The environment in which to run the generator.
-    environment: app.Environment = None
+    environment: Environment | None = None
     #: Whether to pass in the environment.
-    script_pass_env_spec: Optional[bool] = False
+    script_pass_env_spec: bool = False
     #: Whether the generator can be stopped early.
     #: Quick-running scripts tend to not need this.
-    abortable: Optional[bool] = False
+    abortable: bool = False
     #: User-specified rules for whether to run the generator.
-    rules: Optional[List[app.ActionRule]] = None
-
-    def __post_init__(self):
-        self.rules = self.rules or []
-
-    def get_action_rules(self):
-        """Get the rules that allow testing if this input file generator must be run or
-        not for a given element."""
-        return [
-            self.app.ActionRule.check_missing(f"input_files.{self.input_file.label}")
-        ] + self.rules
-
-    def compose_source(self, snip_path) -> str:
-        """Generate the file contents of this input file generator source."""
-
-        script_main_func = snip_path.stem
-        with snip_path.open("rt") as fp:
-            script_str = fp.read()
-
-        main_block = dedent(
-            """\
-            if __name__ == "__main__":
-                import sys
-                from pathlib import Path
-                import {app_module} as app
-                app.load_config(
-                    log_file_path=Path("{run_log_file}").resolve(),
-                    config_dir=r"{cfg_dir}",
-                    config_key=r"{cfg_invoc_key}",
-                )
-                wk_path, EAR_ID = sys.argv[1:]
-                EAR_ID = int(EAR_ID)
-                wk = app.Workflow(wk_path)
-                EAR = wk.get_EARs_from_IDs([EAR_ID])[0]
-                {script_main_func}(path=Path({file_path!r}), **EAR.get_IFG_input_values())
-        """
-        )
-        main_block = main_block.format(
-            run_log_file=self.app.RunDirAppFiles.get_log_file_name(),
-            app_module=self.app.module,
-            cfg_dir=self.app.config.config_directory,
-            cfg_invoc_key=self.app.config.config_key,
-            script_main_func=script_main_func,
-            file_path=self.input_file.name.value(),
-        )
-
-        out = dedent(
-            """\
-            {script_str}
-            {main_block}
-        """
-        )
-
-        out = out.format(script_str=script_str, main_block=main_block)
-        return out
+    rules: list[ActionRule] = field(default_factory=list)
+    #: Whether the generator requires a working directory.
+    requires_dir: bool = True
 
-    def write_source(self, action, env_spec: Dict[str, Any]):
+    def get_action_rules(self) -> list[ActionRule]:
         """
-        Write the script if it is specified as a snippet script, otherwise we assume
-        the script already exists in the working directory.
+        Get the rules that allow testing if this input file generator must be run or
+        not for a given element.
         """
-        snip_path = action.get_snippet_script_path(self.script, env_spec)
-        if snip_path:
-            source_str = self.compose_source(snip_path)
-            with Path(snip_path.name).open("wt", newline="\n") as fp:
-                fp.write(source_str)
+        return [
+            self._app.ActionRule.check_missing(f"input_files.{self.input_file.label}")
+        ] + self.rules
 
 
 @dataclass
+@hydrate
 class OutputFileParser(JSONLike):
     """
     Represents a script that is run to parse output files from an action and create outputs.
@@ -345,7 +350,7 @@ class OutputFileParser(JSONLike):
         Rules for whether to enable this parser.
     """
 
-    _child_objects = (
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
         ChildObjectSpec(
             name="output",
             class_name="Parameter",
@@ -383,46 +388,57 @@ class OutputFileParser(JSONLike):
     )
 
     #: The output files that this parser will parse.
-    output_files: List[app.FileSpec]
+    output_files: list[FileSpec]
     #: The singular output parsed by this parser.
     #: Not to be confused with :py:attr:`outputs` (plural).
-    output: Optional[app.Parameter] = None
+    output: Parameter | None = None
     #: The name of the file containing the output file parser source.
-    script: str = None
+    script: str | None = None
     #: The environment to use to run the parser.
-    environment: Environment = None
+    environment: Environment | None = None
     #: The other inputs to the parser.
-    inputs: List[str] = None
+    inputs: list[str] | None = None
     #: Optional multiple outputs from the upstream actions of the schema that are
     #: required to parametrise this parser.
-    #: Not to be confused with :py:attr:`output` (plural).
-    outputs: List[str] = None
+    #: Not to be confused with :py:attr:`output` (singular).
+    outputs: list[str] | None = None
     #: Miscellaneous options.
-    options: Dict = None
+    options: dict[str, Any] | None = None
     #: Whether to pass the environment specifier to the script.
-    script_pass_env_spec: Optional[bool] = False
+    script_pass_env_spec: bool = False
     #: Whether this script can be aborted.
-    abortable: Optional[bool] = False
+    abortable: bool = False
     #: The files that should be saved to the persistent store for the workflow.
-    save_files: Union[List[str], bool] = True
+    save_files: InitVar[list[FileSpec] | bool] = True
+    _save_files: list[FileSpec] = field(init=False)
     #: The files that should be immediately removed.
-    clean_up: Optional[List[str]] = None
+    clean_up: list[str] = field(default_factory=list)
     #: Rules for whether to enable this parser.
-    rules: Optional[List[app.ActionRule]] = None
+    rules: list[ActionRule] = field(default_factory=list)
+    #: Whether the parser requires a working directory.
+    requires_dir: bool = True
 
-    def __post_init__(self):
-        if not self.save_files:
+    def __post_init__(self, save_files: list[FileSpec] | bool) -> None:
+        if not save_files:
             # save no files
-            self.save_files = []
-        elif self.save_files is True:
+            self._save_files = []
+        elif save_files is True:
             # save all output files
-            self.save_files = [i for i in self.output_files]
-        if self.clean_up is None:
-            self.clean_up = []
-        self.rules = self.rules or []
+            self._save_files = [out_f for out_f in self.output_files]
+        else:
+            self._save_files = save_files
+
+    @override
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        d = super()._postprocess_to_dict(d)
+        if "_save_files" in d:
+            d["save_files"] = d.pop("_save_files")
+        return d
 
     @classmethod
-    def from_json_like(cls, json_like, shared_data=None):
+    def from_json_like(  # type: ignore[override]
+        cls, json_like: dict[str, Any], shared_data: Mapping | None = None
+    ) -> Self:
         if "save_files" in json_like:
             if not json_like["save_files"]:
                 json_like["save_files"] = []
@@ -430,96 +446,30 @@ class OutputFileParser(JSONLike):
                 json_like["save_files"] = [i for i in json_like["output_files"]]
         return super().from_json_like(json_like, shared_data)
 
-    def get_action_rules(self):
+    def get_action_rules(self) -> list[ActionRule]:
         """Get the rules that allow testing if this output file parser must be run or not
         for a given element."""
         return [
-            self.app.ActionRule.check_missing(f"output_files.{i.label}")
-            for i in self.output_files
+            self._app.ActionRule.check_missing(f"output_files.{out_f.label}")
+            for out_f in self.output_files
         ] + self.rules
 
-    def compose_source(self, snip_path) -> str:
-        """Generate the file contents of this output file parser source."""
-
-        if self.output is None:
-            # might be used just for saving files:
-            return
-
-        script_main_func = snip_path.stem
-        with snip_path.open("rt") as fp:
-            script_str = fp.read()
-
-        main_block = dedent(
-            """\
-            if __name__ == "__main__":
-                import sys
-                from pathlib import Path
-                import {app_module} as app
-                app.load_config(
-                    log_file_path=Path("{run_log_file}").resolve(),
-                    config_dir=r"{cfg_dir}",
-                    config_key=r"{cfg_invoc_key}",
-                )
-                wk_path, EAR_ID = sys.argv[1:]
-                EAR_ID = int(EAR_ID)
-                wk = app.Workflow(wk_path)
-                EAR = wk.get_EARs_from_IDs([EAR_ID])[0]
-                value = {script_main_func}(
-                    **EAR.get_OFP_output_files(),
-                    **EAR.get_OFP_inputs(),
-                    **EAR.get_OFP_outputs(),
-                )
-                wk.save_parameter(name="{param_name}", value=value, EAR_ID=EAR_ID)
-
-        """
-        )
-        main_block = main_block.format(
-            run_log_file=self.app.RunDirAppFiles.get_log_file_name(),
-            app_module=self.app.module,
-            cfg_dir=self.app.config.config_directory,
-            cfg_invoc_key=self.app.config.config_key,
-            script_main_func=script_main_func,
-            param_name=f"outputs.{self.output.typ}",
-        )
-
-        out = dedent(
-            """\
-            {script_str}
-            {main_block}
-        """
-        )
-
-        out = out.format(script_str=script_str, main_block=main_block)
-        return out
-
-    def write_source(self, action, env_spec: Dict[str, Any]):
-        """
-        Write the actual output parser to a file so it can be enacted.
-        """
-        if self.output is None:
-            # might be used just for saving files:
-            return
-
-        # write the script if it is specified as a snippet script, otherwise we assume
-        # the script already exists in the working directory:
-        snip_path = action.get_snippet_script_path(self.script, env_spec)
-        if snip_path:
-            source_str = self.compose_source(snip_path)
-            with Path(snip_path.name).open("wt", newline="\n") as fp:
-                fp.write(source_str)
-
 
+@hydrate
 class _FileContentsSpecifier(JSONLike):
     """Class to represent the contents of a file, either via a file-system path or
     directly."""
 
+    #: What file is this? Only if known.
+    file: FileSpec
+
     def __init__(
         self,
-        path: Union[Path, str] = None,
-        contents: Optional[str] = None,
-        extension: Optional[str] = "",
-        store_contents: Optional[bool] = True,
-    ):
+        path: Path | str | None = None,
+        contents: str | None = None,
+        extension: str = "",
+        store_contents: bool = True,
+    ) -> None:
         if path is not None and contents is not None:
             raise ValueError("Specify exactly one of `path` and `contents`.")
 
@@ -528,19 +478,19 @@ class _FileContentsSpecifier(JSONLike):
                 "`store_contents` cannot be set to False if `contents` was specified."
             )
 
-        self._path = _process_demo_data_strings(self.app, path)
+        self._path = _process_demo_data_strings(self._app, path)
         self._contents = contents
         self._extension = extension
         self._store_contents = store_contents
 
         # assigned by `make_persistent`
-        self._workflow = None
-        self._value_group_idx = None
+        self._workflow: Workflow | None = None
+        self._value_group_idx: int | None = None
 
         # assigned by parent `ElementSet`
-        self._element_set = None
+        self._element_set: ElementSet | None = None
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo: dict | None) -> Self:
         kwargs = self.to_dict()
         value_group_idx = kwargs.pop("value_group_idx")
         obj = self.__class__(**copy.deepcopy(kwargs, memo))
@@ -549,16 +499,27 @@ class _FileContentsSpecifier(JSONLike):
         obj._element_set = self._element_set
         return obj
 
-    def to_dict(self):
-        out = super().to_dict()
+    @property
+    def normalised_path(self) -> str:
+        """
+        Full workflow value path to the file.
+
+        Note
+        ----
+        This is not the same as the path in the filesystem, but is closely
+        related.
+        """
+        return str(self._path) if self._path else "."
+
+    @override
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        out = super()._postprocess_to_dict(d)
         if "_workflow" in out:
             del out["_workflow"]
-
-        out = {k.lstrip("_"): v for k, v in out.items()}
-        return out
+        return {k.lstrip("_"): v for k, v in out.items()}
 
     @classmethod
-    def _json_like_constructor(cls, json_like):
+    def _json_like_constructor(cls, json_like: dict[str, Any]) -> Self:
         """Invoked by `JSONLike.from_json_like` instead of `__init__`."""
 
         _value_group_idx = json_like.pop("value_group_idx", None)
@@ -567,7 +528,7 @@ class _FileContentsSpecifier(JSONLike):
 
         return obj
 
-    def _get_members(self, ensure_contents=False):
+    def _get_members(self, ensure_contents: bool = False) -> dict[str, Any]:
         out = self.to_dict()
         del out["value_group_idx"]
 
@@ -578,9 +539,9 @@ class _FileContentsSpecifier(JSONLike):
 
     def make_persistent(
         self,
-        workflow: app.Workflow,
-        source: Dict,
-    ) -> Tuple[str, List[int], bool]:
+        workflow: Workflow,
+        source: ParamSource,
+    ) -> tuple[str, list[int], bool]:
         """Save to a persistent workflow.
 
         Returns
@@ -594,9 +555,9 @@ class _FileContentsSpecifier(JSONLike):
         if self._value_group_idx is not None:
             data_ref = self._value_group_idx
             is_new = False
-            if not workflow.check_parameter_group_exists(data_ref):
+            if not workflow.check_parameters_exist(data_ref):
                 raise RuntimeError(
-                    f"{self.__class__.__name__} has a parameter group index "
+                    f"{self.__class__.__name__} has a data reference "
                     f"({data_ref}), but does not exist in the workflow."
                 )
             # TODO: log if already persistent.
@@ -618,32 +579,51 @@ class _FileContentsSpecifier(JSONLike):
             self._workflow = workflow
             self._path = None
             self._contents = None
-            self._extension = None
-            self._store_contents = None
+            self._extension = ""
+            self._store_contents = True
 
         return (self.normalised_path, [data_ref], is_new)
 
-    def _get_value(self, value_name=None):
+    @overload
+    def _get_value(self, value_name: None = None) -> dict[str, Any]:
+        ...
+
+    @overload
+    def _get_value(self, value_name: str) -> Any:
+        ...
+
+    def _get_value(self, value_name: str | None = None) -> Any:
         # TODO: fix
+        assert self._value_group_idx is None
         if self._value_group_idx is not None:
-            grp = self.workflow.get_zarr_parameter_group(self._value_group_idx)
+            from ..persistence.zarr import ZarrPersistentStore
+
+            assert isinstance(self.workflow._store, ZarrPersistentStore)
+            # FIXME: Next two lines are both thoroughly broken, but at least resolve to something
+            grp = self.workflow._store._get_parameter_group(self._value_group_idx)
             val = zarr_decode(grp)
         else:
             val = self._get_members(ensure_contents=(value_name == "contents"))
         if value_name:
-            val = val.get(value_name)
+            return val.get(value_name)
 
         return val
 
-    def read_contents(self):
+    def read_contents(self) -> str:
         """
         Get the actual contents of the file.
         """
-        with self.path.open("r") as fh:
+        with self.__path.open("r") as fh:
             return fh.read()
 
     @property
-    def path(self):
+    def __path(self) -> Path:
+        path = self._get_value("path")
+        assert path is not None
+        return Path(path)
+
+    @property
+    def path(self) -> Path | None:
         """
         The path to the file.
         """
@@ -651,42 +631,44 @@ class _FileContentsSpecifier(JSONLike):
         return Path(path) if path else None
 
     @property
-    def store_contents(self):
+    def store_contents(self) -> Any:
         """
         Whether the file's contents are stored in the workflow's persistent store.
         """
         return self._get_value("store_contents")
 
     @property
-    def contents(self):
+    def contents(self) -> str:
         """
         The contents of the file.
         """
         if self.store_contents:
-            contents = self._get_value("contents")
+            return self._get_value("contents")
         else:
-            contents = self.read_contents()
-
-        return contents
+            return self.read_contents()
 
     @property
-    def extension(self):
+    def extension(self) -> str:
         """
         The extension of the file.
         """
         return self._get_value("extension")
 
     @property
-    def workflow(self) -> app.Workflow:
+    def workflow(self) -> Workflow:
         """
         The owning workflow.
         """
         if self._workflow:
             return self._workflow
         elif self._element_set:
-            return self._element_set.task_template.workflow_template.workflow
+            w_tmpl = self._element_set.task_template.workflow_template
+            if w_tmpl and w_tmpl.workflow:
+                return w_tmpl.workflow
+        raise NotImplementedError
 
 
+@hydrate
 class InputFile(_FileContentsSpecifier):
     """
     An input file.
@@ -705,7 +687,7 @@ class InputFile(_FileContentsSpecifier):
         Are the file's contents to be cached in the workflow persistent store?
     """
 
-    _child_objects = (
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
         ChildObjectSpec(
             name="file",
             class_name="FileSpec",
@@ -716,30 +698,29 @@ class InputFile(_FileContentsSpecifier):
 
     def __init__(
         self,
-        file: Union[app.FileSpec, str],
-        path: Optional[Union[Path, str]] = None,
-        contents: Optional[str] = None,
-        extension: Optional[str] = "",
-        store_contents: Optional[bool] = True,
-    ):
-        #: What file is this?
-        self.file = file
-        if not isinstance(self.file, FileSpec):
-            self.file = self.app.command_files.get(self.file.label)
+        file: FileSpec | str,
+        path: Path | str | None = None,
+        contents: str | None = None,
+        extension: str = "",
+        store_contents: bool = True,
+    ) -> None:
+        if not isinstance(file, FileSpec):
+            files: CommandFilesList = self._app.command_files
+            self.file = files.get(file)
+        else:
+            self.file = file
 
         super().__init__(path, contents, extension, store_contents)
 
-    def to_dict(self):
-        dct = super().to_dict()
-        return dct
-
-    def _get_members(self, ensure_contents=False, use_file_label=False):
+    def _get_members(
+        self, ensure_contents: bool = False, use_file_label: bool = False
+    ) -> dict[str, Any]:
         out = super()._get_members(ensure_contents)
         if use_file_label:
             out["file"] = self.file.label
         return out
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         val_grp_idx = ""
         if self._value_group_idx is not None:
             val_grp_idx = f", value_group_idx={self._value_group_idx}"
@@ -757,24 +738,18 @@ class InputFile(_FileContentsSpecifier):
         )
 
     @property
-    def normalised_files_path(self):
+    def normalised_files_path(self) -> str:
         """
         Standard name for the file within the workflow.
         """
         return self.file.label
 
     @property
-    def normalised_path(self):
-        """
-        Full workflow value path to the file.
-
-        Note
-        ----
-        This is not the same as the path in the filesystem.
-        """
+    def normalised_path(self) -> str:
         return f"input_files.{self.normalised_files_path}"
 
 
+@hydrate
 class InputFileGeneratorSource(_FileContentsSpecifier):
     """
     The source of code for use in an input file generator.
@@ -784,7 +759,7 @@ class InputFileGeneratorSource(_FileContentsSpecifier):
     generator:
         How to generate the file.
     path:
-        Path to the file.
+        Path to the file to generate.
     contents:
         Contents of the file. Only used when recreating this object.
     extension:
@@ -793,9 +768,9 @@ class InputFileGeneratorSource(_FileContentsSpecifier):
 
     def __init__(
         self,
-        generator: app.InputFileGenerator,
-        path: Union[Path, str] = None,
-        contents: str = None,
+        generator: InputFileGenerator,
+        path: Path | str | None = None,
+        contents: str | None = None,
         extension: str = "",
     ):
         #: How to generate the file.
@@ -803,6 +778,7 @@ class InputFileGeneratorSource(_FileContentsSpecifier):
         super().__init__(path, contents, extension)
 
 
+@hydrate
 class OutputFileParserSource(_FileContentsSpecifier):
     """
     The source of code for use in an output file parser.
@@ -812,7 +788,7 @@ class OutputFileParserSource(_FileContentsSpecifier):
     parser:
         How to parse the file.
     path: Path
-        Path to the file.
+        Path to the file to parse.
     contents:
         Contents of the file. Only used when recreating this object.
     extension:
@@ -821,9 +797,9 @@ class OutputFileParserSource(_FileContentsSpecifier):
 
     def __init__(
         self,
-        parser: app.OutputFileParser,
-        path: Union[Path, str] = None,
-        contents: str = None,
+        parser: OutputFileParser,
+        path: Path | str | None = None,
+        contents: str | None = None,
         extension: str = "",
     ):
         #: How to parse the file.