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

qwak_sdk/commands/models/models_command_group.py

@@ -0,0 +1,36 @@
+import click
+
+from qwak_sdk.commands.auto_scalling.autoscaling_commands_group import (
+    autoscaling_commands_group,
+)
+
+from .build.ui import models_build
+from .builds.builds_commands_group import builds_commands_group
+from .create.ui import model_create
+from .delete.ui import model_delete
+from .deployments.deploy.deploy_commands_group import deploy_group
+from .deployments.undeploy.ui import models_undeploy
+from .executions.execution_commands_group import execution_commands_group
+from .init.ui import model_init
+from .list.ui import model_list
+
+
+@click.group(
+    name="models",
+    help="Commands for interacting with Qwak based models",
+)
+def models_command_group():
+    # Click group injection
+    pass
+
+
+models_command_group.add_command(autoscaling_commands_group)
+models_command_group.add_command(builds_commands_group)
+models_command_group.add_command(execution_commands_group)
+models_command_group.add_command(model_init)
+models_command_group.add_command(model_create)
+models_command_group.add_command(model_delete)
+models_command_group.add_command(model_list)
+models_command_group.add_command(models_build)
+models_command_group.add_command(deploy_group, "deploy")
+models_command_group.add_command(models_undeploy, "undeploy")

qwak_sdk/commands/models/runtime/feedback/_logic.py

@@ -0,0 +1,81 @@
+import os
+from datetime import datetime
+
+from _qwak_proto.qwak.inference.feedback.feedback_pb2 import (
+    Actuals,
+    ActualValuesRequest,
+    ConfigureFeedbackRequest,
+    Entity,
+    FeedbackConfig,
+)
+from _qwak_proto.qwak.inference.feedback.feedback_pb2_grpc import FeedbackServiceStub
+from google.protobuf.internal.well_known_types import Timestamp
+from qwak.inner.const import QwakConstants
+from qwak.inner.di_configuration import UserAccountConfiguration
+from qwak.inner.tool.grpc.grpc_tools import create_grpc_channel
+
+
+class FeedbackClient(object):
+    def __init__(
+        self,
+        model_id=os.environ.get("QWAK_MODEL_ID"),
+        models_url_api=None,
+        enable_ssl=True,
+        enable_auth=True,
+    ):
+        self.account_config = UserAccountConfiguration(QwakConstants.QWAK_CONFIG_FILE)
+        self.model_id = model_id
+        self.models_url_api = (
+            models_url_api if models_url_api else self.account_config.get_models_api()
+        )
+        self.channel = create_grpc_channel(
+            url=self.models_url_api, enable_ssl=enable_ssl, enable_auth=enable_auth
+        )
+
+    def config(
+        self,
+        analytics_entity_column: str,
+        feedback_entity_column: str,
+        model_type: str,
+        feedback_config: list,
+    ):
+        feedbacks = []
+        for config in feedback_config:
+            config_map = config.split("=")
+            feedbacks.append(
+                FeedbackConfig(output_column=config_map[0], actual_tag=config_map[1])
+            )
+
+        feedback = FeedbackServiceStub(self.channel)
+        response = feedback.ConfigureFeedback(
+            ConfigureFeedbackRequest(
+                model_id=self.model_id,
+                analytics_entity_column=analytics_entity_column,
+                feedback_entity_column=feedback_entity_column,
+                feedback_config=feedbacks,
+                model_type=ConfigureFeedbackRequest.ModelType.Value(model_type.upper()),
+            )
+        )
+
+        return response
+
+    def actual(
+        self,
+        entity_name: str,
+        entity_value: str,
+        tag: str,
+        actuals: list,
+        timestamp: datetime = datetime.utcnow(),
+    ):
+        proto_timestamp = Timestamp()
+        proto_timestamp.FromDatetime(timestamp)
+        feedback = FeedbackServiceStub(self.channel)
+        feedback_response = feedback.PostFeedback(
+            ActualValuesRequest(
+                model_id=self.model_id,
+                entity=Entity(name=entity_name, value=entity_value),
+                actuals=Actuals(tag=tag, value=actuals),
+                timestamp=proto_timestamp,
+            )
+        )
+        return feedback_response

