griptape-nodes 0.52.1__py3-none-any.whl → 0.54.0__py3-none-any.whl

griptape_nodes/cli/commands/models.py

@@ -0,0 +1,504 @@
+"""Models command for managing AI models."""
+
+import asyncio
+from typing import TYPE_CHECKING
+
+import typer
+from rich.table import Table
+
+from griptape_nodes.cli.shared import console
+from griptape_nodes.retained_mode.events.model_events import (
+    DeleteModelDownloadRequest,
+    DeleteModelDownloadResultFailure,
+    DeleteModelDownloadResultSuccess,
+    DeleteModelRequest,
+    DeleteModelResultFailure,
+    DeleteModelResultSuccess,
+    ListModelDownloadsRequest,
+    ListModelDownloadsResultFailure,
+    ListModelDownloadsResultSuccess,
+    ListModelsRequest,
+    ListModelsResultFailure,
+    ListModelsResultSuccess,
+    ModelInfo,
+    QueryInfo,
+    SearchModelsRequest,
+    SearchModelsResultFailure,
+    SearchModelsResultSuccess,
+)
+from griptape_nodes.retained_mode.retained_mode import GriptapeNodes
+
+if TYPE_CHECKING:
+    from griptape_nodes.retained_mode.events.model_events import ModelDownloadStatus
+
+app = typer.Typer(help="Manage AI models.")
+downloads_app = typer.Typer(help="Manage model download tracking records.")
+
+# Add downloads subcommand
+app.add_typer(downloads_app, name="downloads")
+
+
+@app.command("download")
+def download_command(
+    model_id: str = typer.Argument(..., help="Model ID or URL (e.g., 'microsoft/DialoGPT-medium')"),
+    local_dir: str | None = typer.Option(None, "--local-dir", help="Local directory to download the model to"),
+    revision: str = typer.Option("main", "--revision", help="Git revision to download"),
+) -> None:
+    """Download a model from Hugging Face Hub."""
+    asyncio.run(_download_model(model_id, local_dir, revision))
+
+
+@app.command("list")
+def list_command() -> None:
+    """List all downloaded model files in local cache."""
+    asyncio.run(_list_models())
+
+
+@app.command("delete")
+def delete_command(
+    model_id: str = typer.Argument(..., help="Model ID to delete (e.g., 'microsoft/DialoGPT-medium')"),
+) -> None:
+    """Delete model files from local cache."""
+    asyncio.run(_delete_model(model_id))
+
+
+@downloads_app.command("status")
+def downloads_status_command(
+    model_id: str = typer.Argument(None, help="Optional model ID to check download status for"),
+) -> None:
+    """Show download status for a specific model or all models."""
+    asyncio.run(_get_model_status(model_id))
+
+
+@downloads_app.command("list")
+def downloads_list_command() -> None:
+    """List all model download status records."""
+    asyncio.run(_get_model_status(None))
+
+
+@downloads_app.command("delete")
+def downloads_delete_command(
+    model_id: str = typer.Argument(
+        ..., help="Model ID to delete download status for (e.g., 'microsoft/DialoGPT-medium')"
+    ),
+) -> None:
+    """Delete download status tracking records for a model."""
+    asyncio.run(_delete_model_status(model_id))
+
+
+@app.command("search")
+def search_command(
+    query: str | None = typer.Argument(None, help="Search query to match against model names"),
+    task: str | None = typer.Option(None, "--task", help="Filter by task type"),
+    limit: int = typer.Option(20, "--limit", help="Maximum number of results (max: 100)"),
+    sort: str = typer.Option("downloads", "--sort", help="Sort results by"),
+    direction: str = typer.Option("desc", "--direction", help="Sort direction"),
+) -> None:
+    """Search for models on Hugging Face Hub."""
+    asyncio.run(_search_models(query, task, limit, sort, direction))
+
+
+async def _download_model(
+    model_id: str,
+    local_dir: str | None,
+    revision: str,
+) -> None:
+    """Download a model from Hugging Face Hub.
+
+    Args:
+        model_id: Model ID or URL to download
+        local_dir: Local directory to download the model to
+        revision: Git revision to download
+    """
+    console.print(f"[bold green]Downloading model: {model_id}[/bold green]")
+
+    try:
+        # ModelManager DownloadModelRequest will use this command so it's important that we don't use the request ourselves
+        model_manager = GriptapeNodes.ModelManager()
+        local_path = model_manager.download_model(
+            model_id=model_id,
+            local_dir=local_dir,
+            revision=revision,
+            allow_patterns=None,
+            ignore_patterns=None,
+        )
+
+        # Success case
+        console.print("[bold green]Model downloaded successfully![/bold green]")
+        console.print(f"[green]Downloaded to: {local_path}[/green]")
+
+    except Exception as e:
+        console.print("[bold red]Model download failed:[/bold red]")
+        console.print(f"[red]{e}[/red]")
+
+
+async def _list_models() -> None:
+    """List all downloaded models in the local cache."""
+    console.print("[bold green]Listing cached models...[/bold green]")
+
+    # Create the list request
+    request = ListModelsRequest()
+
+    try:
+        # Use the ModelManager to handle the listing
+        result = await GriptapeNodes.ahandle_request(request)
+        if isinstance(result, ListModelsResultSuccess):
+            # Success case
+            models = result.models
+            if models:
+                console.print(f"[bold green]Found {len(models)} cached models:[/bold green]")
+
+                table = Table()
+                table.add_column("Model ID", style="green")
+                table.add_column("Size (GB)", style="cyan", justify="right")
+
+                for model in models:
+                    size_gb = round((model.size_bytes or 0) / (1024**3), 2) if model.size_bytes else 0.0
+                    table.add_row(model.model_id, str(size_gb))
+                console.print(table)
+            else:
+                console.print("[yellow]No models found in local cache[/yellow]")
+
+        # Failure case
+
+        elif isinstance(result, ListModelsResultFailure):
+            console.print("[bold red]Model listing failed:[/bold red]")
+            if result.result_details:
+                console.print(f"[red]{result.result_details}[/red]")
+            if result.exception:
+                console.print(f"[dim]Error: {result.exception}[/dim]")
+        else:
+            console.print("[bold red]Model listing failed: Unknown error occurred[/bold red]")
+
+    except Exception as e:
+        console.print("[bold red]Unexpected error during model listing:[/bold red]")
+        console.print(f"[red]{e}[/red]")
+
+
+async def _delete_model(model_id: str) -> None:
+    """Delete a model from the local cache.
+
+    Args:
+        model_id: Model ID to delete
+    """
+    console.print(f"[bold yellow]Deleting model: {model_id}[/bold yellow]")
+
+    # Create the delete request
+    request = DeleteModelRequest(model_id=model_id)
+
+    try:
+        # Use the ModelManager to handle the deletion
+        result = await GriptapeNodes.ahandle_request(request)
+
+        if isinstance(result, DeleteModelResultSuccess):
+            # Success case
+            console.print("[bold green]Model deleted successfully![/bold green]")
+            console.print(f"[green]Deleted: {result.deleted_path}[/green]")
+        # Failure case
+
+        elif isinstance(result, DeleteModelResultFailure):
+            console.print("[bold red]Model deletion failed:[/bold red]")
+            if result.result_details:
+                console.print(f"[red]{result.result_details}[/red]")
+            if result.exception:
+                console.print(f"[dim]Error: {result.exception}[/dim]")
+        else:
+            console.print("[bold red]Model deletion failed: Unknown error occurred[/bold red]")
+
+    except Exception as e:
+        console.print("[bold red]Unexpected error during model deletion:[/bold red]")
+        console.print(f"[red]{e}[/red]")
+
+
+def _format_download_row(download: "ModelDownloadStatus") -> tuple[str, str, str, str, str, str]:
+    """Format a download status object into table row data.
+
+    Args:
+        download: ModelDownloadStatus object
+
+    Returns:
+        tuple: (model_id, status_colored, progress_str, size_str, eta_str, started_str)
+    """
+    progress_str = _format_progress(download)
+    size_str = _format_size(download)
+    eta_str = _format_eta(download)
+    started_str = _format_timestamp(download)
+    status_colored = _format_status(download)
+
+    return (
+        download.model_id,
+        status_colored,
+        progress_str,
+        size_str,
+        eta_str,
+        started_str,
+    )
+
+
+def _format_progress(download: "ModelDownloadStatus") -> str:
+    """Format download progress information."""
+    if download.total_files is not None and download.completed_files is not None and download.total_files > 0:
+        progress_percent = (download.completed_files / download.total_files) * 100
+        return f"{progress_percent:.1f}%"
+    return "Unknown"
+
+
+def _format_size(download: "ModelDownloadStatus") -> str:
+    """Format download size information."""
+    if download.total_files is not None and download.completed_files is not None:
+        return f"{download.completed_files}/{download.total_files} files"
+    return "Unknown"
+
+
+def _format_eta(download: "ModelDownloadStatus") -> str:
+    """Format estimated time of arrival."""
+    # ETA is not available in the current ModelDownloadStatus structure
+    # For active downloads, we could potentially calculate based on progress
+    # but without timing data, we return a status-appropriate message
+    if download.status == "downloading":
+        return "In progress"
+    if download.status == "completed":
+        return "Completed"
+    if download.status == "failed":
+        return "Failed"
+    return "Unknown"
+
+
+def _format_timestamp(download: "ModelDownloadStatus") -> str:
+    """Format started timestamp."""
+    started_at = download.started_at
+    if not started_at:
+        return "Unknown"
+
+    try:
+        from datetime import datetime
+
+        dt = datetime.fromisoformat(started_at)
+        return dt.strftime("%H:%M:%S")
+    except Exception:
+        return started_at[:10]  # Fallback
+
+
+def _format_status(download: "ModelDownloadStatus") -> str:
+    """Format status with color coding."""
+    status = download.status
+    status_colors = {
+        "completed": "green",
+        "failed": "red",
+        "downloading": "yellow",
+    }
+
+    if status in status_colors:
+        return f"[{status_colors[status]}]{status}[/{status_colors[status]}]"
+    return status
+
+
+def _display_downloads_table(downloads: list["ModelDownloadStatus"]) -> None:
+    """Display downloads in a formatted table.
+
+    Args:
+        downloads: List of ModelDownloadStatus objects
+    """
+    console.print(f"[bold green]Found {len(downloads)} download(s):[/bold green]")
+
+    table = Table()
+    table.add_column("Model ID", style="green")
+    table.add_column("Status", style="cyan")
+    table.add_column("Progress", style="yellow", justify="right")
+    table.add_column("Size", style="blue", justify="right")
+    table.add_column("ETA", style="magenta", justify="right")
+    table.add_column("Started", style="dim")
+
+    for download in downloads:
+        row_data = _format_download_row(download)
+        table.add_row(*row_data)
+
+    console.print(table)
+
+
+async def _get_model_status(model_id: str | None) -> None:
+    """Get download status for models.
+
+    Args:
+        model_id: Optional model ID to get status for
+    """
+    if model_id:
+        console.print(f"[bold green]Getting download status for: {model_id}[/bold green]")
+    else:
+        console.print("[bold green]Getting download status for all models...[/bold green]")
+
+    # Create the status request
+    request = ListModelDownloadsRequest(model_id=model_id)
+
+    try:
+        # Use the ModelManager to handle the status query
+        result = await GriptapeNodes.ahandle_request(request)
+
+        if isinstance(result, ListModelDownloadsResultSuccess):
+            # Success case
+            downloads = result.downloads
+            if downloads:
+                _display_downloads_table(downloads)
+            elif model_id:
+                console.print(f"[yellow]No download found for model: {model_id}[/yellow]")
+            else:
+                console.print("[yellow]No downloads found[/yellow]")
+
+        elif isinstance(result, ListModelDownloadsResultFailure):
+            console.print("[bold red]Failed to get download status:[/bold red]")
+            if result.result_details:
+                console.print(f"[red]{result.result_details}[/red]")
+            if result.exception:
+                console.print(f"[dim]Error: {result.exception}[/dim]")
+        else:
+            console.print("[bold red]Failed to get download status: Unknown error occurred[/bold red]")
+
+    except Exception as e:
+        console.print("[bold red]Unexpected error getting download status:[/bold red]")
+        console.print(f"[red]{e}[/red]")
+
+
+async def _search_models(
+    query: str | None,
+    task: str | None,
+    limit: int,
+    sort: str,
+    direction: str,
+) -> None:
+    """Search for models on Hugging Face Hub.
+
+    Args:
+        query: Search query to match against model names
+        task: Filter by task type
+        limit: Maximum number of results
+        sort: Sort results by
+        direction: Sort direction
+    """
+    if query:
+        console.print(f"[bold green]Searching for models: {query}[/bold green]")
+    else:
+        console.print("[bold green]Searching for models...[/bold green]")
+
+    # Create the search request
+    request = SearchModelsRequest(
+        query=query,
+        task=task,
+        library=None,
+        author=None,
+        tags=None,
+        limit=limit,
+        sort=sort,
+        direction=direction,
+    )
+
+    try:
+        # Use the ModelManager to handle the search
+        result = await GriptapeNodes.ahandle_request(request)
+
+        if isinstance(result, SearchModelsResultSuccess):
+            # Success case
+            models = result.models
+            if models:
+                _display_search_results(models, result.query_info)
+            else:
+                console.print("[yellow]No models found matching the search criteria[/yellow]")
+
+        elif isinstance(result, SearchModelsResultFailure):
+            console.print("[bold red]Model search failed:[/bold red]")
+            if result.result_details:
+                console.print(f"[red]{result.result_details}[/red]")
+            if result.exception:
+                console.print(f"[dim]Error: {result.exception}[/dim]")
+        else:
+            console.print("[bold red]Model search failed: Unknown error occurred[/bold red]")
+
+    except Exception as e:
+        console.print("[bold red]Unexpected error during model search:[/bold red]")
+        console.print(f"[red]{e}[/red]")
+
+
+def _display_search_results(models: list[ModelInfo], query_info: QueryInfo) -> None:
+    """Display model search results in a formatted table.
+
+    Args:
+        models: List of model information
+        query_info: Information about the search query
+    """
+    console.print(f"[bold green]Found {len(models)} models[/bold green]")
+
+    # Show search parameters if any were used
+    params = []
+    if query_info.query:
+        params.append(f"query: {query_info.query}")
+    if query_info.task:
+        params.append(f"task: {query_info.task}")
+    if query_info.library:
+        params.append(f"library: {query_info.library}")
+    if query_info.author:
+        params.append(f"author: {query_info.author}")
+    if query_info.tags:
+        params.append(f"tags: {', '.join(query_info.tags)}")
+
+    if params:
+        console.print(f"[dim]Search parameters: {', '.join(params)}[/dim]")
+
+    table = Table()
+    table.add_column("Model ID", style="green")
+    table.add_column("Author", style="blue")
+    table.add_column("Downloads", style="cyan", justify="right")
+    table.add_column("Likes", style="yellow", justify="right")
+    table.add_column("Task", style="magenta")
+    table.add_column("Library", style="dim")
+
+    for model in models:
+        downloads_str = f"{model.downloads:,}" if model.downloads else "0"
+        likes_str = str(model.likes or 0)
+        task_str = model.task or ""
+        library_str = model.library or ""
+        author_str = model.author or ""
+
+        table.add_row(
+            model.model_id,
+            author_str,
+            downloads_str,
+            likes_str,
+            task_str,
+            library_str,
+        )
+
+    console.print(table)
+
+
+async def _delete_model_status(model_id: str) -> None:
+    """Delete download status records for a model.
+
+    Args:
+        model_id: Model ID to delete download status for
+    """
+    console.print(f"[bold yellow]Deleting download status for: {model_id}[/bold yellow]")
+
+    # Create the delete request
+    request = DeleteModelDownloadRequest(model_id=model_id)
+
+    try:
+        # Use the ModelManager to handle the deletion
+        result = await GriptapeNodes.ahandle_request(request)
+
+        if isinstance(result, DeleteModelDownloadResultSuccess):
+            # Success case
+            console.print("[bold green]Download status deleted successfully![/bold green]")
+            console.print(f"[green]Deleted status file: {result.deleted_path}[/green]")
+        # Failure case
+
+        elif isinstance(result, DeleteModelDownloadResultFailure):
+            console.print("[bold red]Download status deletion failed:[/bold red]")
+            if result.result_details:
+                console.print(f"[red]{result.result_details}[/red]")
+            if result.exception:
+                console.print(f"[dim]Error: {result.exception}[/dim]")
+        else:
+            console.print("[bold red]Download status deletion failed: Unknown error occurred[/bold red]")
+
+    except Exception as e:
+        console.print("[bold red]Unexpected error during download status deletion:[/bold red]")
+        console.print(f"[red]{e}[/red]")

