frogml-cli 0.0.1__py3-none-any.whl

frogml_cli/commands/audience/get/logic.py

@@ -0,0 +1,14 @@
+import grpc
+from frogml._proto.qwak.audience.v1.audience_pb2 import Audience
+from frogml.core.clients.audience import AudienceClient
+
+from frogml_cli.exceptions import FrogmlCommandException, FrogmlResourceNotFound
+
+
+def get_audience(audience_id: str) -> Audience:
+    try:
+        return AudienceClient().get_audience(audience_id=audience_id)
+    except grpc.RpcError as e:
+        if e.args[0].code == grpc.StatusCode.NOT_FOUND:
+            raise FrogmlResourceNotFound(e.args[0].details)
+        raise FrogmlCommandException(e.args[0].details)

frogml_cli/commands/audience/get/ui.py

@@ -0,0 +1,25 @@
+import click
+
+from frogml_cli.commands.audience.audience_api_dump import (
+    audience_to_json,
+    audience_to_pretty_string,
+)
+from frogml_cli.commands.audience.get.logic import get_audience
+from frogml_cli.exceptions import FrogmlCommandException, FrogmlResourceNotFound
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("get", cls=FrogMLCommand)
+@click.option("--audience-id", type=str)
+@click.option("--json-format", is_flag=True, type=bool)
+def get_audience_command(audience_id: str, json_format: bool, **kwargs):
+    click.echo(f"Getting audience {audience_id}")
+    try:
+        audience = get_audience(audience_id)
+        if json_format:
+            click.echo(audience_to_json(audience))
+        else:
+            click.echo(audience_to_pretty_string(audience_id, audience))
+    except (FrogmlCommandException, FrogmlResourceNotFound) as e:
+        click.echo(f"Failed to get audience, Error: {e}")
+        exit(1)

frogml_cli/commands/audience/list/logic.py

@@ -0,0 +1,16 @@
+from typing import List
+
+import grpc
+from frogml._proto.qwak.audience.v1.audience_pb2 import AudienceEntry
+from frogml.core.clients.audience import AudienceClient
+
+from frogml_cli.exceptions import FrogmlCommandException, FrogmlResourceNotFound
+
+
+def list_audience() -> List[AudienceEntry]:
+    try:
+        return AudienceClient().list_audience()
+    except grpc.RpcError as e:
+        if e.args[0].code == grpc.StatusCode.NOT_FOUND:
+            raise FrogmlResourceNotFound(e.args[0].details)
+        raise FrogmlCommandException(e.args[0].details)

frogml_cli/commands/audience/list/ui.py

@@ -0,0 +1,26 @@
+import click
+
+from frogml_cli.commands._logic.tools import list_of_messages_to_json_str
+from frogml_cli.commands.audience.audience_api_dump import (
+    audience_entries_to_pretty_string,
+)
+from frogml_cli.commands.audience.list.logic import list_audience
+from frogml_cli.exceptions import FrogmlCommandException, FrogmlResourceNotFound
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("list", cls=FrogMLCommand)
+@click.option("--json-format", is_flag=True, type=bool)
+def list_audience_command(json_format: bool, **kwargs):
+    try:
+        audience_entries = list_audience()
+        if json_format:
+            click.echo(list_of_messages_to_json_str(audience_entries))
+        else:
+            click.echo("Getting audiences")
+            click.echo(
+                audience_entries_to_pretty_string(audience_entries=audience_entries)
+            )
+    except (FrogmlCommandException, FrogmlResourceNotFound) as e:
+        click.echo(f"Failed to list audiences, Error: {e}")
+        exit(1)

frogml_cli/commands/audience/update/logic.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+from typing import Optional
+
+import grpc
+from frogml.core.clients.audience import AudienceClient
+
+from frogml_cli.commands.audience._logic.config.config_base import ConfigBase
+from frogml_cli.commands.audience._logic.config.parser import parse_audience_from_yaml
+from frogml_cli.commands.audience._logic.config.v1.config_v1 import ConfigV1
+from frogml_cli.exceptions import FrogmlCommandException, FrogmlResourceNotFound
+
+
+def update_audience(
+    audience_id: str, name: str = "", description: str = "", file: Optional[Path] = None
+) -> None:
+    config = parse_audience_from_yaml(file)
+    config = merge_kw_yaml(config=config, name=name, description=description)
+    audience_api = config.to_audiences_api()[0]
+
+    try:
+        AudienceClient().update_audience(audience_id=audience_id, audience=audience_api)
+    except grpc.RpcError as e:
+        if e.args[0].code == grpc.StatusCode.NOT_FOUND:
+            raise FrogmlResourceNotFound(e.args[0].details)
+        raise FrogmlCommandException(e.args[0].details)
+
+
+def merge_kw_yaml(
+    config: ConfigBase, name: str = "", description: str = ""
+) -> ConfigBase:
+    if isinstance(config, ConfigV1):
+        if name:
+            config.spec.audiences[0].name = name
+        if description:
+            config.spec.audiences[0].description = description
+
+    return config

