simplex 2.0.0__py3-none-any.whl

simplex/__init__.py

@@ -0,0 +1,50 @@
+"""
+Simplex Python SDK
+
+Official Python SDK for the Simplex API - A workflow automation platform.
+
+Example usage:
+    >>> from simplex import SimplexClient
+    >>> client = SimplexClient(api_key="your-api-key")
+    >>> result = client.run_workflow("workflow-id", variables={"key": "value"})
+    >>>
+    >>> # Poll for completion
+    >>> import time
+    >>> while True:
+    ...     status = client.get_session_status(result["session_id"])
+    ...     if not status["in_progress"]:
+    ...         break
+    ...     time.sleep(1)
+    >>>
+    >>> if status["success"]:
+    ...     print("Outputs:", status["scraper_outputs"])
+"""
+
+from simplex.client import SimplexClient
+from simplex.errors import (
+    AuthenticationError,
+    NetworkError,
+    RateLimitError,
+    SimplexError,
+    ValidationError,
+    WorkflowError,
+)
+from simplex.types import (
+    FileMetadata,
+    RunWorkflowResponse,
+    SessionStatusResponse,
+)
+
+__version__ = "2.0.0"
+__all__ = [
+    "SimplexClient",
+    "SimplexError",
+    "NetworkError",
+    "ValidationError",
+    "AuthenticationError",
+    "RateLimitError",
+    "WorkflowError",
+    "FileMetadata",
+    "SessionStatusResponse",
+    "RunWorkflowResponse",
+]

simplex/_http_client.py

