pltr-cli 0.13.1__tar.gz → 0.14.0__tar.gz

{pltr_cli-0.13.1 → pltr_cli-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pltr-cli
-Version: 0.13.1
+Version: 0.14.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

{pltr_cli-0.13.1 → pltr_cli-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pltr-cli"
-version = "0.13.1"
+version = "0.14.0"
 description = "Command-line interface for Palantir Foundry APIs"
 authors = [
     { name = "anjor", email = "anjor@umd.edu" },

pltr_cli-0.14.0/src/pltr/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.14.0"

{pltr_cli-0.13.1 → pltr_cli-0.14.0}/src/pltr/auth/oauth.py

@@ -54,7 +54,16 @@ class OAuthClientProvider(AuthProvider):
             client_secret=self.client_secret,  # type: ignore
             scopes=self.scopes,
         )
-        return FoundryClient(auth=auth, hostname=self.host)
+        # Newer SDKs may support client-level preview mode while older ones do not.
+        # Try the preview-aware constructor first, then fall back for compatibility.
+        try:
+            return FoundryClient(  # type: ignore[call-arg]
+                auth=auth, hostname=self.host, preview=True
+            )
+        except TypeError as e:
+            if "preview" not in str(e):
+                raise
+            return FoundryClient(auth=auth, hostname=self.host)
 
     def validate(self) -> bool:
         """Validate authentication credentials."""

{pltr_cli-0.13.1 → pltr_cli-0.14.0}/src/pltr/auth/token.py

@@ -32,7 +32,16 @@ class TokenAuthProvider(AuthProvider):
         from foundry_sdk import FoundryClient, UserTokenAuth
 
         auth = UserTokenAuth(token=self.token)  # type: ignore
-        return FoundryClient(auth=auth, hostname=self.host)
+        # Newer SDKs may support client-level preview mode while older ones do not.
+        # Try the preview-aware constructor first, then fall back for compatibility.
+        try:
+            return FoundryClient(  # type: ignore[call-arg]
+                auth=auth, hostname=self.host, preview=True
+            )
+        except TypeError as e:
+            if "preview" not in str(e):
+                raise
+            return FoundryClient(auth=auth, hostname=self.host)
 
     def validate(self) -> bool:
         """Validate authentication credentials."""

{pltr_cli-0.13.1 → pltr_cli-0.14.0}/src/pltr/services/connectivity.py

@@ -2,14 +2,22 @@
 Connectivity service wrapper for Foundry SDK.
 """
 
+import logging
+import os
+from collections import deque
 from typing import Any, Optional, Dict, List
 
 from .base import BaseService
 
+logger = logging.getLogger(__name__)
+
 
 class ConnectivityService(BaseService):
     """Service wrapper for Foundry connectivity operations."""
 
+    DEFAULT_FILESYSTEM_FALLBACK_START_FOLDER_RID = "ri.compass.main.folder.0"
+    MAX_FALLBACK_FOLDERS = 1000
+
     def _get_service(self) -> Any:
         """Get the Foundry client for connectivity operations."""
         return self.client
@@ -17,7 +25,15 @@ class ConnectivityService(BaseService):
     @property
     def connections_service(self) -> Any:
         """Get the connections service from the client."""
-        return self.client.connections
+        # Prefer legacy namespace first for backward compatibility with older SDKs.
+        legacy_connections = getattr(self.client, "connections", None)
+        if legacy_connections is not None:
+            return legacy_connections
+
+        connectivity = getattr(self.client, "connectivity", None)
+        if connectivity is None:
+            raise RuntimeError("Connectivity service is not available on the client")
+        return connectivity
 
     @property
     def file_imports_service(self) -> Any:
@@ -37,8 +53,17 @@ class ConnectivityService(BaseService):
             List of connection information dictionaries
         """
         try:
-            connections = self.connections_service.Connection.list()
-            return [self._format_connection_info(conn) for conn in connections]
+            connection_client = self.connections_service.Connection
+            if hasattr(connection_client, "list"):
+                connections = connection_client.list()
+                return [self._format_connection_info(conn) for conn in connections]
+
+            logger.warning(
+                "Connection.list() is unavailable; falling back to filesystem scan. "
+                "Set PLTR_CONNECTIONS_FALLBACK_START_FOLDER_RID to a narrower folder "
+                "if this is slow."
+            )
+            return self._list_connections_from_filesystem()
         except Exception as e:
             raise RuntimeError(f"Failed to list connections: {e}")
 
@@ -384,6 +409,17 @@ class ConnectivityService(BaseService):
             Formatted connection dictionary
         """
         try:
+            if isinstance(connection, dict):
+                return {
+                    "rid": connection.get("rid", "N/A"),
+                    "display_name": connection.get("display_name", "N/A"),
+                    "description": connection.get("description", ""),
+                    "connection_type": connection.get("connection_type", "N/A"),
+                    "status": connection.get("status", "N/A"),
+                    "created_time": connection.get("created_time", "N/A"),
+                    "modified_time": connection.get("modified_time", "N/A"),
+                }
+
             return {
                 "rid": getattr(connection, "rid", "N/A"),
                 "display_name": getattr(connection, "display_name", "N/A"),
@@ -396,6 +432,88 @@ class ConnectivityService(BaseService):
         except Exception:
             return {"raw": str(connection)}
 
+    def _list_connections_from_filesystem(self) -> List[Dict[str, Any]]:
+        """
+        Discover connection resources from filesystem when SDK list() is unavailable.
+
+        Notes:
+            - Uses Folder.children(preview=True), which requires preview access.
+            - Traversal starts from PLTR_CONNECTIONS_FALLBACK_START_FOLDER_RID when set,
+              otherwise defaults to ri.compass.main.folder.0.
+        """
+        filesystem = getattr(self.client, "filesystem", None)
+        if filesystem is None or not hasattr(filesystem, "Folder"):
+            raise RuntimeError(
+                "Connection.list() is unavailable and filesystem fallback is not supported"
+            )
+
+        folder_client = filesystem.Folder
+        start_folder_rid = os.environ.get(
+            "PLTR_CONNECTIONS_FALLBACK_START_FOLDER_RID",
+            self.DEFAULT_FILESYSTEM_FALLBACK_START_FOLDER_RID,
+        )
+        pending_folders = deque([start_folder_rid])
+        visited_folders: set[str] = set()
+        discovered_connections: List[Dict[str, Any]] = []
+
+        while pending_folders and len(visited_folders) < self.MAX_FALLBACK_FOLDERS:
+            folder_rid = pending_folders.popleft()
+            if folder_rid in visited_folders:
+                continue
+            visited_folders.add(folder_rid)
+
+            try:
+                children = folder_client.children(folder_rid, preview=True)
+            except Exception as error:
+                if folder_rid == start_folder_rid:
+                    raise RuntimeError(
+                        f"Unable to list fallback start folder '{start_folder_rid}': {error}"
+                    ) from error
+                logger.debug(
+                    "Skipping folder '%s' during connection discovery due to error: %s",
+                    folder_rid,
+                    error,
+                )
+                continue
+
+            for child in children:
+                child_rid = getattr(child, "rid", None)
+                if not child_rid:
+                    continue
+
+                child_type = str(getattr(child, "type", "") or "").lower()
+                if self._looks_like_connection_resource(child_rid, child_type):
+                    discovered_connections.append(
+                        {
+                            "rid": child_rid,
+                            "display_name": getattr(child, "display_name", "N/A"),
+                            "description": getattr(child, "description", ""),
+                            "connection_type": child_type or "connection",
+                            "status": getattr(child, "status", "N/A"),
+                            "created_time": getattr(child, "created_time", "N/A"),
+                            "modified_time": getattr(child, "modified_time", "N/A"),
+                        }
+                    )
+                    continue
+
+                if child_type in {"folder", "compass_folder", "project", "space"}:
+                    pending_folders.append(child_rid)
+
+        if pending_folders:
+            raise RuntimeError(
+                "Connection discovery exceeded folder scan limit "
+                f"({self.MAX_FALLBACK_FOLDERS}). "
+                "Set PLTR_CONNECTIONS_FALLBACK_START_FOLDER_RID to a narrower folder "
+                "and retry."
+            )
+
+        return discovered_connections
+
+    @staticmethod
+    def _looks_like_connection_resource(resource_rid: str, resource_type: str) -> bool:
+        """Best-effort detection for connection resources from filesystem entries."""
+        return "connection" in resource_type or ".connection." in resource_rid
+
     def _format_import_info(self, import_obj: Any) -> Dict[str, Any]:
         """
         Format import information for display.

{pltr_cli-0.13.1 → pltr_cli-0.14.0}/src/pltr/services/folder.py

@@ -37,7 +37,8 @@ class FolderService(BaseService):
             )
             return self._format_folder_info(folder)
         except Exception as e:
-            raise RuntimeError(f"Failed to create folder '{display_name}': {e}")
+            detail = self._format_error_detail(e)
+            raise RuntimeError(f"Failed to create folder '{display_name}': {detail}")
 
     def get_folder(self, folder_rid: str) -> Dict[str, Any]:
         """
@@ -53,7 +54,8 @@ class FolderService(BaseService):
             folder = self.service.Folder.get(folder_rid, preview=True)
             return self._format_folder_info(folder)
         except Exception as e:
-            raise RuntimeError(f"Failed to get folder {folder_rid}: {e}")
+            detail = self._format_error_detail(e)
+            raise RuntimeError(f"Failed to get folder {folder_rid}: {detail}")
 
     def list_children(
         self,
@@ -81,7 +83,10 @@ class FolderService(BaseService):
                 children.append(self._format_resource_info(child))
             return children
         except Exception as e:
-            raise RuntimeError(f"Failed to list children of folder {folder_rid}: {e}")
+            detail = self._format_error_detail(e)
+            raise RuntimeError(
+                f"Failed to list children of folder {folder_rid}: {detail}"
+            )
 
     def get_folders_batch(self, folder_rids: List[str]) -> List[Dict[str, Any]]:
         """
@@ -106,7 +111,8 @@ class FolderService(BaseService):
                 folders.append(self._format_folder_info(folder))
             return folders
         except Exception as e:
-            raise RuntimeError(f"Failed to get folders batch: {e}")
+            detail = self._format_error_detail(e)
+            raise RuntimeError(f"Failed to get folders batch: {detail}")
 
     def _format_folder_info(self, folder: Any) -> Dict[str, Any]:
         """
@@ -170,3 +176,18 @@ class FolderService(BaseService):
         if hasattr(timestamp, "time"):
             return str(timestamp.time)
         return str(timestamp)
+
+    @staticmethod
+    def _format_error_detail(error: Exception) -> str:
+        """Format exception details, including fallback for empty SDK error strings."""
+        message = str(error).strip()
+        if message:
+            return message
+
+        args = getattr(error, "args", ())
+        if args:
+            joined = " ".join(str(arg) for arg in args if arg is not None)
+            if joined:
+                return joined
+
+        return error.__class__.__name__

{pltr_cli-0.13.1 → pltr_cli-0.14.0}/src/pltr/services/orchestration.py

@@ -147,14 +147,14 @@ class OrchestrationService(BaseService):
             Search results with pagination info
         """
         try:
-            kwargs: Dict[str, Any] = {}
+            kwargs: Dict[str, Any] = {"preview": True}
             if page_size is not None:
                 kwargs["page_size"] = page_size
             if page_token is not None:
                 kwargs["page_token"] = page_token
             kwargs.update(search_params)
 
-            response = self.service.Build.search(**kwargs)
+            response = self._search_with_optional_preview(kwargs)
             return self._format_builds_search_response(response)
         except Exception as e:
             raise RuntimeError(f"Failed to search builds: {e}")
@@ -183,18 +183,39 @@ class OrchestrationService(BaseService):
                 """Fetch a single page of builds."""
                 kwargs: Dict[str, Any] = {
                     "page_size": config.page_size or settings.get("page_size", 20),
+                    "preview": True,
                 }
                 if page_token:
                     kwargs["page_token"] = page_token
                 kwargs.update(search_params)
 
-                response = self.service.Build.search(**kwargs)
-                return self._format_builds_search_response(response)
+                response = self._search_with_optional_preview(kwargs)
+                formatted = self._format_builds_search_response(response)
+                return {
+                    "data": formatted.get("builds", []),
+                    "next_page_token": formatted.get("next_page_token"),
+                }
 
             return self._paginate_response(fetch_page, config, progress_callback)
         except Exception as e:
             raise RuntimeError(f"Failed to search builds: {e}")
 
+    def _search_with_optional_preview(self, kwargs: Dict[str, Any]) -> Any:
+        """
+        Execute Build.search with preview compatibility fallback.
+
+        Some SDK versions reject the `preview` kwarg at call-time even if preview
+        mode is enabled via client defaults.
+        """
+        try:
+            return self.service.Build.search(**kwargs)
+        except TypeError as e:
+            if "preview" not in str(e):
+                raise
+            fallback_kwargs = dict(kwargs)
+            fallback_kwargs.pop("preview", None)
+            return self.service.Build.search(**fallback_kwargs)
+
     def get_builds_batch(self, build_rids: List[str]) -> Dict[str, Any]:
         """
         Get multiple builds in batch.

{pltr_cli-0.13.1 → pltr_cli-0.14.0}/src/pltr/services/project.py

@@ -155,20 +155,30 @@ class ProjectService(BaseService):
             List of project information dictionaries
         """
         try:
-            projects = []
-            list_params: Dict[str, Any] = {"preview": True}
-
             if space_rid:
-                list_params["space_rid"] = space_rid
-            if page_size:
-                list_params["page_size"] = page_size
-            if page_token:
-                list_params["page_token"] = page_token
+                return self._list_projects_in_parent(
+                    parent_folder_rid=space_rid,
+                    page_size=page_size,
+                    page_token=page_token,
+                )
+
+            # page_size/page_token are cursor semantics for a single folder listing.
+            # They are not meaningful when aggregating projects across all spaces.
+            projects_by_rid: Dict[str, Dict[str, Any]] = {}
+            for space in self.service.Space.list(preview=True):
+                parent_space_rid = getattr(space, "rid", None)
+                if not parent_space_rid:
+                    continue
+
+                projects = self._list_projects_in_parent(
+                    parent_folder_rid=parent_space_rid
+                )
+                for project in projects:
+                    rid = project.get("rid")
+                    if rid:
+                        projects_by_rid[rid] = project
 
-            # The list method returns an iterator
-            for project in self.service.Project.list(**list_params):
-                projects.append(self._format_project_info(project))
-            return projects
+            return list(projects_by_rid.values())
         except Exception as e:
             raise RuntimeError(f"Failed to list projects: {e}")
 
@@ -353,6 +363,14 @@ class ProjectService(BaseService):
         Returns:
             Formatted project information dictionary
         """
+        modified_by = getattr(project, "modified_by", None)
+        if modified_by is None:
+            modified_by = getattr(project, "updated_by", None)
+
+        modified_time = getattr(project, "modified_time", None)
+        if modified_time is None:
+            modified_time = getattr(project, "updated_time", None)
+
         return {
             "rid": getattr(project, "rid", None),
             "display_name": getattr(project, "display_name", None),
@@ -363,14 +381,41 @@ class ProjectService(BaseService):
             "created_time": self._format_timestamp(
                 getattr(project, "created_time", None)
             ),
-            "modified_by": getattr(project, "modified_by", None),
-            "modified_time": self._format_timestamp(
-                getattr(project, "modified_time", None)
-            ),
+            "modified_by": modified_by,
+            "modified_time": self._format_timestamp(modified_time),
             "trash_status": getattr(project, "trash_status", None),
             "type": "project",
         }
 
+    def _list_projects_in_parent(
+        self,
+        parent_folder_rid: str,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """List project resources directly under a parent folder (space)."""
+        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
+
+        projects: List[Dict[str, Any]] = []
+        for resource in self.service.Folder.children(parent_folder_rid, **list_params):
+            if self._is_project_resource(resource):
+                projects.append(self._format_project_info(resource))
+        return projects
+
+    @staticmethod
+    def _is_project_resource(resource: Any) -> bool:
+        """Check whether a filesystem resource is a project."""
+        resource_type = str(getattr(resource, "type", "") or "").upper()
+        resource_rid = str(getattr(resource, "rid", "") or "")
+        # Fallback to canonical project RID prefix when type is missing.
+        return resource_type == "PROJECT" or resource_rid.startswith(
+            "ri.compass.main.project."
+        )
+
     def _format_organization_info(self, organization: Any) -> Dict[str, Any]:
         """
         Format organization information for consistent output.