update17

app.py

@@ -15,7 +15,7 @@ from datetime import datetime
 from tqdm.auto import tqdm
 from src.containerized_eval import eval_string_script
 
-# 添加当前目录和src目录到模块搜索路径
+# Add current directory and src directory to module search path
 current_dir = os.path.dirname(os.path.abspath(__file__))
 src_dir = os.path.join(current_dir, "src")
 if current_dir not in sys.path:
@@ -23,33 +23,30 @@ if current_dir not in sys.path:
 if src_dir not in sys.path:
     sys.path.append(src_dir)
 
-# 创建消息队列
+# Create message queue
 task_queue = queue.Queue()
-# 存储任务状态的字典
+# Dictionary to store task status
 task_status = {}
-# 存储任务历史的列表，最多保存最近20个任务
+# List to store task history, max 20 tasks
 task_history = []
-# 用于保护共享资源的锁
+# Lock for shared resources
 lock = threading.Lock()
-# 工作线程数
+# Number of worker threads
 worker_threads = multiprocessing.cpu_count()
-# 后台线程是否运行的标志
+# Flag for running background threads
 running = True
-# 任务类型到处理时间的映射
+# Mapping from task type to processing time
 task_type_times = {}
 
 def queue_processor():
-    """处理队列中的任务"""
+    """Process tasks in the queue"""
     while running:
         try:
-            # 从队列中获取任务，如果队列为空等待0.1
             task_id, input_data, request_time = task_queue.get(timeout=0.1)
             with lock:
                 task_status[task_id]['status'] = 'processing'
                 task_status[task_id]['start_time'] = time.time()
             
-            # 识别任务特征以估计完成时间
-            # 例如：语言类型、代码大小等
             if isinstance(input_data, list) and len(input_data) > 0:
                 sample_task = input_data[0]
                 language = sample_task.get('language', 'unknown') if isinstance(sample_task, dict) else 'unknown'
@@ -63,10 +60,8 @@ def queue_processor():
                         'complexity': task_complexity
                     }
             
-            # 处理任务
             result = evaluate(input_data)
             
-            # 更新任务状态
             end_time = time.time()
             process_time = end_time - task_status[task_id]['start_time']
             
@@ -76,7 +71,6 @@ def queue_processor():
                 task_status[task_id]['end_time'] = end_time
                 task_status[task_id]['process_time'] = process_time
                 
-                # 更新任务类型到处理时间的映射
                 if 'estimated_factors' in task_status[task_id]:
                     factors = task_status[task_id]['estimated_factors']
                     key = f"{factors['language']}_{factors['complexity']}"
@@ -84,13 +78,10 @@ def queue_processor():
                     if key not in task_type_times:
                         task_type_times[key] = []
                     
-                    # 记录此类型任务的处理时间
                     task_type_times[key].append(process_time / factors['size'])
-                    # 只保留最近的10个记录
                     if len(task_type_times[key]) > 10:
                         task_type_times[key] = task_type_times[key][-10:]
                 
-                # 更新任务历史
                 task_history.append({
                     'task_id': task_id,
                     'request_time': request_time,
@@ -98,15 +89,12 @@ def queue_processor():
                     'status': 'completed',
                     'factors': task_status[task_id].get('estimated_factors', {})
                 })
-                # 只保留最近20个任务
                 while len(task_history) > 20:
                     task_history.pop(0)
                     
-            # 标记任务完成
             task_queue.task_done()
             
         except queue.Empty:
-            # 队列为空，继续等待
             continue
         except Exception as e:
             if 'task_id' in locals():
@@ -117,15 +105,10 @@ def queue_processor():
             task_queue.task_done()
 
 def _estimate_task_complexity(tasks):
-    """估计任务复杂度
+    """Estimate task complexity
     
