qwak-sdk 0.5.102__py3-none-any.whl

qwak_sdk/commands/models/list_models/ui.py

@@ -0,0 +1,60 @@
+import click
+from _qwak_proto.qwak.models.models_pb2 import DeploymentModelStatus
+
+from qwak_sdk.commands.models.list_models._logic import list_models as _list_models
+from qwak_sdk.commands.ui_tools import output_as_json, output_as_table
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+def parse_model(model):
+    return [
+        model.model_id,
+        model.uuid,
+        model.display_name,
+        model.model_description,
+        model.project_id,
+        model.created_by,
+        model.created_at,
+        model.last_modified_by,
+        model.last_modified_at,
+        model.model_status,
+        "\n".join(
+            [f"{branch.branch_name} {branch.branch_id}" for branch in model.branches]
+        ),
+        DeploymentModelStatus.DESCRIPTOR.values_by_number[
+            model.deployment_model_status
+        ].name,
+    ]
+
+
+@click.command("list-models", cls=QwakCommand)
+@click.option("--project-id", metavar="NAME", required=True, help="Project id")
+@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 command output (choose from text, json)",
+)
+def list_models(project_id, format, **kwargs):
+    model_list_result = _list_models(project_id)
+    columns = [
+        "Model id",
+        "Model UUID",
+        "Model Name",
+        "Model Description",
+        "Project ID",
+        "Created By",
+        "Created At",
+        "Last Modified At",
+        "Last Modified By",
+        "Model Status",
+        "Branches",
+        "Deployment Status",
+    ]
+    if format == "json":
+        output_as_json(model_list_result)
+    elif format == "text":
+        output_as_table(model_list_result.models, parse_model, headers=columns)

qwak_sdk/commands/models/metadata/_logic.py

@@ -0,0 +1,5 @@
+from qwak.clients.model_management.client import ModelsManagementClient
+
+
+def list_models_metadata(project_id: str):
+    return ModelsManagementClient().list_models_metadata(project_id)

qwak_sdk/commands/models/metadata/ui.py

@@ -0,0 +1,60 @@
+import re
+
+import click
+from google.protobuf.json_format import MessageToDict
+from tabulate import tabulate
+
+from qwak_sdk.commands.models.metadata._logic import (
+    list_models_metadata as _list_models_metadata,
+)
+from qwak_sdk.commands.ui_tools import output_as_json
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+def print_text_data(metadata):
+    def dict_to_table(data, prefix=""):
+        headers = []
+        values = []
+        for key, value in data.items():
+            key = re.sub(r"(\w)([A-Z])", r"\1 \2", key).lower()
+            if isinstance(value, dict):
+                headers.append(key.title())
+                values.append(dict_to_table(value, prefix=key + ": "))
+            elif isinstance(value, list):
+                headers.append(key.title())
+                values.append(
+                    "\n".join(
+                        [
+                            dict_to_table(item, prefix=key + ": ")
+                            for item in value
+                            if isinstance(item, dict)
+                        ]
+                    )
+                )
+            else:
+                headers.append((prefix + key).title())
+                values.append(value)
+        return tabulate([values], headers=headers)
+
+    for model_metadata in metadata.model_metadata:
+        print(dict_to_table(MessageToDict(model_metadata)))
+        print("")
+
+
+@click.command("metadata", cls=QwakCommand)
+@click.option("--project-id", metavar="NAME", required=True, help="Project id")
+@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 command output (choose from text, json)",
+)
+def list_models_metadata(project_id, format, **kwargs):
+    model_list_result = _list_models_metadata(project_id)
+    if format == "json":
+        output_as_json(model_list_result)
+    elif format == "text":
+        print_text_data(model_list_result)

qwak_sdk/commands/models/models_command_group.py

