Update app.py

app.py

@@ -3,9 +3,8 @@ from faster_whisper import WhisperModel
 import torch
 import io
 import time
-from threading import Lock
-from queue import Queue
 import datetime
+from threading import Semaphore
 
 app = Flask(__name__)
 
@@ -18,11 +17,20 @@ print(f"Using device: {device} with compute_type: {compute_type}")
 beamsize = 2
 wmodel = WhisperModel("guillaumekln/faster-whisper-small", device=device, compute_type=compute_type)
 
-# Server status tracking
+# Concurrency control
+MAX_CONCURRENT_REQUESTS = 2  # Adjust based on your server capacity
+request_semaphore = Semaphore(MAX_CONCURRENT_REQUESTS)
 active_requests = 0
-request_queue = Queue()
-status_lock = Lock()
-MAX_CONCURRENT_REQUESTS = 2 # Adjust based on your server capacity
+
+# Warm up the model (important for CUDA)
+print("Warming up the model...")
+try:
+    dummy_audio = io.BytesIO(b'')  # Empty audio for warmup
+    segments, info = wmodel.transcribe(dummy_audio, beam_size=beamsize)
+    _ = [segment.text for segment in segments]  # Force execution
+    print("Model warmup complete")
+except Exception as e:
+    print(f"Model warmup failed: {str(e)}")
 
 @app.route("/health", methods=["GET"])
 def health_check():
@@ -31,27 +39,18 @@ def health_check():
         'status': 'API is running',
         'timestamp': datetime.datetime.now().isoformat(),
         'device': device,
-        'compute_type': compute_type
+        'compute_type': compute_type,
+        'active_requests': active_requests
     })
 
 @app.route("/status/busy", methods=["GET"])
 def server_busy():
     """Endpoint to check if server is busy"""
-    with status_lock:
-        is_busy = active_requests >= MAX_CONCURRENT_REQUESTS
-        return jsonify({
-            'is_busy': is_busy,
-            'active_requests': active_requests,
-            'max_capacity': MAX_CONCURRENT_REQUESTS,
-            'queue_size': request_queue.qsize()
-        })
-
-@app.route("/status/queue", methods=["GET"])
-def queue_status():
-    """Endpoint to get current queue size"""
+    is_busy = active_requests >= MAX_CONCURRENT_REQUESTS
     return jsonify({
-        'queue_size': request_queue.qsize(),
-        'active_requests': active_requests
+        'is_busy': is_busy,
+        'active_requests': active_requests,
+        'max_capacity': MAX_CONCURRENT_REQUESTS
     })
 
 @app.route("/whisper_transcribe", methods=["POST"])
@@ -59,16 +58,15 @@ def whisper_transcribe():
     global active_requests
     
     # Check if server is at capacity
-    with status_lock:
-        if active_requests >= MAX_CONCURRENT_REQUESTS:
-            request_queue.put(datetime.datetime.now())
-            return jsonify({
-                'status': 'Server busy',
-                'message': f'Currently processing {active_requests} requests',
-                'queue_position': request_queue.qsize()
-            }), 503
-        
-        active_requests += 1
+    if not request_semaphore.acquire(blocking=False):
+        return jsonify({
+            'status': 'Server busy',
+            'message': f'Currently processing {active_requests} requests',
+            'suggestion': 'Please try again shortly'
+        }), 503
+    
+    active_requests += 1
+    print(f"Starting transcription (Active requests: {active_requests})")
     
     try:
         if 'audio' not in request.files:
@@ -79,30 +77,41 @@ def whisper_transcribe():
         if not (audio_file and audio_file.filename.lower().split('.')[-1] in allowed_extensions):
             return jsonify({'error': 'Invalid file format'}), 400
 
-        print(f"Transcribing audio on {device} (Active requests: {active_requests})")
         audio_bytes = audio_file.read()
         audio_file = io.BytesIO(audio_bytes)
 
         try:
+            # Timeout handling (60 seconds max processing time)
+            start_time = time.time()
             segments, info = wmodel.transcribe(audio_file, beam_size=beamsize)
+            
             text = ''
-            starttime = time.time()
             for segment in segments:
+                if time.time() - start_time > 60:  # Timeout after 60 seconds
+                    raise TimeoutError("Transcription took too long")
                 text += segment.text
-            print(f"Time to transcribe: {time.time() - starttime} seconds")
-            return jsonify({'transcription': text})
+            
+            processing_time = time.time() - start_time
+            print(f"Transcription completed in {processing_time:.2f} seconds")
+            
+            return jsonify({
+                'transcription': text,
+                'processing_time': processing_time,
+                'language': info.language,
+                'language_probability': info.language_probability
+            })
+            
+        except TimeoutError:
+            print("Transcription timeout")
+            return jsonify({'error': 'Transcription timeout'}), 504
         except Exception as e:
             print(f"Transcription error: {str(e)}")
             return jsonify({'error': 'Transcription failed'}), 500
+            
     finally:
-        with status_lock:
-            active_requests -= 1
-            # Remove oldest queued request if any
-            if not request_queue.empty():
-                try:
-                    request_queue.get_nowait()
-                except:
-                    pass
+        active_requests -= 1
+        request_semaphore.release()
+        print(f"Request completed (Active requests: {active_requests})")
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", debug=True, port=7860, threaded=True)