outerbounds 0.3.178__py3-none-any.whl → 0.3.179rc1__py3-none-any.whl

outerbounds/apps/app_cli.py

@@ -0,0 +1,723 @@
+import json
+import os
+import sys
+from functools import wraps
+from typing import Dict, List, Any, Optional, Union
+
+# IF this CLI is supposed to be reusable across Metaflow Too
+# Then we need to ensure that the click IMPORT happens from metaflow
+# so that any object class comparisons end up working as expected.
+# since Metaflow lazy loads Click Modules, we need to ensure that the
+# module's click Groups correlate to the same module otherwise Metaflow
+# will not accept the cli as valid.
+# But the BIGGEST Problem of adding a `metaflow._vendor` import is that
+# It will run the remote-config check and that can raise a really dirty exception
+# That will break the CLI.
+# So we need to find a way to import click without having it try to check for remote-config
+# or load the config from the environment.
+from metaflow._vendor import click
+from outerbounds._vendor import yaml
+from outerbounds.utils import metaflowconfig
+from .app_config import (
+    AppConfig,
+    AppConfigError,
+    CODE_PACKAGE_PREFIX,
+    CAPSULE_DEBUG,
+    AuthType,
+)
+from .cli_to_config import build_config_from_options
+from .utils import CommaSeparatedListType, KVPairType, KVDictType
+from . import experimental
+from .validations import deploy_validations
+from .code_package import CodePackager
+from .capsule import CapsuleDeployer, list_and_filter_capsules, CapsuleApi
+import shlex
+import time
+import uuid
+from datetime import datetime
+
+LOGGER_TIMESTAMP = "magenta"
+LOGGER_COLOR = "green"
+LOGGER_BAD_COLOR = "red"
+
+NativeList = list
+
+
+def _logger(
+    body="", system_msg=False, head="", bad=False, timestamp=True, nl=True, color=None
+):
+    if timestamp:
+        if timestamp is True:
+            dt = datetime.now()
+        else:
+            dt = timestamp
+        tstamp = dt.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+        click.secho(tstamp + " ", fg=LOGGER_TIMESTAMP, nl=False)
+    if head:
+        click.secho(head, fg=LOGGER_COLOR, nl=False)
+    click.secho(
+        body,
+        bold=system_msg,
+        fg=LOGGER_BAD_COLOR if bad else color if color is not None else None,
+        nl=nl,
+    )
+
+
+class CliState(object):
+    pass
+
+
+def _pre_create_debug(app_config: AppConfig, capsule: CapsuleDeployer, state_dir: str):
+    if CAPSULE_DEBUG:
+        os.makedirs(state_dir, exist_ok=True)
+        debug_path = os.path.join(state_dir, f"debug_{time.time()}.yaml")
+        with open(
+            debug_path,
+            "w",
+        ) as f:
+            f.write(
+                yaml.dump(
+                    {
+                        "app_state": app_config.dump_state(),
+                        "capsule_input": capsule.create_input(),
+                    },
+                    default_flow_style=False,
+                    indent=2,
+                )
+            )
+
+
+def print_table(data, headers):
+    """Print data in a formatted table."""
+    if not data:
+        return
+
+    # Calculate column widths
+    col_widths = [len(h) for h in headers]
+
+    # Calculate actual widths based on data
+    for row in data:
+        for i, cell in enumerate(row):
+            col_widths[i] = max(col_widths[i], len(str(cell)))
+
+    # Print header
+    header_row = " | ".join(
+        [headers[i].ljust(col_widths[i]) for i in range(len(headers))]
+    )
+    click.secho("-" * len(header_row), fg="yellow")
+    click.secho(header_row, fg="yellow", bold=True)
+    click.secho("-" * len(header_row), fg="yellow")
+
+    # Print data rows
+    for row in data:
+        formatted_row = " | ".join(
+            [str(row[i]).ljust(col_widths[i]) for i in range(len(row))]
+        )
+        click.secho(formatted_row, fg="green", bold=True)
+    click.secho("-" * len(header_row), fg="yellow")
+
+
+@click.group()
+def cli():
+    """Outerbounds CLI tool."""
+    pass
+
+
+@cli.group(
+    help="Commands related to Deploying/Running/Managing Apps on Outerbounds Platform."
+)
+@click.pass_context
+def app(ctx):
+    """App-related commands."""
+    metaflow_set_context = getattr(ctx, "obj", None)
+    ctx.obj = CliState()
+    ctx.obj.trace_id = str(uuid.uuid4())
+    ctx.obj.app_state_dir = os.path.join(os.curdir, ".ob_apps")
+    profile = os.environ.get("METAFLOW_PROFILE", "")
+    config_dir = os.path.expanduser(
+        os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
+    )
+    api_url = metaflowconfig.get_sanitized_url_from_config(
+        config_dir, profile, "OBP_API_SERVER"
+    )
+    ctx.obj.api_url = api_url
+    if os.environ.get("OB_CURRENT_PERIMETER") or os.environ.get("OBP_PERIMETER"):
+        ctx.obj.perimeter = os.environ.get("OB_CURRENT_PERIMETER") or os.environ.get(
+            "OBP_PERIMETER"
+        )
+    else:
+        ob_config_file_path = metaflowconfig.get_ob_config_file_path(
+            config_dir, profile
+        )
+        if os.path.exists(ob_config_file_path):
+            with open(ob_config_file_path, "r") as f:
+                ob_config = json.load(f)
+            ctx.obj.perimeter = ob_config.get("OB_CURRENT_PERIMETER")
+
+    os.makedirs(ctx.obj.app_state_dir, exist_ok=True)
+
+
+def parse_commands(app_config: AppConfig, cli_command_input):
+    # There can be two modes:
+    # 1. User passes command via `--` in the CLI
+    # 2. User passes the `commands` key in the config.
+    base_commands = []
+    if len(cli_command_input) > 0:
+        # TODO: we can be a little more fancy here by allowing the user to just call
+        #       `outerbounds app deploy -- foo.py` and figure out if we need to stuff python
+        #       in front of the command or not. But for sake of dumb simplicity, we can just
+        #       assume what ever the user called on local needs to be called remotely, we can
+        #       just ask them to add the outerbounds command in front of it.
+        #       So the dev ex would be :
+        #       `python foo.py` -> `outerbounds app deploy -- python foo.py`
+        if type(cli_command_input) == str:
+            base_commands.append(cli_command_input)
+        else:
+            base_commands.append(shlex.join(cli_command_input))
+    elif app_config.get("commands", None) is not None:
+        base_commands.extend(app_config.get("commands"))
+    return base_commands
+
+
+def common_deploy_options(func):
+    @click.option(
+        "--name",
+        type=str,
+        help="The name of the app to deploy.",
+    )
+    @click.option("--port", type=int, help="Port where the app is hosted.")
+    @click.option(
+        "--tag",
+        "tags",
+        multiple=True,
+        type=KVPairType,
+        help="The tags of the app to deploy. Format KEY=VALUE. Example --tag foo=bar --tag x=y",
+        default=None,
+    )
+    @click.option(
+        "--image",
+        type=str,
+        help="The Docker image to deploy with the App",
+        default=None,
+    )
+    @click.option(
+        "--cpu",
+        type=str,
+        help="CPU resource request and limit",
+        default=None,
+    )
+    @click.option(
+        "--memory",
+        type=str,
+        help="Memory resource request and limit",
+        default=None,
+    )
+    @click.option(
+        "--gpu",
+        type=str,
+        help="GPU resource request and limit",
+        default=None,
+    )
+    @click.option(
+        "--disk",
+        type=str,
+        help="Storage resource request and limit",
+        default=None,
+    )
+    @click.option(
+        "--health-check-enabled",
+        type=bool,
+        help="Enable health checks",
+        default=None,
+    )
+    @click.option(
+        "--health-check-path",
+        type=str,
+        help="Health check path",
+        default=None,
+    )
+    @click.option(
+        "--health-check-initial-delay",
+        type=int,
+        help="Initial delay seconds for health check",
+        default=None,
+    )
+    @click.option(
+        "--health-check-period",
+        type=int,
+        help="Period seconds for health check",
+        default=None,
+    )
+    @click.option(
+        "--compute-pools",
+        type=CommaSeparatedListType,
+        help="The compute pools to deploy the app to. Example: --compute-pools default,large",
+        default=None,
+    )
+    @click.option(
+        "--auth-type",
+        type=click.Choice(AuthType.enums()),
+        help="The type of authentication to use for the app.",
+        default=None,
+    )
+    @click.option(
+        "--public-access/--private-access",
+        "auth_public",
+        type=bool,
+        help="Whether the app is public or not.",
+        default=None,
+    )
+    @click.option(
+        "--no-deps",
+        is_flag=True,
+        help="Do not any dependencies. Directly used the image provided",
+        default=False,
+    )
+    @click.option(
+        "--min-replicas",
+        type=int,
+        help="Minimum number of replicas to deploy",
+        default=None,
+    )
+    @click.option(
+        "--max-replicas",
+        type=int,
+        help="Maximum number of replicas to deploy",
+        default=None,
+    )
+    @click.option(
+        "--description",
+        type=str,
+        help="The description of the app to deploy.",
+        default=None,
+    )
+    @click.option(
+        "--app-type",
+        type=str,
+        help="The type of app to deploy.",
+        default=None,
+    )
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def common_run_options(func):
+    """Common options for running and deploying apps."""
+
+    @click.option(
+        "--config-file",
+        type=str,
+        help="The config file to use for the App (YAML or JSON)",
+        default=None,
+    )
+    @click.option(
+        "--secret",
+        "secrets",
+        multiple=True,
+        type=str,
+        help="Secrets to deploy with the App",
+        default=None,
+    )
+    @click.option(
+        "--env",
+        "envs",
+        multiple=True,
+        type=KVPairType,
+        help="Environment variables to deploy with the App. Use format KEY=VALUE",
+        default=None,
+    )
+    @click.option(
+        "--package-src-path",
+        type=str,
+        help="The path to the source code to deploy with the App.",
+        default=None,
+    )
+    @click.option(
+        "--package-suffixes",
+        type=CommaSeparatedListType,
+        help="The suffixes of the source code to deploy with the App.",
+        default=None,
+    )
+    @click.option(
+        "--dep-from-requirements",
+        type=str,
+        help="Path to requirements.txt file for dependencies",
+        default=None,
+    )
+    @click.option(
+        "--dep-from-pyproject",
+        type=str,
+        help="Path to pyproject.toml file for dependencies",
+        default=None,
+    )
+    # TODO: [FIX ME]: Get better CLI abstraction for pypi/conda dependencies
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def _package_necessary_things(app_config: AppConfig, logger):
+    # Packaging has a few things to be thought through:
+    #   1. if `entrypoint_path` exists then should we package the directory
+    #      where the entrypoint lives. For example : if the user calls
+    #      `outerbounds app deploy foo/bar.py`  should we package `foo` dir
+    #      or should we package the cwd from which foo/bar.py is being called.
+    #   2. if the src path is used with the config file then how should we view
+    #      that path ?
+    #   3. It becomes interesting when users call the deployment with config files
+    #      where there is a `src_path` and then is the src_path relative to the config file
+    #      or is it relative to where the caller command is sitting. Ideally it should work
+    #      like Kustomizations where its relative to where the yaml file sits for simplicity
+    #      of understanding relationships between config files. Ideally users can pass the src_path
+    #      from the command line and that will aliviate any need to package any other directories for
+    #
+
+    package_dir = app_config.get_state("packaging_directory")
+    if package_dir is None:
+        app_config.set_state("code_package_url", None)
+        app_config.set_state("code_package_key", None)
+        return
+    from metaflow.metaflow_config import DEFAULT_DATASTORE
+
+    package = app_config.get_state("package") or {}
+    suffixes = package.get("suffixes", None)
+
+    packager = CodePackager(
+        datastore_type=DEFAULT_DATASTORE, code_package_prefix=CODE_PACKAGE_PREFIX
+    )
+    package_url, package_key = packager.store(
+        paths_to_include=[package_dir], file_suffixes=suffixes
+    )
+    app_config.set_state("code_package_url", package_url)
+    app_config.set_state("code_package_key", package_key)
+    logger("💾 Code Package Saved to : %s" % app_config.get_state("code_package_url"))
+
+
+@app.command(help="Deploy an app to the Outerbounds Platform.")
+@common_deploy_options
+@common_run_options
+@experimental.wrapping_cli_options
+@click.pass_context
+@click.argument("command", nargs=-1, type=click.UNPROCESSED, required=False)
+def deploy(ctx, command, **options):
+    """Deploy an app to the Outerbounds Platform."""
+    from functools import partial
+
+    if not ctx.obj.perimeter:
+        raise AppConfigError("OB_CURRENT_PERIMETER is not set")
+
+    logger = partial(_logger, timestamp=True)
+    try:
+        # Create configuration
+        if options["config_file"]:
+            # Load from file
+            app_config = AppConfig.from_file(options["config_file"])
+
+            # Update with any CLI options using the unified method
+            app_config.update_from_cli_options(options)
+        else:
+            # Create from CLI options
+            config_dict = build_config_from_options(options)
+            app_config = AppConfig(config_dict)
+
+        # Validate the configuration
+        app_config.validate()
+        logger(
+            f"🚀 Deploying {app_config.get('name')} to the Outerbounds platform...",
+            color=LOGGER_COLOR,
+            system_msg=True,
+        )
+
+        packaging_directory = None
+        package_src_path = app_config.get("package", {}).get("src_path", None)
+        if package_src_path:
+            if os.path.isfile(package_src_path):
+                raise AppConfigError("src_path must be a directory, not a file")
+            elif os.path.isdir(package_src_path):
+                packaging_directory = os.path.abspath(package_src_path)
+            else:
+                raise AppConfigError(f"src_path '{package_src_path}' does not exist")
+        else:
+            # If src_path is None then we assume then we can assume for the moment
+            # that we can package the current working directory.
+            packaging_directory = os.getcwd()
+
+        app_config.set_state("packaging_directory", packaging_directory)
+        logger(
+            "📦 Packaging Directory : %s" % app_config.get_state("packaging_directory"),
+        )
+        # TODO: Construct the command needed to run the app
+        #       If we are constructing the directory with the src_path
+        #       then we need to add the command from the option otherwise
+        #       we use the command from the entrypoint path and whatever follows `--`
+        #       is the command to run.
+
+        # Set some defaults for the deploy command
+        app_config.set_deploy_defaults(packaging_directory)
+
+        if options.get("no_deps") == True:
+            # Setting this in the state will make it skip the fast-bakery step
+            # of building an image.
+            app_config.set_state("skip_dependencies", True)
+        else:
+            # Check if the user has set the dependencies in the app config
+            dependencies = app_config.get("dependencies", {})
+            if len(dependencies) == 0:
+                # The user has not set any dependencies, so we can sniff the packaging directory
+                # for a dependencies file.
+                requirements_file = os.path.join(
+                    packaging_directory, "requirements.txt"
+                )
+                pyproject_toml = os.path.join(packaging_directory, "pyproject.toml")
+                if os.path.exists(pyproject_toml):
+                    app_config.set_state(
+                        "dependencies", {"from_pyproject_toml": pyproject_toml}
+                    )
+                    logger(
+                        "📦 Using dependencies from pyproject.toml: %s" % pyproject_toml
+                    )
+                elif os.path.exists(requirements_file):
+                    app_config.set_state(
+                        "dependencies", {"from_requirements_file": requirements_file}
+                    )
+                    logger(
+                        "📦 Using dependencies from requirements.txt: %s"
+                        % requirements_file
+                    )
+
+        # Print the configuration
+        # 1. validate that the secrets for the app exist
+        # 2. TODO: validate that the compute pool specified in the app exists.
+        # 3. Building Docker image if necessary (based on parameters)
+        #   - We will bake images with fastbakery and pass it to the deploy command
+        # TODO: validation logic can be wrapped in try catch so that we can provide
+        #       better error messages.
+        cache_dir = os.path.join(
+            ctx.obj.app_state_dir, app_config.get("name", "default")
+        )
+        deploy_validations(
+            app_config,
+            cache_dir=cache_dir,
+            logger=logger,
+        )
+
+        base_commands = parse_commands(app_config, command)
+
+        app_config.set_state("commands", base_commands)
+
+        # TODO: Handle the case where packaging_directory is None
+        # This would involve:
+        # 1. Packaging the code:
+        #   - We need to package the code and throw the tarball to some object store
+        _package_necessary_things(app_config, logger)
+
+        app_config.set_state("perimeter", ctx.obj.perimeter)
+
+        # 2. Convert to the IR that the backend accepts
+        capsule = CapsuleDeployer(app_config, ctx.obj.api_url, debug_dir=cache_dir)
+
+        _pre_create_debug(app_config, capsule, cache_dir)
+        # 3. Throw the job into the platform and report deployment status
+        logger(
+            f"🚀 Deploying {capsule.capsule_type.lower()} to the platform...",
+            color=LOGGER_COLOR,
+            system_msg=True,
+        )
+        capsule.create()
+        capsule.wait_for_terminal_state(logger=logger)
+        logger(
+            f"💊 {capsule.capsule_type} {app_config.config['name']} ({capsule.identifier}) deployed successfully! You can access it at {capsule.status.out_of_cluster_url}",
+            color=LOGGER_COLOR,
+            system_msg=True,
+        )
+
+    except AppConfigError as e:
+        click.echo(f"Error in app configuration: {e}", err=True)
+        raise e
+    except Exception as e:
+        click.echo(f"Error deploying app: {e}", err=True)
+        raise e
+
+
+def _parse_capsule_table(filtered_capsules):
+    headers = ["Name", "ID", "Ready", "App Type", "Port", "Tags", "URL"]
+    table_data = []
+
+    for capsule in filtered_capsules:
+        spec = capsule.get("spec", {})
+        status = capsule.get("status", {}) or {}
+        cap_id = capsule.get("id")
+        display_name = spec.get("displayName", "")
+        ready = str(status.get("readyToServeTraffic", False))
+        auth_type = spec.get("authConfig", {}).get("authType", "")
+        port = str(spec.get("port", ""))
+        tags_str = ", ".join(
+            [f"{tag['key']}={tag['value']}" for tag in spec.get("tags", [])]
+        )
+        access_info = status.get("accessInfo", {}) or {}
+        url = access_info.get("outOfClusterURL", None)
+
+        table_data.append(
+            [
+                display_name,
+                cap_id,
+                ready,
+                auth_type,
+                port,
+                tags_str,
+                f"https://{url}" if url else "URL not available",
+            ]
+        )
+    return headers, table_data
+
+
+@app.command(help="List apps in the Outerbounds Platform.")
+@click.option("--project", type=str, help="Filter apps by project")
+@click.option("--branch", type=str, help="Filter apps by branch")
+@click.option("--name", type=str, help="Filter apps by name")
+@click.option(
+    "--tag",
+    "tags",
+    type=KVDictType,
+    help="Filter apps by tag. Format KEY=VALUE. Example --tag foo=bar --tag x=y. If multiple tags are provided, the app must match all of them.",
+    multiple=True,
+)
+@click.option(
+    "--format",
+    type=click.Choice(["json", "text"]),
+    help="Format the output",
+    default="text",
+)
+@click.option(
+    "--auth-type", type=click.Choice(AuthType.enums()), help="Filter apps by Auth type"
+)
+@click.pass_context
+def list(ctx, project, branch, name, tags, format, auth_type):
+    """List apps in the Outerbounds Platform."""
+
+    filtered_capsules = list_and_filter_capsules(
+        ctx.obj.api_url, ctx.obj.perimeter, project, branch, name, tags, auth_type, None
+    )
+    if format == "json":
+        click.echo(json.dumps(filtered_capsules, indent=4))
+    else:
+        headers, table_data = _parse_capsule_table(filtered_capsules)
+        print_table(table_data, headers)
+
+
+@app.command(help="Delete an app/apps from the Outerbounds Platform.")
+@click.option("--name", type=str, help="Filter app to delete by name")
+@click.option("--id", "cap_id", type=str, help="Filter app to delete by id")
+@click.option("--project", type=str, help="Filter apps to delete by project")
+@click.option("--branch", type=str, help="Filter apps to delete by branch")
+@click.option(
+    "--tag",
+    "tags",
+    multiple=True,
+    type=KVDictType,
+    help="Filter apps to delete by tag. Format KEY=VALUE. Example --tag foo=bar --tag x=y. If multiple tags are provided, the app must match all of them.",
+)
+@click.pass_context
+def delete(ctx, name, cap_id, project, branch, tags):
+
+    """Delete an app/apps from the Outerbounds Platform."""
+    # Atleast one of the args need to be provided
+    if not any(
+        [
+            name is not None,
+            cap_id is not None,
+            project is not None,
+            branch is not None,
+            len(tags) != 0,
+        ]
+    ):
+        raise AppConfigError(
+            "Atleast one of the options need to be provided. You can use --name, --id, --project, --branch, --tag"
+        )
+
+    filtered_capsules = list_and_filter_capsules(
+        ctx.obj.api_url, ctx.obj.perimeter, project, branch, name, tags, None, cap_id
+    )
+
+    headers, table_data = _parse_capsule_table(filtered_capsules)
+    click.secho("The following apps will be deleted:", fg="red", bold=True)
+    print_table(table_data, headers)
+
+    # Confirm the deletion
+    confirm = click.prompt(
+        click.style(
+            "💊 Are you sure you want to delete these apps?", fg="red", bold=True
+        ),
+        default="no",
+        type=click.Choice(["yes", "no"]),
+    )
+    if confirm == "no":
+        exit(1)
+
+    def item_show_func(x):
+        if not x:
+            return None
+        name = x.get("spec", {}).get("displayName", "")
+        id = x.get("id", "")
+        return click.style("💊 deleting %s [%s]" % (name, id), fg="red", bold=True)
+
+    with click.progressbar(
+        filtered_capsules,
+        label=click.style("💊 Deleting apps...", fg="red", bold=True),
+        fill_char=click.style("█", fg="red", bold=True),
+        empty_char=click.style("░", fg="red", bold=True),
+        item_show_func=item_show_func,
+    ) as bar:
+        capsule_api = CapsuleApi(ctx.obj.api_url, ctx.obj.perimeter)
+        for capsule in bar:
+            capsule_api.delete(capsule.get("id"))
+
+
+@app.command(help="Run an app locally (for testing).")
+@common_run_options
+@click.pass_context
+def run(ctx, **options):
+    """Run an app locally for testing."""
+    try:
+        # Create configuration
+        if options["config_file"]:
+            # Load from file
+            app_config = AppConfig.from_file(options["config_file"])
+
+            # Update with any CLI options using the unified method
+            app_config.update_from_cli_options(options)
+        else:
+            # Create from CLI options
+            config_dict = build_config_from_options(options)
+            app_config = AppConfig(config_dict)
+
+        # Validate the configuration
+        app_config.validate()
+
+        # Print the configuration
+        click.echo("Running App with configuration:")
+        click.echo(app_config.to_yaml())
+
+        # TODO: Implement local run logic
+        # This would involve:
+        # 1. Setting up the environment
+        # 2. Running the app locally
+        # 3. Reporting status
+
+        click.echo(f"App '{app_config.config['name']}' running locally!")
+
+    except AppConfigError as e:
+        click.echo(f"Error in app configuration: {e}", err=True)
+        ctx.exit(1)
+    except Exception as e:
+        click.echo(f"Error running app: {e}", err=True)
+        ctx.exit(1)
+
+
+# if __name__ == "__main__":
+#     cli()