scalebox-sdk 0.1.25__py3-none-any.whl → 1.0.2__py3-none-any.whl

scalebox/test/bedrock_openai_adapter.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""
+OpenAI-compatible adapter for Amazon Bedrock Claude 3.7 Sonnet
+POST /v1/chat/completions  ->  Bedrock invoke-model
+"""
+import json, boto3, os
+from fastapi import FastAPI, Response, status
+from pydantic import BaseModel
+from typing import List, Dict  # <- 修正语法
+
+app = FastAPI()
+BEDROCK = boto3.client("bedrock-runtime", region_name="us-east-1")
+MODEL_ID = "us.anthropic.claude-3-7-sonnet-20250219-v1:0"
+
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+
+class ChatRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    max_tokens: int = 4096
+    temperature: float = 0.1
+
+
+@app.post("/v1/chat/completions")
+def chat_completions(req: ChatRequest):
+    # 1. OpenAI -> Claude 格式
+    claude_body = {
+        "anthropic_version": "bedrock-2023-05-31",
+        "max_tokens": req.max_tokens,
+        "temperature": req.temperature,
+        "messages": [{"role": m.role, "content": m.content} for m in req.messages],
+    }
+    # 2. 调 Bedrock
+    response = BEDROCK.invoke_model(
+        modelId=MODEL_ID,
+        body=json.dumps(claude_body),
+        contentType="application/json",
+    )
+    # 3. 解析 Claude 响应
+    result = json.loads(response["body"].read())
+    text = result["content"][0]["text"]
+
+    # 4. 伪装成 OpenAI 格式返回
+    openai_reply = {
+        "id": "chatcmpl-bedrock",
+        "object": "chat.completion",
+        "created": 1234567890,
+        "model": "gpt-4",
+        "choices": [
+            {
+                "index": 0,
+                "message": {"role": "assistant", "content": text},
+                "finish_reason": "stop",
+            }
+        ],
+    }
+    return Response(content=json.dumps(openai_reply), media_type="application/json")
+
+
+# 健康检查
+@app.get("/v1/models")
+def models():
+    return {"data": [{"id": "gpt-4", "object": "model"}]}
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

scalebox/test/code_interpreter_test.py

@@ -1,34 +1,34 @@
-import asyncio
-import time
-
-from scalebox.code_interpreter import AsyncSandbox
-
-# from scalebox.sandbox_async.main import AsyncSandbox
-
-
-async def pty_output_handler(output):
-    """处理 PTY 输出的回调函数"""
-    print(f"输出: {output}")
-
-
-async def main():
-    sandbox = AsyncSandbox.create()
-    proc = await sandbox.run_code(
-        """
-import time
-for i in range(3):
-    print("Hello Scalebox", i)
-    time.sleep(50)
-""",
-        language="python3",
-        request_timeout=3600,
-        on_stdout=pty_output_handler,
-        on_stderr=pty_output_handler,
-        on_result=pty_output_handler,
-    )
-    print(proc)
-    time.sleep(10)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
+import asyncio
+import time
+
+from scalebox.code_interpreter import AsyncSandbox
+
+# from scalebox.sandbox_async.main import AsyncSandbox
+
+
+async def pty_output_handler(output):
+    """处理 PTY 输出的回调函数"""
+    print(f"输出: {output}")
+
+
+async def main():
+    sandbox = AsyncSandbox.create()
+    proc = await sandbox.run_code(
+        """
+import time
+for i in range(3):
+    print("Hello Scalebox", i)
+    time.sleep(50)
+""",
+        language="python3",
+        request_timeout=3600,
+        on_stdout=pty_output_handler,
+        on_stderr=pty_output_handler,
+        on_result=pty_output_handler,
+    )
+    print(proc)
+    time.sleep(10)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

scalebox/test/code_interpreter_test_sync.py

@@ -1,34 +1,34 @@
-import asyncio
-import time
-
-from code_interpreter import Sandbox
-
-# from scalebox.sandbox_async.main import AsyncSandbox
-
-
-def pty_output_handler(output):
-    """处理 PTY 输出的回调函数"""
-    print(f"输出: {output}")
-
-
-def main():
-    sandbox = Sandbox()
-    proc = sandbox.run_code(
-        """
-import time
-for i in range(3):
-    print("Hello Scalebox", i)
-    time.sleep(50)
-""",
-        language="python3",
-        request_timeout=3600,
-        on_stdout=pty_output_handler,
-        on_stderr=pty_output_handler,
-        on_result=pty_output_handler,
-    )
-    print(proc)
-    time.sleep(10)
-
-
-if __name__ == "__main__":
-    main()
+import asyncio
+import time
+
+from code_interpreter import Sandbox
+
+# from scalebox.sandbox_async.main import AsyncSandbox
+
+
+def pty_output_handler(output):
+    """处理 PTY 输出的回调函数"""
+    print(f"输出: {output}")
+
+
+def main():
+    sandbox = Sandbox()
+    proc = sandbox.run_code(
+        """
+import time
+for i in range(3):
+    print("Hello Scalebox", i)
+    time.sleep(50)
+""",
+        language="python3",
+        request_timeout=3600,
+        on_stdout=pty_output_handler,
+        on_stderr=pty_output_handler,
+        on_result=pty_output_handler,
+    )
+    print(proc)
+    time.sleep(10)
+
+
+if __name__ == "__main__":
+    main()

scalebox/test/run_stress_code_interpreter_sync.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+import asyncio
+import os
+import sys
+import time
+from typing import Tuple
+import re
+
+
+REPO_ROOT = "/root/scalebox"
+TEST_FILE = os.path.join(
+    REPO_ROOT, "test", "test_code_interpreter_sync_comprehensive.py"
+)
+
+
+def _extract_final_report(stdout_text: str) -> str:
+    lines = stdout_text.splitlines()
+    if not lines:
+        return ""
+    # Prefer capturing from the last report title to include full details
+    title_indices = [
+        i
+        for i, line in enumerate(lines)
+        if "CodeInterpreter" in line and "测试报告" in line
+    ]
+    if title_indices:
+        start_idx = title_indices[-1]
+        return "\n".join(lines[start_idx:]).strip()
+    # Fallback: last long '====' separator block
+    sep_indices = [
+        i
+        for i, line in enumerate(lines)
+        if line.strip().startswith("=")
+        and set(line.strip()) == {"="}
+        and len(line.strip()) >= 20
+    ]
+    if sep_indices:
+        start_idx = sep_indices[-1]
+        return "\n".join(lines[start_idx:]).strip()
+    return stdout_text.strip()
+
+
+def _extract_sandbox_id(text: str) -> str:
+    # Common explicit patterns
+    patterns = [
+        r"sandbox[_\s-]*id\s*[:=]\s*([A-Za-z0-9_\-]+)",
+        r"Sandbox[_\s-]*ID\s*[:=]\s*([A-Za-z0-9_\-]+)",
+        r"sandbox\s*:\s*([A-Za-z0-9_\-]+)",
+        r"sandboxId\s*[:=]\s*([A-Za-z0-9_\-]+)",
+    ]
+    for pat in patterns:
+        m = re.search(pat, text, flags=re.IGNORECASE)
+        if m:
+            return m.group(1)
+    # UUID-like fallback
+    uuid_pat = r"\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\b"
+    m2 = re.search(uuid_pat, text)
+    if m2:
+        return m2.group(0)
+    # sbx_* style fallback
+    m3 = re.search(r"\bsbx_[A-Za-z0-9]+\b", text)
+    if m3:
+        return m3.group(0)
+    return ""
+
+
+async def run_once(run_id: int) -> Tuple[int, float, str, str]:
+    start = time.perf_counter()
+    process = await asyncio.create_subprocess_exec(
+        sys.executable,
+        TEST_FILE,
+        cwd=REPO_ROOT,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await process.communicate()
+    duration = time.perf_counter() - start
+    exit_code = process.returncode
+    result = "PASS" if exit_code == 0 else "FAIL"
+    stdout_text = stdout.decode(errors="ignore") if stdout else ""
+    stderr_text = stderr.decode(errors="ignore") if stderr else ""
+    report = _extract_final_report(stdout_text) or _extract_final_report(stderr_text)
+    if not report:
+        # Fallback to a brief tail if no recognizable report
+        tail = (stdout_text or stderr_text).strip().splitlines()[-10:]
+        report = "\n".join(tail).strip()
+    # Determine if success rate is effectively 0%
+    combined_text = "\n".join([report, stdout_text, stderr_text])
+    zero_rate = False
+    # Match ASCII/full-width colon and percent, and allow 0, 0.0, 0.00 etc.
+    if re.search(r"成功率\s*[：:]\s*0(?:\.0+)?\s*[％%]", combined_text):
+        zero_rate = True
+    else:
+        # Fallback by parsing totals if present (失败数 == 总测试数)
+        total_m = re.search(r"总测试数\s*[：:]\s*(\d+)", combined_text)
+        fail_m = re.search(r"失败数\s*[：:]\s*(\d+)", combined_text)
+        if total_m and fail_m:
+            try:
+                total_n = int(total_m.group(1))
+                fail_n = int(fail_m.group(1))
+                if total_n > 0 and fail_n == total_n:
+                    zero_rate = True
+            except ValueError:
+                pass
+
+    # If success rate is 0%, mark as FAIL and attach detailed errors
+    if zero_rate:
+        result = "FAIL"
+        stderr_lines = stderr_text.strip().splitlines()
+        stdout_lines = stdout_text.strip().splitlines()
+        # Extract sandbox id from combined text
+        sandbox_id = _extract_sandbox_id(combined_text)
+        detail = []
+        if sandbox_id:
+            detail.append(f"Sandbox ID: {sandbox_id}")
+        if stderr_lines:
+            detail.append("[stderr]")
+            detail.extend(stderr_lines)
+        if stdout_lines:
+            detail.append("[stdout]")
+            detail.extend(stdout_lines)
+        if detail:
+            report = f"{report}\n\n" + "\n".join(detail)
+    return run_id, duration, result, report
+
+
+async def run_concurrent(concurrency: int) -> None:
+    if not os.path.isfile(TEST_FILE):
+        print(f"Test file not found: {TEST_FILE}")
+        sys.exit(2)
+
+    tasks = [asyncio.create_task(run_once(i + 1)) for i in range(concurrency)]
+
+    started_at = time.perf_counter()
+    completed = 0
+    passed = 0
+    failed = 0
+
+    for coro in asyncio.as_completed(tasks):
+        run_id, duration, result, report = await coro
+        completed += 1
+        if result == "PASS":
+            passed += 1
+        else:
+            failed += 1
+        print(f"Run {run_id:03d}: {result} in {duration:.2f}s", flush=True)
+        if report:
+            print(report, flush=True)
+            print("-" * 64, flush=True)
+
+    total_time = time.perf_counter() - started_at
+    print("-" * 64)
+    print(
+        f"Completed: {completed}, Passed: {passed}, Failed: {failed}, Total time: {total_time:.2f}s"
+    )
+
+
+def main() -> None:
+    # Default concurrency to 80, but allow override via CLI
+    try:
+        concurrency = int(sys.argv[1]) if len(sys.argv) > 1 else 80
+    except ValueError:
+        print("First argument must be an integer concurrency level.")
+        sys.exit(2)
+
+    if concurrency <= 0:
+        print("Concurrency must be a positive integer.")
+        sys.exit(2)
+
+    # Use Proactor on Windows; default loop elsewhere
+    if sys.platform.startswith("win"):
+        asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())  # type: ignore[attr-defined]
+
+    asyncio.run(run_concurrent(concurrency))
+
+
+if __name__ == "__main__":
+    main()

scalebox/test/simple_upload_example.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""
+简单的 100MB 文件上传示例
+使用 sandbox_sync.filesystem.filesystem.py 上传文件到沙箱
+"""
+
+import os
+import time
+import logging
+from scalebox.sandbox_sync.main import Sandbox
+from scalebox.connection_config import ConnectionConfig
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+def create_test_file(file_path: str, size_mb: int = 100):
+    """创建指定大小的测试文件"""
+    logger.info(f"创建 {size_mb}MB 测试文件: {file_path}")
+
+    file_size = size_mb * 1024 * 1024  # 转换为字节
+    chunk_size = 1024 * 1024  # 1MB 块
+
+    with open(file_path, "wb") as f:
+        written = 0
+        while written < file_size:
+            # 生成测试数据
+            chunk_data = bytes(
+                [i % 256 for i in range(min(chunk_size, file_size - written))]
+            )
+            f.write(chunk_data)
+            written += len(chunk_data)
+
+            if written % (10 * 1024 * 1024) == 0:  # 每10MB显示进度
+                logger.info(f"进度: {written // (1024*1024)}MB")
+
+    logger.info(f"文件创建完成: {os.path.getsize(file_path) / (1024*1024):.2f}MB")
+
+
+def main():
+    """主函数 - 演示文件上传"""
+
+    # 1. 创建 100MB 测试文件
+    test_file = "/tmp/test_100mb.bin"
+    create_test_file(test_file, 100)
+
+    # 2. 创建沙箱连接配置
+    connection_config = ConnectionConfig(
+        debug=True, request_timeout=300.0  # 调试模式  # 5分钟超时
+    )
+
+    # 3. 创建沙箱实例
+    logger.info("连接沙箱...")
+    sandbox = Sandbox(
+        sandbox_id="upload_test_sandbox",
+        sandbox_domain=None,
+        envd_version="v1.0",
+        envd_access_token=None,
+        connection_config=connection_config,
+    )
+
+    try:
+        # 4. 检查沙箱状态
+        if not sandbox.is_running():
+            logger.error("沙箱未运行")
+            return
+
+        logger.info(f"沙箱连接成功: {sandbox.sandbox_id}")
+
+        # 5. 读取本地文件
+        logger.info("读取本地文件...")
+        start_time = time.time()
+
+        with open(test_file, "rb") as f:
+            file_data = f.read()
+
+        read_time = time.time() - start_time
+        logger.info(
+            f"文件读取完成: {len(file_data) / (1024*1024):.2f}MB, 耗时: {read_time:.2f}秒"
+        )
+
+        # 6. 上传文件到沙箱
+        logger.info("开始上传文件到沙箱...")
+        upload_start = time.time()
+
+        # 使用 filesystem.write 方法上传
+        result = sandbox.files.write("/tmp/uploaded_100mb.bin", file_data)
+
+        upload_time = time.time() - upload_start
+        logger.info(f"上传完成: {result.path}")
+        logger.info(f"上传耗时: {upload_time:.2f}秒")
+        logger.info(f"上传速度: {len(file_data) / (1024*1024) / upload_time:.2f} MB/s")
+
+        # 7. 验证上传结果
+        logger.info("验证上传结果...")
+
+        # 检查文件是否存在
+        if sandbox.files.exists("/tmp/uploaded_100mb.bin"):
+            logger.info("✅ 文件上传成功")
+
+            # 获取文件信息
+            file_info = sandbox.files.get_info("/tmp/uploaded_100mb.bin")
+            logger.info(f"文件信息: 路径={file_info.path}, 大小={file_info.size}字节")
+
+        else:
+            logger.error("❌ 文件上传失败")
+
+    except Exception as e:
+        logger.error(f"上传过程中发生错误: {e}")
+
+    finally:
+        # 8. 清理资源
+        try:
+            sandbox.kill()
+            logger.info("沙箱已清理")
+        except Exception as e:
+            logger.warning(f"清理沙箱时发生错误: {e}")
+
+        # 删除本地测试文件
+        try:
+            os.remove(test_file)
+            logger.info("本地测试文件已删除")
+        except Exception as e:
+            logger.warning(f"删除本地文件时发生错误: {e}")
+
+
+if __name__ == "__main__":
+    main()