aync change

app.py

@@ -6,6 +6,7 @@ A Flask-based web interface for image editing using ByteDance's SeedDream model
 import os
 import json
 import requests
+import asyncio
 from flask import Flask, render_template, request, jsonify, send_from_directory
 from flask_cors import CORS
 import fal_client
@@ -13,6 +14,9 @@ from werkzeug.utils import secure_filename
 import base64
 import tempfile
 from pathlib import Path
+import uuid
+from threading import Thread
+from concurrent.futures import ThreadPoolExecutor
 
 app = Flask(__name__)
 CORS(app)
@@ -25,6 +29,12 @@ app.config['UPLOAD_FOLDER'] = tempfile.gettempdir()
 Path("static").mkdir(exist_ok=True)
 Path("templates").mkdir(exist_ok=True)
 
+# Store active request handlers
+active_requests = {}
+
+# Thread pool for async operations
+executor = ThreadPoolExecutor(max_workers=10)
+
 @app.route('/')
 def index():
     """Serve the main HTML interface"""
@@ -35,9 +45,62 @@ def serve_static(filename):
     """Serve static files (CSS, JS)"""
     return send_from_directory('static', filename)
 
+async def process_fal_request(request_id, model_endpoint, fal_arguments, api_key):
+    """Process FAL API request asynchronously"""
+    try:
+        # Set API key for this request
+        os.environ['FAL_KEY'] = api_key
+        
+        # Submit the request asynchronously
+        handler = await fal_client.submit_async(
+            model_endpoint,
+            arguments=fal_arguments,
+        )
+        
+        # Store handler info
+        active_requests[request_id] = {
+            'handler': handler,
+            'status': 'processing',
+            'logs': [],
+            'result': None
+        }
+        
+        # Collect logs asynchronously
+        async for event in handler.iter_events(with_logs=True):
+            if hasattr(event, 'logs') and event.logs:
+                for log in event.logs:
+                    active_requests[request_id]['logs'].append(log.get("message", ""))
+        
+        # Get the final result
+        result = await handler.get()
+        
+        # Update request status
+        active_requests[request_id]['status'] = 'completed'
+        active_requests[request_id]['result'] = result
+        
+        # Add logs to result
+        if active_requests[request_id]['logs']:
+            result['logs'] = active_requests[request_id]['logs']
+        
+        return result
+        
+    except Exception as e:
+        active_requests[request_id]['status'] = 'error'
+        active_requests[request_id]['error'] = str(e)
+        raise
+
+def run_async_task(request_id, model_endpoint, fal_arguments, api_key):
+    """Run async task in a new event loop"""
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        loop.run_until_complete(process_fal_request(request_id, model_endpoint, fal_arguments, api_key))
+    finally:
+        loop.close()
+
 @app.route('/api/generate', methods=['POST'])
 def generate():
-    """Handle image generation requests"""
+    """Handle image generation requests (non-blocking)"""
     try:
         # Get request data
         data = request.json
@@ -49,9 +112,9 @@ def generate():
         auth_header = request.headers.get('Authorization', '')
         if auth_header.startswith('Bearer '):
             api_key = auth_header.replace('Bearer ', '')
-            # Temporarily set the API key for this request
-            os.environ['FAL_KEY'] = api_key
-        elif not os.environ.get('FAL_KEY'):
+        elif os.environ.get('FAL_KEY'):
+            api_key = os.environ.get('FAL_KEY')
+        else:
             return jsonify({'error': 'API key not provided'}), 401
         
         # Prepare arguments for FAL API
@@ -88,33 +151,56 @@ def generate():
         if 'enable_safety_checker' in data:
             fal_arguments['enable_safety_checker'] = data['enable_safety_checker']
         
-        # Create a logs collector
-        logs = []
+        # Generate unique request ID
+        request_id = str(uuid.uuid4())
         