griptape_nodes/cli/commands/self.py

@@ -0,0 +1,120 @@
+"""Self command for Griptape Nodes CLI."""
+
+import shutil
+import sys
+
+import typer
+
+from griptape_nodes.cli.shared import (
+    CONFIG_DIR,
+    DATA_DIR,
+    GITHUB_UPDATE_URL,
+    LATEST_TAG,
+    PYPI_UPDATE_URL,
+    console,
+)
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+from griptape_nodes.utils.uv_utils import find_uv_bin
+from griptape_nodes.utils.version_utils import (
+    get_complete_version_string,
+    get_current_version,
+    get_latest_version_git,
+    get_latest_version_pypi,
+)
+
+config_manager = GriptapeNodes.ConfigManager()
+secrets_manager = GriptapeNodes.SecretsManager()
+os_manager = GriptapeNodes.OSManager()
+
+app = typer.Typer(help="Manage this CLI installation.")
+
+
+@app.command()
+def update() -> None:
+    """Update the CLI."""
+    _update_self()
+
+
+@app.command()
+def uninstall() -> None:
+    """Uninstall the CLI."""
+    _uninstall_self()
+
+
+@app.command()
+def version() -> None:
+    """Print the CLI version."""
+    _print_current_version()
+
+
+def _get_latest_version(package: str, install_source: str) -> str:
+    """Fetches the latest release tag from PyPI.
+
+    Args:
+        package: The name of the package to fetch the latest version for.
+        install_source: The source from which the package is installed (e.g., "pypi", "git", "file").
+
+    Returns:
+        str: Latest release tag (e.g., "v0.31.4")
+    """
+    if install_source == "pypi":
+        return get_latest_version_pypi(package, PYPI_UPDATE_URL)
+    if install_source == "git":
+        return get_latest_version_git(package, GITHUB_UPDATE_URL, LATEST_TAG)
+    # If the package is installed from a file, just return the current version since the user is likely managing it manually
+    return get_current_version()
+
+
+def _update_self() -> None:
+    """Installs the latest release of the CLI *and* refreshes bundled libraries."""
+    console.print("[bold green]Starting updater...[/bold green]")
+
+    os_manager.replace_process([sys.executable, "-m", "griptape_nodes.updater"])
+
+
+def _print_current_version() -> None:
+    """Prints the current version of the script."""
+    version_string = get_complete_version_string()
+    console.print(f"[bold green]{version_string}[/bold green]")
+
+
+def _uninstall_self() -> None:
+    """Uninstalls itself by removing config/data directories and the executable."""
+    console.print("[bold]Uninstalling Griptape Nodes...[/bold]")
+
+    # Remove config and data directories
+    console.print("[bold]Removing config and data directories...[/bold]")
+    dirs = [(CONFIG_DIR, "Config Dir"), (DATA_DIR, "Data Dir")]
+    caveats = []
+    for dir_path, dir_name in dirs:
+        if dir_path.exists():
+            console.print(f"[bold]Removing {dir_name} '{dir_path}'...[/bold]")
+            try:
+                shutil.rmtree(dir_path)
+            except OSError as exc:
+                console.print(f"[red]Error removing {dir_name} '{dir_path}': {exc}[/red]")
+                caveats.append(
+                    f"- [red]Error removing {dir_name} '{dir_path}'. You may want remove this directory manually.[/red]"
+                )
+        else:
+            console.print(f"[yellow]{dir_name} '{dir_path}' does not exist; skipping.[/yellow]")
+
+    # Handle any remaining config files not removed by design
+    remaining_config_files = config_manager.config_files
+    if remaining_config_files:
+        caveats.append("- Some config files were intentionally not removed:")
+        caveats.extend(f"\t[yellow]- {file}[/yellow]" for file in remaining_config_files)
+
+    # If there were any caveats to the uninstallation process, print them
+    if caveats:
+        console.print("[bold]Caveats:[/bold]")
+        for line in caveats:
+            console.print(line)
+
+    # Remove the executable
+    console.print("[bold]Removing the executable...[/bold]")
+    console.print("[bold yellow]When done, press Enter to exit.[/bold yellow]")
+
+    # Remove the tool using UV
+    uv_path = find_uv_bin()
+    os_manager.replace_process([uv_path, "tool", "uninstall", "griptape-nodes"])

