qwak-sdk 0.5.102__py3-none-any.whl

qwak_sdk/commands/audience/audience_api_dump.py

@@ -0,0 +1,86 @@
+from typing import List
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import (
+    Audience,
+    AudienceEntry,
+    BinaryOperatorType,
+    UnaryOperatorType,
+)
+from google.protobuf.json_format import MessageToJson
+from tabulate import tabulate
+
+from qwak_sdk.tools.colors import Color
+
+
+def audience_to_json(audience: Audience):
+    return MessageToJson(audience)
+
+
+def audience_to_pretty_string(audience_id: str, audience: Audience):
+    header = f"{Color.UNDERLINE + Color.BOLD}Audience {audience_id}{Color.END}"
+    details_header = f"{Color.UNDERLINE}Details{Color.END}"
+    details_table = tabulate(
+        tabular_data=[[audience.name, audience.description]],
+        headers=["name", "description"],
+        tablefmt="pretty",
+    )
+    conditions_header = f"{Color.UNDERLINE}Conditions{Color.END}"
+    conditions_binary_header = f"{Color.CYAN}Binary condition{Color.END}"
+    conditions_binary_table = tabulate(
+        tabular_data=[
+            [
+                condition.key,
+                BinaryOperatorType.DESCRIPTOR.values_by_number[
+                    condition.binary_condition.operator
+                ].name,
+                condition.binary_condition.first_operand,
+                condition.binary_condition.second_operand,
+            ]
+            for condition in audience.conditions
+            if condition.binary_condition.operator
+        ],
+        headers=["Key", "Operator", "First operand", "Second operand"],
+        tablefmt="pretty",
+    )
+    conditions_unary_header = f"{Color.CYAN}Unary condition{Color.END}"
+    conditions_unary_table = tabulate(
+        tabular_data=[
+            [
+                condition.key,
+                UnaryOperatorType.DESCRIPTOR.values_by_number[
+                    condition.unary_condition.operator
+                ].name,
+                condition.unary_condition.operand,
+            ]
+            for condition in audience.conditions
+            if condition.unary_condition.operator
+        ],
+        headers=["Key", "Operator", "Operand"],
+        tablefmt="pretty",
+    )
+
+    return f"""
+{header}
+{details_header}
+{details_table}
+
+{conditions_header}
+{conditions_unary_header}
+{conditions_unary_table}
+
+{conditions_binary_header}
+{conditions_binary_table}
+"""
+
+
+def audience_entries_to_pretty_string(audience_entries: List[AudienceEntry]) -> str:
+    header = f"{Color.BOLD + Color.UNDERLINE}Audiences{Color.END}"
+    table = tabulate(
+        tabular_data=[[entry.id, entry.audience.name] for entry in audience_entries],
+        headers=["Audience ID", "Audience Name"],
+        tablefmt="pretty",
+    )
+    return f"""
+{header}
+{table}
+"""

qwak_sdk/commands/audience/audience_commands_group.py

@@ -0,0 +1,30 @@
+import logging
+
+import click
+
+from qwak_sdk.commands.audience.create.ui import create_audience_command
+from qwak_sdk.commands.audience.delete.ui import delete_audience_command
+from qwak_sdk.commands.audience.get.ui import get_audience_command
+from qwak_sdk.commands.audience.list.ui import list_audience_command
+from qwak_sdk.commands.audience.update.ui import update_audience_command
+
+logger = logging.getLogger(__name__)
+DELIMITER = "----------------------------------------"
+
+AUTOMATION = "automation"
+
+
+@click.group(
+    name="audiences",
+    help="Manage audiences",
+)
+def audience_commands_group():
+    # Click commands group injection
+    pass
+
+
+audience_commands_group.add_command(create_audience_command)
+audience_commands_group.add_command(get_audience_command)
+audience_commands_group.add_command(list_audience_command)
+audience_commands_group.add_command(delete_audience_command)
+audience_commands_group.add_command(update_audience_command)

