update6

app.py

@@ -27,11 +27,13 @@ active_tasks = {}
 completed_tasks = []
 task_id_counter = 0
 task_lock = threading.Lock()
-update_event = threading.Event()  # 通知UI需要刷新
+last_update_time = datetime.now()  # 替换update_event为时间戳跟踪
 
 def trigger_ui_update():
     """触发UI更新事件"""
-    update_event.set()
+    global last_update_time
+    with task_lock:
+        last_update_time = datetime.now()  # 更新时间戳而不是使用Event
 
 def get_next_task_id():
     global task_id_counter
@@ -87,18 +89,27 @@ def estimate_completion_time(input_data):
     Returns:
         timedelta: 估计的完成时间
     """
-    # 假设每个任务项平均需要2秒处理
-    # 这个值可以根据实际情况调整或从历史数据中学习
-    avg_time_per_item = 2  
+    # 在Hugging Face Spaces环境中，资源通常受限，调整处理时间预估
+    # 假设每个任务项平均需要5秒处理（HF环境中可能更慢）
+    avg_time_per_item = 5  
     total_items = len(input_data)
     
-    # 考虑并行处理因素
-    cpu_count = multiprocessing.cpu_count()
-    parallel_factor = min(cpu_count, total_items)
+    # Hugging Face Spaces通常有限制的CPU资源
+    # 保守估计并行处理能力
+    try:
+        cpu_count = multiprocessing.cpu_count()
+    except:
+        # 如果获取失败，假设只有2个CPU
+        cpu_count = 2
+    
+    # 在HF环境中，即使有多核也可能性能受限，降低并行因子
+    parallel_factor = min(2, total_items)  # 限制最多2个并行任务
     
     if parallel_factor > 0:
         estimated_seconds = (total_items * avg_time_per_item) / parallel_factor
-        return timedelta(seconds=estimated_seconds)
+        # 为了避免过于乐观的估计，增加30%的缓冲时间
+        estimated_seconds = estimated_seconds * 1.3
+        return timedelta(seconds=round(estimated_seconds))
     else:
         return timedelta(seconds=0)
 
@@ -152,27 +163,67 @@ def evaluate(input_data):
     Returns:
         list: 包含评估结果的列表
     """
+    # 打印Gradio版本，用于调试
+    import gradio
+    print(f"Gradio version: {gradio.__version__}")
+    
     try:
         if not isinstance(input_data, list):
             return {"status": "Exception", "error": "Input must be a list"}
             
         results = []
-        max_workers = multiprocessing.cpu_count()
+        
+        # 在HF Spaces环境中可能受限，降低并行数量
+        try:
+            max_workers = min(multiprocessing.cpu_count(), 2)  # 最多2个并行任务
+        except:
+            max_workers = 2  # 如果无法获取，默认为2
+            
+        # 增加超时处理
         with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
-            future_to_item = {executor.submit(evaluate_single_case, item): item for item in input_data}
-            for future in concurrent.futures.as_completed(future_to_item):
-                item = future_to_item[future]
-                try:
-                    result = future.result()
-                    item.update(result)
-                    results.append(item)
-                except Exception as e:
-                    item.update({"status": "Exception", "error": str(e)})
-                    results.append(item)
+            future_to_item = {}
+            # 分批处理，每批最多5个任务，避免资源耗尽
+            batch_size = 5
+            for i in range(0, len(input_data), batch_size):
+                batch = input_data[i:i+batch_size]
+                # 为每个任务提交并记录
+                for item in batch:
+                    future = executor.submit(evaluate_single_case, item)
+                    future_to_item[future] = item
+                
+                # 等待当前批次完成
+                for future in concurrent.futures.as_completed(future_to_item):
+                    item = future_to_item[future]
+                    try:
+                        # 设置较短的超时时间，避免任务卡死
+                        result = future.result(timeout=60)  # 60秒超时
+                        item.update(result)
+                        results.append(item)
+                    except concurrent.futures.TimeoutError:
+                        # 处理超时情况
+                        item.update({
+                            "status": "Timeout", 
+                            "error": "Task processing timed out in Hugging Face environment"
+                        })
+                        results.append(item)
+                    except Exception as e:
+                        # 处理其他异常
+                        item.update({
+                            "status": "Exception", 
+                            "error": f"Error in Hugging Face environment: {str(e)}"
+                        })
+                        results.append(item)
+                
+                # 清空当前批次
+                future_to_item = {}
+                
+                # 短暂休息，让系统喘息
+                time.sleep(0.5)
+                
         return results
             
     except Exception as e:
