Update app.py

app.py

@@ -3,6 +3,8 @@ import os
 import csv
 from datetime import datetime, timedelta
 from huggingface_hub import Repository
+import threading
+import time
 
 # Configuration
 DATA_STORAGE_REPO = "CIV3283/Data_Storage"
@@ -12,6 +14,83 @@ MIN_IDLE_MINUTES = 10  # Minimum idle time required for space assignment
 ALLOCATION_RECORD_FILE = "allocation_records.csv"  # New file for tracking allocations
 ALLOCATION_LOCK_DURATION = 5  # Lock duration in minutes
 
+# 新增：本地防撞车机制
+class LocalAllocationTracker:
+    def __init__(self):
+        self._recent_allocations = {}  # {space_name: {'student_id': str, 'timestamp': datetime}}
+        self._lock = threading.Lock()
+        self._cleanup_interval = 60  # 清理间隔（秒）
+        self._allocation_ttl = 30   # 本地分配记录的生存时间（秒）
+        
+        # 启动后台清理线程
+        self._start_cleanup_thread()
+    
+    def _start_cleanup_thread(self):
+        """启动后台线程定期清理过期的本地分配记录"""
+        def cleanup_worker():
+            while True:
+                time.sleep(self._cleanup_interval)
+                self._cleanup_expired_allocations()
+        
+        cleanup_thread = threading.Thread(target=cleanup_worker, daemon=True)
+        cleanup_thread.start()
+        print("[LocalAllocationTracker] Background cleanup thread started")
+    
+    def _cleanup_expired_allocations(self):
+        """清理过期的本地分配记录"""
+        with self._lock:
+            current_time = datetime.now()
+            expired_spaces = []
+            
+            for space_name, alloc_info in self._recent_allocations.items():
+                if (current_time - alloc_info['timestamp']).total_seconds() > self._allocation_ttl:
+                    expired_spaces.append(space_name)
+            
+            for space_name in expired_spaces:
+                del self._recent_allocations[space_name]
+                print(f"[LocalAllocationTracker] Cleaned up expired allocation: {space_name}")
+    
+    def is_recently_allocated_locally(self, space_name):
+        """检查空间是否在本地被最近分配过"""
+        with self._lock:
+            if space_name not in self._recent_allocations:
+                return False, None
+            
+            alloc_info = self._recent_allocations[space_name]
+            current_time = datetime.now()
+            elapsed_seconds = (current_time - alloc_info['timestamp']).total_seconds()
+            
+            if elapsed_seconds > self._allocation_ttl:
+                # 过期了，删除记录
+                del self._recent_allocations[space_name]
+                print(f"[LocalAllocationTracker] Expired local allocation removed: {space_name}")
+                return False, None
+            
+            print(f"[LocalAllocationTracker] Space {space_name} recently allocated locally to {alloc_info['student_id']} ({elapsed_seconds:.1f}s ago)")
+            return True, alloc_info['student_id']
+    
+    def record_local_allocation(self, space_name, student_id):
+        """记录本地分配"""
+        with self._lock:
+            self._recent_allocations[space_name] = {
+                'student_id': student_id,
+                'timestamp': datetime.now()
+            }
+            print(f"[LocalAllocationTracker] Locally recorded allocation: {space_name} -> {student_id}")
+    
+    def get_recent_allocations_summary(self):
+        """获取最近本地分配的摘要（用于调试）"""
+        with self._lock:
+            current_time = datetime.now()
+            summary = []
+            for space_name, alloc_info in self._recent_allocations.items():
+                elapsed = (current_time - alloc_info['timestamp']).total_seconds()
+                summary.append(f"{space_name} -> {alloc_info['student_id']} ({elapsed:.1f}s ago)")
+            return summary
+
+# 全局实例
+local_tracker = LocalAllocationTracker()
+
 # Environment variables
 HF_HUB_TOKEN = os.environ.get("HF_HUB_TOKEN", None)
 if HF_HUB_TOKEN is None:
@@ -123,7 +202,7 @@ def get_last_activity_time(csv_file_path):
         return datetime.min
 
 def read_allocation_records(repo_dir):
-    """Read and parse allocation records, returning only non-expired allocations (similar to query log reading)"""
+    """Read and parse allocation records, returning only non-expired allocations"""
     allocation_file = os.path.join(repo_dir, ALLOCATION_RECORD_FILE)
     current_time = datetime.now()
     active_allocations = {}
