Update app.py

app.py

@@ -9,13 +9,9 @@ import psutil
 from flask import Flask, request, jsonify
 from transformers import WhisperProcessor, WhisperForConditionalGeneration
 
-###############################################################################
-# 1) Configure environment & set up model
-###############################################################################
-os.environ["HF_HOME"] = "/tmp/hf_cache"
-os.environ["TRANSFORMERS_CACHE"] = "/tmp/hf_cache"
-os.environ["HF_DATASETS_CACHE"] = "/tmp/hf_cache"
-os.environ["XDG_CACHE_HOME"] = "/tmp"
+# GLOBAL concurrency lock or counter
+concurrent_requests = 0
+concurrent_requests_lock = threading.Lock()
 
 app = Flask(__name__)
 
@@ -26,50 +22,42 @@ model = WhisperForConditionalGeneration.from_pretrained(model_id)
 device = "cuda" if torch.cuda.is_available() else "cpu"
 model.to(device)
 
-# Force Hebrew transcription
 forced_decoder_ids = processor.get_decoder_prompt_ids(language="he", task="transcribe")
 
 WEBHOOK_URL = "https://hook.eu1.make.com/86zogci73u394k2uqpulp5yjjwgm8b9x"
 
-###############################################################################
-# 2) Background transcription function
-###############################################################################
 def transcribe_in_background(audio_url, file_id, company, user, file_name):
+    global concurrent_requests
     try:
-        # Download audio
+        # 1) Download audio
         r = requests.get(audio_url)
         audio_path = "/tmp/temp_audio.wav"
         with open(audio_path, "wb") as f:
             f.write(r.content)
 
-        # Load with librosa, limit to 1 hour
+        # 2) Load audio
         waveform, sr = librosa.load(audio_path, sr=16000)
         max_sec = 3600
         waveform = waveform[: sr * max_sec]
 
-        # Calculate callDuration
         call_duration = int(len(waveform) / sr)
 
-        # Split audio into 25-second chunks
+        # 3) Transcribe in chunks
         chunk_sec = 25
         chunk_size = sr * chunk_sec
         chunks = [waveform[i : i + chunk_size] for i in range(0, len(waveform), chunk_size)]
-
+        
         partial_text = ""
         for chunk in chunks:
             inputs = processor(chunk, sampling_rate=sr, return_tensors="pt", padding=True)
             input_features = inputs.input_features.to(device)
 
             with torch.no_grad():
-                predicted_ids = model.generate(
-                    input_features,
-                    forced_decoder_ids=forced_decoder_ids
-                )
-
+                predicted_ids = model.generate(input_features, forced_decoder_ids=forced_decoder_ids)
             transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
             partial_text += transcription + "\n"
 
-        # Post final transcription back to Make.com
+        # 4) Post final transcription
         payload = {
             "Transcription": partial_text.strip(),
             "callDuration": call_duration,
@@ -81,6 +69,7 @@ def transcribe_in_background(audio_url, file_id, company, user, file_name):
         requests.post(WEBHOOK_URL, json=payload)
 
     except Exception as e:
+        # 5) Handle errors
         error_payload = {
             "error": str(e),
             "fileId": file_id,
@@ -90,23 +79,35 @@ def transcribe_in_background(audio_url, file_id, company, user, file_name):
         }
         requests.post(WEBHOOK_URL, json=error_payload)
 
-###############################################################################
-# 3) Flask route: CPU check and transcription
-###############################################################################
+    finally:
+        # Always decrement concurrency, even on error
+        with concurrent_requests_lock:
+            global concurrent_requests
+            concurrent_requests -= 1
+
 @app.route("/transcribe", methods=["POST"])
 def transcribe_endpoint():
-    # 1) Check CPU usage
-    cpu_usage = psutil.cpu_percent(interval=0.1)  # measure CPU usage over 0.1s
-    if cpu_usage > 40.0:
-        return jsonify({"error": "CPU is busy", "cpuUsage": cpu_usage}), 503
-
-    # 2) Get JSON data
+    global concurrent_requests
+
+    # 1) Check concurrency
+    with concurrent_requests_lock:
+        if concurrent_requests >= 1:
+            # We only allow ONE job at a time
+            return jsonify({"error": "Server is busy with another transcription"}), 503
+        
+        # If it's free, claim the slot
+        concurrent_requests += 1
+
+    # 2) Parse request
     data = request.get_json()
     audio_url = data.get("audio_url")
     if not audio_url:
+        # Since we've already claimed concurrency=1, we should free it
+        with concurrent_requests_lock:
+            concurrent_requests -= 1
         return jsonify({"error": "Missing 'audio_url' in request"}), 400
 
-    # 3) Read headers
+    # 3) Read custom headers
     file_id = request.headers.get("fileId", "")
     company = request.headers.get("company", "")
     user = request.headers.get("user", "")
@@ -119,14 +120,11 @@ def transcribe_endpoint():
     )
     thread.start()
 
-    # 5) Return immediate response
+    # 5) Return an immediate response
     return jsonify({
         "status": "Received. Transcription in progress.",
         "note": "Results will be sent via webhook once done."
     }), 202
 
-###############################################################################
-# 4) Run app locally; HF Spaces uses gunicorn
-###############################################################################
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)