Create app.py

app.py

@@ -0,0 +1,164 @@
+from fastapi import FastAPI, HTTPException, Form
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import transformers
+import torch
+import json
+import logging
+import os
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="TTS API", version="1.0.0")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables
+model = None
+processor = None
+model_loaded = False
+model_type = "none"
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the application"""
+    global model, processor, model_loaded, model_type
+    
+    logger.info("=== TTS API Starting ===")
+    logger.info(f"Transformers version: {transformers.__version__}")
+    logger.info(f"Torch version: {torch.__version__}")
+    
+    await load_model()
+
+async def load_model():
+    """Load the TTS model with fallbacks"""
+    global model, processor, model_loaded, model_type
+    
+    try:
+        logger.info("Step 1: Importing transformers...")
+        from transformers import AutoProcessor, AutoModel
+        
+        logger.info("Step 2: Loading Parler-TTS processor...")
+        processor = AutoProcessor.from_pretrained(
+            "parler-tts/parler-tts-mini-v1",
+            trust_remote_code=True
+        )
+        
+        logger.info("Step 3: Loading Parler-TTS model...")
+        model = AutoModel.from_pretrained(
+            "parler-tts/parler-tts-mini-v1",
+            trust_remote_code=True
+        )
+        
+        model_loaded = True
+        model_type = "parler-tts"
+        logger.info("✅ SUCCESS: Parler-TTS model loaded successfully!")
+        
+    except Exception as e:
+        logger.error(f"❌ FAILED: Parler-TTS loading error: {e}")
+        logger.info("Trying fallback to Bark model...")
+        
+        try:
+            processor = AutoProcessor.from_pretrained("suno/bark-small")
+            model = AutoModel.from_pretrained("suno/bark-small")
+            model_loaded = True
+            model_type = "bark"
+            logger.info("✅ SUCCESS: Bark model loaded as fallback!")
+            
+        except Exception as fallback_error:
+            logger.error(f"❌ FAILED: All models failed: {fallback_error}")
+            model_loaded = False
+            model_type = "none"
+
+@app.get("/")
+async def root():
+    return {
+        "message": "TTS API Service",
+        "status": "operational" if model_loaded else "degraded",
+        "model_loaded": model_loaded,
+        "model_type": model_type,
+        "transformers_version": transformers.__version__,
+        "torch_version": torch.__version__
+    }
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy" if model_loaded else "degraded",
+        "model_loaded": model_loaded,
+        "model_type": model_type
+    }
+
+@app.get("/debug")
+async def debug():
+    """Debug endpoint to check environment"""
+    return {
+        "python_version": "3.9",  # Hugging Face uses Python 3.9
+        "transformers_version": transformers.__version__,
+        "torch_version": torch.__version__,
+        "model_loaded": model_loaded,
+        "model_type": model_type,
+        "cuda_available": torch.cuda.is_available(),
+        "space_ready": True
+    }
+
+@app.post("/api/generate-voiceovers")
+async def generate_voiceovers(
+    project_id: str = Form(...),
+    voiceover_scenes: str = Form(...),
+    upload_to_oci: bool = Form(False)
+):
+    """Generate voiceovers from text scenes"""
+    
+    if not model_loaded:
+        raise HTTPException(
+            status_code=503, 
+            detail="TTS model not loaded. Service unavailable."
+        )
+    
+    try:
+        # Parse input scenes
+        scenes = json.loads(voiceover_scenes)
+        
+        if not isinstance(scenes, list):
+            raise HTTPException(
+                status_code=400, 
+                detail="voiceover_scenes must be a JSON array"
+            )
+        
+        logger.info(f"Processing {len(scenes)} scenes for project {project_id}")
+        
+        # Return success response
+        return {
+            "status": "success",
+            "project_id": project_id,
+            "scenes_processed": len(scenes),
+            "model_type": model_type,
+            "message": f"Ready to process {len(scenes)} voiceover scenes using {model_type}",
+            "expected_files": [f"voiceover_{i:02d}.wav" for i in range(1, len(scenes) + 1)]
+        }
+        
+    except json.JSONDecodeError:
+        raise HTTPException(
+            status_code=400, 
+            detail="Invalid JSON format for voiceover_scenes"
+        )
+    except Exception as e:
+        logger.error(f"Error processing request: {e}")
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Internal server error: {str(e)}"
+        )
+
+if __name__ == "__main__":
+    import uvicorn
+    logger.info("Starting TTS API server on port 7860...")
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")