hpcflow-new2 0.2.0a161__py3-none-any.whl → 0.2.0a163__py3-none-any.whl

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 = []
 

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,

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,
-            ]

hpcflow/sdk/demo/cli.py

@@ -184,7 +184,7 @@ def get_demo_workflow_CLI(app):
             status=status,
         )
         if print_idx:
-            click.echo(out)
+            click.echo(out[1])
 
     @demo_workflow.command("copy")
     @click.argument("workflow_name")

hpcflow/sdk/submission/submission.py

@@ -15,9 +15,11 @@ from hpcflow.sdk.core.errors import (
     MissingEnvironmentError,
     MissingEnvironmentExecutableError,
     MissingEnvironmentExecutableInstanceError,
+    MultipleEnvironmentsError,
     SubmissionFailure,
 )
 from hpcflow.sdk.core.json_like import ChildObjectSpec, JSONLike
+from hpcflow.sdk.core.object_list import ObjectListMultipleMatchError
 from hpcflow.sdk.log import TimeIt
 
 
@@ -90,31 +92,40 @@ class Submission(JSONLike):
         req_envs = defaultdict(lambda: defaultdict(set))
         for js_idx, js_i in enumerate(self.jobscripts):
             for run in js_i.all_EARs:
-                env_label = run.action.get_environment_label()
+                env_spec_h = tuple(zip(*run.env_spec.items()))  # hashable
                 for exec_label_j in run.action.get_required_executables():
-                    req_envs[env_label][exec_label_j].add(js_idx)
-                if env_label not in req_envs:
-                    req_envs[env_label] = {}
+                    req_envs[env_spec_h][exec_label_j].add(js_idx)
+                if env_spec_h not in req_envs:
+                    req_envs[env_spec_h] = {}
 
         # check these envs/execs exist in app data:
         envs = []
-        for env_lab, exec_js in req_envs.items():
+        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_lab)
+                env_i = self.app.envs.get(**env_spec)
+            except ObjectListMultipleMatchError:
+                raise MultipleEnvironmentsError(
+                    f"Multiple environments {env_ref} are defined on this machine."
+                )
             except ValueError:
                 raise MissingEnvironmentError(
-                    f"The environment {env_lab!r} is not defined on this machine, so the "
+                    f"The environment {env_ref} is not defined on this machine, so the "
                     f"submission cannot be created."
                 ) from None
             else:
-                envs.append(env_i)
+                if env_i not in envs:
+                    envs.append(env_i)
 
             for exec_i_lab, js_idx_set in exec_js.items():
                 try:
                     exec_i = env_i.executables.get(exec_i_lab)
                 except ValueError:
                     raise MissingEnvironmentExecutableError(
-                        f"The environment {env_lab!r} as defined on this machine has no "
+                        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."
                     ) from None
@@ -127,7 +138,7 @@ class Submission(JSONLike):
                     if not exec_instances:
                         raise MissingEnvironmentExecutableInstanceError(
                             f"No matching executable instances found for executable "
-                            f"{exec_i_lab!r} of environment {env_lab!r} for jobscript "
+                            f"{exec_i_lab!r} of environment {env_ref} for jobscript "
                             f"index {js_idx_j!r} with requested resources "
                             f"{filter_exec!r}."
                         )

hpcflow/tests/scripts/test_main_scripts.py

@@ -447,3 +447,63 @@ def test_script_hdf5_out_obj(null_config, tmp_path):
     # to be later Python versions):
     time.sleep(10)
     assert wk.tasks[0].elements[0].outputs.p1c.value == P1(a=p1_val + 100)
+
+
+@pytest.mark.integration
+@pytest.mark.skipif("hf.run_time_info.is_frozen")
+def test_script_direct_in_pass_env_spec(new_null_config, tmp_path):
+
+    vers_spec = {"version": "1.2"}
+    env = hf.Environment(
+        name="python_env_with_specifiers",
+        specifiers=vers_spec,
+        executables=[
+            hf.Executable(
+                label="python_script",
+                instances=[
+                    hf.ExecutableInstance(
+                        command="python <<script_name>> <<args>>",
+                        num_cores=1,
+                        parallel_mode=None,
+                    )
+                ],
+            )
+        ],
+    )
+    hf.envs.add_object(env, skip_duplicates=True)
+
+    s1 = hf.TaskSchema(
+        objective="t1",
+        inputs=[hf.SchemaInput(parameter=hf.Parameter("p1"))],
+        outputs=[hf.SchemaOutput(parameter=hf.Parameter("p2"))],
+        actions=[
+            hf.Action(
+                script="<<script:main_script_test_direct_in_direct_out_env_spec.py>>",
+                script_data_in="direct",
+                script_data_out="direct",
+                script_exe="python_script",
+                script_pass_env_spec=True,
+                environments=[
+                    hf.ActionEnvironment(environment="python_env_with_specifiers")
+                ],
+            )
+        ],
+    )
+    t1 = hf.Task(
+        schema=s1,
+        inputs={"p1": 101},
+        environments={"python_env_with_specifiers": vers_spec},
+    )
+    wk = hf.Workflow.from_template_data(
+        tasks=[t1],
+        template_name="main_script_test",
+        path=tmp_path,
+    )
+    wk.submit(wait=True, add_to_known=False)
+    # TODO: investigate why the value is not always populated on GHA Ubuntu runners (tends
+    # to be later Python versions):
+    time.sleep(10)
+    assert wk.tasks[0].elements[0].outputs.p2.value == {
+        "name": "python_env_with_specifiers",
+        **vers_spec,
+    }

hpcflow/tests/unit/test_action.py

@@ -3,6 +3,7 @@ import pytest
 
 from hpcflow.app import app as hf
 from hpcflow.sdk.core.errors import (
+    ActionEnvironmentMissingNameError,
     UnknownScriptDataKey,
     UnknownScriptDataParameter,
     UnsupportedScriptDataFormat,
@@ -602,3 +603,18 @@ def test_process_script_data_in_fmt_dict_mixed(null_config):
         "p1": {"format": "json"},
         "p2": {"format": "hdf5"},
     }
+
+
+def test_ActionEnvironment_env_str(null_config):
+    act_env = hf.ActionEnvironment(environment="my_env")
+    assert act_env.environment == {"name": "my_env"}
+
+
+def test_ActionEnvironment_env_dict(null_config):
+    act_env = hf.ActionEnvironment(environment={"name": "my_env", "key": "value"})
+    assert act_env.environment == {"name": "my_env", "key": "value"}
+
+
+def test_ActionEnvironment_raises_on_missing_name(null_config):
+    with pytest.raises(ActionEnvironmentMissingNameError):
+        hf.ActionEnvironment(environment={"key": "value"})