Update app.py

app.py

@@ -161,6 +161,40 @@ def supports_voice_cloning():
     """Check if the current model supports voice cloning"""
     return "xtts" in current_model.lower()
 
+def save_wav(audio, file_path):
+    """Save audio to WAV file manually"""
+    try:
+        # Try soundfile first
+        try:
+            import soundfile as sf
+            sf.write(file_path, audio, 22050)  # Standard TTS sample rate
+            return True
+        except ImportError:
+            print("⚠️ soundfile not available, using fallback method")
+        
+        # Fallback: use wave library
+        import wave
+        import numpy as np
+        
+        # Ensure audio is numpy array
+        if isinstance(audio, list):
+            audio = np.array(audio)
+        
+        # Convert to 16-bit PCM
+        audio_int16 = (audio * 32767).astype(np.int16)
+        
+        with wave.open(file_path, 'wb') as wav_file:
+            wav_file.setnchannels(1)  # Mono
+            wav_file.setsampwidth(2)  # 16-bit
+            wav_file.setframerate(22050)  # Sample rate
+            wav_file.writeframes(audio_int16.tobytes())
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Failed to save WAV: {e}")
+        return False
+
 def load_tts_model():
     """Load TTS model with retry logic and proper error handling"""
     global tts, model_loaded, current_model, voice_cloning_supported, model_loading, model_load_attempts
@@ -252,6 +286,9 @@ async def generate_tts(request: TTSRequest):
         filename = f"voiceover_{timestamp}.wav"
         output_path = f"/tmp/output/{filename}"
         
+        # Ensure output directory exists
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        
         # Get voice path if custom voice is requested
         speaker_wav = None
         if request.voice_name != "default":
@@ -262,21 +299,53 @@ async def generate_tts(request: TTSRequest):
                     "message": f"Voice '{request.voice_name}' not found"
                 }
         
-        # Generate TTS based on model capabilities
-        if supports_voice_cloning():
-            tts.tts_to_file(
-                text=request.text,
-                speaker_wav=speaker_wav,
-                language=request.language,
-                file_path=output_path
-            )
-        else:
-            tts.tts_to_file(
-                text=request.text,
-                file_path=output_path
-            )
+        print(f"🔊 Generating TTS to: {output_path}")
+        
+        # Generate TTS based on model capabilities - WITH ERROR HANDLING
+        try:
+            if supports_voice_cloning():
+                # XTTS model with voice cloning support
+                tts.tts_to_file(
+                    text=request.text,
+                    speaker_wav=speaker_wav,
+                    language=request.language,
+                    file_path=output_path
+                )
+            else:
+                # Fallback model (Tacotron2)
+                tts.tts_to_file(
+                    text=request.text,
+                    file_path=output_path
+                )
+        except Exception as tts_error:
+            print(f"❌ TTS generation failed: {tts_error}")
+            # Try alternative approach
+            try:
+                print("🔄 Trying alternative TTS generation method...")
+                # Generate audio first, then save
+                if supports_voice_cloning():
+                    audio = tts.tts(
+                        text=request.text,
+                        speaker_wav=speaker_wav,
+                        language=request.language
+                    )
+                else:
+                    audio = tts.tts(text=request.text)
+                
+                # Save manually
+                if not save_wav(audio, output_path):
+                    raise Exception("Failed to save audio file")
+                    
+            except Exception as alt_error:
+                print(f"❌ Alternative method also failed: {alt_error}")
+                raise alt_error
         
