Upload folder using huggingface_hub

handler.py

@@ -44,22 +44,43 @@ class EmotionCNN:
         mel_spec_db = np.clip(mel_spec_db, -80, 0)
         mel_spec_norm = (mel_spec_db + 80) / 80
 
-        from skimage.transform import resize
-        mel_resized = resize(mel_spec_norm, (224, 224), mode="constant")
+        try:
+            from skimage.transform import resize
+            mel_resized = resize(mel_spec_norm, (224, 224), mode="constant")
+        except ImportError:
+            # Fallback: simple nearest-neighbor resize with numpy
+            mel_resized = np.array(
+                [np.interp(np.linspace(0, mel_spec_norm.shape[1]-1, 224),
+                           np.arange(mel_spec_norm.shape[1]), row)
+                 for row in np.interp(
+                     np.linspace(0, mel_spec_norm.shape[0]-1, 224),
+                     np.arange(mel_spec_norm.shape[0]),
+                     np.arange(mel_spec_norm.shape[0])
+                 ).astype(int).__iter__()]
+            ) if mel_spec_norm.size > 0 else np.zeros((224, 224))
+
+        try:
+            from matplotlib import cm
+            colormap = cm.get_cmap("jet")
+            rgb = colormap(mel_resized)[:, :, :3]
+        except (ImportError, Exception):
+            # Fallback: stack grayscale into 3 channels
+            rgb = np.stack([mel_resized] * 3, axis=-1)
 
-        from matplotlib import cm
-        colormap = cm.get_cmap("jet")
-        rgb = colormap(mel_resized)[:, :, :3]
         return np.transpose(rgb, (2, 0, 1)).astype(np.float32)
 
     def extract_embedding(self, audio: np.ndarray, sr: int = 16000) -> np.ndarray:
-        spec_rgb = self.audio_to_spectrogram(audio, sr)
-        tensor = torch.from_numpy(spec_rgb).unsqueeze(0)
-        if self.device == "cuda":
-            tensor = tensor.cuda()
-        with torch.no_grad():
-            emb = self.model(tensor)
-        return emb.cpu().numpy().flatten()
+        try:
+            spec_rgb = self.audio_to_spectrogram(audio, sr)
+            tensor = torch.from_numpy(spec_rgb).unsqueeze(0)
+            if self.device == "cuda":
+                tensor = tensor.cuda()
+            with torch.no_grad():
+                emb = self.model(tensor)
+            return emb.cpu().numpy().flatten()
+        except Exception as e:
+            print(f"[WARN] EmotionCNN embedding extraction failed: {e}")
+            return np.zeros(576)  # MobileNetV3-small output size
 
 
 # ──────────────────────────────────────────────────────────────────────── #
@@ -223,7 +244,10 @@ class AudioFeatureExtractorEndpoint:
 
 from fastapi import FastAPI, File, UploadFile, Form
 from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional
 import base64
+import traceback
 
 app = FastAPI(title="Audio Feature Extraction API", version="1.0.0")
 app.add_middleware(
@@ -234,6 +258,22 @@ app.add_middleware(
 
 extractor = AudioFeatureExtractorEndpoint()
 
+DEFAULT_AUDIO_FEATURES = {
+    "v1_snr": 0.0,
+    "v2_noise_traffic": 0.0, "v2_noise_office": 0.0,
+    "v2_noise_crowd": 0.0, "v2_noise_wind": 0.0, "v2_noise_clean": 1.0,
+    "v3_speech_rate": 0.0,
+    "v4_pitch_mean": 0.0, "v5_pitch_std": 0.0,
+    "v6_energy_mean": 0.0, "v7_energy_std": 0.0,
+    "v8_pause_ratio": 0.0, "v9_avg_pause_dur": 0.0, "v10_mid_pause_cnt": 0,
+    "v11_emotion_stress": 0.0, "v12_emotion_energy": 0.0, "v13_emotion_valence": 0.0,
+}
+
+
+class AudioBase64Request(BaseModel):
+    audio_base64: str = ""
+    transcript: str = ""
+
 
 @app.get("/")
 async def root():
@@ -252,57 +292,63 @@ async def health():
 @app.post("/extract-audio-features")
 async def extract_audio_features(audio: UploadFile = File(...), transcript: str = Form("")):
     """Extract all 17 voice features from uploaded audio file."""
-    audio_bytes = await audio.read()
-    y, sr = librosa.load(io.BytesIO(audio_bytes), sr=16000, mono=True)
-    features = extractor.extract_all(y, transcript)
-    return features
+    try:
+        audio_bytes = await audio.read()
+        y, sr = librosa.load(io.BytesIO(audio_bytes), sr=16000, mono=True)
+        features = extractor.extract_all(y, transcript)
+        return features
+    except Exception as e:
+        print(f"[ERROR] extract_audio_features: {e}")
+        traceback.print_exc()
+        return {**DEFAULT_AUDIO_FEATURES, "_error": str(e)}
 
 
 @app.post("/extract-audio-features-base64")
-async def extract_audio_features_base64(data: dict):
+async def extract_audio_features_base64(data: AudioBase64Request):
     """Extract features from base64-encoded audio (for Vercel serverless calls)."""
     import soundfile as sf
 
-    audio_b64 = data.get("audio_base64", "")
-    transcript = data.get("transcript", "")
+    audio_b64 = data.audio_base64
+    transcript = data.transcript
 
     # Handle empty / missing audio — return default features
     if not audio_b64 or len(audio_b64) < 100:
-        return {
-            "v1_snr": 0.0,
-            "v2_noise_traffic": 0.0, "v2_noise_office": 0.0,
-            "v2_noise_crowd": 0.0, "v2_noise_wind": 0.0, "v2_noise_clean": 1.0,
-            "v3_speech_rate": 0.0,
-            "v4_pitch_mean": 0.0, "v5_pitch_std": 0.0,
-            "v6_energy_mean": 0.0, "v7_energy_std": 0.0,
-            "v8_pause_ratio": 0.0, "v9_avg_pause_dur": 0.0, "v10_mid_pause_cnt": 0,
-            "v11_emotion_stress": 0.0, "v12_emotion_energy": 0.0, "v13_emotion_valence": 0.0,
-        }
+        print("[INFO] Empty or too-short audio_base64, returning defaults")
+        return {**DEFAULT_AUDIO_FEATURES}
 
     try:
+        # Strip data URL prefix if present (e.g. "data:audio/wav;base64,...")
+        if "," in audio_b64[:80]:
+            audio_b64 = audio_b64.split(",", 1)[1]
+
         audio_bytes = base64.b64decode(audio_b64)
-        y, sr = sf.read(io.BytesIO(audio_bytes))
+        print(f"[INFO] Decoded {len(audio_bytes)} bytes of audio")
+
+        # Try soundfile first, fall back to librosa
+        try:
+            y, sr = sf.read(io.BytesIO(audio_bytes))
+        except Exception as sf_err:
+            print(f"[WARN] soundfile failed ({sf_err}), trying librosa...")
+            y, sr = librosa.load(io.BytesIO(audio_bytes), sr=16000, mono=True)
+
         if len(y.shape) > 1:
             y = np.mean(y, axis=1)
         if sr != 16000:
             y = librosa.resample(y, orig_sr=sr, target_sr=16000)
         y = y.astype(np.float32)
 
+        if len(y) < 100:
+            print("[WARN] Audio too short after decode, returning defaults")
+            return {**DEFAULT_AUDIO_FEATURES}
+
         features = extractor.extract_all(y, transcript)
+        print(f"[OK] Extracted {len(features)} audio features")
         return features
     except Exception as e:
-        # If audio decoding fails, return defaults rather than 500
-        return {
-            "v1_snr": 0.0,
-            "v2_noise_traffic": 0.0, "v2_noise_office": 0.0,
-            "v2_noise_crowd": 0.0, "v2_noise_wind": 0.0, "v2_noise_clean": 1.0,
-            "v3_speech_rate": 0.0,
-            "v4_pitch_mean": 0.0, "v5_pitch_std": 0.0,
-            "v6_energy_mean": 0.0, "v7_energy_std": 0.0,
-            "v8_pause_ratio": 0.0, "v9_avg_pause_dur": 0.0, "v10_mid_pause_cnt": 0,
-            "v11_emotion_stress": 0.0, "v12_emotion_energy": 0.0, "v13_emotion_valence": 0.0,
-            "_error": str(e),
-        }
+        print(f"[ERROR] extract_audio_features_base64: {e}")
+        traceback.print_exc()
+        # Return defaults rather than 500
+        return {**DEFAULT_AUDIO_FEATURES, "_error": str(e)}
 
 
 if __name__ == "__main__":