vantage-cli 0.1.1__py3-none-any.whl

vantage_cli/config.py

@@ -0,0 +1,161 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Configuration settings for Vantage CLI."""
+
+import inspect
+import json
+import shutil
+from asyncio.log import logger
+from functools import wraps
+from typing import Any, Callable
+
+import typer
+from pydantic import BaseModel, ValidationError, computed_field
+
+from .constants import (
+    USER_CONFIG_FILE,
+    USER_TOKEN_CACHE_DIR,
+    VANTAGE_CLI_ACTIVE_PROFILE,
+    VANTAGE_CLI_LOCAL_USER_BASE_DIR,
+)
+
+
+class Settings(BaseModel):
+    """Configuration settings for the Vantage CLI."""
+
+    supported_clouds: list[str] = ["localhost", "aws", "gcp", "azure", "on-premises", "k8s"]
+    api_base_url: str = "https://apis.vantagecompute.ai"
+    oidc_base_url: str = "https://auth.vantagecompute.ai"
+    tunnel_api_url: str = "https://tunnel.vantagecompute.ai"
+    oidc_client_id: str = "default"
+    oidc_max_poll_time: int = 5 * 60  # 5 minutes
+
+    @computed_field
+    @property
+    def oidc_domain(self) -> str:
+        """Extract the domain from the OIDC base URL."""
+        return self.oidc_base_url.split("//")[-1]
+
+    @computed_field
+    @property
+    def oidc_token_url(self) -> str:
+        """Construct the OIDC token URL from the base URL."""
+        return f"{self.oidc_base_url}/realms/vantage/protocol/openid-connect/token"
+
+
+def init_user_filesystem(profile: str) -> None:
+    """Initialize the user filesystem directories for a profile."""
+    (USER_TOKEN_CACHE_DIR / profile).mkdir(parents=True, exist_ok=True)
+
+
+def init_settings(**settings_values) -> Settings:
+    """Initialize settings with validation."""
+    try:
+        logger.debug("Validating settings")
+        return Settings(**settings_values)
+    except ValidationError as e:
+        logger.error(f"Settings validation error: {e}")
+        raise
+
+
+def attach_settings(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Attach settings to the CLI context."""
+    if inspect.iscoroutinefunction(func):
+
+        @wraps(func)
+        async def async_wrapper(ctx: typer.Context, *args, **kwargs):
+            try:
+                logger.debug(f"Loading settings from {USER_CONFIG_FILE}")
+                settings_all_profiles = json.loads(USER_CONFIG_FILE.read_text())
+                settings_values = settings_all_profiles.get(ctx.obj.profile)
+            except FileNotFoundError:
+                logger.error("Settings file missing!")
+                typer.echo(
+                    f"""
+                    No settings file found at {USER_CONFIG_FILE}!
+
+                    Run the set-config sub-command first to establish your OIDC settings.
+                    """
+                )
+                raise typer.Exit(1)
+            logger.debug("Binding settings to CLI context")
+            ctx.obj.settings = init_settings(**settings_values)
+            return await func(ctx, *args, **kwargs)
+
+        return async_wrapper
+    else:
+
+        @wraps(func)
+        def wrapper(ctx: typer.Context, *args, **kwargs):
+            try:
+                logger.debug(f"Loading settings from {USER_CONFIG_FILE}")
+                settings_all_profiles = json.loads(USER_CONFIG_FILE.read_text())
+                settings_values = settings_all_profiles.get(ctx.obj.profile)
+            except FileNotFoundError:
+                logger.error("Settings file missing!")
+                typer.echo(
+                    f"""
+                    No settings file found at {USER_CONFIG_FILE}!
+
+                    Run the set-config sub-command first to establish your OIDC settings.
+                    """
+                )
+                raise typer.Exit(1)
+            logger.debug("Binding settings to CLI context")
+            ctx.obj.settings = init_settings(**settings_values)
+            return func(ctx, *args, **kwargs)
+
+    return wrapper
+
+
+def dump_settings(profile: str, settings: Settings) -> None:
+    """Save settings to the user configuration file."""
+    logger.debug(f"Saving settings to {USER_CONFIG_FILE}")
+    if USER_CONFIG_FILE.exists():
+        settings_all_profiles = json.loads(USER_CONFIG_FILE.read_text())
+    else:
+        settings_all_profiles = {}
+
+    settings_all_profiles[f"{profile}"] = settings.model_dump()
+    USER_CONFIG_FILE.write_text(json.dumps(settings_all_profiles))
+
+
+def clear_settings() -> None:
+    """Remove saved settings configuration file."""
+    logger.debug(f"Removing saved settings at {USER_CONFIG_FILE}")
+    USER_CONFIG_FILE.unlink(missing_ok=True)
+    VANTAGE_CLI_ACTIVE_PROFILE.unlink(missing_ok=True)
+    try:
+        shutil.rmtree(f"{USER_TOKEN_CACHE_DIR}")
+        logger.debug(f"Removed user token cache directory at {USER_TOKEN_CACHE_DIR}")
+    except FileNotFoundError:
+        logger.debug("Token cache directory already absent; nothing to remove")
+
+
+def ensure_default_profile_exists() -> None:
+    """Ensure the default profile exists and is properly configured."""
+    if VANTAGE_CLI_LOCAL_USER_BASE_DIR.exists() is False:
+        VANTAGE_CLI_LOCAL_USER_BASE_DIR.mkdir(parents=True, exist_ok=True)
+        logger.debug(f"Created local user base directory at {VANTAGE_CLI_LOCAL_USER_BASE_DIR}")
+
+    if not USER_CONFIG_FILE.exists():
+        # Create the default profile with default settings
+        logger.debug("Creating default profile on first run")
+        default_settings = Settings()
+        dump_settings("default", default_settings)
+
+
+def get_active_profile() -> str:
+    """Get the currently active profile name."""
+    if VANTAGE_CLI_ACTIVE_PROFILE.exists():
+        try:
+            return VANTAGE_CLI_ACTIVE_PROFILE.read_text().strip()
+        except (FileNotFoundError, PermissionError):
+            pass
+    return "default"
+
+
+def set_active_profile(profile_name: str) -> None:
+    """Set the active profile."""
+    VANTAGE_CLI_ACTIVE_PROFILE.parent.mkdir(parents=True, exist_ok=True)
+    VANTAGE_CLI_ACTIVE_PROFILE.write_text(profile_name)

