update9

app.py

@@ -28,12 +28,18 @@ completed_tasks = []
 task_id_counter = 0
 task_lock = threading.Lock()
 last_update_time = datetime.now()  # 替换update_event为时间戳跟踪
+# 持久化的状态用于API访问和轮询更新
+status_poll_counter = 0  # 用于强制更新UI，即使状态没有变化
+last_background_update = datetime.now()  # 最后一次后台更新时间
 
 def trigger_ui_update():
     """触发UI更新事件"""
-    global last_update_time
+    global last_update_time, status_poll_counter, last_background_update
     with task_lock:
-        last_update_time = datetime.now()  # 更新时间戳而不是使用Event
+        last_update_time = datetime.now()  # 更新时间戳
+        status_poll_counter += 1  # 递增计数器，确保每次更新都被捕获
+        last_background_update = last_update_time  # 更新后台状态
+        print(f"UI更新被触发: {datetime.now().strftime('%H:%M:%S')} [计数: {status_poll_counter}]")
 
 def get_next_task_id():
     global task_id_counter
@@ -126,32 +132,53 @@ def process_task_queue():
             
             # 更新任务状态
             with task_lock:
-                active_tasks[task_id]["status"] = "processing"
-                trigger_ui_update()  # 状态变更为处理中时更新UI
+                if task_id in active_tasks:  # 确保任务仍存在
+                    active_tasks[task_id]["status"] = "processing"
+                    print(f"任务 {task_id} 开始处理，当前时间: {datetime.now().strftime('%H:%M:%S')}")
+                    trigger_ui_update()  # 状态变更为处理中时更新UI
+                else:
+                    print(f"警告: 任务 {task_id} 不在活跃任务列表中")
+                    task_queue.task_done()
+                    continue
             
             # 处理任务
+            print(f"开始评估任务 {task_id}，数据项数: {len(task_info['data'])}")
             result = evaluate(task_info["data"])
+            print(f"任务 {task_id} 评估完成，结果数: {len(result) if isinstance(result, list) else 'Not a list'}")
             
             # 更新任务结果
             with task_lock:
-                active_tasks[task_id]["status"] = "completed"
-                active_tasks[task_id]["completed_at"] = datetime.now()
-                active_tasks[task_id]["result"] = result
-                
-                # 将任务移至已完成列表
-                completed_tasks.append(active_tasks[task_id])
-                del active_tasks[task_id]
-                
-                # 保留最近的20个已完成任务
-                if len(completed_tasks) > 20:
-                    completed_tasks.pop(0)
-                
-                trigger_ui_update()  # 任务完成时更新UI
+                if task_id in active_tasks:  # 再次确保任务仍存在
+                    completed_time = datetime.now()
+                    active_tasks[task_id]["status"] = "completed"
+                    active_tasks[task_id]["completed_at"] = completed_time
+                    active_tasks[task_id]["result"] = result
+                    
+                    # 计算处理持续时间
+                    start_time = active_tasks[task_id]["submitted_at"]
+                    duration = completed_time - start_time
+                    print(f"任务 {task_id} 已完成，耗时: {duration}，当前时间: {completed_time.strftime('%H:%M:%S')}")
+                    
+                    # 将任务移至已完成列表
+                    completed_tasks.append(active_tasks[task_id])
+                    del active_tasks[task_id]
+                    
+                    # 保留最近的20个已完成任务
+                    if len(completed_tasks) > 20:
+                        completed_tasks.pop(0)
+                    
+                    # 状态更新后强制触发UI更新
+                    trigger_ui_update()
+                    print(f"任务 {task_id} 完成后触发UI更新: {last_update_time}")
+                else:
+                    print(f"警告: 任务 {task_id} 在处理完成后不在活跃任务列表中")
             
             task_queue.task_done()
             
         except Exception as e:
-            print(f"Error processing task queue: {str(e)}")
+            print(f"处理任务队列出错: {str(e)}")
+            import traceback
+            traceback.print_exc()
             time.sleep(1)
 
 def evaluate(input_data):
