pyromind-sdk 0.0.12__py3-none-any.whl

pyromind_sdk/__init__.py

@@ -0,0 +1,65 @@
+"""
+PyroMind Node SDK
+
+A lightweight SDK stub for local development and testing of third-party nodes 
+without the full platform codebase (without `app.models.nodes`).
+
+In the real platform runtime environment, nodes should prioritize importing 
+base classes from `app.models.nodes`.
+"""
+
+__version__ = "0.1.0"
+
+# Export YAML nodes functionality
+from .nodes import (
+    load_nodes_from_yaml,
+    load_all_nodes_from_directory,
+    create_node_class_from_yaml,
+    convert_node_class_to_yaml,
+    yaml_to_node_class,
+)
+
+# Export API client functionality
+from .client import (
+    PyroMindClient,
+    PyroMindAPIError,
+    SandboxesClient,
+    InstanceClient,
+    InferenceClient,
+    TrainingClient,
+    StorageClient,
+    PyroMindAPIClient,
+)
+
+# Export workflow functionality
+from .client.workflow import (
+    WorkflowLiteConverter,
+    LayoutGenerator,
+    to_workflow_lite,
+    to_workflow_standard,
+)
+
+__all__ = [
+    "__version__",
+    # YAML nodes functionality
+    "load_nodes_from_yaml",
+    "load_all_nodes_from_directory",
+    "create_node_class_from_yaml",
+    "convert_node_class_to_yaml",
+    "yaml_to_node_class",
+    # API client functionality
+    "PyroMindClient",
+    "PyroMindAPIError",
+    "SandboxesClient",
+    "InstanceClient",
+    "InferenceClient",
+    "TrainingClient",
+    "StorageClient",
+    "PyroMindAPIClient",
+    # Workflow functionality
+    "WorkflowLiteConverter",
+    "LayoutGenerator",
+    "to_workflow_lite",
+    "to_workflow_standard",
+]
+

pyromind_sdk/client/__init__.py

@@ -0,0 +1,30 @@
+"""
+PyroMind API Client SDK
+
+This module provides a Python client SDK for interacting with the PyroMind API v1.
+"""
+
+from .base import PyroMindClient, PyroMindAPIError
+from .sandboxes import SandboxesClient
+from .instance import InstanceClient
+from .inference import InferenceClient
+from .training import TrainingClient
+from .storage import StorageClient
+from .client import PyroMindAPIClient
+from .workflow import (
+    validate_workflow,
+    ValidationError
+)
+
+__all__ = [
+    "PyroMindClient",
+    "PyroMindAPIError",
+    "SandboxesClient",
+    "InstanceClient",
+    "InferenceClient",
+    "TrainingClient",
+    "StorageClient",
+    "PyroMindAPIClient",
+    "validate_workflow",
+    "ValidationError",
+]

pyromind_sdk/client/base.py

