Update app.py

app.py

@@ -731,10 +731,11 @@ def create_status_display(space_activity):
     
     return status_display
 
-def select_space_with_enhanced_collision_avoidance(space_activity, student_id, repo):
-    """改进的空间选择函数，包含本地防撞车机制"""
+# 修改select_space函数以使用新的状态显示
+def select_space_with_enhanced_collision_avoidance_cached(space_activity, student_id, repo):
+    """使用缓存的增强防撞空间选择函数"""
     
-    print(f"[select_space_with_enhanced_collision_avoidance] Starting selection for student: {student_id}")
+    print(f"[select_space_with_enhanced_collision_avoidance_cached] Starting selection for student: {student_id}")
     
     # 第一步：过滤掉不符合基本条件的空间
     basic_available_spaces = []
@@ -745,7 +746,7 @@ def select_space_with_enhanced_collision_avoidance(space_activity, student_id, r
             not space['is_recently_allocated_local']):
             basic_available_spaces.append(space)
     
-    print(f"[select_space_with_enhanced_collision_avoidance] Basic available spaces: {len(basic_available_spaces)}")
+    print(f"[select_space_with_enhanced_collision_avoidance_cached] Basic available spaces: {len(basic_available_spaces)}")
     
     if not basic_available_spaces:
         # 生成详细的错误信息
@@ -767,19 +768,19 @@ def select_space_with_enhanced_collision_avoidance(space_activity, student_id, r
             f"**Please try again in 1-2 minutes.**"
         )
         
-        print(f"[select_space_with_enhanced_collision_avoidance] No available spaces: {error_msg}")
+        print(f"[select_space_with_enhanced_collision_avoidance_cached] No available spaces: {error_msg}")
         raise gr.Error(error_msg, duration=10)
     
     # 第二步：选择最优空间并进行最终验证
     selected_space = basic_available_spaces[0]  # 已经按idle_time排序
     space_name = selected_space['space_name']
     
-    print(f"[select_space_with_enhanced_collision_avoidance] Preliminary selection: {space_name}")
+    print(f"[select_space_with_enhanced_collision_avoidance_cached] Preliminary selection: {space_name}")
     
     # 第三步：最终防撞车检查 - 再次验证本地分配状态
     is_local_conflict, conflicting_student = local_tracker.is_recently_allocated_locally(space_name)
     if is_local_conflict:
