Spaces:

Janiopi
/

Musical-Detector-FastAPI

Sleeping

App Files Files Community

Janiopi commited on Jul 10, 2025

Commit

5ab3542

verified ·

1 Parent(s): 8f5a5bf

Update app.py

Browse files

Files changed (1) hide show

app.py +169 -110

app.py CHANGED Viewed

@@ -1,17 +1,20 @@
-# app.py - API FastAPI en Hugging Face Space
 from fastapi import FastAPI, File, UploadFile, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from transformers import pipeline
 import tempfile
 import os
 import uvicorn
-import gradio as gr
-from threading import Thread
 # Crear app FastAPI
-app = FastAPI(title="Musical Instrument Detection API", version="1.0.0")
-# Configurar CORS para permitir requests desde Android
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -20,136 +23,192 @@ app.add_middleware(
     allow_headers=["*"],
 )
-# Cargar modelo
-try:
-    classifier = pipeline("audio-classification", model="Janiopi/detector_de_instrumentos_v1")
-    print("✅ Modelo cargado exitosamente")
-except Exception as e:
-    print(f"❌ Error cargando modelo: {e}")
-    classifier = None
-@app.get("/")
 async def root():
-    return {
-        "message": "Musical Instrument Detection API",
-        "status": "online",
-        "model_loaded": classifier is not None,
-        "endpoints": {
-            "detect": "/detect (POST)",
-            "health": "/health (GET)"
-        }
     }
 @app.get("/health")
 async def health_check():
     return {
-        "status": "ok",
         "model_loaded": classifier is not None,
-        "message": "API funcionando correctamente"
     }
 @app.post("/detect")
 async def detect_instrument(audio: UploadFile = File(...)):
     """
-    Endpoint para detectar instrumentos musicales en audio
     """
     try:
         if classifier is None:
-            raise HTTPException(status_code=503, detail="Modelo no disponible")
         # Verificar tipo de archivo
-        if not audio.content_type.startswith('audio/'):
-            raise HTTPException(status_code=400, detail="El archivo debe ser de audio")
-        # Guardar archivo temporalmente
         with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_file:
-            content = await audio.read()
             temp_file.write(content)
             temp_path = temp_file.name
-        print(f"📁 Procesando archivo: {audio.filename}, tamaño: {len(content)} bytes")
-        # Procesar con el modelo
-        results = classifier(temp_path)
-        # Limpiar archivo temporal
-        os.unlink(temp_path)
-        # Formatear resultados
-        formatted_results = []
-        for result in results:
-            formatted_results.append({
-                "label": result["label"],
-                "score": round(result["score"], 4)
-            })
-        print(f"✅ Resultados: {formatted_results}")
-        return {
-            "success": True,
-            "results": formatted_results,
-            "filename": audio.filename
-        }
     except Exception as e:
-        print(f"❌ Error: {e}")
-        raise HTTPException(status_code=500, detail=f"Error procesando audio: {str(e)}")
-# Crear interfaz Gradio simple para visualización
-def gradio_interface():
-    with gr.Blocks(title="Musical Instrument Detection API") as demo:
-        gr.Markdown("# 🎵 Musical Instrument Detection API")
-        gr.Markdown("## API Endpoints:")
-        gr.Markdown("""
-        - **GET** `/` - Información general
-        - **GET** `/health` - Estado del servicio
-        - **POST** `/detect` - Detectar instrumentos (enviar archivo audio)
-        ### Uso desde Android:
-        ```
-        POST https://tu-usuario-musical-detector-api.hf.space/detect
-        Content-Type: multipart/form-data
-        Body: audio file
-        ```
-        """)
-        # Interfaz simple para probar
-        with gr.Row():
-            audio_input = gr.Audio(type="filepath", label="Probar detección")
-            output_text = gr.Textbox(label="Resultado")
-        def test_detection(audio_path):
-            if audio_path and classifier:
-                try:
-                    results = classifier(audio_path)
-                    output = "Instrumentos detectados:\n"
-                    for result in results:
-                        output += f"- {result['label']}: {result['score']:.4f}\n"
-                    return output
-                except Exception as e:
-                    return f"Error: {e}"
-            return "No se pudo procesar el audio"
-        audio_input.change(test_detection, inputs=[audio_input], outputs=[output_text])
-    return demo
-# Función para ejecutar FastAPI
-def run_fastapi():
-    uvicorn.run(app, host="0.0.0.0", port=7860)
-# Función para ejecutar Gradio
-def run_gradio():
-    demo = gradio_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7861, share=False)
 if __name__ == "__main__":
-    # Ejecutar FastAPI en thread separado
-    fastapi_thread = Thread(target=run_fastapi, daemon=True)
-    fastapi_thread.start()
-    print("🚀 FastAPI iniciado en puerto 7860")
-    print("🎨 Gradio iniciado en puerto 7861")
-    # Ejecutar Gradio en el hilo principal
-    run_gradio()

+# app.py - API FastAPI pura en Hugging Face Space
 from fastapi import FastAPI, File, UploadFile, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
 from transformers import pipeline
 import tempfile
 import os
 import uvicorn
 # Crear app FastAPI