qwak_sdk/commands/models/runtime/feedback/ui.py

@@ -0,0 +1,45 @@
+import click
+
+from qwak_sdk.commands.models.runtime.feedback._logic import FeedbackClient
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("feedback", cls=QwakCommand)
+@click.option("--model-id", help="Model ID", required=True)
+@click.option(
+    "--analytics-entity-column", required=True, help="Analytics entity column name"
+)
+@click.option(
+    "--feedback-entity-column", required=True, help="Feedback entity column name"
+)
+@click.option(
+    "--model-type",
+    required=True,
+    type=click.Choice(
+        ["binary_classification", "multiclass_classification", "regression"],
+        case_sensitive=True,
+    ),
+    help="""Model type. Options: binary_classification / multiclass_classification / regression""",
+)
+@click.option(
+    "--feedback-config",
+    help="Feedback configuration. analytics_output_column=actual_tag",
+    metavar="ANALYTICS_OUTPUT_COLUMN=ACTUAL_TAG",
+    multiple=True,
+)
+def runtime_feedback(
+    model_id,
+    analytics_entity_column,
+    feedback_entity_column,
+    model_type,
+    feedback_config,
+    **kwargs,
+):
+    feedback_client = FeedbackClient(model_id=model_id)
+    response = feedback_client.config(
+        analytics_entity_column=analytics_entity_column,
+        feedback_entity_column=feedback_entity_column,
+        model_type=model_type,
+        feedback_config=feedback_config,
+    )
+    print(response)

qwak_sdk/commands/models/runtime/logs/ui.py

@@ -0,0 +1,63 @@
+import click
+
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+from qwak_sdk.tools.colors import Color
+from qwak_sdk.tools.log_handling import QwakLogHandling
+
+
+@click.command("logs", cls=QwakCommand)
+@click.option("-f", "--follow", is_flag=True, default=False, help="Follow log tail")
+@click.option(
+    "-d",
+    "--deployment-id",
+    required=False,
+    help="Runtime model Deployment ID to show logs of",
+)
+@click.option(
+    "-b",
+    "--build-id",
+    required=False,
+    help="Runtime model Build ID to show logs of",
+)
+@click.option(
+    "-s",
+    "--since",
+    required=False,
+    metavar="X [TYPE] ago",
+    help=f"Get logs from X1 [type] X2 [type]... Xn [type] ago. "
+    f"(x = INT; type = {QwakLogHandling.TIME_UNITS}) i.e. [1 day 2 hours ago]",
+)
+@click.option(
+    "-n",
+    "--number-of-results",
+    required=False,
+    type=int,
+    help="Maximum number of results per query",
+)
+@click.option(
+    "-g", "--grep", required=False, help="Filter by log content contains [expression]"
+)
+def runtime_logs(
+    follow=True,
+    deployment_id=None,
+    build_id=None,
+    since=None,
+    number_of_results=None,
+    grep=None,
+    **kwargs,
+):
+    if not deployment_id and not build_id:
+        print(
+            f"{Color.YELLOW}Please provide either a Deployment or a Build ID{Color.END}"
+        )
+        return
+
+    qwak_log_handling = QwakLogHandling()
+    qwak_log_handling.get_logs(
+        follow,
+        since,
+        number_of_results,
+        grep,
+        {"build_id": build_id, "deployment_id": deployment_id},
+        "runtime_model",
+    )

qwak_sdk/commands/models/runtime/runtime_commands_group.py

@@ -0,0 +1,21 @@
+import click
+
+from qwak_sdk.commands.models.runtime.feedback.ui import runtime_feedback
+from qwak_sdk.commands.models.runtime.logs.ui import runtime_logs
+from qwak_sdk.commands.models.runtime.traffic_update.ui import runtime_traffic_update
+from qwak_sdk.commands.models.runtime.update.ui import runtime_update
+
+
+@click.group(
+    name="runtime",
+    help="Runtime configurations for deployed models",
+)
+def runtime_commands_group():
+    # Click commands group injection
+    pass
+
+
+runtime_commands_group.add_command(runtime_feedback)
+runtime_commands_group.add_command(runtime_logs)
+runtime_commands_group.add_command(runtime_traffic_update)
+runtime_commands_group.add_command(runtime_update)