@@ -0,0 +1,220 @@
+"""
+Internal HTTP client for the Simplex SDK.
+
+This module provides a robust HTTP client with automatic retry logic,
+error handling, and support for various request types.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+from urllib.parse import urlencode
+
+import requests
+
+from simplex.errors import (
+    AuthenticationError,
+    NetworkError,
+    RateLimitError,
+    SimplexError,
+    ValidationError,
+)
+
+__version__ = "2.0.0"
+
+
+class HttpClient:
+    """
+    Internal HTTP client with retry logic and error handling.
+
+    This client handles all communication with the Simplex API, including:
+    - Automatic retry with exponential backoff for 429, 5xx errors
+    - Error mapping to custom exceptions
+    - Support for form-encoded and JSON requests
+    - File downloads
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        timeout: int = 30,
+        max_retries: int = 3,
+        retry_delay: float = 1.0,
+    ):
+        """
+        Initialize the HTTP client.
+
+        Args:
+            base_url: Base URL for the API (e.g., 'https://api.simplex.sh')
+            api_key: Your Simplex API key
+            timeout: Request timeout in seconds (default: 30)
+            max_retries: Maximum number of retry attempts (default: 3)
+            retry_delay: Base delay between retries in seconds (default: 1.0)
+        """
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "X-API-Key": api_key,
+                "User-Agent": f"Simplex-Python-SDK/{__version__}",
+            }
+        )
+
+    def _should_retry(self, status_code: int | None) -> bool:
+        """Determine if a request should be retried based on status code."""
+        if status_code is None:
+            return True  # Network error
+        return status_code == 429 or status_code >= 500
+
+    def _handle_error(self, response: requests.Response) -> SimplexError:
+        """Convert HTTP errors to appropriate exception types."""
+        status_code = response.status_code
+
+        try:
+            data = response.json()
+            if isinstance(data, dict):
+                message = data.get("message") or data.get("error") or "An error occurred"
+            else:
+                message = str(data)
+        except ValueError:
+            message = response.text or "An error occurred"
+
+        if status_code == 400:
+            return ValidationError(message, data=response.json() if response.text else None)
+        elif status_code in [401, 403]:
+            return AuthenticationError(message)
+        elif status_code == 429:
+            retry_after = response.headers.get("Retry-After")
+            retry_after_seconds = int(retry_after) if retry_after and retry_after.isdigit() else None
+            return RateLimitError(message, retry_after=retry_after_seconds)
+        else:
+            return SimplexError(message, status_code=status_code, data=response.json() if response.text else None)
+
+    def _make_request(
+        self,
+        method: str,
+        path: str,
+        data: Any = None,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> requests.Response:
+        """
+        Make an HTTP request with retry logic.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            path: API endpoint path
+            data: Request body data
+            params: Query parameters
+            headers: Additional headers for this request
+            **kwargs: Additional arguments to pass to requests
+
+        Returns:
+            Response object
+
+        Raises:
+            SimplexError: If the request fails after all retries
+        """
+        url = f"{self.base_url}{path}"
+        attempt = 0
+        last_exception: SimplexError | None = None
+
+        while attempt <= self.max_retries:
+            try:
+                response = self.session.request(
+                    method=method,
+                    url=url,
+                    data=data,
+                    params=params,
+                    headers=headers,
+                    timeout=self.timeout,
+                    **kwargs,
+                )
+
+                if not response.ok:
+                    error = self._handle_error(response)
+
+                    if self._should_retry(response.status_code) and attempt < self.max_retries:
+                        attempt += 1
+                        time.sleep(self.retry_delay * attempt)
+                        continue
+
+                    raise error
+
+                return response
+
+            except requests.exceptions.RequestException as e:
+                last_exception = NetworkError(str(e))
+
+                if attempt < self.max_retries:
+                    attempt += 1
+                    time.sleep(self.retry_delay * attempt)
+                    continue
+
+                raise last_exception
+
+        if last_exception:
+            raise last_exception
+        raise NetworkError("Request failed after all retries")
+
+    def get(self, path: str, params: dict[str, Any] | None = None) -> Any:
+        """Make a GET request and return JSON response."""
+        response = self._make_request("GET", path, params=params)
+        return response.json()
+
+    def post(
+        self,
+        path: str,
+        data: dict[str, Any] | None = None,
+    ) -> Any:
+        """
+        Make a POST request with form-encoded data.
+
+        Args:
+            path: API endpoint path
+            data: Form data to send
+
+        Returns:
+            Parsed JSON response
+        """
+        import json as json_module
+
+        form_data = {}
+        if data:
+            for key, value in data.items():
+                if value is not None:
+                    if isinstance(value, (dict, list)):
+                        form_data[key] = json_module.dumps(value)
+                    else:
+                        form_data[key] = str(value)
+
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        response = self._make_request(
+            "POST",
+            path,
+            data=urlencode(form_data) if form_data else None,
+            headers=headers,
+        )
+        return response.json()
+
+    def download_file(self, path: str, params: dict[str, Any] | None = None) -> bytes:
+        """
+        Download a file from the API.
+
+        Args:
+            path: API endpoint path
+            params: Query parameters
+
+        Returns:
+            File content as bytes
+        """
+        response = self._make_request("GET", path, params=params)
+        return response.content

simplex/client.py

@@ -0,0 +1,289 @@
+"""
+Main SimplexClient class for the Simplex SDK.
+
+This module provides the SimplexClient, which is the primary entry point
+for interacting with the Simplex API.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from simplex._http_client import HttpClient
+from simplex.errors import WorkflowError
+from simplex.types import RunWorkflowResponse, SessionStatusResponse
+
+
+class SimplexClient:
+    """
+    Main client for interacting with the Simplex API.
+
+    This is the primary entry point for the SDK. It provides a flat API
+    for all Simplex API functionality.
+
+    Example:
+        >>> from simplex import SimplexClient
+        >>> client = SimplexClient(api_key="your-api-key")
+        >>>
+        >>> # Run a workflow
+        >>> result = client.run_workflow("workflow-id", variables={"key": "value"})
+        >>>
+        >>> # Poll for completion
+        >>> import time
+        >>> while True:
+        ...     status = client.get_session_status(result["session_id"])
+        ...     if not status["in_progress"]:
+        ...         break
+        ...     time.sleep(1)
+        >>>
+        >>> if status["success"]:
+        ...     print("Scraper outputs:", status["scraper_outputs"])
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://api.simplex.sh",
+        timeout: int = 30,
+        max_retries: int = 3,
+        retry_delay: float = 1.0,
+    ):
+        """
+        Initialize the Simplex client.
+
+        Args:
+            api_key: Your Simplex API key (required)
+            base_url: Base URL for the API (default: "https://api.simplex.sh")
+            timeout: Request timeout in seconds (default: 30)
+            max_retries: Maximum number of retry attempts (default: 3)
+            retry_delay: Delay between retries in seconds (default: 1.0)
+
+        Raises:
+            ValueError: If api_key is not provided
+        """
+        if not api_key:
+            raise ValueError("api_key is required")
+
+        self._http_client = HttpClient(
+            base_url=base_url,
+            api_key=api_key,
+            timeout=timeout,
+            max_retries=max_retries,
+            retry_delay=retry_delay,
+        )
+
+    def run_workflow(
+        self,
+        workflow_id: str,
+        variables: dict[str, Any] | None = None,
+        metadata: str | None = None,
+        webhook_url: str | None = None,
+    ) -> RunWorkflowResponse:
+        """
+        Run a workflow by its ID.
+
+        Args:
+            workflow_id: The ID of the workflow to run
+            variables: Dictionary of variables to pass to the workflow
+            metadata: Optional metadata string to attach to the workflow run
+            webhook_url: Optional webhook URL for status updates
+
+        Returns:
+            RunWorkflowResponse with session_id and other details
+
+        Raises:
+            WorkflowError: If the workflow fails to start
+
+        Example:
+            >>> result = client.run_workflow(
+            ...     "workflow-id",
+            ...     variables={"email": "user@example.com"}
+            ... )
+            >>> print(f"Session ID: {result['session_id']}")
+        """
+        request_data: dict[str, Any] = {"workflow_id": workflow_id}
+
+        if variables is not None:
+            request_data["variables"] = variables
+        if metadata is not None:
+            request_data["metadata"] = metadata
+        if webhook_url is not None:
+            request_data["webhook_url"] = webhook_url
+
+        try:
+            response: RunWorkflowResponse = self._http_client.post(
+                "/run_workflow",
+                data=request_data,
+            )
+            return response
+        except Exception as e:
+            if isinstance(e, WorkflowError):
+                raise
+            raise WorkflowError(f"Failed to run workflow: {e}", workflow_id=workflow_id)
+
+    def get_session_status(self, session_id: str) -> SessionStatusResponse:
+        """
+        Get the status of a session.
+
+        Use this method to poll for workflow completion. The session is complete
+        when `in_progress` is False.
+
+        Args:
+            session_id: The session ID to check
+
+        Returns:
+            SessionStatusResponse with status, metadata, and scraper outputs
+
+        Raises:
+            WorkflowError: If retrieving status fails
+
+        Example:
+            >>> status = client.get_session_status("session-123")
+            >>> if not status["in_progress"]:
+            ...     if status["success"]:
+            ...         print("Success! Outputs:", status["scraper_outputs"])
+            ...     else:
+            ...         print("Failed")
+        """
+        try:
+            response: SessionStatusResponse = self._http_client.get(
+                f"/get_session_status/{session_id}"
+            )
+            return response
+        except Exception as e:
+            if isinstance(e, WorkflowError):
+                raise
+            raise WorkflowError(
+                f"Failed to get session status: {e}",
+                session_id=session_id,
+            )
+
+    def download_session_files(
+        self,
+        session_id: str,
+        filename: str | None = None,
+    ) -> bytes:
+        """
+        Download files from a session.
+
+        Downloads files that were created or downloaded during a workflow session.
+        If no filename is specified, all files are downloaded as a zip archive.
+
+        Args:
+            session_id: ID of the session to download files from
+            filename: Optional specific filename to download
+
+        Returns:
+            File content as bytes
+
+        Raises:
+            WorkflowError: If file download fails
+
+        Example:
+            >>> # Download all files as zip
+            >>> zip_data = client.download_session_files("session-123")
+            >>> with open("files.zip", "wb") as f:
+            ...     f.write(zip_data)
+            >>>
+            >>> # Download specific file
+            >>> pdf_data = client.download_session_files("session-123", "report.pdf")
+        """
+        try:
+            params: dict[str, str] = {"session_id": session_id}
+            if filename:
+                params["filename"] = filename
+
+            content = self._http_client.download_file("/download_session_files", params=params)
+
+            # Check if the response is a JSON error
+            try:
+                text = content.decode("utf-8")
+                data = json.loads(text)
+                if isinstance(data, dict) and data.get("succeeded") is False:
+                    raise WorkflowError(
+                        data.get("error") or "Failed to download session files",
+                        session_id=session_id,
+                    )
+            except (UnicodeDecodeError, json.JSONDecodeError):
+                # Binary data (the file), which is what we want
+                pass
+
+            return content
+        except WorkflowError:
+            raise
+        except Exception as e:
+            raise WorkflowError(
+                f"Failed to download session files: {e}",
+                session_id=session_id,
+            )
+
+    def retrieve_session_replay(self, session_id: str) -> bytes:
+        """
+        Retrieve the session replay video for a completed session.
+
+        Downloads a video (MP4) recording of the browser session after it
+        has completed.
+
+        Args:
+            session_id: ID of the session to retrieve replay for
+
+        Returns:
+            Video content as bytes (MP4 format)
+
+        Raises:
+            WorkflowError: If retrieving session replay fails
+
+        Example:
+            >>> video_data = client.retrieve_session_replay("session-123")
+            >>> with open("replay.mp4", "wb") as f:
+            ...     f.write(video_data)
+        """
+        try:
+            content = self._http_client.download_file(f"/retrieve_session_replay/{session_id}")
+            return content
+        except Exception as e:
+            if isinstance(e, WorkflowError):
+                raise
+            raise WorkflowError(
+                f"Failed to retrieve session replay: {e}",
+                session_id=session_id,
+            )
+
+    def retrieve_session_logs(self, session_id: str) -> Any:
+        """
+        Retrieve the session logs for a completed session.
+
+        Downloads the detailed logs of all actions and events that occurred
+        during the workflow session execution.
+
+        Args:
+            session_id: ID of the session to retrieve logs for
+
+        Returns:
+            Parsed JSON logs containing session events and details
+
+        Raises:
+            WorkflowError: If retrieving session logs fails
+
+        Example:
+            >>> logs = client.retrieve_session_logs("session-123")
+            >>> for entry in logs:
+            ...     print(f"{entry['timestamp']}: {entry['message']}")
+        """
+        try:
+            content = self._http_client.download_file(f"/retrieve_session_logs/{session_id}")
+            text = content.decode("utf-8")
+            return json.loads(text)
+        except json.JSONDecodeError as e:
+            raise WorkflowError(
+                f"Failed to parse session logs: {e}",
+                session_id=session_id,
+            )
+        except Exception as e:
+            if isinstance(e, WorkflowError):
+                raise
+            raise WorkflowError(
+                f"Failed to retrieve session logs: {e}",
+                session_id=session_id,
+            )