frogml_cli/commands/audience/update/ui.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+import click
+
+from frogml_cli.commands.audience.update.logic import update_audience
+from frogml_cli.exceptions import FrogmlCommandException, FrogmlResourceNotFound
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("update", cls=FrogMLCommand)
+@click.option("--audience-id", type=str)
+@click.option("--name", type=str)
+@click.option("--description", type=str)
+@click.option("-f", "--file", type=click.Path(exists=True))
+def update_audience_command(
+    audience_id: str, name: str, description: str, file: Path, **kwargs
+):
+    click.echo(f"Updating audience ID {audience_id}")
+    try:
+        update_audience(
+            audience_id=audience_id, name=name, description=description, file=file
+        )
+        click.echo(f"Audience ID {audience_id} updated successfully")
+    except (FrogmlCommandException, FrogmlResourceNotFound) as e:
+        click.echo(f"Failed to update audience, Error: {e}")
+        exit(1)

frogml_cli/commands/auto_scalling/_logic/config/__init__.py

@@ -0,0 +1,3 @@
+from .config import Config
+
+__all__ = ["Config"]

frogml_cli/commands/auto_scalling/_logic/config/config.py

@@ -0,0 +1,152 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List
+
+from frogml._proto.qwak.auto_scaling.v1.auto_scaling_pb2 import (
+    AGGREGATION_TYPE_AVERAGE,
+    AGGREGATION_TYPE_MAX,
+    AGGREGATION_TYPE_MIN,
+    AGGREGATION_TYPE_P50,
+    AGGREGATION_TYPE_P90,
+    AGGREGATION_TYPE_P95,
+    AGGREGATION_TYPE_P99,
+    AGGREGATION_TYPE_SUM,
+    METRIC_TYPE_CPU,
+    METRIC_TYPE_ERROR_RATE,
+    METRIC_TYPE_GPU,
+    METRIC_TYPE_LATENCY,
+    METRIC_TYPE_MEMORY,
+    METRIC_TYPE_THROUGHPUT,
+    AutoScalingConfig,
+    PrometheusTrigger,
+    QuerySpec,
+    Trigger,
+    Triggers,
+)
+
+from frogml_cli.exceptions import FrogmlCommandException
+
+
+class MetricType(Enum):
+    cpu = METRIC_TYPE_CPU
+    gpu = METRIC_TYPE_GPU
+    latency = METRIC_TYPE_LATENCY
+    memory = METRIC_TYPE_MEMORY
+    throughput = METRIC_TYPE_THROUGHPUT
+    error_rate = METRIC_TYPE_ERROR_RATE
+
+    @classmethod
+    def get_metric_type(cls, metric_type: str) -> "MetricType":
+        """
+        Converts a string representation of a metric type to its corresponding `MetricType` enum.
+        The method performs a case-insensitive lookup. If the provided metric type does not exist
+        in the `MetricType` enum, a `FrogmlCommandException` is raised.
+
+        :param metric_type: The name of the metric type to retrieve.
+        :return: The corresponding `MetricType` enum.
+        :raises: FrogmlCommandException if the provided `metric_type` does not match any member
+        """
+
+        try:
+            return cls[metric_type.lower()]
+        except KeyError as exception:
+            raise FrogmlCommandException(
+                f"The metric type {metric_type} doesn't exist"
+            ) from exception
+
+
+class AggregationType(Enum):
+    avg = AGGREGATION_TYPE_AVERAGE
+    max = AGGREGATION_TYPE_MAX
+    min = AGGREGATION_TYPE_MIN
+    sum = AGGREGATION_TYPE_SUM
+    p50 = AGGREGATION_TYPE_P50
+    p90 = AGGREGATION_TYPE_P90
+    p95 = AGGREGATION_TYPE_P95
+    p99 = AGGREGATION_TYPE_P99
+
+    @classmethod
+    def get_aggregation_type(cls, aggregation_type: str) -> "AggregationType":
+        """
+        Converts a string representation of an aggregation type to its corresponding `AggregationType` enum.
+        The method performs a case-insensitive lookup. If the provided aggregation type does not exist
+        in the `AggregationType` enum, a `FrogmlCommandException` is raised.
+
+        :param aggregation_type: The name of the aggregation type to retrieve
+        :return: The corresponding `AggregationType` enum.
+        :raises: FrogmlCommandException if the provided `aggregation_type` does not match
+        """
+        try:
+            return cls[aggregation_type.lower()]
+        except KeyError as exception:
+            raise FrogmlCommandException(
+                f"The aggregation type {aggregation_type} doesn't exist"
+            ) from exception
+
+
+@dataclass
+class AutoScaling:
+    @dataclass
+    class Triggers:
+        @dataclass
+        class PrometheusTrigger:
+            @dataclass
+            class QuerySpec:
+                metric_type: str = field(default=None)
+                aggregation_type: str = field(default=None)
+                time_period: int = field(default=None)
+                error_code: str = field(default=None)
+
+            query_spec: QuerySpec = field(default=QuerySpec)
+            threshold: int = field(default=None)
+
+        prometheus_trigger: List[PrometheusTrigger] = field(default_factory=list)
+
+    min_replica_count: int = field(default=None)
+    max_replica_count: int = field(default=None)
+    polling_interval: int = field(default=None)
+    cool_down_period: int = field(default=None)
+    triggers: Triggers = field(default_factory=Triggers)
+
+    def to_autoscaling_api(self) -> AutoScalingConfig:
+        triggers = Triggers()
+        for trigger in self.triggers.prometheus_trigger:
+            metric_type: MetricType = MetricType.get_metric_type(
+                trigger.query_spec.metric_type
+            )
+            aggregation_type: AggregationType = AggregationType.get_aggregation_type(
+                trigger.query_spec.aggregation_type
+            )
+            triggers.triggers.append(
+                Trigger(
+                    prometheus_trigger=PrometheusTrigger(
+                        query_spec=QuerySpec(
+                            metric_type=metric_type.value,
+                            aggregation_type=aggregation_type.value,
+                            time_period=trigger.query_spec.time_period,
+                            error_code=trigger.query_spec.error_code,
+                        ),
+                        threshold=trigger.threshold,
+                    )
+                )
+            )
+        return AutoScalingConfig(
+            min_replica_count=self.min_replica_count,
+            max_replica_count=self.max_replica_count,
+            polling_interval=self.polling_interval,
+            cool_down_period=self.cool_down_period,
+            triggers=triggers,
+        )
+
+
+@dataclass
+class Spec:
+    model_id: str = field(default="")
+    variation_name: str = field(default="")
+    auto_scaling: AutoScaling = field(default=AutoScaling)
+
+
+@dataclass
+class Config:
+    spec: Spec = field(default=Spec)
+    api_version: str = field(default="v1")

