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

scalebox/test/stabitiy_test.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""
+稳定性测试脚本 - 并发执行CodeInterpreter验证测试
+"""
+
+import concurrent.futures
+import time
+import json
+import logging
+import threading
+from typing import List, Dict, Any
+import sys
+import argparse
+
+# 导入原始测试代码
+from code_interpreter_validator import CodeInterpreterValidator
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - [%(threadName)s] - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+class StabilityTester:
+    """稳定性测试器"""
+
+    def __init__(self, concurrency: int = 10):
+        self.concurrency = concurrency
+        self.results = []
+        self.lock = threading.Lock()
+        self.test_counter = 0
+        self.total_tests = 0
+
+    def get_test_methods(self) -> List[str]:
+        """获取所有测试方法"""
+        validator = CodeInterpreterValidator()
+        test_methods = []
+
+        # 获取所有以test_开头的方法
+        for method_name in dir(validator):
+            if method_name.startswith('test_') and callable(getattr(validator, method_name)):
+                test_methods.append(method_name)
+
+        self.total_tests = len(test_methods)
+        logger.info(f"发现 {self.total_tests} 个测试方法")
+        return test_methods
+
+    def run_single_test(self, test_name: str) -> Dict[str, Any]:
+        """运行单个测试"""
+        thread_name = threading.current_thread().name
+        test_id = 0
+
+        with self.lock:
+            self.test_counter += 1
+            test_id = self.test_counter
+
+        logger.info(f"[线程 {thread_name}] 开始执行测试 {test_id}/{self.total_tests}: {test_name}")
+
+        start_time = time.time()
+        success = False
+        error_message = ""
+        duration = 0
+
+        try:
+            # 为每个测试创建独立的验证器实例
+            validator = CodeInterpreterValidator()
+
+            # 运行沙箱创建测试
+            validator.test_code_interpreter_creation()
+
+            # 运行目标测试
+            test_method = getattr(validator, test_name)
+            test_method()
+
+            duration = time.time() - start_time
+            success = True
+            logger.info(f"[线程 {thread_name}] ✅ 测试通过: {test_name} ({duration:.3f}s)")
+
+        except Exception as e:
+            duration = time.time() - start_time
+            error_message = str(e)
+            logger.error(f"[线程 {thread_name}] ❌ 测试失败: {test_name} - {error_message} ({duration:.3f}s)")
+
+        finally:
+            # 清理资源
+            try:
+                if 'validator' in locals():
+                    validator.cleanup()
+            except Exception as cleanup_error:
+                logger.warning(f"[线程 {thread_name}] 清理资源时出错: {cleanup_error}")
+
+        result = {
+            'test_id': test_id,
+            'test_name': test_name,
+            'thread_name': thread_name,
+            'success': success,
+            'error_message': error_message,
+            'duration': duration,
+            'timestamp': time.time()
+        }
+
+        with self.lock:
+            self.results.append(result)
+
+        return result
+
+    def run_concurrent_tests(self) -> Dict[str, Any]:
+        """运行并发测试"""
+        test_methods = self.get_test_methods()
+
+        if not test_methods:
+            logger.error("未发现测试方法")
+            return {}
+
+        logger.info(f"开始稳定性测试，并发数: {self.concurrency}")
+        logger.info(f"总测试数: {len(test_methods)}")
+
+        start_time = time.time()
+
+        # 使用线程池执行并发测试
+        with concurrent.futures.ThreadPoolExecutor(
+                max_workers=self.concurrency,
+                thread_name_prefix='TestWorker'
+        ) as executor:
+
+            # 提交所有测试任务
+            future_to_test = {
+                executor.submit(self.run_single_test, test_name): test_name
+                for test_name in test_methods
+            }
+
+            # 等待所有测试完成
+            completed = 0
+            for future in concurrent.futures.as_completed(future_to_test):
+                test_name = future_to_test[future]
+                try:
+                    future.result()
+                except Exception as exc:
+                    logger.error(f"测试 {test_name} 生成异常: {exc}")
+                completed += 1
+                logger.info(f"测试进度: {completed}/{len(test_methods)}")
+
+        total_duration = time.time() - start_time
+
+        # 生成测试报告
+        report = self.generate_report(total_duration)
+
+        return report
+
+    def generate_report(self, total_duration: float) -> Dict[str, Any]:
+        """生成测试报告"""
+        successful_tests = [r for r in self.results if r['success']]
+        failed_tests = [r for r in self.results if not r['success']]
+
+        total_tests = len(self.results)
+        success_count = len(successful_tests)
+        failure_count = len(failed_tests)
+        success_rate = (success_count / total_tests * 100) if total_tests > 0 else 0
+
+        # 计算统计信息
+        durations = [r['duration'] for r in self.results]
+        avg_duration = sum(durations) / len(durations) if durations else 0
+        max_duration = max(durations) if durations else 0
+        min_duration = min(durations) if durations else 0
+
+        report = {
+            'summary': {
+                'total_tests': total_tests,
+                'successful_tests': success_count,
+                'failed_tests': failure_count,
+                'success_rate': round(success_rate, 2),
+                'total_duration': round(total_duration, 3),
+                'concurrency': self.concurrency,
+                'avg_duration_per_test': round(avg_duration, 3),
+                'max_duration': round(max_duration, 3),
+                'min_duration': round(min_duration, 3)
+            },
+            'successful_tests': [
+                {
+                    'test_name': r['test_name'],
+                    'duration': round(r['duration'], 3),
+                    'thread': r['thread_name']
+                } for r in successful_tests
+            ],
+            'failed_tests': [
+                {
+                    'test_name': r['test_name'],
+                    'error': r['error_message'],
+                    'duration': round(r['duration'], 3),
+                    'thread': r['thread_name']
+                } for r in failed_tests
+            ],
+            'execution_timeline': [
+                {
+                    'test_id': r['test_id'],
+                    'test_name': r['test_name'],
+                    'thread': r['thread_name'],
+                    'success': r['success'],
+                    'duration': round(r['duration'], 3),
+                    'timestamp': r['timestamp']
+                } for r in self.results
+            ]
+        }
+
+        return report
+
+    def print_detailed_report(self, report: Dict[str, Any]):
+        """打印详细报告"""
+        summary = report['summary']
+
+        print("\n" + "=" * 80)
+        print("🚀 CODEINTERPRETER 稳定性测试报告")
+        print("=" * 80)
+
+        print(f"\n📊 测试摘要:")
+        print(f"   总测试数:     {summary['total_tests']}")
+        print(f"   通过测试:     {summary['successful_tests']} ✅")
+        print(f"   失败测试:     {summary['failed_tests']} ❌")
+        print(f"   成功率:       {summary['success_rate']}%")
+        print(f"   总执行时间:   {summary['total_duration']}s")
+        print(f"   并发数:       {summary['concurrency']}")
+        print(f"   平均测试时间: {summary['avg_duration_per_test']}s")
+        print(f"   最长测试时间: {summary['max_duration']}s")
+        print(f"   最短测试时间: {summary['min_duration']}s")
+
+        # 打印成功测试
+        if report['successful_tests']:
+            print(f"\n✅ 通过的测试 ({len(report['successful_tests'])}):")
+            for test in report['successful_tests']:
+                print(f"   - {test['test_name']} ({test['duration']}s) [{test['thread']}]")
+
+        # 打印失败测试
+        if report['failed_tests']:
+            print(f"\n❌ 失败的测试 ({len(report['failed_tests'])}):")
+            for test in report['failed_tests']:
+                print(f"   - {test['test_name']}")
+                print(f"     错误: {test['error']}")
+                print(f"     时间: {test['duration']}s")
+                print(f"     线程: {test['thread']}")
+
+        # 打印执行时间线
+        print(f"\n⏰ 执行时间线:")
+        for execution in sorted(report['execution_timeline'], key=lambda x: x['timestamp']):
+            status = "✅" if execution['success'] else "❌"
+            print(f"   {status} [{execution['thread']}] {execution['test_name']} ({execution['duration']}s)")
+
+        print("\n" + "=" * 80)
+
+        # 保存详细报告到文件
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        filename = f"stability_test_report_{timestamp}.json"
+        with open(filename, 'w', encoding='utf-8') as f:
+            json.dump(report, f, ensure_ascii=False, indent=2)
+        print(f"📄 详细报告已保存至: {filename}")
+        print("=" * 80)
+
+
+def main():
+    """主函数"""
+    parser = argparse.ArgumentParser(description='CodeInterpreter稳定性测试')
+    parser.add_argument(
+        '--concurrency',
+        type=int,
+        default=10,
+        help='并发线程数 (默认: 10)'
+    )
+    parser.add_argument(
+        '--log-level',
+        choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'],
+        default='INFO',
+        help='日志级别 (默认: INFO)'
+    )
+
+    args = parser.parse_args()
+
+    # 设置日志级别
+    logging.getLogger().setLevel(getattr(logging, args.log_level))
+
+    logger.info(f"启动稳定性测试，并发数: {args.concurrency}")
+
+    tester = StabilityTester(concurrency=args.concurrency)
+
+    try:
+        report = tester.run_concurrent_tests()
+        tester.print_detailed_report(report)
+
+        # 根据成功率返回适当的退出码
+        success_rate = report['summary']['success_rate']
+        if success_rate >= 95:
+            logger.info(f"🎉 测试成功! 成功率: {success_rate}%")
+            sys.exit(0)
+        elif success_rate >= 80:
+            logger.warning(f"⚠️  测试基本通过，但有改进空间。成功率: {success_rate}%")
+            sys.exit(0)
+        else:
+            logger.error(f"💥 测试失败! 成功率: {success_rate}%")
+            sys.exit(1)
+
+    except KeyboardInterrupt:
+        logger.info("测试被用户中断")
+        sys.exit(1)
+    except Exception as e:
+        logger.error(f"测试执行出错: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

scalebox/test/test_browser_use.py

@@ -0,0 +1,25 @@
+import asyncio, openai
+from browser_use import Agent, BrowserProfile
+
+# 指向本地 adapter
+openai.base_url = "http://localhost:8000/v1/"
+openai.api_key = "dummy"
+
+TASK = (
+    "打开 https://www.baidu.com，"
+    "输入“今日天气”并搜索，"
+    "把第一条结果的标题复制出来。"
+)
+
+async def main():
+    agent = Agent(
+        task=TASK,
+        browser_profile=BrowserProfile(headless=False),
+        model="gpt-4"          # 欺骗 browser-use
+    )
+    result = await agent.run()
+    print("---------- 最终结果 ----------")
+    print(result)
+
+if __name__ == "__main__":
+    asyncio.run(main())

scalebox/test/test_browser_use_scalebox.py

@@ -0,0 +1,61 @@
+import asyncio
+import os
+# from browser_use import Agent, BrowserProfile
+from scalebox.sandbox_async.main import AsyncSandbox
+
+# 设置环境变量，避免浏览器启动问题
+os.environ['BROWSER_USE_DISABLE_TELEMETRY'] = '1'
+
+
+async def main():
+    sandbox = await (AsyncSandbox.create(
+        timeout=3600,
+        template="browser-use-headless",
+    ))
+    proc = await sandbox.commands.run("echo hello from async")
+    print("exit_code =", proc.exit_code)
+    print("stdout   =", proc.stdout)
+
+    # try:
+    #     # 配置浏览器参数 - 使用更稳定的配置
+    #     browser_profile = BrowserProfile(
+    #         # 设置浏览器窗口大小
+    #         viewport_width=1200,
+    #         viewport_height=800,
+    #         # 在服务器环境必须使用无头模式
+    #         headless=True,
+    #         # 禁用沙盒，提高容器兼容性
+    #         sandbox=False,
+    #         # 增加超时时间
+    #         browser_launch_timeout=60000,  # 60秒
+    #         # 禁用GPU加速（服务器环境推荐）
+    #         gpu_acceleration=False,
+    #     )
+    #
+    #     # 定义需要 agent 执行的任务
+    #     task = """
+    #     请打开百度首页 (https://www.baidu.com)，在搜索框中输入"今日天气"，然后进行搜索。
+    #     请等待搜索结果页面加载完成。
+    #     """
+    #
+    #     # 创建 Agent 实例
+    #     agent = Agent(
+    #         task=task,
+    #         browser_profile=browser_profile,
+    #     )
+    #
+    #     print("开始执行浏览器自动化任务...")
+    #
+    #     # 运行 Agent
+    #     result = await agent.run()
+    #     print(f"任务执行完成: {result}")
+    #
+    # except Exception as e:
+    #     print(f"执行过程中出现错误: {e}")
+    #     # 打印更详细的错误信息
+    #     import traceback
+    #     traceback.print_exc()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