@@ -317,7 +344,9 @@ def get_queue_status():
                     "completed_at": task["completed_at"].strftime("%Y-%m-%d %H:%M:%S") if "completed_at" in task else "",
                     "duration": str(task["completed_at"] - task["submitted_at"]) if "completed_at" in task else ""
                 } for task in completed_tasks[-5:]  # 只显示最近5个完成的任务
-            ]
+            ],
+            "poll_counter": status_poll_counter,  # 添加轮询计数器
+            "timestamp": datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
         }
 
 def render_queue_status():
@@ -439,9 +468,20 @@ def render_queue_status():
     return html
 
 def refresh_ui():
-    """定期刷新UI函数"""
-    # 不再需要等待事件，直接返回最新状态
-    return render_queue_status()
+    """定期刷新UI函数，确保显示最新状态"""
+    global status_poll_counter
+    print(f"UI刷新被调用: {datetime.now().strftime('%H:%M:%S')} [状态计数: {status_poll_counter}]")
+    return render_queue_status(), status_poll_counter
+
+def get_status_for_polling():
+    """为AJAX轮询提供的状态获取函数，简化返回数据量"""
+    global status_poll_counter
+    # 返回最新状态和计数器值，用于客户端判断是否有更新
+    return {
+        "status_html": render_queue_status(),
+        "poll_counter": status_poll_counter,
+        "timestamp": datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
+    }
 
 def submit_json_data(json_data):
     """提交JSON数据处理接口"""
@@ -452,14 +492,63 @@ def submit_json_data(json_data):
         else:
             data = json_data
             
+        # 为调试记录提交来源
+        print(f"接收到任务提交: {len(data) if isinstance(data, list) else 'Not a list'} 项")
+        print(f"当前队列状态 (提交前): 活跃任务 {len(active_tasks)}, 已完成任务 {len(completed_tasks)}")
+            
         result = submit_task(data)
         response = json.dumps(result, ensure_ascii=False, indent=2)
         
+        # 强制触发UI更新
+        trigger_ui_update()
+        print(f"任务提交后触发UI更新: {last_update_time}")
+        print(f"当前队列状态 (提交后): 活跃任务 {len(active_tasks)}, 已完成任务 {len(completed_tasks)}")
+        
         # 返回任务提交结果和最新的队列状态
-        return response, render_queue_status()
+        status_html = render_queue_status()
+        return response, status_html
     except Exception as e:
+        print(f"提交任务出错: {str(e)}")
         return json.dumps({"status": "error", "message": str(e)}, ensure_ascii=False, indent=2), render_queue_status()
 