-        print(f"[select_space_with_enhanced_collision_avoidance] COLLISION DETECTED! {space_name} recently allocated to {conflicting_student}")
+        print(f"[select_space_with_enhanced_collision_avoidance_cached] COLLISION DETECTED! {space_name} recently allocated to {conflicting_student}")
         
         # 寻找替代空间
         alternative_spaces = [s for s in basic_available_spaces[1:] 
@@ -788,37 +789,52 @@ def select_space_with_enhanced_collision_avoidance(space_activity, student_id, r
         if alternative_spaces:
             selected_space = alternative_spaces[0]
             space_name = selected_space['space_name']
-            print(f"[select_space_with_enhanced_collision_avoidance] Using alternative space: {space_name}")
+            print(f"[select_space_with_enhanced_collision_avoidance_cached] Using alternative space: {space_name}")
         else:
             error_msg = (
                 f"🚫 **Collision detected and no alternatives available**\n\n"
                 f"The system detected a potential conflict with another student's allocation.\n\n"
                 f"**Please try again in 10-15 seconds.**"
             )
-            print(f"[select_space_with_enhanced_collision_avoidance] No alternatives available")
+            print(f"[select_space_with_enhanced_collision_avoidance_cached] No alternatives available")
             raise gr.Error(error_msg, duration=8)
     
     # 第四步：立即记录本地分配（在写入文件之前）
     local_tracker.record_local_allocation(space_name, student_id)
-    print(f"[select_space_with_enhanced_collision_avoidance] Local allocation recorded BEFORE file write")
+    print(f"[select_space_with_enhanced_collision_avoidance_cached] Local allocation recorded BEFORE file write")
     
     # 第五步：记录到文件和远程
     write_success = write_allocation_record(space_name, student_id, repo.local_dir)
     if write_success:
         push_success = simple_push_allocation_record(repo, space_name, student_id)
         if not push_success:
-            print(f"[select_space_with_enhanced_collision_avoidance] Warning: Allocation recorded locally but not synced to remote")
+            print(f"[select_space_with_enhanced_collision_avoidance_cached] Warning: Allocation recorded locally but not synced to remote")
     else:
-        print(f"[select_space_with_enhanced_collision_avoidance] Warning: Failed to record allocation to file")
+        print(f"[select_space_with_enhanced_collision_avoidance_cached] Warning: Failed to record allocation to file")
     
-    # 第六步：生成结果
-    status_display = create_status_display(space_activity)
+    # 第六步：生成结果（使用带缓存信息的状态显示）
+    status_display = create_status_display_with_cache_info(space_activity)
     redirect_url = f"https://huggingface.co/spaces/CIV3283/{space_name}/?check={student_id}"
     
-    print(f"[select_space_with_enhanced_collision_avoidance] Final allocation: {space_name} -> {student_id}")
+    print(f"[select_space_with_enhanced_collision_avoidance_cached] Final allocation: {space_name} -> {student_id}")
     
     return redirect_to_space(redirect_url, selected_space, status_display)
 
+def get_cache_status():
+    """获取缓存状态（用于调试或管理）"""
+    global activity_cache
+    if activity_cache:
+        return activity_cache.get_cache_info()
+    return {"error": "Cache not initialized"}
+
+def force_cache_update():
+    """强制更新缓存（用于调试或管理）"""
+    global activity_cache
+    if activity_cache:
+        activity_cache.force_update()
+        return {"status": "Cache updated"}
+    return {"error": "Cache not initialized"}
+
 def redirect_to_space(redirect_url, selected_space, status_display):
     """Display redirect information with manual click option"""
     
@@ -880,9 +896,9 @@ def redirect_to_space(redirect_url, selected_space, status_display):
     
     return gr.HTML(redirect_html)
 
-def load_balance_user_final(student_id):
-    """最终版本的负载均衡函数"""
-    print(f"[load_balance_user_final] Starting cached load balancing for student ID: {student_id}")
+def load_balance_user_cached(student_id):
+    """使用缓存的负载均衡函数"""
+    print(f"[load_balance_user_cached] Starting cached load balancing for student ID: {student_id}")
     
     # Initialize connection to data storage
     repo = init_data_storage_connection()
@@ -901,9 +917,8 @@ def load_balance_user_final(student_id):
     # 使用缓存版本的分析函数
     space_activity = analyze_space_activity_cached(available_spaces, LOCAL_DATA_DIR)
     
-    # 使用缓存版本的选择函数
-    return select_space_with_enhanced_collision_avoidance_cached(space_activity, student_id, repo)
-
+    # Select space with enhanced collision avoidance
+    return select_space_with_enhanced_collision_avoidance(space_activity, student_id, repo)
 
 def get_url_params(request: gr.Request):
     """Extract URL parameters from request"""
@@ -916,8 +931,48 @@ def get_url_params(request: gr.Request):
             return "Load Distributor", None
     return "Load Distributor", None
 
-def handle_user_access_final(request: gr.Request):
-    """最终版本的用户访问处理"""
+def create_status_display_with_cache_info(space_activity):
+    """创建包含缓存信息的状态显示"""
+    global activity_cache
+    
+    # 获取缓存状态
+    cache_info = activity_cache.get_cache_info() if activity_cache else None
+    
+    status_display = "📊 **Current Space Status (sorted by availability):**<br><br>"
+    
+    # 显示缓存信息
+    if cache_info:
+        if cache_info['is_fresh']:
+            cache_status = f"✅ Fresh (updated {cache_info['age_minutes']:.1f} min ago)"
+        else:
+            cache_status = f"⚠️ Stale (updated {cache_info['age_minutes']:.1f} min ago)"
+        
+        status_display += f"🔄 **Cache Status:** {cache_status}<br>"
+        status_display += f"📋 **Cached Spaces:** {cache_info['spaces_count']}<br><br>"
+    
+    # 显示本地分配记录摘要
+    local_summary = local_tracker.get_recent_allocations_summary()
+    if local_summary:
+        status_display += "🔒 **Recent Local Allocations:**<br>"
+        for alloc in local_summary:
+            status_display += f"&nbsp;&nbsp;&nbsp;• {alloc}<br>"
+        status_display += "<br>"
+    
+    for i, space in enumerate(space_activity, 1):
+        status_display += f"{i}. **{space['space_name']}**<br>"
+        status_display += f"&nbsp;&nbsp;&nbsp;• Status: {space['status']}<br>"
+        status_display += f"&nbsp;&nbsp;&nbsp;• Last activity: {space['last_activity_str']}<br>"
+        
+        # 显示缓存状态（可选）
+        if 'cached_status' in space:
+            status_display += f"&nbsp;&nbsp;&nbsp;• Cache: {space['cached_status']}<br>"
+        
+        status_display += "<br>"
+    
+    return status_display
+
+def handle_user_access_cached(request: gr.Request):
+    """使用缓存的用户访问处理"""
     title, check_id = get_url_params(request)
     
     if not check_id:
@@ -936,7 +991,7 @@ def handle_user_access_final(request: gr.Request):
     
     # Valid student ID - perform cached load balancing
     try:
-        result = load_balance_user_final(check_id)
+        result = load_balance_user_cached(check_id)
         return title, result
     except Exception as e:
         # Handle any errors during load balancing