Update app.py

app.py

@@ -1,8 +1,8 @@
-# app.py — Íslenskt ASR – ZeroGPU Fully Stateless Fix (Dec 2025)
+# app.py — Íslenskt ASR – ZeroGPU Fully Fixed (Dec 2025 – handles str audio + CUDA safe)
 import os
 os.environ["OMP_NUM_THREADS"] = "1"
 os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "garbage_collection_threshold:0.6,max_split_size_mb:128"
-# Force CPU-only at import to prevent any lazy CUDA init
+# Disable CUDA visibility at startup to prevent main process init
 os.environ["CUDA_VISIBLE_DEVICES"] = ""
 
 import gradio as gr
@@ -10,35 +10,62 @@ import spaces
 from transformers import pipeline
 import torch
 import gc
+import librosa  # For loading audio bytes if needed
+import io
+import soundfile as sf  # For writing temp files from bytes
 
 MODEL_NAME = "palli23/whisper-small-sam_spjall"
 
 @spaces.GPU(duration=180, max_batch_size=4)
-def transcribe_3min_gpu(audio_path):
+def transcribe_3min_gpu(audio_input):
     """
-    FULLY SELF-CONTAINED GPU FUNCTION – no globals, no prior CUDA touches.
-    Loads model fresh on CPU first, then moves to GPU INSIDE worker.
+    Handles both filepath (str) and uploaded bytes/temp files.
+    Loads model on CPU first, moves to GPU inside worker.
     """
-    if not audio_path:
+    if not audio_input:
         return "Hlaðið upp hljóðskrá (mp3/wav, max 5 mín)"
     
+    # Handle str (filepath) vs bytes/tuple from Gradio upload
+    if isinstance(audio_input, str):
+        audio_path = audio_input
+    else:
+        # audio_input is tuple (filepath, tuple(bytes, sample_rate)) or just bytes
+        if isinstance(audio_input, tuple) and len(audio_input) > 0:
+            audio_path = audio_input[0]  # Temp filepath from upload
+        else:
+            # Fallback: write bytes to temp file if no path
+            if isinstance(audio_input, bytes):
+                audio_bytes = audio_input
+            else:
+                return "Ógild hljóðskrá – reyndu aftur"
+            
+            # Assume 16kHz sample rate for Whisper (common fallback)
+            sample_rate = 16000
+            # Load with librosa if needed, but for simplicity write to temp
+            with io.BytesIO(audio_bytes) as audio_io:
+                # Use soundfile to write temp wav
+                with sf.SoundFile(audio_io, 'r') as f:
+                    data, sr = f.read(), f.samplerate
+                    if sr != 16000:
+                        data = librosa.resample(data, orig_sr=sr, target_sr=16000)
+                # Write to temp file
+                audio_path = "/tmp/temp_audio.wav"
+                sf.write(audio_path, data, 16000)
+    
     try:
-        print("Loading Whisper model on CPU first (safe init)...")
-        # Load on CPU explicitly to avoid any CUDA during model download/init
+        print("Loading Whisper model on CPU first (safe for ZeroGPU)...")
+        # Load pipeline on CPU – no CUDA touch
         pipe = pipeline(
             "automatic-speech-recognition",
             model=MODEL_NAME,
             torch_dtype=torch.float16,
-            device="cpu",  # ← KEY FIX: CPU first, no CUDA yet
+            device="cpu",  # Critical: CPU init only
             token=os.getenv("HF_TOKEN"),
         )
         
-        # Now move to GPU – this happens INSIDE @spaces.GPU worker, safe!
-        print("Moving model to GPU...")
-        pipe.model = pipe.model.to("cuda")
-        pipe.device = "cuda"
-        if hasattr(pipe, 'model_decoder'):
-            pipe.model_decoder = pipe.model_decoder.to("cuda")
+        # Now inside GPU worker: move entire pipeline to CUDA
+        print("Moving pipeline to GPU (ZeroGPU safe)...")
+        pipe = pipe.to("cuda")
         
         # Run inference
         print("Running transcription...")
@@ -46,18 +73,18 @@ def transcribe_3min_gpu(audio_path):
             audio_path,
             chunk_length_s=30,
             stride_length_s=(6, 0),
-            batch_size=8,
+            batch_size=4,  # Smaller batch for ZeroGPU stability
             return_timestamps=False,
             generate_kwargs={"language": "is", "task": "transcribe"},
         )
         
         text = result["text"].strip()
         
-        # Cleanup chunks
+        # Cleanup
         if "chunks" in result:
             del result["chunks"]
         
-        # Aggressive cleanup BEFORE returning
+        # Delete pipe immediately to free memory
         del pipe
         gc.collect()
         if torch.cuda.is_available():
@@ -79,24 +106,24 @@ with gr.Blocks(title="Íslenskt ASR") as demo:
     gr.Markdown("# Íslenskt ASR – 3–5 mín hljóð")
     gr.Markdown("**Whisper-small fínstillt á íslensku spjalli · mjög lágur WER**")
     gr.Markdown("**Hafa samband:** pallinr1@protonmail.com")
-    gr.Markdown("> Keyrt á **ZeroGPU** – hver umritun hleðst nýtt (15–30 sek), en örugg og stöðug")
+    gr.Markdown("> Keyrt á **ZeroGPU** – hver umritun hleðst nýtt (15–30 sek), stöðug og örugg")
     
     audio_in = gr.Audio(
-        type="filepath",
+        type="filepath",  # Ensures str output for pipeline
         label="Hlaðið upp .mp3 / .wav (allt að 5 mín)",
         sources=["upload", "microphone"]
     )
     btn = gr.Button("Umrita", variant="primary", size="lg")
-    output = gr.Textbox(lines=25, label="Texti")
+    output = gr.Textbox(lines=25, label="Texti", placeholder="Hljóðtextinn birtist hér...")
     
-    # Use the GPU-decorated function directly
+    # Click event uses GPU-decorated fn
     btn.click(fn=transcribe_3min_gpu, inputs=audio_in, outputs=output)
     
     gr.Markdown("""
     ### Leiðbeiningar
-    - Hver umritun hleðst módelinu nýtt á GPU (ZeroGPU regla)
-    - Tími: 15–30 sek (lengur en á venjulegu GPU, en lifir endalaust)
-    - Ef villa kemur → bíddu 10 sek og prófaðu aftur
+    - Hver umritun: 15–30 sek (módel hleðst á GPU)
+    - Styður upload og microphone – sjálfkrafa umbreytir í rétt format
+    - Ef villa: bíddu og prófaðu aftur (ZeroGPU endurræsir)
     """)
 
 # ————————————————————— Launch —————————————————————