frogml-cli 0.0.1__py3-none-any.whl

frogml_cli/commands/models/list_models/ui.py

@@ -0,0 +1,60 @@
+import click
+from frogml._proto.qwak.models.models_pb2 import DeploymentModelStatus
+
+from frogml_cli.commands.models.list_models._logic import list_models as _list_models
+from frogml_cli.commands.ui_tools import output_as_json, output_as_table
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+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=FrogMLCommand)
+@click.option("--project-key", metavar="NAME", required=True, help="JFrog Project key")
+@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_key, format, **kwargs):
+    model_list_result = _list_models(project_key)
+    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)

frogml_cli/commands/models/metadata/_logic.py

@@ -0,0 +1,12 @@
+from frogml._proto.qwak.projects.projects_pb2 import GetProjectResponse
+from frogml.core.clients.model_management.client import ModelsManagementClient
+from frogml.core.clients.project.client import ProjectsManagementClient
+
+
+def list_models_metadata(project_key: str):
+    project_response: GetProjectResponse = ProjectsManagementClient().get_project(
+        project_name=project_key
+    )
+    project_id: str = project_response.project.spec.project_id
+
+    return ModelsManagementClient().list_models_metadata(project_id)

frogml_cli/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 frogml_cli.commands.models.metadata._logic import (
+    list_models_metadata as _list_models_metadata,
+)
+from frogml_cli.commands.ui_tools import output_as_json
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+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=FrogMLCommand)
+@click.option("--project-key", metavar="NAME", required=True, help="JFrog Project key")
+@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_key, format, **kwargs):
+    model_list_result = _list_models_metadata(project_key)
+    if format == "json":
+        output_as_json(model_list_result)
+    elif format == "text":
+        print_text_data(model_list_result)

frogml_cli/commands/models/models_command_group.py

@@ -0,0 +1,44 @@
+import click
+
+from frogml_cli.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 Frogml 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)

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

@@ -0,0 +1,63 @@
+import click
+
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+from frogml_cli.tools.colors import Color
+from frogml_cli.tools.log_handling import FrogmlLogHandling
+
+
+@click.command("logs", cls=FrogMLCommand)
+@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 = {FrogmlLogHandling.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
+
+    frogml_log_handling = FrogmlLogHandling()
+    frogml_log_handling.get_logs(
+        follow,
+        since,
+        number_of_results,
+        grep,
+        {"build_id": build_id, "deployment_id": deployment_id},
+        "runtime_model",
+    )

frogml_cli/commands/models/runtime/runtime_commands_group.py

@@ -0,0 +1,17 @@
+import click
+
+from frogml_cli.commands.models.runtime.logs.ui import runtime_logs
+from frogml_cli.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)

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

@@ -0,0 +1,9 @@
+from frogml.core.clients.deployment.client import DeploymentManagementClient
+from frogml.core.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
+    )

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

@@ -0,0 +1,17 @@
+import click
+from frogml.core.exceptions import FrogmlException
+
+from frogml_cli.commands.models.runtime.update._logic import execute_runtime_update
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("update", cls=FrogMLCommand)
+@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 FrogmlException(
+            f'Failed to update runtime configurations. Error is "{e}"'
+        )

frogml_cli/commands/secrets/delete/_logic.py

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

frogml_cli/commands/secrets/delete/ui.py

@@ -0,0 +1,21 @@
+import click
+import grpc
+
+from frogml_cli.commands.secrets.delete._logic import execute_delete_secret
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("delete", cls=FrogMLCommand)
+@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}")

frogml_cli/commands/secrets/get/_logic.py

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

frogml_cli/commands/secrets/get/ui.py

@@ -0,0 +1,17 @@
+import click
+from frogml.core.exceptions import FrogmlNotFoundException
+
+from frogml_cli.commands.secrets.get._logic import execute_get_secret
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("get", cls=FrogMLCommand)
+@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 FrogmlNotFoundException:
+        print(f"Secret '{name}' does not exists")
+    except Exception as e:
+        print(f"Error getting secret. Error is {e}")

frogml_cli/commands/secrets/secrets_commands_group.py

@@ -0,0 +1,19 @@
+import click
+
+from frogml_cli.commands.secrets.delete.ui import delete_secret
+from frogml_cli.commands.secrets.get.ui import get_secret
+from frogml_cli.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)

