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

pltr/services/project.py

@@ -3,6 +3,7 @@ Project service wrapper for Foundry SDK filesystem API.
 """
 
 from typing import Any, Optional, Dict, List
+import inspect
 
 from .base import BaseService
 
@@ -21,7 +22,7 @@ class ProjectService(BaseService):
         description: Optional[str] = None,
         organization_rids: Optional[List[str]] = None,
         default_roles: Optional[List[str]] = None,
-        role_grants: Optional[List[Dict[str, Any]]] = None,
+        role_grants: Optional[Any] = None,
     ) -> Dict[str, Any]:
         """
         Create a new project.
@@ -38,25 +39,84 @@ class ProjectService(BaseService):
             Created project information
         """
         try:
-            # Prepare the create request payload
-            create_request: Dict[str, Any] = {
+            normalized_role_grants: Dict[str, List[Dict[str, Any]]] = {}
+            if role_grants is None:
+                from .admin import AdminService
+
+                current_user = AdminService(profile=self.profile).get_current_user()
+                user_id = (
+                    current_user.get("id")
+                    or current_user.get("user_id")
+                    or current_user.get("userId")
+                )
+                if not user_id:
+                    raise RuntimeError(
+                        "Unable to determine current user id for owner role grant"
+                    )
+                normalized_role_grants = {
+                    "compass:manage": [
+                        {
+                            "principal_id": user_id,
+                            "principal_type": "USER",
+                        }
+                    ]
+                }
+            elif role_grants:
+                if isinstance(role_grants, dict):
+                    normalized_role_grants = role_grants
+                elif isinstance(role_grants, list):
+                    for grant in role_grants:
+                        if not isinstance(grant, dict):
+                            raise ValueError(
+                                "role_grants list entries must be dictionaries"
+                            )
+                        role_name = grant.get("role_name")
+                        if not role_name:
+                            raise ValueError(
+                                "role_grants entries must include role_name"
+                            )
+                        principal = {
+                            key: value
+                            for key, value in grant.items()
+                            if key != "role_name"
+                        }
+                        normalized_role_grants.setdefault(role_name, []).append(
+                            principal
+                        )
+                else:
+                    raise ValueError("role_grants must be a dict or a list of dicts")
+
+            if normalized_role_grants:
+                for principals in normalized_role_grants.values():
+                    for principal in principals:
+                        principal_type = principal.get("principal_type")
+                        if isinstance(principal_type, str):
+                            principal["principal_type"] = principal_type.upper()
+
+            create_params: Dict[str, Any] = {
                 "display_name": display_name,
                 "space_rid": space_rid,
+                "description": description,
+                "organization_rids": organization_rids if organization_rids else [],
+                "default_roles": default_roles if default_roles else [],
+                "role_grants": normalized_role_grants,
             }
 
-            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,
-            )
+            create_fn = self.service.Project.create
+            try:
+                params = inspect.signature(create_fn).parameters
+                supports_kwargs = "display_name" in params or any(
+                    param.kind == inspect.Parameter.VAR_KEYWORD
+                    for param in params.values()
+                )
+                if supports_kwargs:
+                    project = create_fn(**create_params, preview=True)
+                elif "body" in params:
+                    project = create_fn(body=create_params, preview=True)
+                else:
+                    project = create_fn(**create_params, preview=True)
+            except (TypeError, ValueError):
+                project = create_fn(**create_params, preview=True)
             return self._format_project_info(project)
         except Exception as e:
             raise RuntimeError(f"Failed to create project '{display_name}': {e}")
@@ -134,56 +194,154 @@ class ProjectService(BaseService):
         description: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
-        Update project information.
+        Update project information using replace().
 
         Args:
             project_rid: Project Resource Identifier
-            display_name: New display name (optional)
+            display_name: New display name (optional, fetches current if not provided)
             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:
+        if not display_name and not description:
             raise ValueError("At least one field must be provided for update")
 
         try:
-            project = self.service.Project.update(
+            # Fetch current project to get display_name if not provided (required for replace)
+            if not display_name:
+                current_project = self.service.Project.get(project_rid, preview=True)
+                display_name = current_project.display_name
+
+            project = self.service.Project.replace(
                 project_rid=project_rid,
-                body=update_request,
+                display_name=display_name,
+                description=description,
                 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]]:
+    # ==================== Organization Operations ====================
+
+    def add_organizations(self, project_rid: str, organization_rids: List[str]) -> None:
+        """
+        Add organizations to a project.
+
+        Args:
+            project_rid: Project Resource Identifier
+            organization_rids: List of organization RIDs to add
+
+        Raises:
+            RuntimeError: If adding organizations fails
+        """
+        try:
+            self.service.Project.add_organizations(
+                project_rid, organization_rids=organization_rids, preview=True
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to add organizations to project {project_rid}: {e}"
+            )
+
+    def remove_organizations(
+        self, project_rid: str, organization_rids: List[str]
+    ) -> None:
+        """
+        Remove organizations from a project.
+
+        Args:
+            project_rid: Project Resource Identifier
+            organization_rids: List of organization RIDs to remove
+
+        Raises:
+            RuntimeError: If removing organizations fails
         """
-        Get multiple projects in a single request.
+        try:
+            self.service.Project.remove_organizations(
+                project_rid, organization_rids=organization_rids, preview=True
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to remove organizations from project {project_rid}: {e}"
+            )
+
+    def list_organizations(
+        self,
+        project_rid: str,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        List organizations directly applied to a project.
 
         Args:
-            project_rids: List of project RIDs (max 1000)
+            project_rid: Project Resource Identifier
+            page_size: Number of items per page (optional)
+            page_token: Pagination token (optional)
 
         Returns:
-            List of project information dictionaries
+            List of organization information dictionaries
         """
