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

qwak_sdk/__init__.py

@@ -0,0 +1,9 @@
+# fmt: off
+__author__ = '''Qwak.ai'''
+__version__ = '0.2.20.rc0'
+
+from qwak.inner import wire_dependencies
+
+# fmt: on
+
+wire_dependencies()

qwak_sdk/cli.py

@@ -0,0 +1,51 @@
+import click
+from packaging import version
+from qwak.inner.di_configuration import UserAccountConfiguration
+from qwak.inner.di_configuration.account import UserAccount
+
+from qwak_sdk.commands.admin.admin_commands_group import admin_commands_group
+from qwak_sdk.commands.automations.automations_commands_group import (
+    automations_commands_group,
+)
+from qwak_sdk.commands.feature_store.feature_store_command_group import (
+    feature_store_commands_group,
+)
+from qwak_sdk.commands.models.models_command_group import models_command_group
+from qwak_sdk.commands.projects.projects_command_group import projects_command_group
+from qwak_sdk.commands.secrets.secrets_commands_group import secrets_commands_group
+from qwak_sdk.inner.tools.logger import setup_qwak_logger
+
+version_option_kwargs = {}
+if version.parse(click.__version__) >= version.parse("8.0.0"):
+    version_option_kwargs["package_name"] = "qwak-sdk"
+
+
+def create_qwak_cli():
+    setup_qwak_logger()
+
+    @click.group()
+    @click.version_option(**version_option_kwargs)
+    def qwak_cli():
+        # This class is intentionally empty
+        pass
+
+    @qwak_cli.command("configure", short_help="Configure the Qwak environment")
+    @click.option(
+        "--api-key", metavar="PASSWORD", required=False, help="Qwak assigned API key"
+    )
+    def set_configuration(api_key, **kwargs):
+        if api_key is None:
+            api_key = click.prompt("Please enter your API key", type=str)
+
+        account_config = UserAccountConfiguration()
+        account_config.configure_user(UserAccount(api_key=api_key))
+
+        print("User successfully configured")
+
+    qwak_cli.add_command(projects_command_group)
+    qwak_cli.add_command(models_command_group)
+    qwak_cli.add_command(secrets_commands_group)
+    qwak_cli.add_command(automations_commands_group)
+    qwak_cli.add_command(admin_commands_group)
+    qwak_cli.add_command(feature_store_commands_group)
+    return qwak_cli

qwak_sdk/commands/admin/admin_commands_group.py

@@ -0,0 +1,17 @@
+import click
+
+from qwak_sdk.commands.admin.apikeys.api_keys_commands_group import (
+    api_keys_commands_group,
+)
+
+
+@click.group(
+    name="admin",
+    help="Commands for admin operations",
+)
+def admin_commands_group():
+    # Click commands group injection
+    pass
+
+
+admin_commands_group.add_command(api_keys_commands_group)

qwak_sdk/commands/admin/apikeys/api_keys_commands_group.py

@@ -0,0 +1,17 @@
+import click
+
+from qwak_sdk.commands.admin.apikeys.generate.ui import generate_apikey
+from qwak_sdk.commands.admin.apikeys.revoke.ui import revoke_apikey
+from qwak_sdk.inner.tools.logger.logger import get_qwak_logger
+
+logger = get_qwak_logger()
+
+
+@click.group(name="api-keys", help="api keys")
+def api_keys_commands_group():
+    # Click commands group injection
+    pass
+
+
+api_keys_commands_group.add_command(generate_apikey)
+api_keys_commands_group.add_command(revoke_apikey)

qwak_sdk/commands/admin/apikeys/generate/_logic.py

@@ -0,0 +1,21 @@
+from qwak.clients.administration import SelfServiceUserClient
+from qwak.clients.administration.eco_system.client import EcosystemClient
+
+
+def execute_generate_apikey(
+    environment_name: str, user_id: str, force: bool = False
+) -> str:
+    ecosystem_client = EcosystemClient()
+    environment_name_to_environment_details_map = (
+        ecosystem_client.get_environments_names_to_details([environment_name])
+    )
+
+    user_service = SelfServiceUserClient()
+
+    return user_service.generate_apikey(
+        user_id=user_id,
+        environment_id=environment_name_to_environment_details_map.get(
+            environment_name
+        ).id,
+        force=force,
+    ).api_key

qwak_sdk/commands/admin/apikeys/generate/ui.py

