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

pltr/services/resource.py

@@ -239,6 +239,184 @@ class ResourceService(BaseService):
         except Exception as e:
             raise RuntimeError(f"Failed to search resources: {e}")
 
+    # ==================== Trash Operations ====================
+
+    def delete_resource(self, resource_rid: str) -> None:
+        """
+        Move a resource to trash.
+
+        The resource can be restored later or permanently deleted.
+
+        Args:
+            resource_rid: Resource Identifier
+
+        Raises:
+            RuntimeError: If deletion fails
+        """
+        try:
+            self.service.Resource.delete(resource_rid, preview=True)
+        except Exception as e:
+            raise RuntimeError(f"Failed to delete resource {resource_rid}: {e}")
+
+    def restore_resource(self, resource_rid: str) -> None:
+        """
+        Restore a resource from trash.
+
+        This also restores any directly trashed ancestors.
+        Operation is ignored if the resource is not trashed.
+
+        Args:
+            resource_rid: Resource Identifier
+
+        Raises:
+            RuntimeError: If restoration fails
+        """
+        try:
+            self.service.Resource.restore(resource_rid, preview=True)
+        except Exception as e:
+            raise RuntimeError(f"Failed to restore resource {resource_rid}: {e}")
+
+    def permanently_delete_resource(self, resource_rid: str) -> None:
+        """
+        Permanently delete a resource from trash.
+
+        The resource must already be in the trash. This operation is irreversible.
+
+        Args:
+            resource_rid: Resource Identifier
+
+        Raises:
+            RuntimeError: If permanent deletion fails
+        """
+        try:
+            self.service.Resource.permanently_delete(resource_rid, preview=True)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to permanently delete resource {resource_rid}: {e}"
+            )
+
+    # ==================== Markings Operations ====================
+
+    def add_markings(self, resource_rid: str, marking_ids: List[str]) -> None:
+        """
+        Add markings to a resource.
+
+        Args:
+            resource_rid: Resource Identifier
+            marking_ids: List of marking identifiers to add
+
+        Raises:
+            RuntimeError: If adding markings fails
+        """
+        try:
+            self.service.Resource.add_markings(
+                resource_rid, marking_ids=marking_ids, preview=True
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to add markings to resource {resource_rid}: {e}"
+            )
+
+    def remove_markings(self, resource_rid: str, marking_ids: List[str]) -> None:
+        """
+        Remove markings from a resource.
+
+        Args:
+            resource_rid: Resource Identifier
+            marking_ids: List of marking identifiers to remove
+
+        Raises:
+            RuntimeError: If removing markings fails
+        """
+        try:
+            self.service.Resource.remove_markings(
+                resource_rid, marking_ids=marking_ids, preview=True
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to remove markings from resource {resource_rid}: {e}"
+            )
+
+    def list_markings(
+        self,
+        resource_rid: str,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        List markings directly applied to a resource.
+
+        Args:
+            resource_rid: Resource Identifier
+            page_size: Number of items per page (optional)
+            page_token: Pagination token (optional)
+
+        Returns:
+            List of marking information dictionaries
+        """
+        try:
+            markings = []
+            list_params: Dict[str, Any] = {"preview": True}
+
+            if page_size:
+                list_params["page_size"] = page_size
+            if page_token:
+                list_params["page_token"] = page_token
+
+            for marking in self.service.Resource.markings(resource_rid, **list_params):
+                markings.append(self._format_marking_info(marking))
+            return markings
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to list markings for resource {resource_rid}: {e}"
+            )
+
+    # ==================== Access & Batch Operations ====================
+
+    def get_access_requirements(self, resource_rid: str) -> Dict[str, Any]:
+        """
+        Get access requirements for a resource.
+
+        Returns the Organizations and Markings required to view the resource.
+
+        Args:
+            resource_rid: Resource Identifier
+
+        Returns:
+            Access requirements dictionary with organizations and markings
+        """
+        try:
+            requirements = self.service.Resource.get_access_requirements(
+                resource_rid, preview=True
+            )
+            return self._format_access_requirements(requirements)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to get access requirements for resource {resource_rid}: {e}"
+            )
+
+    def get_resources_by_path_batch(self, paths: List[str]) -> List[Dict[str, Any]]:
+        """
+        Get multiple resources by their absolute paths in a single request.
+
+        Args:
+            paths: List of absolute paths (max 1000)
+
+        Returns:
+            List of resource information dictionaries
+        """
+        if len(paths) > 1000:
+            raise ValueError("Maximum batch size is 1000 paths")
+
+        try:
+            response = self.service.Resource.get_by_path_batch(body=paths, preview=True)
+            resources = []
+            for resource in response.resources:
+                resources.append(self._format_resource_info(resource))
+            return resources
+        except Exception as e:
+            raise RuntimeError(f"Failed to get resources by path batch: {e}")
+
     def _format_resource_info(self, resource: Any) -> Dict[str, Any]:
         """
         Format resource information for consistent output.
@@ -303,3 +481,52 @@ class ResourceService(BaseService):
         if hasattr(timestamp, "time"):
             return str(timestamp.time)
         return str(timestamp)
+
+    def _format_marking_info(self, marking: Any) -> Dict[str, Any]:
+        """
+        Format marking information for consistent output.
+
+        Args:
+            marking: Marking object from Foundry SDK
+
+        Returns:
+            Formatted marking information dictionary
+        """
+        return {
+            "marking_id": getattr(marking, "marking_id", None),
+            "display_name": getattr(marking, "display_name", None),
+            "description": getattr(marking, "description", None),
+            "category_id": getattr(marking, "category_id", None),
+            "category_display_name": getattr(marking, "category_display_name", None),
+        }
+
+    def _format_access_requirements(self, requirements: Any) -> Dict[str, Any]:
+        """
+        Format access requirements for consistent output.
+
+        Args:
+            requirements: AccessRequirements object from Foundry SDK
+
+        Returns:
+            Formatted access requirements dictionary
+        """
+        organizations = []
+        markings = []
+
+        if hasattr(requirements, "organizations"):
+            for org in getattr(requirements, "organizations", []) or []:
+                organizations.append(
+                    {
+                        "organization_rid": getattr(org, "organization_rid", None),
+                        "display_name": getattr(org, "display_name", None),
+                    }
+                )
+
+        if hasattr(requirements, "markings"):
+            for marking in getattr(requirements, "markings", []) or []:
+                markings.append(self._format_marking_info(marking))
+
+        return {
+            "organizations": organizations,
+            "markings": markings,
+        }

pltr/services/sql.py

@@ -30,6 +30,7 @@ class SqlService(BaseService):
         fallback_branch_ids: Optional[List[str]] = None,
         timeout: int = 300,
         format: str = "table",
+        preview: bool = True,
     ) -> Dict[str, Any]:
         """
         Execute a SQL query and wait for completion.
@@ -39,6 +40,7 @@ class SqlService(BaseService):
             fallback_branch_ids: Optional list of branch IDs for fallback
             timeout: Maximum time to wait for query completion (seconds)
             format: Output format for results ('table', 'json', 'raw')
+            preview: Enable preview mode (required for SQL API, defaults to True)
 
         Returns:
             Dictionary containing query results and metadata
@@ -49,19 +51,23 @@ class SqlService(BaseService):
         try:
             # Submit the query
             status = self.service.execute(
-                query=query, fallback_branch_ids=fallback_branch_ids
+                query=query, fallback_branch_ids=fallback_branch_ids, preview=preview
             )
 
             # If the query completed immediately
             if isinstance(status, SucceededQueryStatus):
-                return self._format_completed_query(status.query_id, format)
+                return self._format_completed_query(
+                    status.query_id, format, preview=preview
+                )
             elif isinstance(status, FailedQueryStatus):
                 raise RuntimeError(f"Query failed: {status.error_message}")
             elif isinstance(status, CanceledQueryStatus):
                 raise RuntimeError("Query was canceled")
             elif isinstance(status, RunningQueryStatus):
                 # Wait for completion
-                return self._wait_for_query_completion(status.query_id, timeout, format)
+                return self._wait_for_query_completion(
+                    status.query_id, timeout, format, preview=preview
+                )
             else:
                 raise RuntimeError(f"Unknown query status type: {type(status)}")
 
@@ -71,7 +77,10 @@ class SqlService(BaseService):
             raise RuntimeError(f"Failed to execute query: {e}")
 
     def submit_query(
-        self, query: str, fallback_branch_ids: Optional[List[str]] = None
+        self,
+        query: str,
+        fallback_branch_ids: Optional[List[str]] = None,
+        preview: bool = True,
     ) -> Dict[str, Any]:
         """
         Submit a SQL query without waiting for completion.
