frogml-cli 0.0.1__py3-none-any.whl

frogml_cli/commands/models/deployments/undeploy/_logic/request_undeploy.py

@@ -0,0 +1,249 @@
+from time import sleep
+from typing import Dict, List, Set
+
+from frogml._proto.qwak.audience.v1.audience_pb2 import AudienceRoutesEntry
+from frogml._proto.qwak.deployment.deployment_pb2 import (
+    DeploymentHostingServiceType,
+    EnvironmentDeploymentDetailsMessage,
+    EnvironmentUndeploymentMessage,
+    ModelDeploymentStatus,
+    TrafficConfig,
+)
+from frogml._proto.qwak.ecosystem.v0.ecosystem_pb2 import EnvironmentDetails
+from frogml.core.clients.administration.eco_system.client import EcosystemClient
+from frogml.core.clients.deployment.client import DeploymentManagementClient
+from frogml.core.exceptions import FrogmlException
+from frogml.core.tools.logger.logger import get_frogml_logger
+
+from frogml_cli.commands.models.deployments.deploy._logic.deploy_config import (
+    DeployConfig,
+)
+from frogml_cli.tools.utils import frogml_spinner
+
+NO_DEPLOYED_VARIATIONS_ERROR_MSG = (
+    "There are currently no deployed variations for model {model_id} in {env_name}"
+)
+UNDEPLOY_ERROR_MSG = "Environment {environment_id} failed with status: {status}"
+logger = get_frogml_logger()
+
+FAILED_UNDEPLOYMENT_STATUS = ["FAILED_UNDEPLOYMENT"]
+SUCCESSFUL_UNDEPLOYMENT_STATUS = ["SUCCESSFUL_UNDEPLOYMENT"]
+END_UNDEPLOYMENT_STATUSES = SUCCESSFUL_UNDEPLOYMENT_STATUS + FAILED_UNDEPLOYMENT_STATUS
+TIME_TO_WAIT_FOR_UNDEPLOYMENT_POLLING = 5
+
+
+def get_deployed_variation_name(existing_variations_names: Set[str]) -> str:
+    return list(existing_variations_names)[0]
+
+
+def get_environment_undeploy_message(
+    audiences: List[AudienceRoutesEntry],
+    existing_variations_names: Set[str],
+    fallback_variation: str,
+    model_id: str,
+    model_uuid: str,
+    variation_name: str,
+):
+    if not variation_name and len(existing_variations_names) == 1:
+        variation_name = get_deployed_variation_name(
+            existing_variations_names=existing_variations_names
+        )
+
+    return EnvironmentUndeploymentMessage(
+        model_id=model_id,
+        model_uuid=model_uuid,
+        hosting_service_type=DeploymentHostingServiceType.KUBE_DEPLOYMENT,
+        traffic_config=TrafficConfig(
+            selected_variation_name=variation_name,
+            audience_routes_entries=audiences,
+            fallback_variation=fallback_variation,
+        ),
+    )
+
+
+def get_env_to_undeploy_message(
+    audiences: List[AudienceRoutesEntry],
+    model_uuid: str,
+    env_id_to_deployment_details: Dict[str, EnvironmentDeploymentDetailsMessage],
+    env_name_to_env_details: Dict[str, EnvironmentDetails],
+    model_id: str,
+    variation_name: str,
+    fallback_variation: str,
+) -> Dict[str, EnvironmentUndeploymentMessage]:
+    env_undeployment_requests = dict()
+    errors = []
+    for env_name, env_details in env_name_to_env_details.items():
+        env_deployments_details_message = env_id_to_deployment_details.get(
+            env_details.id
+        )
+        if not env_deployments_details_message:
+            errors.append(
+                NO_DEPLOYED_VARIATIONS_ERROR_MSG.format(
+                    model_id=model_id, env_name=env_name
+                )
+            )
+            continue
+
+        env_deployments_details = env_deployments_details_message.deployments_details
+        existing_variations_names = {
+            deployment.variation.name for deployment in env_deployments_details
+        }
+        try:
+            env_undeployment_requests[
+                env_details.id
+            ] = get_environment_undeploy_message(
+                audiences,
+                existing_variations_names,
+                fallback_variation,
+                model_id,
+                model_uuid,
+                variation_name,
+            )
+        except FrogmlException as e:
+            errors.append(e.message)
+    if errors:
+        raise FrogmlException("\n".join(errors))
+    return env_undeployment_requests
+
+
+def undeploy(
+    model_id: str,
+    config: DeployConfig,
+    model_uuid: str = "",
+    sync: bool = False,
+):
+    deployment_client = DeploymentManagementClient()
+    ecosystem_client = EcosystemClient()
+    audiences: List[AudienceRoutesEntry] = [
+        audience.to_audience_route_entry(index)
+        for index, audience in enumerate(config.realtime.audiences)
+    ]
+
+    if not model_uuid:
+        raise FrogmlException("missing argument model uuid")
+
+    environments_names = config.realtime.environments if config.realtime else []
+
+    deployment_details = deployment_client.get_deployment_details(model_id, model_uuid)
+    env_id_to_deployment_details = dict(
+        deployment_details.environment_to_deployment_details
+    )
+    env_name_to_env_details = ecosystem_client.get_environments_names_to_details(
+        environments_names
+    )
+
+    env_undeployment_requests = get_env_to_undeploy_message(
+        audiences,
+        model_uuid,
+        env_id_to_deployment_details,
+        env_name_to_env_details,
+        model_id,
+        config.realtime.variation_name,
+        config.realtime.fallback_variation,
+    )
+
+    environment_to_deployment_id = {}
+    if sync:
+        environment_to_deployment_id = __get_environment_to_deployment_id(
+            deployment_client, model_id, model_uuid, env_undeployment_requests
+        )
+
+    undeployment_response = deployment_client.undeploy_model(
+        model_id=model_id,
+        model_uuid=model_uuid,
+        env_undeployment_requests=env_undeployment_requests,
+    )
+
+    if sync:
+        __sync_undeploy(
+            environment_to_deployment_id=environment_to_deployment_id,
+            model_id=model_id,
+            deployment_client=deployment_client,
+        )
+    logger.info(
+        f"Current status is {ModelDeploymentStatus.Name(undeployment_response.status)}."
+    )
+
+    return undeployment_response
+
+
+def __get_environment_to_deployment_id(
+    deployment_client: DeploymentManagementClient,
+    model_id: str,
+    model_uuid: str,
+    env_undeployment_requests: Dict,
+) -> Dict:
+    deployment_details = deployment_client.get_deployment_details(
+        model_id, model_uuid
+    ).environment_to_deployment_details
+    result = {}
+    for env_id, env_deployment_details in env_undeployment_requests.items():
+        deployment_detail_by_env = deployment_details.get(env_id)
+        if deployment_detail_by_env:
+            for deployment_detail in deployment_detail_by_env.deployments_details:
+                if (
+                    env_id == deployment_detail.environment_id
+                    and deployment_detail.variation.name
+                    == env_deployment_details.traffic_config.selected_variation_name
+                ):
+                    result[env_id] = deployment_detail.deployment_id
+    return result
+
+
+def __sync_undeploy(
+    environment_to_deployment_id: Dict,
+    model_id: str,
+    deployment_client: DeploymentManagementClient,
+):
+    with frogml_spinner(
+        begin_text=f"Undeploy - model: {model_id}",
+        end_text="Successful undeployment",
+        print_callback=print,
+    ):
+        for environment_id, deployment_id in environment_to_deployment_id.items():
+            status_result = _poll_undeployment_status(
+                deployment_id=deployment_id,
+                deployment_client=deployment_client,
+                check_every_n_seconds=TIME_TO_WAIT_FOR_UNDEPLOYMENT_POLLING,
+            )
+            failed_to_undeployment = []
+            for _, status in status_result.items():
+                if status in FAILED_UNDEPLOYMENT_STATUS:
+                    failed_to_undeployment.append(
+                        UNDEPLOY_ERROR_MSG.format(
+                            environment_id=environment_id, status=status
+                        )
+                    )
+            if failed_to_undeployment:
+                raise FrogmlException("\n".join(failed_to_undeployment))
+
+
+def _poll_undeployment_status(
+    deployment_id: str,
+    deployment_client: DeploymentManagementClient,
+    check_every_n_seconds: int,
+) -> Dict:
+    deployment_status = ""
+
+    while deployment_status not in END_UNDEPLOYMENT_STATUSES:
+        sleep(check_every_n_seconds)
+        deployment_status = __get_deployment_status(
+            deployment_id=deployment_id, deployment_client=deployment_client
+        )
+    return {deployment_id: deployment_status}
+
+
+def __get_deployment_status(
+    deployment_id: str, deployment_client: DeploymentManagementClient
+):
+    try:
+        return ModelDeploymentStatus.Name(
+            deployment_client.get_deployment_status(
+                deployment_named_id=deployment_id,
+            ).status
+        )
+    except FrogmlException as e:
+        logger.error(
+            f"Got error while trying to get deployment id: {deployment_id} status. Error is: {e.message}"
+        )
+        return ""

