qwak-sdk 0.1.0__py3-none-any.whl → 0.2.21rc0__py3-none-any.whl

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

@@ -0,0 +1,176 @@
+from typing import Dict, List, Set
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import AudienceRoutesEntry
+from _qwak_proto.qwak.deployment.deployment_pb2 import (
+    DeploymentHostingServiceType,
+    EnvironmentDeploymentDetailsMessage,
+    EnvironmentUndeploymentMessage,
+    ModelDeploymentStatus,
+    TrafficConfig,
+    Variation,
+)
+from _qwak_proto.qwak.ecosystem.v0.ecosystem_pb2 import EnvironmentDetails
+from qwak.clients.administration.eco_system.client import EcosystemClient
+from qwak.clients.deployment.client import DeploymentManagementClient
+from qwak.exceptions import QwakException
+
+from qwak_sdk.commands.models._logic.variations import (
+    create_variation_from_variation_config,
+)
+from qwak_sdk.commands.models.deployments.deploy._logic.deploy_config import (
+    DeployConfig,
+)
+from qwak_sdk.commands.models.deployments.undeploy._logic.variations import (
+    validate_variations_for_undeploy,
+)
+from qwak_sdk.inner.tools.logger.logger import get_qwak_logger
+
+NO_DEPLOYED_VARIATIONS_ERROR_MSG = (
+    "There are currently no deployed variations for model {model_id} in {env_name}"
+)
+
+logger = get_qwak_logger()
+
+
+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],
+    env_name: str,
+    existing_variations_names: Set[str],
+    fallback_variation: str,
+    model_id: str,
+    model_uuid: str,
+    requested_variations: List[Variation],
+    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
+        )
+
+    if not audiences:
+        validate_variations_for_undeploy(
+            variation_name,
+            existing_variations_names,
+            requested_variations,
+            env_name,
+        )
+    return EnvironmentUndeploymentMessage(
+        model_id=model_id,
+        model_uuid=model_uuid,
+        hosting_service_type=DeploymentHostingServiceType.KUBE_DEPLOYMENT,
+        traffic_config=TrafficConfig(
+            selected_variation_name=variation_name,
+            variations=requested_variations,
+            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,
+    requested_variations: List[Variation],
+    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,
+                env_name,
+                existing_variations_names,
+                fallback_variation,
+                model_id,
+                model_uuid,
+                requested_variations,
+                variation_name,
+            )
+        except QwakException as e:
+            errors.append(e.message)
+    if errors:
+        raise QwakException("\n".join(errors))
+    return env_undeployment_requests
+
+
+def undeploy(
+    model_id: str,
+    branch_id: str,
+    config: DeployConfig,
+    model_uuid: str = "",
+):
+    deployment_client = DeploymentManagementClient()
+    ecosystem_client = EcosystemClient()
+    audiences: List[AudienceRoutesEntry] = [
+        audience.to_audience_route_entry(index)
+        for index, audience in enumerate(config.realtime.audiences)
+    ]
+    requested_variations = list(
+        map(
+            create_variation_from_variation_config,
+            config.realtime.variations if config.realtime else [],
+        )
+    )
+
+    _model_uuid = model_uuid if model_uuid else branch_id
+    if not _model_uuid:
+        raise QwakException("missing argument model uuid or branch id.")
+
+    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,
+        requested_variations,
+        config.realtime.variation_name,
+        config.realtime.fallback_variation,
+    )
+
+    undeployment_response = deployment_client.undeploy_model(
+        model_id=model_id,
+        model_uuid=_model_uuid,
+        env_undeployment_requests=env_undeployment_requests,
+    )
+
+    logger.info(
+        f"Current status is {ModelDeploymentStatus.Name(undeployment_response.status)}."
+    )
+
+    return undeployment_response

qwak_sdk/commands/models/deployments/undeploy/_logic/variations.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import List, Set
+
+from _qwak_proto.qwak.deployment.deployment_pb2 import Variation
+from qwak.exceptions import QwakException
+
+from qwak_sdk.commands.models.deployments.deploy._logic.variations import (
+    validate_percentages,
+    validate_shadow_variation,
+)
+
+
+def validate_variations_for_undeploy(
+    variation_name: str,
+    existing_variations_names: Set[str],
+    requested_variations: List[Variation],
+    environment_name: str,
+):
+    if variation_name not in existing_variations_names:
+        if not variation_name:
+            raise QwakException(
+                f"No selected variation. You must specify a variation since there is more than one deployed in "
+                f"{environment_name}. Currently {list(existing_variations_names)} are deployed"
+            )
+        raise QwakException(
+            f"The selected variation {variation_name} is not deployed in {environment_name}. "
+            f"Only {list(existing_variations_names)} are deployed"
+        )
+
+    requested_variations_names = set(
+        map(lambda variation: variation.name, requested_variations)
+    )
+    if variation_name in requested_variations_names:
+        raise QwakException(
+            f"Selected undeploy to variation '{variation_name}', but it is part of "
+            f"the requested variations {list(requested_variations_names)}. "
+            f"Please modify the variation name, or supply the requested variations definitions with"
+            f" the necessary changes"
+        )
+    if variation_name not in existing_variations_names:
+        raise QwakException(
+            f"Selected undeploy to variation {variation_name} but it is not one of "
+            f"the existing variations {list(existing_variations_names)}. "
+            f"Please modify the variation name."
+        )
+
+    ignored_variations = existing_variations_names.difference(
+        requested_variations_names
+    )
+    if variation_name in ignored_variations:
+        ignored_variations.remove(variation_name)
+
+    if len(existing_variations_names) != 2 and ignored_variations:
+        raise QwakException(
+            f"The given variation configuration does not contain the configuration for the following "
+            f"variations {list(ignored_variations)}. You must include all the variations that will exist after "
+            f"undeploy in the configuration"
+        )
+
+    unexpected_variations = requested_variations_names.difference(
+        existing_variations_names
+    )
+
+    if unexpected_variations:
+        raise QwakException(
+            f"The given variation configuration contains the configuration for the following "
+            f"variations {list(unexpected_variations)} which are not expected. When undeploying, the variations "
+            f"configuration must contain all expected remaining variations (from the existing ones)."
+        )
+
+    if requested_variations:
+        validate_percentages(requested_variations)
+        validate_shadow_variation(requested_variations)

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

@@ -0,0 +1,78 @@
+from typing import List
+
+import click
+from qwak.clients.model_management import ModelsManagementClient
+
+from qwak_sdk.commands.models.deployments.deploy._logic.deploy_config import (
+    DeployConfig,
+)
+from qwak_sdk.commands.models.deployments.undeploy._logic.request_undeploy import (
+    undeploy,
+)
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+from qwak_sdk.inner.tools.config_handler import config_handler
+from qwak_sdk.inner.tools.logger.logger import get_qwak_logger
+
+logger = get_qwak_logger()
+
+
+@click.command(
+    name="undeploy",
+    help="Model undeploy operation",
+    cls=QwakCommand,
+)
+@click.option("--model-id", metavar="NAME", required=True, help="Model ID")
+@click.option(
+    "--branch",
+    metavar="NAME",
+    default="main",
+    help="Branch to deploy under. Default is 'main'.",
+)
+@click.option(
+    "--variation-name",
+    required=False,
+    type=str,
+    help="The variation name",
+)
+@click.option(
+    "--environment-name",
+    required=False,
+    type=str,
+    help="Environment to undeploy from (if not specified uses your default environment",
+    multiple=True,
+)
+@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),
+)
+def models_undeploy(
+    model_id: str,
+    branch: str,
+    variation_name: str,
+    environment_name: List[str],
+    from_file: str = None,
+    **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,
+        branch=branch,
+        variation_name=variation_name,
+        environment_name=environment_name,
+    )
+    model_uuid = models_management.get_model_uuid(model_id)
+
+    undeploy(
+        model_id=model_id,
+        branch_id=model_uuid,
+        config=config,
+        model_uuid=model_uuid,
+    )

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

@@ -0,0 +1,9 @@
+from qwak.clients.batch_job_management import BatchJobManagerClient
+from qwak.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

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

@@ -0,0 +1,27 @@
+import click
+from qwak.exceptions import QwakException
+
+from qwak_sdk.commands.models.executions.cancel._logic import execute_execution_cancel
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+from qwak_sdk.inner.tools.logger.logger import get_qwak_logger
+
+logger = get_qwak_logger()
+
+
+@click.command(name="cancel", help="Cancel a running execution.", cls=QwakCommand)
+@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 QwakException(fail_message)
+
+        logger.info(f"Execution {execution_id} cancelled successfully.")
+
+    except Exception as e:
+        logger.error(f"Failed to cancel execution, Error: {e}")
+        raise

qwak_sdk/commands/models/executions/execution_commands_group.py

@@ -0,0 +1,24 @@
+import click
+
+from qwak_sdk.commands.models.executions.cancel.ui import execution_cancel
+from qwak_sdk.commands.models.executions.report.ui import execution_report
+from qwak_sdk.commands.models.executions.start.ui import execution_start
+from qwak_sdk.commands.models.executions.status.ui import execution_status
+from qwak_sdk.inner.tools.logger.logger import get_qwak_logger
+
+logger = get_qwak_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)

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

@@ -0,0 +1,14 @@
+from qwak.clients.batch_job_management import BatchJobManagerClient
+from qwak.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,
+    )

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

@@ -0,0 +1,43 @@
+import click
+from qwak.exceptions import QwakException
+
+from qwak_sdk.commands.models.executions.report._logic import execute_execution_report
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+from qwak_sdk.inner.tools.logger.logger import get_qwak_logger
+from qwak_sdk.tools.colors import Color
+
+logger = get_qwak_logger()
+
+
+@click.command(name="report", help="Get the report of an execution.", cls=QwakCommand)
+@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 QwakException(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

qwak_sdk/commands/models/executions/start/_logic.py

@@ -0,0 +1,16 @@
+from typing import Tuple
+
+from qwak.clients.batch_job_management import BatchJobManagerClient
+from qwak.clients.batch_job_management.executions_config import ExecutionConfig
+from qwak.clients.batch_job_management.results import StartExecutionResult
+
+
+def execute_start_execution(config: ExecutionConfig) -> Tuple[str, bool, str]:
+    batch_job_start_response: StartExecutionResult = (
+        BatchJobManagerClient().start_execution(config)
+    )
+    return (
+        batch_job_start_response.execution_id,
+        batch_job_start_response.success,
+        batch_job_start_response.failure_message,
+    )

qwak_sdk/commands/models/executions/start/ui.py

@@ -0,0 +1,176 @@
+import click
+from qwak.clients.batch_job_management.executions_config import (
+    GPU_TYPE_MAP,
+    INPUT_FORMATTERS_MAP,
+    OUTPUT_FORMATTERS_MAP,
+    ExecutionConfig,
+)
+from qwak.exceptions import QwakException
+from qwak.inner.const import QwakConstants
+from tabulate import tabulate
+
+from qwak_sdk.commands.models.executions.start._logic import execute_start_execution
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+from qwak_sdk.inner.tools.config_handler import config_handler
+from qwak_sdk.inner.tools.logger.logger import get_qwak_logger
+
+logger = get_qwak_logger()
+
+
+@click.command(
+    name="start", help="Start an execution job on a deployed model.", cls=QwakCommand
+)
+@click.option("--model-id", required=True, help="Model ID", type=str)
+@click.option("--branch", required=True, help="Branch", type=str, default="main")
+@click.option(
+    "--build-id",
+    type=str,
+    help="Explicit Build ID to invoke the execution against. If empty, the deployed build ID will be applied",
+)
+@click.option(
+    "--bucket",
+    type=str,
+    help="The bucket to read and write the data to/from.",
+)
+@click.option(
+    "--source-bucket",
+    type=str,
+    help="The source bucket to read the data from.",
+)
+@click.option(
+    "--source-folder",
+    required=True,
+    type=str,
+    help="The source folder to read the data from.",
+)
+@click.option(
+    "--destination-bucket",
+    type=str,
+    help="The destination bucket to store results on.",
+)
+@click.option(
+    "--destination-folder",
+    type=str,
+    required=True,
+    help="The destination folder to store results on.",
+)
+@click.option(
+    "--input-file-type",
+    type=click.Choice(
+        [fmt for fmt in INPUT_FORMATTERS_MAP.keys()], case_sensitive=False
+    ),
+    help="The input file type to read.",
+)
+@click.option(
+    "--output-file-type",
+    type=click.Choice(
+        [fmt for fmt in OUTPUT_FORMATTERS_MAP.keys()], case_sensitive=False
+    ),
+    help="The output file type to to receive.",
+)
+@click.option(
+    "--access-token-name",
+    type=str,
+    required=True,
+    help="The access token secret name (should be created before by using `qwak secret`).",
+)
+@click.option(
+    "--access-secret-name",
+    type=str,
+    required=True,
+    help="The access secret secret name (should be created before by using `qwak secret`).",
+)
+@click.option(
+    "--job-timeout",
+    type=int,
+    default=0,
+    help="Total inference job timeout in seconds, (e.g. 2000). Default is unlimited.",
+)
+@click.option(
+    "--file-timeout",
+    type=int,
+    default=0,
+    help="A single file inference timeout in seconds, (e.g. 2000). Default is unlimited.",
+)
+@click.option(
+    "--pods",
+    type=int,
+    default=0,
+    help="Number of pods to deploy. (concurrent files processing). Default is as deployed.",
+)
+@click.option(
+    "--cpus",
+    type=float,
+    default=0,
+    help="Number of CPU cores, can be fraction of a core "
+    "(e.g. 0.4). Default is as deployed.",
+)
+@click.option(
+    "--memory",
+    type=int,
+    default=0,
+    help="Memory amount in Mib (e.g. 256). Default is as deployed.",
+)
+@click.option(
+    "--gpu-type",
+    type=click.Choice([fmt for fmt in GPU_TYPE_MAP.keys()], case_sensitive=False),
+    help=f"Type of GPU to use on the deployment ({', '.join([x for x in QwakConstants.GPU_TYPES])}).",
+)
+@click.option(
+    "--gpu-amount",
+    type=int,
+    help="Amount of GPU's to use on the in the batch inference.",
+)
+@click.option(
+    "-f",
+    "--from-file",
+    help="Build 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(
+    "--out-conf",
+    help="Extract deploy conf from command arguments, the command will not run it wil only output valid yaml "
+    "structure",
+    default=False,
+    is_flag=True,
+)
+@click.option(
+    "-P",
+    "--param-list",
+    required=False,
+    metavar="NAME=VALUE",
+    multiple=True,
+    help="A parameter for the batch execution, of the form -P name=value",
+)
+def execution_start(from_file: str, out_conf: bool, **kwargs):
+    config: ExecutionConfig = config_handler(
+        config=ExecutionConfig,
+        from_file=from_file,
+        out_conf=out_conf,
+        sections=("execution", "resources"),
+        **kwargs,
+    )
+    if not out_conf:
+        try:
+            execution_id, success, fail_message = execute_start_execution(config)
+            if success:
+                logger.info(
+                    tabulate(
+                        tabular_data=[
+                            ["Model ID", config.execution.model_id],
+                            ["Branch", config.execution.branch],
+                            ["Execution ID", execution_id],
+                        ],
+                        tablefmt="fancy_grid",
+                    )
+                )
+            else:
+                raise QwakException(fail_message + f" {execution_id}")
+
+            logger.info(
+                "Execution initiated successfully, Use --status to get execution current status."
+            )
+        except Exception as e:
+            logger.error(f"Execution failed, Error: {e}")
+            raise

qwak_sdk/commands/models/executions/status/_logic.py

@@ -0,0 +1,13 @@
+from qwak.clients.batch_job_management import BatchJobManagerClient
+from qwak.clients.batch_job_management.results import ExecutionStatusResult
+
+
+def execute_execution_status(execution_id: str):
+    batch_job_status_response: ExecutionStatusResult = (
+        BatchJobManagerClient().get_execution_status(execution_id)
+    )
+    return (
+        batch_job_status_response.status,
+        batch_job_status_response.success,
+        batch_job_status_response.failure_message,
+    )