nextmv 0.39.0.dev1__py3-none-any.whl → 1.0.0__py3-none-any.whl

nextmv/cli/configuration/list.py

@@ -0,0 +1,77 @@
+"""
+This module defines the configuration list command for the Nextmv CLI.
+"""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from nextmv.cli.configuration.config import API_KEY_KEY, ENDPOINT_KEY, load_config, non_profile_keys, obscure_api_key
+from nextmv.cli.message import error
+
+# Set up subcommand application.
+app = typer.Typer()
+console = Console()
+
+
+@app.command()
+def list() -> None:
+    """
+    List the current configuration and all profiles.
+
+    [bold][underline]Examples[/underline][/bold]
+
+    - Show current configuration and all profiles.
+        $ [dim]nextmv configuration list[/dim]
+    """
+
+    config = load_config()
+    if config == {}:
+        error("No configuration found. Please run [code]nextmv configuration[/code].")
+
+    default = {
+        "api_key": config.get(API_KEY_KEY),
+        "endpoint": config.get(ENDPOINT_KEY),
+        "name": "Default",
+    }
+    profiles = [default]
+
+    for k, v in config.items():
+        # Skip default configuration.
+        if k in non_profile_keys():
+            continue
+
+        profile = {
+            "name": k,
+            "api_key": v.get(API_KEY_KEY),
+            "endpoint": v.get(ENDPOINT_KEY),
+        }
+        profiles.append(profile)
+
+    table = Table("Profile name", "API Key", "Endpoint")
+    not_set = "[italic]Not set[/italic]"
+    for profile in profiles:
+        if profile["name"] != "Default":
+            table.add_row(
+                profile["name"],
+                obscure_api_key(profile["api_key"]) if profile.get("api_key") is not None else not_set,
+                profile["endpoint"] if profile.get("endpoint") is not None else not_set,
+            )
+            continue
+
+        api_key = not_set
+        if profile.get("api_key") is not None:
+            api_key = obscure_api_key(profile["api_key"])
+
+        endpoint = not_set
+        if profile.get("endpoint") is not None:
+            endpoint = profile["endpoint"]
+
+        table.add_row(
+            f"[bold yellow]{profile['name']}[/bold yellow]",
+            f"[bold yellow]{api_key}[/bold yellow]",
+            f"[bold yellow]{endpoint}[/bold yellow]",
+        )
+        table.add_section()
+
+    console.print(table)

nextmv/cli/confirm.py

@@ -0,0 +1,34 @@
+import sys
+
+from rich.prompt import Confirm
+
+
+def get_confirmation(msg: str, default: bool = False) -> bool:
+    """
+    Method to get a yes/no confirmation from the user.
+
+    Parameters
+    ----------
+    msg : str
+        The message to display to the user.
+    default : bool, optional
+        The default value if the user just presses Enter. Default is False.
+
+    Returns
+    -------
+    bool
+        True if the user confirmed, False otherwise.
+    """
+
+    # If this is not an interactive terminal, do not ask for confirmation, to
+    # avoid hanging indefinitely waiting for a user response.
+    if not sys.stdin.isatty():
+        return default
+
+    return Confirm.ask(
+        msg,
+        default=default,
+        case_sensitive=False,
+        show_default=True,
+        show_choices=True,
+    )

nextmv/cli/main.py

@@ -1,20 +1,178 @@
 """
 The Nextmv Command Line Interface (CLI).
 
-This module is the main entry point for the Nextmv CLI application.
+This module is the main entry point for the Nextmv CLI application. The Nextmv
+CLI is built with [Typer](https://typer.tiangolo.com/) and provides various
+commands to interact with Nextmv services. You should visit the "Learn" section
+of the Typer documentation to learn about the features that are used here.
+
+The Nextmv CLI also uses [Rich](https://rich.readthedocs.io/en/stable/) for
+rich text and formatting in the terminal. The command documentation is created
+using Rich markup. You should also visit the Rich documentation to learn more
+about the features used here. An example of Rich markup can be found in the
+epilog of the Typer application defined below.
 """
 
+import sys
+from typing import Annotated
+
+import rich
 import typer
+from typer import rich_utils
 
