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

hpcflow/sdk/core/run_dir_files.py

@@ -3,82 +3,55 @@ Model of files in the run directory.
 """
 
 from __future__ import annotations
-import re
 from typing import Any, TYPE_CHECKING
 from hpcflow.sdk.core.app_aware import AppAware
 from hpcflow.sdk.core.utils import JSONLikeDirSnapShot
 
 if TYPE_CHECKING:
-    from re import Pattern
-    from typing_extensions import ClassVar
     from ..submission.shells.base import Shell
+    from .types import BlockActionKey
 
 
 class RunDirAppFiles(AppAware):
     """A class to encapsulate the naming/recognition of app-created files within run
     directories."""
 
-    __CMD_FILES_RE_PATTERN: ClassVar[Pattern] = re.compile(r"js_\d+_act_\d+\.?\w*")
-
-    @classmethod
-    def get_log_file_name(cls) -> str:
-        """File name for the app log file."""
-        return f"{cls._app.package_name}.log"
-
-    @classmethod
-    def get_std_file_name(cls) -> str:
-        """File name for stdout and stderr streams from the app."""
-        return f"{cls._app.package_name}_std.txt"
-
     @staticmethod
-    def get_run_file_prefix(js_idx: int | str, js_action_idx: int | str) -> str:
+    def get_run_file_prefix(block_act_key: BlockActionKey) -> str:
         """
         Get the common prefix for files associated with a run.
         """
-        return f"js_{js_idx}_act_{js_action_idx}"
+        return f"js_{block_act_key[0]}_block_{block_act_key[1]}_act_{block_act_key[2]}"
 
     @classmethod
-    def get_commands_file_name(
-        cls, js_idx: int | str, js_action_idx: int | str, shell: Shell
-    ) -> str:
+    def get_commands_file_name(cls, block_act_key: BlockActionKey, shell: Shell) -> str:
         """
         Get the name of the file containing commands.
         """
-        return cls.get_run_file_prefix(js_idx, js_action_idx) + shell.JS_EXT
+        return cls.get_run_file_prefix(block_act_key) + shell.JS_EXT
 
     @classmethod
-    def get_run_param_dump_file_prefix(
-        cls, js_idx: int | str, js_action_idx: int | str
-    ) -> str:
+    def get_run_param_dump_file_prefix(cls, block_act_key: BlockActionKey) -> str:
         """Get the prefix to a file in the run directory that the app will dump parameter
         data to."""
-        return cls.get_run_file_prefix(js_idx, js_action_idx) + "_inputs"
+        return cls.get_run_file_prefix(block_act_key) + "_inputs"
 
     @classmethod
-    def get_run_param_load_file_prefix(
-        cls, js_idx: int | str, js_action_idx: int | str
-    ) -> str:
+    def get_run_param_load_file_prefix(cls, block_act_key: BlockActionKey) -> str:
         """Get the prefix to a file in the run directory that the app will load parameter
         data from."""
-        return cls.get_run_file_prefix(js_idx, js_action_idx) + "_outputs"
+        return cls.get_run_file_prefix(block_act_key) + "_outputs"
 
     @classmethod
-    def take_snapshot(cls) -> dict[str, Any]:
+    def take_snapshot(cls, root_path=None) -> dict[str, Any]:
         """
