hpcflow-new2 0.2.0a162__py3-none-any.whl → 0.2.0a164__py3-none-any.whl

hpcflow/sdk/core/object_list.py

@@ -4,6 +4,10 @@ from types import SimpleNamespace
 from hpcflow.sdk.core.json_like import ChildObjectSpec, JSONLike
 
 
+class ObjectListMultipleMatchError(ValueError):
+    pass
+
+
 class ObjectList(JSONLike):
     """A list-like class that provides item access via a `get` method according to
     attributes or dict-keys.
@@ -116,14 +120,22 @@ class ObjectList(JSONLike):
         if not result:
             available = []
             for obj in self._objects:
-                available.append({k: getattr(obj, k) for k in kwargs})
+                attr_vals = {}
+                for k in kwargs:
+                    try:
+                        attr_vals[k] = self._get_obj_attr(obj, k)
+                    except (AttributeError, KeyError):
+                        continue
+                available.append(attr_vals)
             raise ValueError(
                 f"No {self._descriptor} objects with attributes: {kwargs}. Available "
                 f"objects have attributes: {tuple(available)!r}."
             )
 
         elif len(result) > 1:
-            raise ValueError(f"Multiple objects with attributes: {kwargs}.")
+            raise ObjectListMultipleMatchError(
+                f"Multiple objects with attributes: {kwargs}."
+            )
 
         return result[0]
 
@@ -571,23 +583,23 @@ class ResourceList(ObjectList):
     def get_scopes(self):
         return tuple(i.scope for i in self._objects)
 
-    def merge_template_resources(self, temp_res_lst):
-        """Merge lower-precedence template-level resources into this resource list."""
-        for scope_i in temp_res_lst.get_scopes():
+    def merge_other(self, other):
+        """Merge lower-precedence other resource list into this resource list."""
+        for scope_i in other.get_scopes():
             try:
-                es_scoped = self.get(scope=scope_i)
+                self_scoped = self.get(scope=scope_i)
             except ValueError:
-                in_es = False
+                in_self = False
             else:
-                in_es = True
+                in_self = True
 
-            temp_res_scoped = temp_res_lst.get(scope=scope_i)
-            if in_es:
-                for k, v in temp_res_scoped._get_members().items():
-                    if getattr(es_scoped, k) is None:
-                        setattr(es_scoped, f"_{k}", v)
+            other_scoped = other.get(scope=scope_i)
+            if in_self:
+                for k, v in other_scoped._get_members().items():
+                    if getattr(self_scoped, k) is None:
+                        setattr(self_scoped, f"_{k}", copy.deepcopy(v))
             else:
-                self.add_object(copy.deepcopy(temp_res_scoped))
+                self.add_object(copy.deepcopy(other_scoped))
 
 
 def index(obj_lst, obj):

hpcflow/sdk/core/parameters.py

@@ -678,9 +678,11 @@ class ValueSequence(JSONLike):
             )
         path_l = path.lower()
         path_split = path_l.split(".")
-        if not path_split[0] in ("inputs", "resources"):
+        allowed_path_start = ("inputs", "resources", "environments", "env_preset")
+        if not path_split[0] in allowed_path_start:
             raise MalformedParameterPathError(
-                f'`path` must start with "inputs", "outputs", or "resources", but given path '
+                f"`path` must start with one of: "
+                f'{", ".join(f"{i!r}" for i in allowed_path_start)}, but given path '
                 f"is: {path!r}."
             )
 
@@ -703,7 +705,7 @@ class ValueSequence(JSONLike):
             elif label_from_path:
                 label = label_from_path
 
-        if path_split[0] == "resources":
+        elif path_split[0] == "resources":
             if label_from_path or label_arg:
                 raise ValueError(
                     f"{self.__class__.__name__} `label` argument ({label_arg!r}) and/or "
@@ -728,6 +730,14 @@ class ValueSequence(JSONLike):
                         f"resource item names are: {allowed_keys_str}."
                     )
 
+        elif path_split[0] == "environments":
+            # rewrite as a resources path:
+            path = f"resources.any.{path}"
+
+        # note: `env_preset` paths also need to be transformed into `resources` paths, but
+        # we cannot do that until the sequence is part of a task, since the available
+        # environment presets are defined in the task schema.
+
         return path, label
 
     def to_dict(self):
@@ -1330,6 +1340,7 @@ class ResourceSpec(JSONLike):
         "scheduler_args",
         "shell_args",
         "os_name",
+        "environments",
         "SGE_parallel_env",
         "SLURM_partition",
         "SLURM_num_tasks",
@@ -1364,6 +1375,7 @@ class ResourceSpec(JSONLike):
         scheduler_args: Optional[Dict] = None,
         shell_args: Optional[Dict] = None,
         os_name: Optional[str] = None,
+        environments: Optional[Dict] = None,
         SGE_parallel_env: Optional[str] = None,
         SLURM_partition: Optional[str] = None,
         SLURM_num_tasks: Optional[str] = None,
@@ -1392,6 +1404,7 @@ class ResourceSpec(JSONLike):
         self._scheduler = self._process_string(scheduler)
         self._shell = self._process_string(shell)
         self._os_name = self._process_string(os_name)
+        self._environments = environments
         self._use_job_array = use_job_array
         self._max_array_items = max_array_items
         self._time_limit = time_limit
@@ -1526,6 +1539,7 @@ class ResourceSpec(JSONLike):
             self._scheduler_args = None
             self._shell_args = None
             self._os_name = None
+            self._environments = None
 
         return (self.normalised_path, [data_ref], is_new)
 
@@ -1625,6 +1639,10 @@ class ResourceSpec(JSONLike):
     def os_name(self):
         return self._get_value("os_name")
 
+    @property
+    def environments(self):
+        return self._get_value("environments")
+
     @property
     def SGE_parallel_env(self):
         return self._get_value("SGE_parallel_env")

hpcflow/sdk/core/task.py

@@ -25,6 +25,7 @@ from .errors import (
     TaskTemplateMultipleSchemaObjectives,
     TaskTemplateUnexpectedInput,
     TaskTemplateUnexpectedSequenceInput,
+    UnknownEnvironmentPresetError,
     UnrequiredInputSources,
     UnsetParameterDataError,
 )
@@ -126,8 +127,11 @@ class ElementSet(JSONLike):
         groups: Optional[List[app.ElementGroup]] = None,
         input_sources: Optional[Dict[str, app.InputSource]] = None,
         nesting_order: Optional[List] = None,
+        env_preset: Optional[str] = None,
+        environments: Optional[Dict[str, Dict[str, Any]]] = None,
         sourceable_elem_iters: Optional[List[int]] = None,
         allow_non_coincident_task_sources: Optional[bool] = False,
+        merge_envs: Optional[bool] = True,
     ):
         """
         Parameters
