scalebox-sdk 0.1.0__py3-none-any.whl

scalebox/__init__.py

@@ -0,0 +1,80 @@
+"""
+ScaleBox Python SDK
+
+A multi-language code execution sandbox with support for:
+- Python, R, Node.js, Deno/TypeScript, Java, and Bash
+- Synchronous and asynchronous execution
+- Persistent context across executions
+- Rich result formats (text, HTML, Markdown, SVG, images, LaTeX, JSON, etc.)
+- Real-time callbacks and monitoring
+"""
+
+__version__ = "0.1.0"
+__author__ = "ScaleBox Team"
+__email__ = "dev@scalebox.dev"
+
+# API client imports
+from .api.client import Client
+from .api.client.errors import UnexpectedStatus
+
+# Core imports
+from .code_interpreter import AsyncSandbox, Sandbox
+from .code_interpreter.models import (
+    Context,
+    Execution,
+    ExecutionError,
+    Logs,
+    MIMEType,
+    OutputHandler,
+    OutputMessage,
+    Result,
+)
+from .connection_config import ConnectionConfig
+from .exceptions import (
+    AuthenticationException,
+    InvalidArgumentException,
+    NotEnoughSpaceException,
+    NotFoundException,
+    RateLimitException,
+    SandboxException,
+    TemplateException,
+    TimeoutException,
+)
+from .sandbox_async.main import AsyncSandbox as BaseAsyncSandbox
+
+# Sandbox imports
+from .sandbox_sync.main import Sandbox as BaseSandbox
+
+__all__ = [
+    # Version info
+    "__version__",
+    "__author__",
+    "__email__",
+    # Core classes
+    "Sandbox",
+    "AsyncSandbox",
+    "BaseSandbox",
+    "BaseAsyncSandbox",
+    "Client",
+    # Models
+    "Context",
+    "Execution",
+    "ExecutionError",
+    "Result",
+    "MIMEType",
+    "Logs",
+    "OutputHandler",
+    "OutputMessage",
+    # Exceptions
+    "SandboxException",
+    "TimeoutException",
+    "InvalidArgumentException",
+    "NotEnoughSpaceException",
+    "NotFoundException",
+    "AuthenticationException",
+    "TemplateException",
+    "RateLimitException",
+    "APIError",
+    # Configuration
+    "ConnectionConfig",
+]

scalebox/api/__init__.py

@@ -0,0 +1,128 @@
+import json
+import logging
+from dataclasses import dataclass
+from typing import Optional
+
+from httpx import Limits
+
+from ..api.client.client import AuthenticatedClient
+from ..api.client.types import Response
+from ..api.metadata import default_headers
+from ..connection_config import ConnectionConfig
+from ..exceptions import AuthenticationException, RateLimitException, SandboxException
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SandboxCreateResponse:
+    sandbox_id: str
+    sandbox_domain: Optional[str]
+    envd_version: str
+    envd_access_token: str
+
+
+def handle_api_exception(e: Response):
+    try:
+        body = json.loads(e.content) if e.content else {}
+    except json.JSONDecodeError:
+        body = {}
+
+    if e.status_code == 429:
+        return RateLimitException(
+            f"{e.status_code}: Rate limit exceeded, please try again later."
+        )
+
+    if "message" in body:
+        return SandboxException(f"{e.status_code}: {body['message']}")
+    return SandboxException(f"{e.status_code}: {e.content}")
+
+
+class ApiClient(AuthenticatedClient):
+    """
+    The client for interacting with the CSX API.
+    """
+
+    def __init__(
+        self,
+        config: ConnectionConfig,
+        require_api_key: bool = True,
+        require_access_token: bool = False,
+        limits: Optional[Limits] = None,
+        *args,
+        **kwargs,
+    ):
+        if require_api_key and require_access_token:
+            raise AuthenticationException(
+                "Only one of api_key or access_token can be required, not both",
+            )
+
+        if not require_api_key and not require_access_token:
+            raise AuthenticationException(
+                "Either api_key or access_token is required",
+            )
+
+        token = None
+        if require_api_key:
+            if config.api_key is None:
+                raise AuthenticationException(
+                    "API key is required, please visit the Team tab at https://dev/dashboard to get your API key. "
+                    "You can either set the environment variable `E2B_API_KEY` "
+                    'or you can pass it directly to the sandbox like Sandbox(api_key="e2b_...")',
+                )
+            token = config.api_key
+
+        if require_access_token:
+            if config.access_token is None:
+                raise AuthenticationException(
+                    "Access token is required, please visit the Personal tab at https://dev/dashboard to get your access token. "
+                    "You can set the environment variable `E2B_ACCESS_TOKEN` or pass the `access_token` in options.",
+                )
+            token = config.access_token
+
+        auth_header_name = "X-API-KEY" if require_api_key else "Authorization"
+        prefix = "" if require_api_key else "Bearer"
+
+        headers = {
+            **default_headers,
+            **(config.headers or {}),
+        }
+
+        super().__init__(
+            base_url=config.api_url,
+            httpx_args={
+                "event_hooks": {
+                    "request": [self._log_request],
+                    "response": [self._log_response],
+                },
+                "proxy": config.proxy,
+                "limits": limits,
+            },
+            headers=headers,
+            token=token,
+            auth_header_name=auth_header_name,
+            prefix=prefix,
+            *args,
+            **kwargs,
+        )
+
+    def _log_request(self, request):
+        logger.info(f"Request {request.method} {request.url}")
+
+    def _log_response(self, response: Response):
+        if response.status_code >= 400:
+            logger.error(f"Response {response.status_code}")
+        else:
+            logger.info(f"Response {response.status_code}")
+
+
+# We need to override the logging hooks for the async usage
+class AsyncApiClient(ApiClient):
+    async def _log_request(self, request):
+        logger.info(f"Request {request.method} {request.url}")
+
+    async def _log_response(self, response: Response):
+        if response.status_code >= 400:
+            logger.error(f"Response {response.status_code}")
+        else:
+            logger.info(f"Response {response.status_code}")

scalebox/api/client/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing E2B API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

scalebox/api/client/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

scalebox/api/client/api/sandboxes/delete_sandboxes_sandbox_id.py

@@ -0,0 +1,161 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": f"/sandboxes/{sandbox_id}",
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Any, Error]]:
+    if response.status_code == 204:
+        response_204 = cast(Any, None)
+        return response_204
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 404:
+        response_404 = Error.from_dict(response.json())
+
+        return response_404
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Any, Error]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Any, Error]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+) -> Optional[Union[Any, Error]]:
+    """Kill a sandbox
+
+    Args:
+        sandbox_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Any, Error]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+        )
+    ).parsed

scalebox/api/client/api/sandboxes/get_sandboxes.py

@@ -0,0 +1,176 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.error import Error
+from ...models.listed_sandbox import ListedSandbox
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    *,
+    metadata: Union[Unset, str] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["metadata"] = metadata
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/sandboxes",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, list["ListedSandbox"]]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = ListedSandbox.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+    if response.status_code == 400:
+        response_400 = Error.from_dict(response.json())
+
+        return response_400
+    if response.status_code == 401:
+        response_401 = Error.from_dict(response.json())
+
+        return response_401
+    if response.status_code == 500:
+        response_500 = Error.from_dict(response.json())
+
+        return response_500
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[Error, list["ListedSandbox"]]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+) -> Response[Union[Error, list["ListedSandbox"]]]:
+    """List all running sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['ListedSandbox']]]
+    """
+
+    kwargs = _get_kwargs(
+        metadata=metadata,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+) -> Optional[Union[Error, list["ListedSandbox"]]]:
+    """List all running sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['ListedSandbox']]
+    """
+
+    return sync_detailed(
+        client=client,
+        metadata=metadata,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+) -> Response[Union[Error, list["ListedSandbox"]]]:
+    """List all running sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[Error, list['ListedSandbox']]]
+    """
+
+    kwargs = _get_kwargs(
+        metadata=metadata,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    metadata: Union[Unset, str] = UNSET,
+) -> Optional[Union[Error, list["ListedSandbox"]]]:
+    """List all running sandboxes
+
+    Args:
+        metadata (Union[Unset, str]):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[Error, list['ListedSandbox']]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            metadata=metadata,
+        )
+    ).parsed