-        if len(project_rids) > 1000:
-            raise ValueError("Maximum batch size is 1000 projects")
+        try:
+            organizations = []
+            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 org in self.service.Project.organizations(project_rid, **list_params):
+                organizations.append(self._format_organization_info(org))
+            return organizations
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to list organizations for project {project_rid}: {e}"
+            )
+
+    # ==================== Template Operations ====================
+
+    def create_project_from_template(
+        self,
+        template_rid: str,
+        variable_values: Dict[str, str],
+        default_roles: Optional[List[str]] = None,
+        organization_rids: Optional[List[str]] = None,
+        project_description: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a project from a template.
+
+        Args:
+            template_rid: Template Resource Identifier
+            variable_values: Dictionary mapping template variable names to values
+            default_roles: List of default role names (optional)
+            organization_rids: List of organization RIDs (optional)
+            project_description: Project description (optional)
+
+        Returns:
+            Created project information
+        """
         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
+            create_params: Dict[str, Any] = {
+                "template_rid": template_rid,
+                "variable_values": variable_values,
+                "preview": True,
+            }
+
+            if default_roles:
+                create_params["default_roles"] = default_roles
+            if organization_rids:
+                create_params["organization_rids"] = organization_rids
+            if project_description:
+                create_params["project_description"] = project_description
+
+            project = self.service.Project.create_from_template(**create_params)
+            return self._format_project_info(project)
         except Exception as e:
-            raise RuntimeError(f"Failed to get projects batch: {e}")
+            raise RuntimeError(f"Failed to create project from template: {e}")
 
     def _format_project_info(self, project: Any) -> Dict[str, Any]:
         """
@@ -213,6 +371,22 @@ class ProjectService(BaseService):
             "type": "project",
         }
 
+    def _format_organization_info(self, organization: Any) -> Dict[str, Any]:
+        """
+        Format organization information for consistent output.
+
+        Args:
+            organization: Organization object from Foundry SDK
+
+        Returns:
+            Formatted organization information dictionary
+        """
+        return {
+            "organization_rid": getattr(organization, "organization_rid", None),
+            "display_name": getattr(organization, "display_name", None),
+            "description": getattr(organization, "description", None),
+        }
+
     def _format_timestamp(self, timestamp: Any) -> Optional[str]:
         """
         Format timestamp for display.

pltr/services/resource.py

@@ -4,6 +4,11 @@ Resource service wrapper for Foundry SDK filesystem API.
 
 from typing import Any, Optional, Dict, List
 
+from foundry_sdk.v2.filesystem.models import (
+    GetResourcesBatchRequestElement,
+    GetByPathResourcesBatchRequestElement,
+)
+
 from .base import BaseService
 
 
@@ -99,7 +104,11 @@ class ResourceService(BaseService):
             raise ValueError("Maximum batch size is 1000 resources")
 
         try:
-            response = self.service.Resource.get_batch(body=resource_rids, preview=True)
+            elements = [
+                GetResourcesBatchRequestElement(resource_rid=rid)
+                for rid in resource_rids
+            ]
+            response = self.service.Resource.get_batch(body=elements, preview=True)
             resources = []
             for resource in response.resources:
                 resources.append(self._format_resource_info(resource))
@@ -125,119 +134,230 @@ class ResourceService(BaseService):
                 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]:
+    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]]:
         """