+from nextmv.cli.cloud import app as cloud_app
+from nextmv.cli.community import app as community_app
+from nextmv.cli.configuration import app as configuration_app
+from nextmv.cli.configuration.config import CONFIG_DIR, GO_CLI_PATH, load_config
+from nextmv.cli.confirm import get_confirmation
+from nextmv.cli.message import error, info, success, warning
 from nextmv.cli.version import app as version_app
+from nextmv.cli.version import version_callback
+
+# Disable dim text for the extended help of commands.
+rich_utils.STYLE_HELPTEXT = ""
 
 # Main CLI application.
 app = typer.Typer(
     help="The Nextmv Command Line Interface (CLI).",
-    epilog="[italic]:rabbit: Made with :heart: by Nextmv.[/italic]",
+    epilog="[dim]\n---\n\n[italic]:rabbit: Made by Nextmv with :heart:[/italic][/dim]",
     rich_markup_mode="rich",
     context_settings={"help_option_names": ["--help", "-h"]},
+    no_args_is_help=True,
+    invoke_without_command=True,
+    pretty_exceptions_show_locals=False,
 )
 
-# Register subcommands.
+# Register subcommands. The `name` parameter is required when the subcommand
+# module has a callback function defined.
+app.add_typer(cloud_app, name="cloud")
+app.add_typer(community_app, name="community")
+app.add_typer(configuration_app, name="configuration")
 app.add_typer(version_app)
+
+
+@app.callback()
+def callback(
+    ctx: typer.Context,
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            "-v",
+            help="Show the current version of the Nextmv CLI.",
+            callback=version_callback,
+        ),
+    ] = None,
+) -> None:
+    """
+    Callback function that runs before any command. Useful for checks on the
+    environment.
+    """
+
+    # Skip checks for help commands.
+    if "--help" in sys.argv or "-h" in sys.argv:
+        return
+
+    # Skip checks for certain commands.
+    ignored_commands = {"configuration", "version"}
+    if ctx.invoked_subcommand in ignored_commands:
+        return
+
+    handle_go_cli()
+    handle_config_existence(ctx)
+
+
+def handle_go_cli() -> None:
+    """
+    Handle the presence of the deprecated Go CLI by notifying the user.
+
+    This function checks if the Go CLI is installed and prompts the user to
+    remove it to avoid conflicts with the Python CLI.
+    """
+
+    exists = go_cli_exists()
+    if exists:
+        delete = get_confirmation(
+            "Do you want to delete the [italic red]deprecated[/italic red] Nextmv CLI "
+            f"at [magenta]{GO_CLI_PATH}[/magenta] now?"
+        )
+        if delete:
+            remove_go_cli()
+            return
+
+        info(
+            "You can delete the [italic red]deprecated[/italic red] Nextmv CLI later by removing "
+            f"[magenta]{GO_CLI_PATH}[/magenta]. "
+            "Make sure you also clean up your [code]PATH[/code], "
+            f"by removing references to [magenta]{CONFIG_DIR}[/magenta] from it."
+        )
+
+
+def handle_config_existence(ctx: typer.Context) -> None:
+    """
+    Check if configuration exists and show an error if it does not.
+
+    Parameters
+    ----------
+    ctx : typer.Context
+        The Typer context object.
+    """
+
+    config = load_config()
+    if config == {}:
+        error("No configuration found. Please run [code]nextmv configuration create[/code].")
+
+
+def go_cli_exists() -> bool:
+    """
+    Check if the Go CLI is installed by looking for the 'nextmv' executable
+    under the config dir.
+
+    Returns
+    -------
+    bool
+        True if the Go CLI is installed, False otherwise.
+    """
+
+    # Check if the Go CLI executable exists
+    exists = GO_CLI_PATH.exists()
+    if exists:
+        warning(
+            "A [italic red]deprecated[/italic red] Nextmv CLI is installed at "
+            f"[magenta]{GO_CLI_PATH}[/magenta]. You should delete it to avoid conflicts."
+        )
+
+    return exists
+
+
+def remove_go_cli() -> None:
+    """
+    Remove the Go CLI executable if it exists and notify about PATH cleanup.
+    """
+
+    if GO_CLI_PATH.exists():
+        GO_CLI_PATH.unlink()
+        success(f"Deleted [italic red]deprecated[/italic red] [magenta]{GO_CLI_PATH}[/magenta].")
+
+
+def main() -> None:
+    """
+    Entry point for the CLI with global exception handling.
+
+    Catches all exceptions except Typer/Click exceptions (which handle their
+    own exit codes) and displays a clean error message instead of a traceback.
+    """
+
+    try:
+        app()
+    except (typer.Exit, typer.Abort, SystemExit):
+        raise
+    except Exception as e:
+        # We do not use the messages.error function here because doing so would
+        # raise a Typer exception, which would print a traceback.
+        msg = str(e).rstrip("\n")
+        if not msg.endswith("."):
+            msg += "."
+
+        rich.print(f"[red]Error:[/red] {msg}", file=sys.stderr)
+        sys.exit(1)

