glaip-sdk 0.6.12__py3-none-any.whl → 0.6.14__py3-none-any.whl

glaip_sdk/cli/commands/update.py

@@ -1,61 +0,0 @@
-"""Update command for upgrading the glaip-sdk package.
-
-Author:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from collections.abc import Sequence
-
-import click
-from rich.console import Console
-
-from glaip_sdk.branding import ACCENT_STYLE, ERROR_STYLE, INFO_STYLE, SUCCESS_STYLE
-
-PACKAGE_NAME = "glaip-sdk"
-
-
-def _build_upgrade_command(include_prerelease: bool) -> Sequence[str]:
-    """Return the pip command used to upgrade the SDK."""
-    command = [
-        sys.executable,
-        "-m",
-        "pip",
-        "install",
-        "--upgrade",
-        PACKAGE_NAME,
-    ]
-    if include_prerelease:
-        command.append("--pre")
-    return command
-
-
-@click.command(name="update")
-@click.option(
-    "--pre",
-    "include_prerelease",
-    is_flag=True,
-    help="Include pre-release versions when upgrading.",
-)
-def update_command(include_prerelease: bool) -> None:
-    """Upgrade the glaip-sdk package using pip."""
-    console = Console()
-    upgrade_cmd = _build_upgrade_command(include_prerelease)
-    console.print(f"[{ACCENT_STYLE}]Upgrading {PACKAGE_NAME} using[/] [{INFO_STYLE}]{' '.join(upgrade_cmd)}[/]")
-
-    try:
-        subprocess.run(upgrade_cmd, check=True)
-    except FileNotFoundError as exc:
-        raise click.ClickException(
-            "Unable to locate Python executable to run pip. Please ensure Python is installed and try again."
-        ) from exc
-    except subprocess.CalledProcessError as exc:
-        console.print(
-            f"[{ERROR_STYLE}]Automatic upgrade failed.[/] Please run `pip install -U {PACKAGE_NAME}` manually."
-        )
-        raise click.ClickException("Automatic upgrade failed.") from exc
-
-    console.print(f"[{SUCCESS_STYLE}]✅ {PACKAGE_NAME} upgraded successfully.[/]")

glaip_sdk/cli/config.py

@@ -1,95 +0,0 @@
-"""Configuration management utilities.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
-
-import os
-from copy import deepcopy
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-_ENV_CONFIG_DIR = os.getenv("AIP_CONFIG_DIR")
-# Detect pytest environment: check for pytest markers or test session
-# This provides automatic test isolation even if conftest.py doesn't set AIP_CONFIG_DIR
-# Note: conftest.py sets AIP_CONFIG_DIR before imports, which takes precedence
-_TEST_ENV = os.getenv("PYTEST_CURRENT_TEST") or os.getenv("PYTEST_XDIST_WORKER") or os.getenv("_PYTEST_RAISE")
-
-if _ENV_CONFIG_DIR:
-    # Explicit override via environment variable (highest priority)
-    # This is set by conftest.py before imports, ensuring test isolation
-    CONFIG_DIR = Path(_ENV_CONFIG_DIR)
-elif _TEST_ENV:
-    # Isolate test runs (including xdist workers) from the real user config directory
-    # Use a per-process unique temp directory to avoid conflicts in parallel test runs
-    import tempfile
-    import uuid
-
-    # Create a unique temp dir per test process to avoid conflicts
-    temp_base = Path(tempfile.gettempdir())
-    test_config_dir = temp_base / f"aip-test-config-{os.getpid()}-{uuid.uuid4().hex[:8]}"
-    CONFIG_DIR = test_config_dir
-    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
-else:  # pragma: no cover - default path used outside test runs
-    CONFIG_DIR = Path.home() / ".aip"
-
-CONFIG_FILE = CONFIG_DIR / "config.yaml"
-_ALLOWED_KEYS = {
-    "api_url",
-    "api_key",
-    "timeout",
-    "history_default_limit",
-}
-# Keys that must be preserved for multi-account support
-_PRESERVE_KEYS = {
-    "version",
-    "active_account",
-    "accounts",
-}
-
-
-def _sanitize_config(data: dict[str, Any] | None) -> dict[str, Any]:
-    """Return config filtered to allowed keys only, preserving multi-account keys."""
-    if not data:
-        return {}
-    result: dict[str, Any] = {}
-    # Preserve multi-account structure (defensively copy to avoid callers mutating source)
-    for key in _PRESERVE_KEYS:
-        if key in data:
-            result[key] = deepcopy(data[key])
-    # Add allowed legacy keys (copied to avoid side effects)
-    for key in _ALLOWED_KEYS:
-        if key in data:
-            result[key] = deepcopy(data[key])
-    return result
-
-
-def load_config() -> dict[str, Any]:
-    """Load configuration from file."""
-    if not CONFIG_FILE.exists():
-        return {}
-
-    try:
-        with open(CONFIG_FILE) as f:
-            loaded = yaml.safe_load(f) or {}
-            return _sanitize_config(loaded)
-    except yaml.YAMLError:
-        return {}
-
-
-def save_config(config: dict[str, Any]) -> None:
-    """Save configuration to file."""
-    CONFIG_DIR.mkdir(exist_ok=True)
-
-    sanitized = _sanitize_config(config)
-
-    with open(CONFIG_FILE, "w") as f:
-        yaml.dump(sanitized, f, default_flow_style=False)
-
-    # Set secure file permissions
-    try:
-        os.chmod(CONFIG_FILE, 0o600)
-    except OSError:  # pragma: no cover - permission errors are expected in some environments
-        pass

