Update app.py

app.py

@@ -1,12 +1,13 @@
 import os
 
-# Set environment variables so HF uses /tmp for caching
+# Must set environment variables before importing Transformers
 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"
 
-from flask import Flask, request, jsonify
+from flask import Flask, request, jsonify, Response
+import json
 import requests
 import torch
 import librosa
@@ -14,7 +15,8 @@ from transformers import WhisperProcessor, WhisperForConditionalGeneration
 
 app = Flask(__name__)
 
-# Use a multilingual model capable of Hebrew (e.g. whisper-base)
+# Choose a multilingual Whisper model that includes Hebrew.
+# For CPU usage, 'openai/whisper-base' or 'openai/whisper-tiny' are typical.
 model_id = "openai/whisper-base"
 processor = WhisperProcessor.from_pretrained(model_id)
 model = WhisperForConditionalGeneration.from_pretrained(model_id)
@@ -22,36 +24,36 @@ model = WhisperForConditionalGeneration.from_pretrained(model_id)
 device = "cuda" if torch.cuda.is_available() else "cpu"
 model.to(device)
 
-# Force Hebrew transcription tokens so no auto-detect occurs
+# Force Hebrew to avoid short-audio meltdown with auto-detect
 forced_decoder_ids = processor.get_decoder_prompt_ids(language="he", task="transcribe")
 
 def transcribe_audio(audio_url):
-    # 1) Download audio file to /tmp
+    # 1) Download audio to /tmp
     response = requests.get(audio_url)
     audio_path = "/tmp/temp_audio.wav"
     with open(audio_path, "wb") as f:
         f.write(response.content)
 
-    # 2) Load with librosa
+    # 2) Load audio with librosa
     waveform, sr = librosa.load(audio_path, sr=16000)
 
-    # 3) Optional: limit to 1 hour
+    # 3) Limit up to 1 hour for stability
     max_sec = 3600
     waveform = waveform[: sr * max_sec]
 
-    # 4) Split into 25-second chunks (or pick any chunk size)
+    # 4) Chunk the audio in 25-second intervals
     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:
-        # Preprocess chunk to mel
+        # Preprocess chunk → mel spectrogram
         inputs = processor(chunk, sampling_rate=sr, return_tensors="pt", padding=True)
         input_features = inputs.input_features.to(device)
 
+        # Force Hebrew to skip auto-detect logic
         with torch.no_grad():
-            # Force Hebrew so no meltdown on short audio
             predicted_ids = model.generate(
                 input_features,
                 forced_decoder_ids=forced_decoder_ids
@@ -69,8 +71,16 @@ def transcribe_endpoint():
     if not audio_url:
         return jsonify({"error": "Missing 'audio_url' in request"}), 400
 
+    # Perform forced-Hebrew transcription
     text = transcribe_audio(audio_url)
-    return jsonify({"transcription": text})
+
+    # Return JSON with no ASCII escaping (ensures real Hebrew chars)
+    payload = {"Transcription": text}
+    return Response(
+        json.dumps(payload, ensure_ascii=False),
+        status=200,
+        mimetype="application/json; charset=utf-8"
+    )
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)