-        Take a :py:class:`JSONLikeDirSnapShot`, and process to ignore files created by
-        the app.
+        Take a :py:class:`JSONLikeDirSnapShot`.
 
         This includes command files that are invoked by jobscripts, the app log file, and
         the app standard out/error file.
         """
         snapshot = JSONLikeDirSnapShot()
-        snapshot.take(".")
-        ss_js = snapshot.to_json_like()
+        snapshot.take(root_path or ".")
+        ss_js = snapshot.to_json_like(use_strings=True)
         ss_js.pop("root_path")  # always the current working directory of the run
-        excluded = {cls.get_log_file_name(), cls.get_std_file_name()}
-        data: dict[str, Any] = ss_js["data"]
-        for filename in tuple(data):
-            if filename in excluded or cls.__CMD_FILES_RE_PATTERN.match(filename):
-                data.pop(filename)
-
         return ss_js

hpcflow/sdk/core/skip_reason.py

@@ -0,0 +1,7 @@
+import enum
+
+
+class SkipReason(enum.Enum):
+    NOT_SKIPPED = 0
+    UPSTREAM_FAILURE = 1
+    LOOP_TERMINATION = 2

hpcflow/sdk/core/task.py

@@ -67,12 +67,13 @@ if TYPE_CHECKING:
         InputValue,
         InputSource,
         ValueSequence,
+        MultiPathSequence,
         SchemaInput,
         SchemaOutput,
         ParameterPath,
     )
     from .rule import Rule
-    from .task_schema import TaskObjective, TaskSchema
+    from .task_schema import TaskObjective, TaskSchema, MetaTaskSchema
     from .types import (
         MultiplicityDescriptor,
         RelevantData,
@@ -132,6 +133,8 @@ class ElementSet(JSONLike):
         Input files to the set of elements.
     sequences: list[~hpcflow.app.ValueSequence]
         Input value sequences to parameterise over.
+    multi_path_sequences: list[~hpcflow.app.MultiPathSequence]
+        Multi-path sequences to parameterise over.
     resources: ~hpcflow.app.ResourceList
         Resources to use for the set of elements.
     repeats: list[dict]
@@ -154,9 +157,10 @@ class ElementSet(JSONLike):
         If True, if more than one parameter is sourced from the same task, then allow
         these sources to come from distinct element sub-sets. If False (default),
         only the intersection of element sub-sets for all parameters are included.
-    merge_envs: bool
-        If True, merge ``environments`` into ``resources`` using the "any" scope. If
-        False, ``environments`` are ignored. This is required on first initialisation,
+    is_creation: bool
+        If True, merge ``environments`` into ``resources`` using the "any" scope, and
+        merge sequences belonging to multi-path sequences into the value-sequences list.
+        If False, ``environments`` are ignored. This is required on first initialisation,
         but not on subsequent re-initialisation from a persistent workflow.
     """
 
@@ -188,6 +192,12 @@ class ElementSet(JSONLike):
             is_multiple=True,
             parent_ref="_element_set",
         ),
+        ChildObjectSpec(
+            name="multi_path_sequences",
+            class_name="MultiPathSequence",
+            is_multiple=True,
+            parent_ref="_element_set",
+        ),
         ChildObjectSpec(
             name="input_sources",
             class_name="InputSource",
@@ -207,6 +217,7 @@ class ElementSet(JSONLike):
         inputs: list[InputValue] | dict[str, Any] | None = None,
         input_files: list[InputFile] | None = None,
         sequences: list[ValueSequence] | None = None,
+        multi_path_sequences: list[MultiPathSequence] | None = None,
         resources: Resources = None,
         repeats: list[RepeatsDescriptor] | int | None = None,
         groups: list[ElementGroup] | None = None,
@@ -216,7 +227,7 @@ class ElementSet(JSONLike):
         environments: Mapping[str, Mapping[str, Any]] | None = None,
         sourceable_elem_iters: list[int] | None = None,
         allow_non_coincident_task_sources: bool = False,
-        merge_envs: bool = True,
+        is_creation: bool = True,
     ):
         #: Inputs to the set of elements.
         self.inputs = self.__decode_inputs(inputs or [])
@@ -230,6 +241,8 @@ class ElementSet(JSONLike):
         self.resources = self._app.ResourceList.normalise(resources)
         #: Input value sequences to parameterise over.
         self.sequences = sequences or []
+        #: Input value multi-path sequences to parameterise over.
+        self.multi_path_sequences = multi_path_sequences or []
         #: Input source descriptors.
         self.input_sources = input_sources or {}
         #: How to handle nesting of iterations.
@@ -244,9 +257,11 @@ class ElementSet(JSONLike):
         self.sourceable_elem_iters = sourceable_elem_iters
         #: Whether to allow sources to come from distinct element sub-sets.
         self.allow_non_coincident_task_sources = allow_non_coincident_task_sources
-        #: Whether to merge ``environments`` into ``resources`` using the "any" scope
-        #: on first initialisation.
-        self.merge_envs = merge_envs
+        #: Whether this initialisation is the first for this data (i.e. not a
+        #: reconstruction from persistent workflow data), in which case, we merge
+        #: ``environments`` into ``resources`` using the "any" scope, and merge any multi-
+        #: path sequences into the sequences list.
+        self.is_creation = is_creation
         self.original_input_sources: dict[str, list[InputSource]] | None = None
         self.original_nesting_order: dict[str, float] | None = None
 
