openjd-cli 0.7.6__tar.gz → 0.7.7__tar.gz

{openjd_cli-0.7.6 → openjd_cli-0.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openjd-cli
-Version: 0.7.6
+Version: 0.7.7
 Summary: Provides a command-line interface for working with Open Job Description templates.
 Project-URL: Homepage, https://github.com/OpenJobDescription/openjd-cli
 Project-URL: Source, https://github.com/OpenJobDescription/openjd-cli
@@ -22,8 +22,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.9
-Requires-Dist: openjd-model<0.12,>=0.9
-Requires-Dist: openjd-sessions<0.11,>=0.10.11
+Requires-Dist: openjd-model<0.12,>=0.11.4
+Requires-Dist: openjd-sessions<0.13,>=0.12.0
 Description-Content-Type: text/markdown
 
 ## Open Job Description - CLI

{openjd_cli-0.7.6 → openjd_cli-0.7.7}/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.7.6'
-__version_tuple__ = version_tuple = (0, 7, 6)
+__version__ = version = '0.7.7'
+__version_tuple__ = version_tuple = (0, 7, 7)
 
 __commit_id__ = commit_id = None

{openjd_cli-0.7.6 → openjd_cli-0.7.7}/pyproject.toml

@@ -29,11 +29,18 @@ classifiers = [
   "Intended Audience :: End Users/Desktop"
 ]
 dependencies = [
-  # 0.10.11 is the first release with `step_name` on both Session.run_task and
-  # Session.enter_environment (RFC 0007/0008). Below it, run_task() raises
-  # TypeError on every task run, since this CLI passes the keyword unconditionally.
-  "openjd-sessions >= 0.10.11,< 0.11",
-  "openjd-model >= 0.9,< 0.12"
+  # 0.12.0 is the first release carrying `resolved_symtab` on all three of
+  # Session.enter_environment, Session.exit_environment and Session.run_task.
+  # It is also the release that removed `extra_let_bindings` from
+  # enter_environment: 0.10.11 through 0.11.0 have that keyword and no
+  # `resolved_symtab`, so there is no version satisfying both channels and the
+  # floor has to move rather than being feature-detected. Below 0.12.0 every
+  # call site here raises TypeError on the unexpected `resolved_symtab`.
+  "openjd-sessions >= 0.12.0,< 0.13",
+  # 0.11.4 is the first release exporting `create_job_with_symbol_tables` and
+  # `JobWithSymbolTables`. 0.11.3 and below have `create_job` only, so the
+  # step-scope resolved symbol tables cannot be obtained at all.
+  "openjd-model >= 0.11.4,< 0.12"
 ]
 
 [project.urls]

{openjd_cli-0.7.6 → openjd_cli-0.7.7}/src/openjd/cli/_common/__init__.py

@@ -4,7 +4,7 @@ from argparse import ArgumentParser, Namespace, _SubParsersAction
 from dataclasses import asdict, dataclass
 from enum import Enum
 from pathlib import Path
-from typing import Callable, Literal
+from typing import TYPE_CHECKING, Callable, Literal
 import json
 import yaml
 import os
@@ -23,6 +23,10 @@ from ._validation_utils import (
 )
 from openjd.model import DecodeValidationError, Job, JobParameterValues, EnvironmentTemplate
 
+if TYPE_CHECKING:
+    # Annotations only; see the note in _job_from_template.py.
+    from openjd.expr import SerializedSymbolTable
+
 __all__ = [
     "add_extensions_argument",
     "get_doc_type",
@@ -118,7 +122,10 @@ def generate_job(
     environments: list[EnvironmentTemplate] = [],
     *,
     supported_extensions: list[str],
-) -> tuple[Job, JobParameterValues]:
+) -> tuple[Job, JobParameterValues, dict[str, "SerializedSymbolTable"]]:
+    """Returns the job, its parameter values, and the per-step resolved symbol
+    tables keyed by step name. See :func:`job_from_template` for why the tables
+    must be carried alongside the job rather than discarded."""
     try:
         # Raises: RuntimeError, DecodeValidationError
         template = read_job_template(args.path, supported_extensions=supported_extensions)

{openjd_cli-0.7.6 → openjd_cli-0.7.7}/src/openjd/cli/_common/_job_from_template.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import json
 from pathlib import Path
 import re
-from typing import Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 import yaml
 
 from ._validation_utils import get_doc_type
@@ -15,10 +15,17 @@ from openjd.model import (
     Job,
     JobParameterValues,
     JobTemplate,
-    create_job,
+    create_job_with_symbol_tables,
     preprocess_job_parameters,
 )
 
+if TYPE_CHECKING:
+    # Only for annotations: `openjd.expr` is a facade over the native
+    # extension, and importing the CLI must not load it. The tables the model
+    # hands back are already instances of this type, so nothing here
+    # constructs one.
+    from openjd.expr import SerializedSymbolTable
+
 
 def get_params_from_file(parameter_string: str) -> Union[dict, list]:
     """
@@ -111,10 +118,18 @@ def job_from_template(
     parameter_args: list[str] | None,
     job_template_dir: Path,
     current_working_dir: Path,
-) -> tuple[Job, JobParameterValues]:
+) -> tuple[Job, JobParameterValues, dict[str, "SerializedSymbolTable"]]:
     """
     Given a decoded Job Template and a user-input parameter dictionary,
-    generates a Job object and the parameter values for running the job.
+    generates a Job object, the parameter values for running the job, and the
+    per-step resolved symbol tables, keyed by step name.
+
+    A step's template-scope `let` bindings (RFC 0005 §3.6) are evaluated once
+    here, at job creation, and their resolved values reach a session only
+    through those tables -- neither the model nor the session re-derives them
+    from the source expressions. Sessions for a step must therefore be given
+    `step_symbol_tables[step.name]`, or the step's `let` produces no bindings
+    at all.
 
     Raises: RuntimeError if parameters are an unsupported type or don't correspond to the template
     """
@@ -132,11 +147,14 @@ def job_from_template(
         raise RuntimeError(str(ve))
 
     try:
-        job = create_job(
+        # `create_job_with_symbol_tables` returns the same Job that
+        # `create_job` does; it additionally returns the symbol tables that
+        # instantiation built instead of discarding them.
+        created = create_job_with_symbol_tables(
             job_template=template,
             job_parameter_values=parameter_values,
             environment_templates=environments,
         )
-        return (job, parameter_values)
+        return (created.job, parameter_values, created.step_symbol_tables)
     except DecodeValidationError as dve:
         raise RuntimeError(f"Could not generate Job from template and parameters: {str(dve)}")

openjd_cli-0.7.7/src/openjd/cli/_run/_local_session/_actions.py

@@ -0,0 +1,174 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+from enum import Enum
+from typing import TYPE_CHECKING, Optional
+
+from openjd.model import Step, TaskParameterSet
+from openjd.model.v2023_09 import Environment
+from openjd.sessions import Session
+
+if TYPE_CHECKING:
+    # Annotations only: `openjd.expr` is a facade over the native extension and
+    # importing the CLI must not load it. These tables are produced by
+    # `create_job_with_symbol_tables` and forwarded unchanged.
+    from openjd.expr import SerializedSymbolTable
+
+
+class EnvironmentType(str, Enum):
+    """
+    The three different types of environment types that can be entered/exited in a session.
+    """
+
+    EXTERNAL = "EXTERNAL"
+    JOB = "JOB"
+    STEP = "STEP"
+    ALL = "ALL"
+
+    def matches(self, other: "EnvironmentType") -> bool:
+        """Environment types match if they are equal, or one of them is ALL."""
+        return self == other or self == EnvironmentType.ALL or other == EnvironmentType.ALL
+
+
+class SessionAction:
+    _session: Session
+    duration: float
+
+    def __init__(self, session: Session):
+        self._session = session
+
+    def run(self):
+        """
+        Subclasses of `SessionAction` should have
+        custom implementations of this depending on their type.
+        """
+
+
+class RunTaskAction(SessionAction):
+    _step: Step
+    _parameters: TaskParameterSet
+    _resolved_symtab: Optional["SerializedSymbolTable"]
+
+    def __init__(
+        self,
+        session: Session,
+        step: Step,
+        parameters: TaskParameterSet,
+        resolved_symtab: Optional["SerializedSymbolTable"] = None,
+    ):
+        super(RunTaskAction, self).__init__(session)
+        self._step = step
+        self._parameters = parameters
+        # The step's create-time resolved symbol table
+        # (`create_job_with_symbol_tables().step_symbol_tables[step.name]`).
+        # It is the only channel for the step's template-scope `let` values:
+        # the model does not merge them into `script.let`, and the session does
+        # not re-evaluate the source expressions.
+        self._resolved_symtab = resolved_symtab
+
+    def run(self):
+        self._session.run_task(
+            step_script=self._step.script,
+            task_parameter_values=self._parameters,
+            # RFC 0008: the step name feeds the WrappedStep.Name template
+            # variable inside an active onWrapTaskRun hook.
+            step_name=self._step.name,
+            resolved_symtab=self._resolved_symtab,
+        )
+
+    def __str__(self):
+        parameters = {name: parameter.value for name, parameter in self._parameters.items()}
+        return f"Run Step '{self._step.name}' with Task parameters '{str(parameters)}'"
+
+
+class EnterEnvironmentAction(SessionAction):
+    _environment: Environment
+    _id: str
+    _resolved_symtab: Optional["SerializedSymbolTable"]
+    _step_name: Optional[str]
+
+    def __init__(
+        self,
+        session: Session,
+        environment: Environment,
+        env_id: str,
+        resolved_symtab: Optional["SerializedSymbolTable"] = None,
+        step_name: Optional[str] = None,
+    ):
+        super(EnterEnvironmentAction, self).__init__(session)
+        self._environment = environment
+        self._id = env_id
+        # RFC 0005 §3.6: a step's environments are entered with the step's
+        # create-time resolved symbol table, which carries the step's
+        # template-scope `let` values so their variables/actions can reference
+        # them. Only step-environment enters have one; job and external
+        # environment enters leave it None.
+        self._resolved_symtab = resolved_symtab
+        # RFC 0007 §7.3.1 (EXPR): the owning step's name seeds Step.Name for
+        # a step environment's `let` bindings, variables, and actions. Only
+        # step-environment enters carry a step name; job/external enters
+        # leave it None.
+        self._step_name = step_name
+
+    def run(self):
+        # `step_name` is omitted rather than passed as None when this enter has
+        # no owning step. Passing None would be equivalent today, since
+        # enter_environment skips a None `step_name`, but omitting it keeps the
+        # call site's intent legible at the boundary and it is what
+        # test_localsession_step_env_enter_receives_step_name asserts — that
+        # assertion is currently the only check that job and external enters
+        # do not seed Step.Name, because a template referencing Step.Name
+        # outside a step is rejected by static validation before any session
+        # is built, so no loadable template can observe it.
+        #
+        # `resolved_symtab` is passed unconditionally: None is its documented
+        # "no table" value and there is no analogous assertion keyed on its
+        # absence.
+        optional_kwargs: dict[str, str] = {}
+        if self._step_name is not None:
+            optional_kwargs["step_name"] = self._step_name
+        self._session.enter_environment(
+            environment=self._environment,
+            identifier=self._id,
+            resolved_symtab=self._resolved_symtab,
+            **optional_kwargs,
+        )
+
+    def __str__(self):
+        return f"Enter Environment '{self._environment.name}'"
+
+
+class ExitEnvironmentAction(SessionAction):
+    _id: str
+    _keep_session_running: bool
+    _resolved_symtab: Optional["SerializedSymbolTable"]
+
+    def __init__(
+        self,
+        session: Session,
+        id: str,
+        keep_session_running: bool,
+        resolved_symtab: Optional["SerializedSymbolTable"] = None,
+    ):
+        super(ExitEnvironmentAction, self).__init__(session)
+        self._id = id
+        self._keep_session_running = keep_session_running
+        # The same table the environment was entered with, so its onExit
+        # resolves in the same scope as its onEnter (what
+        # Session.exit_environment documents for this argument).
+        #
+        # Unlike the worker agent, the CLI holds the table as an object rather
+        # than a JSON string served by the service, so there is no parse step
+        # here that could fail and no wrapper degrading a parse failure to None
+        # to keep teardown unconditional. An environment entered without a
+        # table simply exits without one.
+        self._resolved_symtab = resolved_symtab
+
+    def run(self):
+        self._session.exit_environment(
+            identifier=self._id,
+            keep_session_running=self._keep_session_running,
+            resolved_symtab=self._resolved_symtab,
+        )
+
+    def __str__(self):
+        return f"Exit Environment '{self._id}'"

{openjd_cli-0.7.6 → openjd_cli-0.7.7}/src/openjd/cli/_run/_local_session/_session_manager.py

@@ -3,7 +3,7 @@
 from queue import Queue
 from threading import Event
 import time
-from typing import Any, Iterable, Optional, Type
+from typing import TYPE_CHECKING, Any, Iterable, Optional, Type
 from types import FrameType, TracebackType
 from signal import signal, SIGINT, SIGTERM, SIG_DFL
 from itertools import islice
@@ -39,6 +39,10 @@ from openjd.sessions import (
     PathMappingRule,
 )
 
+if TYPE_CHECKING:
+    # Annotations only; see the note in _actions.py.
+    from openjd.expr import SerializedSymbolTable
+
 
 class LocalSessionFailed(RuntimeError):
     """
@@ -118,6 +122,8 @@ class LocalSession:
     _path_mapping_rules: Optional[list[PathMappingRule]]
     _environments: Optional[list[Any]]
     _environments_entered: list[tuple[EnvironmentType, str]]
+    _step_symbol_tables: dict[str, "SerializedSymbolTable"]
+    _entered_env_symtabs: dict[str, "SerializedSymbolTable"]
     _log_handler: LocalSessionLogHandler
     _cleanup_called: bool
 
@@ -127,6 +133,7 @@ class LocalSession:
         job: Job,
         job_parameter_values: JobParameterValues,
         session_id: str,
+        step_symbol_tables: Optional[dict[str, "SerializedSymbolTable"]] = None,
         timestamp_format: LoggingTimestampFormat = LoggingTimestampFormat.RELATIVE,
         path_mapping_rules: Optional[list[PathMappingRule]] = None,
         environments: Optional[list[Any]] = None,
@@ -142,6 +149,21 @@ class LocalSession:
         self._timestamp_format = timestamp_format
         self._path_mapping_rules = path_mapping_rules
         self._environments = environments
+        # The create-time resolved symbol tables from
+        # `create_job_with_symbol_tables`, keyed by step name. A step's
+        # template-scope `let` (RFC 0005 §3.6) is evaluated once at job
+        # creation, and this is the only channel its resolved values have into
+        # a session: the model does not fold them into `script.let` and the
+        # session does not re-evaluate the source expressions. A caller that
+        # omits them gets a session in which every step-level `let` is simply
+        # undefined.
+        self._step_symbol_tables = step_symbol_tables or {}
+        # The table each entered environment was entered with, keyed by
+        # environment identifier, so its exit can be given the same one --
+        # `Session.exit_environment` documents that as the way an onExit
+        # resolves in the same scope as its onEnter. Environments entered
+        # without a table are simply absent.
+        self._entered_env_symtabs = {}
 
         # Create an OpenJD Session
         self._openjd_session = Session(
@@ -249,7 +271,7 @@ class LocalSession:
         environments: Optional[list[Any]],
         type: EnvironmentType,
         *,
-        extra_let_bindings: Optional[list[str]] = None,
+        resolved_symtab: Optional["SerializedSymbolTable"] = None,
         step_name: Optional[str] = None,
     ):
         """Enter one or more environments in the session."""
@@ -268,27 +290,39 @@ class LocalSession:
                 session=self._openjd_session,
                 environment=env,
                 env_id=env_id,
-                # RFC 0007: a step's environments see the step-level `let`
-                # bindings.
-                extra_let_bindings=extra_let_bindings,
+                # RFC 0005 §3.6: a step's environments see the step's resolved
+                # template-scope `let` values through its symbol table.
+                resolved_symtab=resolved_symtab,
                 # RFC 0007 §7.3.1 (EXPR): a step's environments see Step.Name.
                 # Only step-environment enters carry a step name.
                 step_name=step_name,
             )
             self._environments_entered.append((type, env_id))
