cubesandbox 0.1.0__py3-none-any.whl

cubesandbox/__init__.py

@@ -0,0 +1,24 @@
+# Copyright (c) 2026 Tencent Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+from .sandbox import Sandbox
+from ._config import Config
+from ._models import Execution, Result, Logs, ExecutionError, OutputMessage
+from ._exceptions import CubeSandboxError, SandboxNotFoundError, ApiError
+from ._commands import CommandResult
+
+__all__ = [
+    "Sandbox",
+    "Config",
+    "Execution",
+    "Result",
+    "Logs",
+    "ExecutionError",
+    "OutputMessage",
+    "CubeSandboxError",
+    "SandboxNotFoundError",
+    "ApiError",
+    "CommandResult",
+]
+
+__version__ = "0.1.0"

cubesandbox/_commands.py

@@ -0,0 +1,51 @@
+# Copyright (c) 2026 Tencent Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .sandbox import Sandbox
+
+
+@dataclass
+class CommandResult:
+    stdout: str
+    stderr: str
+    exit_code: int
+
+
+class Commands:
+    def __init__(self, sandbox: "Sandbox") -> None:
+        self._sandbox = sandbox
+
+    def run(self, cmd: str, *, timeout: float | None = None, **kwargs) -> CommandResult:
+        """Run a shell command inside the sandbox via Python subprocess."""
+        code = (
+            "import subprocess as _sp\n"
+            f"_r = _sp.run({cmd!r}, shell=True, capture_output=True, text=True)\n"
+            "import sys as _sys\n"
+            "_sys.stdout.write(_r.stdout)\n"
+            "_sys.stderr.write(_r.stderr)\n"
+            "print(_r.returncode)\n"
+        )
+        stdout_lines: list[str] = []
+        execution = self._sandbox.run_code(
+            code,
+            timeout=timeout,
+            on_stdout=lambda m: stdout_lines.append(m.text),
+        )
+        # last stdout line is the exit code printed by the wrapper
+        all_stdout = "".join(stdout_lines)
+        lines = all_stdout.splitlines()
+        if lines and lines[-1].strip().lstrip("-").isdigit():
+            exit_code = int(lines[-1].strip())
+            stdout = "\n".join(lines[:-1])
+            if lines[:-1]:  # restore trailing newline if there was content
+                stdout += "\n"
+        else:
+            exit_code = 1 if execution.error else 0
+            stdout = all_stdout
+        stderr = "".join(execution.logs.stderr)
+        return CommandResult(stdout=stdout, stderr=stderr, exit_code=exit_code)

cubesandbox/_config.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2026 Tencent Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Config:
+    """SDK configuration. All fields can be set via environment variables."""
+
+    api_url: str = field(
+        default_factory=lambda: os.environ.get("CUBE_API_URL", "http://127.0.0.1:3000")
+    )
+    template_id: str | None = field(
+        default_factory=lambda: os.environ.get("CUBE_TEMPLATE_ID")
+    )
+    proxy_node_ip: str | None = field(
+        default_factory=lambda: os.environ.get("CUBE_PROXY_NODE_IP")
+    )
+    proxy_port: int = field(
+        default_factory=lambda: int(os.environ.get("CUBE_PROXY_PORT_HTTP", "80"))
+    )
+    sandbox_domain: str = field(
+        default_factory=lambda: os.environ.get("CUBE_SANDBOX_DOMAIN", "cube.app")
+    )
+    timeout: int = 300
+    request_timeout: float = 30.0
+
+    def __post_init__(self) -> None:
+        self.api_url = self.api_url.rstrip("/")

cubesandbox/_exceptions.py

