nextmv 1.0.0__py3-none-any.whl → 1.0.0.dev0__py3-none-any.whl

nextmv/cli/cloud/app/push.py

@@ -2,18 +2,12 @@
 This module defines the cloud app push command for the Nextmv CLI.
 """
 
-import sys
-from datetime import datetime, timezone
 from typing import Annotated
 
 import typer
-from rich.prompt import Prompt
 
 from nextmv.cli.configuration.config import build_app
-from nextmv.cli.confirm import get_confirmation
-from nextmv.cli.message import error, in_progress, info, success
 from nextmv.cli.options import AppIDOption, ProfileOption
-from nextmv.cloud.application import Application
 from nextmv.manifest import Manifest
 
 # Set up subcommand application.
@@ -41,48 +35,44 @@ def push(
             metavar="MANIFEST_PATH",
         ),
     ] = None,
-    # Options for version control.
+    no_version: Annotated[
+        bool,
+        typer.Option(
+            "--no-version",
+            "-n",
+            help="The application will be pushed without creating a new version. "
+            "Default is to create a new version on each push.",
+            rich_help_panel="Versioning control",
+        ),
+    ] = False,
     version_id: Annotated[
         str | None,
         typer.Option(
             "--version-id",
             "-v",
-            help="Custom ID for version creation after app push. Automatically generated if not provided. "
-            "Activates --version-yes.",
+            help="Custom version ID when pushing the application. Automatically generated if not provided.",
+            rich_help_panel="Versioning control",
             metavar="VERSION_ID",
-            rich_help_panel="Version control",
         ),
     ] = None,
-    version_yes: Annotated[
-        bool,
-        typer.Option(
-            "--version-yes",
-            "-y",
-            help="Create a new version after push. Skips confirmation prompt. Useful for non-interactive sessions.",
-            rich_help_panel="Version control",
-        ),
-    ] = False,
-    # Options for instance control.
-    create_instance_id: Annotated[
+    version_name: Annotated[
         str | None,
         typer.Option(
-            "--create-instance-id",
-            "-c",
-            help="Link the newly created version to a [yellow]new[/yellow] instance with this ID. "
-            "Skips prompt to provide an instance ID. Useful for non-interactive sessions.",
-            metavar="CREATE_INSTANCE_ID",
-            rich_help_panel="Instance control",
+            "--version-name",
+            "-e",
+            help="Custom version name when pushing the application. Automatically generated if not provided.",
+            rich_help_panel="Versioning control",
+            metavar="VERSION_NAME",
         ),
     ] = None,
-    update_instance_id: Annotated[
+    version_description: Annotated[
         str | None,
         typer.Option(
-            "--update-instance-id",
-            "-u",
-            help="Link the newly created version to an [yellow]existing[/yellow] instance with this ID. "
-            "Skips prompt to provide an instance ID. Useful for non-interactive sessions.",
-            metavar="UPDATE_INSTANCE_ID",
-            rich_help_panel="Instance control",
+            "--version-description",
+            "-r",
+            help="Custom version description when pushing the application. Automatically generated if not provided.",
+            rich_help_panel="Versioning control",
+            metavar="VERSION_DESCRIPTION",
         ),
     ] = None,
     profile: ProfileOption = None,
@@ -90,343 +80,58 @@ def push(
     """
     Push (deploy) a Nextmv application to Nextmv Cloud.
 
-    Use the --app-dir option to specify the path to your application's root
-    directory. By default, the current working directory is used.
+    Use the [code]--app-dir[/code] option to specify the path to your
+    application's root directory. By default, the current working directory is
+    used.
 
-    You can also provide a custom manifest file using the --manifest option. If
-    not provided, the CLI will look for a file named
-    [magenta]app.yaml[/magenta] in the application's root.
+    You can also provide a custom manifest file using the [code]--manifest[/code]
+    option. If not provided, the CLI will look for a file named [magenta]app.yaml[/magenta]
+    in the application's root.
 
-    By default, this command only pushes the app. After the push, you will be
-    prompted to create a new version. If a new version is created, you will be
-    prompted to link it to an instance. If the instance exists, you will be
-    asked if you want to update it. If it doesn't, you will be asked to create
-    it. You can use the following flags to skip the prompts, useful in
-    non-interactive sessions like in a CI/CD pipeline: --version-yes,
-    --version-id, --create-instance-id, and --update-instance-id.
+    The default behavior of this command is to create a new application version
+    [italic]after[/italic] the app has been pushed. You can use the
+    [code]--no-version[/code] option to skip this step. The
+    [code]--version-...[/code] options allow you to customize the attributes of
+    the version that is created. If any of these options are not provided,
+    automatically generated values will be used.
 
     [bold][underline]Examples[/underline][/bold]
 
     - Push an application, with ID [magenta]hare-app[/magenta], from the current directory.