@@ -0,0 +1,45 @@
+import click
+from qwak.clients.administration.self_service.client import APIKEY_ALREADY_EXISTS
+
+from qwak_sdk.commands.admin.apikeys.generate._logic import execute_generate_apikey
+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("generate", help="api keys", cls=QwakCommand)
+@click.option(
+    "--environment-name",
+    help="Environment name to generate api key for",
+    required=True,
+)
+@click.option(
+    "--user-id",
+    help="User id to generate api key for",
+    required=True,
+)
+@click.option(
+    "--force",
+    help="If override existing one. (default false)",
+    default=False,
+    is_flag=True,
+)
+def generate_apikey(user_id, environment_name, force, **kwargs):
+    logger.info(
+        f"Generating api key for user {user_id} on environment {environment_name}..."
+    )
+    try:
+        api_key = execute_generate_apikey(
+            user_id=user_id, environment_name=environment_name, force=force
+        )
+        logger.info("generated api key:")
+        logger.info(api_key)
+    except Exception as e:
+        if e.message == APIKEY_ALREADY_EXISTS:
+            logger.error(
+                "Failed to generate api key - "
+                "the api key already exists please add --force if you want to override it."
+            )
+        else:
+            logger.error(e)

qwak_sdk/commands/admin/apikeys/revoke/_logic.py

@@ -0,0 +1,22 @@
+from _qwak_proto.qwak.self_service.user.v1.user_service_pb2 import RevokeApiKeyResponse
+from qwak.clients.administration import SelfServiceUserClient
+from qwak.clients.administration.eco_system.client import EcosystemClient
+
+
+def execute_revoke_apikey(environment_name: str, user_id: str) -> bool:
+    ecosystem_client = EcosystemClient()
+    environment_name_to_environment_details_map = (
+        ecosystem_client.get_environments_names_to_details([environment_name])
+    )
+
+    user_service = SelfServiceUserClient()
+
+    return (
+        user_service.revoke_apikey(
+            user_id=user_id,
+            environment_id=environment_name_to_environment_details_map.get(
+                environment_name
+            ).id,
+        ).status
+        == RevokeApiKeyResponse.Status.REVOKED
+    )

qwak_sdk/commands/admin/apikeys/revoke/ui.py

@@ -0,0 +1,31 @@
+import click
+
+from qwak_sdk.commands.admin.apikeys.revoke._logic import execute_revoke_apikey
+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("revoke", help="api keys", cls=QwakCommand)
+@click.option(
+    "--environment-name",
+    help="Environment name to generate api key for",
+    required=True,
+)
+@click.option(
+    "--user-id",
+    help="User id to generate api key for",
+    required=True,
+)
+def revoke_apikey(user_id, environment_name, **kwargs):
+    logger.info(
+        f"Revoking api key for user {user_id} on environment {environment_name}..."
+    )
+    try:
+        if execute_revoke_apikey(user_id=user_id, environment_name=environment_name):
+            logger.info("Successfully revoked api key")
+        else:
+            logger.info("Failed to revoke api key")
+    except Exception as e:
+        logger.error(e.message)

qwak_sdk/commands/audience/_logic/config/config_base.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from dataclasses import field
+from typing import Any
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import Audience
+from pydantic.dataclasses import dataclass
+
+
+@dataclass
+class ConfigBase(ABC):
+    spec: Any
+    api_version: str = field(default="v1")
+
+    @abstractmethod
+    def to_audiences_api(self) -> Audience:
+        pass

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

@@ -0,0 +1,28 @@
+from pathlib import Path
+from typing import Optional, Union
+
+import yaml
+
+from qwak_sdk.commands.audience._logic.config.config_base import ConfigBase
+from qwak_sdk.commands.audience._logic.config.v1.config_v1 import ConfigV1
+
+VERSION_CONFIG_MAPPING = {"v1": ConfigV1}
+
+
+def parse_audience_from_yaml(
+    file_path: Optional[Union[Path, str]] = None
+) -> ConfigBase:
+    if file_path:
+        file_path_obj = Path(file_path)
+        if file_path_obj.exists():
+            audience_dict = yaml.safe_load(file_path_obj.open("r"))
+            audience_config: ConfigBase = VERSION_CONFIG_MAPPING.get(
+                audience_dict.get("api_version")
+            )
+            return audience_config(**audience_dict)
+        else:
+            raise FileNotFoundError(
+                f"Audience file {file_path_obj} definition isn't found"
+            )
+    else:
+        return ConfigV1()

qwak_sdk/commands/audience/_logic/config/v1/audience_config.py

@@ -0,0 +1,26 @@
+from dataclasses import field
+from typing import List
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import AudienceRoutesEntry
+from pydantic.dataclasses import dataclass
+
+from qwak_sdk.commands.audience._logic.config.v1.conditions_config import (
+    ConditionsConfig,
+)
+from qwak_sdk.commands.audience._logic.config.v1.route_config import RouteConfig
+
+
+@dataclass
+class AudienceConfig:
+    name: str = field(default="")
+    id: str = field(default="")
+    description: str = field(default="")
+    routes: List[RouteConfig] = field(default_factory=list)
+    conditions: ConditionsConfig = field(default_factory=ConditionsConfig)
+
+    def to_audience_route_entry(self, index: int = 0) -> AudienceRoutesEntry:
+        return AudienceRoutesEntry(
+            audience_id=self.id,
+            order=index + 1,
+            routes=[route.to_route_api() for route in self.routes],
+        )