-    Args:
-        tasks: 任务列表
-        
-    Returns:
-        str: 复杂度评级 ('simple', 'medium', 'complex')
+    Returns: 'simple', 'medium', or 'complex'
     """
-    # 基于代码和测试的长度评估复杂度
     total_code_length = 0
     count = 0
     
@@ -143,7 +126,7 @@ def _estimate_task_complexity(tasks):
             count += 1
     
     if count == 0:
-        return 'medium'  # 默认中等复杂度
+        return 'medium'
     
     avg_length = total_code_length / count
     
@@ -155,14 +138,7 @@ def _estimate_task_complexity(tasks):
         return 'complex'
 
 def evaluate(input_data):
-    """评估代码的主函数
-    
-    Args:
-        input_data: 列表(批量处理多个测试用例)
-        
-    Returns:
-        list: 包含评估结果的列表
-    """
+    """Main function for code evaluation"""
     try:
         if not isinstance(input_data, list):
             return {"status": "Exception", "error": "Input must be a list"}
@@ -186,14 +162,7 @@ def evaluate(input_data):
         return {"status": "Exception", "error": str(e)}
 
 def evaluate_single_case(input_data):
-    """评估单个代码用例
-    
-    Args:
-        input_data: 字典(包含代码信息)
-        
-    Returns:
-        dict: 包含评估结果的字典
-    """
+    """Evaluate a single code case"""
     try:
         if not isinstance(input_data, dict):
             return {"status": "Exception", "error": "Input item must be a dictionary"}
@@ -218,17 +187,8 @@ def evaluate_single_case(input_data):
         return {"status": "Exception", "error": str(e)}
 
 def evaluate_code(code, language):
-    """评估特定语言的代码
-    
-    Args:
-        code (str): 要评估的代码
-        language (str): 编程语言
-        
-    Returns:
-        dict: 包含评估结果的字典
-    """
+    """Evaluate code in a specific language"""
     try:
-        # 使用containerized_eval中的eval_string_script函数
         result = eval_string_script(language, code)
         return result
 
@@ -236,17 +196,7 @@ def evaluate_code(code, language):
         return {"status": "Exception", "error": str(e)}
 
 def synchronous_evaluate(input_data):
-    """同步评估代码，兼容原来的接口
-    
-    这个函数会阻塞直到评估完成，然后返回结果
-    
-    Args:
-        input_data: 要评估的输入数据
-        
-    Returns:
-        dict: 评估结果
-    """
-    # a) 估计此任务的特征
+    """Synchronously evaluate code, compatible with original interface"""
     if isinstance(input_data, list) and len(input_data) > 0:
         sample_task = input_data[0]
         language = sample_task.get('language', 'unknown') if isinstance(sample_task, dict) else 'unknown'
@@ -257,25 +207,21 @@ def synchronous_evaluate(input_data):
         task_size = 1
         task_complexity = 'medium'
     
-    # b) 估计完成时间用于前端显示
     estimated_time_per_task = _get_estimated_time_for_task(language, task_complexity)
     estimated_total_time = estimated_time_per_task * task_size
     
-    # 获取队列当前状态
     queue_info = get_queue_status()
     waiting_tasks = queue_info['waiting_tasks']
     
-    # 创建任务
     task_id = str(uuid.uuid4())
     request_time = time.time()
     
     with lock:
-        # 创建任务状态记录
         task_status[task_id] = {
             'status': 'queued',
             'queued_time': request_time,
             'queue_position': task_queue.qsize() + 1,
-            'synchronous': True,  # 标记为同步任务
+            'synchronous': True,
             'estimated_factors': {
                 'language': language,
                 'size': task_size,
@@ -284,45 +230,30 @@ def synchronous_evaluate(input_data):
             'estimated_time': estimated_total_time
         }
     
-    # 将任务添加到队列
     task_queue.put((task_id, input_data, request_time))
     
-    # 等待任务完成
     while True:
         with lock:
             if task_id in task_status:
                 status = task_status[task_id]['status']
                 if status == 'completed':
                     result = task_status[task_id]['result']
-                    # 任务完成后清理状态
                     task_status.pop(task_id, None)
                     return result
                 elif status == 'error':
-                    error = task_status[task_id].get('error', '未知错误')
-                    # 任务出错后清理状态
+                    error = task_status[task_id].get('error', 'Unknown error')
                     task_status.pop(task_id, None)
                     return {"status": "Exception", "error": error}
         
-        # 短暂睡眠避免CPU占用过高
         time.sleep(0.1)
 
 def _get_estimated_time_for_task(language, complexity):
-    """获取特定类型任务的估计处理时间
-    
-    Args:
-        language: 编程语言
-        complexity: 任务复杂度
-        
-    Returns:
-        float: 估计的处理时间（秒）
-    """
+    """Get estimated processing time for a specific task type"""
     key = f"{language}_{complexity}"
     
-    # 如果有历史数据，使用中位数作为估计值
     if key in task_type_times and len(task_type_times[key]) > 0:
         return np.median(task_type_times[key])
     
-    # 否则使用基于复杂度的默认估计值
     if complexity == 'simple':
         return 1.0
     elif complexity == 'medium':
@@ -331,15 +262,7 @@ def _get_estimated_time_for_task(language, complexity):
         return 8.0
 
 def enqueue_task(input_data):
-    """将任务添加到队列
-    
-    Args:
-        input_data: 要处理的任务数据
-        
-    Returns:
-        dict: 包含任务ID和状态的字典
-    """
-    # 估计任务特征和处理时间
+    """Add task to queue"""
     if isinstance(input_data, list) and len(input_data) > 0:
         sample_task = input_data[0]
         language = sample_task.get('language', 'unknown') if isinstance(sample_task, dict) else 'unknown'
@@ -357,7 +280,6 @@ def enqueue_task(input_data):
     request_time = time.time()
     
     with lock:
-        # 创建任务状态记录
         task_status[task_id] = {
             'status': 'queued',
             'queued_time': request_time,
@@ -370,11 +292,9 @@ def enqueue_task(input_data):
             'estimated_time': estimated_total_time
         }
     
-    # 获取队列状态以计算等待时间
     queue_info = get_queue_status()
     est_wait = queue_info['estimated_wait']
     
-    # 将任务添加到队列
     task_queue.put((task_id, input_data, request_time))
     
     return {
@@ -386,34 +306,21 @@ def enqueue_task(input_data):
     }
 
 def check_status(task_id):
-    """检查任务状态
-    
-    Args:
-        task_id: 任务ID
-        
-    Returns:
-        dict: 包含任务状态的字典
-    """
+    """Check task status"""
     with lock:
         if task_id not in task_status:
             return {'status': 'not_found'}
         
         status_info = task_status[task_id].copy()
         
-        # 如果任务已完成，从状态字典中移除（避免内存泄漏）
         if status_info['status'] in ['completed', 'error'] and time.time() - status_info.get('end_time', 0) > 3600:
             task_status.pop(task_id, None)
             
         return status_info
 
 def get_queue_status():
-    """获取队列状态
-    
-    Returns:
-        dict: 包含队列状态的字典
-    """
+    """Get queue status"""
     with lock:
-        # 获取队列中的所有任务
         queued_tasks = [t for t in task_status.values() if t['status'] == 'queued']
         processing_tasks = [t for t in task_status.values() if t['status'] == 'processing']
         
@@ -421,61 +328,45 @@ def get_queue_status():
         active_tasks = len(processing_tasks)
         waiting_tasks = len(queued_tasks)
         
-        # 更准确地估计等待时间
-        # 1. 计算当前处理中任务的剩余时间
         remaining_processing_time = 0
         for task in processing_tasks:
-            # 如果任务有开始时间和估计总时间
             if 'start_time' in task and 'estimated_time' in task:
                 elapsed = time.time() - task['start_time']
-                # 剩余时间 = 估计总时间 - 已经过去的时间
                 remaining = max(0, task['estimated_time'] - elapsed)
                 remaining_processing_time += remaining
             else:
-                # 默认假设还需要2秒
                 remaining_processing_time += 2
         
-        # 使用动态均衡：根据工作线程数量平衡负载
         if active_tasks > 0:
             remaining_processing_time = remaining_processing_time / min(active_tasks, worker_threads)
         
-        # 2. 计算排队中任务的估计处理时间
         queued_processing_time = 0
         for task in queued_tasks:
             if 'estimated_time' in task:
                 queued_processing_time += task['estimated_time']
             else:
-                # 默认假设每个任务5秒
                 queued_processing_time += 5
         
-        # 考虑并行处理：分摊到可用工作线程
         if worker_threads > 0 and queued_processing_time > 0:
             queued_processing_time = queued_processing_time / worker_threads
         
-        # 总估计等待时间
         estimated_wait = remaining_processing_time + queued_processing_time
         
-        # 应用统计校正：使用历史数据调整预测
         if task_history:
-            # 计算历史预测与实际处理时间的比例
             prediction_ratios = []
             for task in task_history:
                 if 'factors' in task and 'estimated_time' in task:
                     prediction_ratios.append(task['process_time'] / task['estimated_time'])
             
-            # 如果有足够数据，使用中位数比例调整当前预测
             if prediction_ratios:
                 correction_factor = np.median(prediction_ratios)
-                # 应用校正因子，但限制在合理范围内
                 correction_factor = max(0.5, min(2.0, correction_factor))
                 estimated_wait *= correction_factor
         
-        # 确保等待时间有意义
         estimated_wait = max(0.1, estimated_wait)
         if waiting_tasks == 0 and active_tasks == 0:
             estimated_wait = 0
             
-        # 获取最近处理的任务
         recent_tasks = task_history[-5:] if task_history else []
             
         return {
@@ -488,31 +379,20 @@ def get_queue_status():
         }
 
 def format_time(seconds):
-    """格式化时间为易读格式
-    
-    Args:
-        seconds: 秒数
-        
-    Returns:
-        str: 格式化的时间字符串
-    """
+    """Format time into readable format"""
     if seconds < 60:
-        return f"{seconds:.1f}秒"
+        return f"{seconds:.1f} seconds"
     elif seconds < 3600:
         minutes = int(seconds / 60)
         seconds = seconds % 60
-        return f"{minutes}分{seconds:.1f}秒"
+        return f"{minutes}m {seconds:.1f}s"
     else:
         hours = int(seconds / 3600)
         minutes = int((seconds % 3600) / 60)
-        return f"{hours}小时{minutes}分钟"
+        return f"{hours}h {minutes}m"
 
 def ui_get_queue_info():
-    """获取队列信息的UI函数
-    
-    Returns:
-        str: 包含队列信息的HTML
-    """
+    """Get queue info for UI"""
     queue_info = get_queue_status()
     
     tasks_html = ""
@@ -525,47 +405,46 @@ def ui_get_queue_info():
         </tr>
         """
     
