ucloud-sandbox 0.1.0b3__tar.gz

ucloud_sandbox-0.1.0b3/LICENSE

@@ -0,0 +1,12 @@
+MIT License
+
+Copyright (c) 2025 UCloud Technology Co., Ltd.
+
+This project is based on E2B (https://github.com/e2b-dev/e2b), originally developed by FoundryLabs, Inc.
+Original E2B License: MIT License, Copyright (c) 2025 FOUNDRYLABS, INC.
+
+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.

ucloud_sandbox-0.1.0b3/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: ucloud_sandbox
+Version: 0.1.0b3
+Summary: UCloud Sandbox SDK - Cloud sandbox environments for AI agents
+License: MIT
+License-File: LICENSE
+Author: UCloud
+Author-email: support@ucloud.cn
+Requires-Python: >=3.9,<4.0
+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: Programming Language :: Python :: 3.14
+Requires-Dist: attrs (>=23.2.0)
+Requires-Dist: dockerfile-parse (>=2.0.1,<3.0.0)
+Requires-Dist: httpcore (>=1.0.5,<2.0.0)
+Requires-Dist: httpx (>=0.27.0,<1.0.0)
+Requires-Dist: packaging (>=24.1)
+Requires-Dist: protobuf (>=4.21.0)
+Requires-Dist: python-dateutil (>=2.8.2)
+Requires-Dist: rich (>=14.0.0)
+Requires-Dist: typing-extensions (>=4.1.0)
+Requires-Dist: wcmatch (>=10.1,<11.0)
+Project-URL: Bug Tracker, https://github.com/ucloud/ucloud-sandbox-sdk/issues
+Project-URL: Homepage, https://ucloud.cn/
+Project-URL: Repository, https://github.com/ucloud/ucloud-sandbox-sdk
+Description-Content-Type: text/markdown
+
+# UCloud Sandbox Python SDK
+
+UCloud Sandbox Python SDK 提供云端沙箱环境，用于安全运行 AI 生成的代码。
+
+## 安装
+
+```bash
+pip install ucloud_sandbox
+```
+
+## 快速开始
+
+### 1. 获取 API Key
+
+1. 访问 [UCloud Sandbox](https://sandbox.ucloudai.com) 注册账号
+2. 在控制台获取 API Key
+3. 设置环境变量：
+
+```bash
+export UCLOUD_SANDBOX_API_KEY=your_api_key
+```
+
+### 2. 运行代码
+
+```python
+from ucloud_sandbox import Sandbox
+
+with Sandbox.create() as sandbox:
+    sandbox.run_code("x = 1")
+    execution = sandbox.run_code("x += 1; x")
+    print(execution.text)  # 输出: 2
+```
+
+## 文档
+TODO
+访问 [Sandbox 文档](https://docs.sandbox.ucloudai.com) 获取更多信息。
+
+## 致谢
+
+本项目基于 [E2B](https://github.com/e2b-dev/e2b) 开源项目开发，感谢 E2B 团队的贡献。
+
+## 许可证
+
+MIT License - 详见 [LICENSE](./LICENSE) 文件
+

ucloud_sandbox-0.1.0b3/README.md

@@ -0,0 +1,44 @@
+# UCloud Sandbox Python SDK
+
+UCloud Sandbox Python SDK 提供云端沙箱环境，用于安全运行 AI 生成的代码。
+
+## 安装
+
+```bash
+pip install ucloud_sandbox
+```
+
+## 快速开始
+
+### 1. 获取 API Key
+
+1. 访问 [UCloud Sandbox](https://sandbox.ucloudai.com) 注册账号
+2. 在控制台获取 API Key
+3. 设置环境变量：
+
+```bash
+export UCLOUD_SANDBOX_API_KEY=your_api_key
+```
+
+### 2. 运行代码
+
+```python
+from ucloud_sandbox import Sandbox
+
+with Sandbox.create() as sandbox:
+    sandbox.run_code("x = 1")
+    execution = sandbox.run_code("x += 1; x")
+    print(execution.text)  # 输出: 2
+```
+
+## 文档
+TODO
+访问 [Sandbox 文档](https://docs.sandbox.ucloudai.com) 获取更多信息。
+
+## 致谢
+
+本项目基于 [E2B](https://github.com/e2b-dev/e2b) 开源项目开发，感谢 E2B 团队的贡献。
+
+## 许可证
+
+MIT License - 详见 [LICENSE](./LICENSE) 文件

ucloud_sandbox-0.1.0b3/e2b_connect/__init__.py

@@ -0,0 +1 @@
+from .client import Client, GzipCompressor, ConnectException, Code  # noqa: F401

ucloud_sandbox-0.1.0b3/e2b_connect/client.py

@@ -0,0 +1,493 @@
+import gzip
+import inspect
+import json
+import struct
+import typing
+
+from httpcore import (
+    ConnectionPool,
+    AsyncConnectionPool,
+    RemoteProtocolError,
+    Response,
+)
+from enum import Flag, Enum
+from typing import Callable, Optional, Dict, Any, Generator, Tuple
+from google.protobuf import json_format
+
+
+class EnvelopeFlags(Flag):
+    compressed = 0b00000001
+    end_stream = 0b00000010
+
+
+class Code(Enum):
+    canceled = "canceled"
+    unknown = "unknown"
+    invalid_argument = "invalid_argument"
+    deadline_exceeded = "deadline_exceeded"
+    not_found = "not_found"
+    already_exists = "already_exists"
+    permission_denied = "permission_denied"
+    resource_exhausted = "resource_exhausted"
+    failed_precondition = "failed_precondition"
+    aborted = "aborted"
+    out_of_range = "out_of_range"
+    unimplemented = "unimplemented"
+    internal = "internal"
+    unavailable = "unavailable"
+    data_loss = "data_loss"
+    unauthenticated = "unauthenticated"
+
+
+def make_error_from_http_code(http_code: int):
+    error_code_map = {
+        400: Code.invalid_argument,
+        401: Code.unauthenticated,
+        403: Code.permission_denied,
+        404: Code.not_found,
+        409: Code.already_exists,
+        413: Code.resource_exhausted,
+        429: Code.resource_exhausted,
+        499: Code.canceled,
+        500: Code.internal,
+        501: Code.unimplemented,
+        502: Code.unavailable,
+        503: Code.unavailable,
+        504: Code.deadline_exceeded,
+        505: Code.unimplemented,
+    }
+
+    return error_code_map.get(http_code, Code.unknown)
+
+
+class ConnectException(Exception):
+    def __init__(self, status: Code, message: str):
+        self.status = status
+        self.message = message
+
+
+envelope_header_length = 5
+envelope_header_pack = ">BI"
+
+
+def encode_envelope(*, flags: EnvelopeFlags, data):
+    return encode_envelope_header(flags=flags.value, data=data) + data
+
+
+def encode_envelope_header(*, flags, data):
+    return struct.pack(envelope_header_pack, flags, len(data))
+
+
+def decode_envelope_header(header):
+    flags, data_len = struct.unpack(envelope_header_pack, header)
+    return EnvelopeFlags(flags), data_len
+
+
+def error_for_response(http_resp: Response):
+    try:
+        error = json.loads(http_resp.content)
+        return make_error(error)
+    except (json.decoder.JSONDecodeError, KeyError):
+        error = {"code": http_resp.status, "message": http_resp.content.decode("utf-8")}
+        return make_error(error)
+
+
+def make_error(error):
+    status = None
+    try:
+        code_value = error.get("code")
+        # return error code from http status code
+        if isinstance(code_value, int):
+            status = make_error_from_http_code(code_value)
+        else:
+            status = Code(code_value)
+    except (KeyError, ValueError):
+        status = Code.unknown
+
+    return ConnectException(status, error.get("message", ""))
+
+
+def _sync_retry(func, exc, retries):
+    def retry(*args, **kwargs):
+        for _ in range(retries):
+            try:
+                return func(*args, **kwargs)
+            except exc:
+                continue
+
+        return func(*args, **kwargs)
+
+    return retry
+
+
+def _async_retry(func, exc, retries):
+    async def retry(*args, **kwargs):
+        for _ in range(retries):
+            try:
+                return await func(*args, **kwargs)
+            except exc:
+                continue
+
+        return await func(*args, **kwargs)
+
+    return retry
+
+
+def _retry(exc: typing.Type[Exception], retries: int):
+    def decorator(func):
+        if inspect.iscoroutinefunction(func):
+            return _async_retry(func, exc, retries)
+
+        return _sync_retry(func, exc, retries)
+
+    return decorator
+
+
+class GzipCompressor:
+    name = "gzip"
+    decompress = gzip.decompress
+    compress = gzip.compress
+
+
+class JSONCodec:
+    content_type = "json"
+
+    @staticmethod
+    def encode(msg):
+        return json_format.MessageToJson(msg).encode("utf8")
+
+    @staticmethod
+    def decode(data, *, msg_type):
+        msg = msg_type()
+        json_format.Parse(data.decode("utf8"), msg, ignore_unknown_fields=True)
+        return msg
+
+
+class ProtobufCodec:
+    content_type = "proto"
+
+    @staticmethod
+    def encode(msg):
+        return msg.SerializeToString()
+
+    @staticmethod
+    def decode(data, *, msg_type):
+        msg = msg_type()
+        msg.ParseFromString(data)
+        return msg
+
+
+class Client:
+    def __init__(
+        self,
+        *,
+        pool: Optional[ConnectionPool] = None,
+        async_pool: Optional[AsyncConnectionPool] = None,
+        url: str,
+        response_type,
+        compressor=None,
+        json: Optional[bool] = False,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        if headers is None:
+            headers = {}
+
+        self.pool = pool
+        self.async_pool = async_pool
+        self.url = url
+        self._codec = JSONCodec if json else ProtobufCodec
+        self._response_type = response_type
+        self._compressor = compressor
+        self._headers = headers
+        self._connection_retries = 3
+
+    def _prepare_unary_request(
+        self,
+        req,
+        request_timeout=None,
+        headers: Optional[dict] = None,
+        **opts,
+    ) -> dict:
+        data = self._codec.encode(req)
+
+        if self._compressor is not None:
+            data = self._compressor.compress(data)
+
+        if headers is None:
+            headers = {}
+
+        extensions = (
+            None
+            if request_timeout is None
+            else {
+                "timeout": {
+                    "connect": request_timeout,
+                    "pool": request_timeout,
+                    "read": request_timeout,
+                    "write": request_timeout,
+                }
+            }
+        )
+
+        return {
+            "method": "POST",
+            "url": self.url,
+            "content": data,
+            "extensions": extensions,
+            "headers": {
+                **self._headers,
+                **headers,
+                **opts.get("headers", {}),
+                "connect-protocol-version": "1",
+                "content-encoding": (
+                    "identity" if self._compressor is None else self._compressor.name
+                ),
+                "content-type": f"application/{self._codec.content_type}",
+            },
+        }
+
+    def _process_unary_response(
+        self,
+        http_resp: Response,
+    ):
+        if http_resp.status != 200:
+            raise error_for_response(http_resp)
+
+        content = http_resp.content
+
+        if self._compressor is not None:
+            content = self._compressor.decompress(content)
+
+        return self._codec.decode(
+            content,
+            msg_type=self._response_type,
+        )
+
+    @_retry(RemoteProtocolError, 3)
+    async def acall_unary(
+        self,
+        req,
+        request_timeout=None,
+        headers: Optional[dict] = None,
+        **opts,
+    ):
+        if self.async_pool is None:
+            raise ValueError("async_pool is required")
+
+        req_data = self._prepare_unary_request(
+            req,
+            request_timeout,
+            headers,
+            **opts,
+        )
+
+        res = await self.async_pool.request(**req_data)
+        return self._process_unary_response(res)
+
+    @_retry(RemoteProtocolError, 3)
+    def call_unary(
+        self,
+        req,
+        request_timeout=None,
+        headers: Optional[dict] = None,
+        **opts,
+    ):
+        if self.pool is None:
+            raise ValueError("pool is required")
+
+        req_data = self._prepare_unary_request(
+            req,
+            request_timeout,
+            headers,
+            **opts,
+        )
+
+        res = self.pool.request(**req_data)
+        return self._process_unary_response(res)
+
+    def _create_stream_timeout(self, timeout: Optional[int]):
+        if timeout:
+            return {"connect-timeout-ms": str(timeout * 1000)}
+        return {}
+
+    def _prepare_server_stream_request(
+        self,
+        req,
+        request_timeout=None,
+        timeout=None,
+        headers: Optional[dict] = None,
+        **opts,
+    ) -> dict:
+        headers = headers or {}
+        data = self._codec.encode(req)
+        flags = EnvelopeFlags(0)
+
+        extensions = (
+            None
+            if request_timeout is None
+            else {"timeout": {"connect": request_timeout, "pool": request_timeout}}
+        )
+
+        if self._compressor is not None:
+            data = self._compressor.compress(data)
+            flags |= EnvelopeFlags.compressed
+
+        stream_timeout = self._create_stream_timeout(timeout)
+
+        return {
+            "method": "POST",
+            "url": self.url,
+            "content": encode_envelope(
+                flags=flags,
+                data=data,
+            ),
+            "extensions": extensions,
+            "headers": {
+                **self._headers,
+                **headers,
+                **opts.get("headers", {}),
+                **stream_timeout,
+                "connect-protocol-version": "1",
+                "connect-content-encoding": (
+                    "identity" if self._compressor is None else self._compressor.name
+                ),
+                "content-type": f"application/connect+{self._codec.content_type}",
+            },
+        }
+
+    @_retry(RemoteProtocolError, 3)
+    async def acall_server_stream(
+        self,
+        req,
+        request_timeout=None,
+        timeout=None,
+        headers: Optional[dict] = None,
+        **opts,
+    ):
+        if self.async_pool is None:
+            raise ValueError("async_pool is required")
+
+        req_data = self._prepare_server_stream_request(
+            req,
+            request_timeout,
+            timeout,
+            headers,
+            **opts,
+        )
+
+        parser = ServerStreamParser(
+            decode=self._codec.decode,
+            response_type=self._response_type,
+        )
+
+        async with self.async_pool.stream(**req_data) as http_resp:
+            if http_resp.status != 200:
+                await http_resp.aread()
+                raise error_for_response(http_resp)
+
+            async for chunk in http_resp.aiter_stream():
+                for parsed in parser.parse(chunk):
+                    yield parsed
+
+    @_retry(RemoteProtocolError, 3)
+    def call_server_stream(
+        self,
+        req,
+        request_timeout=None,
+        timeout=None,
+        headers: Optional[dict] = None,
+        **opts,
+    ):
+        if self.pool is None:
+            raise ValueError("pool is required")
+
+        req_data = self._prepare_server_stream_request(
+            req,
+            request_timeout,
+            timeout,
+            headers,
+            **opts,
+        )
+
+        parser = ServerStreamParser(
+            decode=self._codec.decode,
+            response_type=self._response_type,
+        )
+
+        with self.pool.stream(**req_data) as http_resp:
+            if http_resp.status != 200:
+                http_resp.read()
+                raise error_for_response(http_resp)
+
+            for chunk in http_resp.iter_stream():
+                for parsed in parser.parse(chunk):
+                    yield parsed
+
+    def call_client_stream(self, req, **opts):
+        raise NotImplementedError("client stream not supported")
+
+    def acall_client_stream(self, req, **opts):
+        raise NotImplementedError("client stream not supported")
+
+    def call_bidi_stream(self, req, **opts):
+        raise NotImplementedError("bidi stream not supported")
+
+    def acall_bidi_stream(self, req, **opts):
+        raise NotImplementedError("bidi stream not supported")
+
+
+DataLen = int
+
+
+class ServerStreamParser:
+    def __init__(
+        self,
+        decode: Callable,
+        response_type: Any,
+    ):
+        self.decode = decode
+        self.response_type = response_type
+
+        self.buffer: bytes = b""
+        self._header: Optional[tuple[EnvelopeFlags, DataLen]] = None
+
+    def shift_buffer(self, size: int):
+        buffer = self.buffer[:size]
+        self.buffer = self.buffer[size:]
+        return buffer
+
+    @property
+    def header(self) -> Tuple[EnvelopeFlags, DataLen]:
+        if self._header:
+            return self._header
+
+        header_data = self.shift_buffer(envelope_header_length)
+        self._header = decode_envelope_header(header_data)
+
+        return self._header
+
+    @header.deleter
+    def header(self):
+        self._header = None
+
+    def parse(self, chunk: bytes) -> Generator[Any, None, None]:
+        self.buffer += chunk
+
+        while len(self.buffer) >= envelope_header_length:
+            flags, data_len = self.header
+
+            if data_len > len(self.buffer):
+                break
+
+            data = self.shift_buffer(data_len)
+
+            if EnvelopeFlags.end_stream in flags:
+                data = json.loads(data)
+
+                if "error" in data:
+                    raise make_error(data["error"])
+
+                return
+
+            yield self.decode(data, msg_type=self.response_type)
+            del self.header

ucloud_sandbox-0.1.0b3/pyproject.toml

@@ -0,0 +1,46 @@
+[tool.poetry]
+name = "ucloud_sandbox"
+version = "0.1.0-beta3"
+description = "UCloud Sandbox SDK - Cloud sandbox environments for AI agents"
+authors = ["UCloud <support@ucloud.cn>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://ucloud.cn/"
+repository = "https://github.com/ucloud/ucloud-sandbox-sdk"
+packages = [{ include = "ucloud_sandbox" }, { include = "e2b_connect" }]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+python-dateutil = ">=2.8.2"
+wcmatch = "^10.1"
+protobuf = ">=4.21.0"
+httpcore = "^1.0.5"
+httpx = ">=0.27.0, <1.0.0"
+attrs = ">=23.2.0"
+packaging = ">=24.1"
+typing-extensions = ">=4.1.0"
+dockerfile-parse = "^2.0.1"
+rich = ">=14.0.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.0"
+pytest-xdist = "^3.3.1"
+python-dotenv = "^1.0.0"
+pytest-dotenv = "^0.5.2"
+pytest-asyncio = "^0.23.7"
+pydoc-markdown = "^4.8.2"
+datamodel-code-generator = "^0.34.0"
+ruff = "^0.11.12"
+pytest-timeout = "^2.4.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.urls]
+"Bug Tracker" = "https://github.com/ucloud/ucloud-sandbox-sdk/issues"
+
+[tool.ruff]
+exclude = [
+    "ucloud_sandbox/envd/filesystem/filesystem_pb2.py"
+]