simplex/errors.py

@@ -0,0 +1,119 @@
+"""
+Custom exception classes for the Simplex SDK.
+
+This module defines a hierarchy of exceptions that can be raised by the SDK,
+allowing for specific error handling based on the type of error encountered.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class SimplexError(Exception):
+    """
+    Base exception class for all Simplex SDK errors.
+
+    All custom exceptions in the SDK inherit from this class, making it easy
+    to catch any SDK-related error with a single except clause.
+
+    Attributes:
+        message: Human-readable error message
+        status_code: HTTP status code if applicable
+        data: Additional error data or context
+    """
+
+    def __init__(
+        self,
+        message: str,
+        status_code: int | None = None,
+        data: Any = None,
+    ):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.data = data
+
+    def __str__(self) -> str:
+        if self.status_code:
+            return f"[{self.status_code}] {self.message}"
+        return self.message
+
+
+class NetworkError(SimplexError):
+    """
+    Raised when a network-related error occurs.
+
+    This includes connection failures, timeouts, and other network issues
+    that prevent communication with the Simplex API.
+    """
+
+    def __init__(self, message: str):
+        super().__init__(f"Network error: {message}")
+
+
+class ValidationError(SimplexError):
+    """
+    Raised when request validation fails (HTTP 400).
+
+    This indicates that the request data was invalid or malformed,
+    such as missing required fields or invalid parameter values.
+    """
+
+    def __init__(self, message: str, data: Any = None):
+        super().__init__(message, status_code=400, data=data)
+
+
+class AuthenticationError(SimplexError):
+    """
+    Raised when authentication fails (HTTP 401 or 403).
+
+    This typically indicates an invalid API key or insufficient permissions
+    to access the requested resource.
+    """
+
+    def __init__(self, message: str):
+        super().__init__(message, status_code=401)
+
+
+class RateLimitError(SimplexError):
+    """
+    Raised when rate limit is exceeded (HTTP 429).
+
+    The Simplex API has rate limits to prevent abuse. When exceeded,
+    this error is raised with information about when to retry.
+
+    Attributes:
+        retry_after: Number of seconds to wait before retrying
+    """
+
+    def __init__(self, message: str, retry_after: int | None = None):
+        super().__init__(message, status_code=429)
+        self.retry_after = retry_after
+
+
+class WorkflowError(SimplexError):
+    """
+    Raised when a workflow operation fails.
+
+    This is a specialized error for workflow-related failures,
+    including session creation, workflow execution, and agent tasks.
+
+    Attributes:
+        workflow_id: The ID of the workflow that failed (if applicable)
+        session_id: The ID of the session that failed (if applicable)
+    """
+
+    def __init__(
+        self,
+        message: str,
+        workflow_id: str | None = None,
+        session_id: str | None = None,
+    ):
+        super().__init__(
+            message,
+            status_code=500,
+            data={"workflow_id": workflow_id, "session_id": session_id},
+        )
+        self.workflow_id = workflow_id
+        self.session_id = session_id

simplex/types.py

@@ -0,0 +1,64 @@
+"""
+Type definitions for the Simplex SDK.
+
+This module contains TypedDict classes used for type hinting throughout the SDK.
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypedDict
+
+
+class FileMetadata(TypedDict):
+    """
+    Metadata for a file downloaded or created during a session.
+
+    Attributes:
+        filename: The filename
+        download_url: The URL the file was downloaded from
+        file_size: File size in bytes
+        download_timestamp: ISO timestamp when the file was downloaded/created
+    """
+
+    filename: str
+    download_url: str
+    file_size: int
+    download_timestamp: str
+
+
+class SessionStatusResponse(TypedDict):
+    """
+    Response from polling session status.
+
+    Attributes:
+        in_progress: Whether the session is still running
+        success: Whether the session completed successfully (None while in progress)
+        metadata: Custom metadata provided when the session was started
+        workflow_metadata: Metadata from the workflow definition
+        file_metadata: Metadata for files downloaded during the session
+        scraper_outputs: Scraper outputs collected during the session
+    """
+
+    in_progress: bool
+    success: bool | None
+    metadata: dict[str, Any]
+    workflow_metadata: dict[str, Any]
+    file_metadata: list[FileMetadata]
+    scraper_outputs: list[Any]
+
+
+class RunWorkflowResponse(TypedDict):
+    """
+    Response from running a workflow.
+
+    Attributes:
+        succeeded: Whether the workflow started successfully
+        message: Human-readable status message
+        session_id: Unique identifier for this workflow session
+        vnc_url: URL for VNC access to the workflow session
+    """
+
+    succeeded: bool
+    message: str
+    session_id: str
+    vnc_url: str

