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

hpcflow/sdk/core/element.py

@@ -5,16 +5,16 @@ Elements are components of tasks.
 from __future__ import annotations
 import copy
 from dataclasses import dataclass, field
+from itertools import chain
 import os
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import cast, overload, TYPE_CHECKING
 
-from valida.conditions import ConditionLike
-from valida.rules import Rule
-
-from hpcflow.sdk import app
+from hpcflow.sdk.core.enums import ParallelMode
 from hpcflow.sdk.core.errors import UnsupportedOSError, UnsupportedSchedulerError
 from hpcflow.sdk.core.json_like import ChildObjectSpec, JSONLike
-from hpcflow.sdk.core.parallel import ParallelMode
+from hpcflow.sdk.core.loop_cache import LoopIndex
+from hpcflow.sdk.typing import hydrate
+from hpcflow.sdk.core.app_aware import AppAware
 from hpcflow.sdk.core.utils import (
     check_valid_py_identifier,
     dict_values_process_flat,
@@ -24,75 +24,77 @@ from hpcflow.sdk.core.utils import (
 from hpcflow.sdk.log import TimeIt
 from hpcflow.sdk.submission.shells import get_shell
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Mapping, Sequence
+    from typing import Any, ClassVar, Literal
+    from ..app import BaseApp
+    from ..typing import DataIndex, ParamSource
+    from .actions import Action, ElementAction, ElementActionRun
+    from .parameters import InputSource, ParameterPath, InputValue, ResourceSpec
+    from .rule import Rule
+    from .task import WorkflowTask, ElementSet
+    from .workflow import Workflow
 
-class _ElementPrefixedParameter:
-    _app_attr = "_app"
 
+class _ElementPrefixedParameter(AppAware):
     def __init__(
         self,
         prefix: str,
-        element_iteration: Optional[app.Element] = None,
-        element_action: Optional[app.ElementAction] = None,
-        element_action_run: Optional[app.ElementActionRun] = None,
+        element_iteration: ElementIteration | None = None,
+        element_action: ElementAction | None = None,
+        element_action_run: ElementActionRun | None = None,
     ) -> None:
         self._prefix = prefix
         self._element_iteration = element_iteration
         self._element_action = element_action
         self._element_action_run = element_action_run
 
-        self._prefixed_names_unlabelled = None  # assigned on first access
+        # assigned on first access
+        self._prefixed_names_unlabelled: Mapping[str, Sequence[str]] | None = None
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> ElementParameter | Mapping[str, ElementParameter]:
         if name not in self.prefixed_names_unlabelled:
             raise ValueError(
                 f"No {self._prefix} named {name!r}. Available {self._prefix} are: "
                 f"{self.prefixed_names_unlabelled_str}."
             )
 
-        labels = self.prefixed_names_unlabelled.get(name)
-        if labels:
+        if labels := self.prefixed_names_unlabelled.get(name):
             # is multiple; return a dict of `ElementParameter`s
-            out = {}
-            for label_i in labels:
-                path_i = f"{self._prefix}.{name}[{label_i}]"
-                out[label_i] = self._app.ElementParameter(
-                    path=path_i,
-                    task=self._task,
-                    parent=self._parent,
-                    element=self._element_iteration_obj,
-                )
-
+            return {
+                label_i: self.__parameter(f"{self._prefix}.{name}[{label_i}]")
+                for label_i in labels
+            }
         else:
             # could be labelled still, but with `multiple=False`
-            path_i = f"{self._prefix}.{name}"
-            out = self._app.ElementParameter(
-                path=path_i,
-                task=self._task,
-                parent=self._parent,
-                element=self._element_iteration_obj,
-            )
-        return out
+            return self.__parameter(f"{self._prefix}.{name}")
 
-    def __dir__(self):
-        return super().__dir__() + self.prefixed_names_unlabelled
+    def __dir__(self) -> Iterator[str]:
+        yield from super().__dir__()
+        yield from self.prefixed_names_unlabelled
 
     @property
-    def _parent(self):
-        return self._element_iteration or self._element_action or self._element_action_run
-
-    @property
-    def _element_iteration_obj(self):
-        if self._element_iteration:
-            return self._element_iteration
-        else:
-            return self._parent.element_iteration
+    def __parent(self) -> ElementIteration | ElementActionRun | ElementAction:
+        p = self._element_iteration or self._element_action or self._element_action_run
+        assert p is not None
+        return p
+
+    def __parameter(self, name: str) -> ElementParameter:
+        """Manufacture an ElementParameter with the given name."""
+        p = self.__parent
+        return self._app.ElementParameter(
+            path=name,
+            task=self._task,
+            parent=p,
+            element=p if isinstance(p, ElementIteration) else p.element_iteration,
+        )
 
     @property
-    def _task(self):
-        return self._parent.task
+    def _task(self) -> WorkflowTask:
+        return self.__parent.task
 
     @property
-    def prefixed_names_unlabelled(self) -> Dict[str, List[str]]:
+    def prefixed_names_unlabelled(self) -> Mapping[str, Sequence[str]]:
         """
         A mapping between input types and associated labels.
 
@@ -101,45 +103,40 @@ class _ElementPrefixedParameter:
 
         """
         if self._prefixed_names_unlabelled is None:
-            self._prefixed_names_unlabelled = self._get_prefixed_names_unlabelled()
+            self._prefixed_names_unlabelled = self.__get_prefixed_names_unlabelled()
         return self._prefixed_names_unlabelled
 
     @property
-    def prefixed_names_unlabelled_str(self):
+    def prefixed_names_unlabelled_str(self) -> str:
         """
         A description of the prefixed names.
         """
-        return ", ".join(i for i in self.prefixed_names_unlabelled)
+        return ", ".join(self.prefixed_names_unlabelled)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         # If there are one or more labels present, then replace with a single name
         # indicating there could be multiple (using a `*` prefix):
-        names = []
-        for unlabelled, labels in self.prefixed_names_unlabelled.items():
-            name_i = unlabelled
-            if labels:
-                name_i = "*" + name_i
-            names.append(name_i)
-        names_str = ", ".join(i for i in names)
-        return f"{self.__class__.__name__}({names_str})"
-
-    def _get_prefixed_names(self):
-        return sorted(self._parent.get_parameter_names(self._prefix))
-
-    def _get_prefixed_names_unlabelled(self) -> Dict[str, List[str]]:
-        names = self._get_prefixed_names()
-        all_names = {}
-        for i in list(names):
-            if "[" in i:
-                unlab_i, label_i = split_param_label(i)
-                if unlab_i not in all_names:
-                    all_names[unlab_i] = []
-                all_names[unlab_i].append(label_i)
+        names = ", ".join(
+            "*" + unlabelled if labels else unlabelled
+            for unlabelled, labels in self.prefixed_names_unlabelled.items()
+        )
+        return f"{self.__class__.__name__}({names})"
+
+    def _get_prefixed_names(self) -> list[str]:
+        return sorted(self.__parent.get_parameter_names(self._prefix))
+
+    def __get_prefixed_names_unlabelled(self) -> Mapping[str, Sequence[str]]:
+        all_names: dict[str, list[str]] = {}
+        for name in self._get_prefixed_names():
+            if "[" in name:
+                unlab_i, label_i = split_param_label(name)
+                if unlab_i is not None and label_i is not None:
+                    all_names.setdefault(unlab_i, []).append(label_i)
             else:
-                all_names[i] = []
+                all_names[name] = []
         return all_names
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[ElementParameter | Mapping[str, ElementParameter]]:
         for name in self.prefixed_names_unlabelled:
             yield getattr(self, name)
 
@@ -160,9 +157,9 @@ class ElementInputs(_ElementPrefixedParameter):
 
     def __init__(
         self,
-        element_iteration: Optional[app.ElementIteration] = None,
-        element_action: Optional[app.ElementAction] = None,
-        element_action_run: Optional[app.ElementActionRun] = None,
+        element_iteration: ElementIteration | None = None,
+        element_action: ElementAction | None = None,
+        element_action_run: ElementActionRun | None = None,
     ) -> None:
         super().__init__("inputs", element_iteration, element_action, element_action_run)
 
@@ -183,9 +180,9 @@ class ElementOutputs(_ElementPrefixedParameter):
 
     def __init__(
         self,
-        element_iteration: Optional[app.ElementIteration] = None,
-        element_action: Optional[app.ElementAction] = None,
-        element_action_run: Optional[app.ElementActionRun] = None,
+        element_iteration: ElementIteration | None = None,
+        element_action: ElementAction | None = None,
+        element_action_run: ElementActionRun | None = None,
     ) -> None:
         super().__init__("outputs", element_iteration, element_action, element_action_run)
 
@@ -206,9 +203,9 @@ class ElementInputFiles(_ElementPrefixedParameter):
 
     def __init__(
         self,
-        element_iteration: Optional[app.ElementIteration] = None,
-        element_action: Optional[app.ElementAction] = None,
-        element_action_run: Optional[app.ElementActionRun] = None,
+        element_iteration: ElementIteration | None = None,
+        element_action: ElementAction | None = None,
+        element_action_run: ElementActionRun | None = None,
     ) -> None:
         super().__init__(
             "input_files", element_iteration, element_action, element_action_run
@@ -231,9 +228,9 @@ class ElementOutputFiles(_ElementPrefixedParameter):
 
     def __init__(
         self,
-        element_iteration: Optional[app.ElementIteration] = None,
-        element_action: Optional[app.ElementAction] = None,
-        element_action_run: Optional[app.ElementActionRun] = None,
+        element_iteration: ElementIteration | None = None,
+        element_action: ElementAction | None = None,
+        element_action_run: ElementActionRun | None = None,
     ) -> None:
         super().__init__(
             "output_files", element_iteration, element_action, element_action_run
@@ -241,6 +238,7 @@ class ElementOutputFiles(_ElementPrefixedParameter):
 
 
 @dataclass
+@hydrate
 class ElementResources(JSONLike):
     """
     The resources an element requires.
@@ -299,52 +297,53 @@ class ElementResources(JSONLike):
     # TODO: how to specify e.g. high-memory requirement?
 
     #: Which scratch space to use.
-    scratch: Optional[str] = None
+    scratch: str | None = None
     #: Which parallel mode to use.
-    parallel_mode: Optional[ParallelMode] = None
+    parallel_mode: ParallelMode | None = None
     #: How many cores to request.
-    num_cores: Optional[int] = None
+    num_cores: int | None = None
     #: How many cores per compute node to request.
-    num_cores_per_node: Optional[int] = None
+    num_cores_per_node: int | None = None
     #: How many threads to request.
-    num_threads: Optional[int] = None
+    num_threads: int | None = None
     #: How many compute nodes to request.
-    num_nodes: Optional[int] = None
+    num_nodes: int | None = None
 
     #: Which scheduler to use.
-    scheduler: Optional[str] = None
+    scheduler: str | None = None
     #: Which system shell to use.
-    shell: Optional[str] = None
+    shell: str | None = None
     #: Whether to use array jobs.
-    use_job_array: Optional[bool] = None
+    use_job_array: bool | None = None
     #: If using array jobs, up to how many items should be in the job array.
-    max_array_items: Optional[int] = None
+    max_array_items: int | None = None
     #: How long to run for.
-    time_limit: Optional[str] = None
+    time_limit: str | None = None
+
     #: Additional arguments to pass to the scheduler.
-    scheduler_args: Optional[Dict] = None
+    scheduler_args: dict[str, Any] = field(default_factory=dict)
     #: Additional arguments to pass to the shell.
-    shell_args: Optional[Dict] = None
+    shell_args: dict[str, Any] = field(default_factory=dict)
     #: Which OS to use.
-    os_name: Optional[str] = None
+    os_name: str | None = None
     #: Which execution environments to use.
-    environments: Optional[Dict] = None
+    environments: dict[str, dict[str, Any]] | None = None
 
     # SGE scheduler specific:
     #: Which SGE parallel environment to request.
-    SGE_parallel_env: str = None
+    SGE_parallel_env: str | None = None
 
     # SLURM scheduler specific:
     #: Which SLURM partition to request.
-    SLURM_partition: str = None
+    SLURM_partition: str | None = None
     #: How many SLURM tasks to request.
-    SLURM_num_tasks: str = None
+    SLURM_num_tasks: int | None = None
     #: How many SLURM tasks per compute node to request.
-    SLURM_num_tasks_per_node: str = None
+    SLURM_num_tasks_per_node: int | None = None
     #: How many compute nodes to request.
-    SLURM_num_nodes: str = None
+    SLURM_num_nodes: int | None = None
     #: How many CPU cores to ask for per SLURM task.
-    SLURM_num_cpus_per_task: str = None
+    SLURM_num_cpus_per_task: int | None = None
 
     def __post_init__(self):
         if (
@@ -358,38 +357,30 @@ class ElementResources(JSONLike):
         if self.parallel_mode:
             self.parallel_mode = get_enum_by_name_or_val(ParallelMode, self.parallel_mode)
 
-        self.scheduler_args = self.scheduler_args or {}
-        self.shell_args = self.shell_args or {}
-
-    def __eq__(self, other) -> bool:
-        if type(self) != type(other):
-            return False
-        else:
-            return self.__dict__ == other.__dict__
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 
-    def get_jobscript_hash(self):
+    def get_jobscript_hash(self) -> int:
         """Get hash from all arguments that distinguish jobscripts."""
 
-        def _hash_dict(d):
+        def _hash_dict(d: dict) -> int:
             if not d:
                 return -1
             keys, vals = zip(*d.items())
             return hash(tuple((keys, vals)))
 
-        exclude = ("time_limit",)
+        exclude = {"time_limit"}
         dct = {k: copy.deepcopy(v) for k, v in self.__dict__.items() if k not in exclude}
 
         scheduler_args = dct["scheduler_args"]
         shell_args = dct["shell_args"]
         envs = dct["environments"]
 
-        if isinstance(scheduler_args, dict):
-            if "options" in scheduler_args:
-                dct["scheduler_args"]["options"] = _hash_dict(scheduler_args["options"])
-            dct["scheduler_args"] = _hash_dict(dct["scheduler_args"])
+        if "options" in scheduler_args:
+            dct["scheduler_args"]["options"] = _hash_dict(scheduler_args["options"])
+        dct["scheduler_args"] = _hash_dict(dct["scheduler_args"])
 
-        if isinstance(shell_args, dict):
-            dct["shell_args"] = _hash_dict(shell_args)
+        dct["shell_args"] = _hash_dict(shell_args)
 
         if isinstance(envs, dict):
             for k, v in envs.items():
@@ -401,7 +392,7 @@ class ElementResources(JSONLike):
     @property
     def is_parallel(self) -> bool:
         """Returns True if any scheduler-agnostic arguments indicate a parallel job."""
-        return (
+        return bool(
             (self.num_cores and self.num_cores != 1)
             or (self.num_cores_per_node and self.num_cores_per_node != 1)
             or (self.num_nodes and self.num_nodes != 1)
@@ -411,7 +402,7 @@ class ElementResources(JSONLike):
     @property
     def SLURM_is_parallel(self) -> bool:
         """Returns True if any SLURM-specific arguments indicate a parallel job."""
-        return (
+        return bool(
             (self.SLURM_num_tasks and self.SLURM_num_tasks != 1)
             or (self.SLURM_num_tasks_per_node and self.SLURM_num_tasks_per_node != 1)
             or (self.SLURM_num_nodes and self.SLURM_num_nodes != 1)
@@ -419,34 +410,34 @@ class ElementResources(JSONLike):
         )
 
     @staticmethod
-    def get_env_instance_filterable_attributes() -> Tuple[str]:
+    def get_env_instance_filterable_attributes() -> tuple[str, ...]:
         """Get a tuple of resource attributes that are used to filter environment
         executable instances at submit- and run-time."""
         return ("num_cores",)  # TODO: filter on `parallel_mode` later
 
     @staticmethod
-    def get_default_os_name():
+    def get_default_os_name() -> str:
         """
         Get the default value for OS name.
         """
         return os.name
 
     @classmethod
-    def get_default_shell(cls):
+    def get_default_shell(cls) -> str:
         """
         Get the default value for name.
         """
-        return cls.app.config.default_shell
+        return cls._app.config.default_shell
 
     @classmethod
-    def get_default_scheduler(cls, os_name, shell_name):
+    def get_default_scheduler(cls, os_name: str, shell_name: str) -> str:
         """
         Get the default value for scheduler.
         """
         if os_name == "nt" and "wsl" in shell_name:
             # provide a "*_posix" default scheduler on windows if shell is WSL:
             return "direct_posix"
-        return cls.app.config.default_scheduler
+        return cls._app.config.default_scheduler
 
     def set_defaults(self):
         """
@@ -461,13 +452,13 @@ class ElementResources(JSONLike):
 
         # merge defaults shell args from config:
         self.shell_args = {
-            **self.app.config.shells.get(self.shell, {}).get("defaults", {}),
+            **self._app.config.shells.get(self.shell, {}).get("defaults", {}),
             **self.shell_args,
         }
 
         # "direct_posix" scheduler is valid on Windows if using WSL:
         cfg_lookup = f"{self.scheduler}_posix" if "wsl" in self.shell else self.scheduler
-        cfg_sched = copy.deepcopy(self.app.config.schedulers.get(cfg_lookup, {}))
+        cfg_sched = copy.deepcopy(self._app.config.schedulers.get(cfg_lookup, {}))
 
         # merge defaults scheduler args from config:
         cfg_defs = cfg_sched.get("defaults", {})
@@ -481,10 +472,10 @@ class ElementResources(JSONLike):
         supported on this machine (as specified by the app configuration)."""
         if self.os_name != os.name:
             raise UnsupportedOSError(os_name=self.os_name)
-        if self.scheduler not in self.app.config.schedulers:
+        if self.scheduler not in self._app.config.schedulers:
             raise UnsupportedSchedulerError(
                 scheduler=self.scheduler,
-                supported=self.app.config.schedulers,
+                supported=self._app.config.schedulers,
             )
         # might raise `UnsupportedShellError`:
         get_shell(shell_name=self.shell, os_name=self.os_name)
@@ -495,11 +486,11 @@ class ElementResources(JSONLike):
             key = tuple(self.scheduler.split("_"))
         else:
             key = (self.scheduler.lower(), self.os_name.lower())
-        scheduler_cls = self.app.scheduler_lookup[key]
-        scheduler_cls.process_resources(self, self.app.config.schedulers[self.scheduler])
+        scheduler_cls = self._app.scheduler_lookup[key]
+        scheduler_cls.process_resources(self, self._app.config.schedulers[self.scheduler])
 
 
-class ElementIteration:
+class ElementIteration(AppAware):
     """
     A particular iteration of an element.
 
@@ -527,38 +518,36 @@ class ElementIteration:
         Indexing information from the loop.
     """
 
-    _app_attr = "app"
-
     def __init__(
         self,
         id_: int,
         is_pending: bool,
         index: int,
-        element: app.Element,
-        data_idx: Dict,
+        element: Element,
+        data_idx: DataIndex,
         EARs_initialised: bool,
-        EAR_IDs: Dict[int, int],
-        EARs: Union[List[Dict], None],
-        schema_parameters: List[str],
-        loop_idx: Dict,
+        EAR_IDs: dict[int, list[int]],
+        EARs: dict[int, dict[Mapping[str, Any], Any]] | None,
+        schema_parameters: list[str],
+        loop_idx: Mapping[str, int],
     ):
         self._id = id_
         self._is_pending = is_pending
         self._index = index
         self._element = element
         self._data_idx = data_idx
-        self._loop_idx = loop_idx
+        self._loop_idx = LoopIndex(loop_idx)
         self._schema_parameters = schema_parameters
         self._EARs_initialised = EARs_initialised
         self._EARs = EARs
         self._EAR_IDs = EAR_IDs
 
         # assigned on first access of corresponding properties:
-        self._inputs = None
-        self._outputs = None
-        self._input_files = None
-        self._output_files = None
-        self._action_objs = None
+        self._inputs: ElementInputs | None = None
+        self._outputs: ElementOutputs | None = None
+        self._input_files: ElementInputFiles | None = None
+        self._output_files: ElementOutputFiles | None = None
+        self._action_objs: dict[int, ElementAction] | None = None
 
     def __repr__(self):
         return (
@@ -569,24 +558,24 @@ class ElementIteration:
         )
 
     @property
-    def data_idx(self):
+    def data_idx(self) -> DataIndex:
         """The overall element iteration data index, before resolution of EARs."""
         return self._data_idx
 
     @property
-    def EARs_initialised(self):
+    def EARs_initialised(self) -> bool:
         """Whether or not the EARs have been initialised."""
         return self._EARs_initialised
 
     @property
-    def element(self):
+    def element(self) -> Element:
         """
         The element this is an iteration of.
         """
         return self._element
 
     @property
-    def index(self):
+    def index(self) -> int:
         """
         The index of this iteration in its parent element.
         """
@@ -607,108 +596,104 @@ class ElementIteration:
         return self._is_pending
 
     @property
-    def task(self):
+    def task(self) -> WorkflowTask:
         """
         The task this is an iteration of an element for.
         """
         return self.element.task
 
     @property
-    def workflow(self):
+    def workflow(self) -> Workflow:
         """
         The workflow this is a part of.
         """
         return self.element.workflow
 
     @property
-    def loop_idx(self) -> Dict[str, int]:
+    def loop_idx(self) -> LoopIndex[str, int]:
         """
         Indexing information from the loop.
         """
         return self._loop_idx
 
     @property
-    def schema_parameters(self) -> List[str]:
+    def schema_parameters(self) -> Sequence[str]:
         """
         Parameters from the schema.
         """
         return self._schema_parameters
 
     @property
-    def EAR_IDs(self) -> Dict[int, int]:
+    def EAR_IDs(self) -> Mapping[int, Sequence[int]]:
         """
         Mapping from iteration number to EAR ID, where known.
         """
         return self._EAR_IDs
 
     @property
-    def EAR_IDs_flat(self):
+    def EAR_IDs_flat(self) -> Iterable[int]:
         """
         The EAR IDs.
         """
-        return [j for i in self.EAR_IDs.values() for j in i]
+        return chain.from_iterable(self.EAR_IDs.values())
 
     @property
-    def actions(self) -> Dict[app.ElementAction]:
+    def actions(self) -> Mapping[int, ElementAction]:
         """
         The actions of this iteration.
         """
         if self._action_objs is None:
             self._action_objs = {
-                act_idx: self.app.ElementAction(
-                    element_iteration=self,
-                    action_idx=act_idx,
-                    runs=runs,
-                )
+                act_idx: self._app.ElementAction(self, act_idx, runs)
                 for act_idx, runs in (self._EARs or {}).items()
             }
         return self._action_objs
 
     @property
-    def action_runs(self) -> List[app.ElementActionRun]:
+    def action_runs(self) -> Sequence[ElementActionRun]:
         """
         A list of element action runs, where only the final run is taken for each
         element action.
         """
-        return [i.runs[-1] for i in self.actions.values()]
+        return [act.runs[-1] for act in self.actions.values()]
 
     @property
-    def inputs(self) -> app.ElementInputs:
+    def inputs(self) -> ElementInputs:
         """
         The inputs to this element.
         """
         if not self._inputs:
-            self._inputs = self.app.ElementInputs(element_iteration=self)
+            self._inputs = self._app.ElementInputs(element_iteration=self)
         return self._inputs
 
     @property
-    def outputs(self) -> app.ElementOutputs:
+    def outputs(self) -> ElementOutputs:
         """
         The outputs from this element.
         """
         if not self._outputs:
-            self._outputs = self.app.ElementOutputs(element_iteration=self)
+            self._outputs = self._app.ElementOutputs(element_iteration=self)
         return self._outputs
 
     @property
-    def input_files(self) -> app.ElementInputFiles:
+    def input_files(self) -> ElementInputFiles:
         """
         The input files to this element.
         """
         if not self._input_files:
-            self._input_files = self.app.ElementInputFiles(element_iteration=self)
+            self._input_files = self._app.ElementInputFiles(element_iteration=self)
         return self._input_files
 
     @property
-    def output_files(self) -> app.ElementOutputFiles:
+    def output_files(self) -> ElementOutputFiles:
         """
         The output files from this element.
         """
         if not self._output_files:
-            self._output_files = self.app.ElementOutputFiles(element_iteration=self)
+            self._output_files = self._app.ElementOutputFiles(element_iteration=self)
         return self._output_files
 
-    def get_parameter_names(self, prefix: str) -> List[str]:
+    def get_parameter_names(self, prefix: str) -> list[str]:
         """Get parameter types associated with a given prefix.
 
         For example, with the prefix "inputs", this would return `['p1', 'p2']` for a task
@@ -728,19 +713,19 @@ class ElementIteration:
 
         """
         single_label_lookup = self.task.template._get_single_label_lookup("inputs")
-        return list(
-            ".".join(single_label_lookup.get(i, i).split(".")[1:])
-            for i in self.schema_parameters
-            if i.startswith(prefix)
-        )
+        return [
+            ".".join(single_label_lookup.get(param_name, param_name).split(".")[1:])
+            for param_name in self.schema_parameters
+            if param_name.startswith(prefix)
+        ]
 
     @TimeIt.decorator
     def get_data_idx(
         self,
-        path: str = None,
-        action_idx: int = None,
+        path: str | None = None,
+        action_idx: int | None = None,
         run_idx: int = -1,
-    ) -> Dict[str, int]:
+    ) -> DataIndex:
         """
         Get the data index.
 
@@ -766,8 +751,7 @@ class ElementIteration:
             data_idx = {}
             for action in self.actions.values():
                 for k, v in action.runs[run_idx].data_idx.items():
-                    is_input = k.startswith("inputs")
-                    if (is_input and k not in data_idx) or not is_input:
+                    if not k.startswith("inputs") or k not in data_idx:
                         data_idx[k] = v
 
         else:
@@ -779,16 +763,85 @@ class ElementIteration:
 
         return copy.deepcopy(data_idx)
 
+    def __get_parameter_sources(
+        self, data_idx: DataIndex, filter_type: str | None, use_task_index: bool
+    ) -> Mapping[str, ParamSource | list[ParamSource]]:
+        # the value associated with `repeats.*` is the repeats index, not a parameter ID:
+        for k in tuple(data_idx):
+            if k.startswith("repeats."):
+                data_idx.pop(k)
+
+        out: Mapping[str, ParamSource | list[ParamSource]] = dict_values_process_flat(
+            data_idx,
+            callable=self.workflow.get_parameter_sources,
+        )
+
+        if use_task_index:
+            for k, v in out.items():
+                assert isinstance(v, dict)
+                if (insert_ID := v.pop("task_insert_ID", None)) is not None:
+                    # Modify the contents of out
+                    v["task_idx"] = self.workflow.tasks.get(insert_ID=insert_ID).index
+
+        if not filter_type:
+            return out
+
+        # Filter to just the elements that have the right type property
+        filtered = (
+            (k, self.__filter_param_source_by_type(v, filter_type))
+            for k, v in out.items()
+        )
+        return {k: v for k, v in filtered if v is not None}
+
+    @staticmethod
+    def __filter_param_source_by_type(
+        value: ParamSource | list[ParamSource], filter_type: str
+    ) -> ParamSource | list[ParamSource] | None:
+        if isinstance(value, list):
+            if sources := [src for src in value if src["type"] == filter_type]:
+                return sources
+        else:
+            if value["type"] == filter_type:
+                return value
+        return None
+
+    @overload
+    def get_parameter_sources(
+        self,
+        path: str | None,
+        *,
+        action_idx: int | None,
+        run_idx: int = -1,
+        typ: str | None = None,
+        as_strings: Literal[True],
+        use_task_index: bool = False,
+    ) -> Mapping[str, str]:
+        ...
+
+    @overload
+    def get_parameter_sources(
+        self,
+        path: str | None = None,
+        *,
+        action_idx: int | None = None,
+        run_idx: int = -1,
+        typ: str | None = None,
+        as_strings: Literal[False] = False,
+        use_task_index: bool = False,
+    ) -> Mapping[str, ParamSource | list[ParamSource]]:
+        ...
+
     @TimeIt.decorator
     def get_parameter_sources(
         self,
-        path: str = None,
-        action_idx: int = None,
+        path: str | None = None,
+        *,
+        action_idx: int | None = None,
         run_idx: int = -1,
-        typ: str = None,
+        typ: str | None = None,
         as_strings: bool = False,
         use_task_index: bool = False,
-    ) -> Dict[str, Union[str, Dict[str, Any]]]:
+    ) -> Mapping[str, str] | Mapping[str, ParamSource | list[ParamSource]]:
         """
         Get the origin of parameters.
 
@@ -799,79 +852,40 @@ class ElementIteration:
             ID.
         """
         data_idx = self.get_data_idx(path, action_idx, run_idx)
-
-        # the value associated with `repeats.*` is the repeats index, not a parameter ID:
-        for k in list(data_idx.keys()):
-            if k.startswith("repeats."):
-                data_idx.pop(k)
-
-        out = dict_values_process_flat(
-            data_idx,
-            callable=self.workflow.get_parameter_sources,
-        )
-        task_key = "task_insert_ID"
-
-        if use_task_index:
-            task_key = "task_idx"
-            out_task_idx = {}
-            for k, v in out.items():
-                insert_ID = v.pop("task_insert_ID", None)
-                if insert_ID is not None:
-                    v[task_key] = self.workflow.tasks.get(insert_ID=insert_ID).index
-                out_task_idx[k] = v
-            out = out_task_idx
-
-        if typ:
-            out_ = {}
-            for k, v in out.items():
-                is_multi = False
-                if isinstance(v, list):
-                    is_multi = True
-                else:
-                    v = [v]
-
-                sources_k = []
-                for src_i in v:
-                    if src_i["type"] == typ:
-                        if not is_multi:
-                            sources_k = src_i
-                            break
-                        else:
-                            sources_k.append(src_i)
-
-                if sources_k:
-                    out_[k] = sources_k
-
-            out = out_
-
-        if as_strings:
-            # format as a dict with compact string values
-            self_task_val = (
-                self.task.index if task_key == "task_idx" else self.task.insert_ID
-            )
-            out_strs = {}
-            for k, v in out.items():
-                if v["type"] == "local_input":
-                    if v[task_key] == self_task_val:
+        out = self.__get_parameter_sources(data_idx, typ or "", use_task_index)
+        if not as_strings:
+            return out
+
+        # format as a dict with compact string values
+        out_strs: dict[str, str] = {}
+        for k, v in out.items():
+            assert isinstance(v, dict)
+            if v["type"] == "local_input":
+                if use_task_index:
+                    if v["task_idx"] == self.task.index:
                         out_strs[k] = "local"
                     else:
-                        out_strs[k] = f"task.{v[task_key]}.input"
-                elif v["type"] == "default_input":
-                    out_strs == "default"
+                        out_strs[k] = f"task.{v['task_idx']}.input"
                 else:
-                    out_strs[k] = (
-                        f"task.{v[task_key]}.element.{v['element_idx']}."
-                        f"action.{v['action_idx']}.run.{v['run_idx']}"
-                    )
-            out = out_strs
-
-        return out
+                    if v["task_insert_ID"] == self.task.insert_ID:
+                        out_strs[k] = "local"
+                    else:
+                        out_strs[k] = f"task.{v['task_insert_ID']}.input"
+            elif v["type"] == "default_input":
+                out_strs == "default"
+            else:
+                idx = v["task_idx"] if use_task_index else v["task_insert_ID"]
+                out_strs[k] = (
+                    f"task.{idx}.element.{v['element_idx']}."
+                    f"action.{v['action_idx']}.run.{v['run_idx']}"
+                )
+        return out_strs
 
     @TimeIt.decorator
     def get(
         self,
-        path: str = None,
-        action_idx: int = None,
+        path: str | None = None,
+        action_idx: int | None = None,
         run_idx: int = -1,
         default: Any = None,
         raise_on_missing: bool = False,
@@ -888,12 +902,11 @@ class ElementIteration:
         if single_label_lookup:
             # For any non-multiple `SchemaParameter`s of this task with non-empty labels,
             # remove the trivial label:
-            for key in list(data_idx.keys()):
+            for key in tuple(data_idx):
                 if (path or "").startswith(key):
                     # `path` uses labelled type, so no need to convert to non-labelled
                     continue
-                lookup_val = single_label_lookup.get(key)
-                if lookup_val:
+                if lookup_val := single_label_lookup.get(key):
                     data_idx[lookup_val] = data_idx.pop(key)
 
         return self.task._get_merged_parameter_data(
@@ -904,203 +917,286 @@ class ElementIteration:
             default=default,
         )
 
+    @overload
+    def get_EAR_dependencies(
+        self,
+        as_objects: Literal[False] = False,
+    ) -> set[int]:
+        ...
+
+    @overload
+    def get_EAR_dependencies(
+        self,
+        as_objects: Literal[True],
+    ) -> list[ElementActionRun]:
+        ...
+
     @TimeIt.decorator
     def get_EAR_dependencies(
         self,
-        as_objects: Optional[bool] = False,
-    ) -> List[Union[int, app.ElementActionRun]]:
+        as_objects: bool = False,
+    ) -> set[int] | list[ElementActionRun]:
         """Get EARs that this element iteration depends on (excluding EARs of this element
         iteration)."""
         # TODO: test this includes EARs of upstream iterations of this iteration's element
         if self.action_runs:
-            out = sorted(
-                set(
-                    EAR_ID
-                    for i in self.action_runs
-                    for EAR_ID in i.get_EAR_dependencies(as_objects=False)
-                    if not EAR_ID in self.EAR_IDs_flat
-                )
-            )
+            EAR_IDs_set = frozenset(self.EAR_IDs_flat)
+            out = {
+                id_
+                for ear in self.action_runs
+                for id_ in ear.get_EAR_dependencies()
+                if id_ not in EAR_IDs_set
+            }
         else:
             # if an "input-only" task schema, then there will be no action runs, but the
             # ElementIteration can still depend on other EARs if inputs are sourced from
             # upstream tasks:
-            out = []
-            for src in self.get_parameter_sources(typ="EAR_output").values():
-                if not isinstance(src, list):
-                    src = [src]
-                for src_i in src:
-                    EAR_ID_i = src_i["EAR_ID"]
-                    out.append(EAR_ID_i)
-            out = sorted(set(out))
+            out = {
+                src_i["EAR_ID"]
+                for src in self.get_parameter_sources(typ="EAR_output").values()
+                for src_i in (src if isinstance(src, list) else [src])
+            }
 
         if as_objects:
-            out = self.workflow.get_EARs_from_IDs(out)
+            return self.workflow.get_EARs_from_IDs(sorted(out))
         return out
 
+    @overload
+    def get_element_iteration_dependencies(
+        self, as_objects: Literal[True]
+    ) -> list[ElementIteration]:
+        ...
+
+    @overload
+    def get_element_iteration_dependencies(
+        self, as_objects: Literal[False] = False
+    ) -> set[int]:
+        ...
+
     @TimeIt.decorator
     def get_element_iteration_dependencies(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.ElementIteration]]:
+    ) -> set[int] | list[ElementIteration]:
         """Get element iterations that this element iteration depends on."""
         # TODO: test this includes previous iterations of this iteration's element
-        EAR_IDs = self.get_EAR_dependencies(as_objects=False)
-        out = sorted(set(self.workflow.get_element_iteration_IDs_from_EAR_IDs(EAR_IDs)))
+        EAR_IDs = self.get_EAR_dependencies()
+        out = set(self.workflow.get_element_iteration_IDs_from_EAR_IDs(EAR_IDs))
         if as_objects:
-            out = self.workflow.get_element_iterations_from_IDs(out)
+            return self.workflow.get_element_iterations_from_IDs(sorted(out))
         return out
 
+    @overload
+    def get_element_dependencies(
+        self,
+        as_objects: Literal[False] = False,
+    ) -> set[int]:
+        ...
+
+    @overload
+    def get_element_dependencies(
+        self,
+        as_objects: Literal[True],
+    ) -> list[Element]:
+        ...
+
     @TimeIt.decorator
     def get_element_dependencies(
         self,
-        as_objects: Optional[bool] = False,
-    ) -> List[Union[int, app.Element]]:
+        as_objects: bool = False,
+    ) -> set[int] | list[Element]:
         """Get elements that this element iteration depends on."""
         # TODO: this will be used in viz.
