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

pltr/services/models.py

@@ -0,0 +1,179 @@
+"""
+Models service wrapper for Foundry SDK.
+Provides access to ML model registry operations (model lifecycle, versioning, metadata).
+
+Note: This is distinct from LanguageModels, which handles LLM chat/embeddings operations.
+"""
+
+from typing import Any, Dict, Optional
+from .base import BaseService
+
+
+class ModelsService(BaseService):
+    """Service wrapper for Foundry Models operations."""
+
+    def _get_service(self) -> Any:
+        """Get the Foundry Models service."""
+        return self.client.models
+
+    # ===== Model Operations =====
+
+    def create_model(
+        self,
+        name: str,
+        parent_folder_rid: str,
+        preview: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Create a new ML model in the registry.
+
+        Args:
+            name: Model name
+            parent_folder_rid: Parent folder RID (e.g., ri.compass.main.folder.xxx)
+            preview: Enable preview mode (default: False)
+
+        Returns:
+            Model information dictionary containing:
+            - rid: Model resource identifier
+            - name: Model name
+            - parentFolderRid: Parent folder RID
+
+        Raises:
+            RuntimeError: If the operation fails
+
+        Example:
+            >>> service = ModelsService()
+            >>> model = service.create_model(
+            ...     name="fraud-detector",
+            ...     parent_folder_rid="ri.compass.main.folder.xxx"
+            ... )
+        """
+        try:
+            model = self.service.Model.create(
+                name=name,
+                parent_folder_rid=parent_folder_rid,
+                preview=preview,
+            )
+            return self._serialize_response(model)
+        except Exception as e:
+            raise RuntimeError(f"Failed to create model '{name}': {e}")
+
+    def get_model(
+        self,
+        model_rid: str,
+        preview: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Get information about a model.
+
+        Args:
+            model_rid: Model RID (e.g., ri.foundry.main.model.xxx)
+            preview: Enable preview mode (default: False)
+
+        Returns:
+            Model information dictionary
+
+        Raises:
+            RuntimeError: If the operation fails
+
+        Example:
+            >>> service = ModelsService()
+            >>> model = service.get_model(
+            ...     model_rid="ri.foundry.main.model.abc123"
+            ... )
+        """
+        try:
+            model = self.service.Model.get(
+                model_rid=model_rid,
+                preview=preview,
+            )
+            return self._serialize_response(model)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get model '{model_rid}': {e}")
+
+    # ===== ModelVersion Operations =====
+
+    def get_model_version(
+        self,
+        model_rid: str,
+        model_version_rid: str,
+        preview: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Get information about a specific model version.
+
+        Args:
+            model_rid: Model RID (e.g., ri.foundry.main.model.xxx)
+            model_version_rid: Version identifier (e.g., v1.0.0 or version RID)
+            preview: Enable preview mode (default: False)
+
+        Returns:
+            Model version information dictionary
+
+        Raises:
+            RuntimeError: If the operation fails
+
+        Example:
+            >>> service = ModelsService()
+            >>> version = service.get_model_version(
+            ...     model_rid="ri.foundry.main.model.abc123",
+            ...     model_version_rid="v1.0.0"
+            ... )
+        """
+        try:
+            version = self.service.ModelVersion.get(
+                model_rid=model_rid,
+                model_version_rid=model_version_rid,
+                preview=preview,
+            )
+            return self._serialize_response(version)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to get model version '{model_version_rid}' for model '{model_rid}': {e}"
+            )
+
+    def list_model_versions(
+        self,
+        model_rid: str,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+        preview: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        List all versions of a model with pagination support.
+
+        Args:
+            model_rid: Model RID (e.g., ri.foundry.main.model.xxx)
+            page_size: Maximum number of versions to return per page
+            page_token: Token for fetching next page of results
+            preview: Enable preview mode (default: False)
+
+        Returns:
+            Dictionary containing:
+            - data: List of model version information dictionaries
+            - nextPageToken: Token for next page (if available)
+
+        Raises:
+            RuntimeError: If the operation fails
+
+        Example:
+            >>> service = ModelsService()
+            >>> result = service.list_model_versions(
+            ...     model_rid="ri.foundry.main.model.abc123",
+            ...     page_size=50
+            ... )
+            >>> versions = result['data']
+            >>> next_token = result.get('nextPageToken')
+        """
+        try:
+            response = self.service.ModelVersion.list(
+                model_rid=model_rid,
+                page_size=page_size,
+                page_token=page_token,
+                preview=preview,
+            )
+            return self._serialize_response(response)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to list model versions for model '{model_rid}': {e}"
+            )

pltr/services/ontology.py

@@ -2,7 +2,10 @@
 Ontology service wrappers for Foundry SDK.
 """
 
-from typing import Any, Optional, Dict, List
+from typing import Any, Callable, Dict, List, Optional
+
+from ..config.settings import Settings
+from ..utils.pagination import PaginationConfig, PaginationResult
 from .base import BaseService
 
 
@@ -165,6 +168,8 @@ class OntologyObjectService(BaseService):
         """
         List objects of a specific type.
 
+        DEPRECATED: Use list_objects_paginated() instead for better pagination support.
+
         Args:
             ontology_rid: Ontology Resource Identifier
             object_type: Object type API name
@@ -188,6 +193,48 @@ class OntologyObjectService(BaseService):
         except Exception as e:
             raise RuntimeError(f"Failed to list objects: {e}")
 
+    def list_objects_paginated(
+        self,
+        ontology_rid: str,
+        object_type: str,
+        config: PaginationConfig,
+        properties: Optional[List[str]] = None,
+        progress_callback: Optional[Callable[[int, int], None]] = None,
+    ) -> PaginationResult:
+        """
+        List objects with full pagination control.
+
+        Args:
+            ontology_rid: Ontology Resource Identifier
+            object_type: Object type API name
+            config: Pagination configuration
+            properties: List of properties to include
+            progress_callback: Optional progress callback
+
+        Returns:
+            PaginationResult with objects and metadata
+        """
+        try:
+            settings = Settings()
+
+            # Get iterator from SDK - ResourceIterator with next_page_token support
+            iterator = self.service.OntologyObject.list(
+                ontology_rid,
+                object_type,
+                page_size=config.page_size or settings.get("page_size", 20),
+                properties=properties,
+            )
+
+            # Use iterator pagination handler
+            result = self._paginate_iterator(iterator, config, progress_callback)
+
+            # Format objects
+            result.data = [self._format_object(obj) for obj in result.data]
+
+            return result
+        except Exception as e:
+            raise RuntimeError(f"Failed to list objects: {e}")
+
     def get_object(
         self,
         ontology_rid: str,

pltr/services/orchestration.py

@@ -3,8 +3,10 @@ Orchestration service wrapper for Foundry SDK v2 API.
 Provides operations for managing builds, jobs, and schedules.
 """
 
-from typing import Any, Optional, Dict, List
+from typing import Any, Callable, Dict, List, Optional
 
+from ..config.settings import Settings
+from ..utils.pagination import PaginationConfig, PaginationResult
 from .base import BaseService
 
 
@@ -134,6 +136,8 @@ class OrchestrationService(BaseService):
         """
         Search for builds.
 
+        DEPRECATED: Use search_builds_paginated() instead for better pagination support.
+
         Args:
             page_size: Number of results per page
             page_token: Token for pagination
@@ -155,6 +159,63 @@ class OrchestrationService(BaseService):
         except Exception as e:
             raise RuntimeError(f"Failed to search builds: {e}")
 
+    def search_builds_paginated(
+        self,
+        config: PaginationConfig,
+        progress_callback: Optional[Callable[[int, int], None]] = None,
+        **search_params,
+    ) -> PaginationResult:
+        """
+        Search for builds with full pagination control.
+
+        Args:
+            config: Pagination configuration
+            progress_callback: Optional progress callback
+            **search_params: Additional search parameters
+
+        Returns:
+            PaginationResult with builds and metadata
+        """
+        try:
+            settings = Settings()
+
+            def fetch_page(page_token: Optional[str]) -> Dict[str, Any]:
+                """Fetch a single page of builds."""
+                kwargs: Dict[str, Any] = {
+                    "page_size": config.page_size or settings.get("page_size", 20),
+                }
+                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)
+
+            return self._paginate_response(fetch_page, config, progress_callback)
+        except Exception as e:
+            raise RuntimeError(f"Failed to search builds: {e}")
+
+    def get_builds_batch(self, build_rids: List[str]) -> Dict[str, Any]:
+        """
+        Get multiple builds in batch.
+
+        Args:
+            build_rids: List of Build Resource Identifiers (max 100)
+
+        Returns:
+            Batch response with build information
+        """
+        if len(build_rids) > 100:
+            raise ValueError("Maximum batch size is 100 builds")
+
+        try:
+            # SDK expects list of {"rid": ...} objects for batch operations
+            body = [{"rid": rid} for rid in build_rids]
+            response = self.service.Build.get_batch(body)
+            return self._format_builds_batch_response(response)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get builds batch: {e}")
+
     # Job operations
     def get_job(self, job_rid: str) -> Dict[str, Any]:
         """
@@ -353,6 +414,35 @@ class OrchestrationService(BaseService):
         except Exception as e:
             raise RuntimeError(f"Failed to replace schedule {schedule_rid}: {e}")
 
+    def get_schedule_runs(
+        self,
+        schedule_rid: str,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get recent execution runs for a schedule.
+
+        Args:
+            schedule_rid: Schedule Resource Identifier
+            page_size: Number of results per page
+            page_token: Token for pagination
+
+        Returns:
+            Runs list with pagination info
+        """
+        try:
+            kwargs: Dict[str, Any] = {"schedule_rid": schedule_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.Schedule.runs(**kwargs)
+            return self._format_schedule_runs_response(response)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get runs for schedule {schedule_rid}: {e}")
+
     # Formatting methods
     def _format_build_info(self, build: Any) -> Dict[str, Any]:
         """Format build information for consistent output."""
@@ -455,3 +545,45 @@ class OrchestrationService(BaseService):
                     result["jobs"].append(self._format_job_info(item.data))
 
         return result
+
+    def _format_builds_batch_response(self, response: Any) -> Dict[str, Any]:
+        """Format builds batch response."""
+        result: Dict[str, Any] = {"builds": []}
+
+        if hasattr(response, "data"):
+            for item in response.data:
+                if hasattr(item, "data"):
+                    result["builds"].append(self._format_build_info(item.data))
+
+        return result
+
+    def _format_run_info(self, run: Any) -> Dict[str, Any]:
+        """Format schedule run information for consistent output."""
+        info = {}
+
+        for attr in [
+            "rid",
+            "schedule_rid",
+            "status",
+            "created_time",
+            "started_time",
+            "finished_time",
+            "build_rid",
+            "result",
+        ]:
+            if hasattr(run, attr):
+                info[attr] = getattr(run, attr)
+
+        return info
+
+    def _format_schedule_runs_response(self, response: Any) -> Dict[str, Any]:
+        """Format schedule runs response."""
+        result: Dict[str, Any] = {"runs": []}
+
+        if hasattr(response, "data"):
+            result["runs"] = [self._format_run_info(run) for run in response.data]
+
+        if hasattr(response, "next_page_token"):
+            result["next_page_token"] = response.next_page_token
+
+        return result