Upload app.py with huggingface_hub

app.py

@@ -11,7 +11,8 @@ import json
 import time
 import torchaudio
 
-# 🛡️ ZeroGPU Support (v68)
+# 🛡️ ZeroGPU Support (v69)
+# CRITICAL: @spaces.GPU MUST only be used on synchronous functions (def, not async def)
 try:
     import spaces
     print("✅ ZeroGPU/Spaces detected")
@@ -23,8 +24,6 @@ except ImportError:
 
 
 # 🛠️ Monkeypatch torchaudio.backend (DeepFilterNet compatibility)
-# DeepFilterNet uses older torchaudio API structure (torchaudio.backend.common.AudioMetaData)
-# We mock it here before importing df
 import sys
 import types
 if "torchaudio.backend" not in sys.modules:
@@ -40,7 +39,6 @@ if "torchaudio.backend" not in sys.modules:
     sys.modules["torchaudio.backend.common"] = common
 
 # 🛡️ Torchaudio Compatibility Fix (v60)
-# Ensure .info exists for DeepFilterNet
 if not hasattr(torchaudio, "info"):
     print("🛠️ Mocking torchaudio.info for compatibility...")
     def mock_info(filepath, **kwargs):
@@ -61,9 +59,9 @@ if not hasattr(torchaudio, "info"):
 
 from df.enhance import enhance, init_df, load_audio, save_audio
 
-# FORCE BUILD TRIGGER: 15:10:00 Jan 20 2026
+# FORCE BUILD TRIGGER: 15:20:00 Jan 20 2026
 
-# 🛠️ Monkeypatch torchaudio.load to bypass TorchCodec requirement
+# 🛠️ Monkeypatch torchaudio.load
 try:
     _orig_load = torchaudio.load
     def patched_load(filepath, *args, **kwargs):
@@ -71,15 +69,12 @@ try:
             return _orig_load(filepath, *args, **kwargs)
         except ImportError as e:
             if "torchcodec" in str(e).lower():
-                print(f"⚠️ Redirecting load for {filepath} via soundfile (TorchCodec bypass)")
+                print(f"⚠️ Redirecting load for {filepath} via soundfile")
                 import soundfile as sf
                 data, samplerate = sf.read(filepath)
-                # Convert to torch tensor with correct shape (C, N)
                 t = torch.from_numpy(data).float()
-                if len(t.shape) == 1:
-                    t = t.unsqueeze(0)
-                else:
-                    t = t.T
+                if len(t.shape) == 1: t = t.unsqueeze(0)
+                else: t = t.T
                 return t, samplerate
             raise e
     torchaudio.load = patched_load
@@ -97,232 +92,100 @@ def load_models():
     if MODELS["stt"] is None:
         print("🎙️ Loading Faster-Whisper large-v3...")
         from faster_whisper import WhisperModel
-        
-        # 🦾 HYBRID HARDWARE SELECTION (v67)
         if torch.cuda.is_available():