scalebox/test/test_code_interpreter_sync_comprehensive.py

@@ -106,8 +106,9 @@ result = {"x": x, "y": y}
 print(result)
 """
 
-        execution = self.sandbox.run_code(code, language="python")
+        execution = self.sandbox.run_code(code,envs={"CI_TEST": "sync_test1"})
         print(execution.to_json())
+        # time.sleep(1000)
         assert isinstance(execution, Execution)
         assert execution.error is None
         assert len(execution.logs.stdout) > 0
@@ -147,7 +148,7 @@ print(f"标准差: {std_val:.3f}")
 }
 """
 
-        execution = self.sandbox.run_code(code, language="python")
+        execution = self.sandbox.run_code(code)
         print(execution.to_json())
         assert execution.error is None
         assert any("圆的面积" in line for line in execution.logs.stdout)
@@ -197,7 +198,7 @@ result = {
 print(f"\\n处理结果: {json.dumps(result, indent=2)}")
 """
 
-        execution = self.sandbox.run_code(code, language="python")
+        execution = self.sandbox.run_code(code)
         print(execution.to_json())
         assert execution.error is None
         assert any("原始数据" in line for line in execution.logs.stdout)
@@ -799,6 +800,55 @@ print("生成HTML格式结果")
 from IPython.display import HTML
 HTML(html_content)
 """
+        # code = """
+        # import sys
+        # try:
+        #     import matplotlib
+        #     matplotlib.use('Agg')  # Non-interactive backend
+        #     import matplotlib.pyplot as plt
+        #     import numpy as np
+        #     from IPython.display import display
+        #
+        #     print("✅ All imports successful")
+        #
+        #     # Generate a simple plot
+        #     x = np.linspace(0, 2 * np.pi, 100)
+        #     y = np.sin(x)
+        #
+        #     fig, ax = plt.subplots(figsize=(8, 6))
+        #     ax.plot(x, y, 'b-', linewidth=2, label='sin(x)')
+        #     ax.set_xlabel('X axis')
+        #     ax.set_ylabel('Y axis')
+        #     ax.set_title('Sine Wave - Test Plot')
+        #     ax.legend()
+        #     ax.grid(True, alpha=0.3)
+        #
+        #     plt.tight_layout()
+        #
+        #     # 🎯 KEY: Save to bytes and display as Image
+        #     import io
+        #     from IPython.display import Image
+        #
+        #     buf = io.BytesIO()
+        #     plt.savefig(buf, format='png', bbox_inches='tight', dpi=100)
+        #     buf.seek(0)
+        #     plt.close(fig)
+        #
+        #     # Display the image data
+        #     display(Image(data=buf.getvalue()))
+        #     #
+        #     # print("SUCCESS: Plot generated and displayed")
+        #     # "plot_created"
+        #
+        # except ImportError as e:
+        #     print(f"SKIP: matplotlib not available - {e}")
+        #     "matplotlib_not_installed"
+        # except Exception as e:
+        #     print(f"ERROR: {e}")
+        #     import traceback
+        #     traceback.print_exc()
+        #     "error_occurred"
+        # """
 
         execution = self.sandbox.run_code(code, language="python")
         print(execution.to_json())
@@ -3292,68 +3342,68 @@ print(f"\\n完成 {len(results)} 个API调用")
             self.test_file_operations_simulation, "File Operations Simulation"
         )
 