-        return {"status": "Exception", "error": str(e)}
+        return {"status": "Exception", "error": f"Evaluation error in Hugging Face environment: {str(e)}"}
 
 def evaluate_single_case(input_data):
     """评估单个代码用例
@@ -389,6 +440,7 @@ def render_queue_status():
 
 def refresh_ui():
     """定期刷新UI函数"""
+    # 不再需要等待事件，直接返回最新状态
     return render_queue_status()
 
 def submit_json_data(json_data):
@@ -429,32 +481,70 @@ with gr.Blocks(title="代码评估服务", theme=gr.themes.Soft()) as demo:
         # JavaScript-based auto-refresh solution
         gr.HTML("""
         <script>
-            // 使用JavaScript作为自动刷新机制
+            // 为Hugging Face Spaces环境优化的自动刷新机制
             function setupAutoRefresh() {
-                const refreshInterval = 2000; // 2秒刷新一次
+                // 在HF Spaces中更保守的刷新间隔，避免过多请求
+                const refreshInterval = 3000; // 3秒刷新一次
+                let lastTaskCount = 0;
+                let consecutiveNoChange = 0;
                 
                 // 查找刷新按钮并模拟点击
                 function autoRefresh() {
-                    // 获取所有按钮元素
-                    const buttons = document.querySelectorAll('button');
-                    // 查找刷新状态按钮
-                    for (const button of buttons) {
-                        if (button.textContent === '刷新状态') {
-                            button.click();
-                            break;
+                    try {
+                        // 获取所有按钮元素
+                        const buttons = document.querySelectorAll('button');
+                        // 查找刷新状态按钮
+                        for (const button of buttons) {
+                            if (button.textContent === '刷新状态') {
+                                button.click();
+                                
+                                // 检查任务数量是否变化 (动态优化刷新频率的预留代码)
+                                setTimeout(() => {
+                                    const activeTasks = document.querySelectorAll('table tbody tr');
+                                    const currentTaskCount = activeTasks.length;
+                                    
+                                    if (currentTaskCount === lastTaskCount) {
+                                        consecutiveNoChange++;
+                                    } else {
+                                        consecutiveNoChange = 0;
+                                    }
+                                    
+                                    lastTaskCount = currentTaskCount;
+                                }, 500);
+                                
+                                break;
+                            }
                         }
+                    } catch (e) {
+                        console.error("Auto-refresh error:", e);
                     }
                 }
 
-                // 周期性检查刷新
-                setInterval(autoRefresh, refreshInterval);
+                // 周期性检查刷新，确保即使在HF Spaces资源受限情况下也能工作
+                let refreshTimer = setInterval(autoRefresh, refreshInterval);
+                
+                // 确保页面可见性变化时刷新机制正常工作
+                document.addEventListener('visibilitychange', function() {
+                    if (document.visibilityState === 'visible') {
+                        // 页面变为可见时立即刷新一次
+                        autoRefresh();
+                        // 如果计时器被清除，重新创建
+                        if (!refreshTimer) {
+                            refreshTimer = setInterval(autoRefresh, refreshInterval);
+                        }
+                    }
+                });
                 
                 // 设置首次加载时立即刷新一次
                 setTimeout(autoRefresh, 100);
             }
             
-            // 页面加载完成后设置自动刷新
-            window.addEventListener('load', setupAutoRefresh);
+            // 确保在DOM完全加载后运行
+            if (document.readyState === 'loading') {
+                document.addEventListener('DOMContentLoaded', setupAutoRefresh);
+            } else {
+                setupAutoRefresh();
+            }
         </script>
         """)
     
@@ -534,12 +624,20 @@ with gr.Blocks(title="代码评估服务", theme=gr.themes.Soft()) as demo:
         api_input.change(fn=evaluate, inputs=api_input, outputs=api_output)
 
 if __name__ == "__main__":
-    # 打印Gradio版本，用于调试
-    import gradio
-    print(f"Gradio version: {gradio.__version__}")
-    
     # 设置队列，并添加API支持
-    demo.queue(api_open=True)
+    demo.queue(api_open=True, concurrency_count=2, max_size=30)
+    
+    # 针对Hugging Face Spaces环境的优化配置
+    is_hf_space = os.environ.get("SPACE_ID") is not None
+    server_port = int(os.environ.get("PORT", 7860))
+    server_name = "0.0.0.0" if is_hf_space else "127.0.0.1"
     
     # 启动应用
-    demo.launch()
+    demo.launch(
+        server_name=server_name,
+        server_port=server_port,
+        share=False,  # 在HF Spaces环境中无需share
+        debug=False,  # 在HF Spaces环境中关闭调试，提高稳定性
+        show_api=True,
+        max_threads=2  # 限制最大线程数，避免资源耗尽
+    )