scalebox-sdk 0.1.24__py3-none-any.whl → 1.0.1__py3-none-any.whl

scalebox/__init__.py

@@ -9,7 +9,7 @@ A multi-language code execution sandbox with support for:
 - Real-time callbacks and monitoring
 """
 
-__version__ = "0.1.24"
+__version__ = "1.0.1"
 __author__ = "ScaleBox Team"
 __email__ = "dev@scalebox.dev"
 
@@ -74,7 +74,7 @@ __all__ = [
     "AuthenticationException",
     "TemplateException",
     "RateLimitException",
-    "APIError",
+    # "APIError",
     # Configuration
     "ConnectionConfig",
 ]

scalebox/api/__init__.py

@@ -1,128 +1,130 @@
-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 `SBX_API_KEY` "
-                    'or you can pass it directly to the sandbox like Sandbox(api_key="sbx_...")',
-                )
-            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 `SBX_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}")
+import json
+import logging
+from dataclasses import dataclass
+from typing import Optional, Dict
+
+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
+    object_storage: Optional[Dict[str, str]]
+    network_proxy: Optional[Dict[str, any]]
+
+
+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 `SBX_API_KEY` "
+                    'or you can pass it directly to the sandbox like Sandbox(api_key="sbx_...")',
+                )
+            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 `SBX_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

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

scalebox/api/client/api/sandboxes/get_sandboxes_sandbox_id_metrics.py

@@ -39,9 +39,9 @@ def _parse_response(
     if response.status_code == 200:
         response_200 = []
         _response_200 = response.json()
-        print(_response_200)
+        # print(_response_200)
         for response_200_item_data in _response_200["data"]["metrics"]:
-            print(response_200_item_data)
+            # print(response_200_item_data)
             response_200_item = SandboxMetric.from_dict(response_200_item_data)
 
             response_200.append(response_200_item)

scalebox/api/client/api/sandboxes/post_sandboxes.py

@@ -35,7 +35,7 @@ def _parse_response(
     *, client: Union[AuthenticatedClient, Client], response: httpx.Response
 ) -> Optional[Union[Error, Sandbox]]:
     if response.status_code == 201:
-        print(response.json())
+        # print(response.json())
         response_201 = Sandbox.from_dict(response.json())
 
         return response_201
@@ -89,7 +89,7 @@ def sync_detailed(
     kwargs = _get_kwargs(
         body=body,
     )
-    print(kwargs)
+    # print(kwargs)
     response = client.get_httpx_client().request(
         **kwargs,
     )

scalebox/api/client/api/sandboxes/post_sandboxes_sandbox_id_connect.py

@@ -0,0 +1,193 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.connect_sandbox import ConnectSandbox
+from ...models.error import Error
+from ...models.sandbox import Sandbox
+from ...types import Response
+
+
+def _get_kwargs(
+    sandbox_id: str,
+    *,
+    body: ConnectSandbox,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/sandboxes/{sandbox_id}/connect",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[Error, Sandbox]]:
+    if response.status_code == 200:
+        response_200 = Sandbox.from_dict(response.json())
+
+        return response_200
+    if response.status_code == 201:
+        response_201 = Sandbox.from_dict(response.json())
+
+        return response_201
+    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 == 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[Error, Sandbox]]:
+    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,
+    body: ConnectSandbox,
+) -> Response[Union[Error, Sandbox]]:
+    """Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended.
+
+    Args:
+        sandbox_id (str):
+        body (ConnectSandbox):
+
+    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, Sandbox]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ConnectSandbox,
+) -> Optional[Union[Error, Sandbox]]:
+    """Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended.
+
+    Args:
+        sandbox_id (str):
+        body (ConnectSandbox):
+
+    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, Sandbox]
+    """
+
+    return sync_detailed(
+        sandbox_id=sandbox_id,
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ConnectSandbox,
+) -> Response[Union[Error, Sandbox]]:
+    """Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended.
+
+    Args:
+        sandbox_id (str):
+        body (ConnectSandbox):
+
+    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, Sandbox]]
+    """
+
+    kwargs = _get_kwargs(
+        sandbox_id=sandbox_id,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    sandbox_id: str,
+    *,
+    client: AuthenticatedClient,
+    body: ConnectSandbox,
+) -> Optional[Union[Error, Sandbox]]:
+    """Returns sandbox details. If the sandbox is paused, it will be resumed. TTL is only extended.
+
+    Args:
+        sandbox_id (str):
+        body (ConnectSandbox):
+
+    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, Sandbox]
+    """
+
+    return (
+        await asyncio_detailed(
+            sandbox_id=sandbox_id,
+            client=client,
+            body=body,
+        )
+    ).parsed