update53

app.py

@@ -42,67 +42,80 @@ def queue_processor():
     """Process tasks in the queue"""
     while running:
         try:
-            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'
-                task_size = len(input_data)
-                task_complexity = _estimate_task_complexity(input_data)
+            # Use get with a timeout to prevent busy waiting
+            try:
+                task_id, input_data, request_time = task_queue.get(timeout=0.5)
+            except queue.Empty:
+                continue
                 
+            try:
                 with lock:
-                    task_status[task_id]['estimated_factors'] = {
-                        'language': language,
-                        'size': task_size,
-                        'complexity': task_complexity
-                    }
-            
-            result = evaluate(input_data)
-            
-            end_time = time.time()
-            process_time = end_time - task_status[task_id]['start_time']
-            
-            with lock:
-                task_status[task_id]['status'] = 'completed'
-                task_status[task_id]['result'] = result
-                task_status[task_id]['end_time'] = end_time
-                task_status[task_id]['process_time'] = process_time
+                    if task_id not in task_status:
+                        # Task was cancelled or removed
+                        task_queue.task_done()
+                        continue
+                        
+                    task_status[task_id]['status'] = 'processing'
+                    task_status[task_id]['start_time'] = time.time()
                 
-                if 'estimated_factors' in task_status[task_id]:
-                    factors = task_status[task_id]['estimated_factors']
-                    key = f"{factors['language']}_{factors['complexity']}"
-                    
-                    if key not in task_type_times:
-                        task_type_times[key] = []
+                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'
+                    task_size = len(input_data)
+                    task_complexity = _estimate_task_complexity(input_data)
                     
-                    task_type_times[key].append(process_time / factors['size'])
-                    if len(task_type_times[key]) > 10:
-                        task_type_times[key] = task_type_times[key][-10:]
+                    with lock:
+                        task_status[task_id]['estimated_factors'] = {
+                            'language': language,
+                            'size': task_size,
+                            'complexity': task_complexity
+                        }
+                
+                result = evaluate(input_data)
+                
+                end_time = time.time()
+                process_time = end_time - task_status[task_id]['start_time']
                 
-                task_history.append({
-                    'task_id': task_id,
-                    'request_time': request_time,
-                    'process_time': process_time,
-                    'status': 'completed',
-                    'factors': task_status[task_id].get('estimated_factors', {})
-                })
-                while len(task_history) > 200:
-                    task_history.pop(0)
-                    
-            task_queue.task_done()
-            
-        except queue.Empty:
-            continue
-        except Exception as e:
-            if 'task_id' in locals():
                 with lock:
-                    task_status[task_id]['status'] = 'error'
-                    task_status[task_id]['error'] = str(e)
-                    task_status[task_id]['end_time'] = time.time()
-            task_queue.task_done()
+                    if task_id in task_status:  # Check if task still exists
+                        task_status[task_id]['status'] = 'completed'
+                        task_status[task_id]['result'] = result
+                        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']}"
+                            
+                            if key not in task_type_times:
+                                task_type_times[key] = []
+                            
+                            task_type_times[key].append(process_time / factors['size'])
+                            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,
+                            'process_time': process_time,
+                            'status': 'completed',
+                            'factors': task_status[task_id].get('estimated_factors', {})
+                        })
+                        while len(task_history) > 200:
+                            task_history.pop(0)
+            except Exception as e:
+                print(f"Error processing task {task_id}: {str(e)}")
+                with lock:
+                    if task_id in task_status:
+                        task_status[task_id]['status'] = 'error'
+                        task_status[task_id]['error'] = str(e)
+                        task_status[task_id]['end_time'] = time.time()
+            finally:
+                task_queue.task_done()
+                
+        except Exception as e:
+            print(f"Critical error in queue processor: {str(e)}")
+            time.sleep(1)  # Avoid tight loop in case of persistent errors
 
 def _estimate_task_complexity(tasks):
     """Estimate task complexity
@@ -214,55 +227,75 @@ def evaluate_code(code, language):
 
 def synchronous_evaluate(input_data):
     """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'