@@ -193,7 +272,7 @@ def read_allocation_records(repo_dir):
     return active_allocations
 
 def write_allocation_record(space_name, student_id, repo_dir):
-    """Write a new allocation record to the file (similar to query log approach)"""
+    """Write a new allocation record to the file"""
     allocation_file = os.path.join(repo_dir, ALLOCATION_RECORD_FILE)
     current_time = datetime.now()
     expires_at = current_time + timedelta(minutes=ALLOCATION_LOCK_DURATION)
@@ -220,7 +299,7 @@ def write_allocation_record(space_name, student_id, repo_dir):
                 except StopIteration:
                     pass  # Empty file or no header
         
-        # Append new allocation record (similar to query log writing)
+        # Append new allocation record
         with open(allocation_file, 'w', newline='', encoding='utf-8') as f:
             writer = csv.writer(f)
             # Write header
@@ -244,7 +323,7 @@ def write_allocation_record(space_name, student_id, repo_dir):
         return False
 
 def simple_push_allocation_record(repo, space_name, student_id):
-    """Simple push allocation record using Repository API (similar to how query logs are handled)"""
+    """Simple push allocation record using Repository API"""
     try:
         # Use Repository's push_to_hub method instead of git commands
         commit_message = f"Allocate {space_name} to student {student_id}"
@@ -288,12 +367,17 @@ def analyze_space_activity(available_spaces, repo_dir):
             status = f"Idle for {idle_minutes:.1f} minutes"
             last_activity_str = last_activity.strftime('%Y-%m-%d %H:%M:%S')
         
-        # Check if space is recently allocated
-        is_recently_allocated = space_name in active_allocations
-        if is_recently_allocated:
+        # Check if space is recently allocated (remote)
+        is_recently_allocated_remote = space_name in active_allocations
+        if is_recently_allocated_remote:
             alloc_info = active_allocations[space_name]
             minutes_until_free = (alloc_info['expires_at'] - current_time).total_seconds() / 60
-            status += f" (Recently allocated, free in {minutes_until_free:.1f} min)"
+            status += f" (Recently allocated remotely, free in {minutes_until_free:.1f} min)"
+        
+        # Check if space is recently allocated (local)
+        is_recently_allocated_local, local_student = local_tracker.is_recently_allocated_locally(space_name)
+        if is_recently_allocated_local:
+            status += f" (Recently allocated locally to {local_student})"
         
         space_activity.append({
             'space_name': space_name,
@@ -301,7 +385,8 @@ def analyze_space_activity(available_spaces, repo_dir):
             'last_activity_str': last_activity_str,
             'idle_minutes': idle_minutes,
             'status': status,
-            'is_recently_allocated': is_recently_allocated
+            'is_recently_allocated_remote': is_recently_allocated_remote,
+            'is_recently_allocated_local': is_recently_allocated_local
         })
         
         print(f"[analyze_space_activity] {space_name}: {status}")
@@ -315,6 +400,14 @@ def create_status_display(space_activity):
     """Create formatted status display for all spaces with proper line breaks"""
     status_display = "📊 **Current Space Status (sorted by availability):**<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>"
@@ -322,74 +415,96 @@ def create_status_display(space_activity):
     
     return status_display
 
-def select_space_with_boundary_check(space_activity, student_id, repo):
-    """Select space with strict boundary conditions and allocation recording"""
+def select_space_with_enhanced_collision_avoidance(space_activity, student_id, repo):
+    """改进的空间选择函数，包含本地防撞车机制"""
     
-    # Filter out recently allocated spaces
-    available_spaces = [s for s in space_activity 
-                       if s['idle_minutes'] >= MIN_IDLE_MINUTES and not s['is_recently_allocated']]
+    print(f"[select_space_with_enhanced_collision_avoidance] Starting selection for student: {student_id}")
     
-    if not available_spaces:
-        # Check what's preventing allocation
+    # 第一步：过滤掉不符合基本条件的空间
+    basic_available_spaces = []
+    for space in space_activity:
+        # 检查基本条件
+        if (space['idle_minutes'] >= MIN_IDLE_MINUTES and 
+            not space['is_recently_allocated_remote'] and 
+            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)}")
+    
+    if not basic_available_spaces:
+        # 生成详细的错误信息
         idle_spaces = [s for s in space_activity if s['idle_minutes'] >= MIN_IDLE_MINUTES]
