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

nextmv/cli/community/clone.py

@@ -2,14 +2,19 @@
 This module defines the community clone command for the Nextmv CLI.
 """
 
+import os
+import shutil
+import tarfile
+import tempfile
+from collections.abc import Callable
 from typing import Annotated
 
+import rich
 import typer
 
-from nextmv.cli.configuration.config import build_client
-from nextmv.cli.message import error
+from nextmv.cli.community.list import download_file, download_manifest, find_app, versions_table
+from nextmv.cli.message import error, success
 from nextmv.cli.options import ProfileOption
-from nextmv.cloud.community import clone_community_app
 
 # Set up subcommand application.
 app = typer.Typer()
@@ -48,39 +53,218 @@ def clone(
     Clone a community app locally.
 
     By default, the [magenta]latest[/magenta] version will be used. You can
-    specify a version with the --version flag, and customize the output
-    directory with the --directory flag. If you want to list the available
-    apps, use the [code]nextmv community list[/code] command.
+    specify a version with the [code]--version[/code] flag, and customize the
+    output directory with the [code]--directory[/code] flag. If you want to
+    list the available apps, use the [code]nextmv community list[/code] command.
 
     [bold][underline]Examples[/underline][/bold]
 
     - Clone the [magenta]go-nextroute[/magenta] community app (under the
       [magenta]"go-nextroute"[/magenta] directory), using the [magenta]latest[/magenta] version.
-        $ [dim]nextmv community clone --app go-nextroute[/dim]
+        $ [green]nextmv community clone --app go-nextroute[/green]
 
     - Clone the [magenta]go-nextroute[/magenta] community app under the
       [magenta]"~/sample/my_app"[/magenta] directory, using the [magenta]latest[/magenta] version.
-        $ [dim]nextmv community clone --app go-nextroute --directory ~/sample/my_app[/dim]
+        $ [green]nextmv community clone --app go-nextroute --directory ~/sample/my_app[/green]
 
     - Clone the [magenta]go-nextroute[/magenta] community app (under the
       [magenta]"go-nextroute"[/magenta] directory), using version [magenta]v1.2.0[/magenta].
-        $ [dim]nextmv community clone --app go-nextroute --version v1.2.0[/dim]
+        $ [green]nextmv community clone --app go-nextroute --version v1.2.0[/green]
 
     - Clone the [magenta]go-nextroute[/magenta] community app (under the
       [magenta]"go-nextroute"[/magenta] directory), using the [magenta]latest[/magenta] version
       and a profile named [magenta]hare[/magenta].
-        $ [dim]nextmv community clone --app go-nextroute --profile hare[/dim]
+        $ [green]nextmv community clone --app go-nextroute --profile hare[/green]
     """
 
+    manifest = download_manifest(profile=profile)
+    app_obj = find_app(manifest, app)
+
     if version is not None and version == "":
