hpcflow-new2 0.2.0a159__py3-none-any.whl → 0.2.0a160__py3-none-any.whl

hpcflow/sdk/persistence/zarr.py

@@ -42,6 +42,7 @@ from hpcflow.sdk.log import TimeIt
 blosc.use_threads = False  # hpcflow is a multiprocess program in general
 
 
+@TimeIt.decorator
 def _zarr_get_coord_selection(arr, selection, logger):
     @retry(
         RuntimeError,
@@ -51,6 +52,7 @@ def _zarr_get_coord_selection(arr, selection, logger):
         jitter=(0, 5),
         logger=logger,
     )
+    @TimeIt.decorator
     def _inner(arr, selection):
         return arr.get_coordinate_selection(selection)
 
@@ -594,14 +596,21 @@ class ZarrPersistentStore(PersistentStore):
         if attrs != attrs_orig:
             arr.attrs.put(attrs)
 
-    def _update_EAR_submission_index(self, EAR_id: int, sub_idx: int):
+    @TimeIt.decorator
+    def _update_EAR_submission_indices(self, sub_indices: Dict[int:int]):
+        EAR_IDs = list(sub_indices.keys())
+        EARs = self._get_persistent_EARs(EAR_IDs)
+
         arr = self._get_EARs_arr(mode="r+")
         attrs_orig = arr.attrs.asdict()
         attrs = copy.deepcopy(attrs_orig)
 
-        EAR_i = self._get_persistent_EARs([EAR_id])[EAR_id]
-        EAR_i = EAR_i.update(submission_idx=sub_idx)
-        arr[EAR_id] = EAR_i.encode(attrs, self.ts_fmt)
+        encoded_EARs = []
+        for EAR_ID_i, sub_idx_i in sub_indices.items():
+            new_EAR_i = EARs[EAR_ID_i].update(submission_idx=sub_idx_i)
+            # seems to be a Zarr bug that prevents `set_coordinate_selection` with an
+            # object array, so set one-by-one:
+            arr[EAR_ID_i] = new_EAR_i.encode(attrs, self.ts_fmt)
 
         if attrs != attrs_orig:
             arr.attrs.put(attrs)
@@ -686,24 +695,6 @@ class ZarrPersistentStore(PersistentStore):
             f"PersistentStore._append_parameters: finished adding {len(params)} parameters."
         )
 
-    def _set_parameter_value(self, param_id: int, value: Any, is_file: bool):
-        """Set an unset persistent parameter."""
-
-        # the `decode` call in `_get_persistent_parameters` should be quick:
-        param_i = self._get_persistent_parameters([param_id])[param_id]
-        if is_file:
-            param_i = param_i.set_file(value)
-        else:
-            param_i = param_i.set_data(value)
-        dat_i = param_i.encode(
-            root_group=self._get_parameter_user_array_group(mode="r+"),
-            arr_path=self._param_data_arr_grp_name(param_i.id_),
-        )
-
-        # no need to update sources array:
-        base_arr = self._get_parameter_base_array(mode="r+")
-        base_arr[param_id] = dat_i
-
     def _set_parameter_values(self, set_parameters: Dict[int, Tuple[Any, bool]]):
         """Set multiple unset persistent parameters."""
 
@@ -747,9 +738,16 @@ class ZarrPersistentStore(PersistentStore):
         with self.using_resource("attrs", "update") as md:
             md["template_components"] = tc
 
+    @TimeIt.decorator
     def _get_num_persistent_tasks(self) -> int:
-        """Get the number of persistent elements."""
-        return len(self._get_tasks_arr())
+        """Get the number of persistent tasks."""
+        if self.use_cache and self.num_tasks_cache is not None:
+            num = self.num_tasks_cache
+        else:
+            num = len(self._get_tasks_arr())
+        if self.use_cache and self.num_tasks_cache is None:
+            self.num_tasks_cache = num
+        return num
 
     def _get_num_persistent_loops(self) -> int:
         """Get the number of persistent loops."""
@@ -932,32 +930,39 @@ class ZarrPersistentStore(PersistentStore):
         with self.using_resource("attrs", "read") as attrs:
             return attrs["template"]
 