-        def on_queue_update(update):
-            """Handle queue updates and collect logs"""
-            if isinstance(update, fal_client.InProgress):
-                for log in update.logs:
-                    logs.append(log.get("message", ""))
-        
-        # Call FAL API with subscribe (blocking call)
-        result = fal_client.subscribe(
-            model_endpoint,
-            arguments=fal_arguments,
-            with_logs=True,
-            on_queue_update=on_queue_update
-        )
+        # Initialize request tracking
+        active_requests[request_id] = {
+            'status': 'submitted',
+            'logs': [],
+            'result': None
+        }
         
-        # Add logs to the response
-        if logs:
-            result['logs'] = logs
+        # Start async processing in background thread
+        thread = Thread(target=run_async_task, args=(request_id, model_endpoint, fal_arguments, api_key))
+        thread.start()
         
-        return jsonify(result), 200
+        # Return request ID immediately (non-blocking)
+        return jsonify({
+            'request_id': request_id,
+            'status': 'submitted',
+            'message': 'Request submitted successfully'
+        }), 202
         
     except Exception as e:
         print(f"Error in generate endpoint: {str(e)}")
         return jsonify({'error': str(e)}), 500
 
+@app.route('/api/status/<request_id>', methods=['GET'])
+def check_status(request_id):
+    """Check the status of a generation request"""
+    if request_id not in active_requests:
+        return jsonify({'error': 'Request not found'}), 404
+    
+    request_info = active_requests[request_id]
+    
+    response = {
+        'request_id': request_id,
+        'status': request_info['status'],
+        'logs': request_info.get('logs', [])
+    }
+    
+    if request_info['status'] == 'completed':
+        response['result'] = request_info['result']
+        # Clean up completed request after retrieval
+        del active_requests[request_id]
+    elif request_info['status'] == 'error':
+        response['error'] = request_info.get('error', 'Unknown error')
+        # Clean up errored request after retrieval
+        del active_requests[request_id]
+    
+    return jsonify(response), 200
+
 @app.route('/api/upload', methods=['POST'])
 def upload_file():
     """Handle file uploads and return data URL"""

static/script.js

@@ -341,9 +341,10 @@ function getAPIKey() {
     return apiKey || localStorage.getItem('fal_api_key');
 }
 
-// Call FAL API (proxy through backend)
+// Call FAL API (proxy through backend) - Non-blocking version
 async function callFalAPI(apiKey, requestData, model) {
-    const response = await fetch('/api/generate', {
+    // Submit the request (non-blocking)
+    const submitResponse = await fetch('/api/generate', {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
@@ -353,12 +354,53 @@ async function callFalAPI(apiKey, requestData, model) {
         body: JSON.stringify(requestData)
     });
     
-    if (!response.ok) {
-        const error = await response.text();
+    if (!submitResponse.ok) {
+        const error = await submitResponse.text();
         throw new Error(error || 'API request failed');
     }
     
-    return await response.json();
+    const { request_id } = await submitResponse.json();
+    addLog(`Request submitted with ID: ${request_id}`);
+    
+    // Poll for results
+    let attempts = 0;
+    const maxAttempts = 120; // 2 minutes with 1-second intervals
+    const pollInterval = 1000; // 1 second
+    
+    while (attempts < maxAttempts) {
+        await new Promise(resolve => setTimeout(resolve, pollInterval));
+        
+        const statusResponse = await fetch(`/api/status/${request_id}`);
+        if (!statusResponse.ok) {
+            throw new Error('Failed to check request status');
+        }
+        
+        const statusData = await statusResponse.json();
+        
+        // Add any new logs
+        if (statusData.logs && statusData.logs.length > 0) {
+            statusData.logs.forEach(log => {
+                if (log && !log.includes('Request submitted')) {
+                    addLog(log);
+                }
+            });
+        }
+        
+        if (statusData.status === 'completed') {
+            return statusData.result;
+        } else if (statusData.status === 'error') {
+            throw new Error(statusData.error || 'Generation failed');
+        }
+        
+        attempts++;
+        
+        // Update progress indicator
+        if (attempts % 5 === 0) {
+            addLog(`Processing... (${attempts}s elapsed)`);
+        }
+    }
+    
+    throw new Error('Request timed out after 2 minutes');
 }
 
 // Display results