pltr-cli 0.10.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

pltr/commands/cp.py

@@ -0,0 +1,103 @@
+"""
+Copy resources between Compass folders.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..auth.base import MissingCredentialsError, ProfileNotFoundError
+from ..services.copy import CopyService
+from ..utils.completion import complete_profile, complete_rid
+from ..utils.formatting import OutputFormatter
+
+
+def cp_command(
+    source_rid: str = typer.Argument(
+        ...,
+        help="Resource Identifier to copy (dataset or folder)",
+        autocompletion=complete_rid,
+    ),
+    target_folder_rid: str = typer.Argument(
+        ...,
+        help="Destination Compass folder RID",
+        autocompletion=complete_rid,
+    ),
+    profile: Optional[str] = typer.Option(
+        None,
+        "--profile",
+        help="Authentication profile",
+        autocompletion=complete_profile,
+    ),
+    recursive: bool = typer.Option(
+        False,
+        "--recursive",
+        "-r",
+        help="Copy folder contents recursively (required when SOURCE_RID is a folder)",
+    ),
+    branch: str = typer.Option(
+        "master",
+        "--branch",
+        "-b",
+        help="Dataset branch to copy file-backed datasets from",
+    ),
+    name_suffix: str = typer.Option(
+        "-copy",
+        "--name-suffix",
+        help="Suffix appended to cloned folder/dataset names",
+    ),
+    copy_schema: bool = typer.Option(
+        True,
+        "--schema/--no-schema",
+        help="Copy dataset schemas when available",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Log actions without creating any resources",
+    ),
+    fail_fast: bool = typer.Option(
+        False,
+        "--fail-fast",
+        help="Stop immediately on first error when copying folders recursively",
+    ),
+    debug: bool = typer.Option(
+        False,
+        "--debug",
+        help="Print stack traces when errors occur",
+    ),
+):
+    """Copy a resource identified by RID into another Compass folder."""
+    console = Console()
+    formatter = OutputFormatter(console)
+
+    try:
+        service = CopyService(
+            profile=profile,
+            branch=branch,
+            name_suffix=name_suffix,
+            copy_schema=copy_schema,
+            dry_run=dry_run,
+            fail_fast=fail_fast,
+            debug=debug,
+            console=console,
+        )
+        summary = service.copy_resource(
+            source_rid, target_folder_rid, recursive=recursive
+        )
+        formatter.print_success("Copy operation completed")
+        formatter.print_info(
+            "Folders copied: {folders_copied} | Datasets copied: {datasets_copied} | "
+            "Skipped: {skipped} | Errors: {errors}".format(**summary)
+        )
+    except (ProfileNotFoundError, MissingCredentialsError) as exc:
+        formatter.print_error(f"Authentication error: {exc}")
+        raise typer.Exit(1)
+    except Exception as exc:
+        if debug:
+            raise
+        formatter.print_error(f"Failed to copy resource: {exc}")
+        raise typer.Exit(1)

pltr/commands/dataset.py

@@ -8,6 +8,7 @@ from rich.console import Console
 
 from ..services.dataset import DatasetService
 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 (
@@ -73,6 +74,55 @@ def get_dataset(
         raise typer.Exit(1)
 
 
+@app.command("preview")
+def preview_dataset(
+    dataset_rid: str = typer.Argument(
+        ..., help="Dataset Resource Identifier", autocompletion=complete_rid
+    ),
+    limit: int = typer.Option(
+        10, "--limit", "-n", help="Number of rows to display", min=1
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    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"
+    ),
+):
+    """Preview dataset contents."""
+    try:
+        cache_rid(dataset_rid)
+        service = DatasetService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching preview of {dataset_rid} (limit: {limit})..."
+        ):
+            data = service.preview_data(dataset_rid, limit=limit)
+
+        if not data:
+            formatter.print_warning("Dataset is empty or has no readable data")
+            return
+
+        formatter.format_output(data, format, output)
+
+        if output:
+            formatter.print_success(f"Preview 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 preview dataset: {e}")
+        raise typer.Exit(1)
+
+
 # Schema commands
 @schema_app.command("get")
 def get_schema(
@@ -566,21 +616,71 @@ def list_files(
     output: Optional[str] = typer.Option(
         None, "--output", "-o", help="Output file path"
     ),
+    page_size: Optional[int] = typer.Option(
+        None, "--page-size", help="Number of files 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)"
+    ),
 ):
-    """List files in a dataset."""
+    """
+    List files in a dataset with pagination support.
+
+    By default, fetches only the first page of results. Use --all to fetch all files,
+    or --max-pages to control how many pages to fetch. Critical for large datasets.
+
+    Examples:
+        # List first page of files (default)
+        pltr dataset files list DATASET_RID
+
+        # List all files
+        pltr dataset files list DATASET_RID --all
+
+        # List first 3 pages
+        pltr dataset files list DATASET_RID --max-pages 3
+    """
     try:
         cache_rid(dataset_rid)
         service = DatasetService(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(
             f"Fetching files from {dataset_rid} (branch: {branch})..."
         ):
-            files = service.list_files(dataset_rid, branch)
-
-        formatter.format_files(files, format, output)
+            result = service.list_files_paginated(dataset_rid, branch, config)
 
+        # Format and display paginated results
         if output:
+            formatter.format_paginated_output(
+                result,
+                format,
+                output,
+                formatter_fn=lambda data, fmt, out: formatter.format_files(
+                    data, fmt, out
+                ),
+            )
             formatter.print_success(f"Files information saved to {output}")
+        else:
+            formatter.format_paginated_output(
+                result,
+                format,
+                formatter_fn=lambda data, fmt, out: formatter.format_files(
+                    data, fmt, out
+                ),
+            )
 
     except (ProfileNotFoundError, MissingCredentialsError) as e:
         formatter.print_error(f"Authentication error: {e}")

pltr/commands/mediasets.py

@@ -405,6 +405,180 @@ def get_media_reference(
         raise typer.Exit(1)
 
 
+@app.command("thumbnail-calculate")
+def thumbnail_calculate(
+    media_set_rid: str = typer.Argument(
+        ..., help="Media Set Resource Identifier", autocompletion=complete_rid
+    ),
+    media_item_rid: str = typer.Argument(
+        ..., help="Media Item Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    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"
+    ),
+    preview: bool = typer.Option(False, "--preview", help="Enable preview mode"),
+):
+    """Initiate thumbnail generation for an image."""
+    try:
+        cache_rid(media_set_rid)
+        cache_rid(media_item_rid)
+        service = MediaSetsService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Initiating thumbnail calculation for {media_item_rid}..."
+        ):
+            status = service.calculate_thumbnail(
+                media_set_rid, media_item_rid, preview=preview
+            )
+
+        formatter.format_thumbnail_status(status, format, output)
+
+        if output:
+            formatter.print_success(f"Thumbnail status saved to {output}")
+        else:
+            formatter.print_info(
+                "Use 'thumbnail-retrieve' to download once calculation completes"
+            )
+
+    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 calculate thumbnail: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("thumbnail-retrieve")
+def thumbnail_retrieve(
+    media_set_rid: str = typer.Argument(
+        ..., help="Media Set Resource Identifier", autocompletion=complete_rid
+    ),
+    media_item_rid: str = typer.Argument(
+        ..., help="Media Item Resource Identifier", autocompletion=complete_rid
+    ),
+    output_path: str = typer.Argument(
+        ..., help="Local path where thumbnail should be saved"
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    preview: bool = typer.Option(False, "--preview", help="Enable preview mode"),
+    overwrite: bool = typer.Option(
+        False, "--overwrite", help="Overwrite existing file"
+    ),
+):
+    """Download a calculated thumbnail from a media set (200px wide webp)."""
+    try:
+        # Check if output file already exists
+        output_path_obj = Path(output_path)
+        if output_path_obj.exists() and not overwrite:
+            formatter.print_error(f"File already exists: {output_path}")
+            formatter.print_info("Use --overwrite to replace existing file")
+            raise typer.Exit(1)
+
+        cache_rid(media_set_rid)
+        cache_rid(media_item_rid)
+        service = MediaSetsService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner("Downloading thumbnail..."):
+            result = service.retrieve_thumbnail(
+                media_set_rid,
+                media_item_rid,
+                output_path,
+                preview=preview,
+            )
+
+        formatter.print_success("Successfully downloaded thumbnail")
+        formatter.print_info(f"Saved to: {result['output_path']}")
+        formatter.print_info(f"File size: {result['file_size']} bytes")
+        formatter.print_info(f"Format: {result['format']}")
+
+    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 retrieve thumbnail: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("upload-temp")
+def upload_temp(
+    file_path: str = typer.Argument(..., help="Local path to the file to upload"),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Profile name", autocompletion=complete_profile
+    ),
+    filename: Optional[str] = typer.Option(
+        None, "--filename", help="Override filename for the upload"
+    ),
+    attribution: Optional[str] = typer.Option(
+        None, "--attribution", help="Attribution string for the media"
+    ),
+    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"
+    ),
+    preview: bool = typer.Option(False, "--preview", help="Enable preview mode"),
+):
+    """Upload temporary media (auto-deleted after 1 hour if not persisted)."""
+    try:
+        # Validate file exists
+        file_path_obj = Path(file_path)
+        if not file_path_obj.exists():
+            formatter.print_error(f"File not found: {file_path}")
+            raise typer.Exit(1)
+
+        service = MediaSetsService(profile=profile)
+
+        file_size = file_path_obj.stat().st_size
+        formatter.print_info(f"Uploading {file_path} ({file_size} bytes)")
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Uploading {file_path_obj.name}..."
+        ):
+            reference = service.upload_temp_media(
+                file_path,
+                filename=filename,
+                attribution=attribution,
+                preview=preview,
+            )
+
+        formatter.print_success("Successfully uploaded temporary media")
+        formatter.format_media_reference(reference, format, output)
+
+        if output:
+            formatter.print_success(f"Media reference saved to {output}")
+        else:
+            formatter.print_warning(
+                "This is a temporary upload. It will be deleted after 1 hour if not persisted."
+            )
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except FileNotFoundError as e:
+        formatter.print_error(str(e))
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to upload temporary media: {e}")
+        raise typer.Exit(1)
+
+
 @app.callback()
 def main():
     """