glaip_sdk/cli/constants.py

@@ -1,38 +0,0 @@
-"""CLI-specific constants for glaip-sdk.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-"""
-
-# Minimum length that forces multiline YAML strings to be rendered using the literal
-# block style. This prevents long prompts and instructions from being inlined.
-LITERAL_STRING_THRESHOLD = 200
-
-# Masking configuration
-MASKING_ENABLED = True
-MASK_SENSITIVE_FIELDS = {
-    "api_key",
-    "apikey",
-    "token",
-    "access_token",
-    "secret",
-    "client_secret",
-    "password",
-    "private_key",
-    "bearer",
-}
-
-# Table + pager behaviour
-TABLE_SORT_ENABLED = True
-PAGER_MODE = "auto"  # valid values: "auto", "on", "off"
-PAGER_WRAP_LINES = False
-PAGER_HEADER_ENABLED = True
-
-# Update notification toggle
-UPDATE_CHECK_ENABLED = True
-
-# Agent instruction preview defaults
-DEFAULT_AGENT_INSTRUCTION_PREVIEW_LIMIT = 800
-
-# Remote runs defaults
-DEFAULT_REMOTE_RUNS_PAGE_LIMIT = 20

glaip_sdk/cli/context.py

@@ -1,150 +0,0 @@
-"""Context-related helpers for the glaip CLI.
-
-Authors:
-    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from pathlib import Path
-from typing import Any
-
-import click
-
-__all__ = [
-    "get_ctx_value",
-    "_get_view",
-    "_set_view",
-    "_set_json",
-    "output_flags",
-    "detect_export_format",
-]
-
-
-def get_ctx_value(ctx: Any, key: str, default: Any = None) -> Any:
-    """Safely resolve a value from a click context object.
-
-    Args:
-        ctx: Click context object to extract value from
-        key: Key to retrieve from the context
-        default: Default value if key is not found
-
-    Returns:
-        The value associated with the key, or the default if not found
-    """
-    if ctx is None:
-        return default
-
-    obj = getattr(ctx, "obj", None)
-    if obj is None:
-        return default
-
-    if isinstance(obj, dict):
-        return obj.get(key, default)
-
-    getter = getattr(obj, "get", None)
-    if callable(getter):
-        try:
-            return getter(key, default)
-        except TypeError:
-            return default
-
-    return getattr(obj, key, default) if hasattr(obj, key) else default
-
-
-def _get_view(ctx: Any) -> str:
-    """Resolve the active view preference from context.
-
-    Args:
-        ctx: Click context object containing view preferences
-
-    Returns:
-        The view format string (rich, plain, json, md), defaults to 'rich'
-    """
-    view = get_ctx_value(ctx, "view")
-    if view:
-        return view
-
-    fallback = get_ctx_value(ctx, "format")
-    return fallback or "rich"
-
-
-def _set_view(ctx: Any, _param: Any, value: str) -> None:
-    """Click callback to persist the `--view/--output` option.
-
-    Args:
-        ctx: Click context object to store the view preference
-        _param: Click parameter object (unused)
-        value: The view format string to store
-    """
-    if not value:
-        return
-    ctx.ensure_object(dict)
-    ctx.obj["view"] = value
-
-
-def _set_json(ctx: Any, _param: Any, value: bool) -> None:
-    """Click callback for the `--json` shorthand flag.
-
-    Args:
-        ctx: Click context object to store the view preference
-        _param: Click parameter object (unused)
-        value: Boolean flag indicating json mode
-    """
-    if not value:
-        return
-    ctx.ensure_object(dict)
-    ctx.obj["view"] = "json"
-
-
-def output_flags() -> Callable[[Callable[..., Any]], Callable[..., Any]]:
-    """Decorator to add shared output flags (`--view`, `--json`) to commands.
-
-    Returns:
-        A decorator function that adds output format options to click commands
-    """
-
-    def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
-        """Apply output flags to a click command.
-
-        Args:
-            f: Click command function to decorate.
-
-        Returns:
-            Decorated command function.
-        """
-        f = click.option(
-            "--json",
-            "json_mode",
-            is_flag=True,
-            expose_value=False,
-            help="Shortcut for --view json",
-            callback=_set_json,
-        )(f)
-        f = click.option(
-            "-o",
-            "--output",
-            "--view",
-            "view_opt",
-            type=click.Choice(["rich", "plain", "json", "md"]),
-            expose_value=False,
-            help="Output format",
-            callback=_set_view,
-        )(f)
-        return f
-
-    return decorator
-
-
-def detect_export_format(file_path: str | Path) -> str:
-    """Detect the export format from the file extension.
-
-    Args:
-        file_path: Path to the file to analyze
-
-    Returns:
-        The format string ('yaml' or 'json') based on file extension
-    """
-    path = Path(file_path)
-    return "yaml" if path.suffix.lower() in {".yaml", ".yml"} else "json"

glaip_sdk/cli/core/__init__.py

@@ -1,79 +0,0 @@
-"""CLI core modules for glaip-sdk.
-
-This package contains focused modules extracted from the monolithic cli/utils.py:
-- context: Click context helpers, config loading, credential resolution
-- prompting: prompt_toolkit + questionary wrappers, validators
-- rendering: Rich console helpers, viewer launchers, renderer builders
-- output: Table/console output utilities, list rendering
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
-"""  # pylint: disable=duplicate-code
-
-from __future__ import annotations
-
-# Re-export all public APIs from submodules for convenience
-from glaip_sdk.cli.core.context import (
-    bind_slash_session_context,
-    get_client,
-    handle_best_effort_check,
-    restore_slash_session_context,
-)
-from glaip_sdk.cli.core.output import (
-    coerce_to_row,
-    detect_export_format,
-    fetch_resource_for_export,
-    format_datetime_fields,
-    format_size,
-    handle_resource_export,
-    output_list,
-    output_result,
-    parse_json_line,
-    resolve_resource,
-    handle_ambiguous_resource,
-    sdk_version,
-)
-from glaip_sdk.cli.core.prompting import (
-    _fuzzy_pick_for_resources,
-    prompt_export_choice_questionary,
-    questionary_safe_ask,
-)
-from glaip_sdk.cli.core.rendering import (
-    build_renderer,
-    spinner_context,
-    stop_spinner,
-    update_spinner,
-    with_client_and_spinner,
-)
-
-__all__ = [
-    # Context
-    "bind_slash_session_context",
-    "get_client",
-    "handle_best_effort_check",
-    "restore_slash_session_context",
-    # Prompting
-    "_fuzzy_pick_for_resources",
-    "prompt_export_choice_questionary",
-    "questionary_safe_ask",
-    # Rendering
-    "build_renderer",
-    "spinner_context",
-    "stop_spinner",
-    "update_spinner",
-    "with_client_and_spinner",
-    # Output
-    "coerce_to_row",
-    "detect_export_format",
-    "fetch_resource_for_export",
-    "format_datetime_fields",
-    "format_size",
-    "handle_resource_export",
-    "output_list",
-    "output_result",
-    "parse_json_line",
-    "resolve_resource",
-    "handle_ambiguous_resource",
-    "sdk_version",
-]

glaip_sdk/cli/core/context.py

@@ -1,124 +0,0 @@
-"""CLI context helpers, config loading, and credential resolution.
-
-Authors:
-    Raymond Christopher (raymond.christopher@gdplabs.id)
-    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
-"""
-
-from __future__ import annotations
-
-import importlib
-import os
-from collections.abc import Mapping
-from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, cast
-
-import click
-
-from glaip_sdk.cli.config import load_config
-from glaip_sdk.cli.hints import command_hint
-
-if TYPE_CHECKING:  # pragma: no cover - import-only during type checking
-    from glaip_sdk import Client
-
-
-@contextmanager
-def bind_slash_session_context(ctx: Any, session: Any) -> Any:
-    """Temporarily attach a slash session to the Click context.
-
-    Args:
-        ctx: Click context object.
-        session: SlashSession instance to bind.
-
-    Yields:
-        None - context manager for use in with statement.
-    """
-    ctx_obj = getattr(ctx, "obj", None)
-    has_context = isinstance(ctx_obj, dict)
-    previous_session = ctx_obj.get("_slash_session") if has_context else None
-    if has_context:
-        ctx_obj["_slash_session"] = session
-    try:
-        yield
-    finally:
-        if has_context:
-            if previous_session is None:
-                ctx_obj.pop("_slash_session", None)
-            else:
-                ctx_obj["_slash_session"] = previous_session
-
-
-def restore_slash_session_context(ctx_obj: dict[str, Any], previous_session: Any | None) -> None:
-    """Restore slash session context after operation.
-
-    Args:
-        ctx_obj: Click context obj dictionary.
-        previous_session: Previous session to restore, or None to remove.
-    """
-    if previous_session is None:
-        ctx_obj.pop("_slash_session", None)
-    else:
-        ctx_obj["_slash_session"] = previous_session
-
-
-def handle_best_effort_check(
-    check_func: Any,
-) -> None:
-    """Handle best-effort duplicate/existence checks with proper exception handling.
-
-    Args:
-        check_func: Function that performs the check and raises ClickException if duplicate found.
-    """
-    try:
-        check_func()
-    except click.ClickException:
-        raise
-    except Exception:
-        # Non-fatal: best-effort duplicate check
-        pass
-
-
-def get_client(ctx: Any) -> Client:  # pragma: no cover
-    """Get configured client from context and account store (ctx > account)."""
-    # Import here to avoid circular import
-    from glaip_sdk.cli.auth import resolve_credentials  # noqa: PLC0415
-
-    module = importlib.import_module("glaip_sdk")
-    client_class = cast("type[Client]", module.Client)
-    context_config_obj = getattr(ctx, "obj", None)
-    context_config = context_config_obj if isinstance(context_config_obj, Mapping) else {}
-
-    account_name = context_config.get("account_name")
-    api_url, api_key, _ = resolve_credentials(
-        account_name=account_name,
-        api_url=context_config.get("api_url"),
-        api_key=context_config.get("api_key"),
-    )
-
-    if not api_url or not api_key:
-        configure_hint = command_hint("accounts add", slash_command="login", ctx=ctx)
-        actions: list[str] = []
-        if configure_hint:
-            actions.append(f"Run `{configure_hint}` to add an account profile")
-        else:
-            actions.append("add an account with 'aip accounts add'")
-        raise click.ClickException(f"Missing api_url/api_key. {' or '.join(actions)}.")
-
-    # Get timeout from context or config
-    timeout = context_config.get("timeout")
-    if timeout is None:
-        raw_timeout = os.getenv("AIP_TIMEOUT", "0") or "0"
-        try:
-            timeout = float(raw_timeout) if raw_timeout != "0" else None
-        except ValueError:
-            timeout = None
-    if timeout is None:
-        # Fallback to legacy config
-        file_config = load_config() or {}
-        timeout = file_config.get("timeout")
-
-    return client_class(
-        api_url=api_url,
-        api_key=api_key,
-        timeout=float(timeout or 30.0),
-    )