-        $ [dim]nextmv cloud app push --app-id hare-app[/dim]
+        $ [green]nextmv cloud app push --app-id hare-app[/green]
 
     - Push an application, with ID [magenta]hare-app[/magenta], from the [magenta]./my-app[/magenta] directory.
-        $ [dim]nextmv cloud app push --app-id hare-app --app-dir ./my-app[/dim]
+        $ [green]nextmv cloud app push --app-id hare-app --app-dir ./my-app[/green]
 
     - Push an application, with ID [magenta]hare-app[/magenta], using a custom manifest file.
-        $ [dim]nextmv cloud app push --app-id hare-app --manifest ./custom-manifest.yaml[/dim]
+        $ [green]nextmv cloud app push --app-id hare-app --manifest ./custom-manifest.yaml[/green]
 
-    - Push and automatically create a new version (no prompt).
-        $ [dim]nextmv cloud app push --app-id hare-app --version-yes[/dim]
+    - Push an application, with ID [magenta]hare-app[/magenta], from a specific
+      [magenta]./my-app[/magenta] directory with a custom manifest under [magenta]./custom-manifest.yaml[/magenta].
+        $ [green]nextmv cloud app push --app-id hare-app --app-dir ./my-app \\
+            --manifest ./custom-manifest.yaml[/green]
 
-    - Push and create a new version with a custom version ID (no prompt).
-        $ [dim]nextmv cloud app push --app-id hare-app --version-id v1.0.0[/dim]
+    - Push an application without creating a new version.
+        $ [green]nextmv cloud app push --app-id hare-app --no-version[/green]
 
-    - Push and create a new version, then link it to a new instance with a specific ID (no prompt).
-        $ [dim]nextmv cloud app push --app-id hare-app --version-yes --create-instance-id inst-1[/dim]
+    - Push an application with a custom version ID.
+        $ [green]nextmv cloud app push --app-id hare-app --version-id v1.0.0[/green]
 