frogml_cli/commands/auto_scalling/_logic/config/parser.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+from typing import Optional, Union
+
+import yaml
+
+from frogml_cli.commands.auto_scalling._logic.config import Config
+from frogml_cli.inner.tools.dataclasses_utils import create_dataclass_instance
+
+
+def parse_autoscaling_from_yaml(file_path: Optional[Union[Path, str]] = None) -> Config:
+    if file_path:
+        file_obj = Path(file_path)
+        if file_obj.exists():
+            autoscaling_dict = yaml.safe_load(file_obj.open("r"))
+            return create_dataclass_instance(Config, autoscaling_dict)
+        else:
+            raise FileNotFoundError(
+                f"autoscaling file {file_obj} definition isn't found"
+            )
+    else:
+        return Config()

frogml_cli/commands/auto_scalling/attach/_logic.py

@@ -0,0 +1,43 @@
+from typing import Dict
+
+import grpc
+from frogml.core.clients.autoscaling import AutoScalingClient
+
+from frogml_cli.commands.auto_scalling._logic.config import Config
+from frogml_cli.commands.auto_scalling._logic.config.parser import (
+    parse_autoscaling_from_yaml,
+)
+from frogml_cli.exceptions import FrogmlCommandException
+
+
+def attach_autoscaling(model_id: str, variation_name: str, file: str) -> Dict[str, str]:
+    try:
+        config = parse_autoscaling_from_yaml(file)
+        config = merge_kw_yaml(
+            config=config, model_id=model_id, variation_name=variation_name
+        )
+        response = AutoScalingClient().attach_autoscaling(
+            model_id=config.spec.model_id,
+            variation_name=config.spec.variation_name,
+            auto_scaling_config=config.spec.auto_scaling.to_autoscaling_api(),
+        )
+        return {
+            "autoscaling_id": response.auto_scaling_id,
+            "model_id": config.spec.model_id,
+            "variation_name": config.spec.variation_name,
+        }
+    except grpc.RpcError as e:
+        raise FrogmlCommandException(e.args[0].details)
+
+
+def merge_kw_yaml(
+    config: Config,
+    model_id: str = "",
+    variation_name: str = "",
+) -> Config:
+    if model_id:
+        config.spec.model_id = model_id
+    if variation_name:
+        config.spec.variation_name = variation_name
+
+    return config

