truefoundry 0.2.10__py3-none-any.whl → 0.3.0rc2__py3-none-any.whl

truefoundry/deploy/cli/commands/get_command.py

@@ -0,0 +1,216 @@
+import contextlib
+import sys
+from enum import Enum
+
+import rich_click as click
+import yaml
+from rich.pretty import pprint
+
+from truefoundry.deploy.cli.config import CliConfig
+from truefoundry.deploy.cli.console import console
+from truefoundry.deploy.cli.const import COMMAND_CLS, GROUP_CLS
+from truefoundry.deploy.cli.display_util import print_entity_obj, print_json
+from truefoundry.deploy.cli.util import handle_exception_wrapper
+from truefoundry.deploy.lib.dao import application as application_lib
+from truefoundry.deploy.lib.dao import version as version_lib
+from truefoundry.deploy.lib.dao import workspace as workspace_lib
+
+# TODO (chiragjn): --json should disable all non json console prints
+
+
+@click.group(name="get", cls=GROUP_CLS)
+def get_command():
+    # TODO (chiragjn): Figure out a way to update supported resources based on ENABLE_* flags
+    """
+    Get TrueFoundry resources
+
+    \b
+    Supported resources:
+    - Workspace
+    - Application
+    - Application Version
+    """
+    pass
+
+
+@click.command(name="workspace", cls=COMMAND_CLS, help="Get Workspace details")
+@click.option(
+    "-w",
+    "--workspace-fqn",
+    "--workspace_fqn",
+    type=click.STRING,
+    default=None,
+    help="FQN of the Workspace",
+    required=True,
+)
+@handle_exception_wrapper
+def get_workspace(workspace_fqn):
+    workspace = workspace_lib.get_workspace_by_fqn(workspace_fqn=workspace_fqn)
+    if CliConfig.get("json"):
+        print_json(data=workspace.dict())
+    else:
+        print_entity_obj("Workspace", workspace)
+
+
+@click.command(name="application", cls=COMMAND_CLS, help="Get Application details")
+@click.option(
+    "--application-fqn",
+    "--application_fqn",
+    type=click.STRING,
+    default=None,
+    help="FQN of the application",
+    required=True,
+)
+@handle_exception_wrapper
+def get_application(application_fqn):
+    application = application_lib.get_application(application_fqn=application_fqn)
+    if CliConfig.get("json"):
+        print_json(data=application.dict())
+    else:
+        print_entity_obj(
+            "Application",
+            application,
+        )
+
+
+@click.command(
+    name="application-version", cls=COMMAND_CLS, help="Get Application Version details"
+)
+@click.option(
+    "--application-fqn",
+    "--application_fqn",
+    type=click.STRING,
+    default=None,
+    help="FQN of the application",
+    required=True,
+)
+@click.option(
+    "--version",
+    type=click.STRING,
+    default=None,
+    help="Version number of the application deployment",
+    required=True,
+)
+@handle_exception_wrapper
+def get_version(application_fqn, version):
+    version = version_lib.get_version(application_fqn=application_fqn, version=version)
+    if CliConfig.get("json"):
+        print_json(data=version.dict())
+    else:
+        print_entity_obj("Version", version)
+
+
+@click.command(
+    name="spec", cls=COMMAND_CLS, help="Get YAML/Python Spec for an Application Version"
+)
+@click.option(
+    "--application-fqn",
+    "--application_fqn",
+    type=click.STRING,
+    default=None,
+    help="FQN of the application",
+    required=True,
+)
+@click.option(
+    "--version",
+    type=click.STRING,
+    default=None,
+    help="Version number of the application deployment",
+    required=True,
+)
+@click.option(
+    "-o",
+    "--output",
+    type=click.Choice(
+        [
+            "yml",
+            "yaml",
+            "json",
+            "py",
+            "python",
+        ]
+    ),
+    default="yaml",
+    help="Output format for the spec",
+    required=False,
+)
+@handle_exception_wrapper
+def get_spec(application_fqn, version, output):
+    version = version_lib.get_version(application_fqn=application_fqn, version=version)
+    if output in ["yml", "yaml"]:
+        yaml.safe_dump(version.manifest.dict(), sys.stdout, indent=2)
+    elif output in ["json"]:
+        print_json(version.manifest.dict())
+    elif output in ["py", "python"]:
+        from truefoundry.deploy.v2.lib.deployable_patched_models import Application
+
+        manifest = version.manifest.dict()
+        instance = Application.parse_obj(manifest).__root__
+
+        # TODO (chiragjn): Can we somehow just enable `use_enum_values` on all Pydantic classes?
+
+        @contextlib.contextmanager
+        def _monkey_patch_enum_repr():
+            def new_repr(self):
+                # return "%r" % (self._value_)
+                return "%s.%s" % (self.__class__.__name__, self._name_)
+
+            enum_subclasses = [
+                es
+                for es in Enum.__subclasses__()
+                if es.__module__.startswith("truefoundry.")
+            ]
+            original_reprs = []
+            for es in enum_subclasses:
+                original_reprs.append(es)
+                es.__repr__ = new_repr
+
+            yield
+
+            for es, og_repr in zip(enum_subclasses, original_reprs):
+                es.__repr__ = og_repr
+
+        with _monkey_patch_enum_repr():
+            pprint(
+                instance,
+                indent_guides=False,
+                max_length=88,
+                expand_all=True,
+                console=console,
+            )
+
+
+@click.command(name="job-run", cls=COMMAND_CLS, help="Get Job Run")
+@click.option(
+    "--application-fqn",
+    "--application_fqn",
+    type=click.STRING,
+    default=None,
+    help="FQN of the application",
+    required=True,
+)
+@click.option(
+    "--job-run-name",
+    "--job_run_name",
+    type=click.STRING,
+    default=None,
+    help="Run name of the job",
+    required=True,
+)
+@handle_exception_wrapper
+def get_job_run(application_fqn, job_run_name):
+    job_run = application_lib.get_job_run(
+        application_fqn=application_fqn, job_run_name=job_run_name
+    )
+    if CliConfig.get("json"):
+        print_json(data=job_run.dict())
+    else:
+        print_entity_obj("Job Run", job_run)
+
+
+def get_get_command():
+    get_command.add_command(get_workspace)
+    get_command.add_command(get_application)
+    get_command.add_command(get_version)
+    get_command.add_command(get_job_run)
+    return get_command