-        EAR_IDs = self.get_EAR_dependencies(as_objects=False)
-        out = sorted(set(self.workflow.get_element_IDs_from_EAR_IDs(EAR_IDs)))
+        EAR_IDs = self.get_EAR_dependencies()
+        out = set(self.workflow.get_element_IDs_from_EAR_IDs(EAR_IDs))
         if as_objects:
-            out = self.workflow.get_elements_from_IDs(out)
+            return self.workflow.get_elements_from_IDs(sorted(out))
         return out
 
-    def get_input_dependencies(self) -> Dict[str, Dict]:
+    def get_input_dependencies(self) -> Mapping[str, ParamSource]:
         """Get locally defined inputs/sequences/defaults from other tasks that this
         element iteration depends on."""
-        out = {}
+        out: dict[str, ParamSource] = {}
         for k, v in self.get_parameter_sources().items():
-            if not isinstance(v, list):
-                v = [v]
-            for v_i in v:
+            for v_i in v if isinstance(v, list) else [v]:
                 if (
                     v_i["type"] in ["local_input", "default_input"]
                     and v_i["task_insert_ID"] != self.task.insert_ID
                 ):
                     out[k] = v_i
-
         return out
 
+    @overload
+    def get_task_dependencies(self, as_objects: Literal[False] = False) -> set[int]:
+        ...
+
+    @overload
+    def get_task_dependencies(self, as_objects: Literal[True]) -> list[WorkflowTask]:
+        ...
+
     def get_task_dependencies(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.WorkflowTask]]:
+    ) -> set[int] | list[WorkflowTask]:
         """Get tasks (insert ID or WorkflowTask objects) that this element iteration
         depends on.
 
         Dependencies may come from either elements from upstream tasks, or from locally
         defined inputs/sequences/defaults from upstream tasks."""
 
-        out = self.workflow.get_task_IDs_from_element_IDs(
-            self.get_element_dependencies(as_objects=False)
+        out = set(
+            self.workflow.get_task_IDs_from_element_IDs(self.get_element_dependencies())
         )
-        for i in self.get_input_dependencies().values():
-            out.append(i["task_insert_ID"])
-
-        out = sorted(set(out))
+        for p_src in self.get_input_dependencies().values():
+            out.add(p_src["task_insert_ID"])
 
         if as_objects:
-            out = [self.workflow.tasks.get(insert_ID=i) for i in out]
-
+            return [self.workflow.tasks.get(insert_ID=id_) for id_ in sorted(out)]
         return out
 
+    @property
+    def __elements(self) -> Iterator[Element]:
+        """
+        This iteration's element and its downstream elements.
+        """
+        for task in self.workflow.tasks[self.task.index :]:
+            yield from task.elements[:]
+
+    @property
+    def __iterations(self) -> Iterator[ElementIteration]:
+        """
+        This iteration and its downstream iterations.
+        """
+        for elem in self.__elements:
+            yield from elem.iterations
+
+    @overload
+    def get_dependent_EARs(self, as_objects: Literal[False] = False) -> set[int]:
+        ...
+
+    @overload
+    def get_dependent_EARs(self, as_objects: Literal[True]) -> list[ElementActionRun]:
+        ...
+
     @TimeIt.decorator
     def get_dependent_EARs(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.ElementActionRun]]:
+    ) -> set[int] | list[ElementActionRun]:
         """Get EARs of downstream iterations and tasks that depend on this element
         iteration."""
         # TODO: test this includes EARs of downstream iterations of this iteration's element
-        deps = []
-        for task in self.workflow.tasks[self.task.index :]:
-            for elem in task.elements[:]:
-                for iter_ in elem.iterations:
-                    if iter_.id_ == self.id_:
-                        # don't include EARs of this iteration
-                        continue
-                    for run in iter_.action_runs:
-                        for dep_EAR_i in run.get_EAR_dependencies(as_objects=True):
-                            # does dep_EAR_i belong to self?
-                            if dep_EAR_i.id_ in self.EAR_IDs_flat and run.id_ not in deps:
-                                deps.append(run.id_)
-        deps = sorted(deps)
+        deps: set[int] = set()
+        for iter_ in self.__iterations:
+            if iter_.id_ == self.id_:
+                # don't include EARs of this iteration
+                continue
+            for run in iter_.action_runs:
+                if run.get_EAR_dependencies().intersection(self.EAR_IDs_flat):
+                    deps.add(run.id_)
         if as_objects:
-            deps = self.workflow.get_EARs_from_IDs(deps)
-
+            return self.workflow.get_EARs_from_IDs(sorted(deps))
         return deps
 