griptape_nodes/cli/main.py

@@ -0,0 +1,56 @@
+"""Main CLI application using typer."""
+
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+# Add current directory to path for imports to work
+sys.path.append(str(Path.cwd()))
+
+from griptape_nodes.cli.commands import config, engine, init, libraries, models, self
+from griptape_nodes.utils.version_utils import get_complete_version_string
+
+console = Console()
+
+app = typer.Typer(
+    name="griptape-nodes",
+    help="Griptape Nodes Engine CLI",
+    no_args_is_help=False,
+    rich_markup_mode="rich",
+    invoke_without_command=True,
+)
+
+# Add subcommands
+app.command("init", help="Initialize engine configuration.")(init.init_command)
+app.add_typer(config.app, name="config")
+app.add_typer(self.app, name="self")
+app.add_typer(libraries.app, name="libraries")
+app.add_typer(models.app, name="models")
+app.command("engine")(engine.engine_command)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(  # noqa: FBT001
+        False, "--version", help="Show version and exit."
+    ),
+    no_update: bool = typer.Option(  # noqa: FBT001
+        False, "--no-update", help="Skip the auto-update check."
+    ),
+) -> None:
+    """Griptape Nodes Engine CLI."""
+    if version:
+        version_string = get_complete_version_string()
+        console.print(f"[bold green]{version_string}[/bold green]")
+        raise typer.Exit
+
+    if ctx.invoked_subcommand is None:
+        # Default to engine command when no subcommand is specified
+        engine.engine_command(no_update=no_update)
+
+
+if __name__ == "__main__":
+    app()