@@ -79,6 +88,7 @@ class SqlService(BaseService):
         Args:
             query: SQL query string
             fallback_branch_ids: Optional list of branch IDs for fallback
+            preview: Enable preview mode (required for SQL API, defaults to True)
 
         Returns:
             Dictionary containing query ID and initial status
@@ -88,18 +98,19 @@ class SqlService(BaseService):
         """
         try:
             status = self.service.execute(
-                query=query, fallback_branch_ids=fallback_branch_ids
+                query=query, fallback_branch_ids=fallback_branch_ids, preview=preview
             )
             return self._format_query_status(status)
         except Exception as e:
             raise RuntimeError(f"Failed to submit query: {e}")
 
-    def get_query_status(self, query_id: str) -> Dict[str, Any]:
+    def get_query_status(self, query_id: str, preview: bool = True) -> Dict[str, Any]:
         """
         Get the status of a submitted query.
 
         Args:
             query_id: Query identifier
+            preview: Enable preview mode (required for SQL API, defaults to True)
 
         Returns:
             Dictionary containing query status information
@@ -108,18 +119,21 @@ class SqlService(BaseService):
             RuntimeError: If status check fails
         """
         try:
-            status = self.service.get_status(query_id)
+            status = self.service.get_status(query_id, preview=preview)
             return self._format_query_status(status)
         except Exception as e:
             raise RuntimeError(f"Failed to get query status: {e}")
 
-    def get_query_results(self, query_id: str, format: str = "table") -> Dict[str, Any]:
+    def get_query_results(
+        self, query_id: str, format: str = "table", preview: bool = True
+    ) -> Dict[str, Any]:
         """
         Get the results of a completed query.
 
         Args:
             query_id: Query identifier
             format: Output format ('table', 'json', 'raw')
+            preview: Enable preview mode (required for SQL API, defaults to True)
 
         Returns:
             Dictionary containing query results
@@ -129,7 +143,7 @@ class SqlService(BaseService):
         """
         try:
             # First check if the query has completed successfully
-            status = self.service.get_status(query_id)
+            status = self.service.get_status(query_id, preview=preview)
             if not isinstance(status, SucceededQueryStatus):
                 status_info = self._format_query_status(status)
                 if isinstance(status, FailedQueryStatus):
@@ -142,7 +156,7 @@ class SqlService(BaseService):
                     raise RuntimeError(f"Query status: {status_info['status']}")
 
             # Get the results
-            results_bytes = self.service.get_results(query_id)
+            results_bytes = self.service.get_results(query_id, preview=preview)
             return self._format_query_results(results_bytes, format)
 
         except Exception as e:
@@ -150,12 +164,13 @@ class SqlService(BaseService):
                 raise
             raise RuntimeError(f"Failed to get query results: {e}")
 
-    def cancel_query(self, query_id: str) -> Dict[str, Any]:
+    def cancel_query(self, query_id: str, preview: bool = True) -> Dict[str, Any]:
         """
         Cancel a running query.
 
         Args:
             query_id: Query identifier
+            preview: Enable preview mode (required for SQL API, defaults to True)
 
         Returns:
             Dictionary containing cancellation status
@@ -164,15 +179,19 @@ class SqlService(BaseService):
             RuntimeError: If cancellation fails
         """
         try:
-            self.service.cancel(query_id)
+            self.service.cancel(query_id, preview=preview)
             # Get updated status after cancellation
-            status = self.service.get_status(query_id)
+            status = self.service.get_status(query_id, preview=preview)
             return self._format_query_status(status)
         except Exception as e:
             raise RuntimeError(f"Failed to cancel query: {e}")
 
     def wait_for_completion(
-        self, query_id: str, timeout: int = 300, poll_interval: int = 2
+        self,
+        query_id: str,
+        timeout: int = 300,
+        poll_interval: int = 2,
+        preview: bool = True,
     ) -> Dict[str, Any]:
         """
         Wait for a query to complete.
