pltr-cli 0.5.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

pltr/services/project.py

@@ -0,0 +1,232 @@
+"""
+Project service wrapper for Foundry SDK filesystem API.
+"""
+
+from typing import Any, Optional, Dict, List
+
+from .base import BaseService
+
+
+class ProjectService(BaseService):
+    """Service wrapper for Foundry project operations using filesystem API."""
+
+    def _get_service(self) -> Any:
+        """Get the Foundry filesystem service."""
+        return self.client.filesystem
+
+    def create_project(
+        self,
+        display_name: str,
+        space_rid: str,
+        description: Optional[str] = None,
+        organization_rids: Optional[List[str]] = None,
+        default_roles: Optional[List[str]] = None,
+        role_grants: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new project.
+
+        Args:
+            display_name: Project display name (cannot contain '/')
+            space_rid: Space Resource Identifier where project will be created
+            description: Project description (optional)
+            organization_rids: List of organization RIDs (optional)
+            default_roles: List of default role names (optional)
+            role_grants: List of role grant specifications (optional)
+
+        Returns:
+            Created project information
+        """
+        try:
+            # Prepare the create request payload
+            create_request: Dict[str, Any] = {
+                "display_name": display_name,
+                "space_rid": space_rid,
+            }
+
+            if description:
+                create_request["description"] = description
+            if organization_rids:
+                create_request["organization_rids"] = organization_rids
+            if default_roles:
+                create_request["default_roles"] = default_roles
+            if role_grants:
+                create_request["role_grants"] = role_grants
+
+            project = self.service.Project.create(
+                body=create_request,
+                preview=True,
+            )
+            return self._format_project_info(project)
+        except Exception as e:
+            raise RuntimeError(f"Failed to create project '{display_name}': {e}")
+
+    def get_project(self, project_rid: str) -> Dict[str, Any]:
+        """
+        Get information about a specific project.
+
+        Args:
+            project_rid: Project Resource Identifier
+
+        Returns:
+            Project information dictionary
+        """
+        try:
+            project = self.service.Project.get(project_rid, preview=True)
+            return self._format_project_info(project)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get project {project_rid}: {e}")
+
+    def list_projects(
+        self,
+        space_rid: Optional[str] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        List projects, optionally filtered by space.
+
+        Args:
+            space_rid: Space Resource Identifier to filter by (optional)
+            page_size: Number of items per page (optional)
+            page_token: Pagination token (optional)
+
+        Returns:
+            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
+
+            # The list method returns an iterator
+            for project in self.service.Project.list(**list_params):
+                projects.append(self._format_project_info(project))
+            return projects
+        except Exception as e:
+            raise RuntimeError(f"Failed to list projects: {e}")
+
+    def delete_project(self, project_rid: str) -> None:
+        """
+        Delete a project.
+
+        Args:
+            project_rid: Project Resource Identifier
+
+        Raises:
+            RuntimeError: If deletion fails
+        """
+        try:
+            self.service.Project.delete(project_rid, preview=True)
+        except Exception as e:
+            raise RuntimeError(f"Failed to delete project {project_rid}: {e}")
+
+    def update_project(
+        self,
+        project_rid: str,
+        display_name: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update project information.
+
+        Args:
+            project_rid: Project Resource Identifier
+            display_name: New display name (optional)
+            description: New description (optional)
+
+        Returns:
+            Updated project information
+        """
+        update_request: Dict[str, Any] = {}
+        if display_name:
+            update_request["display_name"] = display_name
+        if description:
+            update_request["description"] = description
+
+        if not update_request:
+            raise ValueError("At least one field must be provided for update")
+
+        try:
+            project = self.service.Project.update(
+                project_rid=project_rid,
+                body=update_request,
+                preview=True,
+            )
+            return self._format_project_info(project)
+        except Exception as e:
+            raise RuntimeError(f"Failed to update project {project_rid}: {e}")
+
+    def get_projects_batch(self, project_rids: List[str]) -> List[Dict[str, Any]]:
+        """
+        Get multiple projects in a single request.
+
+        Args:
+            project_rids: List of project RIDs (max 1000)
+
+        Returns:
+            List of project information dictionaries
+        """
+        if len(project_rids) > 1000:
+            raise ValueError("Maximum batch size is 1000 projects")
+
+        try:
+            response = self.service.Project.get_batch(body=project_rids, preview=True)
+            projects = []
+            for project in response.projects:
+                projects.append(self._format_project_info(project))
+            return projects
+        except Exception as e:
+            raise RuntimeError(f"Failed to get projects batch: {e}")
+
+    def _format_project_info(self, project: Any) -> Dict[str, Any]:
+        """
+        Format project information for consistent output.
+
+        Args:
+            project: Project object from Foundry SDK
+
+        Returns:
+            Formatted project information dictionary
+        """
+        return {
+            "rid": getattr(project, "rid", None),
+            "display_name": getattr(project, "display_name", None),
+            "description": getattr(project, "description", None),
+            "path": getattr(project, "path", None),
+            "space_rid": getattr(project, "space_rid", None),
+            "created_by": getattr(project, "created_by", None),
+            "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)
+            ),
+            "trash_status": getattr(project, "trash_status", None),
+            "type": "project",
+        }
+
+    def _format_timestamp(self, timestamp: Any) -> Optional[str]:
+        """
+        Format timestamp for display.
+
+        Args:
+            timestamp: Timestamp object from SDK
+
+        Returns:
+            Formatted timestamp string or None
+        """
+        if timestamp is None:
+            return None
+
+        # Handle different timestamp formats from the SDK
+        if hasattr(timestamp, "time"):
+            return str(timestamp.time)
+        return str(timestamp)