-        Set metadata for a specific resource.
+        Search for resources by query string.
 
         Args:
-            resource_rid: Resource Identifier
-            metadata: Metadata dictionary to set
+            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:
-            Updated resource metadata
+            List of matching resource information dictionaries
         """
         try:
-            updated_metadata = self.service.Resource.set_metadata(
-                resource_rid=resource_rid,
-                body=metadata,
-                preview=True,
-            )
-            return self._format_metadata(updated_metadata)
+            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}")
+
+    # ==================== 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 set metadata for resource {resource_rid}: {e}"
+                f"Failed to permanently delete resource {resource_rid}: {e}"
             )
 
-    def delete_resource_metadata(self, resource_rid: str, keys: List[str]) -> None:
+    # ==================== Markings Operations ====================
+
+    def add_markings(self, resource_rid: str, marking_ids: List[str]) -> None:
         """
-        Delete specific metadata keys for a resource.
+        Add markings to a resource.
 
         Args:
             resource_rid: Resource Identifier
-            keys: List of metadata keys to delete
+            marking_ids: List of marking identifiers to add
 
         Raises:
-            RuntimeError: If deletion fails
+            RuntimeError: If adding markings fails
         """
         try:
-            self.service.Resource.delete_metadata(
-                resource_rid=resource_rid,
-                body={"keys": keys},
-                preview=True,
+            self.service.Resource.add_markings(
+                resource_rid, marking_ids=marking_ids, preview=True
             )
         except Exception as e:
             raise RuntimeError(
-                f"Failed to delete metadata for resource {resource_rid}: {e}"
+                f"Failed to add markings to resource {resource_rid}: {e}"
             )
 
-    def move_resource(
-        self, resource_rid: str, target_folder_rid: str
-    ) -> Dict[str, Any]:
+    def remove_markings(self, resource_rid: str, marking_ids: List[str]) -> None:
         """
-        Move a resource to a different folder.
+        Remove markings from a resource.
 
         Args:
             resource_rid: Resource Identifier
-            target_folder_rid: Target folder Resource Identifier
+            marking_ids: List of marking identifiers to remove
 
-        Returns:
-            Updated resource information
+        Raises:
+            RuntimeError: If removing markings fails
         """
         try:
-            resource = self.service.Resource.move(
-                resource_rid=resource_rid,
-                body={"target_folder_rid": target_folder_rid},
-                preview=True,
+            self.service.Resource.remove_markings(
+                resource_rid, marking_ids=marking_ids, preview=True
             )
-            return self._format_resource_info(resource)
         except Exception as e:
-            raise RuntimeError(f"Failed to move resource {resource_rid}: {e}")
+            raise RuntimeError(
+                f"Failed to remove markings from resource {resource_rid}: {e}"
+            )
 
-    def search_resources(
+    def list_markings(
         self,
-        query: str,
-        resource_type: Optional[str] = None,
-        folder_rid: Optional[str] = None,
+        resource_rid: str,
         page_size: Optional[int] = None,
         page_token: Optional[str] = None,
     ) -> List[Dict[str, Any]]:
         """
-        Search for resources by query string.
+        List markings directly applied to a resource.
 
         Args:
-            query: Search query string
-            resource_type: Resource type to filter by (optional)
-            folder_rid: Folder to search within (optional)
+            resource_rid: Resource Identifier
             page_size: Number of items per page (optional)
             page_token: Pagination token (optional)
 
         Returns:
-            List of matching resource information dictionaries
+            List of marking information dictionaries
         """
         try:
-            resources = []
-            search_params: Dict[str, Any] = {
-                "query": query,
-                "preview": True,
-            }
+            markings = []
+            list_params: Dict[str, Any] = {"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
+                list_params["page_size"] = page_size
             if page_token:
-                search_params["page_token"] = page_token
+                list_params["page_token"] = page_token
 
-            # The search method returns an iterator
-            for resource in self.service.Resource.search(**search_params):
+            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:
+            elements = [GetByPathResourcesBatchRequestElement(path=p) for p in paths]
+            response = self.service.Resource.get_by_path_batch(
+                body=elements, 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 search resources: {e}")
+            raise RuntimeError(f"Failed to get resources by path batch: {e}")
 
     def _format_resource_info(self, resource: Any) -> Dict[str, Any]:
         """
@@ -303,3 +423,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,
+        }