-        recently_allocated_spaces = [s for s in space_activity if s['is_recently_allocated']]
+        remote_allocated = [s for s in space_activity if s['is_recently_allocated_remote']]
+        local_allocated = [s for s in space_activity if s['is_recently_allocated_local']]
         
-        if idle_spaces and not recently_allocated_spaces:
-            # All spaces are busy (used within the last 30 minutes)
-            most_idle = space_activity[0] if space_activity else None
-            
-            if most_idle:
-                if most_idle['idle_minutes'] == float('inf'):
-                    idle_info = "Never used"
-                else:
-                    idle_info = f"{most_idle['idle_minutes']:.1f} minutes ago"
-                
-                error_msg = (
-                    f"🚫 **All learning assistants are currently busy**\n\n"
-                    f"All spaces have been used within the last {MIN_IDLE_MINUTES} minutes.\n\n"
-                    f"**Current Status:**\n"
-                    f"• Most idle space: {most_idle['space_name']}\n"
-                    f"• Last used: {idle_info}\n\n"
-                    f"**Please try again in a few minutes.**"
-                )
-            else:
-                error_msg = "🚫 No learning assistant spaces are available at the moment."
+        error_parts = []
+        if not idle_spaces:
+            error_parts.append(f"all spaces used within {MIN_IDLE_MINUTES} minutes")
+        if remote_allocated:
+            error_parts.append(f"{len(remote_allocated)} spaces remotely allocated")
+        if local_allocated:
+            error_parts.append(f"{len(local_allocated)} spaces locally allocated")
+        
+        error_msg = (
+            f"🚫 **All learning assistants are currently busy**\n\n"
+            f"Blocking conditions: {', '.join(error_parts)}\n\n"
+            f"**Please try again in 1-2 minutes.**"
+        )
+        
+        print(f"[select_space_with_enhanced_collision_avoidance] 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}")
+    
+    # 第三步：最终防撞车检查 - 再次验证本地分配状态
+    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}")
+        
+        # 寻找替代空间
+        alternative_spaces = [s for s in basic_available_spaces[1:] 
+                            if not local_tracker.is_recently_allocated_locally(s['space_name'])[0]]
+        
+        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}")
         else:
-            # Spaces are recently allocated
             error_msg = (
-                f"🚫 **All learning assistants are currently busy or recently allocated**\n\n"
-                f"Some spaces are being assigned to other students right now.\n\n"
-                f"**Please try again in 1-2 minutes.**"
+                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_boundary_check] No available spaces: {error_msg}")
-        raise gr.Error(error_msg, duration=10)
+            print(f"[select_space_with_enhanced_collision_avoidance] No alternatives available")
+            raise gr.Error(error_msg, duration=8)
     
-    # Select the most idle space
-    selected_space = available_spaces[0]
-    print(f"[select_space_with_boundary_check] Selected space: {selected_space['space_name']}")
+    # 第四步：立即记录本地分配（在写入文件之前）
+    local_tracker.record_local_allocation(space_name, student_id)
+    print(f"[select_space_with_enhanced_collision_avoidance] Local allocation recorded BEFORE file write")
     
-    # Record the allocation BEFORE building the response
-    write_success = write_allocation_record(selected_space['space_name'], student_id, repo.local_dir)
+    # 第五步：记录到文件和远程
+    write_success = write_allocation_record(space_name, student_id, repo.local_dir)
     if write_success:
-        # Try to push to remote (non-blocking)
-        push_success = simple_push_allocation_record(repo, selected_space['space_name'], student_id)
+        push_success = simple_push_allocation_record(repo, space_name, student_id)
         if not push_success:
-            print(f"[select_space_with_boundary_check] Warning: Allocation recorded locally but not synced to remote")
+            print(f"[select_space_with_enhanced_collision_avoidance] Warning: Allocation recorded locally but not synced to remote")
     else:
-        print(f"[select_space_with_boundary_check] Warning: Failed to record allocation")
-        # Continue anyway - worst case is potential double allocation, but user gets service
+        print(f"[select_space_with_enhanced_collision_avoidance] Warning: Failed to record allocation to file")
     
-    # Create status display
+    # 第六步：生成结果
     status_display = create_status_display(space_activity)
+    redirect_url = f"https://huggingface.co/spaces/CIV3283/{space_name}/?check={student_id}"
     