@@ -260,16 +275,23 @@ class ElementSet(JSONLike):
         # assigned by WorkflowTask._add_element_set
         self._element_local_idx_range: list[int] | None = None
 
-        # merge `environments` into element set resources (this mutates `resources`, and
-        # should only happen on creation of the element set, not re-initialisation from a
-        # persistent workflow):
-        if self.environments and self.merge_envs:
-            self.resources.merge_one(
-                self._app.ResourceSpec(scope="any", environments=self.environments)
-            )
-            self.merge_envs = False
+        if self.is_creation:
+
+            # merge `environments` into element set resources (this mutates `resources`, and
+            # should only happen on creation of the element set, not re-initialisation from a
+            # persistent workflow):
+            if self.environments:
+                self.resources.merge_one(
+                    self._app.ResourceSpec(scope="any", environments=self.environments)
+                )
+            # note: `env_preset` is merged into resources by the Task init.
 
-        # note: `env_preset` is merged into resources by the Task init.
+            # merge sequences belonging to multi-path sequences into the value-sequences list:
+            if self.multi_path_sequences:
+                for mp_seq in self.multi_path_sequences:
+                    mp_seq._move_to_sequence_list(self.sequences)
+
+            self.is_creation = False
 
     def __deepcopy__(self, memo: dict[int, Any] | None) -> Self:
         dct = self.to_dict()
@@ -450,6 +472,7 @@ class ElementSet(JSONLike):
         inputs: list[InputValue] | dict[str, Any] | None = None,
         input_files: list[InputFile] | None = None,
         sequences: list[ValueSequence] | None = None,
+        multi_path_sequences: list[MultiPathSequence] | None = None,
         resources: Resources = None,
         repeats: list[RepeatsDescriptor] | int | None = None,
         groups: list[ElementGroup] | None = None,
@@ -468,6 +491,7 @@ class ElementSet(JSONLike):
             inputs,
             input_files,
             sequences,
+            multi_path_sequences,
             resources,
             repeats,
             groups,
@@ -692,6 +716,9 @@ class Task(JSONLike):
         A list of `InputValue` objects.
     input_files: list[~hpcflow.app.InputFile]
     sequences: list[~hpcflow.app.ValueSequence]
+        Input value sequences to parameterise over.
+    multi_path_sequences: list[~hpcflow.app.MultiPathSequence]
+        Multi-path sequences to parameterise over.
     input_sources: dict[str, ~hpcflow.app.InputSource]
     nesting_order: list
     env_preset: str
@@ -745,6 +772,7 @@ class Task(JSONLike):
         inputs: list[InputValue] | dict[str, Any] | None = None,
         input_files: list[InputFile] | None = None,
         sequences: list[ValueSequence] | None = None,
+        multi_path_sequences: list[MultiPathSequence] | None = None,
         input_sources: dict[str, list[InputSource]] | None = None,
         nesting_order: dict[str, float] | None = None,
         env_preset: str | None = None,
@@ -790,6 +818,7 @@ class Task(JSONLike):
             inputs=inputs,
             input_files=input_files,
             sequences=sequences,
+            multi_path_sequences=multi_path_sequences,
             resources=resources,
             repeats=repeats,
             groups=groups,
@@ -1000,9 +1029,11 @@ class Task(JSONLike):
         )
 
         return [
-            f"{task.name}_{task_name_rep_idx[idx]}"
-            if task_name_rep_idx[idx] > 0
-            else task.name
+            (
+                f"{task.name}_{task_name_rep_idx[idx]}"
+                if task_name_rep_idx[idx] > 0
+                else task.name
+            )
             for idx, task in enumerate(tasks)
         ]
 
@@ -1684,6 +1715,7 @@ class WorkflowTask(AppAware):
         return self._element_IDs + self._pending_element_IDs
 
     @property