-            print(f"🚀 High-Performance GPU Detected: {torch.cuda.get_device_name(0)} (H200/A10G/T4)")
-            print(f"💾 VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+            print(f"🚀 GPU Detected: {torch.cuda.get_device_name(0)}")
             MODELS["stt"] = WhisperModel("large-v3", device="cuda", compute_type="float16")
         else:
-            print("⚠️ WARNING: GPU NOT DETECTED. Falling back to CPU (int8 optimization).")
-            # CPU fallback: int8 is necessary for decent speed on CPU
+            print("⚠️ Falling back to CPU (int8)")
             MODELS["stt"] = WhisperModel("large-v3", device="cpu", compute_type="int8")
     
     if MODELS["translate"] is None:
-        print("🌍 Loading Google Translate (deep-translator)...")
-        MODELS["translate"] = "deep-translator-active"
+        print("🌍 Loading Google Translate...")
+        MODELS["translate"] = "active"
 
     if MODELS["denoiser"] is None:
-        print("🧹 Loading DeepFilterNet (Voice Cleaner)...")
+        print("扫 Loading DeepFilterNet...")
         try:
-            df_ret = init_df()
-            if isinstance(df_ret, (list, tuple)) and len(df_ret) > 1:
-                MODELS["denoiser"] = df_ret[0]
-            else:
-                MODELS["denoiser"] = df_ret
+            MODELS["denoiser"] = init_df()
             print("✨ DeepFilterNet Loaded")
-        except Exception as e:
-            print(f"⚠️ Failed to load denoiser: {e}")
-            try:
-                MODELS["denoiser"] = init_df()
-            except:
-                pass
+        except: pass
 
     if MODELS["tts"] is None:
-        print("🔊 Loading XTTS-v2 (STRICT GPU PREFERRED)...")
+        print("🔊 Loading XTTS-v2...")
         from TTS.api import TTS
         try:
-            MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=True)
-            print("✨ XTTS-v2 Loaded on GPU")
-        except Exception as tts_e:
-            print(f"⚠️ GPU TTS load failed: {tts_e}. Falling back to CPU...")
-            try:
-                MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)
-                print("✨ XTTS-v2 Loaded on CPU")
-            except Exception as cpu_e:
-                print(f"❌ FATAL: Could not load XTTS-v2 on any hardware: {cpu_e}")
-                raise cpu_e
+            MODELS["tts"] = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2", gpu=torch.cuda.is_available())
+            print(f"✨ XTTS-v2 Loaded (GPU={torch.cuda.is_available()})")
+        except Exception as e:
+            print(f"❌ Failed to load XTTS: {e}")
+            raise e
 
 @spaces.GPU
 def core_process(request_dict):
-    """Internal logic used by both FastAPI and Gradio"""
+    """Synchronous inference logic with GPU decorator"""
     action = request_dict.get("action")
-    print(f"--- 🛠️ Processing Action: {action} (ZeroGPU Context) ---")
-    start_time = time.time()
-    
-    if action == "health":
-        return {"status": "ok", "gpu": torch.cuda.is_available(), "timestamp": time.time()}
-    
-    print(f"⏳ Loading models for {action}...")
+    print(f"--- 🛠️ Processing Action: {action} (GPU Context) ---")
     load_models()
-    print(f"✅ Models ready for {action} (Load time: {time.time() - start_time:.2f}s)")
     
     if action == "stt":
-        audio_b64 = request_dict.get("file")
+        audio_bytes = base64.b64decode(request_dict.get("file"))
         lang = request_dict.get("lang")
-        print(f"🎙️ STT: Decoding audio ({len(audio_b64) if audio_b64 else 0} bytes)...")
-        audio_bytes = base64.b64decode(audio_b64)
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
             f.write(audio_bytes)
             temp_path = f.name
         try:
-            print("🚀 Faster-Whisper Transcription Starting (Instant Mode)...")
-            segments, info = MODELS["stt"].transcribe(temp_path, language=lang, beam_size=1)
-            text = " ".join([segment.text for segment in segments]).strip()
-            print(f"✨ Transcription Done: '{text[:50]}...'")
+            segments, _ = MODELS["stt"].transcribe(temp_path, language=lang, beam_size=1)
+            text = " ".join([s.text for s in segments]).strip()
             return {"text": text}
         finally:
             if os.path.exists(temp_path): os.unlink(temp_path)
     
     elif action == "translate":
-        text = request_dict.get("text")
-        target_lang = request_dict.get("target_lang")
-        print(f"🌍 Translate: '{text[:50]}...' to {target_lang}")
-        
-        g_lang_map = {
-            "en": "en", "fr": "fr", "es": "es", "de": "de", 
-            "ar": "ar", "it": "it", "pt": "pt", "ru": "ru", 
-            "zh": "zh-cn", "ja": "ja", "ko": "ko", "hi": "hi"
-        }
-        g_target = g_lang_map.get(target_lang, "en")
-        
         from deep_translator import GoogleTranslator
