llamactl 0.2.7a1__py3-none-any.whl

llama_deploy/cli/config.py

@@ -0,0 +1,173 @@
+"""Configuration and profile management for llamactl"""
+
+import sqlite3
+from pathlib import Path
+from typing import Optional, List
+from dataclasses import dataclass
+import os
+
+
+@dataclass
+class Profile:
+    """Profile configuration"""
+
+    name: str
+    api_url: str
+    active_project_id: Optional[str] = None
+
+
+class ConfigManager:
+    """Manages profiles and configuration using SQLite"""
+
+    def __init__(self):
+        self.config_dir = self._get_config_dir()
+        self.db_path = self.config_dir / "profiles.db"
+        self._ensure_config_dir()
+        self._init_database()
+
+    def _get_config_dir(self) -> Path:
+        """Get the configuration directory path based on OS"""
+        if os.name == "nt":  # Windows
+            config_dir = Path(os.environ.get("APPDATA", "~")) / "llamactl"
+        else:  # Unix-like (Linux, macOS)
+            config_dir = Path.home() / ".config" / "llamactl"
+        return config_dir.expanduser()
+
+    def _ensure_config_dir(self):
+        """Create configuration directory if it doesn't exist"""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def _init_database(self):
+        """Initialize SQLite database with required tables"""
+        with sqlite3.connect(self.db_path) as conn:
+            # Check if we need to migrate from old schema
+            cursor = conn.execute("PRAGMA table_info(profiles)")
+            columns = [row[1] for row in cursor.fetchall()]
+
+            if "project_id" in columns and "active_project_id" not in columns:
+                # Migrate old schema to new schema
+                conn.execute("""
+                    ALTER TABLE profiles RENAME COLUMN project_id TO active_project_id
+                """)
+
+            # Create tables with new schema
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS profiles (
+                    name TEXT PRIMARY KEY,
+                    api_url TEXT NOT NULL,
+                    active_project_id TEXT
+                )
+            """)
+
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS settings (
+                    key TEXT PRIMARY KEY,
+                    value TEXT NOT NULL
+                )
+            """)
+
+            conn.commit()
+
+    def create_profile(
+        self, name: str, api_url: str, active_project_id: Optional[str] = None
+    ) -> Profile:
+        """Create a new profile"""
+        profile = Profile(
+            name=name, api_url=api_url, active_project_id=active_project_id
+        )
+
+        with sqlite3.connect(self.db_path) as conn:
+            try:
+                conn.execute(
+                    "INSERT INTO profiles (name, api_url, active_project_id) VALUES (?, ?, ?)",
+                    (profile.name, profile.api_url, profile.active_project_id),
+                )
+                conn.commit()
+            except sqlite3.IntegrityError:
+                raise ValueError(f"Profile '{name}' already exists")
+
+        return profile
+
+    def get_profile(self, name: str) -> Optional[Profile]:
+        """Get a profile by name"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT name, api_url, active_project_id FROM profiles WHERE name = ?",
+                (name,),
+            )
+            row = cursor.fetchone()
+            if row:
+                return Profile(name=row[0], api_url=row[1], active_project_id=row[2])
+        return None
+
+    def list_profiles(self) -> List[Profile]:
+        """List all profiles"""
+        profiles = []
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT name, api_url, active_project_id FROM profiles ORDER BY name"
+            )
+            for row in cursor.fetchall():
+                profiles.append(
+                    Profile(name=row[0], api_url=row[1], active_project_id=row[2])
+                )
+        return profiles
+
+    def delete_profile(self, name: str) -> bool:
+        """Delete a profile by name. Returns True if deleted, False if not found."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute("DELETE FROM profiles WHERE name = ?", (name,))
+            conn.commit()
+
+            # If this was the active profile, clear it
+            if self.get_current_profile_name() == name:
+                self.set_current_profile(None)
+
+            return cursor.rowcount > 0
+
+    def set_current_profile(self, name: Optional[str]):
+        """Set the current active profile"""
+        with sqlite3.connect(self.db_path) as conn:
+            if name is None:
+                conn.execute("DELETE FROM settings WHERE key = 'current_profile'")
+            else:
+                conn.execute(
+                    "INSERT OR REPLACE INTO settings (key, value) VALUES ('current_profile', ?)",
+                    (name,),
+                )
+            conn.commit()
+
+    def get_current_profile_name(self) -> Optional[str]:
+        """Get the name of the current active profile"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT value FROM settings WHERE key = 'current_profile'"
+            )
+            row = cursor.fetchone()
+            return row[0] if row else None
+
+    def get_current_profile(self) -> Optional[Profile]:
+        """Get the current active profile"""
+        current_name = self.get_current_profile_name()
+        if current_name:
+            return self.get_profile(current_name)
+        return None
+
+    def set_active_project(self, profile_name: str, project_id: Optional[str]) -> bool:
+        """Set the active project for a profile. Returns True if profile exists."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "UPDATE profiles SET active_project_id = ? WHERE name = ?",
+                (project_id, profile_name),
+            )
+            conn.commit()
+            return cursor.rowcount > 0
+
+    def get_active_project(self, profile_name: str) -> Optional[str]:
+        """Get the active project for a profile"""
+        profile = self.get_profile(profile_name)
+        return profile.active_project_id if profile else None
+
+
+# Global config manager instance
+config_manager = ConfigManager()

