Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py - API FastAPI pura en Hugging Face Space
+# app.py - Versión corregida con padding
 from fastapi import FastAPI, File, UploadFile, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
@@ -6,6 +6,9 @@ from transformers import pipeline
 import tempfile
 import os
 import uvicorn
+import librosa
+import soundfile as sf
+import numpy as np
 
 # Crear app FastAPI
 app = FastAPI(
@@ -32,8 +35,18 @@ async def startup_event():
     global classifier
     try:
         print("🔄 Cargando modelo...")
-        classifier = pipeline("audio-classification", model="Janiopi/detector_de_instrumentos_v1")
-        print("✅ Modelo cargado exitosamente")
+        # Configurar pipeline con padding y truncación
+        classifier = pipeline(
+            "audio-classification", 
+            model="Janiopi/detector_de_instrumentos_v1",
+            feature_extractor_kwargs={
+                "padding": True,
+                "truncation": True,
+                "max_length": 240000,  # 15 segundos a 16kHz
+                "return_tensors": "pt"
+            }
+        )
+        print("✅ Modelo cargado exitosamente con configuración de padding")
     except Exception as e:
         print(f"❌ Error cargando modelo: {e}")
         classifier = None
@@ -77,13 +90,6 @@ async def root():
             <p>Documentación interactiva de la API (Swagger)</p>
         </div>
         
-        <h2>🔗 Links útiles:</h2>
-        <ul>
-            <li><a href="/health">Health Check</a></li>
-            <li><a href="/docs">Documentación Swagger</a></li>
-            <li><a href="/redoc">Documentación ReDoc</a></li>
-        </ul>
-        
         <h2>📱 Uso desde Android:</h2>
         <pre style="background: #f8f8f8; padding: 15px; border-radius: 5px;">
 POST https://janiopi-musical-detector-api.hf.space/detect
@@ -115,7 +121,9 @@ async def health_check():
         "model_loaded": classifier is not None,
         "message": "API funcionando correctamente",
         "model_info": "Janiopi/detector_de_instrumentos_v1",
-        "supported_instruments": ["Guitar", "Piano", "Drum"]
+        "supported_instruments": ["Guitar", "Piano", "Drum"],
+        "max_duration_seconds": 15,
+        "sample_rate": 16000
     }
 
 @app.post("/detect")
@@ -136,42 +144,43 @@ async def detect_instrument(audio: UploadFile = File(...)):
         content = await audio.read()
         print(f"📏 Tamaño: {len(content)} bytes")
         
-        # Determinar extensión basada en content_type o filename
-        if audio.filename and audio.filename.endswith('.3gp'):
-            file_extension = '.3gp'
-        elif audio.filename and audio.filename.endswith('.wav'):
-            file_extension = '.wav'
-        elif audio.content_type and 'wav' in audio.content_type:
-            file_extension = '.wav'
-        else:
-            file_extension = '.wav'  # Por defecto
-        
-        print(f"🎵 Usando extensión: {file_extension}")
-        
-        with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
+        # Crear archivo temporal
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_file:
             temp_file.write(content)
             temp_path = temp_file.name
         
         try:
-            print("🤖 Ejecutando modelo...")
-            
-            # Usar librosa para cargar el audio de manera más robusta
-            import librosa
+            print("🎵 Cargando audio con librosa...")
             
             # Cargar audio con librosa (maneja múltiples formatos)
-            audio_data, sample_rate = librosa.load(temp_path, sr=16000)  # Forzar 16kHz
+            audio_data, sample_rate = librosa.load(temp_path, sr=16000)
             print(f"🔊 Audio cargado: {len(audio_data)} samples a {sample_rate}Hz")
+            print(f"⏱️ Duración: {len(audio_data)/sample_rate:.2f} segundos")
+            
+            # Verificar duración mínima
+            if len(audio_data) < 1600:  # Menos de 0.1 segundos
+                raise ValueError("Audio demasiado corto (mínimo 0.1 segundos)")
+            
+            # Truncar a máximo 15 segundos
+            max_samples = 15 * 16000
+            if len(audio_data) > max_samples:
+                audio_data = audio_data[:max_samples]
+                print(f"🔄 Audio truncado a 15 segundos")
+            
+            # Asegurar que el audio tenga el formato correcto
+            audio_data = np.array(audio_data, dtype=np.float32)
             
             # Guardar como WAV temporal para el modelo
-            temp_wav_path = temp_path.replace(file_extension, '.wav')
-            import soundfile as sf
+            temp_wav_path = temp_path.replace('.wav', '_processed.wav')
             sf.write(temp_wav_path, audio_data, sample_rate)
+            print(f"💾 Audio guardado como: {temp_wav_path}")
             
-            # Procesar con el modelo usando el archivo WAV
+            print("🤖 Ejecutando modelo...")
+            # Procesar con el modelo
             results = classifier(temp_wav_path)
             print(f"🎯 Resultados raw: {results}")
             
-            # Limpiar archivos temporales
+            # Limpiar archivo WAV procesado
             if os.path.exists(temp_wav_path):
                 os.unlink(temp_wav_path)
             
@@ -183,6 +192,7 @@ async def detect_instrument(audio: UploadFile = File(...)):
                     "score": round(float(result["score"]), 4)
                 })
             
+            # Ordenar por score descendente
             formatted_results.sort(key=lambda x: x["score"], reverse=True)
             
             print(f"✅ Resultados formateados: {formatted_results}")
@@ -191,11 +201,11 @@ async def detect_instrument(audio: UploadFile = File(...)):
                 "success": True,
                 "results": formatted_results,
                 "filename": audio.filename,
-                "processed_size_bytes": len(content),
                 "audio_info": {
                     "samples": len(audio_data),
                     "sample_rate": sample_rate,
-                    "duration_seconds": len(audio_data) / sample_rate
+                    "duration_seconds": round(len(audio_data) / sample_rate, 2),
+                    "processed_size_bytes": len(content)
                 }
             }
             
@@ -210,10 +220,19 @@ async def detect_instrument(audio: UploadFile = File(...)):
         print(f"❌ Error inesperado: {e}")
         import traceback
         traceback.print_exc()
-        raise HTTPException(
-            status_code=500, 
-            detail=f"Error procesando audio: {str(e)}"
-        )
+        
+        # Mensajes de error más específicos
+        error_msg = str(e)
+        if "Unable to create tensor" in error_msg:
+            detail = "Error de formato de audio. Intenta con un archivo WAV de mejor calidad."
+        elif "too short" in error_msg.lower():
+            detail = "Audio demasiado corto. Graba al menos 1 segundo."
+        elif "padding" in error_msg:
+            detail = "Error de procesamiento de audio. Intenta con un archivo diferente."
+        else:
+            detail = f"Error procesando audio: {error_msg}"
+        
+        raise HTTPException(status_code=500, detail=detail)
 
 @app.get("/test")
 async def test_endpoint():