frogml_cli/commands/auto_scalling/attach/ui.py

@@ -0,0 +1,21 @@
+import click
+
+from frogml_cli.commands.auto_scalling.attach._logic import attach_autoscaling
+from frogml_cli.exceptions import FrogmlCommandException
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("attach", cls=FrogMLCommand)
+@click.option("-m", "--model-id", required=False, help="Model named ID")
+@click.option("-v", "--variation-name", required=False, help="Model variation name")
+@click.option("-f", "--file", required=True, type=click.Path(exists=True))
+def attach(model_id: str, variation_name: str, file: str, **kwargs):
+    click.echo("Attaching autoscaling configuration")
+    try:
+        response = attach_autoscaling(model_id, variation_name, file)
+        click.echo(
+            f"Successfully configured autoscaling. model: {response['model_id']}, variation: {response['variation_name']}"
+        )
+    except FrogmlCommandException as e:
+        click.echo(f"Failed to attach autoscaling, Error: {e}")
+        exit(1)

frogml_cli/commands/auto_scalling/autoscaling_commands_group.py

@@ -0,0 +1,15 @@
+import click
+
+from frogml_cli.commands.auto_scalling.attach.ui import attach
+
+
+@click.group(
+    name="autoscaling",
+    help="Manage autoscaling",
+)
+def autoscaling_commands_group():
+    # Click commands group injection
+    pass
+
+
+autoscaling_commands_group.add_command(attach)

frogml_cli/commands/automations/automations_commands_group.py

@@ -0,0 +1,30 @@
+import logging
+
+import click
+
+from frogml_cli.commands.automations.delete.ui import delete
+from frogml_cli.commands.automations.executions.executions_commands_group import (
+    executions_command_group,
+)
+from frogml_cli.commands.automations.list.ui import list_automations
+from frogml_cli.commands.automations.register.ui import register
+
+logger = logging.getLogger(__name__)
+DELIMITER = "----------------------------------------"
+
+AUTOMATION = "automation"
+
+
+@click.group(
+    name="automations",
+    help="Commands for interacting with the Qwak Automations",
+)
+def automations_commands_group():
+    # Click commands group injection
+    pass
+
+
+automations_commands_group.add_command(delete)
+automations_commands_group.add_command(list_automations)
+automations_commands_group.add_command(register)
+automations_commands_group.add_command(executions_command_group)

frogml_cli/commands/automations/delete/_logic.py

@@ -0,0 +1,6 @@
+from frogml.core.clients.automation_management.client import AutomationsManagementClient
+
+
+def delete_automation(automation_id: str):
+    client = AutomationsManagementClient()
+    return client.delete_automation(automation_id=automation_id)

frogml_cli/commands/automations/delete/ui.py

@@ -0,0 +1,23 @@
+import click
+
+from frogml_cli.commands.automations.delete._logic import delete_automation
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command(
+    "delete",
+    help="Delete an automation object",
+    cls=FrogMLCommand,
+)
+@click.option(
+    "--automation-id",
+    type=str,
+    metavar="ID",
+    help="The automation id to delete",
+)
+def delete(automation_id: str, **kwargs):
+    deleted = delete_automation(automation_id=automation_id)
+    if deleted:
+        print(f"Automation {automation_id} deleted successfully")
+    else:
+        print(f"Automation {automation_id} was not found")

frogml_cli/commands/automations/executions/executions_commands_group.py

@@ -0,0 +1,14 @@
+import click
+
+from frogml_cli.commands.automations.executions.list.ui import list_executions
+
+DELIMITER = "----------------------------------------"
+
+
+@click.group(name="executions", help=" automation executions")
+def executions_command_group():
+    # Click commands group injection
+    pass
+
+
+executions_command_group.add_command(list_executions)