frogml_cli/commands/models/deployments/undeploy/ui.py

@@ -0,0 +1,61 @@
+import click
+from frogml.core.clients.model_management import ModelsManagementClient
+from frogml.core.tools.logger.logger import get_frogml_logger
+
+from frogml_cli.commands.models.deployments.deploy._logic.deploy_config import (
+    DeployConfig,
+)
+from frogml_cli.commands.models.deployments.undeploy._logic.request_undeploy import (
+    undeploy,
+)
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+from frogml_cli.inner.tools.config_handler import config_handler
+
+logger = get_frogml_logger()
+
+
+@click.command(
+    name="undeploy",
+    help="Model undeploy operation",
+    cls=FrogMLCommand,
+)
+@click.option("--model-id", metavar="NAME", required=True, help="Model ID")
+@click.option(
+    "--variation-name",
+    required=False,
+    type=str,
+    help="The variation name",
+)
+@click.option(
+    "-f",
+    "--from-file",
+    help="Undeploy by run_config file, Command arguments will overwrite any run_config.",
+    required=False,
+    type=click.Path(exists=True, resolve_path=True, dir_okay=False),
+)
+@click.option(
+    "--sync",
+    is_flag=True,
+    default=False,
+    help="Waiting for deployments to be undeploy",
+)
+def models_undeploy(
+    model_id: str,
+    variation_name: str,
+    from_file: str = None,
+    sync: bool = False,
+    **kwargs,
+):
+    logger.info(f"Initiating undeployment for model '{model_id}'")
+    models_management = ModelsManagementClient()
+    config: DeployConfig = config_handler(
+        config=DeployConfig,
+        from_file=from_file,
+        out_conf=False,
+        sections=("realtime",),
+        model_id=model_id,
+        variation_name=variation_name,
+    )
+    model_uuid = models_management.get_model_uuid(model_id)
+
+    undeploy(model_id=model_id, config=config, model_uuid=model_uuid, sync=sync)