+# API端点函数，用于获取最新队列状态
+def api_get_queue_status():
+    """API端点，获取最新队列状态"""
+    status = get_queue_status()
+    status["html"] = render_queue_status()  # 添加HTML渲染版本
+    return status
+
+# 后台UI更新线程
+def background_ui_updater():
+    """每隔一段时间检查任务状态，如有变化则触发更新"""
+    global last_background_update
+    print("后台UI更新线程已启动")
+    
+    while True:
+        try:
+            # 检查队列状态
+            current_time = datetime.now()
+            time_since_last_update = (current_time - last_background_update).total_seconds()
+            
+            # 如果30秒内没有更新，且有活跃任务，触发更新
+            with task_lock:
+                has_active_tasks = len(active_tasks) > 0
+                
+            if time_since_last_update > 30 and has_active_tasks:
+                print(f"后台更新: 有{len(active_tasks)}个活跃任务，{time_since_last_update:.1f}秒未更新")
+                trigger_ui_update()
+            
+            # 如果2分钟内没有更新，无论如何都触发一次更新保持UI活跃
+            if time_since_last_update > 120:
+                print(f"后台更新: 保活触发，{time_since_last_update:.1f}秒未更新")
+                trigger_ui_update()
+                
+        except Exception as e:
+            print(f"后台更新出错: {str(e)}")
+            
+        # 每5秒检查一次
+        time.sleep(5)
+
 # 创建Gradio接口
 with gr.Blocks(title="代码评估服务", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
@@ -467,9 +556,31 @@ with gr.Blocks(title="代码评估服务", theme=gr.themes.Soft()) as demo:
     ### 支持多种编程语言的代码评估服务
     """)
     
+    # 添加隐藏的API处理组件
+    with gr.Row(visible=False):
+        api_input = gr.JSON()
+        api_output = gr.JSON()
+        
+        # 设置API触发器
+        def api_trigger(data):
+            """处理API请求的函数"""
+            print(f"通过API接收到请求: {len(data) if isinstance(data, list) else 'Not a list'}")
+            try:
+                result = submit_task(data)
+                # 强制触发UI更新
+                trigger_ui_update()
+                return result
+            except Exception as e:
+                print(f"API处理出错: {str(e)}")
+                return {"status": "error", "message": str(e)}
+        
+        api_input.change(fn=api_trigger, inputs=api_input, outputs=api_output)
+    
     with gr.Tab("任务队列状态"):
         status_html = gr.HTML(render_queue_status)
+        poll_counter = gr.Number(value=0, visible=False)  # 隐藏的计数器，用于触发更新
         refresh_button = gr.Button("刷新状态")
+        status_text = gr.Markdown("上次更新时间: 未更新")
         
         # 根据Gradio版本使用不同的事件注册方法
         if 'gradio_version' not in locals():
@@ -478,129 +589,116 @@ with gr.Blocks(title="代码评估服务", theme=gr.themes.Soft()) as demo:
         
         if gradio_version.startswith("3."):
             # Gradio 3.x 方式
-            refresh_button.click(fn=refresh_ui, outputs=status_html, concurrency_limit=2)
+            refresh_button.click(fn=refresh_ui, outputs=[status_html, poll_counter], concurrency_limit=2)
         else:
             # Gradio 4.x 方式 (不使用concurrency_limit参数)
-            refresh_button.click(fn=refresh_ui, outputs=status_html)
-        
-        # 使用正确的轮询方式替代
-        dummy_input = gr.Textbox(value="", visible=False)
-        
-        # We'll rely on the JavaScript solution below for auto-refresh
-        # The refresh button still works for manual refresh
-        
-        # JavaScript-based auto-refresh solution
-        gr.HTML("""
+            refresh_button.click(
+                fn=refresh_ui, 
+                outputs=[status_html, poll_counter],
+                every=10  # 每10秒自动刷新一次
+            )
+        
+        # API断点，用于轮询最新状态
+        status_polling_input = gr.Number(value=0, visible=False, label="轮询触发器")
+        status_polling_output = gr.JSON(visible=False, label="轮询结果")
+        
+        status_polling_input.change(
+            fn=get_status_for_polling,
+            inputs=[],
+            outputs=status_polling_output
+        )
+        
+        # 使用JavaScript实现自动轮询
+        polling_js = """
         <script>
-            // 兼容Gradio 3.x和4.x的自动刷新机制
-            function setupAutoRefresh() {
-                // 在HF Spaces中更保守的刷新间隔，避免过多请求
-                const refreshInterval = 3000; // 3秒刷新一次
-                let lastTaskCount = 0;
-                let consecutiveNoChange = 0;
+            // 初始化轮询计数器
+            let lastPollCounter = 0;
+            let pollingActive = true;
+            
+            // 轮询函数
+            async function pollStatus() {
+                if (!pollingActive) return;
                 
-                // 查找刷新按钮并模拟点击
-                function autoRefresh() {
-                    try {
-                        // 兼容Gradio 3.x和4.x的按钮查找方法
-                        const buttons = document.querySelectorAll('button');
-                        let refreshButton = null;
-                        
-                        // 尝试通过文本查找按钮
-                        for (const button of buttons) {
-                            if (button.textContent === '刷新状态' || 
-                                button.textContent.includes('刷新') ||
-                                button.innerHTML.includes('刷新状态')) {
-                                refreshButton = button;
-                                break;
-                            }
-                        }
+                try {
+                    // 查找JSON输出元素 (在Gradio 4.x中，元素ID可能不同)
+                    const jsonElements = document.querySelectorAll('[data-testid="json"]');
+                    const statusElements = document.querySelectorAll('[id*="status_html"]');
+                    
+                    // 如果找不到元素，使用普通AJAX请求
+                    if (!jsonElements.length) {
+                        // 通过已有的刷新按钮点击来刷新
+                        const refreshButton = [...document.querySelectorAll('button')].find(btn => 
+                            btn.textContent.includes('刷新状态'));
                         
-                        // 如果没找到，尝试查找第一个标签页中的第一个按钮
-                        if (!refreshButton) {
-                            const firstTab = document.querySelector('.tabitem');
-                            if (firstTab) {
-                                const firstTabButton = firstTab.querySelector('button');
-                                if (firstTabButton) {
-                                    refreshButton = firstTabButton;
-                                }
-                            }
-                        }
-                        
-                        // 如果找到按钮，模拟点击
                         if (refreshButton) {
                             refreshButton.click();
-                            console.log("自动刷新已触发");
-                        } else {
-                            console.warn("未找到刷新按钮");
-                            // 如果找不到按钮，尝试重新加载整个页面
-                            // 但要限制频率，避免无限刷新
-                            if (consecutiveNoChange > 10) {
-                                console.log("长时间未找到刷新按钮，刷新页面");
-                                location.reload();
-                                return;
-                            }
+                            console.log("刷新按钮被触发");
                         }
-                                
-                        // 在Gradio 3.x和4.x中检查任务数量变化
-                        setTimeout(() => {
-                            // 尝试不同的选择器来适配不同版本
-                            const tables = document.querySelectorAll('table');
-                            let activeTasks = [];
+                    } else {
+                        // 使用Gradio API调用来获取最新状态
+                        // 构建API请求的路径
+                        const apiBase = window.location.pathname.endsWith('/') 
+                            ? window.location.pathname 
+                            : window.location.pathname + '/';
                             
-                            if (tables.length > 0) {
-                                // 在所有表格中查找行
-                                for (const table of tables) {
-                                    const rows = table.querySelectorAll('tbody tr');
-                                    if (rows.length > 0) {
-                                        activeTasks = rows;
-                                        break;
-                                    }
-                                }
-                            }
-                            
-                            const currentTaskCount = activeTasks.length || 0;
+                        const response = await fetch(apiBase + 'api/queue/status');
+                        if (response.ok) {
+                            const data = await response.json();
+                            const statusHtml = statusElements[0];
                             
-                            if (currentTaskCount === lastTaskCount) {
-                                consecutiveNoChange++;
-                            } else {
-                                consecutiveNoChange = 0;
+                            // 如果有状态更新，更新UI
+                            if (statusHtml && data.status) {
+                                // 根据API返回更新页面状态
+                                console.log("服务器状态已更新");
+                                
+                                // 触发刷新按钮
+                                const refreshButton = [...document.querySelectorAll('button')].find(btn => 
+                                    btn.textContent.includes('刷新状态'));
+                                
+                                if (refreshButton) {
+                                    refreshButton.click();
+                                }
                             }
-                            
-                            lastTaskCount = currentTaskCount;
-                        }, 500);
-                    } catch (e) {
-                        console.error("自动刷新错误:", e);
-                    }
-                }
-
-                // 周期性检查刷新，确保即使在HF Spaces资源受限情况下也能工作
-                let refreshTimer = setInterval(autoRefresh, refreshInterval);
-                
-                // 确保页面可见性变化时刷新机制正常工作
-                document.addEventListener('visibilitychange', function() {
-                    if (document.visibilityState === 'visible') {
-                        // 页面变为可见时立即刷新一次
-                        autoRefresh();
-                        // 如果计时器被清除，重新创建
-                        if (!refreshTimer) {
-                            refreshTimer = setInterval(autoRefresh, refreshInterval);
                         }
                     }
-                });
+                } catch (err) {
+                    console.error("轮询错误:", err);
+                }
                 
-                // 设置首次加载时立即刷新一次，但稍微延迟确保DOM已加载
-                setTimeout(autoRefresh, 500);
+                // 继续轮询
+                setTimeout(pollStatus, 5000);  // 每5秒轮询一次
             }
             
-            // 确保在DOM完全加载后运行
+            // 页面加载完成后开始轮询
             if (document.readyState === 'loading') {
-                document.addEventListener('DOMContentLoaded', setupAutoRefresh);
+                document.addEventListener('DOMContentLoaded', () => setTimeout(pollStatus, 1000));
             } else {
-                setupAutoRefresh();
+                setTimeout(pollStatus, 1000);
             }
+            
+            // 页面可见性变化时管理轮询
+            document.addEventListener('visibilitychange', function() {
+                pollingActive = document.visibilityState === 'visible';
+                if (pollingActive) {
+                    // 页面变为可见时立即轮询一次
+                    pollStatus();
+                }
+            });
         </script>
-        """)
+        """
+        
+        gr.HTML(polling_js)
+        
+        # 以下是原来的自动刷新脚本，保留但不使用
+        auto_refresh_js = """
+        <script>
+            // 兼容Gradio 3.x和4.x的自动刷新机制 - 仅作为备用
+            console.log('自动刷新机制已加载，但已被新的轮询系统替代');
+        </script>
+        """
+        
+        # 不显示旧的自动刷新脚本
+        # gr.HTML(auto_refresh_js)
     
     with gr.Tab("提交新任务"):
         with gr.Row():
@@ -677,18 +775,8 @@ with gr.Blocks(title="代码评估服务", theme=gr.themes.Soft()) as demo:
         ```
         """)
 