-    - Push and create a new version, then link it to an existing instance (no prompt).
-        $ [dim]nextmv cloud app push --app-id hare-app --version-yes --update-instance-id inst-1[/dim]
+    - Push an application with custom version ID, name, and description.
+        $ [green]nextmv cloud app push --app-id hare-app --version-id v1.0.0 \\
+            --version-name "Release 1.0.0" \\
+            --version-description "First stable release"[/green]
     """
 
     cloud_app = build_app(app_id=app_id, profile=profile)
-
-    # If a version already exists, we cannot create it.
-    if version_id is not None and version_id != "":
-        exists = cloud_app.version_exists(version_id=version_id)
-        if exists:
-            error(
-                f"Version [magenta]{version_id}[/magenta] already exists for application [magenta]{app_id}[/magenta]."
-            )
-
-    # We cannot create and update an instance at the same time.
-    update_defined = update_instance_id is not None and update_instance_id != ""
-    create_defined = create_instance_id is not None and create_instance_id != ""
-    if update_defined and create_defined:
-        error("Cannot use --update-instance-id and --create-instance-id at the same time.")
-
-    # We cannot update an instance that does not exist.
-    if update_defined and not cloud_app.instance_exists(instance_id=update_instance_id):
-        error(
-            f"Used option --update-instance-id but the instance [magenta]{update_instance_id}[/magenta] "
-            "does not exist. Use --create-instance-id instead."
-        )
-
-    # We cannot create an instance that already exists.
-    if create_defined and cloud_app.instance_exists(instance_id=create_instance_id):
-        error(
-            f"Used option --create-instance-id but the instance [magenta]{create_instance_id}[/magenta] "
-            "already exists. Use --update-instance-id instead."
-        )
-
-    # Do the normal push first.
     loaded_manifest = Manifest.from_yaml(dirpath=manifest) if manifest is not None and manifest != "" else None
     cloud_app.push(
         manifest=loaded_manifest,
         app_dir=app_dir,
         verbose=True,
         rich_print=True,
-    )
-
-    now = datetime.now(timezone.utc)
-    version_id, should_continue = _handle_version_creation(
-        cloud_app=cloud_app,
-        app_id=app_id,
-        version_id=version_id,
-        version_yes=version_yes,
-        now=now,
-    )
-    if not should_continue:
-        return
-
-    # If the override for updating an instance was used, we update the instance
-    # and we are done.
-    if update_defined:
-        info("Used option --update-instance-id to link version to existing instance.")
-        _update_instance(
-            cloud_app=cloud_app,
-            app_id=app_id,
-            version_id=version_id,
-            instance_id=update_instance_id,
-        )
-
-        return
-
-    # If the override for creating a new instance was used, we create the
-    # instance and we are done.
-    if create_defined:
-        info("Used option --create-instance-id to link version to new instance.")
-        _create_instance(
-            cloud_app=cloud_app,
-            app_id=app_id,
-            version_id=version_id,
-            instance_id=create_instance_id,
-            now=now,
-        )
-
-        return
-
-    # If no overrides are used, we handle instance prompting.
-    _handle_instance_prompting(
-        cloud_app=cloud_app,
-        app_id=app_id,
+        no_version=no_version,
         version_id=version_id,
-        now=now,
-    )
-
-
-def _handle_version_creation(
-    cloud_app: Application,
-    app_id: str,
-    version_id: str | None,
-    version_yes: bool,
-    now: datetime,
-) -> tuple[str, bool]:
-    """
-    Handle the logic for version creation after pushing an application.
-
-    If a version ID is provided and exists, it is used directly. If not, the user is prompted (unless auto-confirmed)
-    to create a new version. If confirmed, a new version is created with an automatic description.
-
-    Parameters
-    ----------
-    cloud_app : Application
-        The cloud application object to interact with Nextmv Cloud.
-    app_id : str
-        The application ID.
-    version_id : str or None
-        The version ID to use or check for existence. If None or empty, a new version may be created.
-    version_yes : bool
-        Whether to skip the prompt and auto-create a new version.
-    now : datetime
-        The current datetime, used for version description.
-
-    Returns
-    -------
-    tuple[str, bool]
-        A tuple containing the version ID (empty string if not created) and a boolean indicating
-        whether to continue with subsequent steps (True if a version is selected or created, False otherwise).
-    """
-
-    # If the user provides a version, and it exists, we use it directly and we
-    # are done.
-    if version_id is not None and version_id != "":
-        info(f"Version [magenta]{version_id}[/magenta] does not exist. A new version will be created.")
-        version_yes = True  # Activate auto-confirm since user provided a version ID.
-
-    # If we are not auto-confirming version creation, ask the user.
-    if not version_yes:
-        should_create = get_confirmation(
-            msg=f"Do you want to create a new version for application [magenta]{app_id}[/magenta] now?",
-            default=True,
-        )
-
-        # If the user does not want to create a new version, we are done.
-        if not should_create:
-            info("Will not create a new version.")
-            return "", False
-
-    # Create a new version if either the user confirms by prompt or by using
-    # the flag.
-    in_progress("Creating a new version...")
-    version_description = f"Version created automatically from push at {now.strftime('%Y-%m-%dT%H:%M:%SZ')}"
-    version = cloud_app.new_version(
-        id=version_id,
-        description=version_description,
-    )
-    version_id = version.id
-    success(f"New version [magenta]{version_id}[/magenta] created for application [magenta]{app_id}[/magenta].")
-
-    return version_id, True
-
-
-def _handle_instance_prompting(
-    cloud_app: Application,
-    app_id: str,
-    version_id: str,
-    now: datetime,
-) -> None:
-    """
-    Handle interactive prompting for linking a version to an instance after a push.
-
-    In interactive terminals, prompts the user to link the new version to an existing or new instance.
-    If the terminal is non-interactive, skips prompting. Handles both updating existing instances and creating new ones.
-
-    Parameters
-    ----------
-    cloud_app : Application
-        The cloud application object to interact with Nextmv Cloud.
-    app_id : str
-        The application ID.
-    version_id : str
-        The version ID to link to an instance.
-    now : datetime
-        The current datetime, used for instance description if a new instance is created.
-    """
-
-    # If this is not an interactive terminal, do not ask for instance linking,
-    # to avoid hanging indefinitely waiting for a user response.
-    if not sys.stdin.isatty():
-        info("Non-interactive terminal detected. Skipping instance linking.")
-
-        return
-
-    # Prompt the user for an instance ID to link the new version to.
-    instance_id = Prompt.ask(
-        f"Do you want to link version [magenta]{version_id}[/magenta] to an instance? If so, enter the instance ID. "
-        "Leave blank to abort",
-        case_sensitive=False,
-    )
-    if instance_id == "":
-        info("No instance ID provided. Skipping instance linking.")
-        return
-
-    # Based on whether the instance exists or not, ask the user if they want to
-    # update or create it.
-    exists = cloud_app.instance_exists(instance_id=instance_id)
-
-    # If the instance exists, ask if we want to update it.
-    if exists:
-        should_update = get_confirmation(
-            msg=f"Instance [magenta]{instance_id}[/magenta] exists. "
-            f"Do you want to link it to version [magenta]{version_id}[/magenta]?",
-            default=True,
-        )
-
-        if not should_update:
-            info(f"Will not update instance [magenta]{instance_id}[/magenta].")
-            return
-
-        _update_instance(
-            cloud_app=cloud_app,
-            app_id=app_id,
-            version_id=version_id,
-            instance_id=instance_id,
-        )
-
-        return
-
-    # If the instance does not exist, ask if we want to create it.
-    should_create = get_confirmation(
-        msg=f"Instance [magenta]{instance_id}[/magenta] does not exist. "
-        f"Do you want to create it using version [magenta]{version_id}[/magenta]?",
-        default=True,
-    )
-
-    if not should_create:
-        info(f"Will not create instance [magenta]{instance_id}[/magenta].")
-        return
-
-    _create_instance(
-        cloud_app=cloud_app,
-        app_id=app_id,
-        version_id=version_id,
-        instance_id=instance_id,
-        now=now,
-    )
-
-
-def _update_instance(
-    cloud_app: Application,
-    app_id: str,
-    version_id: str,
-    instance_id: str,
-) -> None:
-    """
-    Update an existing instance to use a new version.
-
-    Parameters
-    ----------
-    cloud_app : Application
-        The cloud application object to interact with Nextmv Cloud.
-    app_id : str
-        The application ID.
-    version_id : str
-        The version ID to link to the instance.
-    instance_id : str
-        The instance ID to update.
-    """
-
-    in_progress(f"Updating instance [magenta]{instance_id}[/magenta] to use version [magenta]{version_id}[/magenta]...")
-    cloud_app.update_instance(id=instance_id, version_id=version_id)
-    success(
-        f"Instance [magenta]{instance_id}[/magenta] updated to use version [magenta]{version_id}[/magenta] "
-        f"for application [magenta]{app_id}[/magenta]."
-    )
-
-
-def _create_instance(
-    cloud_app: Application,
-    app_id: str,
-    version_id: str,
-    instance_id: str,
-    now: datetime,
-) -> None:
-    """
-    Create a new instance linked to a specific version.
-
-    Parameters
-    ----------
-    cloud_app : Application
-        The cloud application object to interact with Nextmv Cloud.
-    app_id : str
-        The application ID.
-    version_id : str
-        The version ID to link to the new instance.
-    instance_id : str
-        The instance ID to create.
-    now : datetime
-        The current datetime, used for the instance description.
-    """
-
-    in_progress(f"Creating a new instance with ID [magenta]{instance_id}[/magenta]...")
-    instance_description = f"Instance created automatically from push at {now.strftime('%Y-%m-%dT%H:%M:%SZ')}"
-    instance = cloud_app.new_instance(
-        version_id=version_id,
-        id=instance_id,
-        description=instance_description,
-    )
-    success(
-        f"New instance [magenta]{instance.id}[/magenta] created using version [magenta]{version_id}[/magenta] "
-        f"for application [magenta]{app_id}[/magenta]."
+        version_name=version_name,
+        version_description=version_description,
     )

nextmv/cli/cloud/app/update.py

@@ -74,33 +74,33 @@ def update(
     [bold][underline]Examples[/underline][/bold]
 
     - Update an application's name.
-        $ [dim]nextmv cloud app update --app-id hare-app --name "New Hare App"[/dim]
+        $ [green]nextmv cloud app update --app-id hare-app --name "New Hare App"[/green]
 
     - Update an application's description.
-        $ [dim]nextmv cloud app update --app-id hare-app --name "Hare App" \\
-            --description "An updated description for routing hares"[/dim]
+        $ [green]nextmv cloud app update --app-id hare-app --name "Hare App" \\
+            --description "An updated description for routing hares"[/green]
 
     - Update an application's default instance ID.
-        $ [dim]nextmv cloud app update --app-id hare-app --name "Hare App" \\
-            --default-instance-id burrow[/dim]
+        $ [green]nextmv cloud app update --app-id hare-app --name "Hare App" \\
+            --default-instance-id burrow[/green]
 
     - Update an application's default experiment instance.
-        $ [dim]nextmv cloud app update --app-id hare-app --name "Hare App" \\
-            --default-experiment-instance experiment-v1[/dim]
+        $ [green]nextmv cloud app update --app-id hare-app --name "Hare App" \\
+            --default-experiment-instance experiment-v1[/green]
 
     - Update multiple application properties at once.
-        $ [dim]nextmv cloud app update --app-id hare-app --name "Hare App" \\
+        $ [green]nextmv cloud app update --app-id hare-app --name "Hare App" \\
             --description "Updated description" --default-instance-id burrow \\
-            --default-experiment-instance experiment-v1[/dim]
+            --default-experiment-instance experiment-v1[/green]
 
     - Update an application and save the updated information to an [magenta]updated_app.json[/magenta] file.
-        $ [dim]nextmv cloud app update --app-id hare-app --name "New Hare App" --output updated_app.json[/dim]
+        $ [green]nextmv cloud app update --app-id hare-app --name "New Hare App" --output updated_app.json[/green]
     """
 
     if name is None and description is None and default_instance_id is None and default_experiment_instance is None:
         error(
-            "Provide at least one option to update: --name, --description, "
-            "--default-instance-id, or --default-experiment-instance."
+            "Provide at least one option to update: [code]--name[/code], [code]--description[/code], "
+            "[code]--default-instance-id[/code], or [code]--default-experiment-instance[/code]."
         )
 
     cloud_app = build_app(app_id=app_id, profile=profile)