-        error("The --version flag cannot be an empty string.")
-
-    client = build_client(profile)
-    clone_community_app(
-        client=client,
-        app=app,
-        directory=directory,
-        version=version,
-        verbose=True,
-        rich_print=True,
+        error("The [code]--version[/code] flag cannot be an empty string.")
+
+    if not app_has_version(app_obj, version):
+        # We don't use error() here to allow printing something before exiting.
+        rich.print(
+            f"[red]Error:[/red] Version [magenta]{version}[/magenta] not found "
+            f"for community app [magenta]{app}[/magenta]. Available versions are:"
+        )
+        versions_table(manifest, app)
+
+        raise typer.Exit(code=1)
+
+    original_version = version
+    if version == LATEST_VERSION:
+        version = app_obj.get("latest_app_version")
+
+    destination = directory
+    if directory is None or directory == "":
+        destination = app
+
+    full_destination = get_valid_path(destination, os.stat)
+    os.makedirs(full_destination, exist_ok=True)
+
+    tarball = f"{app}_{version}.tar.gz"
+    s3_file_path = f"{app}/{version}/{tarball}"
+    downloaded_object = download_object(
+        file=s3_file_path,
+        path="community-apps",
+        output_dir=full_destination,
+        output_file=tarball,
+        profile=profile,
+    )
+
+    # Extract the tarball to a temporary directory to handle nested structure
+    with tempfile.TemporaryDirectory() as temp_dir:
+        with tarfile.open(downloaded_object, "r:gz") as tar:
+            tar.extractall(path=temp_dir)
+
+        # Find the extracted directory (typically the app name)
+        extracted_items = os.listdir(temp_dir)
+        if len(extracted_items) == 1 and os.path.isdir(os.path.join(temp_dir, extracted_items[0])):
+            # Move contents from the extracted directory to full_destination
+            extracted_dir = os.path.join(temp_dir, extracted_items[0])
+            for item in os.listdir(extracted_dir):
+                shutil.move(os.path.join(extracted_dir, item), full_destination)
+        else:
+            # If structure is unexpected, move everything directly
+            for item in extracted_items:
+                shutil.move(os.path.join(temp_dir, item), full_destination)
+
+    # Remove the tarball after extraction
+    os.remove(downloaded_object)
+
+    success(
+        f"Successfully cloned the [magenta]{app}[/magenta] community app, "
+        f"using version [magenta]{original_version}[/magenta] in path: [magenta]{full_destination}[/magenta]."
     )
+
+
+def app_has_version(app_obj: dict, version: str) -> bool:
+    """
+    Check if the given app object has the specified version.
+
+    Parameters
+    ----------
+    app_obj : dict
+        The community app object.
+    version : str
+        The version to check.
+
+    Returns
+    -------
+    bool
+        True if the app has the specified version, False otherwise.
+    """
+
+    if version == LATEST_VERSION:
+        version = app_obj.get("latest_app_version")
+
+    if version in app_obj.get("app_versions", []):
+        return True
+
+    return False
+
+
+def get_valid_path(path: str, stat_fn: Callable[[str], os.stat_result], ending: str = "") -> str:
+    """
+    Validates and returns a non-existing path. If the path exists,
+    it will append a number to the path and return it. If the path does not
+    exist, it will return the path as is.
+
+    The ending parameter is used to check if the path ends with a specific
+    string. This is useful to specify if it is a file (like foo.json, in which
+    case the next iteration is foo-1.json) or a directory (like foo, in which
+    case the next iteration is foo-1).
+
+    Parameters
+    ----------
+    path : str
+        The initial path to validate.
+    stat_fn : Callable[[str], os.stat_result]
+        A function that takes a path and returns its stat result.
+    ending : str, optional
+        The expected ending of the path (e.g., file extension), by default "".
+
+    Returns
+    -------
+    str
+        A valid, non-existing path.
+
+    Raises
+    ------
+    Exception
+        If an unexpected error occurs during path validation
+    """
+    base_name = os.path.basename(path)
+    name_without_ending = base_name.removesuffix(ending) if ending else base_name
+
+    while True:
+        try:
+            stat_fn(path)
+            # If we get here, the path exists
+            # Get folder/file name number, increase it and create new path
+            name = os.path.basename(path)
+
+            # Get folder/file name number
+            parts = name.split("-")
+            last = parts[-1].removesuffix(ending) if ending else parts[-1]
+
+            # Save last folder name index to be changed
+            i = path.rfind(name)
+
+            try:
+                num = int(last)
+                # Increase number and create new path
+                if ending:
+                    temp_path = path[:i] + f"{name_without_ending}-{num + 1}{ending}"
+                else:
+                    temp_path = path[:i] + f"{base_name}-{num + 1}"
+                path = temp_path
+            except ValueError:
+                # If there is no number, add it
+                if ending:
+                    temp_path = path[:i] + f"{name_without_ending}-1{ending}"
+                else:
+                    temp_path = path[:i] + f"{name}-1"
+                path = temp_path
+
+        except FileNotFoundError:
+            # Path doesn't exist, we can use it
+            return path
+        except Exception:
+            # Re-raise unexpected errors
+            error(f"An unexpected error occurred while validating the path: {path}")
+
+
+def download_object(file: str, path: str, output_dir: str, output_file: str, profile: str | None = None) -> str:
+    """
+    Downloads an object from the internal bucket and saves it to the specified
+    output directory.
+
+    Parameters
+    ----------
+    file : str
+        The name of the file to download.
+    path : str
+        The directory in the bucket where the file is located.
+    output_dir : str
+        The local directory where the file will be saved.
+    output_file : str
+        The name of the output file.
+    profile : str | None
+        The profile name to use. If None, the default profile is used.
+
+    Returns
+    -------
+    str
+        The path to the downloaded file.
+    """
+
+    response = download_file(directory=path, file=file, profile=profile)
+    file_name = os.path.join(output_dir, output_file)
+
+    with open(file_name, "wb") as f:
+        f.write(response.content)
+
+    return file_name

nextmv/cli/community/list.py

@@ -2,18 +2,18 @@
 This module defines the community list command for the Nextmv CLI.
 """
 
-from typing import Annotated
+from typing import Annotated, Any
 
+import requests
 import rich
 import typer
+import yaml
 from rich.console import Console
 from rich.table import Table
 
 from nextmv.cli.configuration.config import build_client
 from nextmv.cli.message import error
 from nextmv.cli.options import ProfileOption
-from nextmv.cloud.client import Client
-from nextmv.cloud.community import CommunityApp, list_community_apps
 
 # Set up subcommand application.
 app = typer.Typer()
@@ -37,98 +37,121 @@ def list(
     """
     List the available community apps
 
-    Use the --app flag to list that app's versions. Use the --flat flag to
-    flatten the list of names/versions. If you want to clone a community app
-    locally, use the [code]nextmv community clone[/code] command.
+    Use the [code]--app[/code] flag to list that app's versions. Use the
+    [code]--flat[/code] flag to flatten the list of names/versions. If you
+    want to clone a community app locally, use the [code]nextmv community clone[/code] command.
 
     [bold][underline]Examples[/underline][/bold]
 
     - List the available community apps.
-        $ [dim]nextmv community list[/dim]
+        $ [green]nextmv community list[/green]
 
     - List the available versions of the [magenta]go-nextroute[/magenta] community app.
-        $ [dim]nextmv community list --app go-nextroute[/dim]
+        $ [green]nextmv community list --app go-nextroute[/green]
 
     - List the names of the available community apps as a flat list.
-        $ [dim]nextmv community list --flat[/dim]
+        $ [green]nextmv community list --flat[/green]
 
     - List the available versions of the [magenta]go-nextroute[/magenta] community app as a flat list.
-        $ [dim]nextmv community list --app go-nextroute --flat[/dim]
+        $ [green]nextmv community list --app go-nextroute --flat[/green]
 
     - List the available community apps using a profile named [magenta]hare[/magenta].
-        $ [dim]nextmv community list --profile hare[/dim]
+        $ [green]nextmv community list --profile hare[/green]
     """
 
     if app is not None and app == "":
-        error("The --app flag cannot be an empty string.")
+        error("The [code]--app[/code] flag cannot be an empty string.")
 
-    client = build_client(profile)
+    manifest = download_manifest(profile=profile)
     if flat and app is None:
-        _apps_list(client)
+        apps_list(manifest)
         raise typer.Exit()
     elif not flat and app is None:
-        _apps_table(client)
+        apps_table(manifest)
         raise typer.Exit()
     elif flat and app is not None and app != "":
-        _versions_list(client, app)
+        versions_list(manifest, app)
         raise typer.Exit()
     elif not flat and app is not None and app != "":
-        _versions_table(client, app)
+        versions_table(manifest, app)
         raise typer.Exit()
 
 
-def _apps_table(client: Client) -> None:
+def download_manifest(profile: str | None = None) -> dict:
     """
-    This function prints a table of community apps.
+    Downloads and returns the community apps manifest.
 
     Parameters
     ----------
-    client : Client
-        The Nextmv Cloud client to use for the request.
+    profile : str | None
+        The profile name to use. If None, the default profile is used.
+
+    Returns
+    -------
+    dict
+        The community apps manifest as a dictionary.
+
+    Raises
+    requests.HTTPError
+        If the response status code is not 2xx.
+    """
+
+    response = download_file(directory="community-apps", file="manifest.yml", profile=profile)
+    manifest = yaml.safe_load(response.text)
+
+    return manifest
+
+
+def apps_table(manifest: dict[str, Any]) -> None:
+    """
+    This function prints a table of community apps from the manifest.
+
+    Parameters
+    ----------
+    manifest : dict[str, Any]
+        The community apps manifest.
     """
 
-    apps = list_community_apps(client)
     table = Table("Name", "Type", "Latest", "Description", border_style="cyan", header_style="cyan")
-    for app in apps:
+    for app in manifest.get("apps", []):
         table.add_row(
-            app.name,
-            app.app_type,
-            app.latest_app_version if app.latest_app_version is not None else "",
-            app.description,
+            app.get("name", ""),
+            app.get("type", ""),
+            app.get("latest_app_version", ""),
+            app.get("description", ""),
         )
 
     console.print(table)
 
 
-def _apps_list(client: Client) -> None:
+def apps_list(manifest: dict[str, Any]) -> None:
     """
-    This function prints a flat list of community app names.
+    This function prints a flat list of community app names from the manifest.
 
     Parameters
     ----------
-    client : Client
-        The Nextmv Cloud client to use for the request.
+    manifest : dict[str, Any]
+        The community apps manifest.
     """
 
-    apps = list_community_apps(client)
-    names = [app.name for app in apps]
+    names = [app.get("name", "") for app in manifest.get("apps", [])]
     print("\n".join(names))
 
 
-def _versions_table(client: Client, app: str) -> None:
+def versions_table(manifest: dict[str, Any], app: str) -> None:
     """
     This function prints a table of versions for a specific community app.
 
     Parameters
     ----------
-    client : Client
-        The Nextmv Cloud client to use for the request.
+    manifest : dict[str, Any]
+        The community apps manifest.
     app : str
         The name of the community app.
     """
 
-    comm_app = _find_app(client, app)
-    latest_version = comm_app.latest_app_version if comm_app.latest_app_version is not None else ""
+    app_obj = find_app(manifest, app)
+    latest_version = app_obj.get("latest_app_version", "")
 
     # Add the latest version with indicator
     table = Table("Version", "Latest?", border_style="cyan", header_style="cyan")
@@ -136,7 +159,7 @@ def _versions_table(client: Client, app: str) -> None:
     table.add_row("", "")  # Empty row to separate latest from others.
 
     # Add all other versions (excluding the latest)
-    versions = comm_app.app_versions if comm_app.app_versions is not None else []
+    versions = app_obj.get("app_versions", [])
     for version in versions:
         if version != latest_version:
             table.add_row(version, "")
@@ -144,57 +167,99 @@ def _versions_table(client: Client, app: str) -> None:
     console.print(table)
 
 
-def _versions_list(client: Client, app: str) -> None:
+def versions_list(manifest: dict[str, Any], app: str) -> None:
     """
     This function prints a flat list of versions for a specific community app.
 
     Parameters
     ----------
-    client : Client
-        The Nextmv Cloud client to use for the request.
+    manifest : dict[str, Any]
+        The community apps manifest.
     app : str
         The name of the community app.
     """
 
-    comm_app = _find_app(client, app)
-    versions = comm_app.app_versions if comm_app.app_versions is not None else []
+    app_obj = find_app(manifest, app)
+    versions = app_obj.get("app_versions", [])
 
     versions_output = ""
     for version in versions:
         versions_output += f"{version}\n"
 
-    print(versions_output.rstrip("\n"))
+    print("\n".join(app_obj.get("app_versions", [])))
+
+
+def download_file(
+    directory: str,
+    file: str,
+    profile: str | None = None,
+) -> requests.Response:
+    """
+    Gets a file from an internal bucket and return it.
 
+    Parameters
+    ----------
+    directory : str
+        The directory in the bucket where the file is located.
+    file : str
+        The name of the file to download.
+    profile : str | None
+        The profile name to use. If None, the default profile is used.
 
-def _find_app(client: Client, app: str) -> CommunityApp:
+    Returns
+    -------
+    requests.Response
+        The response object containing the file data.
+
+    Raises
+    requests.HTTPError
+        If the response status code is not 2xx.
+    """
+
+    client = build_client(profile)
+
+    # Request the download URL for the file.
+    response = client.request(
+        method="GET",
+        endpoint="v0/internal/tools",
+        headers=client.headers | {"request-source": "cli"},  # Pass `client.headers` to preserve auth.
+        query_params={"file": f"{directory}/{file}"},
+    )
+
+    # Use the URL obtained to download the file.
+    body = response.json()
+    download_response = client.request(
+        method="GET",
+        endpoint=body.get("url"),
+        headers={"Content-Type": "application/json"},
+    )
+
+    return download_response
+
+
+def find_app(manifest: dict[str, Any], app: str) -> dict[str, Any] | None:
     """
     Finds and returns a community app from the manifest by its name.
 
     Parameters
     ----------
-    client : Client
-        The Nextmv Cloud client to use for the request.
+    manifest : dict[str, Any]
+        The community apps manifest.
     app : str
         The name of the community app to find.
 
     Returns
     -------
-    CommunityApp
-        The community app if found.
-
-    Raises
-    ------
-    ValueError
-        If the community app is not found.
+    dict[str, Any] | None
+        The community app dictionary if found, otherwise None.
     """
 
-    comm_apps = list_community_apps(client)
-    for comm_app in comm_apps:
-        if comm_app.name == app:
-            return comm_app
+    for manifest_app in manifest.get("apps", []):
+        if manifest_app.get("name", "") == app:
+            return manifest_app
 
     # We don't use error() here to allow printing something before exiting.
     rich.print(f"[red]Error:[/red] Community app [magenta]{app}[/magenta] was not found. Here are the available apps:")
-    _apps_table(client)
+    apps_table(manifest)
 
     raise typer.Exit(code=1)

nextmv/cli/configuration/config.py

@@ -7,8 +7,7 @@ from typing import Any
 
 import yaml
 
-from nextmv.cli.confirm import get_confirmation
-from nextmv.cli.message import error, success, warning
+from nextmv.cli.message import error
 from nextmv.cloud.account import Account
 from nextmv.cloud.application import Application
 from nextmv.cloud.client import Client
@@ -60,18 +59,6 @@ def save_config(config: dict[str, Any]) -> None:
         yaml.safe_dump(config, file)
 
 
-def non_profile_keys() -> set[str]:
-    """
-    Returns the set of keys that are not profile names in the configuration.
-
-    Returns
-    -------
-    set[str]
-        The set of non-profile keys.
-    """
-    return {API_KEY_KEY, ENDPOINT_KEY}
-
-
 def build_client(profile: str | None = None) -> Client:
     """
     Builds a `cloud.Client` using the API key and endpoint for the given
@@ -104,35 +91,23 @@ def build_client(profile: str | None = None) -> Client:
 
     if profile is not None:
         if profile not in config:
-            error(
-                f"Profile [magenta]{profile}[/magenta] does not exist. "
-                "Create it using [code]nextmv configuration create[/code] with the --profile option."
-            )
+            error(f"Profile [magenta]{profile}[/magenta] does not exist.")
 
         api_key = config[profile].get(API_KEY_KEY)
         if api_key is None or api_key == "":
-            error(
-                f"API key for profile [magenta]{profile}[/magenta] is not set or is empty. "
-                "Set it using [code]nextmv configuration create[/code] with the --profile and --api-key options."
-            )
+            error(f"API key for profile [magenta]{profile}[/magenta] is not set or is empty.")
 
         endpoint = config[profile].get(ENDPOINT_KEY)
         if endpoint is None or endpoint == "":
-            error(
-                f"Endpoint for profile [magenta]{profile}[/magenta] is not set or is empty. "
-                "Please run [code]nextmv configuration create[/code]."
-            )
+            error(f"Endpoint for profile [magenta]{profile}[/magenta] is not set or is empty.")
     else:
         api_key = config.get(API_KEY_KEY)
         if api_key is None or api_key == "":
-            error(
-                "Default API key is not set or is empty. "
-                "Please run [code]nextmv configuration create[/code] with the --api-key option."
-            )
+            error("Default API key is not set or is empty.")
 
         endpoint = config.get(ENDPOINT_KEY)
         if endpoint is None or endpoint == "":
-            error("Default endpoint is not set or is empty. Please run [code]nextmv configuration create[/code].")
+            error("Default endpoint is not set or is empty.")
 
     return Client(api_key=api_key, url=f"https://{endpoint}")
 
@@ -162,21 +137,13 @@ def build_app(app_id: str, profile: str | None = None) -> Application:
     """
     client = build_client(profile)
     exists = Application.exists(client=client, id=app_id)
-    if exists:
-        return Application(client=client, id=app_id)
-
-    warning(f"Application with ID [magenta]{app_id}[/magenta] does not exist.")
-    should_create = get_confirmation(f"Do you want to create a new application with ID [magenta]{app_id}[/magenta]?")
-    if not should_create:
+    if not exists:
         error(
-            f"Application with ID [magenta]{app_id}[/magenta] was not created and does not exist. "
-            "Use [code]nextmv cloud app create[/code] to create a new app."
+            f"Application with ID [magenta]{app_id}[/magenta] does not exist. "
+            "Use [code]nextmv cloud app create[/code] to create a new application."
         )
 
-    app = Application.new(client=client, id=app_id, name=app_id)
-    success(f"Application with ID and name [magenta]{app_id}[/magenta] created successfully.")
-
-    return app
+    return Application(client=client, id=app_id)
 
 
 def build_account(account_id: str | None = None, profile: str | None = None) -> Account: