qwak-sdk 0.5.102__py3-none-any.whl

qwak_sdk/__init__.py

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

qwak_sdk/cli.py

@@ -0,0 +1,79 @@
+from typing import Optional
+
+import click
+from packaging import version
+from qwak.inner.di_configuration import UserAccountConfiguration
+from qwak.inner.di_configuration.account import UserAccount
+
+from qwak_sdk import __version__ as sdk_version
+from qwak_sdk.commands.admin.admin_commands_group import admin_commands_group
+from qwak_sdk.commands.alerts.alerts_commnad_group import alerts_commands_group
+from qwak_sdk.commands.audience.audience_commands_group import audience_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.commands.workspaces.workspaces_commands_group import (
+    workspaces_commands_group,
+)
+from qwak_sdk.inner.tools.cli_tools import profile_setter_wrapper
+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"
+    version_option_kwargs["version"] = sdk_version
+
+
+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="QWAK_API_KEY",
+        required=False,
+        help="Qwak assigned API key",
+    )
+    @click.option(
+        "--environment",
+        metavar="ENVIRONMENT",
+        default="default",
+        required=False,
+        is_eager=True,
+        help="Qwak environment's name",
+    )
+    @profile_setter_wrapper
+    def set_configuration(
+        api_key: Optional[str],
+        environment: str,
+        **_,
+    ):
+        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(f"User successfully configured for the '{environment}' environment")
+
+    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)
+    qwak_cli.add_command(audience_commands_group)
+    qwak_cli.add_command(alerts_commands_group)
+    qwak_cli.add_command(workspaces_commands_group)
+    return qwak_cli

qwak_sdk/commands/_logic/tools.py

@@ -0,0 +1,6 @@
+from google.protobuf.json_format import MessageToJson
+
+
+def list_of_messages_to_json_str(list_of_proto_msgs) -> str:
+    json_msgs = [MessageToJson(proto_msg) for proto_msg in list_of_proto_msgs]
+    return "[" + ",".join(json_msgs) + "]"

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.tools.logger.logger import get_qwak_logger
+
+from qwak_sdk.commands.admin.apikeys.generate.ui import generate_apikey
+from qwak_sdk.commands.admin.apikeys.revoke.ui import revoke_apikey
+
+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.tools.logger.logger import get_qwak_logger
+
+from qwak_sdk.commands.admin.apikeys.generate._logic import execute_generate_apikey
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+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.tools.logger.logger import get_qwak_logger
+
+from qwak_sdk.commands.admin.apikeys.revoke._logic import execute_revoke_apikey
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+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/alerts/alerts_commnad_group.py

@@ -0,0 +1,18 @@
+import click
+
+from qwak_sdk.commands.alerts.delete.ui import delete_channel
+from qwak_sdk.commands.alerts.list.ui import list_channels
+from qwak_sdk.commands.alerts.register.ui import register_channel
+
+
+@click.group(
+    name="alerts",
+    help="Commands for interacting with the Qwak alerts System",
+)
+def alerts_commands_group():
+    pass
+
+
+alerts_commands_group.add_command(register_channel)
+alerts_commands_group.add_command(list_channels)
+alerts_commands_group.add_command(delete_channel)

qwak_sdk/commands/alerts/delete/_logic.py

@@ -0,0 +1,5 @@
+from qwak.clients.alerts_registry import AlertingRegistryClient
+
+
+def execute_delete_channel(name):
+    return AlertingRegistryClient().delete_alerting_channel(channel_name=name)

qwak_sdk/commands/alerts/delete/ui.py

@@ -0,0 +1,10 @@
+import click
+
+from qwak_sdk.commands.alerts.delete._logic import execute_delete_channel
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("delete", cls=QwakCommand, help="Delete a Channel by name")
+@click.argument("name")
+def delete_channel(name, **kwargs):
+    execute_delete_channel(name)

qwak_sdk/commands/alerts/list/_logic.py

@@ -0,0 +1,23 @@
+from typing import List, Tuple
+
+from qwak.clients.alerts_registry import AlertingRegistryClient
+from qwak.clients.alerts_registry.channel import Channel
+from tabulate import tabulate
+
+from qwak_sdk.commands._logic.tools import list_of_messages_to_json_str
+
+
+def execute_list_channels():
+    alerts_client = AlertingRegistryClient()
+    channels: List[Tuple[str, Channel]] = alerts_client.list_alerting_channel()
+    columns = ["id", "Name", "Type", "repr"]
+    data = []
+    for c_id, c in channels:
+        data.append([c_id, c.name, type(c.channel_conf).__name__, c.__dict__])
+    return tabulate(data, headers=columns)
+
+
+def execute_json_format_list_channels():
+    alerts_client = AlertingRegistryClient()
+    channels = alerts_client.list_alerting_channel_from_client().description
+    return list_of_messages_to_json_str(channels)

qwak_sdk/commands/alerts/list/ui.py

