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

pltr/services/orchestration.py

@@ -0,0 +1,457 @@
+"""
+Orchestration service wrapper for Foundry SDK v2 API.
+Provides operations for managing builds, jobs, and schedules.
+"""
+
+from typing import Any, Optional, Dict, List
+
+from .base import BaseService
+
+
+class OrchestrationService(BaseService):
+    """Service wrapper for Foundry orchestration operations using v2 API."""
+
+    def _get_service(self) -> Any:
+        """Get the Foundry orchestration service."""
+        return self.client.orchestration
+
+    # Build operations
+    def get_build(self, build_rid: str) -> Dict[str, Any]:
+        """
+        Get information about a specific build.
+
+        Args:
+            build_rid: Build Resource Identifier
+
+        Returns:
+            Build information dictionary
+        """
+        try:
+            build = self.service.Build.get(build_rid)
+            return self._format_build_info(build)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get build {build_rid}: {e}")
+
+    def create_build(
+        self,
+        target: Dict[str, Any],
+        fallback_branches: Optional[Dict[str, Any]] = None,
+        abort_on_failure: Optional[bool] = None,
+        branch_name: Optional[str] = None,
+        force_build: Optional[bool] = None,
+        notifications_enabled: Optional[bool] = None,
+        retry_backoff_duration: Optional[int] = None,
+        retry_count: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new build.
+
+        Args:
+            target: Build target configuration
+            fallback_branches: Fallback branches configuration
+            abort_on_failure: Whether to abort on failure
+            branch_name: Branch name for the build
+            force_build: Force build even if no changes
+            notifications_enabled: Enable notifications
+            retry_backoff_duration: Retry backoff duration in milliseconds
+            retry_count: Number of retries
+
+        Returns:
+            Created build information
+        """
+        try:
+            kwargs: Dict[str, Any] = {
+                "target": target,
+                "fallback_branches": fallback_branches or {},
+            }
+
+            # Add optional parameters if provided
+            if abort_on_failure is not None:
+                kwargs["abort_on_failure"] = abort_on_failure
+            if branch_name is not None:
+                kwargs["branch_name"] = branch_name
+            if force_build is not None:
+                kwargs["force_build"] = force_build
+            if notifications_enabled is not None:
+                kwargs["notifications_enabled"] = notifications_enabled
+            if retry_backoff_duration is not None:
+                kwargs["retry_backoff_duration"] = retry_backoff_duration
+            if retry_count is not None:
+                kwargs["retry_count"] = retry_count
+
+            build = self.service.Build.create(**kwargs)
+            return self._format_build_info(build)
+        except Exception as e:
+            raise RuntimeError(f"Failed to create build: {e}")
+
+    def cancel_build(self, build_rid: str) -> None:
+        """
+        Cancel a build.
+
+        Args:
+            build_rid: Build Resource Identifier
+        """
+        try:
+            self.service.Build.cancel(build_rid)
+        except Exception as e:
+            raise RuntimeError(f"Failed to cancel build {build_rid}: {e}")
+
+    def get_build_jobs(
+        self,
+        build_rid: str,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get jobs in a build.
+
+        Args:
+            build_rid: Build Resource Identifier
+            page_size: Number of results per page
+            page_token: Token for pagination
+
+        Returns:
+            Jobs list with pagination info
+        """
+        try:
+            kwargs: Dict[str, Any] = {"build_rid": build_rid}
+            if page_size is not None:
+                kwargs["page_size"] = page_size
+            if page_token is not None:
+                kwargs["page_token"] = page_token
+
+            response = self.service.Build.jobs(**kwargs)
+            return self._format_jobs_response(response)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get jobs for build {build_rid}: {e}")
+
+    def search_builds(
+        self,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+        **search_params,
+    ) -> Dict[str, Any]:
+        """
+        Search for builds.
+
+        Args:
+            page_size: Number of results per page
+            page_token: Token for pagination
+            **search_params: Additional search parameters
+
+        Returns:
+            Search results with pagination info
+        """
+        try:
+            kwargs: Dict[str, Any] = {}
+            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)
+            return self._format_builds_search_response(response)
+        except Exception as e:
+            raise RuntimeError(f"Failed to search builds: {e}")
+
+    # Job operations
+    def get_job(self, job_rid: str) -> Dict[str, Any]:
+        """
+        Get information about a specific job.
+
+        Args:
+            job_rid: Job Resource Identifier
+
+        Returns:
+            Job information dictionary
+        """
+        try:
+            job = self.service.Job.get(job_rid)
+            return self._format_job_info(job)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get job {job_rid}: {e}")
+
+    def get_jobs_batch(self, job_rids: List[str]) -> Dict[str, Any]:
+        """
+        Get multiple jobs in batch.
+
+        Args:
+            job_rids: List of Job Resource Identifiers (max 500)
+
+        Returns:
+            Batch response with job information
+        """
+        try:
+            if len(job_rids) > 500:
+                raise ValueError("Maximum batch size is 500 jobs")
+
+            body = [{"rid": rid} for rid in job_rids]
+            response = self.service.Job.get_batch(body)
+            return self._format_jobs_batch_response(response)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get jobs batch: {e}")
+
+    # Schedule operations
+    def get_schedule(
+        self, schedule_rid: str, preview: Optional[bool] = None
+    ) -> Dict[str, Any]:
+        """
+        Get information about a specific schedule.
+
+        Args:
+            schedule_rid: Schedule Resource Identifier
+            preview: Enable preview mode
+
+        Returns:
+            Schedule information dictionary
+        """
+        try:
+            kwargs: Dict[str, Any] = {"schedule_rid": schedule_rid}
+            if preview is not None:
+                kwargs["preview"] = preview
+
+            schedule = self.service.Schedule.get(**kwargs)
+            return self._format_schedule_info(schedule)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get schedule {schedule_rid}: {e}")
+
+    def create_schedule(
+        self,
+        action: Dict[str, Any],
+        description: Optional[str] = None,
+        display_name: Optional[str] = None,
+        trigger: Optional[Dict[str, Any]] = None,
+        scope_mode: Optional[str] = None,
+        preview: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new schedule.
+
+        Args:
+            action: Schedule action configuration
+            description: Schedule description
+            display_name: Display name for the schedule
+            trigger: Trigger configuration
+            scope_mode: Scope mode for the schedule
+            preview: Enable preview mode
+
+        Returns:
+            Created schedule information
+        """
+        try:
+            kwargs: Dict[str, Any] = {"action": action}
+
+            if description is not None:
+                kwargs["description"] = description
+            if display_name is not None:
+                kwargs["display_name"] = display_name
+            if trigger is not None:
+                kwargs["trigger"] = trigger
+            if scope_mode is not None:
+                kwargs["scope_mode"] = scope_mode
+            if preview is not None:
+                kwargs["preview"] = preview
+
+            schedule = self.service.Schedule.create(**kwargs)
+            return self._format_schedule_info(schedule)
+        except Exception as e:
+            raise RuntimeError(f"Failed to create schedule: {e}")
+
+    def delete_schedule(self, schedule_rid: str) -> None:
+        """
+        Delete a schedule.
+
+        Args:
+            schedule_rid: Schedule Resource Identifier
+        """
+        try:
+            self.service.Schedule.delete(schedule_rid)
+        except Exception as e:
+            raise RuntimeError(f"Failed to delete schedule {schedule_rid}: {e}")
+
+    def pause_schedule(self, schedule_rid: str) -> None:
+        """
+        Pause a schedule.
+
+        Args:
+            schedule_rid: Schedule Resource Identifier
+        """
+        try:
+            self.service.Schedule.pause(schedule_rid)
+        except Exception as e:
+            raise RuntimeError(f"Failed to pause schedule {schedule_rid}: {e}")
+
+    def unpause_schedule(self, schedule_rid: str) -> None:
+        """
+        Unpause a schedule.
+
+        Args:
+            schedule_rid: Schedule Resource Identifier
+        """
+        try:
+            self.service.Schedule.unpause(schedule_rid)
+        except Exception as e:
+            raise RuntimeError(f"Failed to unpause schedule {schedule_rid}: {e}")
+
+    def run_schedule(self, schedule_rid: str) -> None:
+        """
+        Execute a schedule immediately.
+
+        Args:
+            schedule_rid: Schedule Resource Identifier
+        """
+        try:
+            self.service.Schedule.run(schedule_rid)
+        except Exception as e:
+            raise RuntimeError(f"Failed to run schedule {schedule_rid}: {e}")
+
+    def replace_schedule(
+        self,
+        schedule_rid: str,
+        action: Dict[str, Any],
+        description: Optional[str] = None,
+        display_name: Optional[str] = None,
+        trigger: Optional[Dict[str, Any]] = None,
+        scope_mode: Optional[str] = None,
+        preview: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """
+        Replace an existing schedule.
+
+        Args:
+            schedule_rid: Schedule Resource Identifier
+            action: Schedule action configuration
+            description: Schedule description
+            display_name: Display name for the schedule
+            trigger: Trigger configuration
+            scope_mode: Scope mode for the schedule
+            preview: Enable preview mode
+
+        Returns:
+            Updated schedule information
+        """
+        try:
+            kwargs: Dict[str, Any] = {
+                "schedule_rid": schedule_rid,
+                "action": action,
+            }
+
+            if description is not None:
+                kwargs["description"] = description
+            if display_name is not None:
+                kwargs["display_name"] = display_name
+            if trigger is not None:
+                kwargs["trigger"] = trigger
+            if scope_mode is not None:
+                kwargs["scope_mode"] = scope_mode
+            if preview is not None:
+                kwargs["preview"] = preview
+
+            schedule = self.service.Schedule.replace(**kwargs)
+            return self._format_schedule_info(schedule)
+        except Exception as e:
+            raise RuntimeError(f"Failed to replace schedule {schedule_rid}: {e}")
+
+    # Formatting methods
+    def _format_build_info(self, build: Any) -> Dict[str, Any]:
+        """Format build information for consistent output."""
+        info = {}
+
+        # Extract available attributes
+        for attr in [
+            "rid",
+            "status",
+            "created_time",
+            "started_time",
+            "finished_time",
+            "created_by",
+            "branch_name",
+            "commit_hash",
+        ]:
+            if hasattr(build, attr):
+                info[attr] = getattr(build, attr)
+
+        return info
+
+    def _format_job_info(self, job: Any) -> Dict[str, Any]:
+        """Format job information for consistent output."""
+        info = {}
+
+        # Extract available attributes
+        for attr in [
+            "rid",
+            "status",
+            "created_time",
+            "started_time",
+            "finished_time",
+            "job_type",
+            "build_rid",
+        ]:
+            if hasattr(job, attr):
+                info[attr] = getattr(job, attr)
+
+        return info
+
+    def _format_schedule_info(self, schedule: Any) -> Dict[str, Any]:
+        """Format schedule information for consistent output."""
+        info = {}
+
+        # Extract available attributes
+        for attr in [
+            "rid",
+            "display_name",
+            "description",
+            "paused",
+            "created_time",
+            "created_by",
+            "modified_time",
+            "modified_by",
+        ]:
+            if hasattr(schedule, attr):
+                info[attr] = getattr(schedule, attr)
+
+        # Handle nested objects
+        if hasattr(schedule, "trigger"):
+            info["trigger"] = str(schedule.trigger)
+        if hasattr(schedule, "action"):
+            info["action"] = str(schedule.action)
+
+        return info
+
+    def _format_jobs_response(self, response: Any) -> Dict[str, Any]:
+        """Format jobs list response."""
+        result: Dict[str, Any] = {"jobs": []}
+
+        if hasattr(response, "data"):
+            result["jobs"] = [self._format_job_info(job) for job in response.data]
+
+        if hasattr(response, "next_page_token"):
+            result["next_page_token"] = response.next_page_token
+
+        return result
+
+    def _format_builds_search_response(self, response: Any) -> Dict[str, Any]:
+        """Format builds search response."""
+        result: Dict[str, Any] = {"builds": []}
+
+        if hasattr(response, "data"):
+            result["builds"] = [
+                self._format_build_info(build) for build in response.data
+            ]
+
+        if hasattr(response, "next_page_token"):
+            result["next_page_token"] = response.next_page_token
+
+        return result
+
+    def _format_jobs_batch_response(self, response: Any) -> Dict[str, Any]:
+        """Format jobs batch response."""
+        result: Dict[str, Any] = {"jobs": []}
+
+        if hasattr(response, "data"):
+            for item in response.data:
+                if hasattr(item, "data"):
+                    result["jobs"].append(self._format_job_info(item.data))
+
+        return result

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)