truefoundry/deploy/cli/commands/list_command.py

@@ -0,0 +1,171 @@
+import rich_click as click
+
+from truefoundry.deploy.cli.config import CliConfig
+from truefoundry.deploy.cli.const import COMMAND_CLS, GROUP_CLS
+from truefoundry.deploy.cli.display_util import print_entity_list, print_json
+from truefoundry.deploy.cli.util import handle_exception_wrapper
+from truefoundry.deploy.io.rich_output_callback import RichOutputCallBack
+from truefoundry.deploy.lib.dao import application as application_lib
+from truefoundry.deploy.lib.dao import version as version_lib
+from truefoundry.deploy.lib.dao import workspace as workspace_lib
+from truefoundry.deploy.lib.messages import (
+    PROMPT_NO_APPLICATIONS,
+    PROMPT_NO_VERSIONS,
+    PROMPT_NO_WORKSPACES,
+)
+
+# TODO (chiragjn): --json should disable all non json console prints
+
+
+@click.group(name="list", cls=GROUP_CLS)
+def list_command():
+    # TODO (chiragjn): Figure out a way to update supported resources based on ENABLE_* flags
+    """
+    List TrueFoundry resources
+
+    \b
+    Supported resources:
+    - Workspace
+    - Application
+    - Application Version
+    """
+
+
+@click.command(name="workspaces", cls=COMMAND_CLS, help="List Workspaces")
+@click.option(
+    "-c",
+    "--cluster-name",
+    "--cluster_name",
+    type=click.STRING,
+    default=None,
+    help="Cluster name",
+)
+@handle_exception_wrapper
+def list_workspaces(cluster_name):
+    workspaces = workspace_lib.list_workspaces(
+        cluster_name=cluster_name,
+    )
+    if not workspaces:
+        output_hook = RichOutputCallBack()
+        output_hook.print_line(PROMPT_NO_WORKSPACES)
+    else:
+        workspaces.sort(key=lambda s: s.createdAt, reverse=True)
+
+    print_entity_list(
+        "Workspaces",
+        workspaces,
+    )
+
+
+@click.command(name="applications", cls=COMMAND_CLS, help="List Applications")
+@click.option(
+    "-w",
+    "--workspace-fqn",
+    "--workspace_fqn",
+    type=click.STRING,
+    default=None,
+    help="FQN of the Workspace",
+)
+@click.option(
+    "--application-type",
+    "--application_type",
+    type=click.Choice(
+        [
+            "service",
+            "job",
+            "model-deployment",
+            "volume",
+            "notebook",
+            "intercept",
+            "helm",
+            "all",
+        ]
+    ),
+    default="all",
+    help="Application Type",
+)
+@handle_exception_wrapper
+def list_applications(workspace_fqn, application_type):
+    applications = application_lib.list_applications(
+        workspace_fqn=workspace_fqn, application_type=application_type
+    )
+    if not applications:
+        output_hook = RichOutputCallBack()
+        output_hook.print_line(PROMPT_NO_APPLICATIONS)
+    else:
+        applications.sort(key=lambda s: s.createdAt, reverse=True)
+
+    print_entity_list(
+        "Applications",
+        applications,
+    )
+
+
+@click.command(
+    name="application-versions", cls=COMMAND_CLS, help="List Application Versions"
+)
+@click.option(
+    "--application-fqn",
+    "--application_fqn",
+    type=click.STRING,
+    default=None,
+    help="FQN of the application",
+    required=True,
+)
+@handle_exception_wrapper
+def list_versions(application_fqn):
+    versions = version_lib.list_versions(
+        application_fqn=application_fqn,
+    )
+    if not versions:
+        output_hook = RichOutputCallBack()
+        output_hook.print_line(PROMPT_NO_VERSIONS)
+    else:
+        versions.sort(key=lambda s: s.createdAt, reverse=True)
+
+    print_entity_list(
+        "Application Versions",
+        versions,
+    )
+
+
+@click.command(name="job-run", cls=COMMAND_CLS, help="List Job Runs")
+@click.option(
+    "--application-fqn",
+    "--application_fqn",
+    type=click.STRING,
+    default=None,
+    help="FQN of the application",
+    required=True,
+)
+@click.option(
+    "--max-results",
+    "--max_results",
+    type=click.STRING,
+    default=None,
+    help="Maximum number of Runs to fetch",
+)
+@click.option(
+    "--offset",
+    type=click.STRING,
+    default=None,
+    help="Number of Runs to skip",
+)
+@handle_exception_wrapper
+def list_job_runs(application_fqn, max_results, offset):
+    job_runs = application_lib.list_job_runs(
+        application_fqn=application_fqn, max_results=max_results, offset=offset
+    )
+    if CliConfig.get("json"):
+        print_json(data=job_runs.dict())
+    else:
+        print_entity_list("Job Runs", job_runs)
+
+
+def get_list_command():
+    list_command.add_command(list_workspaces)
+    list_command.add_command(list_applications)
+    list_command.add_command(list_versions)
+    list_command.add_command(list_job_runs)
+
+    return list_command