+    @overload
+    def get_dependent_element_iterations(
+        self, as_objects: Literal[True]
+    ) -> list[ElementIteration]:
+        ...
+
+    @overload
+    def get_dependent_element_iterations(
+        self, as_objects: Literal[False] = False
+    ) -> set[int]:
+        ...
+
     @TimeIt.decorator
     def get_dependent_element_iterations(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.ElementIteration]]:
+    ) -> set[int] | list[ElementIteration]:
         """Get elements iterations of downstream iterations and tasks that depend on this
         element iteration."""
         # TODO: test this includes downstream iterations of this iteration's element?
-        deps = []
-        for task in self.workflow.tasks[self.task.index :]:
-            for elem in task.elements[:]:
-                for iter_i in elem.iterations:
-                    if iter_i.id_ == self.id_:
-                        continue
-                    for dep_iter_i in iter_i.get_element_iteration_dependencies(
-                        as_objects=True
-                    ):
-                        if dep_iter_i.id_ == self.id_ and iter_i.id_ not in deps:
-                            deps.append(iter_i.id_)
-        deps = sorted(deps)
+        deps: set[int] = set()
+        for iter_i in self.__iterations:
+            if iter_i.id_ == self.id_:
+                continue
+            if self.id_ in iter_i.get_element_iteration_dependencies():
+                deps.add(iter_i.id_)
         if as_objects:
-            deps = self.workflow.get_element_iterations_from_IDs(deps)
-
+            return self.workflow.get_element_iterations_from_IDs(sorted(deps))
         return deps
 
+    @overload
+    def get_dependent_elements(
+        self,
+        as_objects: Literal[True],
+    ) -> list[Element]:
+        ...
+
+    @overload
+    def get_dependent_elements(
+        self,
+        as_objects: Literal[False] = False,
+    ) -> set[int]:
+        ...
+
     @TimeIt.decorator
     def get_dependent_elements(
         self,
         as_objects: bool = False,
-    ) -> List[Union[int, app.Element]]:
+    ) -> set[int] | list[Element]:
         """Get elements of downstream tasks that depend on this element iteration."""
-        deps = []
+        deps: set[int] = set()
         for task in self.task.downstream_tasks:
             for element in task.elements[:]:
-                for iter_i in element.iterations:
-                    for dep_iter_i in iter_i.get_element_iteration_dependencies(
-                        as_objects=True
-                    ):
-                        if dep_iter_i.id_ == self.id_ and element.id_ not in deps:
-                            deps.append(element.id_)
-
-        deps = sorted(deps)
-        if as_objects:
-            deps = self.workflow.get_elements_from_IDs(deps)
+                if any(
+                    self.id_ in iter_i.get_element_iteration_dependencies()
+                    for iter_i in element.iterations
+                ):
+                    deps.add(element.id_)
 
+        if as_objects:
+            return self.workflow.get_elements_from_IDs(sorted(deps))
         return deps
 
+    @overload
+    def get_dependent_tasks(
+        self,
+        as_objects: Literal[True],
+    ) -> list[WorkflowTask]:
+        ...
+
+    @overload
+    def get_dependent_tasks(
+        self,
+        as_objects: Literal[False] = False,
+    ) -> set[int]:
+        ...
+
     def get_dependent_tasks(
         self,
         as_objects: bool = False,
-    ) -> List[Union[int, app.WorkflowTask]]:
+    ) -> set[int] | list[WorkflowTask]:
         """Get downstream tasks that depend on this element iteration."""