nextmv/cli/cloud/batch/create.py

@@ -109,7 +109,7 @@ def create(
             "--wait",
             "-w",
             help="Wait for the batch experiment to complete. Results are printed to [magenta]stdout[/magenta]. "
-            "Specify output location with --output.",
+            "Specify output location with [code]--output[/code].",
             rich_help_panel="Output control",
         ),
     ] = False,
@@ -122,19 +122,21 @@ def create(
     configurations. Each run is defined by a combination of input, instance or
     version, and optional configuration options.
 
-    Use the --wait flag to wait for the batch experiment to complete, polling
-    for results. Using the --output flag will also activate waiting, and allows
-    you to specify a destination file for the results.
+    Use the [code]--wait[/code] flag to wait for the batch experiment to
+    complete, polling for results. Using the [code]--output[/code] flag will
+    also activate waiting, and allows you to specify a destination file for the
+    results.
 
     [bold][underline]Runs[/underline][/bold]
 
-    Runs are provided as [magenta]json[/magenta] objects using the --runs flag.
-    Each run defines what input, instance/version, and configuration to use.
+    Runs are provided as [magenta]json[/magenta] objects using the
+    [code]--runs[/code] flag. Each run defines what input, instance/version,
+    and configuration to use.
 
     You can provide runs in three ways:
     - A single run as a [magenta]json[/magenta] object.
-    - Multiple runs by repeating the --runs flag.
-    - Multiple runs as a [magenta]json[/magenta] array in a single --runs flag.
+    - Multiple runs by repeating the [code]--runs[/code] flag.
+    - Multiple runs as a [magenta]json[/magenta] array in a single [code]--runs[/code] flag.
 
     Each run must have the following fields:
     - [magenta]input_id[/magenta]: ID of the input to use for this run
@@ -144,46 +146,46 @@ def create(
     - [magenta]instance_id[/magenta] OR [magenta]version_id[/magenta]: Either an instance ID or
       version ID must be provided (at least one required).
     - [magenta]option_set[/magenta]: ID of the option set to use (optional).
-      Make sure to define the option sets using the --option-sets flag.
+      Make sure to define the option sets using the [code]--option-sets[/code] flag.
     - [magenta]input_set_id[/magenta]: ID of the input set (optional).
     - [magenta]scenario_id[/magenta]: Scenario ID if part of a scenario test (optional).
     - [magenta]repetition[/magenta]: Repetition number (optional).
 
     Object format:
-    [dim]{
+    [green]{
         "input_id": "meadow-input-a1",
         "instance_id": "bunny-hopper-v2",
         "option_set": "speed-optimized",
         "input_set_id": "spring-gardens"
-    }[/dim]
+    }[/green]
 
     [bold][underline]Option Sets[/underline][/bold]
 
     Option sets are provided as a [magenta]json[/magenta] object using the
-    --option-sets flag. Option sets define named collections of
+    [code]--option-sets[/code] flag. Option sets define named collections of
     runtime options that can be referenced by runs.
 
     The option sets object is a dictionary where keys are option set IDs and
     values are dictionaries of string key-value pairs representing the options.
 
     Object format:
-    [dim]{
+    [green]{
         "speed-optimized": {"timeout": "30", "algorithm": "fast"},
         "quality-focused": {"timeout": "300", "algorithm": "thorough"}
-    }[/dim]
+    }[/green]
 
     [bold][underline]Examples[/underline][/bold]
 
     - Create a batch experiment with a single run.
-        $ [dim]RUN='{
+        $ [green]RUN='{
             "input_id": "carrot-patch-a",
             "instance_id": "warren-planner-v1"
         }'
         nextmv cloud batch create --app-id hare-app --batch-experiment-id bunny-hop-test \\
-            --name "Spring Meadow Routes" --input-set-id spring-gardens --runs "$RUN"[/dim]
+            --name "Spring Meadow Routes" --input-set-id spring-gardens --runs "$RUN"[/green]
 
     - Create with multiple runs by repeating the flag.
-        $ [dim]RUN1='{
+        $ [green]RUN1='{
             "input_id": "lettuce-field-1",
             "instance_id": "hop-optimizer"
         }'