-    def _get_persistent_tasks(
-        self, id_lst: Optional[Iterable[int]] = None
-    ) -> Dict[int, ZarrStoreTask]:
-        with self.using_resource("attrs", action="read") as attrs:
-            task_dat = {}
-            elem_IDs = []
-            for idx, i in enumerate(attrs["tasks"]):
-                i = copy.deepcopy(i)
-                elem_IDs.append(i.pop("element_IDs_idx"))
-                if id_lst is None or i["id_"] in id_lst:
-                    task_dat[i["id_"]] = {**i, "index": idx}
-        if task_dat:
-            try:
-                elem_IDs_arr_dat = self._get_tasks_arr().get_coordinate_selection(
-                    elem_IDs
-                )
-            except zarr.errors.BoundsCheckError:
-                raise MissingStoreTaskError(elem_IDs) from None  # TODO: not an ID list
-
-            return {
-                id_: ZarrStoreTask.decode({**i, "element_IDs": elem_IDs_arr_dat[id_]})
-                for idx, (id_, i) in enumerate(task_dat.items())
-            }
-        else:
-            return {}
+    @TimeIt.decorator
+    def _get_persistent_tasks(self, id_lst: Iterable[int]) -> Dict[int, ZarrStoreTask]:
+        tasks, id_lst = self._get_cached_persistent_tasks(id_lst)
+        if id_lst:
+            with self.using_resource("attrs", action="read") as attrs:
+                task_dat = {}
+                elem_IDs = []
+                for idx, i in enumerate(attrs["tasks"]):
+                    i = copy.deepcopy(i)
+                    elem_IDs.append(i.pop("element_IDs_idx"))
+                    if id_lst is None or i["id_"] in id_lst:
+                        task_dat[i["id_"]] = {**i, "index": idx}
+            if task_dat:
+                try:
+                    elem_IDs_arr_dat = self._get_tasks_arr().get_coordinate_selection(
+                        elem_IDs
+                    )
+                except zarr.errors.BoundsCheckError:
+                    raise MissingStoreTaskError(
+                        elem_IDs
+                    ) from None  # TODO: not an ID list
+
+                new_tasks = {
+                    id_: ZarrStoreTask.decode({**i, "element_IDs": elem_IDs_arr_dat[id_]})
+                    for idx, (id_, i) in enumerate(task_dat.items())
+                }
+            else:
+                new_tasks = {}
+            self.task_cache.update(new_tasks)
+            tasks.update(new_tasks)
+        return tasks
 
+    @TimeIt.decorator
     def _get_persistent_loops(self, id_lst: Optional[Iterable[int]] = None):
         with self.using_resource("attrs", "read") as attrs:
             loop_dat = {
@@ -967,6 +972,7 @@ class ZarrPersistentStore(PersistentStore):
             }
         return loop_dat
 
+    @TimeIt.decorator
     def _get_persistent_submissions(self, id_lst: Optional[Iterable[int]] = None):
         self.logger.debug("loading persistent submissions from the zarr store")
         with self.using_resource("attrs", "read") as attrs:
@@ -989,47 +995,66 @@ class ZarrPersistentStore(PersistentStore):
 
         return subs_dat
 
+    @TimeIt.decorator
     def _get_persistent_elements(
         self, id_lst: Iterable[int]
     ) -> Dict[int, ZarrStoreElement]:
-        arr = self._get_elements_arr()
-        attrs = arr.attrs.asdict()
-        try:
-            elem_arr_dat = arr.get_coordinate_selection(list(id_lst))
-        except zarr.errors.BoundsCheckError:
-            raise MissingStoreElementError(id_lst) from None
-        elem_dat = dict(zip(id_lst, elem_arr_dat))
-        return {k: ZarrStoreElement.decode(v, attrs) for k, v in elem_dat.items()}
+        elems, id_lst = self._get_cached_persistent_elements(id_lst)
+        if id_lst:
+            arr = self._get_elements_arr()
+            attrs = arr.attrs.asdict()
+            try:
+                elem_arr_dat = arr.get_coordinate_selection(id_lst)
+            except zarr.errors.BoundsCheckError:
+                raise MissingStoreElementError(id_lst) from None
+            elem_dat = dict(zip(id_lst, elem_arr_dat))
+            new_elems = {
+                k: ZarrStoreElement.decode(v, attrs) for k, v in elem_dat.items()
+            }
+            self.element_cache.update(new_elems)
+            elems.update(new_elems)
+        return elems
 