-    # 如果没有任务历史，显示提示信息
     if not tasks_html:
         tasks_html = """
         <tr>
-            <td colspan="3" style="text-align: center; padding: 20px;">暂无历史任务</td>
+            <td colspan="3" style="text-align: center; padding: 20px;">No historical tasks</td>
         </tr>
         """
     
     return f"""
     <div class="dashboard">
         <div class="queue-info-card main-card">
-            <h3 class="card-title">队列状态监控</h3>
+            <h3 class="card-title">Queue Status Monitor</h3>
             <div class="queue-stats">
                 <div class="stat-item">
                     <div class="stat-value">{queue_info['waiting_tasks']}</div>
-                    <div class="stat-label">等待中</div>
+                    <div class="stat-label">Waiting</div>
                 </div>
                 <div class="stat-item">
                     <div class="stat-value">{queue_info['active_tasks']}</div>
-                    <div class="stat-label">处理中</div>
+                    <div class="stat-label">Processing</div>
                 </div>
                 <div class="stat-item">
                     <div class="stat-value">{queue_info['worker_threads']}</div>
-                    <div class="stat-label">工作线程</div>
+                    <div class="stat-label">Worker Threads</div>
                 </div>
             </div>
             
             <div class="wait-time">
-                <p><b>当前预计等待时间:</b> {format_time(queue_info['estimated_wait'])}</p>
-                <p class="last-update"><small>最后更新: {datetime.now().strftime('%H:%M:%S')}</small></p>
+                <p><b>Current Estimated Wait Time:</b> {format_time(queue_info['estimated_wait'])}</p>
+                <p class="last-update"><small>Last update: {datetime.now().strftime('%H:%M:%S')}</small></p>
             </div>
         </div>
             
         <div class="queue-info-card history-card">
-            <h3 class="card-title">最近处理的任务</h3>
+            <h3 class="card-title">Recently Processed Tasks</h3>
             <table class="recent-tasks">
                 <thead>
                     <tr>
-                        <th>任务ID</th>
-                        <th>请求时间</th>
-                        <th>处理时间</th>
+                        <th>Task ID</th>
+                        <th>Request Time</th>
+                        <th>Processing Time</th>
                     </tr>
                 </thead>
                 <tbody>
@@ -577,17 +456,16 @@ def ui_get_queue_info():
     """
 
 def launch_workers():