+    @TimeIt.decorator
     def num_elements(self) -> int:
         """
         The number of elements associated with this task.
@@ -1891,16 +1923,18 @@ class WorkflowTask(AppAware):
             input_data_idx[key] = list(seq_dat_ref)
             sequence_idx[key] = list(range(len(seq_dat_ref)))
             try:
-                key_ = key.removeprefix("inputs.")
+                key_ = key.split("inputs.")[1]
             except IndexError:
-                pass
+                # e.g. "resources."
+                key_ = ""
             try:
                 # TODO: wouldn't need to do this if we raise when an ValueSequence is
                 # provided for a parameter whose inputs sources do not include the local
                 # value.
-                source_idx[key] = [
-                    element_set.input_sources[key_].index(loc_inp_src)
-                ] * len(seq_dat_ref)
+                if key_:
+                    source_idx[key] = [
+                        element_set.input_sources[key_].index(loc_inp_src)
+                    ] * len(seq_dat_ref)
             except ValueError:
                 pass
 
@@ -2942,7 +2976,7 @@ class WorkflowTask(AppAware):
         return params
 
     @staticmethod
-    def __get_relevant_paths(
+    def _get_relevant_paths(
         data_index: Mapping[str, Any], path: list[str], children_of: str | None = None
     ) -> Mapping[str, RelevantPath]:
         relevant_paths: dict[str, RelevantPath] = {}
@@ -2968,7 +3002,12 @@ class WorkflowTask(AppAware):
         return relevant_paths
 
     def __get_relevant_data_item(
-        self, path: str | None, path_i: str, data_idx_ij: int, raise_on_unset: bool
+        self,
+        path: str | None,
+        path_i: str,
+        data_idx_ij: int,
+        raise_on_unset: bool,
+        len_dat_idx: int = 1,
     ) -> tuple[Any, bool, str | None]:
         if path_i.startswith("repeats."):
             # data is an integer repeats index, rather than a parameter ID:
@@ -3002,6 +3041,13 @@ class WorkflowTask(AppAware):
                 data_j = param_j.data
         if raise_on_unset and not is_set_i:
             raise UnsetParameterDataError(path, path_i)
+        if not is_set_i and self.workflow._is_tracking_unset:
+            src_run_id = param_j.source.get("EAR_ID")
+            unset_trackers = self.workflow._tracked_unset
+            assert src_run_id is not None
+            assert unset_trackers is not None
+            unset_trackers[path_i].run_ids.add(src_run_id)
+            unset_trackers[path_i].group_size = len_dat_idx
         return data_j, is_set_i, meth_i
 
     def __get_relevant_data(
@@ -3029,7 +3075,7 @@ class WorkflowTask(AppAware):
             is_param_set_i: list[bool] = []
             for data_idx_ij in data_idx_i:
                 data_j, is_set_i, meth_i = self.__get_relevant_data_item(
-                    path, path_i, data_idx_ij, raise_on_unset
+                    path, path_i, data_idx_ij, raise_on_unset, len_dat_idx=len(data_idx_i)
                 )
                 data_i.append(data_j)
                 methods_i.append(meth_i)
@@ -3041,6 +3087,7 @@ class WorkflowTask(AppAware):
                 "is_set": is_param_set_i,
                 "is_multi": True,
             }
+
         if not raise_on_unset:
             to_remove: set[str] = set()
             for key, dat_info in relevant_data.items():
@@ -3229,13 +3276,38 @@ class WorkflowTask(AppAware):
         """Get element data from the persistent store."""
         path_split = [] if not path else path.split(".")
 
-        if not (relevant_paths := self.__get_relevant_paths(data_index, path_split)):
+        if not (relevant_paths := self._get_relevant_paths(data_index, path_split)):
             if raise_on_missing:
                 # TODO: custom exception?
                 raise ValueError(f"Path {path!r} does not exist in the element data.")
             return default
 
         relevant_data_idx = {k: v for k, v in data_index.items() if k in relevant_paths}
+
+        cache = self.workflow._merged_parameters_cache
+        use_cache = (
+            self.workflow._use_merged_parameters_cache
+            and raise_on_missing is False
+            and raise_on_unset is False
+            and default is None  # cannot cache on default value, may not be hashable
+        )
+        add_to_cache = False
+        if use_cache:
+            # generate the key:
+            dat_idx_cache: list[tuple[str, tuple[int, ...] | int]] = []
+            for k, v in sorted(relevant_data_idx.items()):
+                dat_idx_cache.append((k, tuple(v) if isinstance(v, list) else v))
+            cache_key = (path, tuple(dat_idx_cache))
+
+            # check for cache hit:
+            if cache_key in cache:
+                self._app.logger.debug(
+                    f"_get_merged_parameter_data: cache hit with key: {cache_key}"
+                )
+                return cache[cache_key]
+            else:
+                add_to_cache = True
+
         PV_classes = self._paths_to_PV_classes(*relevant_paths, path)
         relevant_data = self.__get_relevant_data(relevant_data_idx, raise_on_unset, path)
 
@@ -3248,7 +3320,7 @@ class WorkflowTask(AppAware):
         except MayNeedObjectError as err:
             path_to_init = err.path
             path_to_init_split = path_to_init.split(".")
-            relevant_paths = self.__get_relevant_paths(data_index, path_to_init_split)
+            relevant_paths = self._get_relevant_paths(data_index, path_to_init_split)
             PV_classes = self._paths_to_PV_classes(*relevant_paths, path_to_init)
             relevant_data_idx = {
                 k: v for k, v in data_index.items() if k in relevant_paths
@@ -3296,6 +3368,14 @@ class WorkflowTask(AppAware):
                 raise ValueError(f"Path {path!r} does not exist in the element data.")
             current_val = default
 
+        if add_to_cache:
+            self._app.logger.debug(
+                f"_get_merged_parameter_data: adding to cache with key: {cache_key!r}"
+            )
+            # tuple[str | None, tuple[tuple[str, tuple[int, ...] | int], ...]]
+            # tuple[str | None, tuple[tuple[str, tuple[int, ...] | int], ...]] | None
+            cache[cache_key] = current_val
+
         return current_val
 
 
@@ -3626,3 +3706,12 @@ class ElementPropagation(AppAware):
 
 #: A task used as a template for other tasks.
 TaskTemplate: TypeAlias = Task
+
+
+class MetaTask(JSONLike):
+    def __init__(self, schema: MetaTaskSchema, tasks: Sequence[Task]):
+        self.schema = schema
+        self.tasks = tasks
+
+        # TODO: validate schema's inputs and outputs are inputs and outputs of `tasks`
+        # schemas

hpcflow/sdk/core/task_schema.py

@@ -915,3 +915,71 @@ class TaskSchema(JSONLike):
     def multi_input_types(self) -> list[str]:
         """Get a list of input types that have multiple labels."""
         return [inp.parameter.typ for inp in self.inputs if inp.multiple]
+
+
+class MetaTaskSchema(TaskSchema):
+    """Class to represent a task schema with no actions, that can be used to represent the
+    effect of multiple task schemas.
+
+    Parameters
+    ----------
+    objective:
+        This is a string representing the objective of the task schema.
+    method:
+        An optional string to label the task schema by its method.
+    implementation:
+        An optional string to label the task schema by its implementation.
+    inputs:
+        A list of SchemaInput objects that define the inputs to the task.
+    outputs:
+        A list of SchemaOutput objects that define the outputs of the task.
+    version:
+        The version of this task schema.
+    web_doc:
+        True if this object should be included in the Sphinx documentation
+        (normally only relevant for built-in task schemas). True by default.
+    environment_presets:
+        Information about default execution environments. Can be overridden in specific
+        cases in the concrete tasks.
+    """
+
+    _validation_schema: ClassVar[str] = "task_schema_spec_schema.yaml"
+    _hash_value = None
+    _validate_actions = False
+
+    _child_objects = (
+        ChildObjectSpec(name="objective", class_name="TaskObjective"),
+        ChildObjectSpec(
+            name="inputs",
+            class_name="SchemaInput",
+            is_multiple=True,
+            parent_ref="_task_schema",
+        ),
+        ChildObjectSpec(name="outputs", class_name="SchemaOutput", is_multiple=True),
+    )
+
+    def __init__(
+        self,
+        objective: TaskObjective | str,
+        method: str | None = None,
+        implementation: str | None = None,
+        inputs: list[Parameter | SchemaInput] | None = None,
+        outputs: list[Parameter | SchemaParameter] | None = None,
+        version: str | None = None,
+        web_doc: bool | None = True,
+        environment_presets: Mapping[str, Mapping[str, Mapping[str, Any]]] | None = None,
+        doc: str = "",
+        _hash_value: str | None = None,
+    ):
+        super().__init__(
+            objective=objective,
+            method=method,
+            implementation=implementation,
+            inputs=inputs,
+            outputs=outputs,
+            version=version,
+            web_doc=web_doc,
+            environment_presets=environment_presets,
+            doc=doc,
+            _hash_value=_hash_value,
+        )

hpcflow/sdk/core/test_utils.py

@@ -34,46 +34,48 @@ Strs: TypeAlias = "str | tuple[str, ...]"
 def make_schemas(
     *ins_outs: tuple[dict[str, Any], tuple[str, ...]]
     | tuple[dict[str, Any], tuple[str, ...], str]
+    | tuple[dict[str, Any], tuple[str, ...], str, dict[str, Any]]
 ) -> list[TaskSchema]:
     """
     Construct a collection of schemas.
     """
     out: list[TaskSchema] = []
     for idx, info in enumerate(ins_outs):
+        act_kwargs: dict[str, Any] = {}
         if len(info) == 2:
             (ins_i, outs_i) = info
             obj = f"t{idx}"
-        else:
+        elif len(info) == 3:
             (ins_i, outs_i, obj) = info
-
-        # distribute outputs over stdout, stderr and out file parsers:
-        stdout = None
-        stderr = None
-        out_file_parsers = None
-
-        if outs_i:
-            stdout = f"<<parameter:{outs_i[0]}>>"
-        if len(outs_i) > 1:
-            stderr = f"<<parameter:{outs_i[1]}>>"
-        if len(outs_i) > 2:
-            out_file_parsers = [
-                hf.OutputFileParser(
-                    output=hf.Parameter(out_i),
-                    output_files=[hf.FileSpec(label="file1", name="file1.txt")],
+        else:
+            (ins_i, outs_i, obj, act_kwargs) = info
+
+        # distribute outputs over multiple commands' stdout:
+        cmds_lst = []
+        for out_idx, out_j in enumerate(outs_i):
+            cmd = hf.Command(
+                command=(
+                    "echo $(("
+                    + " + ".join(f"<<parameter:{i}>> + {100 + out_idx}" for i in ins_i)
+                    + "))"
+                ),
+                stdout=f"<<int(parameter:{out_j})>>",
+            )
+            cmds_lst.append(cmd)
+
+        if not outs_i:
+            # no outputs
+            cmds_lst = [
+                hf.Command(
+                    command=(
+                        "echo $(("
+                        + " + ".join(f"<<parameter:{i}>> + 100" for i in ins_i)
+                        + "))"
+                    ),
                 )
-                for out_i in outs_i[2:]
             ]
-        cmd = hf.Command(
-            " ".join(f"echo $((<<parameter:{i}>> + 100))" for i in ins_i),
-            stdout=stdout,
-            stderr=stderr,
-        )
 
-        act_i = hf.Action(
-            commands=[cmd],
-            output_file_parsers=out_file_parsers,
-            environments=[hf.ActionEnvironment("env_1")],
-        )
+        act_i = hf.Action(commands=cmds_lst, **act_kwargs)
         out.append(
             hf.TaskSchema(
                 objective=obj,
@@ -402,3 +404,40 @@ class P1_parameter_cls(ParameterValue):
             sub_param = None
         obj = cls(a=a, d=d, sub_param=sub_param)
         workflow.set_parameter_value(param_id=param_id, value=obj, commit=True)
+
+
+def make_workflow_to_run_command(
+    command,
+    path,
+    outputs=None,
+    name="w1",
+    overwrite=False,
+    store="zarr",
+    requires_dir=False,
+):
+    """Generate a single-task single-action workflow that runs the specified command,
+    optionally generating some outputs."""
+
+    outputs = outputs or []
+    commands = [hf.Command(command=command)]
+    commands += [
+        hf.Command(command=f'echo "output_{out}"', stdout=f"<<parameter:{out}>>")
+        for out in outputs
+    ]
+    schema = hf.TaskSchema(
+        objective="run_command",
+        outputs=[hf.SchemaOutput(i) for i in outputs],
+        actions=[hf.Action(commands=commands, requires_dir=requires_dir)],
+    )
+    template = {
+        "name": name,
+        "tasks": [hf.Task(schema=schema)],
+    }
+    wk = hf.Workflow.from_template(
+        hf.WorkflowTemplate(**template),
+        path=path,
+        name=name,
+        overwrite=overwrite,
+        store=store,
+    )
+    return wk