Fixing Logs

main.py

@@ -1,149 +1,15 @@
-import os
-import tempfile
-import subprocess
-from fastapi import FastAPI, File, UploadFile, HTTPException
-from fastapi.responses import JSONResponse
-import aiohttp
-import numpy as np
-from datetime import datetime
-import logging
-
-# Setup
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-app = FastAPI(title="Emotion Detection API", docs_url="/docs")
-
-# Config - get from environment
-HF_TOKEN = os.getenv("HF_TOKEN", "")
-API_TOKEN = os.getenv("API_TOKEN", "test123")
+"""
+Entry point for Hugging Face Spaces
+This file imports the FastAPI app from the app package
+"""
 
-# Models - using only 2 for reliability
-MODELS = {
-    "wav2vec2_english": {
-        "url": "https://api-inference.huggingface.co/models/ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition",
-        "weight": 0.7,
-    },
-    "gigam_emo": {
-        "url": "https://api-inference.huggingface.co/models/salute-developers/GigaAM-emo",
-        "weight": 0.3,
-    }
-}
-
-# Emotion mapping
-EMOTION_MAPPING = {
-    "angry": ["angry", "ang"],
-    "happy": ["happy", "hap"],
-    "sad": ["sad"],
-    "fear": ["fear"],
-    "surprise": ["surprise"],
-    "disgust": ["disgust"],
-    "neutral": ["neutral", "neu"]
-}
-
-@app.get("/health")
-async def health():
-    return {"status": "ok", "hf_token": bool(HF_TOKEN)}
+import os
+import sys
 
-@app.get("/")
-async def root():
-    return {
-        "message": "Emotion Detection API",
-        "docs": "/docs",
-        "endpoints": ["POST /analyze"]
-    }
+# Add the current directory to Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-@app.post("/analyze")
-async def analyze(file: UploadFile = File(...)):
-    """Analyze emotion from audio file"""
-    
-    # Check auth header
-    auth = file.headers.get("authorization", "")
-    if not auth or auth.replace("Bearer ", "") != API_TOKEN:
-        return JSONResponse(
-            status_code=401,
-            content={"error": "Invalid or missing Authorization header"}
-        )
-    
-    # Save uploaded file
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
-        content = await file.read()
-        tmp.write(content)
-        input_path = tmp.name
-    
-    try:
-        # Convert to proper format
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as out:
-            output_path = out.name
-        
-        subprocess.run([
-            "ffmpeg", "-i", input_path,
-            "-ar", "16000", "-ac", "1",
-            "-y", output_path
-        ], check=True, capture_output=True)
-        
-        # Read converted file
-        with open(output_path, "rb") as f:
-            audio_bytes = f.read()
-        
-        # Query models
-        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-        results = {}
-        
-        async with aiohttp.ClientSession() as session:
-            for name, config in MODELS.items():
-                try:
-                    async with session.post(
-                        config["url"],
-                        headers=headers,
-                        data=audio_bytes,
-                        timeout=10
-                    ) as resp:
-                        if resp.status == 200:
-                            results[name] = await resp.json()
-                except Exception as e:
-                    logger.warning(f"{name} failed: {e}")
-        
-        # Simple ensemble
-        emotion_scores = {}
-        total_weight = 0
-        
-        for name, predictions in results.items():
-            weight = MODELS[name]["weight"]
-            total_weight += weight
-            
-            for pred in predictions:
-                label = pred.get("label", "").lower()
-                score = pred.get("score", 0)
-                
-                # Map to standard emotions
-                for std_emo, variations in EMOTION_MAPPING.items():
-                    if any(v in label for v in variations):
-                        emotion_scores[std_emo] = emotion_scores.get(std_emo, 0) + score * weight
-                        break
-        
-        # Normalize
-        if total_weight > 0:
-            emotion_scores = {k: v/total_weight for k, v in emotion_scores.items()}
-        
-        # Get primary emotion
-        primary = max(emotion_scores.items(), key=lambda x: x[1]) if emotion_scores else ("unknown", 0)
-        
-        return {
-            "primary_emotion": primary[0],
-            "confidence": round(primary[1], 3),
-            "all_emotions": {k: round(v, 3) for k, v in emotion_scores.items()},
-            "models_used": list(results.keys())
-        }
-        
-    except Exception as e:
-        logger.error(f"Error: {e}")
-        return JSONResponse(status_code=500, content={"error": str(e)})
-    finally:
-        # Cleanup
-        for path in [input_path, output_path]:
-            if os.path.exists(path):
-                os.unlink(path)
+# Import the FastAPI app from your app module
+from app.main import app
 
-# For Hugging Face
-from fastapi.middleware.cors import CORSMiddleware
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+# This file exists only to give Hugging Face a clear entry point