qwak_sdk/commands/models/runtime/traffic_update/_logic/execute_runtime_update_traffic.py

@@ -0,0 +1,54 @@
+from typing import Tuple
+
+from qwak.clients.administration.eco_system.client import EcosystemClient
+from qwak.clients.deployment.client import DeploymentManagementClient
+
+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.runtime.traffic_update._logic.variations import (
+    validate_requested_variations_against_existing_in_apply,
+)
+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()
+
+
+def execute_runtime_traffic_update(
+    model_id: str, from_file: str, environment_name: Tuple[str]
+):
+    deployment_client = DeploymentManagementClient()
+    ecosystem_client = EcosystemClient()
+    config: DeployConfig = config_handler(
+        config=DeployConfig,
+        from_file=from_file,
+        out_conf=False,
+        sections=("realtime",),
+        model_id=model_id,
+    )
+    requested_variations = list(
+        map(
+            create_variation_from_variation_config,
+            config.realtime.variations,
+        )
+    )
+    environment_names_to_details = ecosystem_client.get_environments_names_to_details(
+        environment_name if environment_name else config.realtime.environments
+    )
+    validate_requested_variations_against_existing_in_apply(
+        model_id,
+        requested_variations,
+        environment_names_to_details,
+        deployment_client,
+    )
+    environment_ids = [env.id for env in environment_names_to_details.values()]
+
+    deployment_client.apply_model_traffic_config(
+        model_id=model_id,
+        requested_variations=requested_variations,
+        environment_ids=environment_ids,
+    )

qwak_sdk/commands/models/runtime/traffic_update/_logic/variations.py

@@ -0,0 +1,84 @@
+from typing import Dict, List, Optional
+
+from _qwak_proto.qwak.deployment.deployment_pb2 import (
+    EnvironmentTrafficMessage,
+    Variation,
+)
+from _qwak_proto.qwak.ecosystem.v0.ecosystem_pb2 import EnvironmentDetails
+from qwak.clients.deployment.client import DeploymentManagementClient
+from qwak.exceptions import QwakException
+
+from qwak_sdk.commands.models._logic.variations import (
+    validate_percentages,
+    validate_shadow_variation,
+)
+
+
+def validate_requested_variations_against_existing_in_apply(
+    model_id: str,
+    requested_variations: List[Variation],
+    environment_names_to_details: Dict[str, EnvironmentDetails],
+    deployment_client: DeploymentManagementClient,
+):
+    model_traffic = deployment_client.get_model_traffic_config(model_id)
+    environments_traffic = dict(model_traffic.environment_to_model_traffic)
+    errors = []
+    for env_name, env_details in environment_names_to_details.items():
+        error = validate_requested_variation_in_envs_for_apply(
+            env_details, environments_traffic, requested_variations
+        )
+        if error:
+            errors.append(error)
+    if errors:
+        raise QwakException("\n".join(errors))
+
+
+def validate_requested_variation_in_envs_for_apply(
+    env_details: EnvironmentDetails,
+    environments_traffic: Dict[str, EnvironmentTrafficMessage],
+    requested_variations: List[Variation],
+) -> Optional[str]:
+    environment_traffic = environments_traffic.get(env_details.id)
+    existing_variations = environment_traffic.variations if environment_traffic else []
+    try:
+        validate_variation_for_apply(
+            existing_variations=existing_variations,
+            requested_variations=requested_variations,
+        )
+    except QwakException as e:
+        return e.message
+
+
+def validate_variation_for_apply(
+    existing_variations: List[Variation],
+    requested_variations: List[Variation],
+):
+    requested_variations_names = set(
+        map(lambda variation: variation.name, requested_variations)
+    )
+    existing_variations_names = set(
+        map(lambda variation: variation.name, 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)}. You must include all the existing variations when updating the "
+            f"model traffic {list(existing_variations_names)}"
+        )
+
+    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. You must include only the existing "
+            f"variations when updating the model traffic {list(existing_variations_names)}"
+        )
+
+    validate_percentages(requested_variations)
+    validate_shadow_variation(requested_variations)