+    @TimeIt.decorator
     def _get_persistent_element_iters(
         self, id_lst: Iterable[int]
-    ) -> Dict[int, StoreElementIter]:
-        arr = self._get_iters_arr()
-        attrs = arr.attrs.asdict()
-        try:
-            iter_arr_dat = arr.get_coordinate_selection(list(id_lst))
-        except zarr.errors.BoundsCheckError:
-            raise MissingStoreElementIterationError(id_lst) from None
-        iter_dat = dict(zip(id_lst, iter_arr_dat))
-        return {k: ZarrStoreElementIter.decode(v, attrs) for k, v in iter_dat.items()}
+    ) -> Dict[int, ZarrStoreElementIter]:
+        iters, id_lst = self._get_cached_persistent_element_iters(id_lst)
+        if id_lst:
+            arr = self._get_iters_arr()
+            attrs = arr.attrs.asdict()
+            try:
+                iter_arr_dat = arr.get_coordinate_selection(id_lst)
+            except zarr.errors.BoundsCheckError:
+                raise MissingStoreElementIterationError(id_lst) from None
+            iter_dat = dict(zip(id_lst, iter_arr_dat))
+            new_iters = {
+                k: ZarrStoreElementIter.decode(v, attrs) for k, v in iter_dat.items()
+            }
+            self.element_iter_cache.update(new_iters)
+            iters.update(new_iters)
+        return iters
 
+    @TimeIt.decorator
     def _get_persistent_EARs(self, id_lst: Iterable[int]) -> Dict[int, ZarrStoreEAR]:
-        arr = self._get_EARs_arr()
-        attrs = arr.attrs.asdict()
-
-        try:
-            self.logger.debug(f"_get_persistent_EARs: {list(id_lst)=}")
-            EAR_arr_dat = _zarr_get_coord_selection(arr, list(id_lst), self.logger)
-        except zarr.errors.BoundsCheckError:
-            raise MissingStoreEARError(id_lst) from None
-
-        EAR_dat = dict(zip(id_lst, EAR_arr_dat))
+        runs, id_lst = self._get_cached_persistent_EARs(id_lst)
+        if id_lst:
+            arr = self._get_EARs_arr()
+            attrs = arr.attrs.asdict()
+            try:
+                self.logger.debug(f"_get_persistent_EARs: {id_lst=}")
+                EAR_arr_dat = _zarr_get_coord_selection(arr, id_lst, self.logger)
+            except zarr.errors.BoundsCheckError:
+                raise MissingStoreEARError(id_lst) from None
+            EAR_dat = dict(zip(id_lst, EAR_arr_dat))
+            new_runs = {
+                k: ZarrStoreEAR.decode(EAR_dat=v, attrs=attrs, ts_fmt=self.ts_fmt)
+                for k, v in EAR_dat.items()
+            }
+            self.EAR_cache.update(new_runs)
+            runs.update(new_runs)
 
-        iters = {
-            k: ZarrStoreEAR.decode(EAR_dat=v, attrs=attrs, ts_fmt=self.ts_fmt)
-            for k, v in EAR_dat.items()
-        }
-        return iters
+        return runs
 
     @TimeIt.decorator
     def _get_persistent_parameters(
@@ -1037,39 +1062,49 @@ class ZarrPersistentStore(PersistentStore):
         id_lst: Iterable[int],
         dataset_copy: Optional[bool] = False,
     ) -> Dict[int, ZarrStoreParameter]:
-        base_arr = self._get_parameter_base_array(mode="r")
-        src_arr = self._get_parameter_sources_array(mode="r")
 
-        try:
-            param_arr_dat = base_arr.get_coordinate_selection(list(id_lst))
-            src_arr_dat = src_arr.get_coordinate_selection(list(id_lst))
-        except zarr.errors.BoundsCheckError:
-            raise MissingParameterData(id_lst) from None
-
-        param_dat = dict(zip(id_lst, param_arr_dat))
-        src_dat = dict(zip(id_lst, src_arr_dat))
+        params, id_lst = self._get_cached_persistent_parameters(id_lst)
+        if id_lst:
+            base_arr = self._get_parameter_base_array(mode="r")
+            src_arr = self._get_parameter_sources_array(mode="r")
 
