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

qwak_sdk/commands/models/deployments/deploy/_logic/deployment_message_helpers.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Dict
+
+from _qwak_proto.qwak.deployment.deployment_pb2 import (
+    BatchConfig,
+    EnvironmentDeploymentMessage,
+    HostingService,
+    KubeDeployment,
+    KubeDeploymentType,
+    ServingStrategy,
+)
+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.deployments.deploy._logic.advance_deployment_options_handler import (
+    get_advanced_deployment_options_from_deploy_config,
+)
+from qwak_sdk.commands.models.deployments.deploy._logic.deploy_config import (
+    DeployConfig,
+)
+from qwak_sdk.commands.models.deployments.deploy._logic.deployment_size_mapper import (
+    deployment_size_from_deploy_config,
+)
+from qwak_sdk.commands.models.deployments.deploy.realtime._logic.serving_strategy_mapper import (
+    create_realtime_serving_strategy_from_deploy_config,
+)
+from qwak_sdk.commands.models.deployments.deploy.streaming._logic.serving_strategy_mapper import (
+    create_streaming_serving_strategy_from_deploy_config,
+)
+from qwak_sdk.inner.tools.cli_tools import dictify_params
+
+UNKNOWN_SERVING_STRATEGY = (
+    "The deployments type doesn't have a serving strategy configured"
+)
+
+
+def get_env_to_deployment_message(
+    deploy_config: DeployConfig,
+    kube_deployment_type: KubeDeploymentType,
+    deployment_client: DeploymentManagementClient,
+    ecosystem_client: EcosystemClient,
+) -> Dict[str, EnvironmentDeploymentMessage]:
+    deployment_size = deployment_size_from_deploy_config(deploy_config)
+    advanced_deployment_options = get_advanced_deployment_options_from_deploy_config(
+        deploy_config, kube_deployment_type
+    )
+    environment_variables = {}
+    if kube_deployment_type == KubeDeploymentType.ONLINE:
+        model_traffic = deployment_client.get_model_traffic_config(
+            deploy_config.model_id
+        )
+        environment_name_to_config = ecosystem_client.get_environments_names_to_details(
+            deploy_config.realtime.environments
+        )
+        env_to_serving_strategy = create_realtime_serving_strategy_from_deploy_config(
+            deploy_config,
+            model_traffic,
+            environment_name_to_config,
+        )
+        environment_variables = dictify_params(deploy_config.realtime.env_vars)
+    elif kube_deployment_type == KubeDeploymentType.BATCH:
+        env_to_serving_strategy = {
+            ecosystem_client.get_account_details().default_environment_id: ServingStrategy(
+                batch_config=BatchConfig()
+            )
+        }
+    elif kube_deployment_type == KubeDeploymentType.STREAM:
+        env_to_serving_strategy = {
+            ecosystem_client.get_account_details().default_environment_id: create_streaming_serving_strategy_from_deploy_config(
+                deploy_config
+            )
+        }
+        environment_variables = dictify_params(deploy_config.stream.env_vars)
+    else:
+        raise QwakException(UNKNOWN_SERVING_STRATEGY)
+    env_to_hosting_services = {
+        env_id: HostingService(
+            kube_deployment=KubeDeployment(
+                deployment_size=deployment_size,
+                advanced_deployment_options=advanced_deployment_options,
+                serving_strategy=serving_strategy,
+                kube_deployment_type=kube_deployment_type,
+                environment_variables=environment_variables,
+            ),
+        )
+        for env_id, serving_strategy in env_to_serving_strategy.items()
+    }
+    env_deployment_messages = {
+        env_id: EnvironmentDeploymentMessage(
+            model_id=deploy_config.model_id,
+            build_id=deploy_config.build_id,
+            hosting_service=hosting_service,
+        )
+        for env_id, hosting_service in env_to_hosting_services.items()
+    }
+    return env_deployment_messages

qwak_sdk/commands/models/deployments/deploy/_logic/deployment_response_handler.py

@@ -0,0 +1,154 @@
+from typing import Dict
+
+from _qwak_proto.qwak.deployment.deployment_pb2 import ModelDeploymentStatus
+from _qwak_proto.qwak.deployment.deployment_service_pb2 import DeployModelResponse
+from _qwak_proto.qwak.ecosystem.v0.ecosystem_pb2 import UserContextEnvironmentDetails
+from qwak.clients.administration.eco_system.client import EcosystemClient
+from qwak.exceptions import QwakException
+from tabulate import tabulate
+
+from qwak_sdk.commands.models.deployments.deploy._logic.base_deploy_executor import (
+    FAILED_STATUS,
+    BaseDeployExecutor,
+)
+from qwak_sdk.inner.tools.logger.logger import get_qwak_logger
+from qwak_sdk.tools.utils import qwak_spinner
+
+logger = get_qwak_logger()
+
+
+def __client_deployment_remote(
+    deploy: BaseDeployExecutor, sync: bool, output_multiple: bool = False
+):
+    try:
+        deploy_response: DeployModelResponse = deploy.deploy()
+        deploy_status, deploy_id = (
+            ModelDeploymentStatus.Name(deploy_response.status),
+            deploy_response.deployment_named_id,
+        )
+
+        if deploy_response.environment_to_deployment_result:
+            account_environments = EcosystemClient().get_environments()
+            output_deployments_response(account_environments, deploy, deploy_response)
+            __check_failed_deployments(account_environments, deploy_response)
+
+            if sync:
+                deployment_id_to_env = {}
+                for (
+                    env_id,
+                    env_deploy_response,
+                ) in deploy_response.environment_to_deployment_result.items():
+                    deployment_id_to_env[
+                        env_deploy_response.deployment_named_id
+                    ] = account_environments.get(env_id).name
+
+                __sync_deployments(deploy, deployment_id_to_env)
+
+            if output_multiple:
+                return deploy_response.environment_to_deployment_result
+        else:
+            if "FAILED" in deploy_status:
+                raise QwakException(deploy_response.info)
+
+            if sync:
+                __sync_deployment(deploy, deploy_id)
+
+        if not sync:
+            logger.info(
+                "Deployment initiated successfully, Use --sync to wait for deployments to be ready."
+            )
+            return deploy_id, deploy_status
+    except Exception as e:
+        logger.error(f"Deployment failed, Error: {e}")
+        raise e
+
+
+def __check_failed_deployments(
+    account_environments: Dict[str, UserContextEnvironmentDetails],
+    deploy_response: DeployModelResponse,
+):
+    failed_deployments = {}
+    for (
+        env_id,
+        env_deploy_response,
+    ) in deploy_response.environment_to_deployment_result.items():
+        deploy_status = ModelDeploymentStatus.Name(env_deploy_response.status)
+        if "FAILED" in deploy_status:
+            env_config = account_environments.get(env_id)
+            failed_deployments[
+                env_config.name if env_config else env_id
+            ] = env_deploy_response.info
+    if failed_deployments:
+        failed_deployments_message = "\n".join(
+            [
+                f"Environment {env_name}: {reason}"
+                for env_name, reason in failed_deployments.items()
+            ]
+        )
+        raise QwakException(
+            f"The following deployments failed:\n {failed_deployments_message}"
+        )
+
+
+def output_deployments_response(
+    account_environments: Dict[str, UserContextEnvironmentDetails],
+    deploy: BaseDeployExecutor,
+    deploy_response: DeployModelResponse,
+):
+    for (
+        env_id,
+        env_deploy_response,
+    ) in deploy_response.environment_to_deployment_result.items():
+        env_config = account_environments.get(env_id)
+        if env_deploy_response.status == ModelDeploymentStatus.INITIATING_DEPLOYMENT:
+            logger.info(
+                tabulate(
+                    tabular_data=[
+                        ["Environment", env_config.name],
+                        ["Model ID", deploy.config.model_id],
+                        ["Build ID", deploy.config.build_id],
+                        ["Deployment ID", env_deploy_response.deployment_named_id],
+                    ],
+                    tablefmt="fancy_grid",
+                )
+            )
+
+
+def __sync_deployments(
+    deploy: BaseDeployExecutor, deployment_id_to_env: Dict[str, str]
+):
+    with qwak_spinner(
+        begin_text=f"Deploy - model: {deploy.config.model_id}, build: {deploy.config.build_id} "
+        f"Environments: {', '.join(deploy.config.realtime.environments)}",
+        end_text="Successful deployments",
+        print_callback=print,
+    ):
+        deployment_id_to_status = deploy.poll_until_complete_multiple(
+            list(deployment_id_to_env.keys()), poll_period=600
+        )
+        failed_deployments = []
+        for deployment_id, status in deployment_id_to_status.items():
+            if status in FAILED_STATUS:
+                failed_deployments.append(
+                    f"Environment {deployment_id_to_env.get(deployment_id)} "
+                    f"failed with status: {status}"
+                )
+        if failed_deployments:
+            raise QwakException("\n".join(failed_deployments))
+
+
+def __sync_deployment(deploy: BaseDeployExecutor, deploy_name: str):
+    with qwak_spinner(
+        begin_text=f"Deploy - model: {deploy.config.model_id}, build: {deploy.config.build_id}",
+        end_text="Successful deployments",
+        print_callback=print,
+    ):
+        deployment_status = deploy.poll_until_complete(deploy_name, poll_period=600)
+        if deployment_status in FAILED_STATUS:
+            raise QwakException(deployment_status)
+
+
+def client_deployment(
+    deploy: BaseDeployExecutor, sync: bool, output_multiple: bool = False
+):
+    return __client_deployment_remote(deploy, sync, output_multiple)

qwak_sdk/commands/models/deployments/deploy/_logic/deployment_size_mapper.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from _qwak_proto.qwak.deployment.deployment_pb2 import DeploymentSize, MemoryUnit
+from _qwak_proto.qwak.user_application.common.v0.resources_pb2 import GpuResources
+
+from qwak_sdk.commands.models.deployments.deploy._logic.deploy_config import (
+    DeployConfig,
+)
+
+
+def deployment_size_from_deploy_config(deploy_config: DeployConfig) -> DeploymentSize:
+    return DeploymentSize(
+        number_of_pods=deploy_config.resources.pods,
+        cpu=deploy_config.resources.cpus,
+        memory_amount=deploy_config.resources.memory,
+        memory_units=MemoryUnit.MIB,
+        gpu_resources=GpuResources(
+            gpu_type=deploy_config.resources.gpu_type,
+            gpu_amount=deploy_config.resources.gpu_amount,
+        ),
+    )

qwak_sdk/commands/models/deployments/deploy/_logic/get_latest_successful_build.py

@@ -0,0 +1,31 @@
+from copy import deepcopy
+
+from _qwak_proto.qwak.builds.builds_pb2 import SUCCESSFUL
+from qwak.clients.build_management.client import BuildsManagementClient
+from qwak.clients.model_management.client import ModelsManagementClient
+from qwak.exceptions import QwakException
+
+
+def get_latest_successful_build_from_model(model_id: str) -> str:
+    """Get the latest successful build from model
+
+    Args:
+        model_id: Model id to search build for.
+
+    Returns:
+        str: Latest build id.
+
+    Raises:
+        QwakException: if no successful build exists in model.
+    """
+    model = ModelsManagementClient().get_model(model_id)
+    model_uuid = model.uuid
+    last_successful_build = BuildsManagementClient().list_builds(model_uuid)
+    builds = deepcopy(last_successful_build.builds)
+    builds = [build for build in builds if build.build_status == SUCCESSFUL]
+    builds.sort(key=lambda r: r.created_at.seconds)
+
+    if not builds:
+        raise QwakException(f"Unable to find successful build for model {model_id}")
+
+    return builds[-1].build_spec.build_id

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

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import List
+
+from _qwak_proto.qwak.deployment.deployment_pb2 import TrafficSpec, Variation
+from qwak.exceptions import QwakException
+
+from qwak_sdk.commands.models._logic.variations import (
+    validate_percentages,
+    validate_shadow_variation,
+)
+
+
+def get_variations_for_deploy(
+    variation_name: str,
+    existing_variations: List[Variation],
+    requested_variations: List[Variation],
+    environment_name: str,
+):
+    if not existing_variations:
+        existing_variations: List[Variation] = [
+            Variation(
+                name=variation_name,
+                traffic=TrafficSpec(
+                    percentage=100,
+                    is_shadow=False,
+                ),
+            )
+        ]
+    requested_variations_names = set(
+        map(lambda variation: variation.name, requested_variations)
+    )
+    existing_variations_names = set(
+        map(lambda variation: variation.name, existing_variations)
+    )
+    if requested_variations_names:
+        if variation_name not in requested_variations_names:
+            raise QwakException(
+                f"Selected deployment to variation '{variation_name}' in {environment_name}, but provided the "
+                f"following variations {list(requested_variations_names)}. "
+                f"Please modify the variation name, or adjust the requested variations definitions"
+            )
+    elif variation_name not in existing_variations_names:
+        raise QwakException(
+            f"Selected deployment to existing variation '{variation_name}' in {environment_name}, but it is not one of "
+            f"the existing variations {list(existing_variations_names)}. "
+            f"Please modify the variation name, or supply the requested variations definitions with"
+            f" the necessary changes"
+        )
+    else:
+        # We are deploying to an existing variations without any change
+        return existing_variations
+
+    ignored_variations = existing_variations_names.difference(
+        requested_variations_names
+    )
+    if ignored_variations:
+        raise QwakException(
+            f"The given variation configuration does not contain the configuration for the following "
+            f"variations {list(ignored_variations)} in {environment_name}. You must include all the existing "
+            f"variations configuration when passing the configuration"
+        )
+
+    unexpected_variations = requested_variations_names.difference(
+        existing_variations_names
+    )
+    if variation_name in unexpected_variations:
+        unexpected_variations.remove(variation_name)
+    if unexpected_variations:
+        raise QwakException(
+            f"The given variation configuration contains the configuration for the following "
+            f"variations {list(unexpected_variations)} in {environment_name} which are not expected. When deploying, "
+            f"the variations configuration must contain all the existing variations, and an optional new variation."
+        )
+
+    validate_percentages(requested_variations)
+    validate_shadow_variation(requested_variations)
+
+    return requested_variations

qwak_sdk/commands/models/deployments/deploy/batch/_logic/advanced_deployment_mapper.py

@@ -0,0 +1,14 @@
+from _qwak_proto.qwak.deployment.deployment_pb2 import AdvancedDeploymentOptions
+
+from qwak_sdk.commands.models.deployments.deploy._logic.deploy_config import (
+    DeployConfig,
+)
+
+
+def batch_advanced_deployment_options_from_deploy_config(
+    deploy_config: DeployConfig,
+) -> AdvancedDeploymentOptions:
+    return AdvancedDeploymentOptions(
+        custom_iam_role_arn=deploy_config.advanced_options.iam_role_arn,
+        purchase_option=deploy_config.advanced_options.purchase_option,
+    )

qwak_sdk/commands/models/deployments/deploy/batch/_logic/deploy_executor.py

@@ -0,0 +1,24 @@
+from _qwak_proto.qwak.deployment.deployment_pb2 import KubeDeploymentType
+from _qwak_proto.qwak.deployment.deployment_service_pb2 import DeployModelResponse
+
+from qwak_sdk.commands.models.deployments.deploy._logic.base_deploy_executor import (
+    BaseDeployExecutor,
+)
+from qwak_sdk.commands.models.deployments.deploy._logic.deployment_message_helpers import (
+    get_env_to_deployment_message,
+)
+
+
+class BatchDeployExecutor(BaseDeployExecutor):
+    def deploy(self) -> DeployModelResponse:
+        env_deployment_messages = get_env_to_deployment_message(
+            self.config,
+            KubeDeploymentType.BATCH,
+            self.deploy_client,
+            self.ecosystem_client,
+        )
+        return self.deploy_client.deploy_model(
+            model_id=self.config.model_id,
+            build_id=self.config.build_id,
+            env_deployment_messages=env_deployment_messages,
+        )

qwak_sdk/commands/models/deployments/deploy/batch/ui.py

@@ -0,0 +1,104 @@
+import click
+from qwak.inner.const import QwakConstants
+
+from qwak_sdk.commands.models.deployments.deploy._logic.deploy_config import (
+    DeployConfig,
+    PurchaseOption,
+)
+from qwak_sdk.commands.models.deployments.deploy._logic.deployment_response_handler import (
+    client_deployment,
+)
+from qwak_sdk.commands.models.deployments.deploy.batch._logic.deploy_executor import (
+    BatchDeployExecutor,
+)
+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 set_qwak_logger_stdout_verbosity_level
+
+
+@click.command("batch", help="Deploy batch model.", cls=QwakCommand)
+@click.option(
+    "--build-id",
+    help="Build ID, If not specified latest successful build will deployed.",
+    type=str,
+)
+@click.option("--model-id", help="Model ID", type=str, required=True)
+@click.option("--branch", help="Branch ID", type=str)
+@click.option(
+    "--pods",
+    type=int,
+    help="Number of pods to deploy.",
+)
+@click.option(
+    "--cpus",
+    type=float,
+    help="Number of CPU cores, can be fraction of a core (e.g. 0.4).",
+)
+@click.option(
+    "--memory",
+    type=int,
+    help="Memory amount in Mib (e.g. 256).",
+)
+@click.option(
+    "--gpu-type",
+    metavar="NAME",
+    required=False,
+    help=f"Type of GPU to use on the deployments ({', '.join([x for x in QwakConstants.GPU_TYPES])}).",
+    type=click.STRING,
+)
+@click.option(
+    "--gpu-amount",
+    metavar="NAME",
+    required=False,
+    type=int,
+    help="Amount of GPU to use on the deployments.",
+)
+@click.option(
+    "--iam-role-arn",
+    type=str,
+    help="Custom IAM Role ARN.",
+)
+@click.option(
+    "--sync",
+    is_flag=True,
+    default=False,
+    help="Waiting for deployments to be ready",
+)
+@click.option(
+    "-v",
+    "--verbose",
+    count=True,
+    help="Log verbosity level - v: INFO, vv: DEBUG [default: WARNING]",
+)
+@click.option(
+    "-f",
+    "--from-file",
+    help="Deploy 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 commands arguments, the commands will not run it wil only output valid yaml "
+    "structure",
+    default=False,
+    is_flag=True,
+)
+@click.option(
+    "--purchase-option",
+    required=False,
+    type=click.Choice([i.value for i in PurchaseOption], case_sensitive=False),
+    help="Indicate the instance deployments type, whether it is spot/ondemand.  Default is spot",
+)
+def batch(verbose: bool, from_file: str, out_conf: bool, sync: bool, **kwargs):
+    set_qwak_logger_stdout_verbosity_level(verbose + 1)
+    config: DeployConfig = config_handler(
+        config=DeployConfig,
+        from_file=from_file,
+        out_conf=out_conf,
+        sections=("batch",),
+        **kwargs,
+    )
+    if not out_conf:
+        deploy_executor = BatchDeployExecutor(config)
+        client_deployment(deploy=deploy_executor, sync=sync)

qwak_sdk/commands/models/deployments/deploy/deploy_commands_group.py

@@ -0,0 +1,19 @@
+from click import group
+
+from qwak_sdk.commands.models.deployments.deploy.batch.ui import batch
+from qwak_sdk.commands.models.deployments.deploy.realtime.ui import realtime
+from qwak_sdk.commands.models.deployments.deploy.streaming.ui import stream
+
+
+@group(
+    name="deploy",
+    help="Model deployments",
+)
+def deploy_group():
+    # Click group injection
+    pass
+
+
+deploy_group.add_command(realtime, "realtime")
+deploy_group.add_command(stream, "stream")
+deploy_group.add_command(batch, "batch")

qwak_sdk/commands/models/deployments/deploy/realtime/_logic/advanced_deployment_mapper.py

@@ -0,0 +1,20 @@
+from _qwak_proto.qwak.deployment.deployment_pb2 import AdvancedDeploymentOptions
+from google.protobuf.wrappers_pb2 import BoolValue
+
+from qwak_sdk.commands.models.deployments.deploy._logic.deploy_config import (
+    DeployConfig,
+)
+
+
+def realtime_advanced_deployment_options_from_deploy_config(
+    deploy_config: DeployConfig,
+) -> AdvancedDeploymentOptions:
+    return AdvancedDeploymentOptions(
+        number_of_http_server_workers=deploy_config.realtime.workers,
+        http_request_timeout_ms=deploy_config.realtime.timeout,
+        daemon_mode=BoolValue(value=deploy_config.realtime.daemon_mode),
+        max_batch_size=deploy_config.realtime.max_batch_size,
+        custom_iam_role_arn=deploy_config.advanced_options.iam_role_arn,
+        purchase_option=deploy_config.advanced_options.purchase_option,
+        deployment_process_timeout_limit=deploy_config.realtime.deployment_timeout,
+    )

qwak_sdk/commands/models/deployments/deploy/realtime/_logic/deploy_executor.py

@@ -0,0 +1,24 @@
+from _qwak_proto.qwak.deployment.deployment_pb2 import KubeDeploymentType
+from _qwak_proto.qwak.deployment.deployment_service_pb2 import DeployModelResponse
+
+from qwak_sdk.commands.models.deployments.deploy._logic.base_deploy_executor import (
+    BaseDeployExecutor,
+)
+from qwak_sdk.commands.models.deployments.deploy._logic.deployment_message_helpers import (
+    get_env_to_deployment_message,
+)
+
+
+class RealtimeDeployExecutor(BaseDeployExecutor):
+    def deploy(self) -> DeployModelResponse:
+        env_deployment_messages = get_env_to_deployment_message(
+            self.config,
+            KubeDeploymentType.ONLINE,
+            self.deploy_client,
+            self.ecosystem_client,
+        )
+        return self.deploy_client.deploy_model(
+            model_id=self.config.model_id,
+            build_id=self.config.build_id,
+            env_deployment_messages=env_deployment_messages,
+        )