-    # Build redirect URL
-    redirect_url = f"https://huggingface.co/spaces/CIV3283/{selected_space['space_name']}/?check={student_id}"
+    print(f"[select_space_with_enhanced_collision_avoidance] Final allocation: {space_name} -> {student_id}")
     
     return redirect_to_space(redirect_url, selected_space, status_display)
 
 def redirect_to_space(redirect_url, selected_space, status_display):
-    """Display redirect information with manual click option (HF Spaces can't auto-redirect)"""
+    """Display redirect information with manual click option"""
     
     if selected_space['idle_minutes'] == float('inf'):
         idle_info = "Never used (completely fresh)"
@@ -435,7 +550,7 @@ def redirect_to_space(redirect_url, selected_space, status_display):
 {status_display}
             </div>
             <p style="margin-bottom: 0; color: #666; font-size: 14px; margin-top: 15px;">
-                <strong>Selection Algorithm:</strong> Spaces idle for ≥{MIN_IDLE_MINUTES} minutes and not recently allocated are eligible. The most idle space is automatically selected for optimal load distribution.
+                <strong>Enhanced Selection Algorithm:</strong> Spaces idle for ≥{MIN_IDLE_MINUTES} minutes, not remotely allocated, and not locally allocated are eligible. The system includes real-time collision avoidance to prevent multiple students from being assigned to the same space.
             </p>
         </div>
         
@@ -450,8 +565,8 @@ def redirect_to_space(redirect_url, selected_space, status_display):
     return gr.HTML(redirect_html)
 
 def load_balance_user(student_id):
-    """Main load balancing function with allocation recording"""
-    print(f"[load_balance_user] Starting load balancing for student ID: {student_id}")
+    """Main load balancing function with enhanced collision avoidance"""
+    print(f"[load_balance_user] Starting enhanced load balancing for student ID: {student_id}")
     
     # Initialize connection to data storage
     repo = init_data_storage_connection()
@@ -464,11 +579,11 @@ def load_balance_user(student_id):
     if not available_spaces:
         raise gr.Error("🚫 No student learning assistant spaces found in the system. Please contact your instructor.", duration=8)
     
-    # Analyze space activity (including allocation records)
+    # Analyze space activity (including both remote and local allocation records)
     space_activity = analyze_space_activity(available_spaces, LOCAL_DATA_DIR)
     
-    # Select space with boundary checking and allocation recording
-    return select_space_with_boundary_check(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"""
@@ -482,51 +597,4 @@ def get_url_params(request: gr.Request):
     return "Load Distributor", None
 
 def handle_user_access(request: gr.Request):
-    """Handle user access and perform load balancing"""
-    title, check_id = get_url_params(request)
-    
-    if not check_id:
-        # No student ID provided
-        error_html = """
-        <div style="max-width: 600px; margin: 50px auto; padding: 30px; text-align: center; 
-                    background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 12px;">
-            <h2 style="color: #856404;">⚠️ Invalid Access</h2>
-            <p style="color: #856404; font-size: 16px; line-height: 1.6;">
-                This load distributor requires a valid student ID parameter.<br><br>
-                <strong>Please access this system through the official link provided in Moodle.</strong>
-            </p>
-        </div>
-        """
-        return title, gr.HTML(error_html)
-    
-    # Valid student ID - perform load balancing
-    try:
-        result = load_balance_user(check_id)
-        return title, result
-    except Exception as e:
-        # Handle any errors during load balancing
-        error_html = f"""
-        <div style="max-width: 600px; margin: 50px auto; padding: 30px; text-align: center; 
-                    background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 12px;">
-            <h2 style="color: #721c24;">🚫 Load Balancing Error</h2>
-            <p style="color: #721c24; font-size: 16px; line-height: 1.6;">
-                {str(e)}<br><br>
-                Please try again in a few moments or contact your instructor if the problem persists.
-            </p>
-        </div>
-        """
-        return title, gr.HTML(error_html)
-
-# Create Gradio interface
-with gr.Blocks(title="CIV3283 Load Distributor") as interface:
-    title_display = gr.Markdown("# 🔄 CIV3283 Learning Assistant Load Distributor", elem_id="title")
-    content_display = gr.HTML("")
-    
-    # Initialize on page load
-    interface.load(
-        fn=handle_user_access,
-        outputs=[title_display, content_display]
-    )
-
-if __name__ == "__main__":
-    interface.launch()
+    """Handle user access an