agenta 0.36.3__py3-none-any.whl → 0.36.5__py3-none-any.whl

agenta/cli/helper.py

@@ -1,202 +0,0 @@
-import os
-import sys
-import toml
-import click
-import questionary
-from pathlib import Path
-from typing import Any, List, MutableMapping
-from agenta.client.api_models import AppVariant
-
-
-from typing import Any, Optional
-from pathlib import Path
-import toml
-
-from agenta.client.backend.client import AgentaApi
-
-BACKEND_URL_SUFFIX = os.environ.get("BACKEND_URL_SUFFIX", "api")
-POSTHOG_KEY = os.environ.get(
-    "POSTHOG_KEY", "phc_hmVSxIjTW1REBHXgj2aw4HW9X6CXb6FzerBgP9XenC7"
-)
-
-
-def get_global_config(var_name: str) -> Optional[Any]:
-    """
-    Get the value of a global configuration variable.
-
-    Args:
-        var_name: the name of the variable to get
-
-    Returns:
-        the value of the variable, or None if it doesn't exist
-    """
-    agenta_dir = Path.home() / ".agenta"
-    if not agenta_dir.exists():
-        return None
-    agenta_config_file = agenta_dir / "config.toml"
-    if not agenta_config_file.exists():
-        return None
-    global_config = toml.load(agenta_config_file)
-    if var_name not in global_config:
-        return None
-    return global_config[var_name]
-
-
-def set_global_config(var_name: str, var_value: Any) -> None:
-    """
-    Set the value of a global configuration variable.
-
-    Args:
-        var_name: the name of the variable to set
-        var_value: the value to set the variable to
-    """
-    agenta_dir = Path.home() / ".agenta"
-    if not agenta_dir.exists():
-        agenta_dir.mkdir(exist_ok=True)
-    agenta_config_file = agenta_dir / "config.toml"
-    if not agenta_config_file.exists():
-        config = {}
-        with agenta_config_file.open("w") as config_file:
-            toml.dump(config, config_file)
-    global_config = toml.load(agenta_config_file)
-    global_config[var_name] = var_value
-    with open(agenta_config_file, "w") as config_file:
-        toml.dump(global_config, config_file)
-
-
-def get_api_key(backend_host: str) -> str:
-    """
-    Retrieve or request the API key for accessing the Agenta platform.
-
-    This function first looks for an existing API key in the global config file.
-    If found, it prompts the user to confirm whether they'd like to use that key.
-    If not found, it asks the user to input a new key.
-
-    Args:
-        backend_host (str): The URL of the backend host.
-
-    Returns:
-        str: The API key to be used for accessing the Agenta platform.
-
-    Raises:
-        SystemExit: If the user cancels the input by pressing Ctrl+C.
-    """
-
-    api_key = get_global_config("api_key")
-    if api_key:
-        # API key exists in the config file, ask for confirmation
-        confirm_api_key = questionary.confirm(
-            f"API Key found: {api_key}\nDo you want to use this API Key?"
-        ).ask()
-
-        if confirm_api_key:
-            return api_key
-        elif confirm_api_key is None:  # User pressed Ctrl+C
-            sys.exit(0)
-
-    api_key = questionary.text(
-        f"(You can get your API Key here: {backend_host}/settings?tab=apiKeys) "
-        "Please provide your API key:"
-    ).ask()
-
-    if api_key:
-        set_global_config("api_key", api_key.strip())
-
-        return api_key
-    elif api_key is None:  # User pressed Ctrl+C
-        sys.exit(0)
-
-
-def init_telemetry_config() -> None:
-    if (
-        get_global_config("telemetry_tracking_enabled") is None
-        or get_global_config("telemetry_api_key") is None
-    ):
-        set_global_config("telemetry_tracking_enabled", True)
-        set_global_config(
-            "telemetry_api_key",
-            POSTHOG_KEY,
-        )
-
-
-def update_variants_from_backend(
-    app_id: str,
-    config: MutableMapping[str, Any],
-    host: str,
-    api_key: str = None,
-) -> MutableMapping[str, Any]:
-    """Reads the list of variants from the backend and updates the config accordingly
-
-    Arguments:
-        app_id -- the app id
-        config -- the config loaded using toml.load
-        api_key -- the api key to use for authentication
-
-    Returns:
-        a new config object later to be saved using toml.dump(config, config_file.open('w'))
-    """
-    client = AgentaApi(
-        base_url=f"{host}/{BACKEND_URL_SUFFIX}",
-        api_key=api_key,
-    )
-
-    try:
-        variants: List[AppVariant] = client.apps.list_app_variants(app_id=app_id)
-    except Exception as ex:
-        raise ex
-
-    config["variants"] = [variant.variant_name for variant in variants]
-    config["variant_ids"] = [variant.variant_id for variant in variants]
-    return config
-
-
-def update_config_from_backend(config_file: Path, host: str):
-    """Updates the config file with new information from the backend
-
-    Arguments:
-        config_file -- the path to the config file
-    """
-    assert config_file.exists(), "Config file does not exist!"
-    config = toml.load(config_file)
-    app_id = config["app_id"]
-    api_key = config.get("api_key", "")
-    if "variants" not in config:
-        config["variants"] = []
-    if "variant_ids" not in config:
-        config["variant_ids"] = []
-    config = update_variants_from_backend(app_id, config, host, api_key)
-    toml.dump(config, config_file.open("w"))
-
-
-def display_app_variant(variant: AppVariant):
-    """Prints a variant nicely in the terminal"""
-    click.echo(
-        click.style("App Name: ", bold=True, fg="green")
-        + click.style(variant.app_name, fg="green")
-    )
-    click.echo(
-        click.style("Variant Name: ", bold=True, fg="blue")
-        + click.style(variant.variant_name, fg="blue")
-    )
-    click.echo(click.style("Parameters: ", bold=True, fg="cyan"))
-    if variant.parameters:
-        for param, value in variant.parameters.items():
-            click.echo(
-                click.style(f"  {param}: ", fg="cyan")
-                + click.style(str(value), fg="cyan")
-            )
-    else:
-        click.echo(click.style("  Defaults from code", fg="cyan"))
-    if variant.previous_variant_name:
-        click.echo(
-            click.style("Template Variant Name: ", bold=True, fg="magenta")
-            + click.style(variant.previous_variant_name, fg="magenta")
-        )
-    else:
-        click.echo(
-            click.style("Template Variant Name: ", bold=True, fg="magenta")
-            + click.style("None", fg="magenta")
-        )
-    click.echo(
-        click.style("-" * 50, bold=True, fg="white")
-    )  # a line for separating each variant

agenta/cli/main.py

@@ -1,229 +0,0 @@
-import os
-import re
-import shutil
-import sys
-from typing import Union
-from pathlib import Path
-
-import click
-import questionary
-import toml
-
-from agenta.cli import helper
-from agenta.cli import variant_configs
-from agenta.cli import variant_commands
-from agenta.cli import evaluation_commands
-
-from agenta.client.backend.client import AgentaApi
-
-BACKEND_URL_SUFFIX = os.environ.get("BACKEND_URL_SUFFIX", "api")
-
-
-def print_version(ctx, param, value):
-    if not value or ctx.resilient_parsing:
-        return
-    try:
-        try:
-            from importlib.metadata import PackageNotFoundError, version
-        except ImportError:
-            from importlib_metadata import PackageNotFoundError, version
-        package_version = version("agenta")
-    except PackageNotFoundError:
-        package_version = "package is not installed"
-    click.echo(f"Agenta CLI version: {package_version}")
-    ctx.exit()
-
-
-def check_latest_version() -> Union[str, None]:
-    import requests
-
-    try:
-        response = requests.get("https://pypi.org/pypi/agenta/json", timeout=360)
-        response.raise_for_status()
-        latest_version = response.json()["info"]["version"]
-        return latest_version
-    except (requests.RequestException, KeyError):
-        return None
-
-
-def notify_update(available_version: str):
-    import importlib.metadata
-
-    installed_version = importlib.metadata.version("agenta")
-    if available_version > installed_version:
-        click.echo(
-            click.style(
-                f"A new release of agenta is available: {installed_version} → {available_version}",
-                fg="yellow",
-            )
-        )
-        click.echo(
-            click.style("To upgrade, run: pip install --upgrade agenta", fg="yellow")
-        )
-
-
-@click.group()
-@click.option(
-    "--version",
-    "-v",
-    is_flag=True,
-    callback=print_version,
-    expose_value=False,
-    is_eager=True,
-)
-def cli():
-    latest_version = check_latest_version()
-    if latest_version:
-        notify_update(latest_version)
-
-
-@click.command()
-@click.option("--app-name", "--app_name", default=None)
-@click.option("--backend-host", "backend_host", default=None)
-def init(app_name: str, backend_host: str):
-    """Initialize a new Agenta app with the template files."""
-
-    init_option = "Blank App" if backend_host != "" and app_name != "" else ""
-
-    api_key = os.getenv("AGENTA_API_KEY")
-
-    if not app_name:
-        while True:
-            app_name = questionary.text("Please enter the app name").ask()
-            if app_name and re.match("^[a-zA-Z0-9_-]+$", app_name):
-                break
-            else:
-                if app_name is None:  # User pressed Ctrl+C
-                    sys.exit(0)
-                else:
-                    print(
-                        "Invalid input. Please use only alphanumeric characters without spaces."
-                    )
-
-    try:
-        backend_hosts = {
-            "https://cloud.agenta.ai": "On agenta cloud",
-            "http://localhost": "On my local machine",
-        }
-        where_question = backend_hosts.get(backend_host, "On a remote machine")
-        if not backend_host:
-            where_question = questionary.select(
-                "Where are you running agenta?",
-                choices=[
-                    "On agenta cloud",
-                    "On my local machine",
-                    "On a remote machine",
-                ],
-            ).ask()
-
-            if where_question == "On my local machine":
-                backend_host = "http://localhost"
-            elif where_question == "On a remote machine":
-                backend_host = questionary.text(
-                    "Please provide the IP or URL of your remote host"
-                ).ask()
-            elif where_question == "On agenta cloud":
-                global_backend_host = helper.get_global_config("host")
-                if global_backend_host:
-                    backend_host = global_backend_host
-                else:
-                    backend_host = "https://cloud.agenta.ai"
-
-                if not api_key:
-                    api_key = helper.get_api_key(backend_host)
-
-            elif where_question is None:  # User pressed Ctrl+C
-                sys.exit(0)
-        backend_host = (
-            backend_host
-            if backend_host.startswith("http://") or backend_host.startswith("https://")
-            else "http://" + backend_host
-        )
-
-        # initialize the client with the backend url and api key
-        client = AgentaApi(
-            base_url=f"{backend_host}/{BACKEND_URL_SUFFIX}",
-            api_key=api_key if where_question == "On agenta cloud" else "",
-        )
-
-        # Get app_id after creating new app in the backend server
-        try:
-            app_id = client.apps.create_app(app_name=app_name).app_id
-        except Exception as ex:
-            click.echo(click.style(f"Error: {ex}", fg="red"))
-            sys.exit(1)
-
-        # Set app toml configuration
-        config = {
-            "app_name": app_name,
-            "app_id": app_id,
-            "backend_host": backend_host,
-            "api_key": api_key if where_question == "On agenta cloud" else None,
-        }
-        with open("config.toml", "w") as config_file:
-            toml.dump(config, config_file)
-
-        # Ask for init option
-        if not init_option:
-            init_option = questionary.select(
-                "How do you want to initialize your app?",
-                choices=["Blank App", "Start from template"],
-            ).ask()
-
-            # If the user selected the second option, show a list of available templates
-            if init_option == "Start from template":
-                current_dir = Path.cwd()
-                template_dir = Path(__file__).parent.parent / "templates"
-                templates = [
-                    folder.name for folder in template_dir.iterdir() if folder.is_dir()
-                ]
-                template_desc = [
-                    toml.load((template_dir / name / "template.toml"))["short_desc"]
-                    for name in templates
-                ]
-
-                # Show the templates to the user
-                template = questionary.select(
-                    "Which template do you want to use?",
-                    choices=[
-                        questionary.Choice(
-                            title=f"{template} - {template_desc}", value=template
-                        )
-                        for template, template_desc in zip(templates, template_desc)
-                    ],
-                ).ask()
-
-                # Copy the template files to the current directory
-                chosen_template_dir = template_dir / template
-                for file in chosen_template_dir.glob("*"):
-                    if file.name != "template.toml" and not file.is_dir():
-                        shutil.copy(file, current_dir / file.name)
-            elif init_option is None:  # User pressed Ctrl+C
-                sys.exit(0)
-
-        # Create a .gitignore file and add some default environment folder names to it
-        gitignore_content = (
-            "# Environments \nenv/\nvenv/\nENV/\nenv.bak/\nvenv.bak/\nmyenv/\n"
-        )
-        if not os.path.exists(".agentaignore"):
-            with open(".agentaignore", "w") as gitignore_file:
-                gitignore_file.write(gitignore_content)
-
-        click.echo("App initialized successfully")
-        if init_option == "Start from template":
-            click.echo(
-                "Please check the README.md for further instructions to setup the template."
-            )
-    except Exception as ex:
-        click.echo(click.style(f"Error: {ex}", fg="red"))
-        sys.exit(1)
-
-
-# Add the commands to the CLI group
-cli.add_command(init)
-cli.add_command(variant_configs.config)
-cli.add_command(variant_commands.variant)
-cli.add_command(evaluation_commands.evaluation)
-
-if __name__ == "__main__":
-    cli()

agenta/cli/telemetry.py

@@ -1,50 +0,0 @@
-# Stdlib Imports
-from uuid import uuid4
-
-# Own Imports
-from agenta.cli import helper
-
-# Third party Imports
-from posthog import Posthog
-
-
-# Load telemetry configuration
-helper.init_telemetry_config()
-
-
-class EventTracking(Posthog):
-    _instance = None
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-    def __init__(self, api_key: str, host: str) -> None:
-        super(Posthog, self).__init__(api_key, host)
-
-    def capture_event(
-        self,
-        event_name: str,
-        body: dict,
-    ) -> None:
-        """
-        Captures an event.
-
-        Args:
-            event_name (str): The name of the event being captured.
-            body (dict): Contains the data associated with the event being captured.
-        """
-
-        # A unique identifier for the user or entity associated with the event
-        distinct_id = helper.get_global_config("telemetry_distinct_id")
-        if not distinct_id:
-            distinct_id = uuid4()
-            helper.set_global_config("telemetry_distinct_id", str(distinct_id))
-        self.capture(distinct_id, event_name, body)
-
-
-# Initialize event tracking
-event_track = EventTracking(
-    helper.get_global_config("telemetry_api_key"), "https://app.posthog.com"
-)