-        params = {
-            k: ZarrStoreParameter.decode(
-                id_=k,
-                data=v,
-                source=src_dat[k],
-                arr_group=self._get_parameter_data_array_group(k),
-                dataset_copy=dataset_copy,
-            )
-            for k, v in param_dat.items()
-        }
+            try:
+                param_arr_dat = base_arr.get_coordinate_selection(list(id_lst))
+                src_arr_dat = src_arr.get_coordinate_selection(list(id_lst))
+            except zarr.errors.BoundsCheckError:
+                raise MissingParameterData(id_lst) from None
+
+            param_dat = dict(zip(id_lst, param_arr_dat))
+            src_dat = dict(zip(id_lst, src_arr_dat))
+
+            new_params = {
+                k: ZarrStoreParameter.decode(
+                    id_=k,
+                    data=v,
+                    source=src_dat[k],
+                    arr_group=self._get_parameter_data_array_group(k),
+                    dataset_copy=dataset_copy,
+                )
+                for k, v in param_dat.items()
+            }
+            self.parameter_cache.update(new_params)
+            params.update(new_params)
 
         return params
 
+    @TimeIt.decorator
     def _get_persistent_param_sources(self, id_lst: Iterable[int]) -> Dict[int, Dict]:
-        src_arr = self._get_parameter_sources_array(mode="r")
-        try:
-            src_arr_dat = src_arr.get_coordinate_selection(list(id_lst))
-        except zarr.errors.BoundsCheckError:
-            raise MissingParameterData(id_lst) from None
-
-        return dict(zip(id_lst, src_arr_dat))
+        sources, id_lst = self._get_cached_persistent_param_sources(id_lst)
+        if id_lst:
+            src_arr = self._get_parameter_sources_array(mode="r")
+            try:
+                src_arr_dat = src_arr.get_coordinate_selection(list(id_lst))
+            except zarr.errors.BoundsCheckError:
+                raise MissingParameterData(id_lst) from None
+            new_sources = dict(zip(id_lst, src_arr_dat))
+            self.param_sources_cache.update(new_sources)
+            sources.update(new_sources)
+        return sources
 
     def _get_persistent_parameter_set_status(
         self, id_lst: Iterable[int]

hpcflow/sdk/submission/jobscript.py

@@ -23,6 +23,7 @@ from hpcflow.sdk.submission.schedulers import Scheduler
 from hpcflow.sdk.submission.shells import get_shell
 
 
+@TimeIt.decorator
 def generate_EAR_resource_map(
     task: app.WorkflowTask,
     loop_idx: Dict,
@@ -77,6 +78,7 @@ def generate_EAR_resource_map(
     )
 
 
+@TimeIt.decorator
 def group_resource_map_into_jobscripts(
     resource_map: Union[List, NDArray],
     none_val: Any = -1,
@@ -148,6 +150,7 @@ def group_resource_map_into_jobscripts(
     return jobscripts, js_map
 
 
+@TimeIt.decorator
 def resolve_jobscript_dependencies(jobscripts, element_deps):
     # first pass is to find the mappings between jobscript elements:
     jobscript_deps = {}
@@ -218,6 +221,7 @@ def resolve_jobscript_dependencies(jobscripts, element_deps):
     return jobscript_deps
 
 
+@TimeIt.decorator
 def merge_jobscripts_across_tasks(jobscripts: Dict) -> Dict:
     """Try to merge jobscripts between tasks.
 
@@ -275,6 +279,7 @@ def merge_jobscripts_across_tasks(jobscripts: Dict) -> Dict:
     return jobscripts
 
 
+@TimeIt.decorator
 def jobscripts_to_list(jobscripts: Dict[int, Dict]) -> List[Dict]:
     """Convert the jobscripts dict to a list, normalising jobscript indices so they refer
     to list indices; also remove `resource_hash`."""
@@ -397,8 +402,11 @@ class Jobscript(JSONLike):
         return self._workflow_app_alias
 
     def get_commands_file_name(self, js_action_idx, shell=None):
-        shell = shell or self.shell
-        return f"js_{self.index}_act_{js_action_idx}{shell.JS_EXT}"
+        return self.app.RunDirAppFiles.get_commands_file_name(
+            js_idx=self.index,
+            js_action_idx=js_action_idx,
+            shell=shell or self.shell,
+        )
 
     @property
     def task_insert_IDs(self):
@@ -421,6 +429,7 @@ class Jobscript(JSONLike):
         return self.EAR_ID.flatten()
 
     @property
+    @TimeIt.decorator
     def all_EARs(self) -> List:
         if not self._all_EARs:
             self._all_EARs = self.workflow.get_EARs_from_IDs(self.all_EAR_IDs)
@@ -439,6 +448,7 @@ class Jobscript(JSONLike):
         return self._dependencies
 
     @property
+    @TimeIt.decorator
     def start_time(self):
         """Get the first start time from all EARs."""
         if not self.is_submitted:
@@ -450,6 +460,7 @@ class Jobscript(JSONLike):
             return None
 
     @property
+    @TimeIt.decorator
     def end_time(self):
         """Get the last end time from all EARs."""
         if not self.is_submitted:
@@ -732,6 +743,7 @@ class Jobscript(JSONLike):
         )
         return loop_idx
 
+    @TimeIt.decorator
     def write_EAR_ID_file(self):
         """Write a text file with `num_elements` lines and `num_actions` delimited tokens
         per line, representing whether a given EAR must be executed."""
@@ -745,6 +757,7 @@ class Jobscript(JSONLike):
                 delimiter=self._EAR_files_delimiter,
             )
 
+    @TimeIt.decorator
     def write_element_run_dir_file(self, run_dirs: List[List[Path]]):
         """Write a text file with `num_elements` lines and `num_actions` delimited tokens
         per line, representing the working directory for each EAR.
@@ -764,6 +777,7 @@ class Jobscript(JSONLike):
                 delimiter=self._EAR_files_delimiter,
             )
 
+    @TimeIt.decorator
     def compose_jobscript(
         self,
         deps: Optional[Dict] = None,
@@ -822,7 +836,7 @@ class Jobscript(JSONLike):
                 "workflow_app_alias": self.workflow_app_alias,
                 "env_setup": env_setup,
                 "app_invoc": app_invoc,
-                "app_package_name": self.app.package_name,
+                "run_log_file": self.app.RunDirAppFiles.get_log_file_name(),
                 "config_dir": str(self.app.config.config_directory),
                 "config_invoc_key": self.app.config.config_key,
                 "workflow_path": self.workflow.path,
@@ -869,7 +883,7 @@ class Jobscript(JSONLike):
             EAR_files_delimiter=self._EAR_files_delimiter,
             workflow_app_alias=self.workflow_app_alias,
             commands_file_name=self.get_commands_file_name(r"${JS_act_idx}", shell=shell),
-            app_package_name=self.app.package_name,
+            run_stream_file=self.app.RunDirAppFiles.get_std_file_name(),
         )
 
         out = header
@@ -891,6 +905,7 @@ class Jobscript(JSONLike):
 
         return out
 
+    @TimeIt.decorator
     def write_jobscript(
         self,
         os_name: str = None,
@@ -953,6 +968,7 @@ class Jobscript(JSONLike):
 
         return run_dirs
 
+    @TimeIt.decorator
     def _launch_direct_js_win(self):
         # this is a "trick" to ensure we always get a fully detached new process (with no
         # parent); the `powershell.exe -Command` process exits after running the inner
@@ -996,6 +1012,7 @@ class Jobscript(JSONLike):
         process_ID = int(self.direct_win_pid_file_path.read_text())
         return process_ID
 
+    @TimeIt.decorator
     def _launch_direct_js_posix(self) -> int:
         # direct submission; submit jobscript asynchronously:
         # detached process, avoid interrupt signals propagating to the subprocess:
@@ -1143,6 +1160,7 @@ class Jobscript(JSONLike):
             out["num_js_elements"] = self.num_elements
         return out
 
+    @TimeIt.decorator
     def get_active_states(
         self, as_json: bool = False
     ) -> Dict[int, JobscriptElementState]:

hpcflow/sdk/submission/shells/bash.py

@@ -24,7 +24,7 @@ class Bash(Shell):
         {workflow_app_alias} () {{
         (
         {env_setup}{app_invoc}\\
-                --with-config log_file_path "`pwd`/{app_package_name}.log"\\
+                --with-config log_file_path "`pwd`/{run_log_file}"\\
                 --config-dir "{config_dir}"\\
                 --config-key "{config_invoc_key}"\\
                 "$@"
@@ -70,7 +70,7 @@ class Bash(Shell):
 
           run_dir="$(cut -d'{EAR_files_delimiter}' -f $(($JS_act_idx + 1)) <<< $elem_run_dirs)"
           cd "$WK_PATH/$run_dir"
-          app_stream_file="`pwd`/{app_package_name}_std.txt"
+          app_stream_file="`pwd`/{run_stream_file}"
 
           skip=`{workflow_app_alias} internal workflow "$WK_PATH_ARG" get-ear-skipped $EAR_ID 2>> "$app_stream_file"`
           exc_sk=$?

hpcflow/sdk/submission/shells/powershell.py

@@ -22,7 +22,7 @@ class WindowsPowerShell(Shell):
         function {workflow_app_alias} {{
             & {{
         {env_setup}{app_invoc} `
-                    --with-config log_file_path "$pwd/{app_package_name}.log" `
+                    --with-config log_file_path "$pwd/{run_log_file}" `
                     --config-dir "{config_dir}" `
                     --config-key "{config_invoc_key}" `
                     $args
@@ -83,7 +83,7 @@ class WindowsPowerShell(Shell):
             $run_dir = ($elem_run_dirs -split "{EAR_files_delimiter}")[$JS_act_idx]
             $run_dir_abs = "$WK_PATH\\$run_dir"
             Set-Location $run_dir_abs
-            $app_stream_file = "$pwd/{app_package_name}_std.txt"
+            $app_stream_file = "$pwd/{run_stream_file}"
 
             $skip = {workflow_app_alias} internal workflow $WK_PATH get-ear-skipped $EAR_ID 2>> $app_stream_file
             $exc_sk = $LASTEXITCODE

hpcflow/sdk/submission/submission.py

@@ -82,6 +82,7 @@ class Submission(JSONLike):
         for js_idx, js in enumerate(self.jobscripts):
             js._index = js_idx
 
+    @TimeIt.decorator
     def _set_environments(self):
         filterable = ElementResources.get_env_instance_filterable_attributes()
 
@@ -167,31 +168,36 @@ class Submission(JSONLike):
             ]
         return self._submission_parts_lst
 
+    @TimeIt.decorator
     def get_start_time(self, submit_time: str) -> Union[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:
-            if self.jobscripts[i].start_time:
-                all_part_starts.append(self.jobscripts[i].start_time)
+            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
 
+    @TimeIt.decorator
     def get_end_time(self, submit_time: str) -> Union[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:
-            if self.jobscripts[i].end_time:
-                all_part_ends.append(self.jobscripts[i].end_time)
+            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
 
     @property
+    @TimeIt.decorator
     def start_time(self):
         """Get the first non-None start time over all submission parts."""
         all_start_times = []
@@ -205,6 +211,7 @@ class Submission(JSONLike):
             return None
 
     @property
+    @TimeIt.decorator
     def end_time(self):
         """Get the final non-None end time over all submission parts."""
         all_end_times = []
@@ -278,6 +285,7 @@ class Submission(JSONLike):
         return [i for js in self.jobscripts for i in js.all_EARs]
 
     @property
+    @TimeIt.decorator
     def EARs_by_elements(self):
         task_elem_EARs = defaultdict(lambda: defaultdict(list))
         for i in self.all_EARs:
@@ -292,6 +300,7 @@ class Submission(JSONLike):
     def abort_EARs_file_path(self):
         return self.path / self.abort_EARs_file_name
 
+    @TimeIt.decorator
     def get_active_jobscripts(
         self, as_json: bool = False
     ) -> List[Tuple[int, Dict[int, JobscriptElementState]]]:
@@ -429,7 +438,8 @@ class Submission(JSONLike):
         supports_JS_para = self.workflow._store._features.jobscript_parallelism
         if self.JS_parallelism:
             if not supports_JS_para:
-                status.stop()
+                if status:
+                    status.stop()
                 raise ValueError(
                     f"Store type {self.workflow._store!r} does not support jobscript "
                     f"parallelism."
@@ -508,7 +518,8 @@ class Submission(JSONLike):
                 continue
 
             try:
-                status.update(f"Submitting jobscript {js.index}...")
+                if status:
+                    status.update(f"Submitting jobscript {js.index}...")
                 js_ref_i = js.submit(scheduler_refs, print_stdout=print_stdout)
                 scheduler_refs[js.index] = (js_ref_i, js.is_array)
                 submitted_js_idx.append(js.index)
@@ -533,7 +544,8 @@ class Submission(JSONLike):
                 )
 
         if errs and not ignore_errors:
-            status.stop()
+            if status:
+                status.stop()
             self._raise_failure(submitted_js_idx, errs)
 
         len_js = len(submitted_js_idx)
@@ -541,6 +553,7 @@ class Submission(JSONLike):
 
         return submitted_js_idx
 
+    @TimeIt.decorator
     def cancel(self):
         act_js = list(self.get_active_jobscripts())
         if not act_js: