ui fix

app.py

@@ -116,31 +116,43 @@ async def process_fal_request(request_id, model_endpoint, fal_arguments, api_key
 def run_async_task(request_id, model_endpoint, fal_arguments, api_key):
     """Run async task with proper event loop management"""
     print(f"[DEBUG run_async_task] Starting for request {request_id}")
+    
+    # Always create a fresh event loop for each task to avoid conflicts
+    loop = None
     try:
-        # Use asyncio.run() which properly creates and closes a new event loop
-        # This avoids the "event loop is closed" error on subsequent requests
-        result = asyncio.run(process_fal_request(request_id, model_endpoint, fal_arguments, api_key))
+        # Create a new event loop for this thread
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        # Run the async task in the new loop
+        result = loop.run_until_complete(process_fal_request(request_id, model_endpoint, fal_arguments, api_key))
         print(f"[DEBUG run_async_task] Completed with result keys: {result.keys() if result else 'None'}")
-    except RuntimeError as e:
-        # Handle case where an event loop is already running (shouldn't happen with asyncio.run)
-        if "There is no current event loop" in str(e) or "Event loop is closed" in str(e):
-            print(f"[ERROR run_async_task] Event loop error, creating new loop: {str(e)}")
-            # Fallback: create a completely new event loop
-            loop = asyncio.new_event_loop()
-            try:
-                result = loop.run_until_complete(process_fal_request(request_id, model_endpoint, fal_arguments, api_key))
-                print(f"[DEBUG run_async_task] Completed with fallback loop")
-            finally:
-                loop.close()
-        else:
-            print(f"[ERROR run_async_task] Runtime error: {str(e)}")
-            import traceback
-            traceback.print_exc()
-            raise
+        
     except Exception as e:
         print(f"[ERROR run_async_task] Failed: {str(e)}")
         import traceback
         traceback.print_exc()
+        # Update the request status to error
+        if request_id in active_requests:
+            active_requests[request_id]['status'] = 'error'
+            active_requests[request_id]['error'] = str(e)
+    finally:
+        # Always close and cleanup the event loop
+        if loop:
+            try:
+                # Cancel any remaining tasks
+                pending = asyncio.all_tasks(loop)
+                for task in pending:
+                    task.cancel()
+                # Run until all tasks are cancelled
+                if pending:
+                    loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+            except Exception as cleanup_error:
+                print(f"[WARNING] Error during loop cleanup: {cleanup_error}")
+            finally:
+                loop.close()
+                # Clear the event loop from the thread
+                asyncio.set_event_loop(None)
 
 @app.route('/api/generate', methods=['POST'])
 def generate():
@@ -299,26 +311,37 @@ async def upload_file_to_fal_async(file_path, api_key):
     return await fal_client.upload_file_async(file_path)
 
 def upload_to_fal_sync(file_path, api_key):
-    """Synchronous wrapper for FAL upload using asyncio.run()"""
+    """Synchronous wrapper for FAL upload with isolated event loop"""
+    loop = None
     try:
-        # Use asyncio.run() which creates a fresh event loop for each request
-        # This avoids the "event loop is closed" error on subsequent requests
-        result = asyncio.run(upload_file_to_fal_async(file_path, api_key))
+        # Always create a fresh event loop for uploads to avoid conflicts
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        # Run the upload in the new loop
+        result = loop.run_until_complete(upload_file_to_fal_async(file_path, api_key))
         return result
-    except RuntimeError as e:
-        # Handle case where an event loop might already be running
-        if "There is no current event loop" in str(e) or "Event loop is closed" in str(e):
-            print(f"[ERROR upload_to_fal_sync] Event loop error, creating new loop: {str(e)}")
-            # Fallback: create a completely new event loop
-            loop = asyncio.new_event_loop()
+        
+    except Exception as e:
+        print(f"[ERROR upload_to_fal_sync] Upload failed: {str(e)}")
+        raise
+    finally:
+        # Always close and cleanup the event loop
+        if loop:
             try:
-                asyncio.set_event_loop(loop)
-                result = loop.run_until_complete(upload_file_to_fal_async(file_path, api_key))
-                return result
+                # Cancel any remaining tasks
+                pending = asyncio.all_tasks(loop)
+                for task in pending:
+                    task.cancel()
+                # Run until all tasks are cancelled
+                if pending:
+                    loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+            except Exception as cleanup_error:
+                print(f"[WARNING] Error during upload loop cleanup: {cleanup_error}")
             finally:
                 loop.close()
-        else:
-            raise
+                # Clear the event loop from the thread
+                asyncio.set_event_loop(None)
 
 @app.route('/api/upload-to-fal', methods=['POST'])
 def upload_to_fal():