@@ -140,7 +144,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
+            If True, merge `environments` into `resources` using the "any" scope. If
+            False, `environments` are ignored. This is required on first initialisation,
+            but not on subsequent re-initialisation from a persistent workflow.
         """
 
         self.inputs = inputs or []
@@ -151,8 +158,11 @@ class ElementSet(JSONLike):
         self.sequences = sequences or []
         self.input_sources = input_sources or {}
         self.nesting_order = nesting_order or {}
+        self.env_preset = env_preset
+        self.environments = environments
         self.sourceable_elem_iters = sourceable_elem_iters
         self.allow_non_coincident_task_sources = allow_non_coincident_task_sources
+        self.merge_envs = merge_envs
 
         self._validate()
         self._set_parent_refs()
@@ -161,6 +171,18 @@ class ElementSet(JSONLike):
         self._defined_input_types = None  # assigned on _task_template assignment
         self._element_local_idx_range = None  # assigned by WorkflowTask._add_element_set
 
+        # 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:
+            envs_res = self.app.ResourceList(
+                [self.app.ResourceSpec(scope="any", environments=self.environments)]
+            )
+            self.resources.merge_other(envs_res)
+            self.merge_envs = False
+
+        # note: `env_preset` is merged into resources by the Task init.
+
     def __deepcopy__(self, memo):
         dct = self.to_dict()
         orig_inp = dct.pop("original_input_sources", None)
@@ -278,6 +300,10 @@ class ElementSet(JSONLike):
                     f"provided for parameter {src_key!r}."
                 )
 
+        # disallow both `env_preset` and `environments` specifications:
+        if self.env_preset and self.environments:
+            raise ValueError("Specify at most one of `env_preset` and `environments`.")
+
     def _validate_against_template(self):
         unexpected_types = (
             set(self.input_types) - self.task_template.all_schema_input_types
@@ -330,6 +356,8 @@ class ElementSet(JSONLike):
         groups=None,
         input_sources=None,
         nesting_order=None,
+        env_preset=None,
+        environments=None,
         element_sets=None,
         sourceable_elem_iters=None,
     ):
@@ -342,6 +370,8 @@ class ElementSet(JSONLike):
             groups,
             input_sources,
             nesting_order,
+            env_preset,
+            environments,
         )
         args_not_none = [i is not None for i in args]
 
@@ -520,9 +550,12 @@ class Task(JSONLike):
         sequences: Optional[List[app.ValueSequence]] = None,
         input_sources: Optional[Dict[str, app.InputSource]] = None,
         nesting_order: Optional[List] = None,
+        env_preset: Optional[str] = None,
+        environments: Optional[Dict[str, Dict[str, Any]]] = None,
         element_sets: Optional[List[app.ElementSet]] = None,
         output_labels: Optional[List[app.OutputLabel]] = None,
         sourceable_elem_iters: Optional[List[int]] = None,
+        merge_envs: Optional[bool] = True,
     ):
         """
         Parameters