qwak_sdk/commands/audience/create/logic.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+from typing import Optional
+
+import grpc
+from qwak.clients.audience import AudienceClient
+
+from qwak_sdk.commands.audience._logic.config.config_base import ConfigBase
+from qwak_sdk.commands.audience._logic.config.parser import parse_audience_from_yaml
+from qwak_sdk.commands.audience._logic.config.v1.config_v1 import ConfigV1
+from qwak_sdk.exceptions import QwakCommandException
+
+
+def create_audience(
+    name: str = "",
+    description: str = "",
+    file: Optional[Path] = None,
+) -> str:
+    config = parse_audience_from_yaml(file)
+    config = merge_kw_yaml(config=config, name=name, description=description)
+    audience_api = config.to_audiences_api()[0]
+
+    try:
+        audience_id = AudienceClient().create_audience(audience=audience_api)
+    except grpc.RpcError as e:
+        raise QwakCommandException(e.args[0].details)
+
+    return audience_id
+
+
+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

qwak_sdk/commands/audience/create/ui.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+import click
+
+from qwak_sdk.commands.audience.create.logic import create_audience
+from qwak_sdk.exceptions import QwakCommandException, QwakResourceNotFound
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("create", cls=QwakCommand)
+@click.option("--name", type=str)
+@click.option("--description", type=str)
+@click.option("-f", "--file", type=click.Path(exists=True))
+def create_audience_command(name: str, description: str, file: Path, **kwargs):
+    click.echo("Creating audience")
+    try:
+        audience_id = create_audience(name=name, description=description, file=file)
+        click.echo(f"Audience ID {audience_id} created successfully")
+    except (QwakCommandException, QwakResourceNotFound) as e:
+        click.echo(f"Failed to create audience, Error: {e}")
+        exit(1)

qwak_sdk/commands/audience/delete/logic.py

@@ -0,0 +1,13 @@
+import grpc
+from qwak.clients.audience import AudienceClient
+
+from qwak_sdk.exceptions import QwakCommandException, QwakResourceNotFound
+
+
+def delete_audience(audience_id: str) -> None:
+    try:
+        AudienceClient().delete_audience(audience_id=audience_id)
+    except grpc.RpcError as e:
+        if e.args[0].code == grpc.StatusCode.NOT_FOUND:
+            raise QwakResourceNotFound(e.args[0].details)
+        raise QwakCommandException(e.args[0].details)

qwak_sdk/commands/audience/delete/ui.py

@@ -0,0 +1,17 @@
+import click
+
+from qwak_sdk.commands.audience.delete.logic import delete_audience
+from qwak_sdk.exceptions import QwakCommandException, QwakResourceNotFound
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("delete", cls=QwakCommand)
+@click.option("--audience-id", type=str)
+def delete_audience_command(audience_id: str, **kwargs):
+    click.echo(f"Deleting audience ID {audience_id}")
+    try:
+        delete_audience(audience_id)
+        click.echo(f"Audience ID {audience_id} deleted successfully")
+    except (QwakCommandException, QwakResourceNotFound) as e:
+        click.echo(f"Failed to delete audience, Error: {e}")
+        exit(1)

qwak_sdk/commands/audience/get/logic.py

@@ -0,0 +1,14 @@
+import grpc
+from _qwak_proto.qwak.audience.v1.audience_pb2 import Audience
+from qwak.clients.audience import AudienceClient
+
+from qwak_sdk.exceptions import QwakCommandException, QwakResourceNotFound
+
+
+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 QwakResourceNotFound(e.args[0].details)
+        raise QwakCommandException(e.args[0].details)

qwak_sdk/commands/audience/get/ui.py

@@ -0,0 +1,25 @@
+import click
+
+from qwak_sdk.commands.audience.audience_api_dump import (
+    audience_to_json,
+    audience_to_pretty_string,
+)
+from qwak_sdk.commands.audience.get.logic import get_audience
+from qwak_sdk.exceptions import QwakCommandException, QwakResourceNotFound
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("get", cls=QwakCommand)
+@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 (QwakCommandException, QwakResourceNotFound) as e:
+        click.echo(f"Failed to get audience, Error: {e}")
+        exit(1)

qwak_sdk/commands/audience/list/logic.py