llama_deploy/cli/debug.py

@@ -0,0 +1,16 @@
+import logging
+
+
+def setup_file_logging(
+    log_file: str = "llamactl.log", level: int = logging.DEBUG
+) -> None:
+    """Set up global file logging for debugging when TUI takes over the terminal"""
+    # Configure the root logger
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.FileHandler(log_file, mode="a"),
+        ],
+        force=True,  # Override any existing configuration
+    )

llama_deploy/cli/env.py

@@ -0,0 +1,30 @@
+"""Environment variable handling utilities for llamactl"""
+
+from typing import Dict
+from io import StringIO
+from rich import print as rprint
+from dotenv import dotenv_values
+
+
+def load_env_secrets_from_string(env_content: str) -> Dict[str, str]:
+    """
+    Load environment variables from string content to use as secrets.
+
+    Args:
+        env_content: String content containing environment variables in .env format
+
+    Returns:
+        Dictionary of environment variable names and values
+    """
+    try:
+        # Use StringIO to create a file-like object from the string
+        # dotenv_values can parse from a stream
+        env_stream = StringIO(env_content)
+        secrets = dotenv_values(stream=env_stream)
+        # Filter out None values and convert to strings
+        return {k: str(v) for k, v in secrets.items() if v is not None}
+    except Exception as e:
+        rprint(
+            f"[yellow]Warning: Could not parse environment variables from string: {e}[/yellow]"
+        )
+        return {}

llama_deploy/cli/interactive_prompts/utils.py

@@ -0,0 +1,86 @@
+"""Shared utilities for CLI operations"""
+
+from typing import Optional
+
+import questionary
+from rich import print as rprint
+from rich.console import Console
+
+from ..client import get_client
+from ..config import config_manager
+
+console = Console()
+
+
+def select_deployment(deployment_id: Optional[str] = None) -> Optional[str]:
+    """
+    Select a deployment interactively if ID not provided.
+    Returns the selected deployment ID or None if cancelled.
+    """
+    if deployment_id:
+        return deployment_id
+
+    try:
+        client = get_client()
+        deployments = client.list_deployments()
+
+        if not deployments:
+            rprint(
+                f"[yellow]No deployments found for project {client.project_id}[/yellow]"
+            )
+            return None
+
+        choices = []
+        for deployment in deployments:
+            name = deployment.name
+            deployment_id = deployment.id
+            status = deployment.status
+            choices.append(
+                questionary.Choice(
+                    title=f"{name} ({deployment_id}) - {status}", value=deployment_id
+                )
+            )
+
+        return questionary.select("Select deployment:", choices=choices).ask()
+
+    except Exception as e:
+        rprint(f"[red]Error loading deployments: {e}[/red]")
+        return None
+
+
+def select_profile(profile_name: Optional[str] = None) -> Optional[str]:
+    """
+    Select a profile interactively if name not provided.
+    Returns the selected profile name or None if cancelled.
+    """
+    if profile_name:
+        return profile_name
+
+    try:
+        profiles = config_manager.list_profiles()
+
+        if not profiles:
+            rprint("[yellow]No profiles found[/yellow]")
+            return None
+
+        choices = []
+        current_name = config_manager.get_current_profile_name()
+
+        for profile in profiles:
+            title = f"{profile.name} ({profile.api_url})"
+            if profile.name == current_name:
+                title += " [current]"
+            choices.append(questionary.Choice(title=title, value=profile.name))
+
+        return questionary.select("Select profile:", choices=choices).ask()
+
+    except Exception as e:
+        rprint(f"[red]Error loading profiles: {e}[/red]")
+        return None
+
+
+def confirm_action(message: str, default: bool = False) -> bool:
+    """
+    Ask for confirmation with a consistent interface.
+    """
+    return questionary.confirm(message, default=default).ask() or False

llama_deploy/cli/options.py

@@ -0,0 +1,21 @@
+import logging
+import click
+
+
+def global_options(f):
+    """Common decorator to add global options to command groups"""
+    from .debug import setup_file_logging
+
+    def debug_callback(ctx, param, value):
+        if value:
+            setup_file_logging(level=logging._nameToLevel[value])
+        return value
+
+    return click.option(
+        "--log-level",
+        type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]),
+        help="Enable debug logging to file",
+        callback=debug_callback,
+        expose_value=False,
+        is_eager=True,
+    )(f)