nextmv/cli/message.py

@@ -0,0 +1,170 @@
+"""
+The message module is used to print messages to the user with pre-defined
+formatting. Logging, in general, is always printed to stderr.
+"""
+
+import sys
+from enum import Enum
+from typing import Any
+
+import rich
+import typer
+
+
+def message(msg: str, emoji: str | None = None) -> None:
+    """
+    Pretty-print a message. Your message should end with a period. The use of
+    emojis is encouraged to give context to the message. An emoji should be a
+    string as specified in:
+    https://rich.readthedocs.io/en/latest/markup.html#emoji.
+
+    Parameters
+    ----------
+    msg : str
+        The message to display.
+    emoji : str | None
+        An optional emoji to prefix the message. If None, no emoji is used. The
+        emoji should be a string as specified in:
+        https://rich.readthedocs.io/en/latest/markup.html#emoji. For example:
+        `:hourglass_flowing_sand:`.
+    """
+
+    msg = _format(msg)
+    if emoji:
+        rich.print(f"{emoji} {msg}", file=sys.stderr)
+        return
+
+    rich.print(msg, file=sys.stderr)
+
+
+def info(msg: str) -> None:
+    """
+    Pretty-print an informational message. Your message should end with a
+    period.
+
+    Parameters
+    ----------
+    msg : str
+        The informational message to display.
+    """
+
+    message(msg, emoji=":bulb:")
+
+
+def in_progress(msg: str) -> None:
+    """
+    Pretty-print an in-progress message with an hourglass emoji. Your message
+    should end with a period.
+
+    Parameters
+    ----------
+    msg : str
+        The in-progress message to display.
+    """
+
+    message(msg, emoji=":hourglass_flowing_sand:")
+
+
+def success(msg: str) -> None:
+    """
+    Pretty-print a success message. Your message should end with a period.
+
+    Parameters
+    ----------
+    msg : str
+        The success message to display.
+    """
+
+    message(msg, emoji=":white_check_mark:")
+
+
+def warning(msg: str) -> None:
+    """
+    Pretty-print a warning message. Your message should end with a period.
+
+    Parameters
+    ----------
+    msg : str
+        The warning message to display.
+    """
+
+    msg = _format(msg)
+    rich.print(f":construction: [yellow] Warning:[/yellow] {msg}", file=sys.stderr)
+
+
+def error(msg: str) -> None:
+    """
+    Pretty-print an error message and exit with code 1. Your message should end
+    with a period.
+
+    Parameters
+    ----------
+    msg : str
+        The error message to display.
+
+    Raises
+    ------
+    typer.Exit
+        Exits the program with code 1.
+    """
+
+    msg = _format(msg)
+    rich.print(f":x: [red]Error:[/red] {msg}", file=sys.stderr)
+
+    raise typer.Exit(code=1)
+
+
+def print_json(data: dict[str, Any] | list[dict[str, Any]]) -> None:
+    """
+    Pretty-print json-serializable data as JSON to stdout.
+
+    Parameters
+    ----------
+    data : dict[str, Any] | list[dict[str, Any]]
+        The data to print as JSON.
+    """
+
+    rich.print_json(data=data)
+
+
+def enum_values(enum_class: Enum) -> str:
+    """
+    Get a nicely formatted string of the values of an Enum class, using commas
+    and an oxford comma.
+
+    Parameters
+    ----------
+    enum_class : Enum
+        The Enum class to get the values from.
+
+    Returns
+    -------
+    str
+        A nicely formatted string of the values of the Enum class.
+    """
+
+    values = [f"[magenta]{member.value}[/magenta]" for member in enum_class]
+    if len(values) == 0:
+        return ""
+    if len(values) == 1:
+        return values[0]
+    if len(values) == 2:
+        return " and ".join(values)
+
+    return ", ".join(values[:-1]) + ", and " + values[-1]
+
+
+def _format(msg: str) -> str:
+    """
+    Format a message to ensure it ends with a period.
+
+    Parameters
+    ----------
+    msg : str
+        The message to format.
+    """
+    msg = msg.rstrip("\n")
+    if not msg.endswith("."):
+        msg += "."
+
+    return msg