@@ -0,0 +1,270 @@
+"""
+Base client class for PyroMind API
+
+This module provides the base client class that handles authentication,
+HTTP requests, and error handling for all API clients.
+"""
+
+import os
+import requests
+from typing import Optional, Dict, Any, Union
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+
+# Constants
+DEFAULT_API_BASE_URL = "https://api.pyromind.ai/api/v1"
+DEFAULT_TIMEOUT = 30
+DEFAULT_MAX_RETRIES = 3
+ENV_API_KEY = "PYROMIND_API_KEY"
+ENV_BASE_URL = "PYROMIND_BASE_URL"
+RETRY_STATUS_CODES = [429, 500, 502, 503, 504]
+RETRY_ALLOWED_METHODS = ["GET", "POST", "PUT", "DELETE"]
+
+
+class PyroMindAPIError(Exception):
+    """Base exception for PyroMind API errors"""
+    def __init__(self, message: str, status_code: Optional[int] = None, response: Optional[Dict] = None):
+        self.message = message
+        self.status_code = status_code
+        self.response = response
+        super().__init__(self.message)
+
+
+class PyroMindClient:
+    """
+    Base client class for PyroMind API
+
+    Handles authentication, HTTP requests, and error handling.
+    All resource-specific clients inherit from this class.
+
+    Args:
+        api_key: Bearer token for API authentication. If not provided, will try to
+                read from PYROMIND_API_KEY environment variable. If neither is
+                provided, will raise ValueError.
+        base_url: Base URL for the API. If not provided, will try to read from
+                 PYROMIND_BASE_URL environment variable. If neither is provided,
+                 defaults to https://api.pyromind.ai/api/v1
+        timeout: Request timeout in seconds (default: 30)
+        max_retries: Maximum number of retries for failed requests (default: 3)
+
+    Raises:
+        ValueError: If api_key is not provided and PYROMIND_API_KEY environment
+                   variable is not set.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+        max_retries: int = DEFAULT_MAX_RETRIES
+    ):
+        # Get API key from parameter or environment variable
+        if api_key is None:
+            api_key = os.getenv(ENV_API_KEY)
+
+        if not api_key:
+            raise ValueError(
+                f"API key is required. Please provide it either as a parameter "
+                f"or set the {ENV_API_KEY} environment variable."
+            )
+
+        # Strip whitespace from API key
+        api_key = api_key.strip()
+
+        # Get base URL from parameter, environment variable, or use default
+        if base_url is None:
+            base_url = os.getenv(ENV_BASE_URL, DEFAULT_API_BASE_URL)
+
+        if not base_url:
+            raise ValueError(
+                f"Base URL is required. Please provide it either as a parameter "
+                f"or set the {ENV_BASE_URL} environment variable."
+            )
+        self.api_key = api_key
+        self.base_url = base_url.rstrip('/')
+        self.timeout = timeout
+
+        # Create session with retry strategy
+        self.session = requests.Session()
+        retry_strategy = Retry(
+            total=max_retries,
+            backoff_factor=1,
+            status_forcelist=RETRY_STATUS_CODES,
+            allowed_methods=RETRY_ALLOWED_METHODS
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+        
+        # Set default headers
+        self.session.headers.update({
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        })
+    
+    def _extract_data(self, response: Dict[str, Any]) -> Any:
+        """
+        Extract data from API response
+        
+        API responses are wrapped in {success: True, data: {...}} format.
+        This method extracts the actual data from the response.
+        
+        Args:
+            response: API response dictionary
+            
+        Returns:
+            Extracted data from response
+        """
+        if isinstance(response, dict):
+            if "data" in response:
+                return response["data"]
+            # If response doesn't have 'data' field, return the whole response
+            # (for backward compatibility)
+            return response
+        return response
+    
+    def _request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Make an HTTP request to the API
+        
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE)
+            endpoint: API endpoint (relative to base_url)
+            params: Query parameters
+            json_data: JSON request body
+            **kwargs: Additional arguments to pass to requests
+            
+        Returns:
+            Response JSON data as dictionary
+            
+        Raises:
+            PyroMindAPIError: If the request fails
+        """
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+        
+        try:
+            response = self.session.request(
+                method=method,
+                url=url,
+                params=params,
+                json=json_data,
+                timeout=self.timeout,
+                **kwargs
+            )
+            
+            # Handle non-2xx responses
+            if not response.ok:
+                error_data = None
+                try:
+                    error_data = response.json()
+                except:
+                    error_data = {"message": response.text}
+                
+                # Provide more detailed error messages for specific status codes
+                if response.status_code == 400:
+                    error_message = (
+                        "Bad Request (400). The request was invalid or malformed. "
+                        "This usually means there's an issue with the request parameters, "
+                        "request body format, or missing required fields."
+                    ) + f"\nResponse: {response.text}"
+                elif response.status_code == 401:
+                    error_message = (
+                        "Authentication failed (401). Please check your API key. "
+                        "The API key may be invalid, expired, or incorrectly formatted."
+                    )
+                    if error_data.get("message"):
+                        error_message += f" Server message: {error_data.get('message')}"
+                elif response.status_code == 404:
+                    error_message = "Resource not found (404). The requested resource does not exist."
+                    # Try to extract detailed error information from the response
+                    if isinstance(error_data, dict):
+                        # Check for nested error structure (APIResponse format)
+                        if "error" in error_data:
+                            error_obj = error_data.get("error", {})
+                            if isinstance(error_obj, dict):
+                                error_code = error_obj.get("code", "")
+                                error_msg = error_obj.get("message", "")
+                                if error_code:
+                                    error_message = f"{error_code}: {error_msg}"
+                                elif error_msg:
+                                    error_message = error_msg
+                        elif "detail" in error_data:
+                            detail = error_data.get("detail")
+                            if isinstance(detail, dict) and "error" in detail:
+                                error_obj = detail.get("error", {})
+                                if isinstance(error_obj, dict):
+                                    error_code = error_obj.get("code", "")
+                                    error_msg = error_obj.get("message", "")
+                                    if error_code:
+                                        error_message = f"{error_code}: {error_msg}"
+                                    elif error_msg:
+                                        error_message = error_msg
+                            elif isinstance(detail, str):
+                                error_message = detail
+                        elif error_data.get("message"):
+                            error_message += f" Details: {error_data.get('message')}"
+                elif response.status_code == 422:
+                    error_message = "Unprocessable Entity (422). The request was well-formed but contains semantic errors."
+                    if error_data.get("message"):
+                        error_message += f" Details: {error_data.get('message')}"
+                    if error_data.get("detail"):
+                        error_message += f"\nValidation details: {error_data.get('detail')}"
+                else:
+                    error_message = error_data.get("message", f"API request failed with status {response.status_code}")
+                    if error_data.get("detail"):
+                        error_message += f"\nDetails: {error_data.get('detail')}"
+                
+                raise PyroMindAPIError(
+                    message=error_message,
+                    status_code=response.status_code,
+                    response=error_data
+                )
+            
+            # Return JSON response
+            if response.content:
+                return response.json()
+            return {}
+
+        except requests.exceptions.RequestException as e:
+            raise PyroMindAPIError(
+                message=f"Request failed: {str(e)}",
+                status_code=None
+            )
+    
+    def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None, **kwargs) -> Dict[str, Any]:
+        """Make a GET request"""
+        return self._request("GET", endpoint, params=params, **kwargs)
+    
+    def post(self, endpoint: str, json_data: Optional[Dict[str, Any]] = None, **kwargs) -> Dict[str, Any]:
+        """Make a POST request"""
+        return self._request("POST", endpoint, json_data=json_data, **kwargs)
+    
+    def put(self, endpoint: str, json_data: Optional[Dict[str, Any]] = None, **kwargs) -> Dict[str, Any]:
+        """Make a PUT request"""
+        return self._request("PUT", endpoint, json_data=json_data, **kwargs)
+    
+    def delete(self, endpoint: str, **kwargs) -> Dict[str, Any]:
+        """Make a DELETE request"""
+        return self._request("DELETE", endpoint, **kwargs)
+    
+    def close(self):
+        """Close the session"""
+        self.session.close()
+    
+    def __enter__(self):
+        """Context manager entry"""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.close()