@@ -532,7 +565,11 @@ class Task(JSONLike):
             schema names that uniquely identify a task schema. If strings are provided,
             the `TaskSchema` object will be fetched from the known task schemas loaded by
             the app configuration.
-
+        merge_envs
+            If True, merge environment presets (set via the element set `env_preset` key)
+            into `resources` using the "any" scope. If False, these presets are ignored.
+            This is required on first initialisation, but not on subsequent
+            re-initialisation from a persistent workflow.
         """
 
         # TODO: allow init via specifying objective and/or method and/or implementation
@@ -576,10 +613,13 @@ class Task(JSONLike):
             groups=groups,
             input_sources=input_sources,
             nesting_order=nesting_order,
+            env_preset=env_preset,
+            environments=environments,
             element_sets=element_sets,
             sourceable_elem_iters=sourceable_elem_iters,
         )
         self._output_labels = output_labels or []
+        self.merge_envs = merge_envs
 
         # appended to when new element sets are added and reset on dump to disk:
         self._pending_element_sets = []
@@ -591,8 +631,73 @@ class Task(JSONLike):
         self._insert_ID = None
         self._dir_name = None
 
+        if self.merge_envs:
+            self._merge_envs_into_resources()
+
+        # TODO: consider adding a new element_set; will need to merge new environments?
+
         self._set_parent_refs({"schema": "schemas"})
 
+    def _merge_envs_into_resources(self):
+        # for each element set, merge `env_preset` into `resources` (this mutates
+        # `resources`, and should only happen on creation of the task, not
+        # re-initialisation from a persistent workflow):
+        self.merge_envs = False
+
+        # TODO: required so we don't raise below; can be removed once we consider multiple
+        # schemas:
+        has_presets = False
+        for es in self.element_sets:
+            if es.env_preset:
+                has_presets = True
+                break
+            for seq in es.sequences:
+                if seq.path == "env_preset":
+                    has_presets = True
+                    break
+            if has_presets:
+                break
+
+        if not has_presets:
+            return
+        try:
+            env_presets = self.schema.environment_presets
+        except ValueError:
+            # TODO: consider multiple schemas
+            raise NotImplementedError(
+                "Cannot merge environment presets into a task with multiple schemas."
+            )
+
+        for es in self.element_sets:
+            if es.env_preset:
+                # retrieve env specifiers from presets defined in the schema:
+                try:
+                    env_specs = env_presets[es.env_preset]
+                except (TypeError, KeyError):
+                    raise UnknownEnvironmentPresetError(
+                        f"There is no environment preset named {es.env_preset!r} "
+                        f"defined in the task schema {self.schema.name}."
+                    )
+                envs_res = self.app.ResourceList(
+                    [self.app.ResourceSpec(scope="any", environments=env_specs)]
+                )
+                es.resources.merge_other(envs_res)
+
+            for seq in es.sequences:
+                if seq.path == "env_preset":
+                    # change to a resources path:
+                    seq.path = f"resources.any.environments"
+                    _values = []
+                    for i in seq.values:
+                        try:
+                            _values.append(env_presets[i])
+                        except (TypeError, KeyError):
+                            raise UnknownEnvironmentPresetError(
+                                f"There is no environment preset named {i!r} defined "
+                                f"in the task schema {self.schema.name}."
+                            )
+                    seq._values = _values
+
     def _reset_pending_element_sets(self):
         self._pending_element_sets = []
 
@@ -1839,8 +1944,8 @@ class WorkflowTask:
             # run-specific data index to `test_rules` and `generate_data_index`
             # (e.g. if we wanted to increase the memory requirements of a action because
             # it previously failed)
-            rules_valid = action.test_rules(element_iter=element_iter)
-            if all(rules_valid):
+            act_valid, cmds_idx = action.test_rules(element_iter=element_iter)
+            if act_valid:
                 self.app.logger.info(f"All action rules evaluated to true {log_common}")
                 EAR_ID = self.workflow.num_EARs + count
                 param_source = {
@@ -1864,6 +1969,7 @@ class WorkflowTask:
                 run_0 = {
                     "elem_iter_ID": element_iter.id_,
                     "action_idx": act_idx,
+                    "commands_idx": cmds_idx,
                     "metadata": {},
                 }
                 action_runs[(act_idx, EAR_ID)] = run_0
@@ -1877,6 +1983,7 @@ class WorkflowTask:
             self.workflow._store.add_EAR(
                 elem_iter_ID=element_iter.id_,
                 action_idx=act_idx,
+                commands_idx=run["commands_idx"],
                 data_idx=all_data_idx[(act_idx, EAR_ID_i)],
                 metadata={},
             )

hpcflow/sdk/core/task_schema.py

@@ -2,7 +2,7 @@ from contextlib import contextmanager
 import copy
 from dataclasses import dataclass
 from importlib import import_module
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 from html import escape
 
 from rich import print as rich_print
@@ -13,6 +13,7 @@ from rich.markup import escape as rich_esc
 from rich.text import Text
 
 from hpcflow.sdk import app
+from hpcflow.sdk.core.errors import EnvironmentPresetUnknownEnvironmentError
 from hpcflow.sdk.core.parameters import Parameter
 from .json_like import ChildObjectSpec, JSONLike
 from .parameters import NullDefault, ParameterPropagationMode, SchemaInput
@@ -89,6 +90,7 @@ class TaskSchema(JSONLike):
         version: Optional[str] = None,
         parameter_class_modules: Optional[List[str]] = None,
         web_doc: Optional[bool] = True,
+        environment_presets: Optional[Dict[str, Dict[str, Dict[str, Any]]]] = None,
         _hash_value: Optional[str] = None,
     ):
         self.objective = objective
@@ -99,6 +101,7 @@ class TaskSchema(JSONLike):
         self.outputs = outputs or []
         self.parameter_class_modules = parameter_class_modules or []
         self.web_doc = web_doc
+        self.environment_presets = environment_presets
         self._hash_value = _hash_value
 
         self._set_parent_refs()
@@ -114,6 +117,18 @@ class TaskSchema(JSONLike):
 
         self._update_parameter_value_classes()
 
+        if self.environment_presets:
+            # validate against env names in actions:
+            env_names = {act.get_environment_name() for act in self.actions}
+            preset_envs = {i for v in self.environment_presets.values() for i in v.keys()}
+            bad_envs = preset_envs - env_names
+            if bad_envs:
+                raise EnvironmentPresetUnknownEnvironmentError(
+                    f"Task schema {self.name} has environment presets that refer to one "
+                    f"or more environments that are not referenced in any of the task "
+                    f"schema's actions: {', '.join(f'{i!r}' for i in bad_envs)}."
+                )
+
         # if version is not None:  # TODO: this seems fragile
         #     self.assign_versions(
         #         version=version,
@@ -513,7 +528,7 @@ class TaskSchema(JSONLike):
                 f'</tr><tr><td class="action-header-cell">scope:</td>'
                 f"<td><code>{act.get_precise_scope().to_string()}</code></td></tr>"
                 f'<tr><td class="action-header-cell">environment:</td>'
-                f"<td><code>{act.get_environment().name}</code></td></tr>"
+                f"<td><code>{act.get_environment_name()}</code></td></tr>"
                 f"{inp_fg_rows}"
                 f"{out_fp_rows}"
                 f"{act_i_script_rows}"

hpcflow/sdk/core/test_utils.py

@@ -61,8 +61,11 @@ def make_parameters(num):
     return [hf.Parameter(f"p{i + 1}") for i in range(num)]
 
 
-def make_actions(ins_outs: List[Tuple[Union[Tuple, str], str]]) -> List[hf.Action]:
-    act_env = hf.ActionEnvironment(environment="env1")
+def make_actions(
+    ins_outs: List[Tuple[Union[Tuple, str], str]],
+    env="env1",
+) -> List[hf.Action]:
+    act_env = hf.ActionEnvironment(environment=env)
     actions = []
     for ins_outs_i in ins_outs:
         if len(ins_outs_i) == 2:

hpcflow/sdk/core/workflow.py

@@ -105,6 +105,7 @@ class WorkflowTemplate(JSONLike):
     """
 
     _app_attr = "app"