@@ -0,0 +1,44 @@
+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 .describe.ui import model_describe
+from .executions.execution_commands_group import execution_commands_group
+from .init.ui import model_init
+from .list.ui import model_list
+from .list_models.ui import list_models
+from .metadata.ui import list_models_metadata
+from .runtime.runtime_commands_group import runtime_commands_group
+
+
+@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")
+models_command_group.add_command(model_describe)
+models_command_group.add_command(runtime_commands_group)
+models_command_group.add_command(list_models)
+models_command_group.add_command(list_models_metadata)

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,17 @@
+import click
+
+from qwak_sdk.commands.models.runtime.logs.ui import runtime_logs
+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_logs)
+runtime_commands_group.add_command(runtime_update)

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,9 @@
+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,68 @@
+import re
+
+import click
+from click import Argument, Context
+
+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
+
+
+def validate_name(_: Context, argument: Argument, value: str) -> str:
+    """
+    Validate that `value` is a valid project name.
+    A valid project name must:
+    - Start with a lowercase letter,
+    - Contain only lowercase letters or hyphens,
+    - End with a lowercase letter,
+    - Not be empty.
+    :param _: Unused parameter for click's callback signature.
+    :param argument: Argument provided.
+    :param value: The project name to validate.
+    :raise click.BadParameter: If the validation fails.
+    :return: The validated project name.
+    """
+    # Validate that `value`:
+    # - starts with a lowercase letter,
+    # - contains only lowercase letters or hyphens,
+    # - ends with a lowercase letter,
+    # - and is not empty.
+    if not re.fullmatch(r"[a-z](?:[a-z-]*[a-z])?", value):
+        raise click.BadParameter(
+            f"{argument.name} must be lower-cased, "
+            "start and end with a letter, and only contain letters or hyphens (-)."
+        )
+    return value
+
+
+@click.command("create", cls=QwakCommand)
+@click.argument(
+    "name", metavar="name", type=click.STRING, required=True, callback=validate_name
+)
+@click.option(
+    "--description",
+    metavar="DESCRIPTION",
+    required=False,
+    help="Project description",
+)
+@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 create_project(
+    name,
+    description,
+    format,
+    *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,24 @@
+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")
+@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 delete_project(project_id, format, **kwargs):
+    response = execute_delete(project_id)
+    if 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,45 @@
+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)
+@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 projects_list(format, **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}")

qwak_sdk/commands/secrets/secrets_commands_group.py

@@ -0,0 +1,19 @@
+import click
+
+from qwak_sdk.commands.secrets.delete.ui import delete_secret
+from qwak_sdk.commands.secrets.get.ui import get_secret
+from qwak_sdk.commands.secrets.set.ui import set_secret
+
+
+@click.group(
+    "secrets",
+    help="Commands for interacting with the secret store",
+)
+def secrets_commands_group():
+    # Click commands group injection
+    pass
+
+
+secrets_commands_group.add_command(set_secret)
+secrets_commands_group.add_command(get_secret)
+secrets_commands_group.add_command(delete_secret)

qwak_sdk/commands/secrets/set/_logic.py

@@ -0,0 +1,5 @@
+from qwak.clients.secret_service import SecretServiceClient
+
+
+def execute_set_secret(name, value):
+    SecretServiceClient().set_secret(name, value)

qwak_sdk/commands/secrets/set/ui.py

@@ -0,0 +1,16 @@
+import click
+
+from qwak_sdk.commands.secrets.set._logic import execute_set_secret
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("set", cls=QwakCommand)
+@click.option("--name", metavar="TEXT", required=True, help="the secret name")
+@click.option("--value", hide_input=True, confirmation_prompt=False, prompt=True)
+def set_secret(name, value, **kwargs):
+    print(f"Creating secret named '{name}' with value length of {len(value)}...")
+    try:
+        execute_set_secret(name, value)
+        print("Created!")
+    except Exception as e:
+        print(f"Error setting secret. Error is {e}")

qwak_sdk/commands/ui_tools.py

@@ -0,0 +1,18 @@
+from typing import Any, Callable, Iterable, List
+
+from google.protobuf.json_format import MessageToJson
+from tabulate import tabulate
+
+
+def output_as_json(data: Any):
+    print(MessageToJson(data))
+
+
+def output_as_table(
+    data_source: Iterable[Any], data_extractor: Callable, headers: List[str]
+):
+    data = []
+    for item in data_source:
+        data.append(data_extractor(item))
+
+    print(tabulate(data, headers=headers))

qwak_sdk/commands/workspaces/_logic/tools.py

@@ -0,0 +1,44 @@
+from typing import Optional
+
+from qwak.clients.workspace_manager import WorkspaceManagerClient
+from qwak.exceptions import QwakException
+
+
+def get_workspace_id_by_name(
+    workspace_name: str, workspace_manager_client: Optional[WorkspaceManagerClient]
+) -> str:
+    """
+    Args:
+        workspace_name: The name of the workspace
+        workspace_manager_client: The workspace manager client
+    Returns:
+        The id of the workspace
+    """
+    return get_workspace_by_name(
+        workspace_name=workspace_name, workspace_manager_client=workspace_manager_client
+    ).workspace_id
+
+
+def get_workspace_by_name(
+    workspace_name: str, workspace_manager_client: Optional[WorkspaceManagerClient]
+) -> str:
+    """
+    Args:
+        workspace_name: The name of the workspace
+        workspace_manager_client: The workspace manager client
+    Returns:
+        The id of the workspace
+    """
+    client = (
+        workspace_manager_client
+        if workspace_manager_client
+        else WorkspaceManagerClient()
+    )
+
+    response = client.get_workspaces()
+
+    for workspace in response.workspaces:
+        if workspace.workspace_name == workspace_name:
+            return workspace
+
+    raise QwakException(f"Failed to find workspace with name {workspace_name}")