Update app.py

app.py

@@ -9,51 +9,85 @@ import asyncio
 from datetime import datetime
 from pathlib import Path
 from transformers import pipeline
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
 
 # Pexels API key from environment variable
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
+logger.info("Loaded PEXELS_API_KEY from environment")
 
 # Ensure asyncio works with Gradio
 def run_async(coro):
+    logger.info("Running async coroutine")
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
     result = loop.run_until_complete(coro)
     loop.close()
+    logger.info("Async coroutine completed")
     return result
 
-# Load lightweight text generation model
+# Load lightweight text generation model for Spanish
+logger.info("Loading text generation model: facebook/mbart-large-50")
 try:
-    generator = pipeline("text-generation", model="distilbert/distilgpt2", device="cpu", pad_token_id=50256)
+    generator = pipeline("text-generation", model="facebook/mbart-large-50", device="cpu")
+    logger.info("Model loaded successfully")
 except Exception as e:
-    print(f"Error loading model: {e}")
+    logger.error(f"Error loading model: {e}")
     generator = None
 
+# List available Spanish voices for Edge TTS
+SPANISH_VOICES = [
+    "es-MX-DaliaNeural",
+    "es-MX-JorgeNeural",
+    "es-MX-CecilioNeural",
+    "es-MX-BeatrizNeural",
+    "es-MX-CandelaNeural",
+    "es-MX-CarlosNeural",
+    "es-MX-LarissaNeural",
+    "es-MX-ManuelNeural",
+    "es-MX-MarinaNeural",
+    "es-MX-NuriaNeural"
+]
+
 # Fetch videos from Pexels
 def fetch_pexels_videos(query, num_videos=5):
+    logger.info(f"Fetching {num_videos} videos from Pexels with query: {query}")
     headers = {"Authorization": PEXELS_API_KEY}
     url = f"https://api.pexels.com/videos/search?query={query}&per_page={num_videos}"
     response = requests.get(url, headers=headers)
     if response.status_code == 200:
-        return [video["video_files"][0]["link"] for video in response.json()["videos"]]
+        videos = [video["video_files"][0]["link"] for video in response.json()["videos"]]
+        logger.info(f"Fetched {len(videos)} videos from Pexels")
+        return videos
+    logger.error("Failed to fetch videos from Pexels")
     return []
 
 # Generate script using local model or custom text
 def generate_script(prompt, custom_text=None):
+    logger.info("Generating script")
     if custom_text:
+        logger.info("Using custom text provided by user")
         return custom_text.strip()
     if not prompt:
+        logger.error("No prompt or custom text provided")
         return "Error: Debes proporcionar un prompt o un guion personalizado."
     
     # Generate script with local model
     if generator:
-        input_text = f"Generate a script for a video about '{prompt}'. Create a numbered list with short descriptions (max 20 words per item) for a top 10 related to the topic."
+        input_text = f"Genera un guion para un video sobre '{prompt}'. Crea una lista numerada con descripciones breves (máximo 20 palabras por ítem) para un top 10 relacionado con el tema en español."
+        logger.info(f"Generating script with prompt: {prompt}")
         try:
             result = generator(input_text, max_length=300, num_return_sequences=1, do_sample=True, truncation=True)[0]['generated_text']
+            logger.info("Script generated successfully")
             return result.strip()
         except Exception as e:
-            print(f"Error generating script: {e}")
+            logger.error(f"Error generating script: {e}")
     
     # Fallback mock response
+    logger.info("Using fallback mock response")
     if "recetas" in prompt.lower():
         return """
         1. Tacos al pastor: Jugosa carne marinada con piña.
@@ -71,44 +105,61 @@ def generate_script(prompt, custom_text=None):
 
 # Generate voice using Edge TTS
 async def generate_voice(text, output_file="output.mp3"):
-    communicate = edge_tts.Communicate(text, voice="es-MX-DaliaNeural")
-    await communicate.save(output_file)
-    return output_file
+    logger.info(f"Generating voice with Edge TTS using voice: es-MX-DaliaNeural")
+    try:
+        communicate = edge_tts.Communicate(text, voice="es-MX-DaliaNeural")
+        await communicate.save(output_file)
+        logger.info(f"Voice generated and saved to {output_file}")
+        return output_file
+    except Exception as e:
+        logger.error(f"Error generating voice: {e}")
+        return None
 
 # Download and trim video
 def download_and_trim_video(url, duration, output_path):
+    logger.info(f"Downloading video from {url}")
     response = requests.get(url, stream=True)
     with open("temp_video.mp4", "wb") as f:
         for chunk in response.iter_content(chunk_size=1024):
             f.write(chunk)
+    logger.info("Trimming video")
     clip = VideoFileClip("temp_video.mp4").subclip(0, min(duration, VideoFileClip("temp_video.mp4").duration))
     clip.write_videofile(output_path, codec="libx264", audio_codec="aac")
     clip.close()
     os.remove("temp_video.mp4")
+    logger.info(f"Video trimmed and saved to {output_path}")
     return output_path
 
 # Main video creation function
 def create_video(prompt, custom_text, music_file):
+    logger.info("Starting video creation process")
     output_dir = "output_videos"
     os.makedirs(output_dir, exist_ok=True)
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     output_video = f"{output_dir}/video_{timestamp}.mp4"
+    logger.info(f"Output video will be saved to {output_video}")
 
     # Generate or use provided script
     script = generate_script(prompt, custom_text)
     if "Error" in script:
+        logger.error(script)
         return script
 
     # Generate voice
     voice_file = "temp_audio.mp3"
     run_async(generate_voice(script, voice_file))
+    if not os.path.exists(voice_file):
+        logger.error("Voice generation failed")
+        return "Error: No se pudo generar la voz."
     audio = AudioFileClip(voice_file)
     video_duration = audio.duration
+    logger.info(f"Audio duration: {video_duration} seconds")
 
     # Fetch Pexels videos
     query = prompt.split()[0] if prompt else "generic"
     video_urls = fetch_pexels_videos(query, num_videos=5)
     if not video_urls:
+        logger.error("No videos found on Pexels")
         return "Error: No se encontraron videos en Pexels."
 
     # Download and trim videos
@@ -117,22 +168,28 @@ def create_video(prompt, custom_text, music_file):
         clip_path = f"temp_clip_{i}.mp4"
         download_and_trim_video(url, video_duration / len(video_urls), clip_path)
         clips.append(VideoFileClip(clip_path))
+        logger.info(f"Processed video clip {i+1}/{len(video_urls)}")
 
     # Concatenate video clips
+    logger.info("Concatenating video clips")
     final_clip = concatenate_videoclips(clips, method="compose").set_duration(video_duration)
 
     # Add looped music
     if music_file:
+        logger.info("Adding user-uploaded music")
         music = AudioFileClip(music_file.name)
         music = audio_loop(music, duration=video_duration)
         final_clip = final_clip.set_audio(music.set_duration(video_duration))
     else:
+        logger.info("Using generated voice as audio")
         final_clip = final_clip.set_audio(audio)
 
     # Write final video
+    logger.info(f"Writing final video to {output_video}")
     final_clip.write_videofile(output_video, codec="libx264", audio_codec="aac", fps=24)
     
     # Clean up
+    logger.info("Cleaning up temporary files")
     for clip in clips:
         clip.close()
     audio.close()
@@ -143,6 +200,7 @@ def create_video(prompt, custom_text, music_file):
     for i in range(len(video_urls)):
         os.remove(f"temp_clip_{i}.mp4")
 
+    logger.info("Video creation completed")
     return output_video
 
 # Gradio interface