change from base64 to file upload

app.py

@@ -293,26 +293,36 @@ def upload_file():
         print(f"Error in upload endpoint: {str(e)}")
         return jsonify({'error': str(e)}), 500
 
-async def upload_file_to_fal(file_path, api_key):
+# Global variable to store the event loop for FAL uploads
+fal_upload_loop = None
+fal_upload_thread = None
+
+def get_or_create_fal_loop():
+    """Get or create a persistent event loop for FAL uploads"""
+    global fal_upload_loop, fal_upload_thread
+    
+    if fal_upload_loop is None or not fal_upload_loop.is_running():
+        # Create new event loop in a separate thread
+        fal_upload_loop = asyncio.new_event_loop()
+        
+        def run_loop():
+            asyncio.set_event_loop(fal_upload_loop)
+            fal_upload_loop.run_forever()
+        
+        fal_upload_thread = Thread(target=run_loop, daemon=True)
+        fal_upload_thread.start()
+        
+        # Give the loop a moment to start
+        import time
+        time.sleep(0.1)
+    
+    return fal_upload_loop
+
+async def upload_file_to_fal_async(file_path, api_key):
     """Helper function to upload a file to FAL storage"""
     os.environ['FAL_KEY'] = api_key
     return await fal_client.upload_file_async(file_path)
 
-def run_upload_task(file_path, api_key):
-    """Run the upload task with proper event loop management"""
-    try:
-        # Create a new event loop for this thread
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        try:
-            result = loop.run_until_complete(upload_file_to_fal(file_path, api_key))
-            return result
-        finally:
-            loop.close()
-    except Exception as e:
-        print(f"Error in run_upload_task: {str(e)}")
-        raise
-
 @app.route('/api/upload-to-fal', methods=['POST'])
 def upload_to_fal():
     """Upload base64 image data to FAL storage and return the URL"""
@@ -345,13 +355,26 @@ def upload_to_fal():
                 tmp_file_path = tmp_file.name
             
             try:
-                # Upload to FAL using the helper function with proper event loop management
-                fal_url = run_upload_task(tmp_file_path, api_key)
+                # Get or create the persistent event loop
+                loop = get_or_create_fal_loop()
+                
+                # Schedule the upload coroutine and wait for result
+                future = asyncio.run_coroutine_threadsafe(
+                    upload_file_to_fal_async(tmp_file_path, api_key),
+                    loop
+                )
+                
+                # Wait for the result with a timeout
+                fal_url = future.result(timeout=30)
+                
                 print(f"[DEBUG] Uploaded to FAL: {fal_url}")
                 return jsonify({'url': fal_url}), 200
             finally:
                 # Clean up temporary file
-                os.unlink(tmp_file_path)
+                try:
+                    os.unlink(tmp_file_path)
+                except:
+                    pass
         else:
             # If it's already a URL, return it as-is
             return jsonify({'url': image_data}), 200