frogml_cli/commands/models/describe/_logic.py

@@ -0,0 +1,169 @@
+import json
+from datetime import datetime
+
+from frogml._proto.qwak.builds.builds_pb2 import BuildStatus, ValueType
+from frogml._proto.qwak.deployment.deployment_pb2 import ModelDeploymentStatus
+from frogml.core.clients.build_orchestrator import BuildOrchestratorClient
+from frogml.core.clients.deployment.client import DeploymentManagementClient
+from frogml.core.clients.model_management import ModelsManagementClient
+from google.protobuf.json_format import MessageToDict
+from tabulate import tabulate
+
+
+def execute_model_describe(model_id, interface, show_list_builds, output_format):
+    model = _model_data(model_id)
+    deployment_data = _get_deployment_data(model)
+    list_builds = _builds_data(show_list_builds, model)
+    schema_data = _schema_data(interface, deployment_data)
+    if output_format == "text":
+        print_text_data(model, list_builds, schema_data, deployment_data)
+    elif output_format == "json":
+        print_json_data(model, list_builds, schema_data)
+
+
+def _get_deployment_data(model):
+    return DeploymentManagementClient().get_deployment_details(
+        model_id=model.model_id, model_uuid=model.uuid
+    )
+
+
+def _model_data(model_id):
+    models_management = ModelsManagementClient()
+    return models_management.get_model(model_id)
+
+
+def _builds_data(list_builds, model):
+    if list_builds:
+        builds_orchestrator = BuildOrchestratorClient()
+        return builds_orchestrator.list_builds(model.uuid)
+    return None
+
+
+def _schema_data(interface, deployment_data):
+    if interface and deployment_data.current_deployment_details.build_id:
+        build_response = BuildOrchestratorClient().get_build(
+            deployment_data.current_deployment_details.build_id
+        )
+        if build_response.build.HasField("model_schema"):
+            return build_response.build.model_schema
+    return None
+
+
+def print_json_data(model, list_builds, schema_data):
+    output = MessageToDict(model)
+    if list_builds:
+        output["builds"] = MessageToDict(list_builds)
+    if schema_data:
+        output["interface"] = MessageToDict(schema_data)
+    print(json.dumps(output, indent=4, sort_keys=True))
+
+
+def print_text_data(model, list_builds, schema_data, deployment_data):
+    print(
+        f"Model id: {model.model_id}\nDisplay name: {model.display_name}\nDescription: {model.model_description}\n"
+        + f'Creation Date: {datetime.fromtimestamp(model.created_at.seconds + model.created_at.nanos / 1e9).strftime("%A, %B %d, %Y %I:%M:%S")}\n'
+        + f'Last update: {datetime.fromtimestamp(model.created_at.seconds + model.last_modified_at.nanos / 1e9).strftime("%A, %B %d, %Y %I:%M:%S")}'
+    )
+    if list_builds:
+        _print_text_builds(deployment_data, list_builds)
+    if schema_data:
+        _print_text_schema(schema_data)
+
+
+def _print_text_schema(schema_data):
+    columns = [
+        "Parameter name",
+        "Parameter type",
+        "Parameter source",
+        "Parameter category",
+    ]
+    data = []
+    for entity in schema_data.entities:
+        data.append(
+            [
+                entity.name,
+                ValueType.Types.Name(entity.type.type),
+                None,
+                "Input",
+            ]
+        )
+    for feature in schema_data.features:
+        parsed_feature = _parse_feature(feature)
+        if parsed_feature:
+            data.append(parsed_feature)
+
+    for prediction in schema_data.predictions:
+        data.append(
+            [
+                prediction.name,
+                ValueType.Types.Name(prediction.type.type),
+                None,
+                "Output",
+            ]
+        )
+    print("\n" + tabulate(data, headers=columns))
+
+
+def _parse_feature(feature):
+    if feature.HasField("explicit_feature"):
+        return [
+            feature.explicit_feature.name,
+            ValueType.Types.Name(feature.explicit_feature.type.type),
+            None,
+            "Input",
+        ]
+    elif feature.HasField("batch_feature"):
+        return [
+            feature.batch_feature.name,
+            None,
+            feature.batch_feature.entity.name,
+            "Batch Feature",
+        ]
+    elif feature.HasField("on_the_fly_feature"):
+        return [
+            feature.on_the_fly_feature.name,
+            None,
+            str(
+                [
+                    source.explicit_feature.name
+                    for source in feature.on_the_fly_feature.source_features
+                ]
+            ),
+            "On-The-Fly Feature",
+        ]
+
+
+def _print_text_builds(deployment_data, list_builds):
+    columns = [
+        "Build id",
+        "Commit id",
+        "Last modified date",
+        "Build Status",
+        "Deployment build status",
+    ]
+    data = []
+    for build in list_builds.build:
+        deployments = deployment_data.build_to_environment_deployment_status.get(
+            build.buildId
+        )
+        if deployments:
+            deployment_status = ModelDeploymentStatus.Name(
+                number=list(deployments.environment_to_deployment_brief.values())[
+                    0
+                ].status
+            )
+        else:
+            deployment_status = ""
+        data.append(
+            [
+                build.buildId,
+                build.commitId,
+                datetime.fromtimestamp(
+                    build.audit.last_modified_at.seconds
+                    + build.audit.last_modified_at.nanos / 1e9
+                ).strftime("%A, %B %d, %Y %I:%M:%S"),
+                BuildStatus.Name(number=build.build_status),
+                deployment_status,
+            ]
+        )
+    print("\n" + tabulate(data, headers=columns))