simplex-2.0.0.dist-info/METADATA

@@ -0,0 +1,224 @@
+Metadata-Version: 2.4
+Name: simplex
+Version: 2.0.0
+Summary: Official Python SDK for the Simplex API
+Author-email: Simplex <support@simplex.sh>
+License: MIT
+Project-URL: Homepage, https://simplex.sh
+Project-URL: Documentation, https://docs.simplex.sh
+Project-URL: Repository, https://github.com/simplexlabs/simplex-python
+Keywords: simplex,api,sdk,workflow,automation,browser,scraping
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: types-requests>=2.25.0; extra == "dev"
+Dynamic: license-file
+
+# Simplex Python SDK
+
+Official Python SDK for the [Simplex API](https://simplex.sh) - A powerful workflow automation platform for browser-based tasks.
+
+[![Python Version](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install simplex
+```
+
+## Quick Start
+
+```python
+import time
+from simplex import SimplexClient
+
+# Initialize the client
+client = SimplexClient(api_key="your-api-key")
+
+# Run a workflow
+response = client.run_workflow(
+    "workflow-id",
+    variables={"email": "user@example.com"}
+)
+
+print(f"Session started: {response['session_id']}")
+
+# Poll for completion
+while True:
+    status = client.get_session_status(response["session_id"])
+    if not status["in_progress"]:
+        break
+    time.sleep(1)
+
+# Check results
+if status["success"]:
+    print("Success!")
+    print("Scraper outputs:", status["scraper_outputs"])
+    print("File metadata:", status["file_metadata"])
+else:
+    print("Failed")
+```
+
+## API Reference
+
+### SimplexClient
+
+```python
+client = SimplexClient(
+    api_key="your-api-key",
+    base_url="https://api.simplex.sh",  # Optional
+    timeout=30,                          # Request timeout in seconds
+    max_retries=3,                       # Retry attempts for failed requests
+    retry_delay=1.0,                     # Delay between retries in seconds
+)
+```
+
+### Methods
+
+#### `run_workflow(workflow_id, variables=None, metadata=None, webhook_url=None)`
+
+Run a workflow by its ID.
+
+```python
+response = client.run_workflow(
+    "workflow-id",
+    variables={"key": "value"},
+    metadata="optional metadata",
+    webhook_url="https://your-webhook.com/callback"
+)
+
+print(response["session_id"])  # Session ID for polling
+print(response["vnc_url"])     # VNC URL to watch the session
+```
+
+#### `get_session_status(session_id)`
+
+Get the status of a running or completed session.
+
+```python
+status = client.get_session_status("session-id")
+
+print(status["in_progress"])       # True while running
+print(status["success"])           # True/False when complete, None while running
+print(status["scraper_outputs"])   # Data collected by scrapers
+print(status["file_metadata"])     # Metadata for downloaded files
+print(status["metadata"])          # Custom metadata
+print(status["workflow_metadata"]) # Workflow metadata
+```
+
+#### `download_session_files(session_id, filename=None)`
+
+Download files from a completed session.
+
+```python
+# Download all files as a zip
+zip_data = client.download_session_files("session-id")
+with open("files.zip", "wb") as f:
+    f.write(zip_data)
+
+# Download a specific file
+pdf_data = client.download_session_files("session-id", filename="report.pdf")
+with open("report.pdf", "wb") as f:
+    f.write(pdf_data)
+```
+
+#### `retrieve_session_replay(session_id)`
+
+Download the session replay video (MP4).
+
+```python
+video = client.retrieve_session_replay("session-id")
+with open("replay.mp4", "wb") as f:
+    f.write(video)
+```
+
+#### `retrieve_session_logs(session_id)`
+
+Get the session logs as parsed JSON.
+
+```python
+logs = client.retrieve_session_logs("session-id")
+for entry in logs:
+    print(f"{entry['timestamp']}: {entry['message']}")
+```
+
+## Error Handling
+
+The SDK provides specific exception types for different error scenarios:
+
+```python
+from simplex import (
+    SimplexClient,
+    SimplexError,
+    WorkflowError,
+    AuthenticationError,
+    RateLimitError,
+    NetworkError,
+    ValidationError,
+)
+
+client = SimplexClient(api_key="your-api-key")
+
+try:
+    result = client.run_workflow("workflow-id")
+except AuthenticationError as e:
+    print(f"Invalid API key: {e.message}")
+except RateLimitError as e:
+    print(f"Rate limited. Retry after {e.retry_after} seconds")
+except ValidationError as e:
+    print(f"Invalid request: {e.message}")
+except WorkflowError as e:
+    print(f"Workflow error: {e.message}")
+    print(f"Session ID: {e.session_id}")
+except NetworkError as e:
+    print(f"Network error: {e.message}")
+except SimplexError as e:
+    print(f"General error: {e.message}")
+```
+
+## Type Hints
+
+The SDK includes full type hints for better IDE support:
+
+```python
+from simplex import (
+    SimplexClient,
+    SessionStatusResponse,
+    RunWorkflowResponse,
+    FileMetadata,
+)
+
+client = SimplexClient(api_key="your-api-key")
+response: RunWorkflowResponse = client.run_workflow("workflow-id")
+status: SessionStatusResponse = client.get_session_status(response["session_id"])
+```
+
+## Requirements
+
+- Python 3.9+
+- `requests>=2.25.0`
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Support
+
+- Documentation: [https://docs.simplex.sh](https://docs.simplex.sh)
+- Email: support@simplex.sh

simplex-2.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+simplex/__init__.py,sha256=Okie1I8gw2-rwBZaNoqOXggKgcuy9I-wezRnH4yMFoQ,1188
+simplex/_http_client.py,sha256=BbDsNYnfpydjNNXNw7gkyoRXGIG-QFMXfQgKN93WBxU,6819
+simplex/client.py,sha256=xPw5eQhF7V9os0iXwT0jQbIWPjqloj-oXZD_6RXQmk0,9480
+simplex/errors.py,sha256=xfRn6FCbQT_YgjZJrWq9MQPj8LMfjNAhNYMBW6XL8aw,3323
+simplex/types.py,sha256=pc4n-HQ2hNm1LfK5psgh-UDKfvl1_pN9EXfkCyFTkvM,1765
+simplex-2.0.0.dist-info/licenses/LICENSE,sha256=TyxVTRp5rBigFCL8EDC9Bv7AZfb4JBMVUZUeCs4Pk6Y,1063
+simplex-2.0.0.dist-info/METADATA,sha256=VN8m-8rhvYg5ZIV7L_mjlscZm0-xrsuw1eg4t1daWBc,6024
+simplex-2.0.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+simplex-2.0.0.dist-info/top_level.txt,sha256=cbMH1bYpN0A3gP-ecibPRHasHoqB-01T_2BUFS8p0CE,8
+simplex-2.0.0.dist-info/RECORD,,

simplex-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simplex-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Simplex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simplex-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+simplex