-        task_size = len(input_data)
-        task_complexity = _estimate_task_complexity(input_data)
-    else:
-        language = 'unknown'
-        task_size = 1
-        task_complexity = 'medium'
-    
-    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,
-            'estimated_factors': {
-                'language': language,
-                'size': task_size,
-                'complexity': task_complexity
-            },
-            'estimated_time': estimated_total_time
-        }
-    
-    task_queue.put((task_id, input_data, request_time))
-    
-    while True:
+    try:
+        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'
+            task_size = len(input_data)
+            task_complexity = _estimate_task_complexity(input_data)
+        else:
+            language = 'unknown'
+            task_size = 1
+            task_complexity = 'medium'
+        
+        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:
-            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', 'Unknown error')
-                    task_status.pop(task_id, None)
-                    return {"status": "Exception", "error": error}
+            task_status[task_id] = {
+                'status': 'queued',
+                'queued_time': request_time,
+                'queue_position': task_queue.qsize() + 1,
+                'synchronous': True,
+                'estimated_factors': {
+                    'language': language,
+                    'size': task_size,
+                    'complexity': task_complexity
+                },
+                'estimated_time': estimated_total_time
+            }
+        
+        task_queue.put((task_id, input_data, request_time))
         
-        time.sleep(0.1)
+        # Set a reasonable timeout to avoid hanging
+        max_wait_time = max(300, estimated_total_time * 2)  # At least 5 minutes or double the estimated time
+        start_wait = time.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', 'Unknown error')
+                        task_status.pop(task_id, None)
+                        return {"status": "Exception", "error": error}
+                else:
+                    # Task somehow disappeared
+                    return {"status": "Exception", "error": "Task was lost during processing"}
+            
+            # Check if we've waited too long
+            if time.time() - start_wait > max_wait_time:
+                with lock:
+                    if task_id in task_status:
+                        task_status[task_id]['status'] = 'error'
+                        task_status[task_id]['error'] = f"Task timed out after {max_wait_time} seconds"
+                    return {"status": "Exception", "error": f"Evaluation timed out after {max_wait_time} seconds"}
+            
+            time.sleep(0.1)
+    
+    except Exception as e:
+        print(f"Error in synchronous_evaluate: {str(e)}")
+        return {"status": "Exception", "error": str(e)}
 
 def _get_estimated_time_for_task(language, complexity):
     """Get estimated processing time for a specific task type"""
@@ -647,7 +680,7 @@ with gr.Blocks(css=custom_css) as demo:
     with gr.Row():
         with gr.Column(scale=3):
             # Queue status info card
-            queue_info_html = gr.HTML()
+            queue_info_html = gr.HTML(update_queue_info())
             refresh_queue_btn = gr.Button("Refresh Queue Status", variant="primary")
     
     # Hidden API interface components
@@ -657,10 +690,34 @@ with gr.Blocks(css=custom_css) as demo:
     
     # Define update function
     def update_queue_info():
-        return ui_get_queue_info()
+        try:
+            info = ui_get_queue_info()
+            return info
+        except Exception as e:
+            print(f"Error updating queue info: {str(e)}")
+            return f"""
+            <div class="dashboard">
+                <div class="queue-info-card main-card">
+                    <h3 class="card-title">Queue Status Monitor</h3>
+                    <div class="queue-stats">
+                        <p>Error refreshing queue status. Click refresh to try again.</p>
+                    </div>
+                </div>
+            </div>
+            """
+    
+    # Set up periodic refresh with error handling
+    refresh_interval = 3
+    
+    def safe_refresh():
+        try:
+            return update_queue_info()
+        except Exception as e:
+            print(f"Safe refresh error: {str(e)}")
+            return queue_info_html.value  # Keep existing value on error
     
     # Update queue info periodically
-    demo.load(update_queue_info, None, queue_info_html, every=3)
+    demo.load(safe_refresh, None, queue_info_html, every=refresh_interval)
     
     # Refresh button event
     refresh_queue_btn.click(update_queue_info, None, queue_info_html)
@@ -671,7 +728,15 @@ with gr.Blocks(css=custom_css) as demo:
 
 if __name__ == "__main__":
     try:
-        demo.launch()
+        # Use configuration suitable for Hugging Face Spaces
+        demo.launch(
+            server_name="0.0.0.0",  # Listen on all network interfaces
+            share=False,            # No need for sharing link in Spaces
+            show_error=True,        # Show detailed error messages
+            debug=True,             # Enable debug mode for better error reporting
+            max_threads=10,         # Limit number of threads to avoid resource contention
+            quiet=False             # Log to console for debugging
+        )
     finally:
         # Stop worker threads
         running = False