frogml_cli/commands/secrets/set/_logic.py

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

frogml_cli/commands/secrets/set/ui.py

@@ -0,0 +1,16 @@
+import click
+
+from frogml_cli.commands.secrets.set._logic import execute_set_secret
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("set", cls=FrogMLCommand)
+@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}")

frogml_cli/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))

frogml_cli/exceptions/__init__.py

@@ -0,0 +1,14 @@
+from frogml.core.exceptions import (
+    FrogmlGeneralBuildException,
+    FrogmlSuggestionException,
+)
+
+from .frogml_command_exception import FrogmlCommandException
+from .frogml_resource_not_found import FrogmlResourceNotFound
+
+__all__ = [
+    "FrogmlGeneralBuildException",
+    "FrogmlSuggestionException",
+    "FrogmlResourceNotFound",
+    "FrogmlCommandException",
+]

frogml_cli/exceptions/frogml_command_exception.py

@@ -0,0 +1,2 @@
+class FrogmlCommandException(Exception):
+    pass

frogml_cli/exceptions/frogml_deploy_new_build_failed.py

@@ -0,0 +1,5 @@
+from frogml.core.exceptions import FrogmlSuggestionException
+
+
+class FrogmlDeployNewBuildFailedException(FrogmlSuggestionException):
+    pass

frogml_cli/exceptions/frogml_resource_not_found.py

@@ -0,0 +1,2 @@
+class FrogmlResourceNotFound(Exception):
+    pass

frogml_cli/inner/file_registry.py

@@ -0,0 +1,98 @@
+import importlib.util
+import os
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+from typing import List, Tuple
+
+from yaspin.core import Yaspin
+
+
+def list_qwak_python_files(path: Path, sp: Yaspin) -> List[Tuple[str, str]]:
+    """
+    Helper function which finds python files with qwak imports in a given module
+
+    Args:
+        path: path to a directory
+        sp: spinner object, used to print
+    Returns:
+        List of python files which use the Frogml cli
+    """
+
+    file_paths = []
+    if Path.is_dir(path):
+        for object_path in path.glob("**/*.py"):
+            try:
+                if not object_path.is_file():
+                    continue
+                mod_name, file_ext = os.path.splitext(object_path.name)
+                if file_ext != ".py" or mod_name == "setup":
+                    continue
+
+                with object_path.open("rb") as fp:
+                    content = fp.read()
+                    contains_qwak_feature = all(
+                        [token in content for token in (b"frogml")]
+                    )
+
+                if not contains_qwak_feature:
+                    continue
+
+                with _add_to_python_path(object_path):
+                    # Test that the file can be imported cleanly
+                    spec = importlib.util.spec_from_file_location(mod_name, object_path)
+                    if not spec:
+                        sp.write(f"Could not load file: {object_path}. Skipping.")
+                        continue
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
+
+                    file_paths.append((mod_name, object_path))
+            except Exception as e:
+                sp.write(
+                    f"Got an error trying to handle the file {object_path}, error is: {e}. Skipping."
+                )
+    return file_paths
+
+
+def extract_class_objects(python_files, clazz):
+    """
+    Helper function which given a list of python files extracts objects of the type `clazz`
+
+    Args
+        python_files: list of python files
+        clazz: class object which its instances should be extracted
+    Returns
+        list of extracted objects of type clazz from the given python files
+    """
+    clazz_objects = []
+    for mod, file in python_files:
+        with _add_to_python_path(Path(file)):
+            spec = importlib.util.spec_from_file_location(mod, file)
+            if not spec:
+                continue
+
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            for feature in list(module.__dict__.values()):
+                if isinstance(feature, clazz):
+                    clazz_objects.append((feature, file))
+
+    return clazz_objects
+
+
+@contextmanager
+def _add_to_python_path(path: Path):
+    """
+    Helper function - context adding path to python path and then remove it
+
+    Args
+        path: path of file or folder to add to python path, in case of file adds the containing folder
+    Returns
+    """
+    try:
+        folder = str(path.parent) if path.is_file() else str(path)
+        sys.path.append(folder)
+        yield
+    finally:
+        sys.path.remove(folder)