+app = FastAPI(
+    title="Musical Instrument Detection API",
+    description="API para detectar instrumentos musicales en audio",
+    version="1.0.0"
+)
+# Configurar CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
     allow_headers=["*"],
 )
+# Variable global para el modelo
+classifier = None
+@app.on_event("startup")
+async def startup_event():
+    """Cargar modelo al iniciar la aplicación"""
+    global classifier
+    try:
+        print("🔄 Cargando modelo...")
+        classifier = pipeline("audio-classification", model="Janiopi/detector_de_instrumentos_v1")
+        print("✅ Modelo cargado exitosamente")
+    except Exception as e:
+        print(f"❌ Error cargando modelo: {e}")
+        classifier = None
+@app.get("/", response_class=HTMLResponse)
 async def root():
+    """Página principal con documentación"""
+    html_content = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Musical Instrument Detection API</title>
+        <style>
+            body { font-family: Arial, sans-serif; margin: 40px; }
+            .endpoint { background: #f0f0f0; padding: 10px; margin: 10px 0; border-radius: 5px; }
+            .method { color: white; padding: 2px 8px; border-radius: 3px; font-weight: bold; }
+            .get { background: #61affe; }
+            .post { background: #49cc90; }
+        </style>
+    </head>
+    <body>
+        <h1>🎵 Musical Instrument Detection API</h1>
+        <p>API para detectar instrumentos musicales (Guitarra, Piano, Batería)</p>
+        <h2>📡 Endpoints Disponibles:</h2>
+        <div class="endpoint">
+            <span class="method get">GET</span> <strong>/health</strong>
+            <p>Verificar estado del servicio y modelo</p>
+        </div>
+        <div class="endpoint">
+            <span class="method post">POST</span> <strong>/detect</strong>
+            <p>Detectar instrumentos en archivo de audio</p>
+            <p><strong>Content-Type:</strong> multipart/form-data</p>
+            <p><strong>Parámetro:</strong> audio (archivo)</p>
+        </div>
+        <div class="endpoint">
+            <span class="method get">GET</span> <strong>/docs</strong>
+            <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
+Content-Type: multipart/form-data
+Body: audio file (campo "audio")
+Respuesta:
+{
+  "success": true,
+  "results": [
+    {
+      "label": "Sound_Guitar",
+      "score": 0.8547
     }
+  ],
+  "filename": "audio.wav"
+}
+        </pre>
+    </body>
+    </html>
+    """
+    return html_content
 @app.get("/health")
 async def health_check():
+    """Verificar estado del servicio"""
     return {
+        "status": "online",
         "model_loaded": classifier is not None,
+        "message": "API funcionando correctamente",
+        "model_info": "Janiopi/detector_de_instrumentos_v1",
+        "supported_instruments": ["Guitar", "Piano", "Drum"]
     }
 @app.post("/detect")
 async def detect_instrument(audio: UploadFile = File(...)):
     """
+    Detectar instrumentos musicales en archivo de audio
+    Args:
+        audio: Archivo de audio (WAV, MP3, etc.)
+    Returns:
+        JSON con resultados de detección
     """
     try:
+        # Verificar si el modelo está cargado
         if classifier is None:
+            raise HTTPException(
+                status_code=503,
+                detail="Modelo no disponible. Intenta más tarde."
+            )
         # Verificar tipo de archivo
+        if not audio.content_type or not audio.content_type.startswith('audio/'):
+            raise HTTPException(
+                status_code=400,
+                detail=f"Tipo de archivo inválido: {audio.content_type}. Debe ser audio."
+            )
+        print(f"📁 Procesando: {audio.filename} ({audio.content_type})")
+        # Leer y guardar archivo temporalmente
+        content = await audio.read()
+        print(f"📏 Tamaño: {len(content)} bytes")
         with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_file:
             temp_file.write(content)
             temp_path = temp_file.name
+        try:
+            # Procesar con el modelo
+            print("🤖 Ejecutando modelo...")
+            results = classifier(temp_path)
+            print(f"🎯 Resultados raw: {results}")
+            # Formatear resultados
+            formatted_results = []
+            for result in results:
+                formatted_results.append({
+                    "label": result["label"],
+                    "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}")
+            return {
+                "success": True,
+                "results": formatted_results,
+                "filename": audio.filename,
+                "processed_size_bytes": len(content)
+            }
+        finally:
+            # Limpiar archivo temporal
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+    except HTTPException:
+        raise
     except Exception as e:
+        print(f"❌ Error inesperado: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error procesando audio: {str(e)}"
+        )
+@app.get("/test")
+async def test_endpoint():
+    """Endpoint de prueba para verificar conectividad"""
+    return {
+        "message": "API funcionando",
+        "timestamp": "2025-01-16",
+        "test": "ok"
+    }
+# Ejecutar la aplicación
 if __name__ == "__main__":
+    print("🚀 Iniciando Musical Instrument Detection API...")
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=7860,
+        log_level="info"
+    )