vantage_cli/constants.py

@@ -0,0 +1,40 @@
+# © 2025 Vantage Compute, Inc. All rights reserved.
+# Confidential and proprietary. Unauthorized use prohibited.
+"""Constants for Vantage CLI."""
+
+from pathlib import Path
+
+VANTAGE_CLI_LOCAL_USER_BASE_DIR: Path = Path.home() / ".vantage-cli"
+VANTAGE_CLI_ACTIVE_PROFILE: Path = VANTAGE_CLI_LOCAL_USER_BASE_DIR / "active_profile"
+
+USER_CONFIG_FILE: Path = VANTAGE_CLI_LOCAL_USER_BASE_DIR / "config.json"
+
+USER_TOKEN_CACHE_DIR: Path = VANTAGE_CLI_LOCAL_USER_BASE_DIR / "token_cache"
+
+# Common deployment constants
+DEFAULT_CLUSTER_NAME = "vantage-cluster"
+DEFAULT_MODEL_PREFIX = "vantage"
+
+# Multipass-specific constants
+MULTIPASS_ARCH = "arm64"
+MULTIPASS_CLOUD_IMAGE_URL = "https://vantage-public-assets.s3.us-west-2.amazonaws.com/multipass-singlenode/multipass-singlenode.img"
+MULTIPASS_CLOUD_IMAGE_DEST = Path("/tmp/multipass-singlenode.img")
+MULTIPASS_CLOUD_IMAGE_LOCAL = (
+    Path.home() / "multipass-singlenode" / "build" / "multipass-singlenode.img"
+)
+
+# Juju-specific constants
+JUJU_SECRET_NAME = "vantage-jupyterhub-config"
+JUJU_APPLICATION_NAME = "vantage-jupyterhub"
+
+# Environment variable names
+ENV_CLIENT_SECRET = "VANTAGE_CLIENT_SECRET"
+ENV_OIDC_DOMAIN = "VANTAGE_OIDC_DOMAIN"
+ENV_BASE_API_URL = "VANTAGE_BASE_API_URL"
+ENV_TUNNEL_API_URL = "VANTAGE_TUNNEL_API_URL"
+
+# Error messages
+ERROR_NO_CLUSTER_DATA = "[red]Error: No cluster data provided.[/red]"
+ERROR_NO_CLIENT_ID = "[red]Error: No client ID found in cluster data.[/red]"
+ERROR_NO_CLIENT_SECRET = "[red]Error: No client secret found in cluster data.[/red]"
+ERROR_MULTIPASS_NOT_FOUND = "[red]Error: 'multipass' is not installed or not found in PATH.[/red]"

