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

pltr/commands/resource.py

@@ -459,6 +459,378 @@ def move_resource(
         raise typer.Exit(1)
 
 
+# ==================== Trash Operations ====================
+
+
+@app.command("delete")
+def delete_resource(
+    resource_rid: str = typer.Argument(
+        ..., help="Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation prompt"),
+):
+    """Move a resource to trash."""
+    try:
+        if not force:
+            confirm = typer.confirm(
+                f"Are you sure you want to move resource {resource_rid} to trash?"
+            )
+            if not confirm:
+                formatter.print_info("Operation cancelled.")
+                return
+
+        service = ResourceService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Moving resource {resource_rid} to trash..."
+        ):
+            service.delete_resource(resource_rid)
+
+        formatter.print_success(f"Successfully moved resource {resource_rid} to trash")
+
+    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 delete resource: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("restore")
+def restore_resource(
+    resource_rid: str = typer.Argument(
+        ..., help="Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+):
+    """Restore a resource from trash."""
+    try:
+        service = ResourceService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Restoring resource {resource_rid} from trash..."
+        ):
+            service.restore_resource(resource_rid)
+
+        formatter.print_success(
+            f"Successfully restored resource {resource_rid} from trash"
+        )
+
+    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 restore resource: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("permanently-delete")
+def permanently_delete_resource(
+    resource_rid: str = typer.Argument(
+        ..., help="Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation prompt"),
+):
+    """Permanently delete a resource from trash. This action is irreversible."""
+    try:
+        if not force:
+            confirm = typer.confirm(
+                f"Are you sure you want to PERMANENTLY delete resource {resource_rid}? "
+                "This action cannot be undone!"
+            )
+            if not confirm:
+                formatter.print_info("Operation cancelled.")
+                return
+
+        service = ResourceService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Permanently deleting resource {resource_rid}..."
+        ):
+            service.permanently_delete_resource(resource_rid)
+
+        formatter.print_success(
+            f"Successfully permanently deleted resource {resource_rid}"
+        )
+
+    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 permanently delete resource: {e}")
+        raise typer.Exit(1)
+
+
+# ==================== Markings Operations ====================
+
+
+@app.command("add-markings")
+def add_markings(
+    resource_rid: str = typer.Argument(
+        ..., help="Resource Identifier", autocompletion=complete_rid
+    ),
+    marking_ids: List[str] = typer.Option(
+        ...,
+        "--marking",
+        "-m",
+        help="Marking identifier(s) to add (can specify multiple)",
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+):
+    """Add markings to a resource."""
+    try:
+        service = ResourceService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Adding {len(marking_ids)} marking(s) to resource {resource_rid}..."
+        ):
+            service.add_markings(resource_rid, marking_ids)
+
+        formatter.print_success(
+            f"Successfully added {len(marking_ids)} marking(s) to resource {resource_rid}"
+        )
+
+    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 add markings: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("remove-markings")
+def remove_markings(
+    resource_rid: str = typer.Argument(
+        ..., help="Resource Identifier", autocompletion=complete_rid
+    ),
+    marking_ids: List[str] = typer.Option(
+        ...,
+        "--marking",
+        "-m",
+        help="Marking identifier(s) to remove (can specify multiple)",
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", help="Profile name", autocompletion=complete_profile
+    ),
+):
+    """Remove markings from a resource."""
+    try:
+        service = ResourceService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Removing {len(marking_ids)} marking(s) from resource {resource_rid}..."
+        ):
+            service.remove_markings(resource_rid, marking_ids)
+
+        formatter.print_success(
+            f"Successfully removed {len(marking_ids)} marking(s) from resource {resource_rid}"
+        )
+
+    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 remove markings: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("list-markings")
+def list_markings(
+    resource_rid: str = typer.Argument(
+        ..., help="Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", 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"
+    ),
+    page_size: Optional[int] = typer.Option(
+        None, "--page-size", help="Number of items per page"
+    ),
+):
+    """List markings directly applied to a resource."""
+    try:
+        service = ResourceService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching markings for resource {resource_rid}..."
+        ):
+            markings = service.list_markings(resource_rid, page_size=page_size)
+
+        if not markings:
+            formatter.print_info("No markings found on this resource.")
+            return
+
+        # Format output
+        if format == "json":
+            if output:
+                formatter.save_to_file(markings, output, "json")
+            else:
+                formatter.format_list(markings)
+        elif format == "csv":
+            if output:
+                formatter.save_to_file(markings, output, "csv")
+            else:
+                formatter.format_list(markings)
+        else:
+            _format_markings_table(markings)
+
+        if output:
+            formatter.print_success(f"Markings list 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 list markings: {e}")
+        raise typer.Exit(1)
+
+
+# ==================== Access & Batch Operations ====================
+
+
+@app.command("access-requirements")
+def get_access_requirements(
+    resource_rid: str = typer.Argument(
+        ..., help="Resource Identifier", autocompletion=complete_rid
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", 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"
+    ),
+):
+    """Get access requirements (organizations and markings) for a resource."""
+    try:
+        service = ResourceService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching access requirements for resource {resource_rid}..."
+        ):
+            requirements = service.get_access_requirements(resource_rid)
+
+        # Format output
+        if format == "json":
+            if output:
+                formatter.save_to_file(requirements, output, "json")
+            else:
+                formatter.format_dict(requirements)
+        elif format == "csv":
+            # Flatten for CSV output
+            flat_data = []
+            for org in requirements.get("organizations", []):
+                flat_data.append({"type": "organization", **org})
+            for marking in requirements.get("markings", []):
+                flat_data.append({"type": "marking", **marking})
+            if output:
+                formatter.save_to_file(flat_data, output, "csv")
+            else:
+                formatter.format_list(flat_data)
+        else:
+            _format_access_requirements_table(requirements)
+
+        if output:
+            formatter.print_success(f"Access requirements 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 get access requirements: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("batch-get-by-path")
+def get_resources_by_path_batch(
+    paths: List[str] = typer.Argument(
+        ..., help="Absolute paths to resources (space-separated)"
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", 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"
+    ),
+):
+    """Get multiple resources by their absolute paths (max 1000)."""
+    try:
+        if len(paths) > 1000:
+            formatter.print_error("Maximum batch size is 1000 paths")
+            raise typer.Exit(1)
+
+        service = ResourceService(profile=profile)
+
+        with SpinnerProgressTracker().track_spinner(
+            f"Fetching {len(paths)} resources by path..."
+        ):
+            resources = service.get_resources_by_path_batch(paths)
+
+        # Cache RIDs for future completions
+        for resource in resources:
+            if resource.get("rid"):
+                cache_rid(resource["rid"])
+
+        # Format output
+        if format == "json":
+            if output:
+                formatter.save_to_file(resources, output, "json")
+            else:
+                formatter.format_list(resources)
+        elif format == "csv":
+            if output:
+                formatter.save_to_file(resources, output, "csv")
+            else:
+                formatter.format_list(resources)
+        else:
+            _format_resources_table(resources)
+
+        if output:
+            formatter.print_success(f"Resources information saved to {output}")
+
+    except (ProfileNotFoundError, MissingCredentialsError) as e:
+        formatter.print_error(f"Authentication error: {e}")
+        raise typer.Exit(1)
+    except ValueError as e:
+        formatter.print_error(f"Invalid request: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        formatter.print_error(f"Failed to get resources by path batch: {e}")
+        raise typer.Exit(1)
+
+
 def _format_resource_table(resource: dict):
     """Format resource information as a table."""
     table = Table(
@@ -520,6 +892,70 @@ def _format_metadata_table(metadata: dict):
     console.print(table)
 
 
+def _format_markings_table(markings: List[dict]):
+    """Format markings as a table."""
+    table = Table(title="Markings", show_header=True, header_style="bold cyan")
+    table.add_column("Marking ID")
+    table.add_column("Display Name")
+    table.add_column("Category")
+    table.add_column("Description")
+
+    for marking in markings:
+        table.add_row(
+            marking.get("marking_id", "N/A"),
+            marking.get("display_name", "N/A"),
+            marking.get("category_display_name", "N/A"),
+            marking.get("description", "N/A"),
+        )
+
+    console.print(table)
+    console.print(f"\nTotal: {len(markings)} markings")
+
+
+def _format_access_requirements_table(requirements: dict):
+    """Format access requirements as tables."""
+    organizations = requirements.get("organizations", [])
+    markings = requirements.get("markings", [])
+
+    if organizations:
+        org_table = Table(
+            title="Required Organizations", show_header=True, header_style="bold cyan"
+        )
+        org_table.add_column("Organization RID")
+        org_table.add_column("Display Name")
+
+        for org in organizations:
+            org_table.add_row(
+                org.get("organization_rid", "N/A"),
+                org.get("display_name", "N/A"),
+            )
+
+        console.print(org_table)
+        console.print(f"Total: {len(organizations)} organizations\n")
+    else:
+        console.print("[dim]No organization requirements[/dim]\n")
+
+    if markings:
+        marking_table = Table(
+            title="Required Markings", show_header=True, header_style="bold cyan"
+        )
+        marking_table.add_column("Marking ID")
+        marking_table.add_column("Display Name")
+        marking_table.add_column("Category")
+
+        for marking in markings:
+            marking_table.add_row(
+                marking.get("marking_id", "N/A"),
+                marking.get("display_name", "N/A"),
+                marking.get("category_display_name", "N/A"),
+            )
+
+        console.print(marking_table)
+        console.print(f"Total: {len(markings)} markings")
+    else:
+        console.print("[dim]No marking requirements[/dim]")
+
+
 @app.callback()
 def main():
     """
@@ -556,5 +992,21 @@ def main():
 
         # Move resource to different folder
         pltr resource move ri.compass.main.dataset.xyz123 --target-folder ri.compass.main.folder.new456
+
+        # Trash operations
+        pltr resource delete ri.compass.main.dataset.xyz123
+        pltr resource restore ri.compass.main.dataset.xyz123
+        pltr resource permanently-delete ri.compass.main.dataset.xyz123
+
+        # Markings operations
+        pltr resource add-markings ri.compass.main.dataset.xyz123 -m marking-id-1 -m marking-id-2
+        pltr resource remove-markings ri.compass.main.dataset.xyz123 -m marking-id-1
+        pltr resource list-markings ri.compass.main.dataset.xyz123
+
+        # Access requirements
+        pltr resource access-requirements ri.compass.main.dataset.xyz123
+
+        # Batch get by path
+        pltr resource batch-get-by-path "/Org/Project/Dataset1" "/Org/Project/Dataset2"
     """
     pass

pltr/commands/sql.py

@@ -42,8 +42,15 @@ def execute_query(
     fallback_branches: Optional[str] = typer.Option(
         None, "--fallback-branches", help="Comma-separated list of fallback branch IDs"
     ),
+    preview: bool = typer.Option(
+        True,
+        "--preview/--no-preview",
+        help="Enable preview mode (required for SQL API)",
+    ),
 ) -> None:
-    """Execute a SQL query and display results."""
+    """Execute a SQL query and display results.
+
+    Note: SQL queries are currently in preview and may be modified or removed at any time."""
     console = Console()
     formatter = OutputFormatter()
 
@@ -62,6 +69,7 @@ def execute_query(
                 fallback_branch_ids=fallback_branch_ids,
                 timeout=timeout,
                 format="table" if output_format in ["table", "csv"] else "json",
+                preview=preview,
             )
 
         # Extract results
@@ -92,8 +100,15 @@ def submit_query(
     fallback_branches: Optional[str] = typer.Option(
         None, "--fallback-branches", help="Comma-separated list of fallback branch IDs"
     ),
+    preview: bool = typer.Option(
+        True,
+        "--preview/--no-preview",
+        help="Enable preview mode (required for SQL API)",
+    ),
 ) -> None:
-    """Submit a SQL query without waiting for completion."""
+    """Submit a SQL query without waiting for completion.
+
+    Note: SQL queries are currently in preview and may be modified or removed at any time."""
     console = Console()
     formatter = OutputFormatter()
 
@@ -108,7 +123,7 @@ def submit_query(
 
         with SpinnerProgressTracker().track_spinner("Submitting SQL query..."):
             result = service.submit_query(
-                query=query, fallback_branch_ids=fallback_branch_ids
+                query=query, fallback_branch_ids=fallback_branch_ids, preview=preview
             )
 
         console.print("[green]Query submitted successfully[/green]")
@@ -136,6 +151,11 @@ def get_query_status(
     profile: Optional[str] = typer.Option(
         None, "--profile", help="Auth profile to use"
     ),
+    preview: bool = typer.Option(
+        True,
+        "--preview/--no-preview",
+        help="Enable preview mode (required for SQL API)",
+    ),
 ) -> None:
     """Get the status of a submitted query."""
     console = Console()
@@ -145,7 +165,7 @@ def get_query_status(
         service = SqlService(profile=profile)
 
         with SpinnerProgressTracker().track_spinner("Checking query status..."):
-            result = service.get_query_status(query_id)
+            result = service.get_query_status(query_id, preview=preview)
 
         console.print(f"Query ID: [bold]{query_id}[/bold]")
 
@@ -183,6 +203,11 @@ def get_query_results(
     output_file: Optional[Path] = typer.Option(
         None, "--output", help="Save results to file"
     ),
+    preview: bool = typer.Option(
+        True,
+        "--preview/--no-preview",
+        help="Enable preview mode (required for SQL API)",
+    ),
 ) -> None:
     """Get the results of a completed query."""
     console = Console()
@@ -195,6 +220,7 @@ def get_query_results(
             result = service.get_query_results(
                 query_id,
                 format="table" if output_format in ["table", "csv"] else "json",
+                preview=preview,
             )
 
         # Display or save results
@@ -217,6 +243,11 @@ def cancel_query(
     profile: Optional[str] = typer.Option(
         None, "--profile", help="Auth profile to use"
     ),
+    preview: bool = typer.Option(
+        True,
+        "--preview/--no-preview",
+        help="Enable preview mode (required for SQL API)",
+    ),
 ) -> None:
     """Cancel a running query."""
     console = Console()
@@ -226,7 +257,7 @@ def cancel_query(
         service = SqlService(profile=profile)
 
         with SpinnerProgressTracker().track_spinner("Canceling query..."):
-            result = service.cancel_query(query_id)
+            result = service.cancel_query(query_id, preview=preview)
 
         console.print(f"Query ID: [bold]{query_id}[/bold]")
 
@@ -259,8 +290,15 @@ def export_query_results(
     fallback_branches: Optional[str] = typer.Option(
         None, "--fallback-branches", help="Comma-separated list of fallback branch IDs"
     ),
+    preview: bool = typer.Option(
+        True,
+        "--preview/--no-preview",
+        help="Enable preview mode (required for SQL API)",
+    ),
 ) -> None:
-    """Execute a SQL query and export results to a file."""
+    """Execute a SQL query and export results to a file.
+
+    Note: SQL queries are currently in preview and may be modified or removed at any time."""
     console = Console()
     formatter = OutputFormatter()
 
@@ -289,6 +327,7 @@ def export_query_results(
                 fallback_branch_ids=fallback_branch_ids,
                 timeout=timeout,
                 format="table" if output_format in ["table", "csv"] else "json",
+                preview=preview,
             )
 
         # Save results to file
@@ -321,6 +360,11 @@ def wait_for_query(
     output_file: Optional[Path] = typer.Option(
         None, "--output", help="Save results to file when completed"
     ),
+    preview: bool = typer.Option(
+        True,
+        "--preview/--no-preview",
+        help="Enable preview mode (required for SQL API)",
+    ),
 ) -> None:
     """Wait for a query to complete and optionally display results."""
     console = Console()
@@ -330,7 +374,9 @@ def wait_for_query(
         service = SqlService(profile=profile)
 
         with SpinnerProgressTracker().track_spinner("Waiting for query to complete..."):
-            status_result = service.wait_for_completion(query_id, timeout)
+            status_result = service.wait_for_completion(
+                query_id, timeout, preview=preview
+            )
 
         console.print(f"Query ID: [bold]{query_id}[/bold]")
         console.print(
@@ -343,6 +389,7 @@ def wait_for_query(
                 result = service.get_query_results(
                     query_id,
                     format="table" if output_format in ["table", "csv"] else "json",
+                    preview=preview,
                 )
 
             if output_file: