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

pltr/utils/formatting.py

@@ -4,7 +4,7 @@ Output formatting utilities for CLI commands.
 
 import json
 import csv
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union, Callable
 from datetime import datetime
 from io import StringIO
 
@@ -12,6 +12,12 @@ from rich.console import Console
 from rich.table import Table
 from rich import print as rich_print
 
+# Type checking import to avoid circular dependencies
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
 
 class OutputFormatter:
     """Handles different output formats for CLI commands."""
@@ -460,6 +466,118 @@ class OutputFormatter:
                 else:
                     f.write(str(data))
 
+    def format_paginated_output(
+        self,
+        result: Any,  # PaginationResult
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+        formatter_fn: Optional[Callable] = None,
+    ) -> Optional[str]:
+        """
+        Format paginated results with metadata.
+
+        This method handles display of paginated data and automatically
+        includes pagination information based on the output format.
+
+        Args:
+            result: PaginationResult object with .data and .metadata attributes
+            format_type: Output format ('table', 'json', 'csv')
+            output_file: Optional output file path
+            formatter_fn: Optional custom formatter function for the data
+
+        Returns:
+            Formatted string if no output file specified
+
+        Example:
+            >>> result = PaginationResult(data=[...], metadata=metadata)
+            >>> formatter.format_paginated_output(result, "json")
+        """
+        # Extract data and metadata
+        data = result.data if hasattr(result, "data") else result
+        metadata = result.metadata if hasattr(result, "metadata") else None
+
+        # JSON format: include pagination metadata in output
+        if format_type == "json":
+            if metadata:
+                output_data = {
+                    "data": data,
+                    "pagination": {
+                        "page": metadata.current_page,
+                        "items_count": metadata.items_fetched,
+                        "has_more": metadata.has_more,
+                        "total_pages_fetched": metadata.total_pages_fetched,
+                    },
+                }
+                # Include next_page_token if available
+                if metadata.next_page_token:
+                    output_data["pagination"]["next_page_token"] = (
+                        metadata.next_page_token
+                    )
+
+                return self._format_json(output_data, output_file)
+            else:
+                # No metadata, format data directly
+                return self._format_json(data, output_file)
+
+        # Table/CSV format: format data normally, then print pagination info
+        else:
+            # Format the data using custom formatter or default
+            if formatter_fn:
+                formatted_result = formatter_fn(data, format_type, output_file)
+            else:
+                formatted_result = self.format_output(data, format_type, output_file)
+
+            # Print pagination info to console (even when saving to file)
+            # For CSV/table formats, pagination metadata is shown on console
+            # while data is written to file
+            if metadata:
+                self.print_pagination_info(metadata)
+
+            return formatted_result
+
+    def print_pagination_info(self, metadata: Any) -> None:  # PaginationMetadata
+        """
+        Print pagination information to the console.
+
+        This provides users with helpful information about the current
+        pagination state and how to fetch more data.
+
+        Args:
+            metadata: PaginationMetadata object
+
+        Example output:
+            Fetched 20 items (page 1)
+            Next page: --page-token abc123
+            Fetch all: Add --all flag
+        """
+        if not metadata:
+            return
+
+        # Build info message
+        info_lines = []
+
+        # Current state
+        info_lines.append(
+            f"Fetched {metadata.items_fetched} items (page {metadata.current_page})"
+        )
+
+        # Next steps if more data available
+        if metadata.has_more:
+            if metadata.next_page_token:
+                info_lines.append(f"Next page: --page-token {metadata.next_page_token}")
+            else:
+                # Iterator pattern without explicit token
+                info_lines.append(
+                    f"Next page: Use --max-pages {metadata.current_page + 1}"
+                )
+
+            info_lines.append("Fetch all: Add --all flag")
+        else:
+            info_lines.append("No more pages available")
+
+        # Print as info message
+        self.print_info("\n".join(info_lines))
+
     def format_sql_results(
         self,
         results: Any,
@@ -826,6 +944,38 @@ class OutputFormatter:
 
         return self.format_output(formatted_schedules, format_type, output_file)
 
+    def format_schedule_runs_list(
+        self,
+        runs: List[Dict[str, Any]],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format list of schedule runs.
+
+        Args:
+            runs: List of schedule run dictionaries
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        formatted_runs = []
+        for run in runs:
+            build_rid = run.get("build_rid", "")
+            formatted_run = {
+                "RID": run.get("rid", ""),
+                "Status": run.get("status", ""),
+                "Started": self._format_datetime(run.get("started_time")),
+                "Finished": self._format_datetime(run.get("finished_time")),
+                "Build": build_rid[:40] + "..." if len(build_rid) > 40 else build_rid,
+                "Result": run.get("result", ""),
+            }
+            formatted_runs.append(formatted_run)
+
+        return self.format_output(formatted_runs, format_type, output_file)
+
     # MediaSets formatting methods
 
     def format_media_item_info(
@@ -953,6 +1103,50 @@ class OutputFormatter:
         else:
             return self.format_output(reference, format_type, output_file)
 
+    def format_thumbnail_status(
+        self,
+        status: Dict[str, Any],
+        format_type: str = "table",
+        output_file: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Format thumbnail calculation status for display.
+
+        Args:
+            status: Thumbnail status dictionary
+            format_type: Output format
+            output_file: Optional output file path
+
+        Returns:
+            Formatted string if no output file specified
+        """
+        if format_type == "table":
+            details = []
+
+            property_order = [
+                ("status", "Status"),
+                ("transformation_id", "Transformation ID"),
+                ("media_item_rid", "Media Item RID"),
+            ]
+
+            for key, label in property_order:
+                if status.get(key) is not None:
+                    details.append({"Property": label, "Value": str(status[key])})
+
+            # Add any remaining properties
+            for key, value in status.items():
+                if (
+                    key not in [prop[0] for prop in property_order]
+                    and value is not None
+                ):
+                    details.append(
+                        {"Property": key.replace("_", " ").title(), "Value": str(value)}
+                    )
+
+            return self.format_output(details, format_type, output_file)
+        else:
+            return self.format_output(status, format_type, output_file)
+
     # Dataset formatting methods
 
     def format_branches(

pltr/utils/pagination.py

@@ -0,0 +1,325 @@
+"""
+Pagination utilities for handling large result sets.
+
+This module provides a unified interface for pagination across different
+SDK patterns used by the Foundry platform.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
+
+
+@dataclass
+class PaginationConfig:
+    """
+    Configuration for pagination behavior.
+
+    Attributes:
+        page_size: Number of items per page (None = use service default)
+        max_pages: Maximum number of pages to fetch (None = fetch all)
+        page_token: Token to resume from a specific page
+        fetch_all: If True, overrides max_pages to fetch all available pages
+    """
+
+    page_size: Optional[int] = None
+    max_pages: Optional[int] = 1  # Default: fetch single page
+    page_token: Optional[str] = None
+    fetch_all: bool = False
+
+    def should_show_progress(self) -> bool:
+        """
+        Determine if progress tracking should be shown.
+
+        Returns:
+            True if fetching multiple pages with known max_pages
+        """
+        return self.max_pages is not None and self.max_pages > 1 and not self.fetch_all
+
+    def effective_max_pages(self) -> Optional[int]:
+        """
+        Get the effective maximum pages to fetch.
+
+        Returns:
+            None if fetch_all is True, otherwise max_pages value
+        """
+        return None if self.fetch_all else self.max_pages
+
+
+@dataclass
+class PaginationMetadata:
+    """
+    Metadata about pagination state.
+
+    Attributes:
+        current_page: Current page number (1-indexed)
+        items_fetched: Total number of items fetched
+        next_page_token: Token for fetching the next page (if available)
+        has_more: Whether more pages are available
+        total_pages_fetched: Total number of pages fetched so far
+    """
+
+    current_page: int = 1
+    items_fetched: int = 0
+    next_page_token: Optional[str] = None
+    has_more: bool = False
+    total_pages_fetched: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert metadata to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of metadata
+        """
+        result: Dict[str, Any] = {
+            "page": self.current_page,
+            "items_count": self.items_fetched,
+            "has_more": self.has_more,
+            "total_pages_fetched": self.total_pages_fetched,
+        }
+        if self.next_page_token:
+            result["next_page_token"] = self.next_page_token
+        return result
+
+
+@dataclass
+class PaginationResult:
+    """
+    Wrapper for paginated results with metadata.
+
+    Attributes:
+        data: List of items fetched
+        metadata: Pagination metadata
+    """
+
+    data: List[Any] = field(default_factory=list)
+    metadata: PaginationMetadata = field(default_factory=PaginationMetadata)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert result to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary with data and pagination metadata
+        """
+        return {
+            "data": self.data,
+            "pagination": self.metadata.to_dict(),
+        }
+
+
+class ResponsePaginationHandler:
+    """
+    Handler for SDK Pattern B: Response-based pagination.
+
+    This handler works with SDK methods that return response objects
+    with explicit `.data` and `.next_page_token` attributes.
+
+    Example SDK methods:
+        - admin.User.list()
+        - orchestration.Build.search()
+    """
+
+    def collect_pages(
+        self,
+        fetch_fn: Callable[[Optional[str]], Dict[str, Any]],
+        config: PaginationConfig,
+        progress_callback: Optional[Callable[[int, int], None]] = None,
+    ) -> PaginationResult:
+        """
+        Collect pages using a fetch function.
+
+        Args:
+            fetch_fn: Function that accepts a page_token and returns a dict
+                     with 'data' and 'next_page_token' keys
+            config: Pagination configuration
+            progress_callback: Optional callback(page_num, items_count)
+
+        Returns:
+            PaginationResult with collected items and metadata
+
+        Example:
+            >>> def fetch(token):
+            ...     response = service.list(page_token=token)
+            ...     return {"data": response.data, "next_page_token": response.next_page_token}
+            >>> handler = ResponsePaginationHandler()
+            >>> result = handler.collect_pages(fetch, config)
+        """
+        all_items: List[Any] = []
+        page_num = 0
+        current_token = config.page_token
+        max_pages = config.effective_max_pages()
+
+        while True:
+            try:
+                # Fetch the current page
+                response = fetch_fn(current_token)
+                page_data = response.get("data", [])
+                next_token = response.get("next_page_token")
+
+                # Add items from this page
+                all_items.extend(page_data)
+                page_num += 1
+
+                # Update progress
+                if progress_callback:
+                    progress_callback(page_num, len(all_items))
+
+                # Check if we should continue
+                has_more = next_token is not None
+                should_stop = (
+                    not has_more  # No more pages
+                    or (
+                        max_pages is not None and page_num >= max_pages
+                    )  # Reached max pages
+                )
+
+                if should_stop:
+                    metadata = PaginationMetadata(
+                        current_page=page_num,
+                        items_fetched=len(all_items),
+                        next_page_token=next_token,
+                        has_more=has_more,
+                        total_pages_fetched=page_num,
+                    )
+                    return PaginationResult(data=all_items, metadata=metadata)
+
+                # Continue to next page
+                current_token = next_token
+
+            except Exception as e:
+                # Error occurred while fetching - return partial results
+                # Include the error information in metadata for user awareness
+                if all_items:
+                    # We have partial results - return what we got so far
+                    import sys
+
+                    print(
+                        f"\nWarning: Error fetching page {page_num + 1}: {e}",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"Returning partial results ({len(all_items)} items from {page_num} pages)",
+                        file=sys.stderr,
+                    )
+
+                    metadata = PaginationMetadata(
+                        current_page=page_num,
+                        items_fetched=len(all_items),
+                        next_page_token=current_token,  # Token for retry
+                        has_more=True,  # Assume more pages exist
+                        total_pages_fetched=page_num,
+                    )
+                    return PaginationResult(data=all_items, metadata=metadata)
+                else:
+                    # No data fetched yet - re-raise the error
+                    raise
+
+
+class IteratorPaginationHandler:
+    """
+    Handler for SDK Pattern A: Iterator-based pagination.
+
+    This handler works with SDK methods that return ResourceIterator instances
+    that automatically paginate internally and expose next_page_token.
+
+    Example SDK methods:
+        - ontology.OntologyObject.list()
+        - Dataset.File.list()
+
+    Note: The SDK's ResourceIterator exposes .next_page_token and .data properties
+    which we leverage for proper pagination support.
+    """
+
+    def collect_pages(
+        self,
+        iterator: Any,  # ResourceIterator from SDK
+        config: PaginationConfig,
+        progress_callback: Optional[Callable[[int, int], None]] = None,
+    ) -> PaginationResult:
+        """
+        Collect pages from a ResourceIterator using SDK's pagination.
+
+        Args:
+            iterator: ResourceIterator instance from SDK (has .next_page_token property)
+            config: Pagination configuration
+            progress_callback: Optional callback(page_num, items_count)
+
+        Returns:
+            PaginationResult with collected items and metadata
+
+        Note:
+            This leverages the SDK's ResourceIterator.next_page_token property
+            for proper token-based pagination and resume capability.
+        """
+        all_items: List[Any] = []
+        page_num = 0
+        max_pages = config.effective_max_pages()
+        next_token = None
+        has_more = False
+
+        try:
+            # Collect items from the iterator
+            for item in iterator:
+                all_items.append(item)
+
+                # Check if we've completed a "page" worth of items
+                page_size = config.page_size or 20  # Default page size
+                if len(all_items) % page_size == 0:
+                    page_num += 1
+
+                    # Update progress
+                    if progress_callback:
+                        progress_callback(page_num, len(all_items))
+
+                    # Check if we should stop
+                    if max_pages is not None and page_num >= max_pages:
+                        # Capture next_page_token BEFORE breaking while iterator state is known
+                        if hasattr(iterator, "next_page_token"):
+                            next_token = iterator.next_page_token
+                            has_more = next_token is not None
+                        break
+
+            # Calculate final page number if items don't align with page_size
+            if len(all_items) % page_size != 0:
+                page_num += 1
+                if progress_callback:
+                    progress_callback(page_num, len(all_items))
+
+            # If we didn't break early (exhausted iterator), check for next_page_token
+            if next_token is None and hasattr(iterator, "next_page_token"):
+                next_token = iterator.next_page_token
+                has_more = next_token is not None
+
+        except Exception as e:
+            # Error occurred during iteration - return partial results
+            if all_items:
+                # We have partial results
+                import sys
+
+                print(
+                    f"\nWarning: Error during iteration: {e}",
+                    file=sys.stderr,
+                )
+                print(
+                    f"Returning partial results ({len(all_items)} items)",
+                    file=sys.stderr,
+                )
+
+                # Try to get next_page_token if available
+                if hasattr(iterator, "next_page_token"):
+                    next_token = iterator.next_page_token
+                    has_more = next_token is not None
+            else:
+                # No data fetched yet - re-raise the error
+                raise
+
+        metadata = PaginationMetadata(
+            current_page=page_num,
+            items_fetched=len(all_items),
+            next_page_token=next_token,
+            has_more=has_more,
+            total_pages_fetched=page_num,
+        )
+
+        return PaginationResult(data=all_items, metadata=metadata)

{pltr_cli-0.11.0.dist-info → pltr_cli-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pltr-cli
-Version: 0.11.0
+Version: 0.12.0
 Summary: Command-line interface for Palantir Foundry APIs
 Project-URL: Homepage, https://github.com/anjor/pltr-cli
 Project-URL: Repository, https://github.com/anjor/pltr-cli
@@ -29,6 +29,7 @@ Requires-Python: >=3.9
 Requires-Dist: click-repl>=0.3.0
 Requires-Dist: foundry-platform-sdk>=1.27.0
 Requires-Dist: keyring>=25.6.0
+Requires-Dist: pandas>=2.0.0
 Requires-Dist: python-dotenv>=1.1.1
 Requires-Dist: requests>=2.32.4
 Requires-Dist: rich>=14.1.0
@@ -37,7 +38,7 @@ Description-Content-Type: text/markdown
 
 # pltr-cli
 
-A comprehensive command-line interface for Palantir Foundry APIs, providing 80+ commands for data analysis, dataset management, ontology operations, orchestration, SQL queries, folder management, and administrative tasks.
+A comprehensive command-line interface for Palantir Foundry APIs, providing 81+ commands for data analysis, dataset management, ontology operations, orchestration, SQL queries, folder management, and administrative tasks.
 
 ## Overview
 
@@ -215,6 +216,7 @@ pltr connectivity import table <conn-rid> <table-name> <dataset-rid> --execute
 # Administrative
 pltr admin user current        # Current user info
 pltr admin user list          # List users
+pltr third-party-apps get <rid>  # Get third-party application details
 
 # Interactive & Tools
 pltr shell                    # Interactive mode
@@ -470,7 +472,7 @@ See **[API Wrapper Documentation](docs/api/wrapper.md)** for detailed architectu
 
 pltr-cli is **production-ready** with comprehensive features:
 
-- ✅ **80+ Commands** across 10 command groups
+- ✅ **81+ Commands** across 11 command groups
 - ✅ **273 Unit Tests** with 67% code coverage
 - ✅ **Published on PyPI** with automated releases
 - ✅ **Cross-Platform** support (Windows, macOS, Linux)

pltr_cli-0.12.0.dist-info/RECORD

@@ -0,0 +1,62 @@
+pltr/__init__.py,sha256=eHjt9DPsMbptabS2yGx9Yhbyzq5hFSUHXb7zc8Q_8-o,23
+pltr/__main__.py,sha256=HWJ49UoAYBQCf8kjuySPmBTuUjTZrOx-y6PzMTyS1KE,879
+pltr/cli.py,sha256=jyUbgOzqJkbZUr1NcnJDSXIhBFG7WMn-8q8TYoQTDzU,3085
+pltr/auth/__init__.py,sha256=G0V-Rh25FaJsH2nhrf146XQQG_ApdbyPJNuHJC25kgk,38
+pltr/auth/base.py,sha256=LvmCwS7A0q0CITcym8udPzdACL52_jSGusiaeCTOaE8,981
+pltr/auth/manager.py,sha256=ZqlGefr1a8MGx0g7kkQhpmiuVp0XTg3f43yMBCk-IRo,4305
+pltr/auth/oauth.py,sha256=uTl5T3MSPlq8Jb3c45hib0vj-GQoyLxmS_NbnKez5dI,2844
+pltr/auth/storage.py,sha256=C7I3-22CJcnrKGNdxk9nXjphsnqQVguT5gNfAnR78Ok,2474
+pltr/auth/token.py,sha256=V48kxGn7CFbNGo17er5oI_ZA3xJ3iS9TsFjphZYqS2s,1925
+pltr/commands/__init__.py,sha256=iOLJ1ql4mz-3-4nz21hAqjd-9IjpYAIxr9SJQKHNFxM,29
+pltr/commands/admin.py,sha256=2E38LAFP5O1bTFzBASd-7IO7NAWPRoIkWm2nOjEczq8,34998
+pltr/commands/aip_agents.py,sha256=vPFRNmj6hR8sbedaIjgb77T-b4-cmodCwV4Z2m8T5NE,10324
+pltr/commands/alias.py,sha256=r9xMsQNrGvaixSlspzoO2IXQ44LFXuZM4itt8vC0dRc,6862
+pltr/commands/completion.py,sha256=YTxaRL4-rDs5n7aXf3ogFsxbHVJUBo_HiBbd0fbBPZ0,10870
+pltr/commands/configure.py,sha256=oYj-VlOEj3MDwtB2RC4bYOYzI_sXTanPnz7y1GmMTqY,4800
+pltr/commands/connectivity.py,sha256=6oqKjEx0a2vLGIXhDrwRXVP5ATa36QQQ7dNOvXrqM-8,25442
+pltr/commands/cp.py,sha256=yYUJ9gf_px2NvbmDEFtWkhHM96ddzL5-2pJUTSW0dIg,3050
+pltr/commands/dataset.py,sha256=TEqyALNgSO1jOX6RJvOHkvsvfC-oYL_94__q0fd4gIg,56693
+pltr/commands/folder.py,sha256=ItUp49lyDWIoMv8RaNDo7JFyrlk-r_Klab9FCPXwUM8,10721
+pltr/commands/mediasets.py,sha256=u_Ju3vsWl8ZVQvKxArk9pFQJVVrr9eua1X0PTaDxDwk,21832
+pltr/commands/ontology.py,sha256=ArDdlYdYy9CnPQWCMKHbwWYmWKFx48jul224urQDENM,22956
+pltr/commands/orchestration.py,sha256=qQxSdG9p76dj2FgYxv8IY-D6WrSDxNJik-vYVkDWARM,28483
+pltr/commands/project.py,sha256=jFwsA9LzYVuOEPGRjULOPnv7E0DgxXIy4uSmE-pKqU4,22662
+pltr/commands/resource.py,sha256=NxLVspn4PaBMNIXHM3yhmOMavxods5-Ehe_uqR3Y7lo,33837
+pltr/commands/resource_role.py,sha256=pM0DQxLBU9xyIYzLv1Y0sOMZG5oZ1INNSkMubYBGHJM,15394
+pltr/commands/shell.py,sha256=QLF7TEGpaau9i0A9s3VjnegvtHde-SLRqI4suJFT4WI,3622
+pltr/commands/space.py,sha256=R9TN9OQVDtFB92DOjrh81_YYajiQaqRNELsBHK4O-pI,21944
+pltr/commands/sql.py,sha256=Nn3fyrqS11LxWV_w0V73Wvv5dxHATPBKEPQHlS8HMvA,14148
+pltr/commands/third_party_applications.py,sha256=0fGSx7anaO4sVxE8-I8lQlOqdRO5J46CjQ3ABjAdI-8,2508
+pltr/commands/verify.py,sha256=n8LWhbfGieYa-a5_l3MxqkYbdpyVf8-i0FQIL__AaPA,6650
+pltr/config/__init__.py,sha256=Y6gARy5lUHy-OJaOUxtfXoeQVNZV5QHLl6uKHQ8tpTk,41
+pltr/config/aliases.py,sha256=ZmesZWMfa5riZlVe3fyC7EI3uIzxEGsDHz-8shOpIbM,6947
+pltr/config/profiles.py,sha256=XMUIp6Ez5LNC6rGXZe2JLH7IKepXhARtuc8ASUA9FYA,3431
+pltr/config/settings.py,sha256=bfIiosPqH_W73TOHS71DvgZdAHka4fJDopU1SvBRFuQ,2908
+pltr/services/__init__.py,sha256=zQpgrqPdAkZI-nobi33mctU2-iGNgazzvjBVY8YRbSQ,101
+pltr/services/admin.py,sha256=0nxQEYYY0H3dCica0_gSdhdeZR6v04Z46LuvX22cYuE,20650
+pltr/services/aip_agents.py,sha256=fyzJPXcaIAPwWvDDtwR53fpDTDfSUD0DEJvieaOzOpQ,5218
+pltr/services/base.py,sha256=R64ao_k-HihjW-WugDsJlo0Z4sV3aBGe0v2TyN4FwvM,7266
+pltr/services/connectivity.py,sha256=0KNoZJFms5R3-zHiWlCSQe5aeBWlxIiwIxpOJw7Y-dI,15107
+pltr/services/copy.py,sha256=bJEQYVAiouRMiz25QU3ET7Q6g4oXIqeTsuyrbwQpuxs,15081
+pltr/services/dataset.py,sha256=EkMJQm-opqchbg6b_pLHS8otdTi0wli7ANa3eHSZD2A,47560
+pltr/services/folder.py,sha256=mWElyvn-wXPB5sv8Ik_dLeW5JM6jZg3g9KKBk6UcrlQ,5389
+pltr/services/mediasets.py,sha256=dNUGVLb50WMOXq06_A6UIrELRa23c4yfjlzpF1vGD8w,14499
+pltr/services/ontology.py,sha256=1E3ejSansyyQRorvws1eeKpbYMBVIOrvEWdVNoqrovI,18652
+pltr/services/orchestration.py,sha256=C-jEW2Q2Mggpdff_WGdnAaRoytj5XyX7n5pEAAJKOfQ,19270
+pltr/services/project.py,sha256=kiY1hRqeFouDhIXubHwtz2ZClB94PhCLJryD1FJARhY,12504
+pltr/services/resource.py,sha256=hUlYRIwZvgp7V-o50QJDXcVE2aGvq7XHaURXWYm6RuU,17712
+pltr/services/resource_role.py,sha256=Ootor16c6PR9TNxe6KJyd4W2lYM_HHDxJk-JvZhgRxU,10608
+pltr/services/space.py,sha256=4uea1nQ6CA-6_xWoD6n49E4Zm6KbW_7Cq9o89JorMTE,11544
+pltr/services/sql.py,sha256=sVB7A-vp3QdrdFcFCX3e3eGsEwaxcmYS3qwDNDMx1oY,12509
+pltr/services/third_party_applications.py,sha256=v-V4CQl371DhSI0l-WMVf-vxfXWddwjS7_DE2IRtad4,1966
+pltr/utils/__init__.py,sha256=DF7TigL1XbKVGM5VjgU8_8AGIszofkdO80oCzLGGnTE,38
+pltr/utils/alias_resolver.py,sha256=DIF7P1UnUU8kqocJfIDEWjYq4s8_0KfqRZBbECeZEh8,1539
+pltr/utils/completion.py,sha256=bjeqjleEfB2YcQFpcxvF0GoQ763F6KBbULSZC4FWY_g,4980
+pltr/utils/formatting.py,sha256=CE0eVojkLIBfMevBDt4BKN_jyIgdLjNSNhpba3gRJGE,57502
+pltr/utils/pagination.py,sha256=BgJ-AOAQQ1grF05lB8Lz3Pi5B8c_boEsa9WQo84Uako,11219
+pltr/utils/progress.py,sha256=BKYbiLO61uhQbibabU7pxvvbAWMRLRmqk4pZldBQK_g,9053
+pltr_cli-0.12.0.dist-info/METADATA,sha256=wFYEN6U4kEnUfjzuHxPGQc0AX6htysCfUe-4Ncirpv4,17815
+pltr_cli-0.12.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pltr_cli-0.12.0.dist-info/entry_points.txt,sha256=8tvEcW04kA_oAE2Dwwu-Og9efjl4ESJvs4AzlP2KBdQ,38
+pltr_cli-0.12.0.dist-info/licenses/LICENSE,sha256=6VUFd_ytnOBD2O1tmkKrA-smigi9QEhYr_tge4h4z8Y,1070
+pltr_cli-0.12.0.dist-info/RECORD,,

{pltr_cli-0.11.0.dist-info → pltr_cli-0.12.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any