truefoundry/deploy/cli/commands/login_command.py

@@ -0,0 +1,33 @@
+import rich_click as click
+
+from truefoundry.deploy.cli.const import COMMAND_CLS
+from truefoundry.deploy.cli.util import (
+    _prompt_if_no_value_and_supported,
+    handle_exception_wrapper,
+)
+from truefoundry.deploy.io.rich_output_callback import RichOutputCallBack
+from truefoundry.deploy.lib.const import HOST_ENV_NAME
+from truefoundry.deploy.lib.session import login
+
+
+@click.command(name="login", cls=COMMAND_CLS)
+@click.option("--relogin", type=click.BOOL, is_flag=True, default=False)
+@click.option("--host", type=click.STRING, required=True, envvar=HOST_ENV_NAME)
+@click.option(
+    "--api-key",
+    "--api_key",
+    type=click.STRING,
+    default=None,
+    **_prompt_if_no_value_and_supported(prompt="API Key", hide_input=True),
+)
+@handle_exception_wrapper
+def login_command(relogin: bool, host: str, api_key: str):
+    """
+    Login to TrueFoundry
+    """
+    callback = RichOutputCallBack()
+    login(api_key=api_key, host=host, relogin=relogin, output_hook=callback)
+
+
+def get_login_command():
+    return login_command