-        # 性能测试
-        self.run_test(
-            self.test_performance_simple_calculations, "Performance Simple Calculations"
-        )
-        self.run_test(
-            self.test_performance_concurrent_simulation,
-            "Performance Concurrent Simulation",
-        )
-
-        # 结果格式测试
-        self.run_test(self.test_text_result, "Text Result Format")
-        self.run_test(self.test_html_result, "HTML Result Format")
-        self.run_test(self.test_markdown_result, "Markdown Result Format")
-        self.run_test(self.test_svg_result, "SVG Result Format")
-        self.run_test(self.test_image_results, "Image Result Formats (PNG/JPEG)")
-        self.run_test(self.test_latex_result, "LaTeX Result Format")
-        self.run_test(self.test_json_data_result, "JSON Data Result Format")
-        self.run_test(self.test_javascript_result, "JavaScript Result Format")
-        self.run_test(self.test_chart_data_result, "Chart Data Result Format")
-        self.run_test(self.test_mixed_format_result, "Mixed Format Result")
-
-        # R语言测试
-        self.run_test(
-            self.test_r_language_basic_execution, "R Language Basic Execution"
-        )
-        self.run_test(self.test_r_language_data_analysis, "R Language Data Analysis")
-        self.run_test(self.test_r_language_visualization, "R Language Visualization")
-        self.run_test(self.test_r_language_statistics, "R Language Statistics")
-        self.run_test(
-            self.test_r_language_context_management, "R Language Context Management"
-        )
-
-        # Node.js/JavaScript 测试
-        self.run_test(self.test_nodejs_basic_execution, "Node.js Basic Execution")
-        self.run_test(self.test_nodejs_async_promises, "Node.js Async Promises")
-        self.run_test(self.test_nodejs_data_processing, "Node.js Data Processing")
-        self.run_test(self.test_nodejs_chart_data, "Node.js Chart Data Generation")
-        self.run_test(self.test_nodejs_context_management, "Node.js Context Management")
-
-        # Bash 测试
-        self.run_test(self.test_bash_basic_execution, "Bash Basic Execution")
-        self.run_test(self.test_bash_file_operations, "Bash File Operations")
-        self.run_test(self.test_bash_pipelines_and_grep, "Bash Pipelines and Grep")
-        # self.run_test(self.test_bash_env_and_exit_codes, "Bash Env and Exit Codes")
-        self.run_test(self.test_bash_context_management, "Bash Context Management")
-
-        # IJAVA 测试
-        self.run_test(self.test_ijava_basic_execution, "IJAVA Basic Execution")
-        self.run_test(self.test_ijava_oop_features, "IJAVA OOP Features")
-        self.run_test(self.test_ijava_collections, "IJAVA Collections")
-        self.run_test(self.test_ijava_file_io, "IJAVA File I/O")
-        self.run_test(self.test_ijava_context_management, "IJAVA Context Management")
-
-        # Deno 测试
-        self.run_test(self.test_deno_basic_execution, "Deno Basic Execution")
-        self.run_test(self.test_deno_typescript_features, "Deno TypeScript Features")
-        self.run_test(self.test_deno_async_await, "Deno Async/Await")
-        self.run_test(self.test_deno_file_operations, "Deno File Operations")
-        self.run_test(self.test_deno_context_management, "Deno Context Management")
-
-        # 高级功能测试
-        self.run_test(self.test_web_request_simulation, "Web Request Simulation")
+        # # 性能测试
+        # self.run_test(
+        #     self.test_performance_simple_calculations, "Performance Simple Calculations"
+        # )
+        # self.run_test(
+        #     self.test_performance_concurrent_simulation,
+        #     "Performance Concurrent Simulation",
+        # )
+
+        # # 结果格式测试
+        # self.run_test(self.test_text_result, "Text Result Format")
+        # self.run_test(self.test_html_result, "HTML Result Format")
+        # self.run_test(self.test_markdown_result, "Markdown Result Format")
+        # self.run_test(self.test_svg_result, "SVG Result Format")
+        # self.run_test(self.test_image_results, "Image Result Formats (PNG/JPEG)")
+        # self.run_test(self.test_latex_result, "LaTeX Result Format")
+        # self.run_test(self.test_json_data_result, "JSON Data Result Format")
+        # self.run_test(self.test_javascript_result, "JavaScript Result Format")
+        # self.run_test(self.test_chart_data_result, "Chart Data Result Format")
+        # self.run_test(self.test_mixed_format_result, "Mixed Format Result")
+        #
+        # # R语言测试
+        # self.run_test(
+        #     self.test_r_language_basic_execution, "R Language Basic Execution"
+        # )
+        # self.run_test(self.test_r_language_data_analysis, "R Language Data Analysis")
+        # self.run_test(self.test_r_language_visualization, "R Language Visualization")
+        # self.run_test(self.test_r_language_statistics, "R Language Statistics")
+        # self.run_test(
+        #     self.test_r_language_context_management, "R Language Context Management"
+        # )
+        #
+        # # Node.js/JavaScript 测试
+        # self.run_test(self.test_nodejs_basic_execution, "Node.js Basic Execution")
+        # self.run_test(self.test_nodejs_async_promises, "Node.js Async Promises")
+        # self.run_test(self.test_nodejs_data_processing, "Node.js Data Processing")
+        # self.run_test(self.test_nodejs_chart_data, "Node.js Chart Data Generation")
+        # self.run_test(self.test_nodejs_context_management, "Node.js Context Management")
+        #
+        # # Bash 测试
+        # self.run_test(self.test_bash_basic_execution, "Bash Basic Execution")
+        # self.run_test(self.test_bash_file_operations, "Bash File Operations")
+        # self.run_test(self.test_bash_pipelines_and_grep, "Bash Pipelines and Grep")
+        # # self.run_test(self.test_bash_env_and_exit_codes, "Bash Env and Exit Codes")
+        # self.run_test(self.test_bash_context_management, "Bash Context Management")
+        #
+        # # IJAVA 测试
+        # self.run_test(self.test_ijava_basic_execution, "IJAVA Basic Execution")
+        # self.run_test(self.test_ijava_oop_features, "IJAVA OOP Features")
+        # self.run_test(self.test_ijava_collections, "IJAVA Collections")
+        # self.run_test(self.test_ijava_file_io, "IJAVA File I/O")
+        # self.run_test(self.test_ijava_context_management, "IJAVA Context Management")
+        #
+        # # Deno 测试
+        # self.run_test(self.test_deno_basic_execution, "Deno Basic Execution")
+        # # self.run_test(self.test_deno_typescript_features, "Deno TypeScript Features")
+        # self.run_test(self.test_deno_async_await, "Deno Async/Await")
+        # self.run_test(self.test_deno_file_operations, "Deno File Operations")
+        # self.run_test(self.test_deno_context_management, "Deno Context Management")
+        #
+        # # 高级功能测试
+        # self.run_test(self.test_web_request_simulation, "Web Request Simulation")
 
     def cleanup(self):
         """清理资源"""