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

scalebox/test/test_connect_pause_sync.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""
+Test cases for connect and pause functionality (synchronous version).
+
+This test suite validates:
+- Creating a sandbox
+- Adding and deleting files before pause
+- Pausing the sandbox
+- Connecting to the paused sandbox
+- Verifying file operations after connect
+"""
+
+import time
+
+from scalebox.sandbox.filesystem.filesystem import WriteInfo, FileType
+from scalebox.sandbox_sync.main import Sandbox
+
+
+class ConnectPauseSyncTest:
+    """Test suite for connect and pause functionality (sync)."""
+
+    def __init__(self):
+        self.sandbox = None
+        self.sandbox_id = None
+        self.test_results = []
+
+    def log_test_result(self, test_name: str, success: bool, message: str = ""):
+        """记录测试结果"""
+        status = "✅ PASS" if success else "❌ FAIL"
+        result = {
+            "test": test_name,
+            "success": success,
+            "message": message,
+        }
+        self.test_results.append(result)
+        print(f"{status} {test_name}: {message}")
+
+    def test_connect_pause_with_files(self):
+        """测试connect和pause功能，包含文件操作"""
+        try:
+            # 1. 创建沙箱
+            print("Step 1: Creating sandbox...")
+            self.sandbox = Sandbox.create(
+                template="code-interpreter",
+                timeout=3600,
+                metadata={"test": "connect_pause_sync"},
+                envs={"TEST_ENV": "sync_test"},
+            )
+            self.sandbox_id = self.sandbox.sandbox_id
+            assert self.sandbox is not None
+            assert self.sandbox_id is not None
+            print(f"Created sandbox with ID: {self.sandbox_id}")
+
+            # 2. 在pause之前增加文件
+            print("Step 2: Adding files before pause...")
+            test_files = {
+                "/tmp/test_file1.txt": "Content of test file 1",
+                "/tmp/test_file2.txt": "Content of test file 2",
+                "/tmp/test_file3.bin": b"Binary content for test file 3",
+            }
+
+            for file_path, content in test_files.items():
+                result = self.sandbox.files.write(file_path, content)
+                print(result)
+                assert isinstance(result, WriteInfo)
+                assert self.sandbox.files.exists(file_path)
+                print(f"Created file: {file_path}")
+
+            # 3. 在pause之前删除一个文件
+            print("Step 3: Deleting a file before pause...")
+            file_to_delete = "/tmp/test_file2.txt"
+            self.sandbox.files.remove(file_to_delete)
+            assert not self.sandbox.files.exists(file_to_delete)
+            print(f"Deleted file: {file_to_delete}")
+
+            # 4. 创建目录和文件
+            print("Step 4: Creating directory and nested files...")
+            self.sandbox.files.make_dir("/tmp/test_dir")
+            self.sandbox.files.write(
+                "/tmp/test_dir/nested_file.txt", "Nested file content"
+            )
+            assert self.sandbox.files.exists("/tmp/test_dir")
+            assert self.sandbox.files.exists("/tmp/test_dir/nested_file.txt")
+            print("Created directory and nested file")
+
+            # 5. Pause沙箱
+            print("Step 5: Pausing sandbox...")
+            self.sandbox.beta_pause()
+            print("Sandbox paused successfully")
+
+            # 等待一小段时间确保pause完成
+            time.sleep(1)
+
+            # 6. Connect到暂停的沙箱
+            print("Step 6: Connecting to paused sandbox...")
+            connected_sandbox = Sandbox.connect(self.sandbox_id)
+            print(connected_sandbox)
+            assert connected_sandbox.sandbox_id == self.sandbox_id
+            print("Connected to sandbox successfully")
+
+            # 等待一小段时间确保connect完成
+            time.sleep(2)
+
+            # 7. 在connect之后校验文件操作结果
+            print("Step 7: Verifying file operations after connect...")
+
+            # 校验应该存在的文件
+            assert connected_sandbox.files.exists(
+                "/tmp/test_file1.txt"
+            ), "test_file1.txt should exist"
+            file1_content = connected_sandbox.files.read(
+                "/tmp/test_file1.txt", format="text"
+            )
+            assert "Content of test file 1" in file1_content
+            print("✅ Verified test_file1.txt exists and content is correct")
+
+            assert connected_sandbox.files.exists(
+                "/tmp/test_file3.bin"
+            ), "test_file3.bin should exist"
+            file3_content = connected_sandbox.files.read(
+                "/tmp/test_file3.bin", format="bytes"
+            )
+            assert bytes(file3_content) == b"Binary content for test file 3"
+            print("✅ Verified test_file3.bin exists and content is correct")
+
+            # 校验应该不存在的文件（被删除的）
+            assert not connected_sandbox.files.exists(
+                "/tmp/test_file2.txt"
+            ), "test_file2.txt should not exist"
+            print("✅ Verified test_file2.txt was deleted correctly")
+
+            # 校验目录和嵌套文件
+            assert connected_sandbox.files.exists(
+                "/tmp/test_dir"
+            ), "test_dir should exist"
+            assert connected_sandbox.files.exists(
+                "/tmp/test_dir/nested_file.txt"
+            ), "nested_file.txt should exist"
+            nested_content = connected_sandbox.files.read(
+                "/tmp/test_dir/nested_file.txt", format="text"
+            )
+            assert "Nested file content" in nested_content
+            print("✅ Verified directory and nested file exist and content is correct")
+
+            # 8. 在connect后的沙箱中执行一些操作验证功能正常
+            print("Step 8: Verifying sandbox functionality after connect...")
+            result = connected_sandbox.commands.run("echo 'Test command after connect'")
+            assert result.exit_code == 0
+            assert "Test command after connect" in result.stdout
+            print("✅ Verified sandbox commands work after connect")
+
+            # 9. 创建新文件验证写入功能正常
+            print("Step 9: Testing file write after connect...")
+            new_file_path = "/tmp/new_file_after_connect.txt"
+            connected_sandbox.files.write(
+                new_file_path, "New file created after connect"
+            )
+            assert connected_sandbox.files.exists(new_file_path)
+            new_content = connected_sandbox.files.read(new_file_path, format="text")
+            assert "New file created after connect" in new_content
+            print("✅ Verified file write works after connect")
+
+            self.log_test_result(
+                "Connect and Pause with Files", True, "All verifications passed"
+            )
+            return True
+
+        except Exception as e:
+            self.log_test_result("Connect and Pause with Files", False, str(e))
+            print(f"Test failed with error: {e}")
+            import traceback
+
+            traceback.print_exc()
+            return False
+
+    def test_connect_pause_multiple_operations(self):
+        """测试多次pause和connect操作"""
+        try:
+            # 1. 创建沙箱
+            print("Test 2: Creating sandbox for multiple operations test...")
+            sandbox = Sandbox.create(
+                template="base",
+                timeout=3600,
+                metadata={"test": "connect_pause_multiple_sync"},
+            )
+            sandbox_id = sandbox.sandbox_id
+            print(f"Created sandbox with ID: {sandbox_id}")
+
+            # 2. 第一次操作：创建文件
+            print("First operation: Creating files...")
+            sandbox.files.write("/tmp/multi_test1.txt", "First batch")
+            sandbox.files.write("/tmp/multi_test2.txt", "First batch")
+
+            # 3. 第一次pause
+            print("First pause...")
+            sandbox.beta_pause()
+            time.sleep(2)
+
+            # 4. 第一次connect
+            print("First connect...")
+            sandbox = Sandbox.connect(sandbox_id)
+            time.sleep(2)
+
+            # 5. 验证第一次的文件存在
+            assert sandbox.files.exists("/tmp/multi_test1.txt")
+            assert sandbox.files.exists("/tmp/multi_test2.txt")
+
+            # 6. 第二次操作：删除一个文件，创建新文件
+            print("Second operation: Deleting and creating files...")
+            sandbox.files.remove("/tmp/multi_test1.txt")
+            sandbox.files.write("/tmp/multi_test3.txt", "Second batch")
+
+            # 7. 第二次pause
+            print("Second pause...")
+            sandbox.beta_pause()
+            time.sleep(2)
+
+            # 8. 第二次connect
+            print("Second connect...")
+            sandbox = Sandbox.connect(sandbox_id)
+            time.sleep(2)
+
+            # 9. 验证第二次操作的结果
+            assert not sandbox.files.exists(
+                "/tmp/multi_test1.txt"
+            ), "multi_test1.txt should be deleted"
+            assert sandbox.files.exists(
+                "/tmp/multi_test2.txt"
+            ), "multi_test2.txt should exist"
+            assert sandbox.files.exists(
+                "/tmp/multi_test3.txt"
+            ), "multi_test3.txt should exist"
+            content = sandbox.files.read("/tmp/multi_test3.txt", format="text")
+            assert "Second batch" in content
+
+            # 清理
+            sandbox.kill()
+
+            self.log_test_result(
+                "Multiple Connect and Pause Operations",
+                True,
+                "All verifications passed",
+            )
+            return True
+
+        except Exception as e:
+            self.log_test_result("Multiple Connect and Pause Operations", False, str(e))
+            print(f"Test failed with error: {e}")
+            import traceback
+
+            traceback.print_exc()
+            return False
+
+    def cleanup(self):
+        """清理资源"""
+        if self.sandbox:
+            try:
+                self.sandbox.kill()
+                print("Sandbox cleaned up successfully")
+            except Exception as e:
+                print(f"Error cleaning up sandbox: {e}")
+
+    def print_summary(self):
+        """打印测试摘要"""
+        total_tests = len(self.test_results)
+        passed_tests = sum(1 for r in self.test_results if r["success"])
+        failed_tests = total_tests - passed_tests
+
+        print("\n" + "=" * 60)
+        print("Connect and Pause Test Report (Sync)")
+        print("=" * 60)
+        print(f"总测试数: {total_tests}")
+        print(f"通过数: {passed_tests}")
+        print(f"失败数: {failed_tests}")
+        print(f"成功率: {(passed_tests/total_tests*100):.1f}%")
+
+        if failed_tests > 0:
+            print(f"\n失败的测试:")
+            for result in self.test_results:
+                if not result["success"]:
+                    print(f"  ❌ {result['test']}: {result['message']}")
+
+        print("=" * 60)
+
+
+def main():
+    """主函数"""
+    test_suite = ConnectPauseSyncTest()
+
+    try:
+        # 运行测试
+        test_suite.test_connect_pause_with_files()
+        # test_suite.test_connect_pause_multiple_operations()
+    finally:
+        test_suite.cleanup()
+        test_suite.print_summary()
+
+
+if __name__ == "__main__":
+    main()

scalebox/test/test_csx_desktop_examples.py

@@ -18,7 +18,9 @@ class CsxDesktopValidator:
         self.success_count = 0
         self.fail_count = 0
 
-    def log_test_result(self, name: str, success: bool, error: Optional[Exception] = None) -> None:
+    def log_test_result(
+        self, name: str, success: bool, error: Optional[Exception] = None
+    ) -> None:
         if success:
             self.success_count += 1
             print(f"✅ {name}")
@@ -126,5 +128,3 @@ if __name__ == "__main__":
     finally:
         validator.cleanup()
         validator.print_summary()
-
-

scalebox/test/test_desktop_sandbox_sf.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+测试用例：基于desktop创建sandbox，上传并执行test_sf.py
+"""
+
+import os
+import re
+import sys
+import time
+
+# 确保可以从项目根导入 scalebox
+from scalebox.csx_desktop.main import Sandbox
+
+
+def main():
+    """主测试函数"""
+    print("=" * 60)
+    print("开始测试：基于desktop创建sandbox并执行test_sf.py")
+    print("=" * 60)
+
+    # 1. 基于desktop创建sandbox
+    print("\n[步骤 1] 正在创建desktop sandbox...")
+    sandbox = Sandbox.create(
+        template="browser-use",
+        timeout=3600,  # 1小时超时
+    )
+    print(f"✓ Sandbox创建成功，ID: {sandbox.sandbox_id}")
+
+    # 2. 获取network_proxy
+    print("\n[步骤 2] 获取network_proxy...")
+    network_proxy = sandbox.network_proxy()
+    print(f"✓ Network Proxy: {network_proxy}")
+
+    # 3. 获取VNC URL（不启动，直接获取）
+    print("\n[步骤 3] 获取VNC URL...")
+    vnc_url = sandbox.stream.get_url(auto_connect=True)
+    print(f"✓ VNC URL: {vnc_url}")
+
+    # 4. 读取test_sf.py并修改username和password
+    print("\n[步骤 4] 读取并修改test_sf.py...")
+    test_sf_path = os.path.join(os.path.dirname(__file__), "test_sf.py")
+
+    with open(test_sf_path, "r", encoding="utf-8") as f:
+        test_sf_content = f.read()
+
+    # 从network_proxy中提取username和password
+    if network_proxy and isinstance(network_proxy, dict):
+        # network_proxy结构: {'proxy_configs': {'username': '...', 'password': '...', ...}, ...}
+        proxy_configs = network_proxy.get("proxy_configs", {})
+        if isinstance(proxy_configs, dict):
+            proxy_username = proxy_configs.get("username", "")
+            proxy_password = proxy_configs.get("password", "")
+        else:
+            # 兼容旧格式：直接在network_proxy中
+            proxy_username = network_proxy.get("username", "")
+            proxy_password = network_proxy.get("password", "")
+
+        if not proxy_username or not proxy_password:
+            print("⚠ 警告: network_proxy中缺少username或password字段")
+            print(f"  network_proxy内容: {network_proxy}")
+        else:
+            # 替换test_sf.py中的username和password
+            # 匹配proxy字典中的username和password（处理可能的引号差异）
+            pattern_username = r'"username"\s*:\s*"[^"]*"'
+            pattern_password = r'"password"\s*:\s*"[^"]*"'
+
+            test_sf_content = re.sub(
+                pattern_username, f'"username": "{proxy_username}"', test_sf_content
+            )
+            test_sf_content = re.sub(
+                pattern_password, f'"password": "{proxy_password}"', test_sf_content
+            )
+
+            print(f"✓ 已更新username: {proxy_username}")
+            print(f"✓ 已更新password: {proxy_password[:20]}...")
+    else:
+        print("⚠ 警告: network_proxy为空或格式不正确，跳过修改")
+        print(f"  network_proxy类型: {type(network_proxy)}, 值: {network_proxy}")
+
+    # 5. 上传test_sf.py到sandbox的/目录
+    print("\n[步骤 5] 上传test_sf.py到sandbox的/目录...")
+    result = sandbox.files.write("/test_sf.py", test_sf_content.encode("utf-8"))
+    print(f"✓ 文件上传成功: {result.path}")
+
+    # 6. 在sandbox中执行命令
+    print("\n[步骤 6] 在sandbox中执行: source /venv/bin/activate && python /test_sf.py")
+    try:
+        # 使用bash -c确保source命令和环境变量正确加载
+        result = sandbox.commands.run(
+            'bash -c "source /venv/bin/activate && python /test_sf.py"',
+            timeout=600,  # 10分钟超时
+        )
+        print(f"✓ 命令执行完成")
+        print(f"退出码: {result.exit_code}")
+        print(f"标准输出:\n{result.stdout}")
+        if result.stderr:
+            print(f"标准错误:\n{result.stderr}")
+    except Exception as e:
+        print(f"✗ 命令执行失败: {e}")
+        raise
+
+    print("\n" + "=" * 60)
+    print("测试完成！")
+    print("=" * 60)
+
+    # 清理（可选，注释掉以保留sandbox）
+    # sandbox.kill()
+    # print("Sandbox已清理")
+
+
+if __name__ == "__main__":
+    main()

