pltr-cli 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

pltr/commands/models.py

@@ -0,0 +1,362 @@
+"""
+Models management commands for Foundry.
+Provides commands for managing ML models and model versions in the registry.
+
+Note: This is distinct from LanguageModels, which handles LLM chat/embeddings operations.
+"""
+
+import typer
+from typing import Optional
+from rich.console import Console
+
+from ..services.models import ModelsService
+from ..utils.formatting import OutputFormatter
+from ..utils.progress import SpinnerProgressTracker
+from ..auth.base import ProfileNotFoundError, MissingCredentialsError
+from ..utils.completion import (
+    complete_rid,
+    complete_profile,
+    complete_output_format,
+)
+
+# Create main app and sub-apps
+app = typer.Typer(help="Manage ML models and versions")
+model_app = typer.Typer(help="Manage models")
+version_app = typer.Typer(help="Manage model versions")
+
+# Add sub-apps
+app.add_typer(model_app, name="model")
+app.add_typer(version_app, name="version")
+
+console = Console()
+formatter = OutputFormatter(console)
+
+
+@model_app.command("create")
+def create_model(
+    name: str = typer.Argument(
+        ...,
+        help="Model name",
+    ),
+    folder: str = typer.Option(
+        ...,
+        "--folder",
+        "-f",
+        help="Parent folder RID (e.g., ri.compass.main.folder.xxx)",
+        autocompletion=complete_rid,
+    ),
+    profile: Optional[str] = typer.Option(
+        None,
+        "--profile",
+        "-p",
+        help="Profile name",
+        autocompletion=complete_profile,
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file path (writes to file instead of stdout)",
+    ),
+    preview: bool = typer.Option(
+        False,
+        "--preview",
+        help="Enable preview mode",
+    ),
+):
+    """
+    Create a new ML model in the registry.
+
+    Creates a model container that can hold multiple versions.
+
+    Note: SDK does not support listing all models. Use the Foundry web UI
+    or Ontology API to discover existing models.
+
+    Examples:
+
+        # Create a new model
+        pltr models model create "fraud-detector" \\
+            --folder ri.compass.main.folder.xxx
+
+        # Create with JSON output
+        pltr models model create "recommendation-engine" \\
+            --folder ri.compass.main.folder.xxx \\
+            --format json
+
+        # Save to file
+        pltr models model create "anomaly-detector" \\
+            --folder ri.compass.main.folder.xxx \\
+            --output model-info.json
+    """
+    try:
+        with SpinnerProgressTracker().track_spinner("Creating model"):
+            service = ModelsService(profile=profile)
+            result = service.create_model(
+                name=name,
+                parent_folder_rid=folder,
+                preview=preview,
+            )
+
+        console.print(f"[green]✓[/green] Created model: {result.get('name')}")
+        console.print(f"  Model RID: {result.get('rid')}")
+
+        formatter.format_output(result, format, output)
+
+        if output:
+            console.print(f"[green]✓[/green] Model information saved to {output}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        console.print(f"[red]Authentication Error: {e}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@model_app.command("get")
+def get_model(
+    model_rid: str = typer.Argument(
+        ...,
+        help="Model RID (e.g., ri.foundry.main.model.xxx)",
+        autocompletion=complete_rid,
+    ),
+    profile: Optional[str] = typer.Option(
+        None,
+        "--profile",
+        "-p",
+        help="Profile name",
+        autocompletion=complete_profile,
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file path (writes to file instead of stdout)",
+    ),
+    preview: bool = typer.Option(
+        False,
+        "--preview",
+        help="Enable preview mode",
+    ),
+):
+    """
+    Get information about a model.
+
+    Retrieves model metadata including name, folder location, and other properties.
+
+    Examples:
+
+        # Get model details
+        pltr models model get ri.foundry.main.model.abc123
+
+        # Get as JSON
+        pltr models model get ri.foundry.main.model.abc123 --format json
+
+        # Save to file
+        pltr models model get ri.foundry.main.model.abc123 \\
+            --format json \\
+            --output model-details.json
+    """
+    try:
+        with SpinnerProgressTracker().track_spinner("Fetching model information"):
+            service = ModelsService(profile=profile)
+            result = service.get_model(
+                model_rid=model_rid,
+                preview=preview,
+            )
+
+        formatter.format_output(result, format, output)
+
+        if output:
+            console.print(f"[green]✓[/green] Model information saved to {output}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        console.print(f"[red]Authentication Error: {e}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@version_app.command("get")
+def get_version(
+    model_rid: str = typer.Argument(
+        ...,
+        help="Model RID (e.g., ri.foundry.main.model.xxx)",
+        autocompletion=complete_rid,
+    ),
+    version_rid: str = typer.Argument(
+        ...,
+        help="Version identifier (e.g., v1.0.0 or version RID)",
+    ),
+    profile: Optional[str] = typer.Option(
+        None,
+        "--profile",
+        "-p",
+        help="Profile name",
+        autocompletion=complete_profile,
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file path (writes to file instead of stdout)",
+    ),
+    preview: bool = typer.Option(
+        False,
+        "--preview",
+        help="Enable preview mode",
+    ),
+):
+    """
+    Get information about a specific model version.
+
+    Retrieves version metadata including creation time, schema, and other properties.
+
+    Examples:
+
+        # Get specific version
+        pltr models version get ri.foundry.main.model.abc123 v1.0.0
+
+        # Get as JSON
+        pltr models version get ri.foundry.main.model.abc123 v1.0.0 \\
+            --format json
+
+        # Save to file
+        pltr models version get ri.foundry.main.model.abc123 v1.0.0 \\
+            --format json \\
+            --output version-details.json
+    """
+    try:
+        with SpinnerProgressTracker().track_spinner("Fetching version information"):
+            service = ModelsService(profile=profile)
+            result = service.get_model_version(
+                model_rid=model_rid,
+                model_version_rid=version_rid,
+                preview=preview,
+            )
+
+        formatter.format_output(result, format, output)
+
+        if output:
+            console.print(f"[green]✓[/green] Version information saved to {output}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        console.print(f"[red]Authentication Error: {e}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@version_app.command("list")
+def list_versions(
+    model_rid: str = typer.Argument(
+        ...,
+        help="Model RID (e.g., ri.foundry.main.model.xxx)",
+        autocompletion=complete_rid,
+    ),
+    page_size: Optional[int] = typer.Option(
+        None,
+        "--page-size",
+        help="Maximum number of versions to return per page",
+    ),
+    page_token: Optional[str] = typer.Option(
+        None,
+        "--page-token",
+        help="Token for fetching next page of results",
+    ),
+    profile: Optional[str] = typer.Option(
+        None,
+        "--profile",
+        "-p",
+        help="Profile name",
+        autocompletion=complete_profile,
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file path (writes to file instead of stdout)",
+    ),
+    preview: bool = typer.Option(
+        False,
+        "--preview",
+        help="Enable preview mode",
+    ),
+):
+    """
+    List all versions of a model with pagination support.
+
+    Returns a list of model versions with their metadata.
+
+    Examples:
+
+        # List all versions
+        pltr models version list ri.foundry.main.model.abc123
+
+        # List with pagination
+        pltr models version list ri.foundry.main.model.abc123 \\
+            --page-size 50
+
+        # Get next page
+        pltr models version list ri.foundry.main.model.abc123 \\
+            --page-size 50 \\
+            --page-token <token-from-previous-response>
+
+        # Save to file
+        pltr models version list ri.foundry.main.model.abc123 \\
+            --format json \\
+            --output versions.json
+    """
+    try:
+        with SpinnerProgressTracker().track_spinner("Fetching model versions"):
+            service = ModelsService(profile=profile)
+            result = service.list_model_versions(
+                model_rid=model_rid,
+                page_size=page_size,
+                page_token=page_token,
+                preview=preview,
+            )
+
+        formatter.format_output(result, format, output)
+
+        # Show pagination info if available (only when outputting to console, not file)
+        if not output and result.get("nextPageToken"):
+            console.print(
+                f"[dim]Next page available. Use --page-token {result['nextPageToken']}[/dim]"
+            )
+
+        if output:
+            console.print(f"[green]✓[/green] Version list saved to {output}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        console.print(f"[red]Authentication Error: {e}[/red]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1)

pltr/commands/ontology.py

@@ -15,6 +15,7 @@ from ..services.ontology import (
     QueryService,
 )
 from ..utils.formatting import OutputFormatter
+from ..utils.pagination import PaginationConfig
 from ..utils.progress import SpinnerProgressTracker
 from ..auth.base import ProfileNotFoundError, MissingCredentialsError
 
@@ -176,36 +177,66 @@ def list_objects(
         None, "--output", "-o", help="Output file path"
     ),
     page_size: Optional[int] = typer.Option(
-        None, "--page-size", help="Number of results per page"
+        None, "--page-size", help="Number of objects per page (default: from settings)"
+    ),
+    max_pages: Optional[int] = typer.Option(
+        1, "--max-pages", help="Maximum number of pages to fetch (default: 1)"
+    ),
+    page_token: Optional[str] = typer.Option(
+        None, "--page-token", help="Page token to resume from previous response"
+    ),
+    all: bool = typer.Option(
+        False, "--all", help="Fetch all available pages (overrides --max-pages)"
     ),
     properties: Optional[str] = typer.Option(
         None, "--properties", help="Comma-separated list of properties to include"
     ),
 ):
-    """List objects of a specific type."""
+    """
+    List objects of a specific type with pagination support.
+
+    By default, fetches only the first page of results. Use --all to fetch all objects,
+    or --max-pages to control how many pages to fetch.
+
+    Examples:
+        # List first page of objects (default)
+        pltr ontology object-list ONTOLOGY_RID ObjectType
+
+        # List all objects
+        pltr ontology object-list ONTOLOGY_RID ObjectType --all
+
+        # List first 3 pages
+        pltr ontology object-list ONTOLOGY_RID ObjectType --max-pages 3
+
+        # Resume from a specific page
+        pltr ontology object-list ONTOLOGY_RID ObjectType --page-token abc123
+    """
     try:
         service = OntologyObjectService(profile=profile)
 
         prop_list = properties.split(",") if properties else None
 
+        # Create pagination config
+        config = PaginationConfig(
+            page_size=page_size,
+            max_pages=max_pages,
+            page_token=page_token,
+            fetch_all=all,
+        )
+
         with SpinnerProgressTracker().track_spinner(
             f"Fetching {object_type} objects..."
         ):
-            objects = service.list_objects(
-                ontology_rid, object_type, page_size=page_size, properties=prop_list
+            result = service.list_objects_paginated(
+                ontology_rid, object_type, config, properties=prop_list
             )
 
-        if format == "table" and objects:
-            # Use first object's keys as columns
-            columns = list(objects[0].keys()) if objects else []
-            formatter.format_table(
-                objects, columns=columns, format=format, output=output
-            )
-        else:
-            formatter.format_list(objects, format=format, output=output)
-
+        # Format and display paginated results
         if output:
+            formatter.format_paginated_output(result, format, output)
             formatter.print_success(f"Objects saved to {output}")
+        else:
+            formatter.format_paginated_output(result, format)
 
     except (ProfileNotFoundError, MissingCredentialsError) as e:
         formatter.print_error(f"Authentication error: {e}")

pltr/commands/orchestration.py

@@ -9,6 +9,7 @@ from rich.console import Console
 
 from ..services.orchestration import OrchestrationService
 from ..utils.formatting import OutputFormatter
+from ..utils.pagination import PaginationConfig
 from ..utils.progress import SpinnerProgressTracker
 from ..auth.base import ProfileNotFoundError, MissingCredentialsError
 from ..utils.completion import (
@@ -226,7 +227,7 @@ def get_build_jobs(
 
         if response.get("next_page_token"):
             formatter.print_info(
-                "More results available. Use pagination token to fetch next page."
+                f"More results available. Use --page-token {response['next_page_token']} to fetch next page."
             )
 
     except (ProfileNotFoundError, MissingCredentialsError) as e:
@@ -241,7 +242,16 @@ def get_build_jobs(
 def search_builds(
     profile: Optional[str] = typer.Option(None, "--profile", "-p", help="Profile name"),
     page_size: Optional[int] = typer.Option(
-        None, "--page-size", help="Number of results per page"
+        None, "--page-size", help="Number of builds per page (default: from settings)"
+    ),
+    max_pages: Optional[int] = typer.Option(
+        1, "--max-pages", help="Maximum number of pages to fetch (default: 1)"
+    ),
+    page_token: Optional[str] = typer.Option(
+        None, "--page-token", help="Page token to resume from previous response"
+    ),
+    all: bool = typer.Option(
+        False, "--all", help="Fetch all available pages (overrides --max-pages)"
     ),
     format: str = typer.Option(
         "table", "--format", "-f", help="Output format (table, json, csv)"
@@ -250,12 +260,102 @@ def search_builds(
         None, "--output", "-o", help="Output file path"
     ),
 ):
-    """Search for builds."""
+    """
+    Search for builds with pagination support.
+
+    By default, fetches only the first page of results. Use --all to fetch all builds,
+    or --max-pages to control how many pages to fetch.
+
+    Examples:
+        # Search first page of builds (default)
+        pltr orchestration builds search
+
+        # Search all builds
+        pltr orchestration builds search --all
+
+        # Search first 3 pages
+        pltr orchestration builds search --max-pages 3
+
+        # Resume from a specific page
+        pltr orchestration builds search --page-token abc123
+    """
     try:
         service = OrchestrationService(profile=profile)
 
+        # Create pagination config
+        config = PaginationConfig(
+            page_size=page_size,
+            max_pages=max_pages,
+            page_token=page_token,
+            fetch_all=all,
+        )
+
         with SpinnerProgressTracker().track_spinner("Searching builds..."):
-            response = service.search_builds(page_size=page_size)
+            result = service.search_builds_paginated(config)
+
+        if not result.data:
+            formatter.print_warning("No builds found")
+            return
+
+        # Format and display paginated results
+        if output:
+            formatter.format_paginated_output(
+                result,
+                format,
+                output,
+                formatter_fn=lambda data, fmt, out: formatter.format_builds_list(
+                    data, fmt, out
+                ),
+            )
+            formatter.print_success(f"Builds list saved to {output}")
+        else:
+            formatter.format_paginated_output(
+                result,
+                format,
+                formatter_fn=lambda data, fmt, out: formatter.format_builds_list(
+                    data, fmt, out
+                ),
+            )
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to search builds: {e}")
+        raise typer.Exit(1)
+
+
+@builds_app.command("get-batch")
+def get_builds_batch(
+    build_rids: str = typer.Argument(
+        ..., help="Comma-separated list of Build RIDs (max 100)"
+    ),
+    profile: Optional[str] = typer.Option(None, "--profile", "-p", help="Profile name"),
+    format: str = typer.Option(
+        "table", "--format", "-f", help="Output format (table, json, csv)"
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """Get multiple builds in batch (max 100)."""
+    try:
+        rids_list = [rid.strip() for rid in build_rids.split(",") if rid.strip()]
+
+        if not rids_list:
+            formatter.print_error("No valid RIDs provided")
+            raise typer.Exit(1)
+
+        if len(rids_list) > 100:
+            formatter.print_error("Maximum batch size is 100 builds")
+            raise typer.Exit(1)
+
+        service = OrchestrationService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching {len(rids_list)} builds..."
+        ):
+            response = service.get_builds_batch(rids_list)
 
         builds = response.get("builds", [])
 
@@ -266,18 +366,13 @@ def search_builds(
         formatter.format_builds_list(builds, format, output)
 
         if output:
-            formatter.print_success(f"Builds list saved to {output}")
-
-        if response.get("next_page_token"):
-            formatter.print_info(
-                "More results available. Use pagination token to fetch next page."
-            )
+            formatter.print_success(f"Builds information saved to {output}")
 
     except (ProfileNotFoundError, MissingCredentialsError) as e:
         formatter.print_error(f"Authentication error: {e}")
         raise typer.Exit(1)
     except Exception as e:
-        formatter.print_error(f"Failed to search builds: {e}")
+        formatter.print_error(f"Failed to get builds batch: {e}")
         raise typer.Exit(1)
 
 
@@ -655,6 +750,67 @@ def replace_schedule(
         raise typer.Exit(1)
 
 
+@schedules_app.command("runs")
+def get_schedule_runs(
+    schedule_rid: str = typer.Argument(
+        ..., help="Schedule Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    page_size: Optional[int] = typer.Option(
+        None, "--page-size", help="Number of results per page"
+    ),
+    page_token: Optional[str] = typer.Option(
+        None, "--page-token", help="Pagination token for next page"
+    ),
+    format: str = typer.Option(
+        "table",
+        "--format",
+        "-f",
+        help="Output format (table, json, csv)",
+        autocompletion=complete_output_format,
+    ),
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path"
+    ),
+):
+    """List recent execution runs for a schedule."""
+    try:
+        cache_rid(schedule_rid)
+        service = OrchestrationService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching runs for schedule {schedule_rid}..."
+        ):
+            response = service.get_schedule_runs(
+                schedule_rid, page_size=page_size, page_token=page_token
+            )
+
+        runs = response.get("runs", [])
+
+        if not runs:
+            formatter.print_warning("No runs found for this schedule")
+            return
+
+        formatter.format_schedule_runs_list(runs, format, output)
+
+        if output:
+            formatter.print_success(f"Runs list saved to {output}")
+
+        if response.get("next_page_token"):
+            formatter.print_info(
+                f"More results available. Use --page-token {response['next_page_token']} to fetch next page."
+            )
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to get schedule runs: {e}")
+        raise typer.Exit(1)
+
+
 # ============================================================================
 # Main app setup
 # ============================================================================