-        print(f"✅ TTS generated: {output_path}")
+        # Verify the file was created
+        if not os.path.exists(output_path):
+            raise Exception(f"TTS failed to create output file: {output_path}")
+        
+        file_size = os.path.getsize(output_path)
+        print(f"✅ TTS generated: {output_path} ({file_size} bytes)")
         
         # Upload to OCI
         upload_result, error = upload_to_oci_with_retry(
@@ -285,11 +354,13 @@ async def generate_tts(request: TTSRequest):
         
         if error:
             print(f"❌ OCI upload failed: {error}")
+            # Still return the local file path if upload fails
             return {
                 "status": "partial_success",
                 "message": f"TTS generated but upload failed: {error}",
                 "local_file": output_path,
-                "filename": filename
+                "filename": filename,
+                "file_size": file_size
             }
         
         print(f"✅ Upload successful: {filename}")
@@ -297,8 +368,9 @@ async def generate_tts(request: TTSRequest):
         # Clean up local file
         try:
             os.remove(output_path)
-        except:
-            pass
+            print(f"🧹 Cleaned up local file: {output_path}")
+        except Exception as cleanup_error:
+            print(f"⚠️ Could not clean up file: {cleanup_error}")
             
         return {
             "status": "success",
@@ -311,7 +383,14 @@ async def generate_tts(request: TTSRequest):
         
     except Exception as e:
         print(f"❌ TTS generation error: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"TTS generation failed: {str(e)}")
+        # Provide more detailed error information
+        error_detail = {
+            "error": str(e),
+            "model": current_model,
+            "voice_cloning_supported": supports_voice_cloning(),
+            "device": DEVICE
+        }
+        raise HTTPException(status_code=500, detail=error_detail)
 
 @app.post("/api/batch-tts")
 async def batch_generate_tts(request: BatchTTSRequest):
@@ -350,19 +429,63 @@ async def batch_generate_tts(request: BatchTTSRequest):
             filename = f"voiceover_{i+1:02d}.wav"
             output_path = f"/tmp/output/{filename}"
             
-            # Generate TTS based on model capabilities
-            if supports_voice_cloning():
-                tts.tts_to_file(
-                    text=text,
-                    speaker_wav=speaker_wav,
-                    language=request.language,
-                    file_path=output_path
-                )
-            else:
-                tts.tts_to_file(
-                    text=text,
-                    file_path=output_path
-                )
+            # Ensure output directory exists
+            os.makedirs(os.path.dirname(output_path), exist_ok=True)
+            
+            # Generate TTS based on model capabilities - WITH ERROR HANDLING
+            try:
+                if supports_voice_cloning():
+                    tts.tts_to_file(
+                        text=text,
+                        speaker_wav=speaker_wav,
+                        language=request.language,
+                        file_path=output_path
+                    )
+                else:
+                    tts.tts_to_file(
+                        text=text,
+                        file_path=output_path
+                    )
+            except Exception as tts_error:
+                print(f"❌ TTS generation failed for text {i+1}: {tts_error}")
+                # Try alternative approach
+                try:
+                    print("🔄 Trying alternative TTS generation method...")
+                    if supports_voice_cloning():
+                        audio = tts.tts(
+                            text=text,
+                            speaker_wav=speaker_wav,
+                            language=request.language
+                        )
+                    else:
+                        audio = tts.tts(text=text)
+                    
+                    # Save manually
+                    if not save_wav(audio, output_path):
+                        raise Exception("Failed to save audio file")
+                        
+                except Exception as alt_error:
+                    print(f"❌ Alternative method also failed: {alt_error}")
+                    results.append({
+                        "text_index": i,
+                        "status": "error",
+                        "message": f"TTS generation failed: {str(alt_error)}",
+                        "filename": filename
+                    })
+                    continue
+            
+            # Verify the file was created
+            if not os.path.exists(output_path):
+                results.append({
+                    "text_index": i,
+                    "status": "error",
+                    "message": f"TTS failed to create output file: {output_path}",
+                    "filename": filename
+                })
+                continue
+            
+            file_size = os.path.getsize(output_path)
+            print(f"✅ TTS generated: {output_path} ({file_size} bytes)")
             
             # Upload to OCI
             upload_result, error = upload_to_oci_with_retry(
@@ -376,7 +499,8 @@ async def batch_generate_tts(request: BatchTTSRequest):
                     "status": "partial_success",
                     "message": f"TTS generated but upload failed: {error}",
                     "local_file": output_path,
-                    "filename": filename
+                    "filename": filename,
+                    "file_size": file_size
                 })
             else:
                 print(f"✅ Upload successful: {filename}")
@@ -385,14 +509,16 @@ async def batch_generate_tts(request: BatchTTSRequest):
                     "status": "success",
                     "message": "TTS generated and uploaded successfully",
                     "filename": filename,
-                    "oci_path": upload_result.get("path", f"{request.project_id}/voiceover/{filename}")
+                    "oci_path": upload_result.get("path", f"{request.project_id}/voiceover/{filename}"),
+                    "file_size": file_size
                 })
                 
                 # Clean up local file
                 try:
                     os.remove(output_path)
-                except:
-                    pass
+                    print(f"🧹 Cleaned up local file: {output_path}")
+                except Exception as cleanup_error:
+                    print(f"⚠️ Could not clean up file: {cleanup_error}")
         
         return {
             "status": "completed",