truefoundry/deploy/cli/commands/logout_command.py

@@ -0,0 +1,20 @@
+import rich_click as click
+
+from truefoundry.deploy.cli.const import COMMAND_CLS
+from truefoundry.deploy.cli.util import handle_exception_wrapper
+from truefoundry.deploy.io.rich_output_callback import RichOutputCallBack
+from truefoundry.deploy.lib.session import logout
+
+
+@click.command(name="logout", cls=COMMAND_CLS)
+@handle_exception_wrapper
+def logout_command():
+    """
+    Logout from current TrueFoundry session
+    """
+    callback = RichOutputCallBack()
+    logout(output_hook=callback)
+
+
+def get_logout_command():
+    return logout_command

truefoundry/deploy/cli/commands/logs_command.py

@@ -0,0 +1,134 @@
+from datetime import datetime
+from typing import Optional
+
+import rich_click as click
+from dateutil.tz import tzlocal
+
+from truefoundry.deploy.cli.const import COMMAND_CLS
+from truefoundry.deploy.cli.util import handle_exception_wrapper
+from truefoundry.deploy.io.rich_output_callback import RichOutputCallBack
+from truefoundry.deploy.lib.clients.servicefoundry_client import (
+    ServiceFoundryServiceClient,
+)
+from truefoundry.deploy.lib.logs_utils import get_timestamp_from_timestamp_or_duration
+from truefoundry.deploy.lib.util import get_deployment_fqn_from_application_fqn
+from truefoundry.logger import logger
+
+
+@click.command(name="logs", cls=COMMAND_CLS)
+@click.option(
+    "--application-fqn",
+    type=click.STRING,
+    help="FQN of the application",
+    required=True,
+)
+@click.option(
+    "--job-run-name",
+    "--job_run_name",
+    type=click.STRING,
+    default=None,
+    help="Run name of the job (if application is a job)",
+)
+@click.option(
+    "--version",
+    type=click.INT,
+    help="Version number of the application deployment",
+    default=None,
+)
+@click.option(
+    "--since",
+    type=click.STRING,
+    help="Show logs since timestamp (e.g.2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)",
+    default="2h",
+)
+@click.option(
+    "--until",
+    type=click.STRING,
+    help="Show logs until timestamp (e.g.2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)",
+    default=None,
+)
+@click.option(
+    "-n", "--tail", type=click.INT, help="Number of logs to tail", default=None
+)
+@click.option("-f", "--follow", help="Follow log output", is_flag=True, default=False)
+@handle_exception_wrapper
+def logs_command(
+    application_fqn: str,
+    job_run_name: Optional[str],
+    version: Optional[int],
+    since: str,
+    until: Optional[str],
+    tail: Optional[int],
+    follow: bool,
+) -> None:
+    """
+    Get logs for Application
+    """
+    start_ts = get_timestamp_from_timestamp_or_duration(since)
+    end_ts = (
+        get_timestamp_from_timestamp_or_duration(until)
+        if until
+        else datetime.now().timestamp() * 1000
+    )
+
+    output_hook = RichOutputCallBack()
+    tfs_client = ServiceFoundryServiceClient()
+
+    if version:
+        deployment_fqn = get_deployment_fqn_from_application_fqn(
+            application_fqn=application_fqn, version=version
+        )
+        deployment_fqn_response = tfs_client.get_deployment_info_by_fqn(deployment_fqn)
+        workspace_id, application_id, deployment_id = (
+            deployment_fqn_response.workspaceId,
+            deployment_fqn_response.applicationId,
+            deployment_fqn_response.deploymentId,
+        )
+    else:
+        app_fqn_response = tfs_client.get_application_info_by_fqn(application_fqn)
+        workspace_id, application_id, deployment_id = (
+            app_fqn_response.workspaceId,
+            app_fqn_response.applicationId,
+            None,
+        )
+
+    if until:
+        logger.info(
+            "Fetching logs from %s to %s for application fqn: %s",
+            datetime.fromtimestamp(start_ts / 1000, tzlocal()).isoformat(),
+            datetime.fromtimestamp(end_ts / 1000, tzlocal()).isoformat(),
+            application_fqn,
+        )
+    else:
+        logger.info(
+            "Fetching logs from %s for application fqn: %s",
+            datetime.fromtimestamp(start_ts / 1000, tzlocal()).isoformat(),
+            application_fqn,
+        )
+
+    if until or not follow:
+        tfs_client.fetch_deployment_logs(
+            workspace_id=workspace_id,
+            application_id=application_id,
+            deployment_id=deployment_id,
+            job_run_name=job_run_name,
+            start_ts=start_ts,
+            end_ts=end_ts,
+            limit=tail,
+            callback=output_hook,
+        )
+    else:
+        tfs_client.poll_logs_for_deployment(
+            workspace_id=workspace_id,
+            application_id=application_id,
+            deployment_id=deployment_id,
+            job_run_name=job_run_name,
+            start_ts=start_ts,
+            limit=tail,
+            poll_interval_seconds=5,
+            callback=output_hook,
+        )
+
+
+def get_logs_command():
+    return logs_command