-        deps = []
+        deps: set[int] = set()
         for task in self.task.downstream_tasks:
-            for element in task.elements[:]:
-                for iter_i in element.iterations:
-                    for dep_iter_i in iter_i.get_element_iteration_dependencies(
-                        as_objects=True
-                    ):
-                        if dep_iter_i.id_ == self.id_ and task.insert_ID not in deps:
-                            deps.append(task.insert_ID)
-        deps = sorted(deps)
+            if any(
+                self.id_ in iter_i.get_element_iteration_dependencies()
+                for element in task.elements[:]
+                for iter_i in element.iterations
+            ):
+                deps.add(task.insert_ID)
         if as_objects:
-            deps = [self.workflow.tasks.get(insert_ID=i) for i in deps]
-
+            return [self.workflow.tasks.get(insert_ID=id_) for id_ in sorted(deps)]
         return deps
 
-    def get_template_resources(self) -> Dict:
+    def get_template_resources(self) -> Mapping[str, Any]:
         """Get template-level resources."""
-        out = {}
-        for res_i in self.workflow.template.resources:
-            out[res_i.scope.to_string()] = res_i._get_value()
-        return out
+        res = self.workflow.template._resources
+        return {res_i.normalised_resources_path: res_i._get_value() for res_i in res}
 
     @TimeIt.decorator
-    def get_resources(self, action: app.Action, set_defaults: bool = False) -> Dict:
+    def get_resources(
+        self, action: Action, set_defaults: bool = False
+    ) -> Mapping[str, Any]:
         """Resolve specific resources for the specified action of this iteration,
         considering all applicable scopes.
 
@@ -1121,60 +1217,58 @@ class ElementIteration:
         # question is perhaps "what would the resources be if this action were to become
         # an EAR?" which would then allow us to test a resources-based action rule.
 
-        resource_specs = copy.deepcopy(self.get("resources"))
+        # FIXME: Use a TypedDict?
+        resource_specs: dict[str, dict[str, dict[str, Any]]] = copy.deepcopy(
+            self.get("resources")
+        )
 
         env_spec = action.get_environment_spec()
-        env_name = env_spec["name"]
+        env_name: str = env_spec["name"]
 
         # set default env specifiers, if none set:
-        if "any" not in resource_specs:
-            resource_specs["any"] = {}
-        if "environments" not in resource_specs["any"]:
-            resource_specs["any"]["environments"] = {env_name: copy.deepcopy(env_spec)}
+        if "environments" not in (any_specs := resource_specs.setdefault("any", {})):
+            any_specs["environments"] = {env_name: copy.deepcopy(env_spec)}
 
-        for scope, dat in resource_specs.items():
+        for dat in resource_specs.values():
             if "environments" in dat:
                 # keep only relevant user-provided environment specifiers:
-                resource_specs[scope]["environments"] = {
+                dat["environments"] = {
                     k: v for k, v in dat["environments"].items() if k == env_name
                 }
                 # merge user-provided specifiers into action specifiers:
-                resource_specs[scope]["environments"][env_name] = {
-                    **resource_specs[scope]["environments"].get(env_name, {}),
-                    **copy.deepcopy(env_spec),
-                }
+                dat["environments"].setdefault(env_name, {}).update(
+                    copy.deepcopy(env_spec)
+                )
 
-        resources = {}
-        for scope in action.get_possible_scopes()[::-1]:
-            # loop in reverse so higher-specificity scopes take precedence:
-            scope_s = scope.to_string()
-            scope_res = resource_specs.get(scope_s, {})
-            resources.update({k: v for k, v in scope_res.items() if v is not None})
+        resources: dict[str, Any] = {}
+        for scope in action._get_possible_scopes_reversed():
+            # loop from least-specific to most so higher-specificity scopes take precedence:
+            if scope_res := resource_specs.get(scope.to_string()):
+                resources.update((k, v) for k, v in scope_res.items() if v is not None)
 
         if set_defaults:
             # used in e.g. `Rule.test` if testing resource rules on element iterations:
-            if "os_name" not in resources:
-                resources["os_name"] = self.app.ElementResources.get_default_os_name()
-            if "shell" not in resources:
-                resources["shell"] = self.app.ElementResources.get_default_shell()
+            ER = self._app.ElementResources
+            resources.setdefault("os_name", ER.get_default_os_name())
+            resources.setdefault("shell", ER.get_default_shell())
             if "scheduler" not in resources:
-                resources["scheduler"] = self.app.ElementResources.get_default_scheduler(
+                resources["scheduler"] = ER.get_default_scheduler(
                     resources["os_name"], resources["shell"]
                 )
 
         return resources
 
     def get_resources_obj(
-        self, action: app.Action, set_defaults: bool = False
-    ) -> app.ElementResources:
+        self, action: Action, set_defaults: bool = False
+    ) -> ElementResources:
         """
         Get the resources for an action (see :py:meth:`get_resources`)
         as a searchable model.
         """
-        return self.app.ElementResources(**self.get_resources(action, set_defaults))
+        return self._app.ElementResources(**self.get_resources(action, set_defaults))
 
 
-class Element:
+class Element(AppAware):
     """
     A basic component of a workflow. Elements are enactments of tasks.
 
@@ -1200,8 +1294,6 @@ class Element:
         Data for creating iteration objects.
     """
 
-    _app_attr = "app"
-
     # TODO: use slots
     # TODO:
     #   - add `iterations` property which returns `ElementIteration`
@@ -1211,13 +1303,13 @@ class Element:
         self,
         id_: int,
         is_pending: bool,
-        task: app.WorkflowTask,
+        task: WorkflowTask,
         index: int,
         es_idx: int,
-        seq_idx: Dict[str, int],
-        src_idx: Dict[str, int],
-        iteration_IDs: List[int],
-        iterations: List[Dict],
+        seq_idx: Mapping[str, int],
+        src_idx: Mapping[str, int],
+        iteration_IDs: list[int],
+        iterations: list[dict[str, Any]],
     ) -> None:
         self._id = id_
         self._is_pending = is_pending
@@ -1231,7 +1323,7 @@ class Element:
         self._iterations = iterations
 
         # assigned on first access:
-        self._iteration_objs = None
+        self._iteration_objs: list[ElementIteration] | None = None
 
     def __repr__(self):
         return (
@@ -1255,7 +1347,7 @@ class Element:
         return self._is_pending
 
     @property
-    def task(self) -> app.WorkflowTask:
+    def task(self) -> WorkflowTask:
         """
         The task this is part of the enactment of.
         """
@@ -1278,45 +1370,45 @@ class Element:
         return self._es_idx
 
     @property
-    def element_set(self):
+    def element_set(self) -> ElementSet:
         """
         The element set containing this element.
         """
         return self.task.template.element_sets[self.element_set_idx]
 
     @property
-    def sequence_idx(self) -> Dict[str, int]:
+    def sequence_idx(self) -> Mapping[str, int]:
         """
         The sequence index IDs.
         """
         return self._seq_idx
 
     @property
-    def input_source_idx(self) -> Dict[str, int]:
+    def input_source_idx(self) -> Mapping[str, int]:
         """
         The input source indices.
         """
         return self._src_idx
 
     @property
-    def input_sources(self) -> Dict[str, app.InputSource]:
+    def input_sources(self) -> Mapping[str, InputSource]:
         """
         The sources of the inputs to this element.
         """
         return {
-            k: self.element_set.input_sources[k.split("inputs.")[1]][v]
+            k: self.element_set.input_sources[k.removeprefix("inputs.")][v]
             for k, v in self.input_source_idx.items()
         }
 
     @property
-    def workflow(self) -> app.Workflow:
+    def workflow(self) -> Workflow:
         """
         The workflow containing this element.
         """
         return self.task.workflow
 
     @property
-    def iteration_IDs(self) -> List[int]:
+    def iteration_IDs(self) -> Sequence[int]:
         """
         The IDs of the iterations of this element.
         """
@@ -1324,14 +1416,14 @@ class Element:
 
     @property
     @TimeIt.decorator
-    def iterations(self) -> List[app.ElementIteration]:
+    def iterations(self) -> Sequence[ElementIteration]:
         """
         The iterations of this element.
         """
         # TODO: fix this
         if self._iteration_objs is None:
             self._iteration_objs = [
-                self.app.ElementIteration(
+                self._app.ElementIteration(
                     element=self,
                     index=idx,
                     **{k: v for k, v in iter_i.items() if k != "element_ID"},
@@ -1341,95 +1433,95 @@ class Element:
         return self._iteration_objs
 
     @property
-    def dir_name(self):
+    def dir_name(self) -> str:
         """
         The name of the directory for containing temporary files for this element.
         """
         return f"e_{self.index}"
 
     @property
-    def latest_iteration(self):
+    def latest_iteration(self) -> ElementIteration:
         """
         The most recent iteration of this element.
         """
         return self.iterations[-1]
 
     @property
-    def inputs(self) -> app.ElementInputs:
+    def inputs(self) -> ElementInputs:
         """
         The inputs to this element (or its most recent iteration).
         """
         return self.latest_iteration.inputs
 
     @property
-    def outputs(self) -> app.ElementOutputs:
+    def outputs(self) -> ElementOutputs:
         """
         The outputs from this element (or its most recent iteration).
         """
         return self.latest_iteration.outputs
 
     @property
-    def input_files(self) -> app.ElementInputFiles:
+    def input_files(self) -> ElementInputFiles:
         """
         The input files to this element (or its most recent iteration).
         """
         return self.latest_iteration.input_files
 
     @property
-    def output_files(self) -> app.ElementOutputFiles:
+    def output_files(self) -> ElementOutputFiles:
         """
         The output files from this element (or its most recent iteration).
         """
         return self.latest_iteration.output_files
 
     @property
-    def schema_parameters(self) -> List[str]:
+    def schema_parameters(self) -> Sequence[str]:
         """
         The schema-defined parameters to this element (or its most recent iteration).
         """
         return self.latest_iteration.schema_parameters
 
     @property
-    def actions(self) -> Dict[app.ElementAction]:
+    def actions(self) -> Mapping[int, ElementAction]:
         """
         The actions of this element (or its most recent iteration).
         """
         return self.latest_iteration.actions
 
     @property
-    def action_runs(self) -> List[app.ElementActionRun]:
+    def action_runs(self) -> Sequence[ElementActionRun]:
         """
         A list of element action runs from the latest iteration, where only the
         final run is taken for each element action.
         """
         return self.latest_iteration.action_runs
 
-    def init_loop_index(self, loop_name: str):
+    def init_loop_index(self, loop_name: str) -> None:
         """
         Initialise the loop index if necessary.
         """
         pass
 
-    def to_element_set_data(self):
+    def to_element_set_data(self) -> tuple[list[InputValue], list[ResourceSpec]]:
         """Generate lists of workflow-bound InputValues and ResourceList."""
-        inputs = []
-        resources = []
+        inputs: list[InputValue] = []
+        resources: list[ResourceSpec] = []
         for k, v in self.get_data_idx().items():
-            k_s = k.split(".")
+            kind, parameter_or_scope, *path = k.split(".")
 
-            if k_s[0] == "inputs":
-                inp_val = self.app.InputValue(
-                    parameter=k_s[1],
-                    path=k_s[2:] or None,
+            if kind == "inputs":
+                inp_val = self._app.InputValue(
+                    parameter=parameter_or_scope,
+                    path=cast("str", path) or None,  # FIXME: suspicious cast!
                     value=None,
                 )
                 inp_val._value_group_idx = v
                 inp_val._workflow = self.workflow
                 inputs.append(inp_val)
 
-            elif k_s[0] == "resources":
-                scope = self.app.ActionScope.from_json_like(k_s[1])
-                res = self.app.ResourceSpec(scope=scope)
+            elif kind == "resources":
+                scope = self._app.ActionScope.from_json_like(parameter_or_scope)
+                res = self._app.ResourceSpec(scope=scope)
                 res._value_group_idx = v
                 res._workflow = self.workflow
                 resources.append(res)
@@ -1440,20 +1532,24 @@ class Element:
         """
         Get the value of a sequence that applies.
         """
-        seq = self.element_set.get_sequence_from_path(sequence_path)
-        if not seq:
+
+        if not (seq := self.element_set.get_sequence_from_path(sequence_path)):
             raise ValueError(
                 f"No sequence with path {sequence_path!r} in this element's originating "
                 f"element set."
             )
-        return seq.values[self.sequence_idx[sequence_path]]
+        if (values := seq.values) is None:
+            raise ValueError(
+                f"Sequence with path {sequence_path!r} has no defined values."
+            )
+        return values[self.sequence_idx[sequence_path]]
 
     def get_data_idx(
         self,
-        path: str = None,
-        action_idx: int = None,
+        path: str | None = None,
+        action_idx: int | None = None,
         run_idx: int = -1,
-    ) -> Dict[str, int]:
+    ) -> DataIndex:
         """Get the data index of the most recent element iteration.
 
         Parameters
@@ -1467,15 +1563,42 @@ class Element:
             run_idx=run_idx,
         )
 
+    @overload
     def get_parameter_sources(
         self,
-        path: str = None,
-        action_idx: int = None,
+        path: str | None = None,
+        *,
+        action_idx: int | None = None,
         run_idx: int = -1,
-        typ: str = None,
+        typ: str | None = None,
+        as_strings: Literal[False] = False,
+        use_task_index: bool = False,
+    ) -> Mapping[str, ParamSource | list[ParamSource]]:
+        ...
+
+    @overload
+    def get_parameter_sources(
+        self,
+        path: str | None = None,
+        *,
+        action_idx: int | None = None,
+        run_idx: int = -1,
+        typ: str | None = None,
+        as_strings: Literal[True],
+        use_task_index: bool = False,
+    ) -> Mapping[str, str]:
+        ...
+
+    def get_parameter_sources(
+        self,
+        path: str | None = None,
+        *,
+        action_idx: int | None = None,
+        run_idx: int = -1,
+        typ: str | None = None,
         as_strings: bool = False,
         use_task_index: bool = False,
-    ) -> Dict[str, Union[str, Dict[str, Any]]]:
+    ) -> Mapping[str, str] | Mapping[str, ParamSource | list[ParamSource]]:
         """ "Get the parameter sources of the most recent element iteration.
 
         Parameters
@@ -1484,19 +1607,27 @@ class Element:
             If True, use the task index within the workflow, rather than the task insert
             ID.
         """
+        if as_strings:
+            return self.latest_iteration.get_parameter_sources(
+                path=path,
+                action_idx=action_idx,
+                run_idx=run_idx,
+                typ=typ,
+                as_strings=True,
+                use_task_index=use_task_index,
+            )
         return self.latest_iteration.get_parameter_sources(
             path=path,
             action_idx=action_idx,
             run_idx=run_idx,
             typ=typ,
-            as_strings=as_strings,
             use_task_index=use_task_index,
         )
 
     def get(
         self,
-        path: str = None,
-        action_idx: int = None,
+        path: str | None = None,
+        action_idx: int | None = None,
         run_idx: int = -1,
         default: Any = None,
         raise_on_missing: bool = False,
@@ -1512,71 +1643,159 @@ class Element:
             raise_on_unset=raise_on_unset,
         )
 
+    @overload
+    def get_EAR_dependencies(self, as_objects: Literal[True]) -> list[ElementActionRun]:
+        ...
+
+    @overload
+    def get_EAR_dependencies(self, as_objects: Literal[False] = False) -> set[int]:
+        ...
+
     def get_EAR_dependencies(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.ElementActionRun]]:
+    ) -> set[int] | list[ElementActionRun]:
         """Get EARs that the most recent iteration of this element depends on."""
-        return self.latest_iteration.get_EAR_dependencies(as_objects=as_objects)
+        if as_objects:
+            return self.latest_iteration.get_EAR_dependencies(as_objects=True)
+        return self.latest_iteration.get_EAR_dependencies()
+
+    @overload
+    def get_element_iteration_dependencies(
+        self, as_objects: Literal[True]
+    ) -> list[ElementIteration]:
+        ...
+
+    @overload
+    def get_element_iteration_dependencies(
+        self, as_objects: Literal[False] = False
+    ) -> set[int]:
+        ...
 
     def get_element_iteration_dependencies(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.ElementIteration]]:
+    ) -> set[int] | list[ElementIteration]:
         """Get element iterations that the most recent iteration of this element depends
         on."""
-        return self.latest_iteration.get_element_iteration_dependencies(
-            as_objects=as_objects
-        )
+        if as_objects:
+            return self.latest_iteration.get_element_iteration_dependencies(
+                as_objects=True
+            )
+        return self.latest_iteration.get_element_iteration_dependencies()
+
+    @overload
+    def get_element_dependencies(self, as_objects: Literal[True]) -> list[Element]:
+        ...
+
+    @overload
+    def get_element_dependencies(self, as_objects: Literal[False] = False) -> set[int]:
+        ...
 
     def get_element_dependencies(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.Element]]:
+    ) -> set[int] | list[Element]:
         """Get elements that the most recent iteration of this element depends on."""
-        return self.latest_iteration.get_element_dependencies(as_objects=as_objects)
+        if as_objects:
+            return self.latest_iteration.get_element_dependencies(as_objects=True)
+        return self.latest_iteration.get_element_dependencies()
 
-    def get_input_dependencies(self) -> Dict[str, Dict]:
+    def get_input_dependencies(self) -> Mapping[str, ParamSource]:
         """Get locally defined inputs/sequences/defaults from other tasks that this
         the most recent iteration of this element depends on."""
         return self.latest_iteration.get_input_dependencies()
 
