update40

app.py

@@ -37,13 +37,30 @@ worker_threads = max(1, multiprocessing.cpu_count() // 2)  # Using half the avai
 running = True
 # Mapping from task type to processing time
 task_type_times = {}
+# Currently processing tasks counter
+processing_count = 0
 
 def queue_processor():
     """Process tasks in the queue"""
+    global processing_count
+    
     while running:
         try:
+            # Only process if we haven't reached worker thread limit
+            with lock:
+                if processing_count >= worker_threads:
+                    # Already at max capacity, wait and try again
+                    time.sleep(0.5)
+                    continue
+                    
+            # Get a task from the queue with small timeout to prevent blocking
             task_id, input_data, request_time = task_queue.get(timeout=0.1)
+            
+            # Increment processing count to track active tasks
             with lock:
+                processing_count += 1
+                
+                # Update task status
                 if task_id in task_status:
                     task_status[task_id]['status'] = 'processing'
                     task_status[task_id]['start_time'] = time.time()
@@ -74,6 +91,10 @@ def queue_processor():
             process_time = end_time - task_status[task_id]['start_time']
             
             with lock:
+                # Decrease processing count now that we're done
+                processing_count -= 1
+                
+                # Update task status
                 task_status[task_id]['status'] = 'completed'
                 task_status[task_id]['result'] = result
                 task_status[task_id]['end_time'] = end_time
@@ -107,6 +128,9 @@ def queue_processor():
         except Exception as e:
             if 'task_id' in locals():
                 with lock:
+                    # Decrease processing count on error
+                    processing_count -= 1
+                    
                     if task_id in task_status:
                         task_status[task_id]['status'] = 'error'
                         task_status[task_id]['error'] = str(e)
@@ -229,45 +253,9 @@ 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()
-    
-    # Add task to queue and update UI first
-    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
-        }
-    
-    # Show task in UI for at least 1 second to ensure visibility
-    time.sleep(1)
-    
-    # Add to queue for processing
-    task_queue.put((task_id, input_data, request_time))
+    # Create a task and queue it
+    task_info = enqueue_task(input_data)
+    task_id = task_info['task_id']
     
     # Wait for task to complete
     while True:
@@ -325,6 +313,7 @@ def enqueue_task(input_data):
     task_id = str(uuid.uuid4())
     request_time = time.time()
     
+    # Add to task_status with 'queued' status first
     with lock:
         task_status[task_id] = {
             'status': 'queued',
@@ -338,9 +327,11 @@ def enqueue_task(input_data):
             'estimated_time': estimated_total_time
         }
     
+    # Get queue info for wait time estimation
     queue_info = get_queue_status()
     est_wait = queue_info['estimated_wait']
     
+    # Add to the task queue - this must be done AFTER adding to task_status
     task_queue.put((task_id, input_data, request_time))
     
     return {
@@ -371,7 +362,7 @@ def get_queue_status():
         processing_tasks = [t for t in task_status.values() if t['status'] == 'processing']
         
         queue_size = task_queue.qsize()
-        active_tasks = len(processing_tasks)
+        active_tasks = processing_count
         waiting_tasks = len(queued_tasks)
         
         remaining_processing_time = 0