-    # 添加API端点
-    with gr.Row(visible=False):
-        api_input = gr.JSON()
-        api_output = gr.JSON()
-        
-        # 根据Gradio版本使用不同的事件注册方法
-        if gradio_version.startswith("3."):
-            # Gradio 3.x 方式
-            api_input.change(fn=evaluate, inputs=api_input, outputs=api_output, concurrency_limit=2)
-        else:
-            # Gradio 4.x 方式
-            api_input.change(fn=evaluate, inputs=api_input, outputs=api_output)
+    # 这里不再添加状态API端点，避免与FastAPI冲突
+    # demo.queue(api_open=True).add_api_route("/api/queue/status", api_get_queue_status, methods=["GET"])
 
 if __name__ == "__main__":
     # 检测Gradio版本以适配不同版本的API
@@ -696,78 +784,108 @@ if __name__ == "__main__":
     gradio_version = getattr(gradio, "__version__", "unknown")
     print(f"当前Gradio版本: {gradio_version}")
     
+    # 启动后台UI更新线程
+    bg_thread = threading.Thread(target=background_ui_updater, daemon=True)
+    bg_thread.start()
+    print("后台UI更新线程已启动")
+    
     try:
-        # 设置队列，并添加API支持
-        try:
-            # 根据Gradio版本使用不同的队列配置
-            if gradio_version.startswith("3."):
-                # Gradio 3.x 版本
-                demo.queue(api_open=True, max_size=30)
-            else:
-                # Gradio 4.x 或更高版本可能有不同的队列API
-                try:
-                    # 尝试新版本的queue方法
-                    demo.queue(api_name="/api", max_size=30)
-                except:
-                    # 如果失败，尝试不带参数的queue方法
-                    demo.queue()
-        except Exception as e:
-            # 任何队列配置错误，记录后继续
-            print(f"配置队列时出错: {e}")
-            print("继续启动应用，但队列功能可能不可用")
-        
-        # 针对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"
+        # 设置标准日志记录，确保足够的调试信息
+        import logging
+        logging.basicConfig(level=logging.INFO, 
+                            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        logger = logging.getLogger("CodeEvalService")
+        logger.info(f"启动代码评估服务，Gradio版本: {gradio_version}")
         
         # 尝试使用兼容所有版本的参数启动
         launch_kwargs = {
-            "server_name": server_name,
-            "server_port": server_port,
+            "server_name": "0.0.0.0",
+            "server_port": int(os.environ.get("PORT", 7860)),
             "share": False,
         }
         
-        # 对于Gradio 3.x添加额外参数
-        if gradio_version.startswith("3."):
-            launch_kwargs.update({
-                "debug": False,
-                "show_api": True,
-                "max_threads": 5,
-                "concurrency_limit": 2
-            })
-        
-        # 启动应用
-        demo.launch(**launch_kwargs)
+        # Gradio 4.x专用的FastAPI初始化
+        if not gradio_version.startswith("3."):
+            # 针对Gradio 4的API配置
+            import fastapi
+            from fastapi import FastAPI
+            
+            # 创建FastAPI应用
+            app = FastAPI(title="代码评估服务API")
+            
+            # 添加队列状态API端点
+            @app.get("/api/queue/status")
+            def get_queue_status_api():
+                return api_get_queue_status()
+                
+            # 添加任务提交API端点
+            @app.post("/api/submit_task")
+            async def submit_task_api(data: list):
+                try:
+                    result = submit_task(data)
+                    return result
+                except Exception as e:
+                    return {"status": "error", "message": str(e)}
+            
+            # 启动应用到FastAPI
+            demo.launch(
+                **launch_kwargs,
+                app=app,
+                max_threads=5,
+            )
+        else:
+            # Gradio 3.x的方式
+            # 设置队列，并添加API支持
+            try:
+                demo.queue(api_open=True, max_size=30)
+            except Exception as e:
+                logger.warning(f"配置队列时出错: {e}")
+            
+            # 启动应用
+            demo.launch(
+                **launch_kwargs,
+                debug=False,
+                show_api=True,
+                max_threads=5,
+                concurrency_limit=2
+            )
+            
     except Exception as e:
-        # 记录错误并使用最简配置重试
         print(f"启动时发生错误: {e}")
-        print("使用最小配置重试...")
+        import traceback
+        traceback.print_exc()
+        
+        # 尝试最简配置启动
         try:
-            # 最小配置，确保应用能启动
+            print("使用最小配置重试...")
             demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
         except Exception as e2:
             print(f"最小配置启动也失败: {e2}")
+            traceback.print_exc()
             
             # 终极回退方案：创建最简单的接口并启动
-            print("尝试创建备用界面...")
             try:
-                import gradio as gr
+                print("尝试创建备用界面...")
                 
+                import gradio as gr
                 def simple_evaluate(json_data):
                     try:
-                        return evaluate(json.loads(json_data) if isinstance(json_data, str) else json_data)
+                        print(f"备用界面收到请求: {json_data[:100] if isinstance(json_data, str) else 'Not a string'}")
+                        data = json.loads(json_data) if isinstance(json_data, str) else json_data
+                        result = submit_task(data)
+                        return json.dumps(result, ensure_ascii=False)
                     except Exception as e:
                         return {"error": str(e)}
                 
                 backup_demo = gr.Interface(
                     fn=simple_evaluate,
                     inputs=gr.Textbox(label="JSON输入"),
-                    outputs=gr.JSON(label="结果"),
+                    outputs=gr.Textbox(label="结果"),
                     title="代码评估服务 (备用界面)",
-                    description="原界面启动失败，这是简化版本"
+                    description="原界面启动失败，这是简化版本。提交格式: [{\"language\": \"python\", \"prompt\": \"def add(a, b):\\n\", \"processed_completions\": [\"    return a + b\"], \"tests\": \"assert add(1, 2) == 3\"}]"
                 )
                 
                 backup_demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
             except Exception as e3:
                 print(f"备用界面也启动失败: {e3}")
+                traceback.print_exc()