-        result = GoogleTranslator(source='auto', target=g_target).translate(text)
-        
-        print(f"✨ Translation Done: '{result[:50]}...'")
-        return {"translated": result}
+        text = request_dict.get("text")
+        target_lang = request_dict.get("target_lang", "en")
+        translated = GoogleTranslator(source='auto', target=target_lang).translate(text)
+        return {"translated": translated}
     
     elif action == "tts":
         text = request_dict.get("text")
         lang = request_dict.get("lang")
-        print(f"🔊 TTS: '{text[:50]}...' in {lang}")
         speaker_wav_b64 = request_dict.get("speaker_wav")
         speaker_wav_path = None
         if speaker_wav_b64:
-            speaker_bytes = base64.b64decode(speaker_wav_b64)
+            sb = base64.b64decode(speaker_wav_b64)
             with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-                f.write(speaker_bytes)
+                f.write(sb)
                 speaker_wav_path = f.name
         else:
-            print("⚠️ No speaker ref provided. Using generated default.")
-            import wave, struct, math
-            default_path = "default_speaker.wav"
-            if not os.path.exists(default_path):
-                try:
-                    with wave.open(default_path, "w") as wav_file:
-                        wav_file.setnchannels(1)
-                        wav_file.setsampwidth(2)
-                        wav_file.setframerate(24000)
-                        data = [struct.pack('<h', int(math.sin(x/100.0)*3000)) for x in range(24000)]
-                        wav_file.writeframes(b''.join(data))
-                except: pass
-            if os.path.exists(default_path):
-                speaker_wav_path = default_path
+            speaker_wav_path = "default_speaker.wav"
             
         try:
             with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as output_file:
                 output_path = output_file.name
-            
-            if speaker_wav_path:
-                MODELS["tts"].tts_to_file(text=text, language=lang, file_path=output_path, speaker_wav=speaker_wav_path)
-            
-            if MODELS["denoiser"]:
-                try:
-                    noisy_audio, _ = load_audio(output_path, sr=48000)
-                    enhanced_audio = enhance(MODELS["denoiser"], noisy_audio, pad=True)
-                    save_audio(output_path, enhanced_audio, 48000)
-                except: pass
-
+            MODELS["tts"].tts_to_file(text=text, language=lang, file_path=output_path, speaker_wav=speaker_wav_path)
             with open(output_path, "rb") as f:
                 audio_b64 = base64.b64encode(f.read()).decode()
-            print("✨ TTS Done")
             return {"audio": audio_b64}
         finally:
-            if speaker_wav_path and os.path.exists(speaker_wav_path) and "default_speaker" not in speaker_wav_path:
-                os.unlink(speaker_wav_path)
+            if speaker_wav_path and "default_speaker" not in speaker_wav_path:
+                if os.path.exists(speaker_wav_path): os.unlink(speaker_wav_path)
             if 'output_path' in locals() and os.path.exists(output_path): os.unlink(output_path)
 
     elif action == "s2st":
-        audio_b64 = request_dict.get("file")
-        source_lang = request_dict.get("source_lang")
-        target_lang = request_dict.get("target_lang")
-        speaker_wav_b64 = request_dict.get("speaker_wav")
-        
-        audio_bytes = base64.b64decode(audio_b64)
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-            f.write(audio_bytes)
-            temp_path = f.name
+        # Full S2ST flow
+        data = core_process({"action": "stt", "file": request_dict.get("file"), "lang": request_dict.get("source_lang")})
+        text = data.get("text", "")
+        if not text: return {"error": "No speech detected"}
         
-        speaker_wav_path = None
-        if speaker_wav_b64:
-            speaker_bytes = base64.b64decode(speaker_wav_b64)
-            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as sf:
-                sf.write(speaker_bytes)
-                speaker_wav_path = sf.name
-        else:
-            default_path = "default_speaker.wav"
-            if os.path.exists(default_path):
-                speaker_wav_path = default_path
+        data_tr = core_process({"action": "translate", "text": text, "target_lang": request_dict.get("target_lang")})
+        translated = data_tr.get("translated", "")
         
-        try:
-            # Padding & Denoising
-            try:
-                waveform, sr = torchaudio.load(temp_path)
-                if MODELS["denoiser"]:
-                    noisy_in, _ = load_audio(temp_path, sr=48000)
-                    clean_in = enhance(MODELS["denoiser"], noisy_in, pad=True)
-                    save_audio(temp_path, clean_in, 48000)
-                    waveform, sr = torchaudio.load(temp_path)
-                
-                silence = torch.zeros((waveform.shape[0], int(1.5 * sr)))
-                padded = torch.cat([waveform, silence], dim=1)
-                torchaudio.save(temp_path, padded, sr)
-            except: pass
-
-            # STT
-            segments, info = MODELS["stt"].transcribe(temp_path, language=source_lang, beam_size=1)
-            text = " ".join([segment.text for segment in segments]).strip()
-            if text and not text.endswith(('.', '!', '?', '…')): text += "..."
-            if not text: return {"error": "No speech detected"}
-
-            # Translate
-            g_lang_map = {"en": "en", "fr": "fr", "es": "es", "de": "de", "ar": "ar", "it": "it", "pt": "pt", "ru": "ru", "zh": "zh-cn", "ja": "ja", "ko": "ko", "hi": "hi"}
-            g_target = g_lang_map.get(target_lang, "en")
-            from deep_translator import GoogleTranslator
-            translated_text = GoogleTranslator(source='auto', target=g_target).translate(text)
+        data_tts = core_process({"action": "tts", "text": translated, "lang": request_dict.get("target_lang"), "speaker_wav": request_dict.get("speaker_wav")})
+        return {"text": text, "translated": translated, "audio": data_tts.get("audio")}
 
-            # TTS
-            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as output_file:
-                output_path = output_file.name
-            
-            MODELS["tts"].tts_to_file(text=translated_text, language=target_lang, file_path=output_path, speaker_wav=speaker_wav_path)
-
-            with open(output_path, "rb") as o:
-                audio_out_b64 = base64.b64encode(o.read()).decode()
-            
-            return {"text": text, "translated": translated_text, "audio": audio_out_b64}
-        finally:
-            if os.path.exists(temp_path): os.unlink(temp_path)
-            if speaker_wav_path and os.path.exists(speaker_wav_path) and "default_speaker" not in speaker_wav_path:
-                os.unlink(speaker_wav_path)
-            if 'output_path' in locals() and os.path.exists(output_path): os.unlink(output_path)
-    
     return {"error": f"Unknown action: {action}"}
 
-# --- FastAPI App ---
-app = FastAPI()
-
-@app.post("/api/v1/process")
-async def api_process(request: Request):
-    try:
-        data = await request.json()
-        print(f"📥 FastAPI Request: {data.get('action')}")
-        result = core_process(data)
-        return result
-    except Exception as e:
-        print(f"❌ API Global Error: {traceback.format_exc()}")
-        return {"error": str(e)}
-
 def create_wav_header(sample_rate=24000, channels=1, bit_depth=16):
     header = bytearray(b'RIFF')
     header.extend((1000000000).to_bytes(4, 'little')) 
@@ -338,65 +201,74 @@ def create_wav_header(sample_rate=24000, channels=1, bit_depth=16):
     header.extend((0xFFFFFFFF).to_bytes(4, 'little'))
     return header
 
-@app.post("/api/v1/tts_stream")
+# 🚀 Sync Generator for ZeroGPU
 @spaces.GPU