nextmv/cli/options.py

@@ -0,0 +1,220 @@
+"""
+Shared CLI options for the Nextmv CLI.
+
+This module defines reusable option types that can be imported
+and used across all CLI commands.
+"""
+
+from typing import Annotated
+
+import typer
+
+# profile option - can be used in any command to specify which profile to use.
+# Define it as follows in commands or callbacks, as necessary:
+# profile: ProfileOption = None
+ProfileOption = Annotated[
+    str | None,
+    typer.Option(
+        "--profile",
+        "-p",
+        help="Profile to use for this action. Use [code]nextmv configuration[/code] to manage profiles.",
+        envvar="NEXTMV_PROFILE",
+        metavar="PROFILE_NAME",
+    ),
+]
+
+# app_id option - can be used in any command that requires an application ID.
+# Define it as follows in commands or callbacks, as necessary:
+# app_id: AppIDOption
+AppIDOption = Annotated[
+    str,
+    typer.Option(
+        "--app-id",
+        "-a",
+        help="The Nextmv Cloud application ID to use for this action.",
+        envvar="NEXTMV_APP_ID",
+        metavar="APP_ID",
+    ),
+]
+
+# run_id option - can be used in any command that requires a run ID.
+# Define it as follows in commands or callbacks, as necessary:
+# run_id: RunIDOption
+RunIDOption = Annotated[
+    str,
+    typer.Option(
+        "--run-id",
+        "-r",
+        help="The Nextmv Cloud run ID to use for this action.",
+        envvar="NEXTMV_RUN_ID",
+        metavar="RUN_ID",
+    ),
+]
+
+# version_id option - can be used in any command that requires a version ID.
+# Define it as follows in commands or callbacks, as necessary:
+# version_id: VersionIDOption
+VersionIDOption = Annotated[
+    str,
+    typer.Option(
+        "--version-id",
+        "-v",
+        help="The Nextmv Cloud version ID to use for this action.",
+        envvar="NEXTMV_VERSION_ID",
+        metavar="VERSION_ID",
+    ),
+]
+
+# input_set_id option - can be used in any command that requires an input set ID.
+# Define it as follows in commands or callbacks, as necessary:
+# input_set_id: InputSetIDOption
+InputSetIDOption = Annotated[
+    str,
+    typer.Option(
+        "--input-set-id",
+        "-s",
+        help="The Nextmv Cloud input set ID to use for this action.",
+        envvar="NEXTMV_INPUT_SET_ID",
+        metavar="INPUT_SET_ID",
+    ),
+]
+
+# instance_id option - can be used in any command that requires an instance ID.
+# Define it as follows in commands or callbacks, as necessary:
+# instance_id: InstanceIDOption
+InstanceIDOption = Annotated[
+    str,
+    typer.Option(
+        "--instance-id",
+        "-i",
+        help="The Nextmv Cloud instance ID to use for this action.",
+        envvar="NEXTMV_INSTANCE_ID",
+        metavar="INSTANCE_ID",
+    ),
+]
+
+# managed_input_id option - can be used in any command that requires a managed input ID.
+# Define it as follows in commands or callbacks, as necessary:
+# managed_input_id: ManagedInputIDOption
+ManagedInputIDOption = Annotated[
+    str,
+    typer.Option(
+        "--managed-input-id",
+        "-m",
+        help="The Nextmv Cloud managed input ID to use for this action.",
+        envvar="NEXTMV_MANAGED_INPUT_ID",
+        metavar="MANAGED_INPUT_ID",
+    ),
+]
+
+# ensemble_definition_id option - can be used in any command that requires an ensemble definition ID.
+# Define it as follows in commands or callbacks, as necessary:
+# ensemble_definition_id: EnsembleDefinitionIDOption
+EnsembleDefinitionIDOption = Annotated[
+    str,
+    typer.Option(
+        "--ensemble-definition-id",
+        "-e",
+        help="The Nextmv Cloud ensemble definition ID to use for this action.",
+        envvar="NEXTMV_ENSEMBLE_DEFINITION_ID",
+        metavar="ENSEMBLE_DEFINITION_ID",
+    ),
+]
+
+# account_id option - can be used in any command that requires an account ID.
+# Define it as follows in commands or callbacks, as necessary:
+# account_id: AccountIDOption
+AccountIDOption = Annotated[
+    str,
+    typer.Option(
+        "--account-id",
+        "-a",
+        help="The Nextmv Cloud account ID to use for this action.",
+        envvar="NEXTMV_ACCOUNT_ID",
+        metavar="ACCOUNT_ID",
+    ),
+]
+
+# acceptance_test_id option - can be used in any command that requires an acceptance test ID.
+# Define it as follows in commands or callbacks, as necessary:
+# acceptance_test_id: AcceptanceTestIDOption
+AcceptanceTestIDOption = Annotated[
+    str,
+    typer.Option(
+        "--acceptance-test-id",
+        "-t",
+        help="The Nextmv Cloud acceptance test ID to use for this action.",
+        envvar="NEXTMV_ACCEPTANCE_TEST_ID",
+        metavar="ACCEPTANCE_TEST_ID",
+    ),
+]
+
+# batch_experiment_id option - can be used in any command that requires a batch experiment ID.
+# Define it as follows in commands or callbacks, as necessary:
+# batch_experiment_id: BatchExperimentIDOption
+BatchExperimentIDOption = Annotated[
+    str,
+    typer.Option(
+        "--batch-experiment-id",
+        "-b",
+        help="The Nextmv Cloud batch experiment ID to use for this action.",
+        envvar="NEXTMV_BATCH_EXPERIMENT_ID",
+        metavar="BATCH_EXPERIMENT_ID",
+    ),
+]
+
+# scenario_test_id option - can be used in any command that requires a scenario test ID.
+# Define it as follows in commands or callbacks, as necessary:
+# scenario_test_id: ScenarioTestIDOption
+ScenarioTestIDOption = Annotated[
+    str,
+    typer.Option(
+        "--scenario-test-id",
+        "-i",
+        help="The Nextmv Cloud scenario test ID to use for this action.",
+        envvar="NEXTMV_SCENARIO_TEST_ID",
+        metavar="SCENARIO_TEST_ID",
+    ),
+]
+
+# secrets_collection_id option - can be used in any command that requires a secrets collection ID.
+# Define it as follows in commands or callbacks, as necessary:
+# secrets_collection_id: SecretsCollectionIDOption
+SecretsCollectionIDOption = Annotated[
+    str,
+    typer.Option(
+        "--secrets-collection-id",
+        "-s",
+        help="The Nextmv Cloud secrets collection ID to use for this action.",
+        envvar="NEXTMV_SECRETS_COLLECTION_ID",
+        metavar="SECRETS_COLLECTION_ID",
+    ),
+]
+
+# shadow_test_id option - can be used in any command that requires a shadow test ID.
+# Define it as follows in commands or callbacks, as necessary:
+# shadow_test_id: ShadowTestIDOption
+ShadowTestIDOption = Annotated[
+    str,
+    typer.Option(
+        "--shadow-test-id",
+        "-s",
+        help="The Nextmv Cloud shadow test ID to use for this action.",
+        envvar="NEXTMV_SHADOW_TEST_ID",
+        metavar="SHADOW_TEST_ID",
+    ),
+]
+
+# switchback_test_id option - can be used in any command that requires a switchback test ID.
+# Define it as follows in commands or callbacks, as necessary:
+# switchback_test_id: SwitchbackTestIDOption
+SwitchbackTestIDOption = Annotated[
+    str,
+    typer.Option(
+        "--switchback-test-id",
+        "-s",
+        help="The Nextmv Cloud switchback test ID to use for this action.",
+        envvar="NEXTMV_SWITCHBACK_TEST_ID",
+        metavar="SWITCHBACK_TEST_ID",
+    ),
+]