Update app.py

app.py

@@ -1,236 +1,124 @@
-# spam.py (optimized backend)
-# Install: pip install flask flask-socketio gradio_client eventlet
+# spam_space_backend.py
+# Install: pip install flask flask-socketio gradio_client
 
-from flask import Flask, request, render_template
+from flask import Flask, request
 from flask_socketio import SocketIO, emit
 from gradio_client import Client, handle_file
-import os
-import base64
-import logging
-import threading
-import time
-import re
+import os, base64, threading, time, logging
 from datetime import datetime, timedelta
 
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+# ----------------- Logging -----------------
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+# ----------------- Flask + SocketIO -----------------
 app = Flask(__name__)
-# Increased timeouts to prevent disconnections during long API calls
-socketio = SocketIO(app, 
-                   cors_allowed_origins="*", 
-                   ping_timeout=300,  # Increased to 5 minutes
-                   ping_interval=60,  # Increased to 1 minute
-                   max_http_buffer_size=10 * 1024 * 1024,  # 10MB max file size
-                   async_mode='eventlet')
-
-# Replace with your ACTUAL runtime URL from "Use via API" (e.g., https://tonyassi-voice-clone.hf.space)
-HF_SPACE_URL = "https://tonyassi-voice-clone.hf.space"  # Update this!
+# Use 'threading' mode for maximum compatibility on Spaces
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode='threading')
 
+# ----------------- HF Space -----------------
+HF_SPACE_URL = "https://tonyassi-voice-clone.hf.space"  # Replace with your Space API URL
 try:
-    logger.info(f"Loading Gradio Client for {HF_SPACE_URL}...")
     client = Client(HF_SPACE_URL)
-    logger.info("Client loaded successfully!")
-except ValueError as e:
-    logger.error(f"Failed to load client: {e}")
-    print(f"ERROR: Invalid URL. Visit https://huggingface.co/spaces/tonyassi/voice-clone, click 'Use via API', and copy the base URL.")
-    exit(1)
+    logger.info("Gradio Client loaded successfully!")
 except Exception as e:
-    logger.error(f"Unexpected error loading client: {e}")
+    logger.error(f"Failed to load client: {e}")
     exit(1)
 
-# Store active tasks and quota information
+# ----------------- Task & Quota Tracking -----------------
 active_tasks = {}
-quota_info = {
-    'reset_time': None,
-    'retry_after': None
-}
+quota_info = {"reset_time": None, "retry_after": None}
 
-@app.route('/status')
+# ----------------- Routes -----------------
+@app.route("/status")
 def status_check():
-    """Health check endpoint for monitoring"""
-    return {
-        'status': 'ok',
-        'quota_reset_time': quota_info['reset_time'],
-        'active_tasks': len(active_tasks)
-    }
-
-@socketio.on('connect')
+    return {"status": "ok", "active_tasks": len(active_tasks), "quota_reset_time": quota_info["reset_time"]}
+
+# ----------------- SocketIO Events -----------------
+@socketio.on("connect")
 def handle_connect():
-    logger.info('Client connected: %s', request.sid)
-    # Send current quota status to newly connected client
-    if quota_info['reset_time'] and quota_info['reset_time'] > datetime.now():
-        time_left = quota_info['reset_time'] - datetime.now()
-        hours, remainder = divmod(time_left.total_seconds(), 3600)
-        minutes, seconds = divmod(remainder, 60)
-        emit('error', {'message': f'GPU quota exceeded. Try again in {int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}'})
-    else:
-        emit('status', {'message': 'Connected to backend'})
-
-@socketio.on('disconnect')
+    sid = request.sid
+    logger.info(f"Client connected: {sid}")
+    emit("status", {"message": "Connected to backend"})
+
+@socketio.on("disconnect")
 def handle_disconnect():
-    logger.info('Client disconnected: %s', request.sid)
-    # Clean up any active tasks for this client
-    if request.sid in active_tasks:
-        del active_tasks[request.sid]
+    sid = request.sid
+    logger.info(f"Client disconnected: {sid}")
+    if sid in active_tasks:
+        del active_tasks[sid]
 
-@socketio.on('generate_voice')
+@socketio.on("generate_voice")
 def handle_generate_voice(data):
+    sid = request.sid
     try:
-        sid = request.sid
-        logger.info('Generate voice request from: %s', sid)
-        
-        # Check if we're in a quota timeout period
-        if quota_info['reset_time'] and quota_info['reset_time'] > datetime.now():
-            time_left = quota_info['reset_time'] - datetime.now()
-            hours, remainder = divmod(time_left.total_seconds(), 3600)
-            minutes, seconds = divmod(remainder, 60)
-            emit('error', {'message': f'GPU quota exceeded. Try again in {int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}'})
+        text = data.get("text")
+        audio_base64 = data.get("audio")
+
+        if not text or not audio_base64:
+            emit("error", {"message": "Text or audio missing"})
             return
-        
-        text = data['text']
-        audio_base64 = data['audio']  # Base64 from frontend
-        
-        if not text:
-            raise ValueError("No text provided")
-        
-        # Store that this client has an active task
-        active_tasks[sid] = {
-            'start_time': datetime.now(),
-            'status': 'processing'
-        }
-        
-        # Send immediate acknowledgement
-        emit('status', {'message': 'Processing your request...'})
-        
-        # Run the processing in a thread to avoid blocking
-        thread = threading.Thread(target=process_voice, args=(sid, text, audio_base64))
-        thread.daemon = True
-        thread.start()
-        
+
+        # Track active task
+        active_tasks[sid] = {"start_time": datetime.now(), "status": "processing"}
+        emit("status", {"message": "Processing request..."})
+
+        # Process in background thread
+        threading.Thread(target=process_voice, args=(sid, text, audio_base64), daemon=True).start()
+
     except Exception as e:
-        logger.error(f"Error in generate_voice handler: {e}")
-        emit('error', {'message': f"Failed to process request: {str(e)}"})
-        # Clean up task tracking
+        logger.error(f"Error in generate_voice: {e}")
+        emit("error", {"message": f"Failed to process request: {str(e)}"})
         if sid in active_tasks:
             del active_tasks[sid]
 
-def process_voice(sid, text, audio_base64, retry_count=0):
-    """Process voice generation in a separate thread with retry logic"""
-    max_retries = 2  # Maximum number of retry attempts
-    
+# ----------------- Voice Processing -----------------
+def process_voice(sid, text, audio_base64):
+    temp_audio_path = f"/tmp/temp_reference_{sid}.wav"
     try:
-        # Decode base64 to temp file (skip prefix like 'data:audio/wav;base64,')
-        if audio_base64.startswith('data:'):
-            audio_base64 = audio_base64.split(',')[1]
-        
-        audio_data = base64.b64decode(audio_base64)
-        temp_audio_path = f'/tmp/temp_reference_{sid}.wav'  # Unique filename for each client
-        with open(temp_audio_path, 'wb') as f:
-            f.write(audio_data)
-        
-        logger.info("Calling HF Space for client: %s (attempt %d)", sid, retry_count + 1)
-        
-        # Send progress update
-        with app.app_context():
-            socketio.emit('status', {'message': f'Calling Hugging Face API... (Attempt {retry_count + 1})'}, room=sid)
-        
-        # Call the API with timeout handling
-        try:
-            # Call the API (api_name="/predict" matches Gradio's default for your Interface)
-            result = client.predict(
-                text,
-                handle_file(temp_audio_path),
-                api_name="/predict"
-            )
-        except Exception as api_error:
-            # Check if it's a timeout error and we should retry
-            if "timeout" in str(api_error).lower() and retry_count < max_retries:
-                logger.warning("API timeout for client %s, retrying... (attempt %d)", sid, retry_count + 1)
-                with app.app_context():
-                    socketio.emit('status', {'message': f'Timeout occurred, retrying... (Attempt {retry_count + 2})'}, room=sid)
-                # Wait a bit before retrying
-                time.sleep(5)
-                # Retry the request
-                process_voice(sid, text, audio_base64, retry_count + 1)
-                return
-            else:
-                raise api_error  # Re-raise if not a timeout or max retries exceeded
-        
-        # Send progress update
-        with app.app_context():
-            socketio.emit('status', {'message': 'Processing audio response...'}, room=sid)
-        
-        # Read and encode output to base64
-        with open(result, 'rb') as f:
+        # Decode audio
+        if audio_base64.startswith("data:"):
+            audio_base64 = audio_base64.split(",")[1]
+        with open(temp_audio_path, "wb") as f:
+            f.write(base64.b64decode(audio_base64))
+
+        # Call HF Space API
+        socketio.emit("status", {"message": "Calling HF Space API..."}, room=sid)
+        result_path = client.predict(text, handle_file(temp_audio_path), api_name="/predict")
+
+        # Read result and send back
+        with open(result_path, "rb") as f:
             output_audio = f.read()
