Made Some Changes

DockerFile

@@ -0,0 +1,9 @@
+FROM python:3.9-slim
+
+RUN apt-get update && apt-get install -y ffmpeg && rm -rf /var/lib/apt/lists/*
+RUN pip install fastapi uvicorn aiohttp numpy
+
+WORKDIR /app
+COPY main.py .
+
+CMD uvicorn main:app --host 0.0.0.0 --port 7860

app/audio/preprocessor.py

@@ -1,92 +0,0 @@
-import os
-import tempfile
-import subprocess
-import numpy as np
-import librosa
-from fastapi import UploadFile, HTTPException
-from typing import Tuple
-import logging
-from ..config import config
-
-logger = logging.getLogger(__name__)
-
-class AudioPreprocessor:
-    """Simplified audio preprocessing for Hugging Face"""
-    
-    def __init__(self):
-        self.target_sr = config.AUDIO_CONFIG["target_sample_rate"]
-        self.max_duration = config.AUDIO_CONFIG["max_duration"]
-        self.max_size_mb = config.AUDIO_CONFIG["max_file_size_mb"]
-    
-    async def validate_and_preprocess(self, file: UploadFile) -> Tuple[np.ndarray, int, dict]:
-        """
-        Validate and preprocess audio file
-        Simplified for Hugging Face deployment
-        """
-        # Read file
-        contents = await file.read()
-        file_size_mb = len(contents) / (1024 * 1024)
-        
-        # Validate size
-        if file_size_mb > self.max_size_mb:
-            raise HTTPException(
-                status_code=400,
-                detail=f"File too large: {file_size_mb:.1f}MB (max: {self.max_size_mb}MB)"
-            )
-        
-        # Save to temp file
-        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{file.filename.split('.')[-1]}") as tmp_input:
-            tmp_input.write(contents)
-            input_path = tmp_input.name
-        
-        try:
-            # Convert to WAV using FFmpeg
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_output:
-                output_path = tmp_output.name
-            
-            # FFmpeg command
-            cmd = [
-                "ffmpeg",
-                "-i", input_path,
-                "-ar", str(self.target_sr),
-                "-ac", "1",
-                "-acodec", "pcm_s16le",
-                "-y",
-                output_path
-            ]
-            
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            
-            if result.returncode != 0:
-                raise HTTPException(status_code=400, detail="Audio conversion failed")
-            
-            # Load audio
-            audio, sr = librosa.load(output_path, sr=self.target_sr)
-            
-            # Check duration
-            duration = len(audio) / sr
-            if duration > self.max_duration:
-                audio = audio[:int(self.max_duration * sr)]
-            
-            # Simple normalization
-            audio = audio / np.max(np.abs(audio)) if np.max(np.abs(audio)) > 0 else audio
-            
-            metadata = {
-                "filename": file.filename,
-                "duration": round(len(audio) / sr, 2),
-                "sample_rate": sr,
-                "size_mb": round(file_size_mb, 2)
-            }
-            
-            return audio, sr, metadata
-            
-        except Exception as e:
-            logger.error(f"Audio processing failed: {str(e)}")
-            raise HTTPException(status_code=500, detail="Audio processing failed")
-        finally:
-            # Cleanup
-            for path in [input_path, output_path]:
-                if os.path.exists(path):
-                    os.unlink(path)
-
-audio_preprocessor = AudioPreprocessor()

app/main.py

@@ -1,192 +0,0 @@
-from fastapi import FastAPI, File, UploadFile, Depends, HTTPException, Request
-from fastapi.security import HTTPBearer
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.openapi.docs import get_swagger_ui_html
-import aiohttp
-import time
-import hashlib
-import logging
-from datetime import datetime
-from typing import Optional
-import os
-
-from .config import config
-from .auth import auth_handler
-from .audio.preprocessor import audio_preprocessor
-from .models.ensemble import ensemble_fusion
-
-# Setup logging
-logging.basicConfig(level=getattr(logging, config.LOG_LEVEL))
-logger = logging.getLogger(__name__)
-
-# Initialize FastAPI
-app = FastAPI(
-    title=config.API_TITLE,
-    version=config.API_VERSION,
-    docs_url=None  # We'll create custom docs
-)
-
-# CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Simple cache
-prediction_cache = {}
-http_session = None
-
-@app.on_event("startup")
-async def startup():
-    """Initialize on startup"""
-    global http_session
-    http_session = aiohttp.ClientSession()
-    logger.info(f"🚀 API started with {len(config.MODELS)} models")
-    logger.info(f"HF_TOKEN present: {bool(config.HF_TOKEN)}")
-
-@app.on_event("shutdown")
-async def shutdown():
-    """Cleanup on shutdown"""
-    if http_session:
-        await http_session.close()
-
-@app.get("/", include_in_schema=False)
-async def root():
-    """Root endpoint"""
-    return {
-        "service": config.API_TITLE,
-        "version": config.API_VERSION,
-        "docs": "/docs",
-        "health": "/health"
-    }
-
-@app.get("/health")
-async def health_check():
-    """Health check for Hugging Face"""
-    return {
-        "status": "healthy",
-        "timestamp": datetime.utcnow().isoformat(),
-        "models": len(config.MODELS),
-        "hf_token_configured": bool(config.HF_TOKEN)
-    }
-
-@app.get("/models")
-async def list_models():
-    """List all models in ensemble"""
-    return {
-        "models": [
-            {
-                "name": name,
-                "weight": model["weight"],
-                "description": model.get("description", "")
-            }
-            for name, model in config.MODELS.items()
-        ]
-    }
-
-@app.post("/analyze")
-async def analyze_emotion(
-    request: Request,
-    file: UploadFile = File(...),
-    token: str = Depends(auth_handler.verify_token)
-):
-    """
-    Analyze emotion from audio file
-    """
-    start_time = time.time()
-    
-    try:
-        # Check cache
-        file_content = await file.read()
-        await file.seek(0)
-        
-        cache_key = hashlib.md5(file_content).hexdigest()
-        if cache_key in prediction_cache:
-            logger.info(f"Cache hit for {cache_key}")
-            return prediction_cache[cache_key]
-        
-        # Process audio
-        logger.info(f"Processing: {file.filename}")
-        audio, sr, metadata = await audio_preprocessor.validate_and_preprocess(file)
-        
-        # Get file bytes again
-        await file.seek(0)
-        audio_bytes = await file.read()
-        
-        # Query models
-        logger.info("Querying models...")
-        model_outputs = await ensemble_fusion.query_all_models(http_session, audio_bytes)
-        
-        if len(model_outputs) < config.ENSEMBLE_CONFIG["min_models_for_prediction"]:
-            raise HTTPException(
-                status_code=503,
-                detail=f"Only {len(model_outputs)}/{len(config.MODELS)} models responded"
-            )
-        
-        # Fuse predictions
-        result = ensemble_fusion.fuse_predictions(model_outputs)
-        
-        # Add metadata
-        result["processing_time"] = round(time.time() - start_time, 2)
-        result["audio_metadata"] = metadata
-        result["timestamp"] = datetime.utcnow().isoformat()
-        
-        # Cache result
-        if len(prediction_cache) < config.CACHE_CONFIG["max_size"]:
-            prediction_cache[cache_key] = result
-        
-        logger.info(f"Analysis complete: {result['primary_emotion']} ({result['processing_time']}s)")
-        return result
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/docs", include_in_schema=False)
-async def custom_docs():
-    """Custom Swagger UI"""
-    return get_swagger_ui_html(
-        openapi_url="/openapi.json",
-        title=f"{config.API_TITLE} - Docs",
-        swagger_js_url="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js",
-        swagger_css_url="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css",
-    )
-
-@app.get("/openapi.json", include_in_schema=False)
-async def get_openapi():
-    """Custom OpenAPI schema"""
-    from fastapi.openapi.utils import get_openapi
-    
-    if app.openapi_schema:
-        return app.openapi_schema
-    
-    openapi_schema = get_openapi(
-        title=config.API_TITLE,
-        version=config.API_VERSION,
-        description="Emotion detection API using ensemble of 5 models",
-        routes=app.routes,
-    )
-    
-    # Add security
-    openapi_schema["components"]["securitySchemes"] = {
-        "bearerAuth": {
-            "type": "http",
-            "scheme": "bearer",
-            "description": "Enter your API token"
-        }
-    }
-    openapi_schema["security"] = [{"bearerAuth": []}]
-    
-    app.openapi_schema = openapi_schema
-    return app.openapi_schema
-
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.getenv("PORT", 8000))
-    uvicorn.run(app, host="0.0.0.0", port=port)

app/utils/logger.py

@@ -1,12 +0,0 @@
-import logging
-import sys
-
-def setup_logging():
-    """Simple logging setup"""
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-        handlers=[
-            logging.StreamHandler(sys.stdout)
-        ]
-    )

main.py

@@ -0,0 +1,149 @@
+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")
+
+# 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)}
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Emotion Detection API",
+        "docs": "/docs",
+        "endpoints": ["POST /analyze"]
+    }
+
+@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)
+
+# For Hugging Face
+from fastapi.middleware.cors import CORSMiddleware
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])

requirements.txt

@@ -1,28 +1,4 @@
-# Core Framework
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-pydantic==2.5.0
-python-dotenv==1.0.0
-
-# Authentication
-python-jose[cryptography]==3.3.0
-passlib[bcrypt]==1.7.4
-python-multipart==0.0.6
-
-# HTTP & Async
-aiohttp==3.9.1
-httpx==0.25.1
-
-# Audio Processing
-librosa==0.10.1
-soundfile==0.12.1
-pydub==0.25.1
-ffmpeg-python==0.2.0
-
-# Scientific Computing
-numpy==1.24.3
-scipy==1.11.4
-scikit-learn==1.3.2
-
-# Rate Limiting
-slowapi==0.1.8
+fastapi
+uvicorn
+aiohttp
+numpy