@@ -0,0 +1,16 @@
+# Copyright (c) 2026 Tencent Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+
+class CubeSandboxError(Exception):
+    def __init__(self, message: str, status_code: int | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class SandboxNotFoundError(CubeSandboxError): ...
+class TemplateNotFoundError(CubeSandboxError): ...
+class AuthenticationError(CubeSandboxError): ...
+class ApiError(CubeSandboxError): ...

cubesandbox/_filesystem.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2026 Tencent Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .sandbox import Sandbox
+
+
+class Filesystem:
+    def __init__(self, sandbox: "Sandbox") -> None:
+        self._sandbox = sandbox
+
+    def read(self, path: str) -> str:
+        result = self._sandbox.run_code(f"open({path!r}).read()")
+        if result.error:
+            raise IOError(f"Failed to read {path}: {result.error.value}")
+        return result.text or ""

cubesandbox/_models.py

@@ -0,0 +1,62 @@
+# Copyright (c) 2026 Tencent Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+
+@dataclass
+class Logs:
+    stdout: List[str] = field(default_factory=list)
+    stderr: List[str] = field(default_factory=list)
+
+
+@dataclass
+class ExecutionError:
+    name: str
+    value: str
+    traceback: List[str] = field(default_factory=list)
+
+
+@dataclass
+class Result:
+    text: Optional[str] = None
+    html: Optional[str] = None
+    markdown: Optional[str] = None
+    svg: Optional[str] = None
+    png: Optional[str] = None
+    jpeg: Optional[str] = None
+    pdf: Optional[str] = None
+    latex: Optional[str] = None
+    json_data: Optional[dict] = None
+    javascript: Optional[str] = None
+    is_main_result: bool = False
+    extra: Optional[dict] = None
+
+
+@dataclass
+class Execution:
+    results: List[Result] = field(default_factory=list)
+    logs: Logs = field(default_factory=Logs)
+    error: Optional[ExecutionError] = None
+    execution_count: Optional[int] = None
+
+    @property
+    def text(self) -> Optional[str]:
+        """Text of the main result (last expression value)."""
+        for r in self.results:
+            if r.is_main_result:
+                return r.text
+        return None
+
+    def __repr__(self) -> str:
+        return f"Execution(text={self.text!r}, error={self.error})"
+
+
+@dataclass
+class OutputMessage:
+    text: str
+    timestamp: str = ""
+    is_stderr: bool = False

cubesandbox/_stream.py

@@ -0,0 +1,64 @@
+# Copyright (c) 2026 Tencent Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Callable, Optional
+
+from ._models import Execution, ExecutionError, OutputMessage, Result
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_line(
+    execution: Execution,
+    line: str,
+    on_stdout: Optional[Callable[[OutputMessage], None]] = None,
+    on_stderr: Optional[Callable[[OutputMessage], None]] = None,
+    on_result: Optional[Callable[[Result], None]] = None,
+    on_error: Optional[Callable[[ExecutionError], None]] = None,
+) -> None:
+    if not line:
+        return
+    try:
+        data = json.loads(line)
+    except json.JSONDecodeError:
+        logger.debug("_parse_line: malformed JSON, skipping: %r", line)
+        return
+
+    event_type = data.pop("type", None)
+
+    if event_type == "result":
+        result = Result(**{k: v for k, v in data.items() if k in Result.__dataclass_fields__})
+        execution.results.append(result)
+        if on_result:
+            on_result(result)
+
+    elif event_type == "stdout":
+        text = data.get("text", "")
+        execution.logs.stdout.append(text)
+        if on_stdout:
+            on_stdout(OutputMessage(text, data.get("timestamp", "")))
+
+    elif event_type == "stderr":
+        text = data.get("text", "")
+        execution.logs.stderr.append(text)
+        if on_stderr:
+            on_stderr(OutputMessage(text, data.get("timestamp", ""), is_stderr=True))
+
+    elif event_type == "error":
+        execution.error = ExecutionError(
+            name=data.get("name", ""),
+            value=data.get("value", ""),
+            traceback=data.get("traceback", []),
+        )
+        if on_error:
+            on_error(execution.error)
+
+    elif event_type == "number_of_executions":
+        execution.execution_count = data.get("execution_count")
+
+    else:
+        logger.debug("_parse_line: unknown event type %r, skipping", event_type)

cubesandbox/_transport.py

@@ -0,0 +1,56 @@
+# Copyright (c) 2026 Tencent Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import ssl
+
+import httpx
+
+from ._config import Config
+
+
+class IPOverrideTransport(httpx.HTTPTransport):
+    """Routes all TCP connections to a fixed IP:port while preserving the Host header.
+
+    Equivalent to ``curl --resolve host:port:ip``.
+    Used when ``CUBE_PROXY_NODE_IP`` is set to bypass DNS resolution of ``*.cube.app``.
+    """
+
+    def __init__(self, ip: str, port: int, ssl_context: ssl.SSLContext | None = None, **kw):
+        super().__init__(verify=ssl_context or True, **kw)
+        self._ip = ip
+        self._port = port
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        original_host = request.url.host
+        url = request.url.copy_with(host=self._ip, port=self._port)
+        proxied = httpx.Request(
+            method=request.method,
+            url=url,
+            headers=[
+                (k, original_host if k.lower() == "host" else v)
+                for k, v in request.headers.raw
+            ],
+            content=request.content,
+        )
+        return super().handle_request(proxied)
+
+
+def build_client(config: Config) -> httpx.Client:
+    """Build an httpx client for sandbox stream requests.
+
+    When ``config.proxy_node_ip`` is set, all connections are routed directly
+    to that IP, bypassing DNS. The ``Host`` header retains the virtual hostname
+    so CubeProxy can route to the correct sandbox.
+    """
+    if config.proxy_node_ip:
+        transport = IPOverrideTransport(config.proxy_node_ip, config.proxy_port)
+    else:
+        transport = httpx.HTTPTransport()
+
+    return httpx.Client(
+        transport=transport,
+        timeout=httpx.Timeout(connect=config.request_timeout, read=None, write=30, pool=30),
+        follow_redirects=True,
+    )

cubesandbox/sandbox.py

@@ -0,0 +1,408 @@
+# Copyright (c) 2026 Tencent Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any, Callable, Dict, Optional
+
+import httpx
+
+from ._commands import CommandResult, Commands
+from ._config import Config
+from ._exceptions import ApiError, AuthenticationError, CubeSandboxError, SandboxNotFoundError, TemplateNotFoundError
+from ._filesystem import Filesystem
+from ._models import Execution, ExecutionError, OutputMessage, Result
+from ._stream import _parse_line
+from ._transport import build_client
+
+logger = logging.getLogger(__name__)
+
+JUPYTER_PORT = 49999
+
+
+def _check_response(resp: httpx.Response) -> None:
+    if resp.is_success:
+        return
+    try:
+        msg = resp.json().get("message") or resp.json().get("detail") or resp.text
+    except Exception:
+        msg = resp.text or f"HTTP {resp.status_code}"
+    code = resp.status_code
+    if code in (401, 403):
+        raise AuthenticationError(msg, code)
+    if code == 404:
+        raise (TemplateNotFoundError if "template" in msg.lower() else SandboxNotFoundError)(msg, code)
+    raise ApiError(msg, code)
+
+
+class Sandbox:
+    """A CubeSandbox code execution environment.
+
+    Example::
+
+        with Sandbox.create() as sb:
+            sb.run_code("x = 1")
+            result = sb.run_code("x + 1")
+            print(result.text)   # "2"
+    """
+
+    def __init__(self, data: dict, config: Optional[Config] = None) -> None:
+        self._data = data
+        self._config = config or Config()
+        self._session = self._build_session()
+        self._client: httpx.Client | None = None
+        self._commands = Commands(self)
+        self._files = Filesystem(self)
+
+    # ── properties ───────────────────────────────────────────────────
+
+    @property
+    def sandbox_id(self) -> str:
+        return self._data["sandboxID"]
+
+    @property
+    def template_id(self) -> str:
+        return self._data["templateID"]
+
+    @property
+    def domain(self) -> str:
+        return self._data.get("domain") or self._config.sandbox_domain
+
+    def get_host(self, port: int) -> str:
+        """Return the virtual hostname for a sandbox port.
+
+        e.g. ``49999-<sandboxID>.cube.app``
+        """
+        return f"{port}-{self.sandbox_id}.{self.domain}"
+
+    @property
+    def commands(self) -> "Commands":
+        return self._commands
+
+    @property
+    def files(self) -> "Filesystem":
+        return self._files
+
+    # ── factory methods ───────────────────────────────────────────────
+
+    @classmethod
+    def create(
+        cls,
+        template: str | None = None,
+        *,
+        timeout: int | None = None,
+        env_vars: Dict[str, str] | None = None,
+        metadata: Dict[str, str] | None = None,
+        allow_internet_access: bool = True,
+        network: Dict[str, Any] | None = None,
+        config: Config | None = None,
+        **kwargs: Any,
+    ) -> "Sandbox":
+        """POST /sandboxes - Create a new sandbox.
+
+        Args:
+            template: Template ID. Falls back to ``CUBE_TEMPLATE_ID`` env var.
+            timeout: Sandbox TTL in seconds. Defaults to ``Config.timeout`` (300).
+            env_vars: Environment variables injected into the sandbox.
+            metadata: Arbitrary key-value metadata (e.g. network-policy, hostdir-mount).
+            config: SDK config. Uses default (env-based) config if omitted.
+
+        Returns:
+            A running :class:`Sandbox` instance.
+
+        Raises:
+            ValueError: If no template ID is provided.
+            ApiError: On unexpected backend error (HTTP 500).
+        """
+        cfg = config or Config()
+        tpl = template or cfg.template_id
+        if not tpl:
+            raise ValueError("template is required. Set CUBE_TEMPLATE_ID or pass template=")
+
+        payload: dict = {"templateID": tpl, "timeout": timeout or cfg.timeout}
+        if env_vars:
+            payload["envVars"] = env_vars
+        if metadata:
+            payload["metadata"] = metadata
+        if not allow_internet_access:
+            payload["allowInternetAccess"] = False
+        if network:
+            net: dict = {}
+            if "allow_out" in network:
+                net["allowOut"] = network["allow_out"]
+            if "deny_out" in network:
+                net["denyOut"] = network["deny_out"]
+            if net:
+                payload["network"] = net
+        payload.update(kwargs)
+
+        with httpx.Client(headers={"Content-Type": "application/json"}) as s:
+            resp = s.post(f"{cfg.api_url}/sandboxes", json=payload)
+        _check_response(resp)
+        return cls(resp.json(), config=cfg)
+
+    @classmethod
+    def connect(cls, sandbox_id: str, *, config: Config | None = None) -> "Sandbox":
+        """POST /sandboxes/:sandboxID/connect - Connect to an existing sandbox.
+
+        Resumes the sandbox if it is currently paused.
+
+        Args:
+            sandbox_id: Sandbox identifier.
+            config: SDK config. Uses default (env-based) config if omitted.
+
+        Returns:
+            A :class:`Sandbox` instance connected to the existing sandbox.
+
+        Raises:
+            SandboxNotFoundError: If the sandbox does not exist (HTTP 404).
+            ApiError: On unexpected backend error (HTTP 500).
+        """
+        cfg = config or Config()
+        with httpx.Client(headers={"Content-Type": "application/json"}) as s:
+            resp = s.post(
+                f"{cfg.api_url}/sandboxes/{sandbox_id}/connect",
+                json={"timeout": cfg.timeout},
+            )
+        _check_response(resp)
+        return cls(resp.json(), config=cfg)
+
+    # ── class-level API methods ───────────────────────────────────────
+
+    @classmethod
+    def list(cls, config: Config | None = None) -> list[dict]:
+        """GET /sandboxes - List all running sandboxes (v1).
+
+        Args:
+            config: SDK config. Uses default (env-based) config if omitted.
+
+        Returns:
+            A list of sandbox info dicts, each containing at least
+            ``sandboxID``, ``templateID``, and ``state`` keys.
+        """
+        cfg = config or Config()
+        with httpx.Client() as s:
+            resp = s.get(f"{cfg.api_url}/sandboxes")
+        _check_response(resp)
+        return resp.json()
+
+    @classmethod
+    def list_v2(cls, config: Config | None = None) -> list[dict]:
+        """GET /v2/sandboxes - List all running sandboxes (v2).
+
+        Supports state / metadata filtering on the server side.
+
+        Args:
+            config: SDK config. Uses default (env-based) config if omitted.
+
+        Returns:
+            A list of sandbox info dicts.
+        """
+        cfg = config or Config()
+        with httpx.Client() as s:
+            resp = s.get(f"{cfg.api_url}/v2/sandboxes")
+        _check_response(resp)
+        return resp.json()
+
+    @classmethod
+    def health(cls, config: Config | None = None) -> dict:
+        """GET /health - Check the health of the CubeAPI service.
+
+        Args:
+            config: SDK config. Uses default (env-based) config if omitted.
+
+        Returns:
+            A dict with at least a ``status`` key, e.g.
+            ``{"status": "ok", "sandboxes": 0}``.
+        """
+        cfg = config or Config()
+        with httpx.Client() as s:
+            resp = s.get(f"{cfg.api_url}/health")
+        _check_response(resp)
+        return resp.json()
+
+    # ── code execution ────────────────────────────────────────────────
+
+    def run_code(
+        self,
+        code: str,
+        *,
+        language: str | None = None,
+        on_stdout: Callable[[OutputMessage], None] | None = None,
+        on_stderr: Callable[[OutputMessage], None] | None = None,
+        on_result: Callable[[Result], None] | None = None,
+        on_error: Callable[[ExecutionError], None] | None = None,
+        envs: Dict[str, str] | None = None,
+        timeout: float | None = None,
+    ) -> Execution:
+        """POST /execute - Execute code inside the sandbox.
+
+        Streams the ndjson response from the sandbox's envd process via
+        CubeProxy. When ``CUBE_PROXY_NODE_IP`` is set, connections bypass
+        DNS resolution using :class:`IPOverrideTransport`.
+
+        Args:
+            code: Python code to execute.
+            language: Kernel language override (default: ``"python"``).
+                pass ``None`` (or omit) to use the sandbox's global namespace.
+            on_stdout: Callback invoked for each stdout event.
+            on_stderr: Callback invoked for each stderr event.
+            on_result: Callback invoked for each result event.
+            on_error: Callback invoked on execution error.
+            envs: Per-execution environment variables.
+            timeout: Read timeout in seconds (default: no timeout).
+
+        Returns:
+            :class:`Execution` with ``.text``, ``.logs``, and ``.error``.
+
+        Raises:
+            ApiError: If the execute endpoint returns HTTP 4xx/5xx.
+        """
+        if self._client is None:
+            self._client = build_client(self._config)
+
+        url = f"http://{self.get_host(JUPYTER_PORT)}/execute"
+        payload = {
+            "code": code,
+            "language": language,
+            "env_vars": envs,
+        }
+        execution = Execution()
+
+        with self._client.stream(
+            "POST", url,
+            json=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=httpx.Timeout(
+                connect=self._config.request_timeout,
+                read=timeout,
+                write=30,
+                pool=30,
+            ),
+        ) as resp:
+            if resp.status_code >= 400:
+                raise ApiError(f"execute failed: HTTP {resp.status_code}", resp.status_code)
+            for line in resp.iter_lines():
+                _parse_line(execution, line,
+                            on_stdout=on_stdout, on_stderr=on_stderr,
+                            on_result=on_result, on_error=on_error)
+
+        return execution
+
+    # ── lifecycle ─────────────────────────────────────────────────────
+
+    def pause(self, *, wait: bool = True, timeout: float = 30, interval: float = 1.0) -> None:
+        """POST /sandboxes/:sandboxID/pause - Pause a sandbox.
+
+        Preserves the sandbox memory snapshot. The sandbox can be resumed
+        later via :meth:`connect`.
+
+        Args:
+            wait: If ``True`` (default), poll :meth:`get_info` until the sandbox
+                state becomes ``"paused"`` before returning.
+            timeout: Maximum seconds to wait when ``wait=True`` (default: 30).
+            interval: Polling interval in seconds (default: 1.0).
+
+        Raises:
+            SandboxNotFoundError: If the sandbox does not exist (HTTP 404).
+            ApiError: If the sandbox cannot be paused (HTTP 409) or on
+                unexpected backend error (HTTP 500).
+            TimeoutError: If ``wait=True`` and sandbox does not reach
+                ``"paused"`` state within ``timeout`` seconds.
+        """
+        resp = self._session.post(f"{self._config.api_url}/sandboxes/{self.sandbox_id}/pause")
+        _check_response(resp)
+        if wait:
+            deadline = time.monotonic() + timeout
+            while time.monotonic() < deadline:
+                if self.get_info().get("state") == "paused":
+                    return
+                time.sleep(interval)
+            raise TimeoutError(
+                f"Sandbox {self.sandbox_id!r} did not reach 'paused' state within {timeout}s"
+            )
+
+    def resume(self, timeout: int = 300) -> None:
+        """POST /sandboxes/:sandboxID/resume - Resume a paused sandbox.
+
+        .. deprecated::
+            Use :meth:`connect` instead, which auto-resumes paused sandboxes
+            and returns a fresh :class:`Sandbox` instance.
+
+        Args:
+            timeout: Sandbox TTL in seconds after resume (default: 300).
+
+        Raises:
+            SandboxNotFoundError: If the sandbox does not exist (HTTP 404).
+            ApiError: If the sandbox is already running (HTTP 409) or on
+                unexpected backend error (HTTP 500).
+        """
+        resp = self._session.post(
+            f"{self._config.api_url}/sandboxes/{self.sandbox_id}/resume",
+            json={"timeout": timeout},
+        )
+        _check_response(resp)
+
+    def kill(self) -> None:
+        """DELETE /sandboxes/:sandboxID - Destroy a sandbox.
+
+        Raises:
+            SandboxNotFoundError: If the sandbox does not exist (HTTP 404).
+            ApiError: On unexpected backend error (HTTP 500).
+        """
+        resp = self._session.delete(f"{self._config.api_url}/sandboxes/{self.sandbox_id}")
+        _check_response(resp)
+
+    def get_info(self) -> dict:
+        """GET /sandboxes/:sandboxID - Get sandbox detail.
+
+        Returns:
+            A dict containing ``sandboxID``, ``state``, ``cpuCount``,
+            ``memoryMB``, ``startedAt``, and other sandbox metadata.
+
+        Raises:
+            SandboxNotFoundError: If the sandbox does not exist (HTTP 404).
+            ApiError: On unexpected backend error (HTTP 500).
+        """
+        resp = self._session.get(f"{self._config.api_url}/sandboxes/{self.sandbox_id}")
+        _check_response(resp)
+        return resp.json()
+
+    def close(self) -> None:
+        """Close the underlying httpx streaming client.
+
+        Called automatically by :meth:`__exit__` and :meth:`__del__`.
+        Safe to call multiple times.
+        """
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+        self._session.close()
+
+    # ── context manager ───────────────────────────────────────────────
+
+    def __enter__(self) -> "Sandbox":
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        try:
+            self.kill()
+        except CubeSandboxError:
+            pass
+        self.close()
+
+    def __del__(self) -> None:
+        self.close()
+
+    def __repr__(self) -> str:
+        return f"Sandbox(id={self.sandbox_id!r}, domain={self.domain!r})"
+
+    # ── internal ──────────────────────────────────────────────────────
+
+    def _build_session(self) -> httpx.Client:
+        return httpx.Client(
+            headers={"Content-Type": "application/json"},
+            base_url=self._config.api_url,
+        )

cubesandbox-0.1.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: cubesandbox
+Version: 0.1.0
+Summary: Python SDK for CubeSandbox
+Author: TencentCloud CubeSandbox Team
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/TencentCloud/CubeSandbox
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"

cubesandbox-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+cubesandbox/__init__.py,sha256=2jkmkpIHJY3Wa7a5s0h1zjNpP_S18C2Xy8JvN5iec7o,559
+cubesandbox/_commands.py,sha256=zTctnxC1q8_Ve0nsEf9CjZVMj0B5Eu0_oA--_fe47pI,1727
+cubesandbox/_config.py,sha256=fXP_5tpjYPcMshyTrXGSYJ3PzxBSrYx8FaD597mlyFw,991
+cubesandbox/_exceptions.py,sha256=7RF0nrKH2DEOv-TFVP_zwcIBEq38orLnKJyTEcSI5T8,478
+cubesandbox/_filesystem.py,sha256=AiGoPcid4uebgnwl8vhDa4EvWw5ejvNMVSq4c6R8BBI,534
+cubesandbox/_models.py,sha256=l_tafAEd1E-MG35zTweZckWltxYt9hLpg_RT2vblx3w,1494
+cubesandbox/_stream.py,sha256=gjoY9MAx_4gdJPDV-G2dRkUZArUKf8S78BvpzUm-dNQ,1964
+cubesandbox/_transport.py,sha256=vHy4bEpFKr4Gdn-Hcmbu51rqs6YzJBYnrpiT2NEz_-g,1839
+cubesandbox/sandbox.py,sha256=m13fwxv20-_LogPz_hoPMqSpWdwWmzxmmoLYvlSLacw,14931
+cubesandbox-0.1.0.dist-info/METADATA,sha256=-3Q4evAA1HiAXbB8fdT5eZsLYHJn6Qi3dmVWCDclV44,458
+cubesandbox-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cubesandbox-0.1.0.dist-info/top_level.txt,sha256=DOmupcsRljFKJANtyvcP81YtDhglveTqjHNVozaY14I,12
+cubesandbox-0.1.0.dist-info/RECORD,,

cubesandbox-0.1.0.dist-info/WHEEL

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

cubesandbox-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cubesandbox