-        output_base64 = base64.b64encode(output_audio).decode('utf-8')
-        
-        # Cleanup
-        try:
-            os.remove(temp_audio_path)
-            if os.path.exists(result):
-                os.remove(result)
-        except Exception as cleanup_error:
-            logger.warning("Cleanup error for client %s: %s", sid, cleanup_error)
-        
-        logger.info("Generation complete for client: %s", sid)
-        
-        # Send results back to the specific client
-        with app.app_context():
-            socketio.emit('voice_generated', {'audio': f'data:audio/wav;base64,{output_base64}'}, room=sid)
-            socketio.emit('status', {'message': 'Generation complete'}, room=sid)
-            
+        output_base64 = base64.b64encode(output_audio).decode("utf-8")
+
+        socketio.emit("voice_generated", {"audio": f"data:audio/wav;base64,{output_base64}"}, room=sid)
+        socketio.emit("status", {"message": "Generation complete"}, room=sid)
+
     except Exception as e:
-        logger.error(f"Error in process_voice for client {sid}: {e}")
-        
-        # Check if this is a GPU quota error
-        error_msg = str(e)
-        if "quota" in error_msg.lower():
-            # Try to parse the time from the error message
-            time_match = re.search(r'Try again in (\d+):(\d+):(\d+)', error_msg)
-            if time_match:
-                hours, minutes, seconds = map(int, time_match.groups())
-                reset_time = datetime.now() + timedelta(hours=hours, minutes=minutes, seconds=seconds)
-                quota_info['reset_time'] = reset_time
-                quota_info['retry_after'] = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
-                
-                logger.warning("GPU quota exceeded. Resets at: %s", reset_time)
-                error_msg = f"GPU quota exceeded. Try again in {hours:02d}:{minutes:02d}:{seconds:02d}"
-        
-        with app.app_context():
-            socketio.emit('error', {'message': f"Generation failed: {error_msg}"}, room=sid)
+        logger.error(f"Error in process_voice: {e}")
+        socketio.emit("error", {"message": f"Generation failed: {str(e)}"}, room=sid)
     finally:
-        # Clean up task tracking
+        # Cleanup
+        if os.path.exists(temp_audio_path):
+            os.remove(temp_audio_path)
         if sid in active_tasks:
             del active_tasks[sid]
 
+# ----------------- Cleanup Thread -----------------
 def cleanup_old_files():
-    """Clean up temporary files older than 1 hour"""
-    try:
+    while True:
         now = time.time()
-        for filename in os.listdir('/tmp'):
-            if filename.startswith('temp_reference_') and filename.endswith('.wav'):
-                filepath = os.path.join('/tmp', filename)
-                if os.path.isfile(filepath) and now - os.path.getctime(filepath) > 3600:
-                    os.remove(filepath)
-                    logger.info("Cleaned up old file: %s", filename)
-    except Exception as e:
-        logger.warning("Error during cleanup: %s", e)
-
-# Start a background thread for periodic cleanup
-def start_cleanup_thread():
-    def cleanup_loop():
-        while True:
-            time.sleep(3600)  # Clean up every hour
-            cleanup_old_files()
-    
-    thread = threading.Thread(target=cleanup_loop)
-    thread.daemon = True
-    thread.start()
-
-if __name__ == '__main__':
-    logger.info("Starting backend with improved timeout and quota handling...")
-    start_cleanup_thread()
-    socketio.run(app, host='0.0.0.0', port=5000, debug=True, allow_unsafe_werkzeug=True)
+        for f in os.listdir("/tmp"):
+            if f.startswith("temp_reference_") and f.endswith(".wav"):
+                path = os.path.join("/tmp", f)
+                if now - os.path.getctime(path) > 3600:  # 1 hour
+                    os.remove(path)
+                    logger.info(f"Removed old file: {f}")
+        time.sleep(3600)
+
+threading.Thread(target=cleanup_old_files, daemon=True).start()
+
+# ----------------- Main -----------------
+if __name__ == "__main__":
+    logger.info("Starting backend...")
+    socketio.run(app, host="0.0.0.0", port=5000, debug=True)