+def gpu_tts_generator(text, lang, speaker_wav_path):
+    load_models()
+    try:
+        yield create_wav_header(sample_rate=24000)
+        # inference_stream is a generator
+        for chunk in MODELS["tts"].synthesizer.tts_model.inference_stream(
+            text,
+            lang,
+            *MODELS["tts"].synthesizer.tts_model.get_conditioning_latents(audio_path=[speaker_wav_path]),
+            stream_chunk_size=20
+        ):
+            yield (chunk * 32767).to(torch.int16).cpu().numpy().tobytes()
+        print("✨ [Generator Complete]")
+    except Exception as e:
+        print(f"❌ [Generator Error]: {e}")
+    finally:
+        if speaker_wav_path and "default_speaker" not in speaker_wav_path:
+            if os.path.exists(speaker_wav_path): os.unlink(speaker_wav_path)
+
+# --- FastAPI Entry Points ---
+app = FastAPI()
+
+@app.post("/api/v1/process")
+async def api_process(request: Request):
+    """Async endpoint calls synchronous GPU function"""
+    try:
+        data = await request.json()
+        result = core_process(data)
+        return result
+    except Exception as e:
+        return {"error": str(e)}
+
+@app.post("/api/v1/tts_stream")
 async def api_tts_stream(request: Request):
+    """Async entry point for StreamingResponse"""
     try:
-        load_models() 
         data = await request.json()
-        text = data.get("text")
-        lang = data.get("lang")
         speaker_wav_b64 = data.get("speaker_wav")
-        
         speaker_wav_path = None
         if speaker_wav_b64:
-            speaker_bytes = base64.b64decode(speaker_wav_b64)
+            sb = base64.b64decode(speaker_wav_b64)
             with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-                f.write(speaker_bytes)
+                f.write(sb)
                 speaker_wav_path = f.name
         else:
             speaker_wav_path = "default_speaker.wav"
-
-        def stream_generator():
-            try:
-                yield create_wav_header(sample_rate=24000)
-                for chunk in MODELS["tts"].synthesizer.tts_model.inference_stream(
-                    text,
-                    lang,
-                    *MODELS["tts"].synthesizer.tts_model.get_conditioning_latents(audio_path=[speaker_wav_path]),
-                    stream_chunk_size=20
-                ):
-                    yield (chunk * 32767).to(torch.int16).cpu().numpy().tobytes()
-            except Exception as ge:
-                print(f"❌ [Stream Error]: {ge}")
-            finally:
-                if speaker_wav_path and os.path.exists(speaker_wav_path) and "default_speaker" not in speaker_wav_path:
-                    os.unlink(speaker_wav_path)
-
-        return StreamingResponse(stream_generator(), media_type="audio/wav")
+            
+        return StreamingResponse(
+            gpu_tts_generator(data.get("text"), data.get("lang"), speaker_wav_path), 
+            media_type="audio/wav"
+        )
     except Exception as e:
         return {"error": str(e)}
 
 @app.get("/health")
 def health():
-    return {"status": "ok", "gpu": torch.cuda.is_available(), "timestamp": time.time()}
+    return {"status": "ok", "gpu": torch.cuda.is_available()}
 
-# --- Gradio Interface ---
+# --- Gradio UI ---
 def gradio_fn(req_json):
     try:
-        data = json.loads(req_json)
-        res = core_process(data)
-        return json.dumps(res)
+        return json.dumps(core_process(json.loads(req_json)))
     except Exception as e:
         return json.dumps({"error": str(e)})
 
-demo = gr.Interface(
-    fn=gradio_fn,
-    inputs=gr.Textbox(label="JSON Request"),
-    outputs=gr.Textbox(label="JSON Response"),
-    title="🚀 Unified AI Engine (H200/XTTS-v2)"
-)
-
+demo = gr.Interface(fn=gradio_fn, inputs="text", outputs="text", title="🚀 AI Engine")
 app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":