@@ -193,10 +195,10 @@ def create(
         }'
         nextmv cloud batch create --app-id hare-app --batch-experiment-id lettuce-routes \\
             --name "Lettuce Delivery Optimization" --input-set-id veggie-gardens \\
-            --runs "$RUN1" --runs "$RUN2"[/dim]
+            --runs "$RUN1" --runs "$RUN2"[/green]
 
     - Create with multiple runs in a single [magenta]json[/magenta] array.
-        $ [dim]RUNS='[
+        $ [green]RUNS='[
             {
                 "input_id": "warren-zone-a",
                 "instance_id": "burrow-builder"
@@ -207,28 +209,28 @@ def create(
             }
         ]'
         nextmv cloud batch create --app-id hare-app --batch-experiment-id warren-expansion \\
-            --name "Warren Construction Plans" --input-set-id burrow-sites --runs "$RUNS"[/dim]
+            --name "Warren Construction Plans" --input-set-id burrow-sites --runs "$RUNS"[/green]
 
     - Create a batch experiment and wait for it to complete.
-        $ [dim]RUN='{
+        $ [green]RUN='{
             "input_id": "carrot-harvest",
             "instance_id": "foraging-route"
         }'
         nextmv cloud batch create --app-id hare-app --batch-experiment-id harvest-time \\
             --name "Autumn Carrot Collection" --input-set-id harvest-season \\