qwak_sdk/commands/models/runtime/traffic_update/ui.py

@@ -0,0 +1,37 @@
+from typing import Tuple
+
+import click
+from qwak.exceptions import QwakException
+
+from qwak_sdk.commands.models.runtime.traffic_update._logic.execute_runtime_update_traffic import (
+    execute_runtime_traffic_update,
+)
+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("traffic_update", cls=QwakCommand)
+@click.option("-m", "--model-id", required=True, help="Model named ID")
+@click.option(
+    "--environment-name",
+    required=False,
+    type=str,
+    help="Environments to deploy on (if not specified uses your default environment)",
+    multiple=True,
+)
+@click.option(
+    "--from-file",
+    required=True,
+    help="The variations config file path",
+    type=click.Path(exists=True, resolve_path=True, dir_okay=False),
+)
+def runtime_traffic_update(
+    model_id: str, from_file: str, environment_name: Tuple[str], **kwargs
+):
+    try:
+        execute_runtime_traffic_update(model_id, from_file, environment_name)
+        logger.info(f"Successfully updated traffic for models {model_id}")
+    except Exception as e:
+        raise QwakException(f'Failed to apply traffic configurations. Error is "{e}"')

qwak_sdk/commands/models/runtime/update/_logic.py

@@ -0,0 +1,9 @@
+from qwak.clients.deployment.client import DeploymentManagementClient
+from qwak.clients.model_management import ModelsManagementClient
+
+
+def execute_runtime_update(model_id, log_level):
+    model_uuid = ModelsManagementClient().get_model_uuid(model_id)
+    DeploymentManagementClient().update_runtime_configurations(
+        model_id=model_id, model_uuid=model_uuid, log_level=log_level
+    )

qwak_sdk/commands/models/runtime/update/ui.py

@@ -0,0 +1,15 @@
+import click
+from qwak.exceptions import QwakException
+
+from qwak_sdk.commands.models.runtime.update._logic import execute_runtime_update
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("update", cls=QwakCommand)
+@click.option("-l", "--log-level", required=True, help="Log level to set.")
+@click.option("-m", "--model-id", required=True, help="Model named ID")
+def runtime_update(model_id, log_level, **kwargs):
+    try:
+        execute_runtime_update(model_id, log_level=log_level)
+    except Exception as e:
+        raise QwakException(f'Failed to update runtime configurations. Error is "{e}"')

qwak_sdk/commands/projects/create/_logic.py

@@ -0,0 +1,6 @@
+from qwak.clients.project.client import ProjectsManagementClient
+
+
+def execute(project_name: str, project_description: str):
+    projects_management = ProjectsManagementClient()
+    return projects_management.create_project(project_name, project_description)

qwak_sdk/commands/projects/create/ui.py

@@ -0,0 +1,21 @@
+import click
+
+from qwak_sdk.commands.projects.create._logic import execute as execute_create
+from qwak_sdk.commands.ui_tools import output_as_json
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("create", cls=QwakCommand)
+@click.argument("name", metavar="name", required=True)
+@click.option(
+    "--description",
+    metavar="DESCRIPTION",
+    required=False,
+    help="Project description",
+)
+def create_project(name, description, format: str = "text", *args, **kwargs):
+    response = execute_create(name, description)
+    if format == "json":
+        output_as_json(response)
+    else:
+        print(f"Project created\nproject id : {response.project.project_id}")

qwak_sdk/commands/projects/delete/_logic.py

@@ -0,0 +1,6 @@
+from qwak.clients.project.client import ProjectsManagementClient
+
+
+def execute(project_id):
+    projects_management = ProjectsManagementClient()
+    return projects_management.delete_project(project_id)

qwak_sdk/commands/projects/delete/ui.py

@@ -0,0 +1,15 @@
+import click
+from google.protobuf.json_format import MessageToJson
+
+from qwak_sdk.commands.projects.delete._logic import execute as execute_delete
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("delete", cls=QwakCommand)
+@click.option("--project-id", metavar="NAME", required=True, help="Project name")
+def delete_project(project_id, **kwargs):
+    response = execute_delete(project_id)
+    if kwargs["format"] == "json":
+        print(MessageToJson(response))
+    else:
+        print(f"Project deleted\nproject id : {project_id}")