pyromind_sdk/client/client.py

@@ -0,0 +1,138 @@
+"""
+Main PyroMind API Client
+
+This module provides the main client class that integrates all resource clients.
+"""
+
+import os
+from typing import Optional
+from .base import PyroMindClient
+from .sandboxes import SandboxesClient
+from .instance import InstanceClient
+from .inference import InferenceClient
+from .training import TrainingClient
+
+
+class PyroMindAPIClient:
+    """
+    Main PyroMind API Client
+    
+    This class provides a unified interface to all PyroMind API resources.
+    It integrates all resource-specific clients (Sandboxes, Instance, Inference, Training).
+    
+    Args:
+        api_key: Bearer token for API authentication. If not provided, will try to
+                read from PYROMIND_API_KEY environment variable. If neither is
+                provided, will raise ValueError.
+        base_url: Base URL for the API. If not provided, will try to read from
+                 PYROMIND_BASE_URL environment variable. If neither is provided,
+                 defaults to https://api.pyromind.ai/api/v1
+        timeout: Request timeout in seconds (default: 30)
+        max_retries: Maximum number of retries for failed requests (default: 3)
+    
+    Raises:
+        ValueError: If api_key is not provided and PYROMIND_API_KEY environment
+                   variable is not set.
+    
+    Example:
+        ```python
+        from pyromind_sdk import PyroMindAPIClient
+        
+        client = PyroMindAPIClient(api_key="your-api-key")
+        
+        # List all sandboxes
+        sandboxes = client.sandboxes.list()
+        
+        # Create a Jupyter instance
+        from pyromind_sdk.client.models import JupyterRequest, ResourceConfig
+        jupyter = client.instance.create(
+            JupyterRequest(
+                name="my-jupyter",
+                image="jupyter/scipy-notebook:latest",
+                resources=ResourceConfig(cpu="2", memory="4Gi")
+            )
+        )
+        ```
+    """
+    
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+        max_retries: int = 3
+    ):
+        """
+        Initialize the PyroMind API Client
+        
+        Args:
+            api_key: Bearer token for API authentication. If not provided, will try to
+                    read from PYROMIND_API_KEY environment variable.
+            base_url: Base URL for the API. If not provided, will try to read from
+                     PYROMIND_BASE_URL environment variable. If neither is provided,
+                     defaults to https://api.pyromind.ai/api/v1
+            timeout: Request timeout in seconds
+            max_retries: Maximum number of retries for failed requests
+        """
+        # Get API key from parameter or environment variable
+        if api_key is None:
+            api_key = os.getenv("PYROMIND_API_KEY")
+        
+        if not api_key:
+            raise ValueError(
+                "API key is required. Please provide it either as a parameter "
+                "or set the PYROMIND_API_KEY environment variable."
+            )
+        
+        # Get base URL from parameter, environment variable, or use default
+        if base_url is None:
+            base_url = os.getenv("PYROMIND_BASE_URL", "https://api.pre2-pyromind.ai/api/v1")
+        
+        self._base_client = PyroMindClient(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries
+        )
+        
+        # Initialize resource clients
+        self.sandboxes = SandboxesClient(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries
+        )
+        self.instance = InstanceClient(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries
+        )
+        self.inference = InferenceClient(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries
+        )
+        self.training = TrainingClient(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries
+        )
+    
+    def close(self):
+        """Close all client sessions"""
+        self._base_client.close()
+        self.sandboxes.close()
+        self.instance.close()
+        self.inference.close()
+        self.training.close()
+    
+    def __enter__(self):
+        """Context manager entry"""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.close()