pltr/services/resource.py

@@ -0,0 +1,289 @@
+"""
+Resource service wrapper for Foundry SDK filesystem API.
+"""
+
+from typing import Any, Optional, Dict, List
+
+from .base import BaseService
+
+
+class ResourceService(BaseService):
+    """Service wrapper for Foundry resource operations using filesystem API."""
+
+    def _get_service(self) -> Any:
+        """Get the Foundry filesystem service."""
+        return self.client.filesystem
+
+    def get_resource(self, resource_rid: str) -> Dict[str, Any]:
+        """
+        Get information about a specific resource.
+
+        Args:
+            resource_rid: Resource Identifier
+
+        Returns:
+            Resource information dictionary
+        """
+        try:
+            resource = self.service.Resource.get(resource_rid, preview=True)
+            return self._format_resource_info(resource)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get resource {resource_rid}: {e}")
+
+    def list_resources(
+        self,
+        folder_rid: Optional[str] = None,
+        resource_type: Optional[str] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        List resources, optionally filtered by folder and type.
+
+        Args:
+            folder_rid: Folder Resource Identifier to filter by (optional)
+            resource_type: Resource type to filter by (optional)
+            page_size: Number of items per page (optional)
+            page_token: Pagination token (optional)
+
+        Returns:
+            List of resource information dictionaries
+        """
+        try:
+            resources = []
+            list_params: Dict[str, Any] = {"preview": True}
+
+            if folder_rid:
+                list_params["folder_rid"] = folder_rid
+            if resource_type:
+                list_params["resource_type"] = resource_type
+            if page_size:
+                list_params["page_size"] = page_size
+            if page_token:
+                list_params["page_token"] = page_token
+
+            # The list method returns an iterator
+            for resource in self.service.Resource.list(**list_params):
+                resources.append(self._format_resource_info(resource))
+            return resources
+        except Exception as e:
+            raise RuntimeError(f"Failed to list resources: {e}")
+
+    def get_resources_batch(self, resource_rids: List[str]) -> List[Dict[str, Any]]:
+        """
+        Get multiple resources in a single request.
+
+        Args:
+            resource_rids: List of resource RIDs (max 1000)
+
+        Returns:
+            List of resource information dictionaries
+        """
+        if len(resource_rids) > 1000:
+            raise ValueError("Maximum batch size is 1000 resources")
+
+        try:
+            response = self.service.Resource.get_batch(body=resource_rids, 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 batch: {e}")
+
+    def get_resource_metadata(self, resource_rid: str) -> Dict[str, Any]:
+        """
+        Get metadata for a specific resource.
+
+        Args:
+            resource_rid: Resource Identifier
+
+        Returns:
+            Resource metadata dictionary
+        """
+        try:
+            metadata = self.service.Resource.get_metadata(resource_rid, preview=True)
+            return self._format_metadata(metadata)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to get metadata for resource {resource_rid}: {e}"
+            )
+
+    def set_resource_metadata(
+        self, resource_rid: str, metadata: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Set metadata for a specific resource.
+
+        Args:
+            resource_rid: Resource Identifier
+            metadata: Metadata dictionary to set
+
+        Returns:
+            Updated resource metadata
+        """
+        try:
+            updated_metadata = self.service.Resource.set_metadata(
+                resource_rid=resource_rid,
+                body=metadata,
+                preview=True,
+            )
+            return self._format_metadata(updated_metadata)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to set metadata for resource {resource_rid}: {e}"
+            )
+
+    def delete_resource_metadata(self, resource_rid: str, keys: List[str]) -> None:
+        """
+        Delete specific metadata keys for a resource.
+
+        Args:
+            resource_rid: Resource Identifier
+            keys: List of metadata keys to delete
+
+        Raises:
+            RuntimeError: If deletion fails
+        """
+        try:
+            self.service.Resource.delete_metadata(
+                resource_rid=resource_rid,
+                body={"keys": keys},
+                preview=True,
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to delete metadata for resource {resource_rid}: {e}"
+            )
+
+    def move_resource(
+        self, resource_rid: str, target_folder_rid: str
+    ) -> Dict[str, Any]:
+        """
+        Move a resource to a different folder.
+
+        Args:
+            resource_rid: Resource Identifier
+            target_folder_rid: Target folder Resource Identifier
+
+        Returns:
+            Updated resource information
+        """
+        try:
+            resource = self.service.Resource.move(
+                resource_rid=resource_rid,
+                body={"target_folder_rid": target_folder_rid},
+                preview=True,
+            )
+            return self._format_resource_info(resource)
+        except Exception as e:
+            raise RuntimeError(f"Failed to move resource {resource_rid}: {e}")
+
+    def search_resources(
+        self,
+        query: str,
+        resource_type: Optional[str] = None,
+        folder_rid: Optional[str] = None,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Search for resources by query string.
+
+        Args:
+            query: Search query string
+            resource_type: Resource type to filter by (optional)
+            folder_rid: Folder to search within (optional)
+            page_size: Number of items per page (optional)
+            page_token: Pagination token (optional)
+
+        Returns:
+            List of matching resource information dictionaries
+        """
+        try:
+            resources = []
+            search_params: Dict[str, Any] = {
+                "query": query,
+                "preview": True,
+            }
+
+            if resource_type:
+                search_params["resource_type"] = resource_type
+            if folder_rid:
+                search_params["folder_rid"] = folder_rid
+            if page_size:
+                search_params["page_size"] = page_size
+            if page_token:
+                search_params["page_token"] = page_token
+
+            # The search method returns an iterator
+            for resource in self.service.Resource.search(**search_params):
+                resources.append(self._format_resource_info(resource))
+            return resources
+        except Exception as e:
+            raise RuntimeError(f"Failed to search resources: {e}")
+
+    def _format_resource_info(self, resource: Any) -> Dict[str, Any]:
+        """
+        Format resource information for consistent output.
+
+        Args:
+            resource: Resource object from Foundry SDK
+
+        Returns:
+            Formatted resource information dictionary
+        """
+        return {
+            "rid": getattr(resource, "rid", None),
+            "display_name": getattr(resource, "display_name", None),
+            "name": getattr(resource, "name", None),
+            "description": getattr(resource, "description", None),
+            "path": getattr(resource, "path", None),
+            "type": getattr(resource, "type", None),
+            "folder_rid": getattr(resource, "folder_rid", None),
+            "created_by": getattr(resource, "created_by", None),
+            "created_time": self._format_timestamp(
+                getattr(resource, "created_time", None)
+            ),
+            "modified_by": getattr(resource, "modified_by", None),
+            "modified_time": self._format_timestamp(
+                getattr(resource, "modified_time", None)
+            ),
+            "size_bytes": getattr(resource, "size_bytes", None),
+            "trash_status": getattr(resource, "trash_status", None),
+        }
+
+    def _format_metadata(self, metadata: Any) -> Dict[str, Any]:
+        """
+        Format metadata for consistent output.
+
+        Args:
+            metadata: Metadata object from Foundry SDK
+
+        Returns:
+            Formatted metadata dictionary
+        """
+        if hasattr(metadata, "__dict__"):
+            return dict(metadata.__dict__)
+        elif isinstance(metadata, dict):
+            return metadata
+        else:
+            return {"raw": str(metadata)}
+
+    def _format_timestamp(self, timestamp: Any) -> Optional[str]:
+        """
+        Format timestamp for display.
+
+        Args:
+            timestamp: Timestamp object from SDK
+
+        Returns:
+            Formatted timestamp string or None
+        """
+        if timestamp is None:
+            return None
+
+        # Handle different timestamp formats from the SDK
+        if hasattr(timestamp, "time"):
+            return str(timestamp.time)
+        return str(timestamp)