pltr-cli 0.12.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,57 +194,35 @@ 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]]:
-        """
-        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}")
-
     # ==================== Organization Operations ====================
 
     def add_organizations(self, project_rid: str, organization_rids: List[str]) -> None:

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,76 +134,6 @@ 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]:
-        """
-        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,
@@ -409,7 +348,10 @@ class ResourceService(BaseService):
             raise ValueError("Maximum batch size is 1000 paths")
 
         try:
-            response = self.service.Resource.get_by_path_batch(body=paths, preview=True)
+            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))

pltr/services/space.py

@@ -17,7 +17,9 @@ class SpaceService(BaseService):
     def create_space(
         self,
         display_name: str,
-        organization_rid: str,
+        enrollment_rid: str,
+        organizations: List[str],
+        deletion_policy_organizations: List[str],
         description: Optional[str] = None,
         default_roles: Optional[List[str]] = None,
         role_grants: Optional[List[Dict[str, Any]]] = None,
@@ -27,7 +29,9 @@ class SpaceService(BaseService):
 
         Args:
             display_name: Space display name
-            organization_rid: Organization Resource Identifier
+            enrollment_rid: Enrollment Resource Identifier
+            organizations: List of organization RIDs
+            deletion_policy_organizations: List of organization RIDs for deletion policy
             description: Space description (optional)
             default_roles: List of default role names (optional)
             role_grants: List of role grant specifications (optional)
@@ -36,21 +40,14 @@ class SpaceService(BaseService):
             Created space information
         """
         try:
-            # Prepare the create request payload
-            create_request: Dict[str, Any] = {
-                "display_name": display_name,
-                "organization_rid": organization_rid,
-            }
-
-            if description:
-                create_request["description"] = description
-            if default_roles:
-                create_request["default_roles"] = default_roles
-            if role_grants:
-                create_request["role_grants"] = role_grants
-
             space = self.service.Space.create(
-                body=create_request,
+                display_name=display_name,
+                enrollment_rid=enrollment_rid,
+                organizations=organizations,
+                deletion_policy_organizations=deletion_policy_organizations,
+                description=description,
+                default_roles=default_roles if default_roles else [],
+                role_grants=role_grants if role_grants else [],
                 preview=True,
             )
             return self._format_space_info(space)
@@ -115,29 +112,29 @@ class SpaceService(BaseService):
         description: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
-        Update space information.
+        Update space information using replace().
 
         Args:
             space_rid: Space 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 space 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:
-            space = self.service.Space.update(
+            # Fetch current space to get display_name if not provided (required for replace)
+            if not display_name:
+                current_space = self.service.Space.get(space_rid, preview=True)
+                display_name = current_space.display_name
+
+            space = self.service.Space.replace(
                 space_rid=space_rid,
-                body=update_request,
+                display_name=display_name,
+                description=description,
                 preview=True,
             )
             return self._format_space_info(space)
@@ -159,135 +156,6 @@ class SpaceService(BaseService):
         except Exception as e:
             raise RuntimeError(f"Failed to delete space {space_rid}: {e}")
 
-    def get_spaces_batch(self, space_rids: List[str]) -> List[Dict[str, Any]]:
-        """
-        Get multiple spaces in a single request.
-
-        Args:
-            space_rids: List of space RIDs (max 1000)
-
-        Returns:
-            List of space information dictionaries
-        """
-        if len(space_rids) > 1000:
-            raise ValueError("Maximum batch size is 1000 spaces")
-
-        try:
-            response = self.service.Space.get_batch(body=space_rids, preview=True)
-            spaces = []
-            for space in response.spaces:
-                spaces.append(self._format_space_info(space))
-            return spaces
-        except Exception as e:
-            raise RuntimeError(f"Failed to get spaces batch: {e}")
-
-    def get_space_members(
-        self,
-        space_rid: str,
-        principal_type: Optional[str] = None,
-        page_size: Optional[int] = None,
-        page_token: Optional[str] = None,
-    ) -> List[Dict[str, Any]]:
-        """
-        Get all members (users/groups) of a space.
-
-        Args:
-            space_rid: Space Resource Identifier
-            principal_type: Filter by principal type ('User' or 'Group', optional)
-            page_size: Number of items per page (optional)
-            page_token: Pagination token (optional)
-
-        Returns:
-            List of space member information dictionaries
-        """
-        try:
-            members = []
-            list_params: Dict[str, Any] = {"preview": True}
-
-            if principal_type:
-                list_params["principal_type"] = principal_type
-            if page_size:
-                list_params["page_size"] = page_size
-            if page_token:
-                list_params["page_token"] = page_token
-
-            # The get_members method returns an iterator
-            for member in self.service.Space.get_members(space_rid, **list_params):
-                members.append(self._format_member_info(member))
-            return members
-        except Exception as e:
-            raise RuntimeError(f"Failed to get members for space {space_rid}: {e}")
-
-    def add_space_member(
-        self,
-        space_rid: str,
-        principal_id: str,
-        principal_type: str,
-        role_name: str,
-    ) -> Dict[str, Any]:
-        """
-        Add a member to a space with a specific role.
-
-        Args:
-            space_rid: Space Resource Identifier
-            principal_id: Principal (user/group) identifier
-            principal_type: Principal type ('User' or 'Group')
-            role_name: Role name to grant
-
-        Returns:
-            Space member information
-        """
-        try:
-            member_request: Dict[str, Any] = {
-                "principal_id": principal_id,
-                "principal_type": principal_type,
-                "role_name": role_name,
-            }
-
-            result = self.service.Space.add_member(
-                space_rid=space_rid,
-                body=member_request,
-                preview=True,
-            )
-            return self._format_member_info(result)
-        except Exception as e:
-            raise RuntimeError(
-                f"Failed to add {principal_type} '{principal_id}' to space {space_rid}: {e}"
-            )
-
-    def remove_space_member(
-        self,
-        space_rid: str,
-        principal_id: str,
-        principal_type: str,
-    ) -> None:
-        """
-        Remove a member from a space.
-
-        Args:
-            space_rid: Space Resource Identifier
-            principal_id: Principal (user/group) identifier
-            principal_type: Principal type ('User' or 'Group')
-
-        Raises:
-            RuntimeError: If removal fails
-        """
-        try:
-            member_removal: Dict[str, Any] = {
-                "principal_id": principal_id,
-                "principal_type": principal_type,
-            }
-
-            self.service.Space.remove_member(
-                space_rid=space_rid,
-                body=member_removal,
-                preview=True,
-            )
-        except Exception as e:
-            raise RuntimeError(
-                f"Failed to remove {principal_type} '{principal_id}' from space {space_rid}: {e}"
-            )
-
     def _format_space_info(self, space: Any) -> Dict[str, Any]:
         """
         Format space information for consistent output.
@@ -316,25 +184,6 @@ class SpaceService(BaseService):
             "type": "space",
         }
 
-    def _format_member_info(self, member: Any) -> Dict[str, Any]:
-        """
-        Format space member information for consistent output.
-
-        Args:
-            member: Member object from Foundry SDK
-
-        Returns:
-            Formatted member information dictionary
-        """
-        return {
-            "space_rid": getattr(member, "space_rid", None),
-            "principal_id": getattr(member, "principal_id", None),
-            "principal_type": getattr(member, "principal_type", None),
-            "role_name": getattr(member, "role_name", None),
-            "added_by": getattr(member, "added_by", None),
-            "added_time": self._format_timestamp(getattr(member, "added_time", None)),
-        }
-
     def _format_timestamp(self, timestamp: Any) -> Optional[str]:
         """
         Format timestamp for display.