+    @overload
+    def get_task_dependencies(self, as_objects: Literal[True]) -> list[WorkflowTask]:
+        ...
+
+    @overload
+    def get_task_dependencies(self, as_objects: Literal[False] = False) -> set[int]:
+        ...
+
     def get_task_dependencies(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.WorkflowTask]]:
+    ) -> set[int] | list[WorkflowTask]:
         """Get tasks (insert ID or WorkflowTask objects) that the most recent iteration of
         this element depends on.
 
         Dependencies may come from either elements from upstream tasks, or from locally
         defined inputs/sequences/defaults from upstream tasks."""
-        return self.latest_iteration.get_task_dependencies(as_objects=as_objects)
+        if as_objects:
+            return self.latest_iteration.get_task_dependencies(as_objects=True)
+        return self.latest_iteration.get_task_dependencies()
+
+    @overload
+    def get_dependent_EARs(self, as_objects: Literal[True]) -> list[ElementActionRun]:
+        ...
+
+    @overload
+    def get_dependent_EARs(self, as_objects: Literal[False] = False) -> set[int]:
+        ...
 
     def get_dependent_EARs(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.ElementActionRun]]:
+    ) -> set[int] | list[ElementActionRun]:
         """Get EARs that depend on the most recent iteration of this element."""
-        return self.latest_iteration.get_dependent_EARs(as_objects=as_objects)
+        if as_objects:
+            return self.latest_iteration.get_dependent_EARs(as_objects=True)
+        return self.latest_iteration.get_dependent_EARs()
+
+    @overload
+    def get_dependent_element_iterations(
+        self, as_objects: Literal[True]
+    ) -> list[ElementIteration]:
+        ...
+
+    @overload
+    def get_dependent_element_iterations(
+        self, as_objects: Literal[False] = False
+    ) -> set[int]:
+        ...
 
     def get_dependent_element_iterations(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.ElementIteration]]:
+    ) -> set[int] | list[ElementIteration]:
         """Get element iterations that depend on the most recent iteration of this
         element."""
-        return self.latest_iteration.get_dependent_element_iterations(
-            as_objects=as_objects
-        )
+        if as_objects:
+            return self.latest_iteration.get_dependent_element_iterations(as_objects=True)
+        return self.latest_iteration.get_dependent_element_iterations()
+
+    @overload
+    def get_dependent_elements(self, as_objects: Literal[True]) -> list[Element]:
+        ...
+
+    @overload
+    def get_dependent_elements(self, as_objects: Literal[False] = False) -> set[int]:
+        ...
 
     def get_dependent_elements(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.Element]]:
+    ) -> set[int] | list[Element]:
         """Get elements that depend on the most recent iteration of this element."""
-        return self.latest_iteration.get_dependent_elements(as_objects=as_objects)
+        if as_objects:
+            return self.latest_iteration.get_dependent_elements(as_objects=True)
+        return self.latest_iteration.get_dependent_elements()
+
+    @overload
+    def get_dependent_tasks(self, as_objects: Literal[True]) -> list[WorkflowTask]:
+        ...
+
+    @overload
+    def get_dependent_tasks(self, as_objects: Literal[False] = False) -> set[int]:
+        ...
 
     def get_dependent_tasks(
         self, as_objects: bool = False
-    ) -> List[Union[int, app.WorkflowTask]]:
+    ) -> set[int] | list[WorkflowTask]:
         """Get tasks that depend on the most recent iteration of this element."""
-        return self.latest_iteration.get_dependent_tasks(as_objects=as_objects)
+        if as_objects:
+            return self.latest_iteration.get_dependent_tasks(as_objects=True)
+        return self.latest_iteration.get_dependent_tasks()
 
     @TimeIt.decorator
-    def get_dependent_elements_recursively(self, task_insert_ID=None):
+    def get_dependent_elements_recursively(
+        self, task_insert_ID: int | None = None
+    ) -> list[Element]:
         """Get downstream elements that depend on this element, including recursive
         dependencies.
 
@@ -1586,28 +1805,26 @@ class Element:
 
         Parameters
         ----------
-        task_insert_ID
+        task_insert_ID: int
             If specified, only return elements from this task.
 
         """
 
-        def get_deps(element):
-            deps = element.iterations[0].get_dependent_elements(as_objects=False)
+        def get_deps(element: Element) -> set[int]:
+            deps = element.iterations[0].get_dependent_elements()
             deps_objs = self.workflow.get_elements_from_IDs(deps)
-            return set(deps).union(
-                [dep_j for deps_i in deps_objs for dep_j in get_deps(deps_i)]
-            )
+            return deps.union(dep_j for deps_i in deps_objs for dep_j in get_deps(deps_i))
 
         all_deps = get_deps(self)
-
         if task_insert_ID is not None:
-            elem_ID_subset = self.workflow.tasks.get(insert_ID=task_insert_ID).element_IDs
-            all_deps = [i for i in all_deps if i in elem_ID_subset]
-
+            all_deps.intersection_update(
+                self.workflow.tasks.get(insert_ID=task_insert_ID).element_IDs
+            )
         return self.workflow.get_elements_from_IDs(sorted(all_deps))
 
 
-@dataclass
+@dataclass(repr=False, eq=False)
+@hydrate
 class ElementParameter:
     """
     A parameter to an :py:class:`.Element`.
@@ -1624,19 +1841,22 @@ class ElementParameter:
         The element that this is a parameter of.
     """
 
-    _app_attr = "app"
+    # Intended to be subclassed, so public
+    #: Application context.
+    app: ClassVar[BaseApp]
+    _app_attr: ClassVar[str] = "app"
 
     #: The task that this is part of.
-    task: app.WorkflowTask
+    task: WorkflowTask
     #: The path to this parameter.
     path: str
     #: The entity that owns this parameter.
-    parent: Union[Element, app.ElementAction, app.ElementActionRun, app.Parameters]
+    parent: Element | ElementAction | ElementActionRun | ElementIteration
     #: The element that this is a parameter of.
-    element: Element
+    element: Element | ElementIteration
 
     @property
-    def data_idx(self):
+    def data_idx(self) -> DataIndex:
         """
         The data indices associated with this parameter.
         """
@@ -1655,20 +1875,20 @@ class ElementParameter:
     def __eq__(self, __o: object) -> bool:
         if not isinstance(__o, self.__class__):
             return False
-        if self.task == __o.task and self.path == __o.path:
-            return True
+        return self.task == __o.task and self.path == __o.path
 
     @property
-    def data_idx_is_set(self):
+    def data_idx_is_set(self) -> Mapping[str, bool]:
         """
         The associated data indices for which this is set.
         """
         return {
-            k: self.task.workflow.is_parameter_set(v) for k, v in self.data_idx.items()
+            k: self.task.workflow.is_parameter_set(cast("int", v))
+            for k, v in self.data_idx.items()
         }
 
     @property
-    def is_set(self):
+    def is_set(self) -> bool:
         """
         Whether this parameter is set.
         """
@@ -1682,6 +1902,7 @@ class ElementParameter:
 
 
 @dataclass
+@hydrate
 class ElementFilter(JSONLike):
     """
     A filter for iterations.
@@ -1692,22 +1913,22 @@ class ElementFilter(JSONLike):
         The filtering rules to use.
     """
 
-    _child_objects = (ChildObjectSpec(name="rules", is_multiple=True, class_name="Rule"),)
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
+        ChildObjectSpec(name="rules", is_multiple=True, class_name="Rule"),
+    )
 
     #: The filtering rules to use.
-    rules: List[app.Rule] = field(default_factory=list)
+    rules: list[Rule] = field(default_factory=list)
 
-    def filter(
-        self, element_iters: List[app.ElementIteration]
-    ) -> List[app.ElementIteration]:
+    def filter(self, element_iters: list[ElementIteration]) -> list[ElementIteration]:
         """
         Apply the filter rules to select a subsequence of iterations.
         """
-        out = []
-        for i in element_iters:
-            if all(rule_j.test(i) for rule_j in self.rules):
-                out.append(i)
-        return out
+        return [
+            el_iter
+            for el_iter in element_iters
+            if all(rule_j.test(el_iter) for rule_j in self.rules)
+        ]
 
 
 @dataclass
@@ -1728,9 +1949,9 @@ class ElementGroup(JSONLike):
     #: The name of the grouping rule.
     name: str
     #: A filtering rule to select which iterations to use in the group.
-    where: Optional[ElementFilter] = None
+    where: ElementFilter | None = None
     #: If specified, the name of the property to group iterations by.
-    group_by_distinct: Optional[app.ParameterPath] = None
+    group_by_distinct: ParameterPath | None = None
 
     def __post_init__(self):
         self.name = check_valid_py_identifier(self.name)
@@ -1752,4 +1973,4 @@ class ElementRepeats:
     #: The number of times to repeat.
     number: int
     #: A filtering rule for what to repeat.
-    where: Optional[ElementFilter] = None
+    where: ElementFilter | None = None