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

hpcflow/sdk/submission/submission.py

@@ -4,16 +4,12 @@ A collection of submissions to a scheduler, generated from a workflow.
 
 from __future__ import annotations
 from collections import defaultdict
-
-from datetime import datetime, timedelta, timezone
-import enum
 import os
 from pathlib import Path
-from textwrap import indent
-from typing import Dict, List, Optional, Tuple
+from typing import Any, overload, TYPE_CHECKING
+from typing_extensions import override
 
-from hpcflow.sdk import app
-from hpcflow.sdk.core.element import ElementResources
+from hpcflow.sdk.typing import hydrate
 from hpcflow.sdk.core.errors import (
     JobscriptSubmissionFailure,
     MissingEnvironmentError,
@@ -24,44 +20,27 @@ from hpcflow.sdk.core.errors import (
 )
 from hpcflow.sdk.core.json_like import ChildObjectSpec, JSONLike
 from hpcflow.sdk.core.object_list import ObjectListMultipleMatchError
+from hpcflow.sdk.core.utils import parse_timestamp, current_timestamp
+from hpcflow.sdk.submission.enums import SubmissionStatus
 from hpcflow.sdk.log import TimeIt
 
-
-def timedelta_format(td: timedelta) -> str:
-    """
-    Convert time delta to string in standard form.
-    """
-    days, seconds = td.days, td.seconds
-    hours = seconds // (60 * 60)
-    seconds -= hours * (60 * 60)
-    minutes = seconds // 60
-    seconds -= minutes * 60
-    return f"{days}-{hours:02}:{minutes:02}:{seconds:02}"
-
-
-def timedelta_parse(td_str: str) -> timedelta:
-    """
-    Parse a string in standard form as a time delta.
-    """
-    days, other = td_str.split("-")
-    days = int(days)
-    hours, mins, secs = [int(i) for i in other.split(":")]
-    return timedelta(days=days, hours=hours, minutes=mins, seconds=secs)
-
-
-class SubmissionStatus(enum.Enum):
-    """
-    The overall status of a submission.
-    """
-
-    #: Not yet submitted.
-    PENDING = 0
-    #: All jobscripts submitted successfully.
-    SUBMITTED = 1
-    #: Some jobscripts submitted successfully.
-    PARTIALLY_SUBMITTED = 2
-
-
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping, Sequence
+    from datetime import datetime
+    from typing import ClassVar, Literal
+    from rich.status import Status
+    from .jobscript import Jobscript
+    from .enums import JobscriptElementState
+    from .schedulers import Scheduler
+    from .shells import Shell
+    from .types import SubmissionPart
+    from ..core.element import ElementActionRun
+    from ..core.environment import Environment
+    from ..core.object_list import EnvironmentsList
+    from ..core.workflow import Workflow
+
+
+@hydrate
 class Submission(JSONLike):
     """
     A collection of jobscripts to be submitted to a scheduler.
@@ -82,7 +61,7 @@ class Submission(JSONLike):
         The execution environments to use.
     """
 
-    _child_objects = (
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
         ChildObjectSpec(
             name="jobscripts",
             class_name="Jobscript",
@@ -98,11 +77,11 @@ class Submission(JSONLike):
     def __init__(
         self,
         index: int,
-        jobscripts: List[app.Jobscript],
-        workflow: Optional[app.Workflow] = None,
-        submission_parts: Optional[Dict] = None,
-        JS_parallelism: Optional[bool] = None,
-        environments: Optional[app.EnvironmentsList] = None,
+        jobscripts: list[Jobscript],
+        workflow: Workflow | None = None,
+        submission_parts: dict[str, list[int]] | None = None,
+        JS_parallelism: bool | None = None,
+        environments: EnvironmentsList | None = None,
     ):
         self._index = index
         self._jobscripts = jobscripts
@@ -110,7 +89,9 @@ class Submission(JSONLike):
         self._JS_parallelism = JS_parallelism
         self._environments = environments
 
-        self._submission_parts_lst = None  # assigned on first access; datetime objects
+        self._submission_parts_lst: list[
+            SubmissionPart
+        ] | None = None  # assigned on first access
 
         if workflow:
             #: The workflow this is part of.
@@ -122,37 +103,33 @@ class Submission(JSONLike):
             js._index = js_idx
 
     @TimeIt.decorator
-    def _set_environments(self):
-        filterable = ElementResources.get_env_instance_filterable_attributes()
+    def _set_environments(self) -> None:
+        filterable = self._app.ElementResources.get_env_instance_filterable_attributes()
 
         # map required environments and executable labels to job script indices:
-        req_envs = defaultdict(lambda: defaultdict(set))
+        req_envs: dict[
+            tuple[tuple[str, ...], tuple[Any, ...]], dict[str, set[int]]
+        ] = defaultdict(lambda: defaultdict(set))
         for js_idx, js_i in enumerate(self.jobscripts):
             for run in js_i.all_EARs:
-                env_spec_h = tuple(zip(*run.env_spec.items()))  # hashable
+                # Alas, mypy can't typecheck the next line if the type is right!
+                # So we use Any to get it to shut up...
+                env_spec_h: Any = tuple(zip(*run.env_spec.items()))  # hashable
                 for exec_label_j in run.action.get_required_executables():
                     req_envs[env_spec_h][exec_label_j].add(js_idx)
-                if env_spec_h not in req_envs:
-                    req_envs[env_spec_h] = {}
+                # Ensure overall element is present
+                req_envs[env_spec_h]
 
         # check these envs/execs exist in app data:
-        envs = []
+        envs: list[Environment] = []
         for env_spec_h, exec_js in req_envs.items():
             env_spec = dict(zip(*env_spec_h))
-            non_name_spec = {k: v for k, v in env_spec.items() if k != "name"}
-            spec_str = f" with specifiers {non_name_spec!r}" if non_name_spec else ""
-            env_ref = f"{env_spec['name']!r}{spec_str}"
             try:
-                env_i = self.app.envs.get(**env_spec)
+                env_i = self._app.envs.get(**env_spec)
             except ObjectListMultipleMatchError:
-                raise MultipleEnvironmentsError(
-                    f"Multiple environments {env_ref} are defined on this machine."
-                )
+                raise MultipleEnvironmentsError(env_spec)
             except ValueError:
-                raise MissingEnvironmentError(
-                    f"The environment {env_ref} is not defined on this machine, so the "
-                    f"submission cannot be created."
-                ) from None
+                raise MissingEnvironmentError(env_spec) from None
             else:
                 if env_i not in envs:
                     envs.append(env_i)
@@ -162,34 +139,28 @@ class Submission(JSONLike):
                     exec_i = env_i.executables.get(exec_i_lab)
                 except ValueError:
                     raise MissingEnvironmentExecutableError(
-                        f"The environment {env_ref} as defined on this machine has no "
-                        f"executable labelled {exec_i_lab!r}, which is required for this "
-                        f"submission, so the submission cannot be created."
+                        env_spec, exec_i_lab
                     ) from None
 
                 # check matching executable instances exist:
                 for js_idx_j in js_idx_set:
-                    js_j = self.jobscripts[js_idx_j]
-                    filter_exec = {j: getattr(js_j.resources, j) for j in filterable}
-                    exec_instances = exec_i.filter_instances(**filter_exec)
-                    if not exec_instances:
+                    js_res = self.jobscripts[js_idx_j].resources
+                    filter_exec = {j: getattr(js_res, j) for j in filterable}
+                    if not exec_i.filter_instances(**filter_exec):
                         raise MissingEnvironmentExecutableInstanceError(
-                            f"No matching executable instances found for executable "
-                            f"{exec_i_lab!r} of environment {env_ref} for jobscript "
-                            f"index {js_idx_j!r} with requested resources "
-                            f"{filter_exec!r}."
+                            env_spec, exec_i_lab, js_idx_j, filter_exec
                         )
 
         # save env definitions to the environments attribute:
-        self._environments = self.app.EnvironmentsList(envs)
+        self._environments = self._app.EnvironmentsList(envs)
 
-    def to_dict(self):
-        dct = super().to_dict()
+    @override
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        dct = super()._postprocess_to_dict(d)
         del dct["_workflow"]
         del dct["_index"]
         del dct["_submission_parts_lst"]
-        dct = {k.lstrip("_"): v for k, v in dct.items()}
-        return dct
+        return {k.lstrip("_"): v for k, v in dct.items()}
 
     @property
     def index(self) -> int:
@@ -199,14 +170,15 @@ class Submission(JSONLike):
         return self._index
 
     @property
-    def environments(self) -> app.EnvironmentsList:
+    def environments(self) -> EnvironmentsList:
         """
         The execution environments to use.
         """
+        assert self._environments
         return self._environments
 
     @property
-    def submission_parts(self) -> List[Dict]:
+    def submission_parts(self) -> list[SubmissionPart]:
         """
         Description of the parts of this submission.
         """
@@ -216,9 +188,7 @@ class Submission(JSONLike):
         if self._submission_parts_lst is None:
             self._submission_parts_lst = [
                 {
-                    "submit_time": datetime.strptime(dt, self.workflow.ts_fmt)
-                    .replace(tzinfo=timezone.utc)
-                    .astimezone(),
+                    "submit_time": parse_timestamp(dt, self.workflow.ts_fmt),
                     "jobscripts": js_idx,
                 }
                 for dt, js_idx in self._submission_parts.items()
@@ -226,116 +196,89 @@ class Submission(JSONLike):
         return self._submission_parts_lst
 
     @TimeIt.decorator
-    def get_start_time(self, submit_time: str) -> Union[datetime, None]:
+    def get_start_time(self, submit_time: str) -> datetime | None:
         """Get the start time of a given submission part."""
-        js_idx = self._submission_parts[submit_time]
-        all_part_starts = []
-        for i in js_idx:
-            start_time = self.jobscripts[i].start_time
-            if start_time:
-                all_part_starts.append(start_time)
-        if all_part_starts:
-            return min(all_part_starts)
-        else:
-            return None
+        times = (
+            self.jobscripts[i].start_time for i in self._submission_parts[submit_time]
+        )
+        return min((t for t in times if t is not None), default=None)
 
     @TimeIt.decorator
-    def get_end_time(self, submit_time: str) -> Union[datetime, None]:
+    def get_end_time(self, submit_time: str) -> datetime | None:
         """Get the end time of a given submission part."""
-        js_idx = self._submission_parts[submit_time]
-        all_part_ends = []
-        for i in js_idx:
-            end_time = self.jobscripts[i].end_time
-            if end_time:
-                all_part_ends.append(end_time)
-        if all_part_ends:
-            return max(all_part_ends)
-        else:
-            return None
+        times = (self.jobscripts[i].end_time for i in self._submission_parts[submit_time])
+        return max((t for t in times if t is not None), default=None)
 
     @property
     @TimeIt.decorator
-    def start_time(self):
+    def start_time(self) -> datetime | None:
         """Get the first non-None start time over all submission parts."""
-        all_start_times = []
-        for submit_time in self._submission_parts:
-            start_i = self.get_start_time(submit_time)
-            if start_i:
-                all_start_times.append(start_i)
-        if all_start_times:
-            return max(all_start_times)
-        else:
-            return None
+        times = (
+            self.get_start_time(submit_time) for submit_time in self._submission_parts
+        )
+        return min((t for t in times if t is not None), default=None)
 
     @property
     @TimeIt.decorator
-    def end_time(self):
+    def end_time(self) -> datetime | None:
         """Get the final non-None end time over all submission parts."""
-        all_end_times = []
-        for submit_time in self._submission_parts:
-            end_i = self.get_end_time(submit_time)
-            if end_i:
-                all_end_times.append(end_i)
-        if all_end_times:
-            return max(all_end_times)
-        else:
-            return None
+        times = (self.get_end_time(submit_time) for submit_time in self._submission_parts)
+        return max((t for t in times if t is not None), default=None)
 
     @property
-    def jobscripts(self) -> List:
+    def jobscripts(self) -> list[Jobscript]:
         """
         The jobscripts in this submission.
         """
         return self._jobscripts
 
     @property
-    def JS_parallelism(self):
+    def JS_parallelism(self) -> bool | None:
         """
         Whether to exploit jobscript parallelism.
         """
         return self._JS_parallelism
 
     @property
-    def workflow(self) -> List:
+    def workflow(self) -> Workflow:
         """
         The workflow this is part of.
         """
         return self._workflow
 
     @workflow.setter
-    def workflow(self, wk):
+    def workflow(self, wk: Workflow):
         self._workflow = wk
 
     @property
-    def jobscript_indices(self) -> Tuple[int]:
+    def jobscript_indices(self) -> tuple[int, ...]:
         """All associated jobscript indices."""
-        return tuple(i.index for i in self.jobscripts)
+        return tuple(js.index for js in self.jobscripts)
 
     @property
-    def submitted_jobscripts(self) -> Tuple[int]:
+    def submitted_jobscripts(self) -> tuple[int, ...]:
         """Jobscript indices that have been successfully submitted."""
-        return tuple(j for i in self.submission_parts for j in i["jobscripts"])
+        return tuple(j for sp in self.submission_parts for j in sp["jobscripts"])
 
     @property
-    def outstanding_jobscripts(self) -> Tuple[int]:
+    def outstanding_jobscripts(self) -> tuple[int, ...]:
         """Jobscript indices that have not yet been successfully submitted."""
-        return tuple(set(self.jobscript_indices) - set(self.submitted_jobscripts))
+        return tuple(set(self.jobscript_indices).difference(self.submitted_jobscripts))
 
     @property
-    def status(self):
+    def status(self) -> SubmissionStatus:
         """
         The status of this submission.
         """
         if not self.submission_parts:
             return SubmissionStatus.PENDING
+        elif set(self.submitted_jobscripts) == set(self.jobscript_indices):
+            return SubmissionStatus.SUBMITTED
         else:
-            if set(self.submitted_jobscripts) == set(self.jobscript_indices):
-                return SubmissionStatus.SUBMITTED
-            else:
-                return SubmissionStatus.PARTIALLY_SUBMITTED
+            return SubmissionStatus.PARTIALLY_SUBMITTED
 
     @property
-    def needs_submit(self):
+    def needs_submit(self) -> bool:
         """
         Whether this submission needs a submit to be done.
         """
@@ -345,71 +288,87 @@ class Submission(JSONLike):
         )
 
     @property
-    def path(self):
+    def path(self) -> Path:
         """
         The path to files associated with this submission.
         """
         return self.workflow.submissions_path / str(self.index)
 
     @property
-    def all_EAR_IDs(self):
+    def all_EAR_IDs(self) -> Iterable[int]:
         """
         The IDs of all EARs in this submission.
         """
-        return [i for js in self.jobscripts for i in js.all_EAR_IDs]
+        return (i for js in self.jobscripts for i in js.all_EAR_IDs)
 
     @property
-    def all_EARs(self):
+    def all_EARs(self) -> Iterable[ElementActionRun]:
         """
         All EARs in this this submission.
         """
-        return [i for js in self.jobscripts for i in js.all_EARs]
+        return (ear for js in self.jobscripts for ear in js.all_EARs)
 
     @property
     @TimeIt.decorator
-    def EARs_by_elements(self):
+    def EARs_by_elements(self) -> Mapping[int, Mapping[int, Sequence[ElementActionRun]]]:
         """
         All EARs in this submission, grouped by element.
         """
-        task_elem_EARs = defaultdict(lambda: defaultdict(list))
-        for i in self.all_EARs:
-            task_elem_EARs[i.task.index][i.element.index].append(i)
+        task_elem_EARs: dict[int, dict[int, list[ElementActionRun]]] = defaultdict(
+            lambda: defaultdict(list)
+        )
+        for ear in self.all_EARs:
+            task_elem_EARs[ear.task.index][ear.element.index].append(ear)
         return task_elem_EARs
 
     @property
-    def abort_EARs_file_name(self):
+    def abort_EARs_file_name(self) -> str:
         """
         The name of a file describing what EARs have aborted.
         """
-        return f"abort_EARs.txt"
+        return "abort_EARs.txt"
 
     @property
-    def abort_EARs_file_path(self):
+    def abort_EARs_file_path(self) -> Path:
         """
         The path to the file describing what EARs have aborted in this submission.
         """
         return self.path / self.abort_EARs_file_name
 
+    @overload
+    def get_active_jobscripts(
+        self, as_json: Literal[False] = False
+    ) -> Mapping[int, Mapping[int, JobscriptElementState]]:
+        ...
+
+    @overload
+    def get_active_jobscripts(self, as_json: Literal[True]) -> dict[int, dict[int, str]]:
+        ...
+
     @TimeIt.decorator
     def get_active_jobscripts(
         self, as_json: bool = False
-    ) -> List[Tuple[int, Dict[int, JobscriptElementState]]]:
+    ) -> Mapping[int, Mapping[int, JobscriptElementState]] | dict[int, dict[int, str]]:
         """Get jobscripts that are active on this machine, and their active states."""
         # this returns: {JS_IDX: {JS_ELEMENT_IDX: STATE}}
         # TODO: query the scheduler once for all jobscripts?
-        out = {}
-        for js in self.jobscripts:
-            active_states = js.get_active_states(as_json=as_json)
-            if active_states:
-                out[js.index] = active_states
-        return out
+        if as_json:
+            details = (
+                (js.index, js.get_active_states(as_json=True)) for js in self.jobscripts
+            )
+            return {idx: state for idx, state in details if state}
+        else:
+            dets2 = (
+                (js.index, js.get_active_states(as_json=False)) for js in self.jobscripts
+            )
+            return {idx: state for idx, state in dets2 if state}
 
-    def _write_abort_EARs_file(self):
+    def _write_abort_EARs_file(self) -> None:
         with self.abort_EARs_file_path.open(mode="wt", newline="\n") as fp:
             # write a single line for each EAR currently in the workflow:
             fp.write("\n".join("0" for _ in range(self.workflow.num_EARs)) + "\n")
 
-    def _set_run_abort(self, run_ID: int):
+    def _set_run_abort(self, run_ID: int) -> None:
         """Modify the abort runs file to indicate a specified run should be aborted."""
         with self.abort_EARs_file_path.open(mode="rt", newline="\n") as fp:
             lines = fp.read().splitlines()
@@ -418,58 +377,82 @@ class Submission(JSONLike):
         # write a new temporary run-abort file:
         tmp_suffix = self.abort_EARs_file_path.suffix + ".tmp"
         tmp = self.abort_EARs_file_path.with_suffix(tmp_suffix)
-        self.app.submission_logger.debug(f"Creating temporary run abort file: {tmp!r}.")
+        self._app.submission_logger.debug(f"Creating temporary run abort file: {tmp!r}.")
         with tmp.open(mode="wt", newline="\n") as fp:
-            fp.write("\n".join(i for i in lines) + "\n")
+            fp.write("\n".join(lines) + "\n")
 
         # atomic rename, overwriting original:
-        self.app.submission_logger.debug(
+        self._app.submission_logger.debug(
             "Replacing original run abort file with new temporary file."
         )
         os.replace(src=tmp, dst=self.abort_EARs_file_path)
 
     @staticmethod
     def get_unique_schedulers_of_jobscripts(
-        jobscripts: List[Jobscript],
-    ) -> Dict[Tuple[Tuple[int, int]], Scheduler]:
+        jobscripts: Iterable[Jobscript],
+    ) -> Iterable[tuple[tuple[tuple[int, int], ...], Scheduler]]:
         """Get unique schedulers and which of the passed jobscripts they correspond to.
 
-        Uniqueness is determines only by the `Scheduler.unique_properties` tuple.
+        Uniqueness is determines only by the `QueuedScheduler.unique_properties` tuple.
 
         Parameters
         ----------
         jobscripts: list[~hpcflow.app.Jobscript]
+
+        Returns
+        -------
+        scheduler_mapping
+            Mapping where keys are a sequence of jobscript index descriptors and
+            the values are the scheduler to use for that jobscript.
+            A jobscript index descriptor is a pair of the submission index and the main
+            jobscript index.
         """
-        js_idx = []
-        schedulers = []
+        js_idx: list[list[tuple[int, int]]] = []
+        schedulers: list[Scheduler] = []
 
         # list of tuples of scheduler properties we consider to determine "uniqueness",
         # with the first string being the scheduler type (class name):
-        seen_schedulers = []
+        seen_schedulers: dict[tuple, int] = {}
 
         for js in jobscripts:
-            if js.scheduler.unique_properties not in seen_schedulers:
-                seen_schedulers.append(js.scheduler.unique_properties)
+            if (
+                sched_idx := seen_schedulers.get(key := js.scheduler.unique_properties)
+            ) is None:
+                seen_schedulers[key] = sched_idx = len(seen_schedulers) - 1
                 schedulers.append(js.scheduler)
                 js_idx.append([])
-            sched_idx = seen_schedulers.index(js.scheduler.unique_properties)
             js_idx[sched_idx].append((js.submission.index, js.index))
 
-        sched_js_idx = dict(zip((tuple(i) for i in js_idx), schedulers))
+        return zip(map(tuple, js_idx), schedulers)
 
-        return sched_js_idx
+    @property
+    @TimeIt.decorator
+    def _unique_schedulers(
+        self,
+    ) -> Iterable[tuple[tuple[tuple[int, int], ...], Scheduler]]:
+        return self.get_unique_schedulers_of_jobscripts(self.jobscripts)
 
     @TimeIt.decorator
-    def get_unique_schedulers(self) -> Dict[Tuple[int], Scheduler]:
+    def get_unique_schedulers(self) -> Mapping[tuple[tuple[int, int], ...], Scheduler]:
         """Get unique schedulers and which of this submission's jobscripts they
-        correspond to."""
-        return self.get_unique_schedulers_of_jobscripts(self.jobscripts)
+        correspond to.
+
+        Returns
+        -------
+        scheduler_mapping
+            Mapping where keys are a sequence of jobscript index descriptors and
+            the values are the scheduler to use for that jobscript.
+            A jobscript index descriptor is a pair of the submission index and the main
+            jobscript index.
+        """
+        # This is an absurd type; you never use the key as a key
+        return dict(self._unique_schedulers)
 
     @TimeIt.decorator
-    def get_unique_shells(self) -> Dict[Tuple[int], Shell]:
+    def get_unique_shells(self) -> Iterable[tuple[tuple[int, ...], Shell]]:
         """Get unique shells and which jobscripts they correspond to."""
-        js_idx = []
-        shells = []
+        js_idx: list[list[int]] = []
+        shells: list[Shell] = []
 
         for js in self.jobscripts:
             if js.shell not in shells:
@@ -478,38 +461,9 @@ class Submission(JSONLike):
             shell_idx = shells.index(js.shell)
             js_idx[shell_idx].append(js.index)
 
-        shell_js_idx = dict(zip((tuple(i) for i in js_idx), shells))
-
-        return shell_js_idx
+        return zip(map(tuple, js_idx), shells)
 
-    def _raise_failure(self, submitted_js_idx, exceptions):
-        msg = f"Some jobscripts in submission index {self.index} could not be submitted"
-        if submitted_js_idx:
-            msg += f" (but jobscripts {submitted_js_idx} were submitted successfully):"
-        else:
-            msg += ":"
-
-        msg += "\n"
-        for sub_err in exceptions:
-            msg += (
-                f"Jobscript {sub_err.js_idx} at path: {str(sub_err.js_path)!r}\n"
-                f"Submit command: {sub_err.submit_cmd!r}.\n"
-                f"Reason: {sub_err.message!r}\n"
-            )
-            if sub_err.subprocess_exc is not None:
-                msg += f"Subprocess exception: {sub_err.subprocess_exc}\n"
-            if sub_err.job_ID_parse_exc is not None:
-                msg += f"Subprocess job ID parse exception: {sub_err.job_ID_parse_exc}\n"
-            if sub_err.job_ID_parse_exc is not None:
-                msg += f"Job ID parse exception: {sub_err.job_ID_parse_exc}\n"
-            if sub_err.stdout:
-                msg += f"Submission stdout:\n{indent(sub_err.stdout, '  ')}\n"
-            if sub_err.stderr:
-                msg += f"Submission stderr:\n{indent(sub_err.stderr, '  ')}\n"
-
-        raise SubmissionFailure(message=msg)
-
-    def _append_submission_part(self, submit_time: str, submitted_js_idx: List[int]):
+    def _append_submission_part(self, submit_time: str, submitted_js_idx: list[int]):
         self._submission_parts[submit_time] = submitted_js_idx
         self.workflow._store.add_submission_part(
             sub_idx=self.index,
@@ -520,11 +474,11 @@ class Submission(JSONLike):
     @TimeIt.decorator
     def submit(
         self,
-        status,
-        ignore_errors: Optional[bool] = False,
-        print_stdout: Optional[bool] = False,
-        add_to_known: Optional[bool] = True,
-    ) -> List[int]:
+        status: Status | None,
+        ignore_errors: bool = False,
+        print_stdout: bool = False,
+        add_to_known: bool = True,
+    ) -> list[int]:
         """Generate and submit the jobscripts of this submission."""
 
         # if JS_parallelism explicitly requested but store doesn't support, raise:
@@ -550,34 +504,28 @@ class Submission(JSONLike):
 
         # get scheduler, shell and OS version information (also an opportunity to fail
         # before trying to submit jobscripts):
-        js_vers_info = {}
-        for js_indices, sched in self.get_unique_schedulers().items():
+        js_vers_info: dict[int, dict[str, str | list[str]]] = {}
+        for js_indices, sched in self._unique_schedulers:
             try:
                 vers_info = sched.get_version_info()
-            except Exception as err:
-                if ignore_errors:
-                    vers_info = {}
-                else:
-                    raise err
+            except Exception:
+                if not ignore_errors:
+                    raise
+                vers_info = {}
             for _, js_idx in js_indices:
                 if js_idx in outstanding:
-                    if js_idx not in js_vers_info:
-                        js_vers_info[js_idx] = {}
-                    js_vers_info[js_idx].update(vers_info)
+                    js_vers_info.setdefault(js_idx, {}).update(vers_info)
 
-        for js_indices, shell in self.get_unique_shells().items():
+        for js_indices_2, shell in self.get_unique_shells():
             try:
                 vers_info = shell.get_version_info()
-            except Exception as err:
-                if ignore_errors:
-                    vers_info = {}
-                else:
-                    raise err
-            for js_idx in js_indices:
+            except Exception:
+                if not ignore_errors:
+                    raise
+                vers_info = {}
+            for js_idx in js_indices_2:
                 if js_idx in outstanding:
-                    if js_idx not in js_vers_info:
-                        js_vers_info[js_idx] = {}
-                    js_vers_info[js_idx].update(vers_info)
+                    js_vers_info.setdefault(js_idx, {}).update(vers_info)
 
         for js_idx, vers_info_i in js_vers_info.items():
             self.jobscripts[js_idx]._set_version_info(vers_info_i)
@@ -595,9 +543,9 @@ class Submission(JSONLike):
             self._write_abort_EARs_file()
 
         # map jobscript `index` to (scheduler job ID or process ID, is_array):
-        scheduler_refs = {}
-        submitted_js_idx = []
-        errs = []
+        scheduler_refs: dict[int, tuple[str, bool]] = {}
+        submitted_js_idx: list[int] = []
+        errs: list[JobscriptSubmissionFailure] = []
         for js in self.jobscripts:
             # check not previously submitted:
             if js.index not in outstanding:
@@ -622,14 +570,14 @@ class Submission(JSONLike):
                 continue
 
         if submitted_js_idx:
-            dt_str = datetime.utcnow().strftime(self.app._submission_ts_fmt)
+            dt_str = current_timestamp().strftime(self._app._submission_ts_fmt)
             self._append_submission_part(
                 submit_time=dt_str,
                 submitted_js_idx=submitted_js_idx,
             )
             # add a record of the submission part to the known-submissions file
             if add_to_known:
-                self.app._add_to_known_submissions(
+                self._app._add_to_known_submissions(
                     wk_path=self.workflow.path,
                     wk_id=self.workflow.id_,
                     sub_idx=self.index,
@@ -639,7 +587,7 @@ class Submission(JSONLike):
         if errs and not ignore_errors:
             if status:
                 status.stop()
-            self._raise_failure(submitted_js_idx, errs)
+            raise SubmissionFailure(self.index, submitted_js_idx, errs)
 
         len_js = len(submitted_js_idx)
         print(f"Submitted {len_js} jobscript{'s' if len_js > 1 else ''}.")
@@ -647,24 +595,22 @@ class Submission(JSONLike):
         return submitted_js_idx
 
     @TimeIt.decorator
-    def cancel(self):
+    def cancel(self) -> None:
         """
         Cancel the active jobs for this submission's jobscripts.
         """
-        act_js = list(self.get_active_jobscripts())
-        if not act_js:
+        if not (act_js := self.get_active_jobscripts()):
             print("No active jobscripts to cancel.")
             return
-        for js_indices, sched in self.get_unique_schedulers().items():
+        for js_indices, sched in self._unique_schedulers:
             # filter by active jobscripts:
-            js_idx = [i[1] for i in js_indices if i[1] in act_js]
-            if js_idx:
+            if js_idx := [i[1] for i in js_indices if i[1] in act_js]:
                 print(
                     f"Cancelling jobscripts {js_idx!r} of submission {self.index} of "
                     f"workflow {self.workflow.name!r}."
                 )
                 jobscripts = [self.jobscripts[i] for i in js_idx]
-                sched_refs = [i.scheduler_js_ref for i in jobscripts]
+                sched_refs = [js.scheduler_js_ref for js in jobscripts]
                 sched.cancel_jobs(js_refs=sched_refs, jobscripts=jobscripts)
             else:
                 print("No active jobscripts to cancel.")