@@ -0,0 +1,16 @@
+from typing import List
+
+import grpc
+from _qwak_proto.qwak.audience.v1.audience_pb2 import AudienceEntry
+from qwak.clients.audience import AudienceClient
+
+from qwak_sdk.exceptions import QwakCommandException, QwakResourceNotFound
+
+
+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 QwakResourceNotFound(e.args[0].details)
+        raise QwakCommandException(e.args[0].details)

qwak_sdk/commands/audience/list/ui.py

@@ -0,0 +1,26 @@
+import click
+
+from qwak_sdk.commands._logic.tools import list_of_messages_to_json_str
+from qwak_sdk.commands.audience.audience_api_dump import (
+    audience_entries_to_pretty_string,
+)
+from qwak_sdk.commands.audience.list.logic import list_audience
+from qwak_sdk.exceptions import QwakCommandException, QwakResourceNotFound
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("list", cls=QwakCommand)
+@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 (QwakCommandException, QwakResourceNotFound) as e:
+        click.echo(f"Failed to list audiences, Error: {e}")
+        exit(1)

qwak_sdk/commands/audience/update/logic.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+from typing import Optional
+
+import grpc
+from qwak.clients.audience import AudienceClient
+
+from qwak_sdk.commands.audience._logic.config.config_base import ConfigBase
+from qwak_sdk.commands.audience._logic.config.parser import parse_audience_from_yaml
+from qwak_sdk.commands.audience._logic.config.v1.config_v1 import ConfigV1
+from qwak_sdk.exceptions import QwakCommandException, QwakResourceNotFound
+
+
+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 QwakResourceNotFound(e.args[0].details)
+        raise QwakCommandException(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

qwak_sdk/commands/audience/update/ui.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+import click
+
+from qwak_sdk.commands.audience.update.logic import update_audience
+from qwak_sdk.exceptions import QwakCommandException, QwakResourceNotFound
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("update", cls=QwakCommand)
+@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 (QwakCommandException, QwakResourceNotFound) as e:
+        click.echo(f"Failed to update audience, Error: {e}")
+        exit(1)

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

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

qwak_sdk/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 _qwak_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 qwak_sdk.exceptions import QwakCommandException
+
+
+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 `QwakCommandException` is raised.
+
+        :param metric_type: The name of the metric type to retrieve.
+        :return: The corresponding `MetricType` enum.
+        :raises: QwakCommandException if the provided `metric_type` does not match any member
+        """
+
+        try:
+            return cls[metric_type.lower()]
+        except KeyError as exception:
+            raise QwakCommandException(
+                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 `QwakCommandException` is raised.
+
+        :param aggregation_type: The name of the aggregation type to retrieve
+        :return: The corresponding `AggregationType` enum.
+        :raises: QwakCommandException if the provided `aggregation_type` does not match
+        """
+        try:
+            return cls[aggregation_type.lower()]
+        except KeyError as exception:
+            raise QwakCommandException(
+                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")

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

@@ -0,0 +1,21 @@
+from pathlib import Path
+from typing import Optional, Union
+
+import yaml
+
+from qwak_sdk.commands.auto_scalling._logic.config import Config
+from qwak_sdk.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()

qwak_sdk/commands/auto_scalling/attach/_logic.py

@@ -0,0 +1,43 @@
+from typing import Dict
+
+import grpc
+from qwak.clients.autoscaling import AutoScalingClient
+
+from qwak_sdk.commands.auto_scalling._logic.config import Config
+from qwak_sdk.commands.auto_scalling._logic.config.parser import (
+    parse_autoscaling_from_yaml,
+)
+from qwak_sdk.exceptions import QwakCommandException
+
+
+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 QwakCommandException(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

qwak_sdk/commands/auto_scalling/attach/ui.py

@@ -0,0 +1,21 @@
+import click
+
+from qwak_sdk.commands.auto_scalling.attach._logic import attach_autoscaling
+from qwak_sdk.exceptions import QwakCommandException
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("attach", cls=QwakCommand)
+@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 QwakCommandException as e:
+        click.echo(f"Failed to attach autoscaling, Error: {e}")
+        exit(1)

qwak_sdk/commands/auto_scalling/autoscaling_commands_group.py

@@ -0,0 +1,15 @@
+import click
+
+from qwak_sdk.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)