+            # Recorded before the enter runs, and deliberately not undone on
+            # failure: whether the enter succeeds or not, the exit that follows
+            # must be given the table the enter was attempted with.
+            if resolved_symtab is not None:
+                self._entered_env_symtabs[env_id] = resolved_symtab
             try:
                 self._current_action.run()
             except (RuntimeError, ValueError) as exc:
                 # Session.enter_environment raises (rather than reporting
                 # through the action-status callback) when it rejects the
-                # environment up front — e.g. the RFC 0008 "at most one wrap
-                # environment" RuntimeError, or a ValueError from the extra
-                # `let` bindings — but it can also raise *after* registering
-                # the environment (e.g. an environment `variables` expression
-                # that fails to evaluate). Only when the session did NOT
-                # register the environment may we drop it from our entered
-                # list (cleanup must not try to exit it). If the session did
-                # register it, it must stay in our list so cleanup exits it —
+                # environment up front, before registering it — the RFC 0008
+                # "at most one Environment defining wrap hooks" RuntimeError is
+                # the trigger that reaches us in practice. Every failure it
+                # detects *after* registering goes through
+                # _fail_action_before_start() and returns normally instead, so
+                # as of openjd-sessions 0.12.0 nothing raises post-registration
+                # and the else-branch below is defensive. It is kept because the
+                # cost of being wrong is asymmetric: if a future release does
+                # raise after registering, dropping the environment from our
+                # list would skip its onExit and desynchronize us from the
+                # session's LIFO exit-ordering check, masking the original error
+                # with "Must exit Environment X first". So: only when the session
+                # did NOT register the environment may we drop it from our
+                # entered list (cleanup must not try to exit it). If the session
+                # did register it, it must stay in our list so cleanup exits it —
                 # popping it here would skip its onExit and desynchronize us
                 # from the session's LIFO exit ordering check, masking the
                 # original error with "Must exit Environment X first".