pyromind_sdk/client/inference.py

@@ -0,0 +1,135 @@
+"""
+Inference API Client
+
+This module provides a client for managing inference jobs via the PyroMind API.
+"""
+
+from typing import List
+from .base import PyroMindClient
+from .models import (
+    InferenceJobRequest,
+    InferenceJobResponse,
+)
+
+
+class InferenceClient(PyroMindClient):
+    """
+    Client for managing inference jobs
+    
+    Provides methods for creating, listing, getting, and deleting inference jobs.
+    """
+    
+    def list(self) -> List[InferenceJobResponse]:
+        """
+        List all inference jobs
+        
+        Returns:
+            List of InferenceJobResponse objects
+        """
+        response = self.get("/inference")
+        # API returns {success: True, data: {...}} format
+        data = self._extract_data(response)
+        
+        # Handle different possible data structures
+        if isinstance(data, dict) and "inference_jobs" in data:
+            jobs_data = data["inference_jobs"]
+        elif isinstance(data, dict) and "pagination" in data:
+            # Response format: {inference_jobs: [...], pagination: {...}}
+            jobs_data = data.get("inference_jobs", [])
+        elif isinstance(data, list):
+            jobs_data = data
+        else:
+            jobs_data = []
+        
+        # Convert each job data to InferenceJobResponse
+        return [InferenceJobResponse(**job) if isinstance(job, dict) else job for job in jobs_data]
+    
+    def create(self, request: InferenceJobRequest) -> str:
+        """
+        Create a new inference job
+        
+        Args:
+            request: InferenceJobCreateRequest with job configuration
+            
+        Returns:
+            Job ID string
+        """
+        response = self.post("/inference", json_data=request.model_dump())
+        # API returns {success: True, data: {...}} format
+        data = self._extract_data(response)
+        
+        # Backend returns either {job_id: "..."} or full job object
+        if isinstance(data, dict) and "job_id" in data:
+            return data["job_id"]
+        elif isinstance(data, dict) and "id" in data:
+            return data["id"]
+        else:
+            # Try to parse as InferenceJobResponse and extract ID
+            job_response = InferenceJobResponse(**data)
+            return job_response.id
+    
+    def get_job(self, job_id: str) -> InferenceJobResponse:
+        """
+        Get a specific inference job by ID
+        
+        Args:
+            job_id: ID of the inference job to retrieve
+            
+        Returns:
+            InferenceJobResponse object
+        """
+        response = self.get(f"/inference/{job_id}")
+        # API returns {success: True, data: {...}} format
+        data = self._extract_data(response)
+        
+        # Backend returns the job data directly in the data field
+        return InferenceJobResponse(**data)
+    
+    def update(self, job_id: str, request) -> InferenceJobResponse:
+        """
+        Update an inference job
+        
+        Args:
+            job_id: ID of the inference job to update
+            request: InferenceJobRequest with updated configuration
+            
+        Returns:
+            InferenceJobResponse object
+        """
+        # Import here to avoid circular dependency
+        from .models import InferenceJobRequest
+        if not isinstance(request, InferenceJobRequest):
+            request = InferenceJobRequest(**request)
+        
+        request_dict = request.model_dump(exclude_none=True)
+        
+        response = self.put(f"/inference/{job_id}", json_data=request_dict)
+        # API returns {success: True, data: {...}} format
+        data = self._extract_data(response)
+        
+        return InferenceJobResponse(**data)
+    
+    def delete(self, job_id: str) -> None:
+        """
+        Delete an inference job
+        
+        Args:
+            job_id: ID of the inference job to delete
+        """
+        self._request("DELETE", f"/inference/{job_id}")
+    
+    def pause(self, job_id: str) -> InferenceJobResponse:
+        """
+        Pause an inference job
+        
+        Args:
+            job_id: ID of the inference job to pause
+            
+        Returns:
+            InferenceJobResponse object
+        """
+        response = self.post(f"/inference/{job_id}/pause")
+        # API returns {success: True, data: {...}} format
+        data = self._extract_data(response)
+        
+        return InferenceJobResponse(**data)