frogml_cli/commands/models/describe/ui.py

@@ -0,0 +1,35 @@
+import click
+
+from frogml_cli.commands.models.describe._logic import execute_model_describe
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("describe", cls=FrogMLCommand)
+@click.option("--model-id", metavar="NAME", help="Model ID")
+@click.option(
+    "--interface",
+    metavar="",
+    required=False,
+    default=False,
+    help="Returns the deployed build interface",
+    is_flag=True,
+)
+@click.option(
+    "--list-builds",
+    metavar="",
+    required=False,
+    default=False,
+    help="Returns the list of builds of model",
+    is_flag=True,
+)
+@click.option(
+    "--format",
+    default="text",
+    show_default=True,
+    type=click.Choice(["text", "json"], case_sensitive=True),
+    metavar="FORMAT",
+    required=False,
+    help="The formatting style for commands output (choose from text, json)",
+)
+def model_describe(model_id, interface, list_builds, format, **kwargs):
+    execute_model_describe(model_id, interface, list_builds, format)

frogml_cli/commands/models/executions/cancel/_logic.py

@@ -0,0 +1,9 @@
+from frogml.core.clients.batch_job_management import BatchJobManagerClient
+from frogml.core.clients.batch_job_management.results import CancelExecutionResult
+
+
+def execute_execution_cancel(execution_id: str):
+    batch_job_cancel_response: CancelExecutionResult = (
+        BatchJobManagerClient().cancel_execution(execution_id)
+    )
+    return batch_job_cancel_response.success, batch_job_cancel_response.failure_message