@@ -325,7 +359,12 @@ class LocalSession:
             prev_action_failed = self.failed
             self._action_ended.clear()
             self._current_action = ExitEnvironmentAction(
-                session=self._openjd_session, id=env_id, keep_session_running=keep_session_running
+                session=self._openjd_session,
+                id=env_id,
+                keep_session_running=keep_session_running,
+                # The same table the enter used, so onExit resolves in the same
+                # scope as onEnter. `pop` because an environment is exited once.
+                resolved_symtab=self._entered_env_symtabs.pop(env_id, None),
             )
             self._current_action.run()
             self._action_ended.wait()
@@ -345,7 +384,11 @@ class LocalSession:
 
         self._action_ended.clear()
         self._current_action = RunTaskAction(
-            session=self._openjd_session, step=step, parameters=parameter_set
+            session=self._openjd_session,
+            step=step,
+            parameters=parameter_set,
+            # RFC 0005 §3.6: the step's resolved template-scope `let` values.
+            resolved_symtab=self._step_symbol_tables.get(step.name),
         )
         self._current_action.run()
         self._action_ended.wait()
@@ -436,17 +479,16 @@ class LocalSession:
         if task_parameters is None:
             task_parameters = StepParameterSpaceIterator(space=step.parameterSpace)
 
-        # Enter all the step environments. When the step defines step-level
-        # `let` bindings (RFC 0007), its environments are entered with them so
-        # their variables and actions can reference them.
-        # getattr guard: requires an openjd-model with Step.let on the
-        # instantiated Job (openjd-model PR #318+); collapse to plain
-        # `step.let` once the version pin floor guarantees it.
-        step_let_bindings = getattr(step, "let", None)
+        # Enter all the step environments with the step's create-time resolved
+        # symbol table, so a step-level `let` (RFC 0005 §3.6) is visible to
+        # their variables and actions. The source expressions are not
+        # re-evaluated anywhere downstream, so a missing table here means the
+        # step's `let` names are undefined rather than merely stale.
+        resolved_symtab = self._step_symbol_tables.get(step.name)
         self.run_environment_enters(
             step.stepEnvironments,
             EnvironmentType.STEP,
-            extra_let_bindings=step_let_bindings or None,
+            resolved_symtab=resolved_symtab,
             # RFC 0007 §7.3.1 (EXPR): Step.Name is available to a step's
             # environments (openjd-rs threads the step's resolved symbol
             # table into enter_environment; this is the CLI counterpart).

{openjd_cli-0.7.6 → openjd_cli-0.7.7}/src/openjd/cli/_run/_run_command.py

@@ -4,7 +4,7 @@ from argparse import ArgumentParser, Namespace
 from dataclasses import dataclass
 from pathlib import Path
 import json
-from typing import Iterable, Optional
+from typing import TYPE_CHECKING, Iterable, Optional
 import re
 import logging
 import time
@@ -40,6 +40,10 @@ from openjd.model import (
 )
 from openjd.sessions import PathMappingRule, LOG
 
+if TYPE_CHECKING:
+    # Annotations only; see the note in _local_session/_actions.py.
+    from openjd.expr import SerializedSymbolTable
+
 
 @dataclass
 class OpenJDRunResult(OpenJDCliResult):
@@ -321,6 +325,7 @@ def _run_local_session(
     *,
     job: Job,
     job_parameter_values: JobParameterValues,
+    step_symbol_tables: Optional[dict[str, "SerializedSymbolTable"]] = None,
     step_list: list[Step],
     selected_step: Optional[Step],
     timestamp_format: LoggingTimestampFormat,
@@ -346,6 +351,9 @@ def _run_local_session(
         with LocalSession(
             job=job,
             job_parameter_values=job_parameter_values,
+            # RFC 0005 §3.6: each step's create-time resolved `let` values. The
+            # only channel they have into the session.
+            step_symbol_tables=step_symbol_tables,
             timestamp_format=timestamp_format,
             session_id="CLI-session",
             path_mapping_rules=path_mapping_rules,
@@ -464,7 +472,7 @@ def do_run(args: Namespace) -> OpenJDCliResult:
 
     try:
         # Raises: RuntimeError
-        the_job, job_parameter_values = generate_job(
+        the_job, job_parameter_values, step_symbol_tables = generate_job(
             args, environments, supported_extensions=extensions
         )
 
@@ -572,6 +580,7 @@ def do_run(args: Namespace) -> OpenJDCliResult:
     return _run_local_session(
         job=the_job,
         job_parameter_values=job_parameter_values,
+        step_symbol_tables=step_symbol_tables,
         step_list=step_list,
         selected_step=selected_step,
         task_parameter_values=task_parameter_values,

{openjd_cli-0.7.6 → openjd_cli-0.7.7}/src/openjd/cli/_summary/_summary_command.py

@@ -35,7 +35,7 @@ def do_summary(args: Namespace) -> OpenJDCliResult:
 
     try:
         # Raises: RuntimeError
-        sample_job, _ = generate_job(args, supported_extensions=extensions)
+        sample_job, _, _ = generate_job(args, supported_extensions=extensions)
     except RuntimeError as rte:
         return OpenJDCliResult(status="error", message=str(rte))
 

{openjd_cli-0.7.6 → openjd_cli-0.7.7}/src/openjd/cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.7.6'
-__version_tuple__ = version_tuple = (0, 7, 6)
+__version__ = version = '0.7.7'
+__version_tuple__ = version_tuple = (0, 7, 7)
 
 __commit_id__ = commit_id = None

openjd_cli-0.7.6/src/openjd/cli/_run/_local_session/_actions.py

@@ -1,126 +0,0 @@
-# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-
-from enum import Enum
-from typing import Any, Optional
-
-from openjd.model import Step, TaskParameterSet
-from openjd.model.v2023_09 import Environment
-from openjd.sessions import Session
-
-
-class EnvironmentType(str, Enum):
-    """
-    The three different types of environment types that can be entered/exited in a session.
-    """
-
-    EXTERNAL = "EXTERNAL"
-    JOB = "JOB"
-    STEP = "STEP"
-    ALL = "ALL"
-
-    def matches(self, other: "EnvironmentType") -> bool:
-        """Environment types match if they are equal, or one of them is ALL."""
-        return self == other or self == EnvironmentType.ALL or other == EnvironmentType.ALL
-
-
-class SessionAction:
-    _session: Session
-    duration: float
-
-    def __init__(self, session: Session):
-        self._session = session
-
-    def run(self):
-        """
-        Subclasses of `SessionAction` should have
-        custom implementations of this depending on their type.
-        """
-
-
-class RunTaskAction(SessionAction):
-    _step: Step
-    _parameters: TaskParameterSet
-
-    def __init__(self, session: Session, step: Step, parameters: TaskParameterSet):
-        super(RunTaskAction, self).__init__(session)
-        self._step = step
-        self._parameters = parameters
-
-    def run(self):
-        self._session.run_task(
-            step_script=self._step.script,
-            task_parameter_values=self._parameters,
-            # RFC 0008: the step name feeds the WrappedStep.Name template
-            # variable inside an active onWrapTaskRun hook.
-            step_name=self._step.name,
-        )
-
-    def __str__(self):
-        parameters = {name: parameter.value for name, parameter in self._parameters.items()}
-        return f"Run Step '{self._step.name}' with Task parameters '{str(parameters)}'"
-
-
-class EnterEnvironmentAction(SessionAction):
-    _environment: Environment
-    _id: str
-    _extra_let_bindings: Optional[list[str]]
-    _step_name: Optional[str]
-
-    def __init__(
-        self,
-        session: Session,
-        environment: Environment,
-        env_id: str,
-        extra_let_bindings: Optional[list[str]] = None,
-        step_name: Optional[str] = None,
-    ):
-        super(EnterEnvironmentAction, self).__init__(session)
-        self._environment = environment
-        self._id = env_id
-        # RFC 0007: a step's environments are entered with the step-level
-        # `let` bindings so their variables/actions can reference them.
-        self._extra_let_bindings = extra_let_bindings
-        # RFC 0007 §7.3.1 (EXPR): the owning step's name seeds Step.Name for
-        # a step environment's `let` bindings, variables, and actions. Only
-        # step-environment enters carry a step name; job/external enters
-        # leave it None.
-        self._step_name = step_name
-
-    def run(self):
-        # Both keywords are guaranteed by this package's `openjd-sessions`
-        # floor (>= 0.10.11), so neither is feature-detected. They are still
-        # only forwarded when they carry something: a step with no `let`
-        # bindings means "no extra bindings", and job/external environment
-        # enters have no owning step, so `Step.Name` must stay undefined for
-        # them rather than being seeded with None.
-        optional_kwargs: dict[str, Any] = {}
-        if self._extra_let_bindings:
-            optional_kwargs["extra_let_bindings"] = self._extra_let_bindings
-        if self._step_name is not None:
-            optional_kwargs["step_name"] = self._step_name
-        self._session.enter_environment(
-            environment=self._environment,
-            identifier=self._id,
-            **optional_kwargs,
-        )
-
-    def __str__(self):
-        return f"Enter Environment '{self._environment.name}'"
-
-
-class ExitEnvironmentAction(SessionAction):
-    _id: str
-    _keep_session_running: bool
-
-    def __init__(self, session: Session, id: str, keep_session_running: bool):
-        super(ExitEnvironmentAction, self).__init__(session)
-        self._id = id
-        self._keep_session_running = keep_session_running
-
-    def run(self):
-        self._session.exit_environment(
-            identifier=self._id, keep_session_running=self._keep_session_running
-        )
-
-    def __str__(self):
-        return f"Exit Environment '{self._id}'"