@@ -0,0 +1,17 @@
+import click
+
+from qwak_sdk.commands.alerts.list._logic import (
+    execute_json_format_list_channels,
+    execute_list_channels,
+)
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("list", cls=QwakCommand, help="List all alerts system channels.")
+@click.option("--json-format", is_flag=True, type=bool)
+def list_channels(json_format, **kwargs):
+    if json_format:
+        print(execute_json_format_list_channels())
+
+    else:
+        print(execute_list_channels())

qwak_sdk/commands/alerts/register/_logic.py

@@ -0,0 +1,72 @@
+import os
+from pathlib import Path
+from typing import List
+
+from qwak.clients.alerts_registry import AlertingRegistryClient
+from qwak.clients.alerts_registry.channel import Channel
+
+from qwak_sdk.inner.file_registry import extract_class_objects, list_qwak_python_files
+from qwak_sdk.inner.tools.cli_tools import ask_yesno
+from qwak_sdk.tools.utils import qwak_spinner
+
+QWAK_alerts_DELIMITER = "----------------------------------------"
+
+
+def _register_channels(qwak_python_files, alerts_client, force):
+    """
+    Register Channels
+
+    Args:
+        qwak_python_files: a list of python files containing qwak package imports
+        alerts_client: AlertingRegistryClient alerts service client
+        force: boolean determining if to force register all encountered Channel objects
+    """
+    with qwak_spinner(
+        begin_text="Looking for channels to register", print_callback=print
+    ):
+        qwak_channels: List[Channel] = extract_class_objects(qwak_python_files, Channel)
+
+    print(f"👀 Found {len(qwak_channels)} Channels")
+    for channel, source_file_path in qwak_channels:
+        channel_id, existing_channel = alerts_client.get_alerting_channel(channel.name)
+        if existing_channel:
+            if ask_yesno(
+                f"Update existing Channel '{channel.name}' from source file '{source_file_path}'?",
+                force,
+            ):
+                alerts_client.update_alerting_channel(
+                    channel_id=channel_id, channel=channel
+                )
+        else:
+            if ask_yesno(
+                f"Create new Channel '{channel.name}' from source file '{source_file_path}'?",
+                force,
+            ):
+                alerts_client.create_alerting_channel(channel)
+    print(QWAK_alerts_DELIMITER)
+
+
+def execute_register_channel(path: Path, force: bool):
+    if not path:
+        path = Path.cwd()
+    else:
+        path = Path(path)
+
+    if path.is_file():
+        qwak_python_files = [(str(path), os.path.abspath(path))]
+    elif Path.is_dir(path):
+        with qwak_spinner(
+            begin_text="Recursively looking for python files in input dir",
+            print_callback=print,
+        ) as sp:
+            qwak_python_files = list_qwak_python_files(path, sp)
+            print(qwak_python_files)
+            print(sp)
+            pass
+
+    alerts_client = AlertingRegistryClient()
+    _register_channels(
+        qwak_python_files=qwak_python_files,
+        alerts_client=alerts_client,
+        force=force,
+    )

qwak_sdk/commands/alerts/register/ui.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+import click
+
+from qwak_sdk.commands.alerts.register._logic import execute_register_channel
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command(
+    "register",
+    cls=QwakCommand,
+    help="Register all alerts system objects under the given path.",
+)
+@click.option(
+    "--path",
+    "-p",
+    type=click.Path(exists=True),
+    metavar="PATH",
+    help="Directory / module where qwak alerts system objects are stored",
+)
+@click.option(
+    "--force",
+    "-f",
+    default=False,
+    is_flag=True,
+    metavar="FLAG",
+    help="Force register all found qwak alerts system objects",
+)
+def register_channel(path: Path, force: bool, **kwargs):
+    execute_register_channel(path, force)

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

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import Audience
+
+
+@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,30 @@
+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
+from qwak_sdk.inner.tools.dataclasses_utils import create_dataclass_instance
+
+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 create_dataclass_instance(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 dataclass, field
+from typing import List
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import AudienceRoutesEntry
+
+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,
+            audience_name=self.name,
+            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,59 @@
+from dataclasses import dataclass, field
+from typing import List
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import (
+    BinaryCondition,
+    BinaryOperatorType,
+    Condition,
+    UnaryCondition,
+    UnaryOperatorType,
+)
+
+
+@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=str(self.first_operand),
+                second_operand=str(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,23 @@
+from dataclasses import dataclass, field
+from typing import List
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import Audience
+
+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,15 @@
+from dataclasses import dataclass
+
+from _qwak_proto.qwak.audience.v1.audience_pb2 import Route
+
+
+@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,9 @@
+from dataclasses import dataclass, field
+from typing import List
+
+from qwak_sdk.commands.audience._logic.config.v1.audience_config import AudienceConfig
+
+
+@dataclass
+class Spec:
+    audiences: List[AudienceConfig] = field(default_factory=list)