qwak_sdk/commands/audience/_logic/config/v1/conditions_config.py

@@ -0,0 +1,60 @@
+from dataclasses import field
+from typing import List
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import (
+    BinaryCondition,
+    BinaryOperatorType,
+    Condition,
+    UnaryCondition,
+    UnaryOperatorType,
+)
+from pydantic.dataclasses import dataclass
+
+
+@dataclass
+class UnaryConditionConfig:
+    key: str
+    operator: str
+    operand: str
+
+    def to_condition_api(self) -> Condition:
+        return Condition(
+            key=self.key,
+            unary_condition=UnaryCondition(
+                operator=UnaryOperatorType.DESCRIPTOR.values_by_name[
+                    self.operator
+                ].number,
+                operand=self.operand,
+            ),
+        )
+
+
+@dataclass
+class BinaryConditionConfig:
+    key: str
+    operator: str
+    first_operand: str
+    second_operand: str
+
+    def to_condition_api(self) -> Condition:
+        return Condition(
+            key=self.key,
+            binary_condition=BinaryCondition(
+                operator=BinaryOperatorType.DESCRIPTOR.values_by_name[
+                    self.operator
+                ].number,
+                first_operand=self.first_operand,
+                second_operand=self.second_operand,
+            ),
+        )
+
+
+@dataclass
+class ConditionsConfig:
+    unary: List[UnaryConditionConfig] = field(default_factory=list)
+    binary: List[BinaryConditionConfig] = field(default_factory=list)
+
+    def to_conditions_api(self) -> List[Condition]:
+        conditions = [condition.to_condition_api() for condition in self.unary]
+        conditions.extend([condition.to_condition_api() for condition in self.binary])
+        return conditions

qwak_sdk/commands/audience/_logic/config/v1/config_v1.py

@@ -0,0 +1,24 @@
+from dataclasses import field
+from typing import List
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import Audience
+from pydantic.dataclasses import dataclass
+
+from qwak_sdk.commands.audience._logic.config.config_base import ConfigBase
+from qwak_sdk.commands.audience._logic.config.v1.spec import Spec
+
+
+@dataclass
+class ConfigV1(ConfigBase):
+    spec: Spec = field(default_factory=Spec)
+
+    def to_audiences_api(self) -> List[Audience]:
+        return [
+            Audience(
+                name=audience_config.name,
+                description=audience_config.description,
+                routes=[route.to_route_api() for route in audience_config.routes],
+                conditions=audience_config.conditions.to_conditions_api(),
+            )
+            for audience_config in self.spec.audiences
+        ]

qwak_sdk/commands/audience/_logic/config/v1/route_config.py

@@ -0,0 +1,14 @@
+from _qwak_proto.qwak.audience.v1.audience_pb2 import Route
+from pydantic.dataclasses import dataclass
+
+
+@dataclass
+class RouteConfig:
+    variation_name: str
+    weight: int
+    shadow: bool
+
+    def to_route_api(self):
+        return Route(
+            variation_name=self.variation_name, weight=self.weight, shadow=self.shadow
+        )

qwak_sdk/commands/audience/_logic/config/v1/spec.py

@@ -0,0 +1,11 @@
+from dataclasses import field
+from typing import List
+
+from pydantic.dataclasses import dataclass
+
+from qwak_sdk.commands.audience._logic.config.v1.audience_config import AudienceConfig
+
+
+@dataclass
+class Spec:
+    audiences: List[AudienceConfig] = field(default_factory=list)

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,100 @@
+from dataclasses import 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_SUM,
+    METRIC_TYPE_CPU,
+    METRIC_TYPE_GPU,
+    METRIC_TYPE_LATENCY,
+    METRIC_TYPE_MEMORY,
+    AutoScalingConfig,
+    PrometheusTrigger,
+    QuerySpec,
+    Trigger,
+    Triggers,
+)
+from pydantic.dataclasses import dataclass
+
+
+class MetricType(Enum):
+    cpu = METRIC_TYPE_CPU
+    gpu = METRIC_TYPE_GPU
+    latency = METRIC_TYPE_LATENCY
+    memory = METRIC_TYPE_MEMORY
+
+
+class AggregationType(Enum):
+    avg = AGGREGATION_TYPE_AVERAGE
+    max = AGGREGATION_TYPE_MAX
+    min = AGGREGATION_TYPE_MIN
+    sum = AGGREGATION_TYPE_SUM
+
+
+@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:
+            triggers.triggers.append(
+                Trigger(
+                    prometheus_trigger=PrometheusTrigger(
+                        query_spec=QuerySpec(
+                            metric_type=MetricType[
+                                trigger.query_spec.metric_type.lower()
+                            ].value,
+                            aggregation_type=AggregationType[
+                                trigger.query_spec.aggregation_type.lower()
+                            ].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
+
+
+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"))
+            autoscaling_config = Config
+            return autoscaling_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)