@@ -181,6 +200,7 @@ class SqlService(BaseService):
             query_id: Query identifier
             timeout: Maximum time to wait (seconds)
             poll_interval: Time between status checks (seconds)
+            preview: Enable preview mode (required for SQL API, defaults to True)
 
         Returns:
             Dictionary containing final query status
@@ -192,7 +212,7 @@ class SqlService(BaseService):
 
         while time.time() - start_time < timeout:
             try:
-                status = self.service.get_status(query_id)
+                status = self.service.get_status(query_id, preview=preview)
 
                 if isinstance(status, SucceededQueryStatus):
                     return self._format_query_status(status)
@@ -216,7 +236,7 @@ class SqlService(BaseService):
         raise RuntimeError(f"Query timed out after {timeout} seconds")
 
     def _wait_for_query_completion(
-        self, query_id: str, timeout: int, format: str
+        self, query_id: str, timeout: int, format: str, preview: bool = True
     ) -> Dict[str, Any]:
         """
         Wait for query completion and return formatted results.
@@ -225,28 +245,32 @@ class SqlService(BaseService):
             query_id: Query identifier
             timeout: Maximum wait time
             format: Result format
+            preview: Enable preview mode (required for SQL API, defaults to True)
 
         Returns:
             Dictionary with query results
         """
         # Wait for completion
-        self.wait_for_completion(query_id, timeout)
+        self.wait_for_completion(query_id, timeout, preview=preview)
 
         # Get results
-        return self._format_completed_query(query_id, format)
+        return self._format_completed_query(query_id, format, preview=preview)
 
-    def _format_completed_query(self, query_id: str, format: str) -> Dict[str, Any]:
+    def _format_completed_query(
+        self, query_id: str, format: str, preview: bool = True
+    ) -> Dict[str, Any]:
         """
         Format a completed query's results.
 
         Args:
             query_id: Query identifier
             format: Result format
+            preview: Enable preview mode (required for SQL API, defaults to True)
 
         Returns:
             Formatted query results
         """
-        results_bytes = self.service.get_results(query_id)
+        results_bytes = self.service.get_results(query_id, preview=preview)
         results = self._format_query_results(results_bytes, format)
 
         return {

pltr/services/third_party_applications.py

@@ -0,0 +1,53 @@
+"""
+Third-party applications service wrapper for Foundry SDK.
+Provides access to third-party application management operations.
+"""
+
+from typing import Any, Dict
+
+from .base import BaseService
+
+
+class ThirdPartyApplicationsService(BaseService):
+    """Service wrapper for Foundry third-party applications operations."""
+
+    def _get_service(self) -> Any:
+        """Get the Foundry third-party applications service."""
+        return self.client.third_party_applications.ThirdPartyApplication
+
+    def get_application(
+        self, application_rid: str, preview: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Get information about a specific third-party application.
+
+        Args:
+            application_rid: Third-party application Resource Identifier
+                Expected format: ri.third-party-applications.<realm>.third-party-application.<locator>
+                Example: ri.third-party-applications.main.third-party-application.my-app-123
+            preview: Enable preview mode (default: False)
+
+        Returns:
+            Third-party application information dictionary containing:
+            - rid: Application resource identifier
+            - name: Application name
+            - description: Application description (if available)
+            - status: Application status (if available)
+
+        Raises:
+            RuntimeError: If the operation fails
+
+        Example:
+            >>> service = ThirdPartyApplicationsService()
+            >>> app = service.get_application(
+            ...     "ri.third-party-applications.main.third-party-application.my-app"
+            ... )
+            >>> print(app['name'])
+        """
+        try:
+            application = self.service.get(application_rid, preview=preview)
+            return self._serialize_response(application)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to get third-party application {application_rid}: {e}"
+            )