frogml_cli/commands/models/executions/cancel/ui.py

@@ -0,0 +1,27 @@
+import click
+from frogml.core.exceptions import FrogmlException
+from frogml.core.tools.logger.logger import get_frogml_logger
+
+from frogml_cli.commands.models.executions.cancel._logic import execute_execution_cancel
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+logger = get_frogml_logger()
+
+
+@click.command(name="cancel", help="Cancel a running execution.", cls=FrogMLCommand)
+@click.option(
+    "--execution-id",
+    type=str,
+    help="The execution id.",
+)
+def execution_cancel(execution_id: str, **kwargs):
+    try:
+        success, fail_message = execute_execution_cancel(execution_id)
+        if not success:
+            raise FrogmlException(fail_message)
+
+        logger.info(f"Execution {execution_id} cancelled successfully.")
+
+    except Exception as e:
+        logger.error(f"Failed to cancel execution, Error: {e}")
+        raise

frogml_cli/commands/models/executions/execution_commands_group.py

@@ -0,0 +1,24 @@
+import click
+from frogml.core.tools.logger.logger import get_frogml_logger
+
+from frogml_cli.commands.models.executions.cancel.ui import execution_cancel
+from frogml_cli.commands.models.executions.report.ui import execution_report
+from frogml_cli.commands.models.executions.start.ui import execution_start
+from frogml_cli.commands.models.executions.status.ui import execution_status
+
+logger = get_frogml_logger()
+
+
+@click.group(
+    name="execution",
+    help="Executions of a batch job on deployed model.",
+)
+def execution_commands_group():
+    # Click commands group injection
+    pass
+
+
+execution_commands_group.add_command(execution_cancel)
+execution_commands_group.add_command(execution_report)
+execution_commands_group.add_command(execution_start)
+execution_commands_group.add_command(execution_status)

frogml_cli/commands/models/executions/report/_logic.py

@@ -0,0 +1,14 @@
+from frogml.core.clients.batch_job_management import BatchJobManagerClient
+from frogml.core.clients.batch_job_management.results import GetExecutionReportResult
+
+
+def execute_execution_report(execution_id: str):
+    batch_job_report_response: GetExecutionReportResult = (
+        BatchJobManagerClient().get_execution_report(execution_id)
+    )
+    return (
+        batch_job_report_response.records,
+        batch_job_report_response.model_logs,
+        batch_job_report_response.success,
+        batch_job_report_response.failure_message,
+    )

frogml_cli/commands/models/executions/report/ui.py

@@ -0,0 +1,43 @@
+import click
+from frogml.core.exceptions import FrogmlException
+from frogml.core.tools.logger.logger import get_frogml_logger
+
+from frogml_cli.commands.models.executions.report._logic import execute_execution_report
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+from frogml_cli.tools.colors import Color
+
+logger = get_frogml_logger()
+
+
+@click.command(name="report", help="Get the report of an execution.", cls=FrogMLCommand)
+@click.option(
+    "--execution-id",
+    type=str,
+    help="The execution id.",
+)
+def execution_report(execution_id: str, **kwargs):
+    try:
+        report_messages, model_logs, success, fail_message = execute_execution_report(
+            execution_id
+        )
+        if not success:
+            raise FrogmlException(fail_message)
+
+        colored_report_lines = [
+            f"{Color.BLUE}{message}{Color.END}" for message in report_messages
+        ]
+
+        colored_log_lines = [
+            f"{Color.BLUE}{message}{Color.END}" for message in model_logs
+        ]
+
+        print(f"{Color.WHITE}Execution Report{Color.END}")
+        print(f"{Color.WHITE}================{Color.END}")
+        print("\n".join(colored_report_lines), end="\n")
+        print(f"{Color.WHITE}Execution Logs{Color.END}")
+        print(f"{Color.WHITE}=============={Color.END}")
+        print("\n".join(colored_log_lines), end="\n")
+
+    except Exception as e:
+        logger.error(f"Failed to get execution report, Error: {e}")
+        raise