Update app.py

app.py

@@ -4,6 +4,7 @@ import requests
 import threading
 import torch
 import librosa
+import psutil
 
 from flask import Flask, request, jsonify
 from transformers import WhisperProcessor, WhisperForConditionalGeneration
@@ -25,38 +26,31 @@ model = WhisperForConditionalGeneration.from_pretrained(model_id)
 device = "cuda" if torch.cuda.is_available() else "cpu"
 model.to(device)
 
-# Force Hebrew transcription (skip auto-detect)
+# Force Hebrew transcription
 forced_decoder_ids = processor.get_decoder_prompt_ids(language="he", task="transcribe")
 
-# Where we send the final transcription
 WEBHOOK_URL = "https://hook.eu1.make.com/86zogci73u394k2uqpulp5yjjwgm8b9x"
 
 ###############################################################################
 # 2) Background transcription function
 ###############################################################################
-def transcribe_in_background(audio_url, file_id, company, user):
-    """
-    Called by a background thread. Downloads & transcribes audio,
-    then sends results to your Make.com webhook.
-    """
+def transcribe_in_background(audio_url, file_id, company, user, file_name):
     try:
-        # 1) Download the audio
+        # Download audio
         r = requests.get(audio_url)
         audio_path = "/tmp/temp_audio.wav"
         with open(audio_path, "wb") as f:
             f.write(r.content)
 
-        # 2) Load with librosa
+        # Load with librosa, limit to 1 hour
         waveform, sr = librosa.load(audio_path, sr=16000)
-
-        # Optional: limit to ~1 hour
         max_sec = 3600
         waveform = waveform[: sr * max_sec]
 
-        # Calculate total duration actually analyzed
-        call_duration = int(len(waveform) / sr)  # Rounded to nearest second
+        # Calculate callDuration
+        call_duration = int(len(waveform) / sr)
 
-        # 3) Split audio into 25-second chunks
+        # Split audio into 25-second chunks
         chunk_sec = 25
         chunk_size = sr * chunk_sec
         chunks = [waveform[i : i + chunk_size] for i in range(0, len(waveform), chunk_size)]
@@ -75,58 +69,64 @@ def transcribe_in_background(audio_url, file_id, company, user):
             transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
             partial_text += transcription + "\n"
 
-        # 4) Post final transcription back to Make.com, including extra fields
+        # Post final transcription back to Make.com
         payload = {
             "Transcription": partial_text.strip(),
             "callDuration": call_duration,
             "fileId": file_id,
             "company": company,
-            "user": user
+            "user": user,
+            "fileName": file_name
         }
         requests.post(WEBHOOK_URL, json=payload)
 
     except Exception as e:
-        # In case of errors, notify the webhook
         error_payload = {
             "error": str(e),
             "fileId": file_id,
             "company": company,
-            "user": user
-            # You could optionally include "callDuration" here if relevant
+            "user": user,
+            "fileName": file_name
         }
         requests.post(WEBHOOK_URL, json=error_payload)
 
 ###############################################################################
-# 3) Flask route: returns immediately, transcribes in a separate thread
+# 3) Flask route: CPU check and transcription
 ###############################################################################
 @app.route("/transcribe", methods=["POST"])
 def transcribe_endpoint():
-    # 1) Get JSON data from request
+    # 1) Check CPU usage
+    cpu_usage = psutil.cpu_percent(interval=0.1)  # measure CPU usage over 0.1s
+    if cpu_usage > 1.0:
+        return jsonify({"error": "CPU is busy", "cpuUsage": cpu_usage}), 503
+
+    # 2) Get JSON data
     data = request.get_json()
     audio_url = data.get("audio_url")
     if not audio_url:
         return jsonify({"error": "Missing 'audio_url' in request"}), 400
 
-    # 2) Read custom headers (fileId, company, user)
+    # 3) Read headers
     file_id = request.headers.get("fileId", "")
     company = request.headers.get("company", "")
     user = request.headers.get("user", "")
+    file_name = request.headers.get("fileName", "")
 
-    # 3) Spawn a thread to handle transcription
+    # 4) Spawn a background thread
     thread = threading.Thread(
         target=transcribe_in_background,
-        args=(audio_url, file_id, company, user)
+        args=(audio_url, file_id, company, user, file_name)
     )
     thread.start()
 
-    # 4) Immediately return a JSON response
+    # 5) Return immediate response
     return jsonify({
         "status": "Received. Transcription in progress.",
         "note": "Results will be sent via webhook once done."
     }), 202
 
 ###############################################################################
-# 4) Run app if local; on HF Spaces, gunicorn is used
+# 4) Run app locally; HF Spaces uses gunicorn
 ###############################################################################
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)