-    """启动工作线程"""
+    """Launch worker threads"""
     global running
     running = True
     
-    # 创建工作线程
     for _ in range(worker_threads):
         worker = threading.Thread(target=queue_processor)
         worker.daemon = True
         worker.start()
 
-# 自定义CSS
+# Custom CSS
 custom_css = """
 .container {
     max-width: 1200px;
@@ -741,36 +619,36 @@ button.primary:hover {
 }
 """
 
-# 初始化并启动工作线程
+# Initialize and launch worker threads
 launch_workers()
 
-# 创建Gradio接口
+# Create Gradio interface
 with gr.Blocks(css=custom_css) as demo:
-    gr.Markdown("# 代码评估服务")
-    gr.Markdown("支持多种编程语言的代码评估服务，采用队列机制处理请求")
+    gr.Markdown("# Code Evaluation Service")
+    gr.Markdown("Code evaluation service supporting multiple programming languages, using queue mechanism to process requests")
     
     with gr.Row():
         with gr.Column(scale=3):
-            # 队列状态信息卡片
+            # Queue status info card
             queue_info_html = gr.HTML()
-            refresh_queue_btn = gr.Button("刷新队列状态", variant="primary")
+            refresh_queue_btn = gr.Button("Refresh Queue Status", variant="primary")
     
-    # 隐藏的API接口组件，不在UI上显示
+    # Hidden API interface components
     with gr.Row(visible=False):
         api_input = gr.JSON()
         api_output = gr.JSON()
     
-    # 定义更新函数
+    # Define update function
     def update_queue_info():
         return ui_get_queue_info()
     
-    # 定时更新队列信息
+    # Update queue info periodically
     demo.load(update_queue_info, None, queue_info_html, every=3)
     
-    # 刷新按钮事件
+    # Refresh button event
     refresh_queue_btn.click(update_queue_info, None, queue_info_html)
     
-    # 添加兼容原有接口的评估端点，但不在UI显示
+    # Add evaluation endpoint compatible with original interface
     demo.queue()
     evaluate_endpoint = demo.load(fn=synchronous_evaluate, inputs=api_input, outputs=api_output, api_name="evaluate")
 
@@ -778,5 +656,5 @@ if __name__ == "__main__":
     try:
         demo.launch()
     finally:
-        # 停止工作线程
+        # Stop worker threads
         running = False