+    _validation_schema = "workflow_spec_schema.yaml"
 
     _child_objects = (
         ChildObjectSpec(
@@ -132,9 +133,12 @@ class WorkflowTemplate(JSONLike):
     loops: Optional[List[app.Loop]] = field(default_factory=lambda: [])
     workflow: Optional[app.Workflow] = None
     resources: Optional[Dict[str, Dict]] = None
+    environments: Optional[Dict[str, Dict[str, Any]]] = None
+    env_presets: Optional[Union[str, List[str]]] = None
     source_file: Optional[str] = field(default=None, compare=False)
     store_kwargs: Optional[Dict] = field(default_factory=lambda: {})
     merge_resources: Optional[bool] = True
+    merge_envs: Optional[bool] = True
 
     def __post_init__(self):
         self.resources = self.app.ResourceList.normalise(self.resources)
@@ -146,12 +150,95 @@ class WorkflowTemplate(JSONLike):
         if self.merge_resources:
             for task in self.tasks:
                 for element_set in task.element_sets:
-                    element_set.resources.merge_template_resources(self.resources)
+                    element_set.resources.merge_other(self.resources)
             self.merge_resources = False
 
+        if self.merge_envs:
+            self._merge_envs_into_task_resources()
+
         if self.doc and not isinstance(self.doc, list):
             self.doc = [self.doc]
 
+    def _merge_envs_into_task_resources(self):
+
+        self.merge_envs = False
+
+        # disallow both `env_presets` and `environments` specifications:
+        if self.env_presets and self.environments:
+            raise ValueError(
+                "Workflow template: specify at most one of `env_presets` and "
+                "`environments`."
+            )
+
+        if not isinstance(self.env_presets, list):
+            self.env_presets = [self.env_presets] if self.env_presets else []
+
+        for task in self.tasks:
+
+            # get applicable environments and environment preset names:
+            try:
+                schema = task.schema
+            except ValueError:
+                # TODO: consider multiple schemas
+                raise NotImplementedError(
+                    "Cannot merge environment presets into a task without multiple "
+                    "schemas."
+                )
+            schema_presets = schema.environment_presets
+            app_envs = {act.get_environment_name() for act in schema.actions}
+            for es in task.element_sets:
+                app_env_specs_i = None
+                if not es.environments and not es.env_preset:
+                    # no task level envs/presets specified, so merge template-level:
+                    if self.environments:
+                        app_env_specs_i = {
+                            k: v for k, v in self.environments.items() if k in app_envs
+                        }
+                        if app_env_specs_i:
+                            self.app.logger.info(
+                                f"(task {task.name!r}, element set {es.index}): using "
+                                f"template-level requested `environment` specifiers: "
+                                f"{app_env_specs_i!r}."
+                            )
+                            es.environments = app_env_specs_i
+
+                    elif self.env_presets:
+                        # take only the first applicable preset:
+                        app_presets_i = [
+                            k for k in self.env_presets if k in schema_presets
+                        ]
+                        if app_presets_i:
+                            app_env_specs_i = schema_presets[app_presets_i[0]]
+                            self.app.logger.info(
+                                f"(task {task.name!r}, element set {es.index}): using "
+                                f"template-level requested {app_presets_i[0]!r} "
+                                f"`env_preset`: {app_env_specs_i!r}."
+                            )
+                            es.env_preset = app_presets_i[0]
+
+                    else:
+                        # no env/preset applicable here (and no env/preset at task level),
+                        # so apply a default preset if available:
+                        app_env_specs_i = (schema_presets or {}).get("", None)
+                        if app_env_specs_i:
+                            self.app.logger.info(
+                                f"(task {task.name!r}, element set {es.index}): setting "
+                                f"to default (empty-string named) `env_preset`: "
+                                f"{app_env_specs_i}."
+                            )
+                            es.env_preset = ""
+
+                    if app_env_specs_i:
+                        es.resources.merge_other(
+                            self.app.ResourceList(
+                                [
+                                    self.app.ResourceSpec(
+                                        scope="any", environments=app_env_specs_i
+                                    )
+                                ]
+                            )
+                        )
+
     @classmethod
     @TimeIt.decorator
     def _from_data(cls, data: Dict) -> app.WorkflowTemplate:
@@ -172,28 +259,29 @@ class WorkflowTemplate(JSONLike):
                 }
 
         # extract out any template components:
-        params_dat = data.pop("parameters", [])
+        tcs = data.pop("template_components", {})
+        params_dat = tcs.pop("parameters", [])
         if params_dat:
             parameters = cls.app.ParametersList.from_json_like(
                 params_dat, shared_data=cls.app.template_components
             )
             cls.app.parameters.add_objects(parameters, skip_duplicates=True)
 
-        cmd_files_dat = data.pop("command_files", [])
+        cmd_files_dat = tcs.pop("command_files", [])
         if cmd_files_dat:
             cmd_files = cls.app.CommandFilesList.from_json_like(
                 cmd_files_dat, shared_data=cls.app.template_components
             )
             cls.app.command_files.add_objects(cmd_files, skip_duplicates=True)
 
-        envs_dat = data.pop("environments", [])
+        envs_dat = tcs.pop("environments", [])
         if envs_dat:
             envs = cls.app.EnvironmentsList.from_json_like(
                 envs_dat, shared_data=cls.app.template_components
             )
             cls.app.envs.add_objects(envs, skip_duplicates=True)
 
-        ts_dat = data.pop("task_schemas", [])
+        ts_dat = tcs.pop("task_schemas", [])
         if ts_dat:
             task_schemas = cls.app.TaskSchemasList.from_json_like(
                 ts_dat, shared_data=cls.app.template_components

hpcflow/sdk/data/workflow_spec_schema.yaml

@@ -1,64 +1,20 @@
 rules:
   - path: []
-    condition:
-      value.allowed_keys: [tasks]
-
-  - path: [tasks]
-    condition: { value.type.equal_to: list }
-
-  - path: [tasks, { type: list_value }]
     condition:
       value.allowed_keys:
-        [
-          objective,
-          method,
-          implementation,
-          resources,
-          inputs,
-          input_sources,
-          input_files,
-          perturbations,
-          sequences,
-          groups,
-          repeats,
-          nesting_order,
-        ]
+        - doc
+        - name
+        - source_file
+        - resources
+        - environments
+        - env_presets
+        - template_components
+        - tasks
+        - loops
+        - store_kwargs
+        - merge_resources
+        - merge_envs
+        - workflow
 
-  - path: [tasks, { type: list_value }, resources]
-    condition: { value.type.equal_to: dict }
-
-  - path: [tasks, { type: list_value }, perturbations]
-    condition: { value.type.equal_to: dict }
-
-  - path: [tasks, { type: list_value }, nesting_order]
-    condition: { value.type.equal_to: dict }
-
-  - path: [tasks, { type: list_value }, sequences]
-    condition: { value.type.equal_to: list }
-
-  - path: [tasks, { type: list_value }, inputs]
-    condition: { value.type.in: [list, dict] }
-
-  - path: [tasks, { type: list_value }, inputs, { type: list_value }]
-    condition:
-      and:
-        - value.required_keys: [parameter, value]
-        - value.allowed_keys: [parameter, value, path]
-
-  - path: [tasks, { type: list_value }, inputs, { type: list_value }, parameter]
-    condition: { value.type.equal_to: str }
-
-  - path: [tasks, { type: list_value }, inputs, { type: list_value }, path]
+  - path: [tasks]
     condition: { value.type.equal_to: list }
-
-  - path: [tasks, { type: list_value }, sequences, { type: list_value }]
-    condition:
-      and:
-        - value.required_keys: [path, nesting_order]
-        - value.keys_contain_one_of:
-            [
-              values,
-              values.from_linear_space,
-              values.from_grometric_space,
-              values_from_log_space,
-            ]