-            --runs "$RUN" --wait[/dim]
+            --runs "$RUN" --wait[/green]
 
     - Create a batch experiment and save the results to a file, waiting for completion.
-        $ [dim]RUN='{
+        $ [green]RUN='{
             "input_id": "predator-zones",
             "instance_id": "safe-hopper"
         }'
         nextmv cloud batch create --app-id hare-app --batch-experiment-id safety-analysis \\
             --name "Fox Avoidance Routes" --input-set-id danger-zones \\
-            --runs "$RUN" --output bunny-safety-results.json[/dim]
+            --runs "$RUN" --output bunny-safety-results.json[/green]
 
     - Create a batch experiment with option sets.
-        $ [dim]RUN1='{
+        $ [green]RUN1='{
             "input_id": "garden-route-1",
             "instance_id": "hop-optimizer",
             "option_set": "fast-hops"
@@ -244,7 +246,7 @@ def create(
         }'
         nextmv cloud batch create --app-id hare-app --batch-experiment-id hop-comparison \\
             --name "Speed vs Safety Analysis" --input-set-id garden-paths \\
-            --runs "$RUN1" --runs "$RUN2" --option-sets "$OPTION_SETS"[/dim]
+            --runs "$RUN1" --runs "$RUN2" --option-sets "$OPTION_SETS"[/green]
     """
 
     cloud_app = build_app(app_id=app_id, profile=profile)