Create main.py

main.py

@@ -0,0 +1,155 @@
+# 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=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    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()