frogml-cli 0.0.1__py3-none-any.whl

frogml_cli/__init__.py

@@ -0,0 +1,10 @@
+# fmt: off
+__author__ = '''JFrog Ltd.'''
+__version__ = '0.0.1'
+__name__ = 'frogml_cli'
+
+from frogml import wire_dependencies
+
+# fmt: on
+
+wire_dependencies()

frogml_cli/cli.py

@@ -0,0 +1,40 @@
+import click
+from packaging import version
+
+from frogml_cli import __version__ as sdk_version
+from frogml_cli.commands.alerts.alerts_commnad_group import alerts_commands_group
+from frogml_cli.commands.audience.audience_commands_group import audience_commands_group
+from frogml_cli.commands.automations.automations_commands_group import (
+    automations_commands_group,
+)
+from frogml_cli.commands.config.config_commands_group import config_commands_group
+from frogml_cli.commands.feature_store.feature_store_command_group import (
+    feature_store_commands_group,
+)
+from frogml_cli.commands.models.models_command_group import models_command_group
+from frogml_cli.commands.secrets.secrets_commands_group import secrets_commands_group
+from frogml_cli.inner.tools.logger import setup_frogml_logger
+
+version_option_kwargs = {}
+if version.parse(click.__version__) >= version.parse("8.0.0"):
+    version_option_kwargs["package_name"] = "frogml_cli"
+    version_option_kwargs["version"] = sdk_version
+
+
+def create_frogml_cli():
+    setup_frogml_logger()
+
+    @click.group()
+    @click.version_option(**version_option_kwargs)
+    def frogml_cli():
+        # This class is intentionally empty
+        pass
+
+    frogml_cli.add_command(config_commands_group)
+    frogml_cli.add_command(models_command_group)
+    frogml_cli.add_command(secrets_commands_group)
+    frogml_cli.add_command(automations_commands_group)
+    frogml_cli.add_command(feature_store_commands_group)
+    frogml_cli.add_command(audience_commands_group)
+    frogml_cli.add_command(alerts_commands_group)
+    return frogml_cli

frogml_cli/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) + "]"

frogml_cli/commands/alerts/alerts_commnad_group.py

@@ -0,0 +1,18 @@
+import click
+
+from frogml_cli.commands.alerts.delete.ui import delete_channel
+from frogml_cli.commands.alerts.list.ui import list_channels
+from frogml_cli.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)

frogml_cli/commands/alerts/delete/_logic.py

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

frogml_cli/commands/alerts/delete/ui.py

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

frogml_cli/commands/alerts/list/_logic.py

@@ -0,0 +1,23 @@
+from typing import List, Tuple
+
+from frogml.core.clients.alerts_registry import AlertingRegistryClient
+from frogml.core.clients.alerts_registry.channel import Channel
+from tabulate import tabulate
+
+from frogml_cli.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)

frogml_cli/commands/alerts/list/ui.py

@@ -0,0 +1,17 @@
+import click
+
+from frogml_cli.commands.alerts.list._logic import (
+    execute_json_format_list_channels,
+    execute_list_channels,
+)
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("list", cls=FrogMLCommand, 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())

frogml_cli/commands/alerts/register/_logic.py

@@ -0,0 +1,72 @@
+import os
+from pathlib import Path
+from typing import List
+
+from frogml.core.clients.alerts_registry import AlertingRegistryClient
+from frogml.core.clients.alerts_registry.channel import Channel
+
+from frogml_cli.inner.file_registry import extract_class_objects, list_qwak_python_files
+from frogml_cli.inner.tools.cli_tools import ask_yesno
+from frogml_cli.tools.utils import frogml_spinner
+
+FROGML_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 frogml_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(FROGML_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 frogml_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,
+    )

frogml_cli/commands/alerts/register/ui.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+import click
+
+from frogml_cli.commands.alerts.register._logic import execute_register_channel
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command(
+    "register",
+    cls=FrogMLCommand,
+    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 frogml alerts system objects are stored",
+)
+@click.option(
+    "--force",
+    "-f",
+    default=False,
+    is_flag=True,
+    metavar="FLAG",
+    help="Force register all found frogml alerts system objects",
+)
+def register_channel(path: Path, force: bool, **kwargs):
+    execute_register_channel(path, force)

frogml_cli/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 frogml._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

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

@@ -0,0 +1,30 @@
+from pathlib import Path
+from typing import Optional, Union
+
+import yaml
+
+from frogml_cli.commands.audience._logic.config.config_base import ConfigBase
+from frogml_cli.commands.audience._logic.config.v1.config_v1 import ConfigV1
+from frogml_cli.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()

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

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+from typing import List
+
+from frogml._proto.qwak.audience.v1.audience_pb2 import AudienceRoutesEntry
+
+from frogml_cli.commands.audience._logic.config.v1.conditions_config import (
+    ConditionsConfig,
+)
+from frogml_cli.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],
+        )

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

@@ -0,0 +1,59 @@
+from dataclasses import dataclass, field
+from typing import List
+
+from frogml._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

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

@@ -0,0 +1,23 @@
+from dataclasses import dataclass, field
+from typing import List
+
+from frogml._proto.qwak.audience.v1.audience_pb2 import Audience
+
+from frogml_cli.commands.audience._logic.config.config_base import ConfigBase
+from frogml_cli.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
+        ]

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

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+from frogml._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
+        )

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

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

frogml_cli/commands/audience/audience_api_dump.py

@@ -0,0 +1,86 @@
+from typing import List
+
+from frogml._proto.qwak.audience.v1.audience_pb2 import (
+    Audience,
+    AudienceEntry,
+    BinaryOperatorType,
+    UnaryOperatorType,
+)
+from google.protobuf.json_format import MessageToJson
+from tabulate import tabulate
+
+from frogml_cli.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}
+"""

frogml_cli/commands/audience/audience_commands_group.py

@@ -0,0 +1,30 @@
+import logging
+
+import click
+
+from frogml_cli.commands.audience.create.ui import create_audience_command
+from frogml_cli.commands.audience.delete.ui import delete_audience_command
+from frogml_cli.commands.audience.get.ui import get_audience_command
+from frogml_cli.commands.audience.list.ui import list_audience_command
+from frogml_cli.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)

frogml_cli/commands/audience/create/logic.py

@@ -0,0 +1,41 @@
+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
+
+
+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 FrogmlCommandException(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

frogml_cli/commands/audience/create/ui.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+import click
+
+from frogml_cli.commands.audience.create.logic import create_audience
+from frogml_cli.exceptions import FrogmlCommandException, FrogmlResourceNotFound
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("create", cls=FrogMLCommand)
+@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 (FrogmlCommandException, FrogmlResourceNotFound) as e:
+        click.echo(f"Failed to create audience, Error: {e}")
+        exit(1)

frogml_cli/commands/audience/delete/logic.py

@@ -0,0 +1,13 @@
+import grpc
+from frogml.core.clients.audience import AudienceClient
+
+from frogml_cli.exceptions import FrogmlCommandException, FrogmlResourceNotFound
+
+
+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 FrogmlResourceNotFound(e.args[0].details)
+        raise FrogmlCommandException(e.args[0].details)

frogml_cli/commands/audience/delete/ui.py

@@ -0,0 +1,17 @@
+import click
+
+from frogml_cli.commands.audience.delete.logic import delete_audience
+from frogml_cli.exceptions import FrogmlCommandException, FrogmlResourceNotFound
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+
+
+@click.command("delete", cls=FrogMLCommand)
+@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 (FrogmlCommandException, FrogmlResourceNotFound) as e:
+        click.echo(f"Failed to delete audience, Error: {e}")
+        exit(1)