frogml_cli/commands/automations/executions/list/_logic.py

@@ -0,0 +1,8 @@
+from typing import List
+
+from frogml.core.automations.automation_executions import AutomationExecution
+from frogml.core.clients.automation_management.client import AutomationsManagementClient
+
+
+def execute_list_executions(automation_id: str) -> List[AutomationExecution]:
+    return AutomationsManagementClient().list_executions(automation_id)

frogml_cli/commands/automations/executions/list/ui.py

@@ -0,0 +1,27 @@
+import click
+
+from frogml_cli.commands.automations.executions.list._logic import (
+    execute_list_executions,
+)
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+DELIMITER = "----------------------------------------"
+
+
+@click.command(
+    "list",
+    help="List all executions for a specific automation",
+    cls=FrogMLCommand,
+)
+@click.option(
+    "--automation-id",
+    type=str,
+    metavar="ID",
+    required=True,
+    help="The automation id to list its executions",
+)
+def list_executions(automation_id: str, **kwargs):
+    executions_list = execute_list_executions(automation_id)
+    for execution in executions_list:
+        print(execution)
+        print(DELIMITER)

frogml_cli/commands/automations/list/_logic.py

@@ -0,0 +1,36 @@
+from frogml.core.clients.automation_management.client import AutomationsManagementClient
+from tabulate import tabulate
+
+from frogml_cli.commands._logic.tools import list_of_messages_to_json_str
+
+COLUMNS = ["Id", "Name", "Model id", "Type", "Status", "Last updated", "Updated by"]
+
+
+def execute_list_automations():
+    client = AutomationsManagementClient()
+    automations_list = client.list_automations()
+    data = []
+    for automation in automations_list:
+        data.append(
+            [
+                automation.id,
+                automation.name,
+                automation.model_id,
+                automation.action.__class__.__name__,
+                _map_automation_status(automation.is_enabled),
+                automation.create_audit.date,
+                automation.create_audit.user_id,
+            ]
+        )
+
+    return tabulate(data, headers=COLUMNS)
+
+
+def execute_list_json_automations() -> str:
+    client = AutomationsManagementClient()
+    automations = client.get_list_automations_from_server()
+    return list_of_messages_to_json_str(automations)
+
+
+def _map_automation_status(status: bool) -> str:
+    return "Active" if status else "Inactive"

frogml_cli/commands/automations/list/ui.py

@@ -0,0 +1,21 @@
+import click
+
+from frogml_cli.commands.automations.list._logic import (
+    execute_list_automations,
+    execute_list_json_automations,
+)
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command(
+    "list",
+    help="List all automations",
+    cls=FrogMLCommand,
+)
+@click.option("--json-format", is_flag=True, type=bool)
+def list_automations(json_format: bool, **kwargs):
+    if json_format:
+        click.echo(execute_list_json_automations())
+
+    else:
+        click.echo(execute_list_automations())

frogml_cli/commands/automations/register/_logic.py

@@ -0,0 +1,43 @@
+from typing import List
+
+from frogml.core.automations import Automation
+from frogml.core.clients.automation_management.client import AutomationsManagementClient
+
+from frogml_cli.inner.file_registry import extract_class_objects
+from frogml_cli.inner.tools.cli_tools import ask_yesno
+from frogml_cli.tools.utils import frogml_spinner
+
+DELIMITER = "----------------------------------------"
+
+
+def register_automations(qwak_python_files: List[str], force: bool):
+    """
+    Register Automation Entities Objects
+
+    Args:
+        qwak_python_files: a list of python files containing qwak package imports
+        force: to force
+    """
+    with frogml_spinner(
+        begin_text="Finding Automations to register", print_callback=print
+    ):
+        qwak_automations: List[Automation] = extract_class_objects(
+            qwak_python_files, Automation
+        )
+    client = AutomationsManagementClient()
+    print(f"Found {len(qwak_automations)} Automations")
+    for automation, source_file_path in qwak_automations:
+        existing_automation = client.get_automation_by_name(automation.name)
+        if existing_automation:
+            if ask_yesno(
+                f"Update existing Automation '{automation.name}' from source file '{source_file_path}'?",
+                force,
+            ):
+                client.update_automation(existing_automation.id, automation.to_proto())
+        else:
+            if ask_yesno(
+                f"Create new Automation '{automation.name}' from source file '{source_file_path}'?",
+                force,
+            ):
+                client.create_automation(automation.to_proto())
+    print(DELIMITER)