@@ -415,6 +589,8 @@ def main():
     - Create, commit, and abort upload transactions
     - Upload media files to media sets
     - Download media items from media sets
+    - Generate and retrieve image thumbnails
+    - Upload temporary media
 
     All operations require Resource Identifiers (RIDs) like:
     ri.mediasets.main.media-set.12345678-1234-1234-1234-123456789abc

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
-            )
-
-        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
+            result = service.list_objects_paginated(
+                ontology_rid, object_type, config, properties=prop_list
             )
-        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}")
@@ -366,6 +397,99 @@ def list_linked_objects(
         raise typer.Exit(1)
 
 
+@app.command("object-count")
+def count_objects(
+    ontology_rid: str = typer.Argument(..., help="Ontology Resource Identifier"),
+    object_type: str = typer.Argument(..., help="Object type API name"),
+    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"
+    ),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """Count objects of a specific type."""
+    try:
+        service = OntologyObjectService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Counting {object_type} objects..."
+        ):
+            result = service.count_objects(ontology_rid, object_type, branch=branch)
+
+        formatter.format_dict(result, format=format, output=output)
+
+        if output:
+            formatter.print_success(f"Count result 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 count objects: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("object-search")
+def search_objects(
+    ontology_rid: str = typer.Argument(..., help="Ontology Resource Identifier"),
+    object_type: str = typer.Argument(..., help="Object type API name"),
+    query: str = typer.Option(..., "--query", "-q", help="Search query string"),
+    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"
+    ),
+    page_size: Optional[int] = typer.Option(
+        None, "--page-size", help="Number of results per page"
+    ),
+    properties: Optional[str] = typer.Option(
+        None, "--properties", help="Comma-separated list of properties to include"
+    ),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """Search objects by query."""
+    try:
+        service = OntologyObjectService(profile=profile)
+
+        prop_list = properties.split(",") if properties else None
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Searching {object_type} objects..."
+        ):
+            objects = service.search_objects(
+                ontology_rid,
+                object_type,
+                query,
+                page_size=page_size,
+                properties=prop_list,
+                branch=branch,
+            )
+
+        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)
+
+        if output:
+            formatter.print_success(f"Search results 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 objects: {e}")
+        raise typer.Exit(1)
+
+
 # Action commands
 @app.command("action-apply")
 def apply_action(