scalebox/test/test_download_url.py

@@ -0,0 +1,41 @@
+from scalebox.code_interpreter import Sandbox
+import json
+
+# 1. 准备要上传的文件内容
+print("正在准备文件内容...")
+results_data = {
+    "experiment_id": "exp_001",
+    "status": "completed",
+    "metrics": {"accuracy": 0.952, "precision": 0.94, "recall": 0.96},
+    "timestamp": "2024-01-01T12:00:00Z",
+    "details": [
+        {"epoch": 1, "loss": 0.45},
+        {"epoch": 2, "loss": 0.32},
+        {"epoch": 3, "loss": 0.18},
+    ],
+}
+
+# 转换为 JSON 字符串
+json_content = json.dumps(results_data, indent=2)
+
+# 2. 创建沙箱并写入文件
+print("\n正在创建沙箱并写入文件...")
+sandbox = Sandbox.create(timeout=1800)
+remote_path = "/home/user/results.json"
+
+# 关键修改：使用 sandbox.write() 写入文件
+sandbox.files.write(remote_path, json_content)
+print(f"✅ 文件已写入沙箱: {remote_path}")
+
+# 3. 获取预签名下载 URL
+print("\n正在生成下载链接...")
+download_url = sandbox.download_url(
+    path=remote_path, use_signature_expiration=180  # 180秒有效期
+)
+
+print(f"\n📥 下载 URL: {download_url}")
+print(f"⏰ 链接将在 3 分钟后过期")
+
+upload_url = sandbox.upload_url(path="/home/user", use_signature_expiration=360)
+print(f"\n📥 上传 URL: {upload_url}")
+print(f"⏰ 链接将在 6 分钟后过期")