vantage_cli/exceptions.py

@@ -0,0 +1,127 @@
+"""Exception handling and error management for the Vantage CLI."""
+
+import inspect
+from functools import wraps
+from sys import exc_info
+
+import buzz
+import snick
+import typer
+from loguru import logger
+from rich import traceback
+from rich.console import Console
+from rich.panel import Panel
+
+# Enables prettified traceback printing via rich
+traceback.install()
+
+
+class VantageCliError(buzz.Buzz):
+    """Base exception class for Vantage CLI errors."""
+
+    pass
+
+
+class DeploymentError(VantageCliError):
+    """Exception for deployment-related failures."""
+
+    pass
+
+
+class ValidationError(VantageCliError):
+    """Exception for data validation failures."""
+
+    pass
+
+
+class ConfigurationError(VantageCliError):
+    """Exception for configuration-related issues."""
+
+    pass
+
+
+class AuthenticationError(VantageCliError):
+    """Exception for authentication and authorization failures."""
+
+    pass
+
+
+class ApiError(VantageCliError):
+    """Exception for API communication failures."""
+
+    pass
+
+
+class Abort(buzz.Buzz):
+    """Exception class for aborting operations with user-friendly messages."""
+
+    def __init__(
+        self,
+        message,
+        *args,
+        subject=None,
+        log_message=None,
+        warn_only=False,
+        **kwargs,
+    ):
+        self.subject = subject
+        self.log_message = log_message
+        self.warn_only = warn_only
+        (_, self.original_error, __) = exc_info()
+        super().__init__(message, *args, **kwargs)
+
+
+def handle_abort(func):
+    """Handle abort exceptions in decorated functions."""
+    if inspect.iscoroutinefunction(func):
+
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except Abort as err:
+                if not err.warn_only:
+                    if err.log_message is not None:
+                        logger.error(err.log_message)
+
+                    if err.original_error is not None:
+                        logger.error(f"Original exception: {err.original_error}")
+
+                panel_kwargs = {}
+                if err.subject is not None:
+                    panel_kwargs["title"] = f"[red]{err.subject}"
+                message = snick.dedent(err.message)
+
+                console = Console()
+                console.print()
+                console.print(Panel(message, **panel_kwargs))
+                console.print()
+                raise typer.Exit(code=1)
+
+        return async_wrapper
+    else:
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Abort as err:
+                if not err.warn_only:
+                    if err.log_message is not None:
+                        logger.error(err.log_message)
+
+                    if err.original_error is not None:
+                        logger.error(f"Original exception: {err.original_error}")
+
+                panel_kwargs = {}
+                if err.subject is not None:
+                    panel_kwargs["title"] = f"[red]{err.subject}"
+                message = snick.dedent(err.message)
+
+                console = Console()
+                console.print()
+                console.print(Panel(message, **panel_kwargs))
+                console.print()
+                raise typer.Exit(code=1)
+
+        return wrapper

vantage_cli/format.py

@@ -0,0 +1,39 @@
+"""Output formatting utilities for the Vantage CLI."""
+
+import json
+from typing import Any, Optional
+
+import snick
+from rich.console import Console
+from rich.panel import Panel
+
+
+def terminal_message(
+    message: str,
+    subject: Optional[str],
+    color: str = "green",
+    footer: Optional[str] = None,
+    indent: bool = True,
+):
+    """Display a formatted message in the terminal."""
+    text = snick.dedent(message)
+    if indent:
+        text = snick.indent(text, prefix="  ")
+    console = Console()
+    console.print()
+
+    # Build panel with explicit parameters
+    panel_title = f"[{color}]{subject}" if subject is not None else None
+    panel_subtitle = f"[dim italic]{footer}[/dim italic]" if footer is not None else None
+    panel = Panel(text, title=panel_title, subtitle=panel_subtitle, padding=(1, 1))
+
+    console.print(panel)
+    console.print()
+
+
+def render_json(data: Any) -> None:
+    """Render data as formatted JSON output."""
+    console = Console()
+    console.print()
+    console.print_json(json.dumps(data))
+    console.print()