truefoundry/deploy/cli/commands/patch_application_command.py

@@ -0,0 +1,79 @@
+import json
+
+import rich_click as click
+import yaml
+
+from truefoundry.deploy.cli.const import GROUP_CLS
+from truefoundry.deploy.lib.dao import application as application_lib
+
+
+@click.group(
+    name="patch-application",
+    cls=GROUP_CLS,
+    invoke_without_command=True,
+    help="Deploy application with patches to Truefoundry",
+)
+@click.option(
+    "-f",
+    "--patch-file",
+    "--patch_file",
+    type=click.Path(exists=True, dir_okay=False, resolve_path=True),
+    help="Path to yaml patch file",
+    show_default=True,
+)
+@click.option(
+    "-p",
+    "--patch",
+    type=click.STRING,
+    help="Patch in JSON format provided as a string.",
+    show_default=True,
+)
+@click.option(
+    "-a",
+    "--application_fqn",
+    "--application-fqn",
+    type=click.STRING,
+    required=True,
+    help="FQN of the Application to patch and deploy",
+)
+@click.option(
+    "--wait/--no-wait",
+    "--wait/--no_wait",
+    is_flag=True,
+    show_default=True,
+    default=True,
+    help="Wait and tail the deployment progress",
+)
+def patch_application_command(
+    patch_file: str, application_fqn: str, patch: str, wait: bool
+):
+    from truefoundry.deploy.v2.lib.deployable_patched_models import Application
+
+    manifest_patch_obj = None
+    if not patch_file and not patch:
+        raise Exception("You need to either provide --file or --patch.")
+    elif patch and patch_file:
+        raise Exception("You can only provide one of --file and --patch")
+    elif patch:
+        try:
+            manifest_patch_obj = json.loads(patch)
+        except json.decoder.JSONDecodeError as e:
+            raise Exception("Invalid JSON provided as --patch") from e
+    elif patch_file:
+        with open(patch_file, "r") as f:
+            manifest_patch_obj = yaml.safe_load(f)
+
+    if not manifest_patch_obj or not isinstance(manifest_patch_obj, dict):
+        raise Exception("Invalid patch, aborting deployment.")
+
+    tfy_application = application_lib.get_application(application_fqn=application_fqn)
+    patched_application_obj = application_lib.get_patched_application_definition(
+        application=tfy_application, manifest_patch=manifest_patch_obj
+    )
+
+    application = Application.parse_obj(patched_application_obj)
+    application.deploy(workspace_fqn=tfy_application.workspace.fqn, wait=wait)
+
+
+def get_patch_application_command():
+    return patch_application_command