qwak_sdk/commands/projects/list/_logic.py

@@ -0,0 +1,6 @@
+from qwak.clients.project.client import ProjectsManagementClient
+
+
+def execute():
+    projects_management = ProjectsManagementClient()
+    return projects_management.list_projects()

qwak_sdk/commands/projects/list/ui.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+
+import click
+
+from qwak_sdk.commands.projects.list._logic import execute as execute_list
+from qwak_sdk.commands.ui_tools import output_as_json, output_as_table
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+def parse_project(project):
+    return [
+        project.project_id,
+        project.project_name,
+        datetime.fromtimestamp(
+            project.created_at.seconds + project.created_at.nanos / 1e9
+        ).strftime("%A, %B %d, %Y %I:%M:%S"),
+        datetime.fromtimestamp(
+            project.last_modified_at.seconds + project.last_modified_at.nanos / 1e9
+        ).strftime("%A, %B %d, %Y %I:%M:%S"),
+    ]
+
+
+@click.command("list", cls=QwakCommand)
+def projects_list(format: str = "text", **kwargs):
+    projects_data = execute_list()
+    if format == "json":
+        output_as_json(projects_data)
+    elif format == "text":
+        columns = [
+            "Project id",
+            "Project name",
+            "Creation date",
+            "Last updated",
+            "Models count",
+        ]
+        output_as_table(projects_data.projects, parse_project, columns)

qwak_sdk/commands/projects/projects_command_group.py

@@ -0,0 +1,19 @@
+import click
+
+from qwak_sdk.commands.projects.create.ui import create_project
+from qwak_sdk.commands.projects.delete.ui import delete_project
+from qwak_sdk.commands.projects.list.ui import projects_list
+
+
+@click.group(
+    name="projects",
+    help="Commands for interacting with Qwak based project",
+)
+def projects_command_group():
+    # Intentionally left empty since this is how we inject this CLI to the general CLI group
+    pass
+
+
+projects_command_group.add_command(create_project)
+projects_command_group.add_command(projects_list)
+projects_command_group.add_command(delete_project)

qwak_sdk/commands/secrets/delete/_logic.py

@@ -0,0 +1,5 @@
+from qwak.clients.secret_service import SecretServiceClient
+
+
+def execute_delete_secret(name):
+    SecretServiceClient().delete_secret(name)

qwak_sdk/commands/secrets/delete/ui.py

@@ -0,0 +1,21 @@
+import click
+import grpc
+
+from qwak_sdk.commands.secrets.delete._logic import execute_delete_secret
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("delete", cls=QwakCommand)
+@click.option("--name", metavar="TEXT", required=True, help="The secret name")
+def delete_secret(name, **kwargs):
+    print(f"Deleting secret named '{name}'")
+    try:
+        execute_delete_secret(name)
+        print(f"Secret '{name}' has been deleted")
+    except grpc.RpcError as e:
+        if e.code() == grpc.StatusCode.NOT_FOUND:
+            print(f"Secret '{name}' does not exist")
+        else:
+            print(f"Error deleting secret. Error is {e}")
+    except Exception as e:
+        print(f"Error deleting secret. Error is {e}")

qwak_sdk/commands/secrets/get/_logic.py

@@ -0,0 +1,5 @@
+from qwak.clients.secret_service import SecretServiceClient
+
+
+def execute_get_secret(name):
+    return SecretServiceClient().get_secret(name)

qwak_sdk/commands/secrets/get/ui.py

@@ -0,0 +1,17 @@
+import click
+from qwak.exceptions import QwakNotFoundException
+
+from qwak_sdk.commands.secrets.get._logic import execute_get_secret
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("get", cls=QwakCommand)
+@click.option("--name", metavar="TEXT", required=True, help="the secret name")
+def get_secret(name, **kwargs):
+    try:
+        value = execute_get_secret(name)
+        print(value)
+    except QwakNotFoundException:
+        print(f"Secret '{name}' does not exists")
+    except Exception as e:
+        print(f"Error getting secret. Error is {e}")