Update app.py

app.py

@@ -25,160 +25,98 @@ def clean_text_for_search(text):
     text = re.sub(r'[^\w\s]', '', text).strip()
     return text
 
-def resize_and_blur_video(clip, target_width=1920, target_height=1080):
+def resize_and_blur_video(clip, target_aspect_ratio=16/9):
     """
-    Redimensiona y aplica desenfoque al video para mantener aspecto 16:9 con resolución objetivo.
-    Los videos más pequeños se redimensionan y los verticales se convierten en horizontales con blur.
-    
-    Args:
-        clip: VideoFileClip object
-        target_width: Ancho objetivo (default 1920 para 1080p)
-        target_height: Alto objetivo (default 1080 para 1080p)
+    Redimensiona y aplica desenfoque al fondo del video para mantener el aspecto 16:9.
     """
     try:
         w, h = clip.size
-        current_ratio = w / h
-        target_ratio = target_width / target_height
-        
-        print(f"Video original: {w}x{h}, ratio: {current_ratio}")
-        
-        if current_ratio < target_ratio:  # Video vertical o más cuadrado que 16:9
-            # Crear un fondo desenfocado escalado
-            background = (clip
-                .resize(width=target_width)
-                .resize(width=target_width * 2)  # Hacer el blur más suave
-                .fx(vfx.blur, sigma=10)
-                .resize(width=target_width))
-            
-            # Calcular el tamaño para el video principal
-            new_height = target_height
-            new_width = int(h * current_ratio)
-            if new_width > target_width:
-                new_width = target_width
-                new_height = int(new_width / current_ratio)
-            
-            # Redimensionar video principal
-            foreground = clip.resize(width=new_width, height=new_height)
-            
-            # Centrar el video
-            x_center = (target_width - new_width) // 2
-            y_center = (target_height - new_height) // 2
-            
-            final = CompositeVideoClip(
-                [background,
-                 foreground.set_position((x_center, y_center))],
-                size=(target_width, target_height)
+        current_aspect_ratio = w / h
+
+        print(f"Procesando video: {w}x{h}, ratio: {current_aspect_ratio}")
+        if abs(current_aspect_ratio - target_aspect_ratio) < 0.1:
+            return clip
+
+        if current_aspect_ratio < target_aspect_ratio:  # Video vertical
+            target_w = int(h * target_aspect_ratio)
+            target_h = h
+
+            background = clip.resize(width=target_w)
+            try:
+                background = background.fx(vfx.blur, sigma=50)
+            except Exception as e:
+                print(f"Error al aplicar blur: {e}")
+
+            foreground = clip.resize(height=target_h)
+            x_center = (target_w - foreground.w) / 2
+            return CompositeVideoClip(
+                [background, foreground.set_position((x_center, 0))],
+                size=(target_w, target_h)
             )
-            
-            return final
-            
         else:  # Video horizontal
-            # Si es más ancho que 16:9, recortamos los bordes
-            return clip.resize(width=target_width, height=target_height)
-            
-    except Exception as e:
-        print(f"Error en resize_and_blur_video: {e}")
-        return clip.resize(width=target_width, height=target_height)
+            return clip.resize(width=int(h * target_aspect_ratio), height=h)
 
     except Exception as e:
         print(f"Error en resize_and_blur_video: {e}")
         return clip
 
-def concatenate_pexels_videos(keywords, num_videos_per_keyword=1, target_width=1920, target_height=1080):
+def concatenate_pexels_videos(keywords, num_videos_per_keyword=1):
     """
-    Concatena videos de Pexels manteniendo una calidad y resolución consistentes.
-    
-    Args:
-        keywords (str): Palabras clave separadas por comas
-        num_videos_per_keyword (int): Número de videos por palabra clave
-        target_width (int): Ancho objetivo para los videos
-        target_height (int): Alto objetivo para los videos
+    Concatena videos de Pexels basados en palabras clave proporcionadas por el usuario.
+    :param keywords: Palabras clave separadas por comas (ejemplo: "universo, galaxia, bosque, gato").
     """
     keyword_list = [keyword.strip() for keyword in keywords.split(",") if keyword.strip()]
     if not keyword_list:
-        raise ValueError("No se proporcionaron palabras clave válidas.")
+        raise Exception("No se proporcionaron palabras clave válidas.")
 
     video_clips = []
-    processed_keywords = []
 
     for keyword in keyword_list:
         try:
-            print(f"Buscando videos para: '{keyword}'...")
-            # Limpiar la palabra clave para búsqueda
-            clean_keyword = clean_text_for_search(keyword)
-            
-            # Obtener videos con la nueva API
-            links = search_pexels(clean_keyword, num_results=num_videos_per_keyword)
+            print(f"Buscando videos para la palabra clave '{keyword}'...")
+            links = search_pexels(keyword, num_results=num_videos_per_keyword)
             if not links:
-                print(f"No se encontraron videos para: '{keyword}'")
+                print(f"No se encontraron videos para la palabra clave '{keyword}'.")
                 continue
 
-            for link in links:
-                try:
-                    print(f"Descargando video para: '{keyword}'...")
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video:
-                        video_response = requests.get(link, stream=True)
-                        if video_response.status_code != 200:
-                            print(f"Error descargando video: {video_response.status_code}")
-                            continue
-                            
-                        # Guardar el video
-                        for chunk in video_response.iter_content(chunk_size=8192):
-                            if chunk:
-                                tmp_video.write(chunk)
-                        
-                        tmp_video.flush()
-                        
-                        # Procesar el video
-                        try:
-                            clip = VideoFileClip(tmp_video.name)
-                            
-                            # Verificar duración mínima
-                            if clip.duration < 3:
-                                print(f"Video demasiado corto ({clip.duration}s), saltando...")
-                                clip.close()
-                                continue
-                                
-                            # Procesar y agregar el clip
-                            processed_clip = resize_and_blur_video(clip, target_width, target_height)
-                            if processed_clip:
-                                video_clips.append(processed_clip)
-                                processed_keywords.append(keyword)
-                                print(f"Video procesado exitosamente para: '{keyword}'")
-                            
-                        except Exception as e:
-                            print(f"Error procesando video: {e}")
-                            if 'clip' in locals():
-                                clip.close()
-                            continue
-                            
-                finally:
-                    # Limpiar archivo temporal
-                    if os.path.exists(tmp_video.name):
-                        try:
-                            os.unlink(tmp_video.name)
-                        except Exception as e:
-                            print(f"Error eliminando archivo temporal: {e}")
+            link = links[0]  # Usamos solo el primer video encontrado
+            video_response = requests.get(link)
+            if video_response.status_code != 200:
+                print(f"Error al descargar video desde {link}: Código de estado {video_response.status_code}")
+                continue
+
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video:
+                tmp_video.write(video_response.content)
+                clip = VideoFileClip(tmp_video.name)
+                processed_clip = resize_and_blur_video(clip)
+                video_clips.append(processed_clip)
 
         except Exception as e:
             print(f"Error procesando palabra clave '{keyword}': {e}")
             continue
 
     if not video_clips:
-        raise Exception("No se pudieron obtener videos válidos para ninguna palabra clave.")
+        raise Exception("No se pudieron obtener videos válidos.")
 
-    print(f"Videos procesados exitosamente para las palabras: {', '.join(processed_keywords)}")
-    
-    # Aleatorizar el orden de los clips
+    # Aleatorizar el orden de los clips si es necesario
     random.shuffle(video_clips)
-    
-    # Concatenar los clips
+
+    return concatenate_videoclips(video_clips, method="compose")
+
+def adjust_background_music(video_duration, music_file):
     try:
-        final_clip = concatenate_videoclips(video_clips, method="compose")
-        print(f"Video final generado: {final_clip.size}")
-        return final_clip
+        music = AudioFileClip(music_file)
+        if music.duration < video_duration:
+            repetitions = int(video_duration / music.duration) + 1
+            music_clips = [music] * repetitions
+            music = concatenate_audioclips(music_clips)
+        if music.duration > video_duration:
+            music = music.subclip(0, video_duration)
+        music = music.volumex(0.2)
+        return music
     except Exception as e:
-        raise Exception(f"Error concatenando clips: {e}")
+        print(f"Error ajustando música: {e}")
+        return None
 
 def combine_audio_video(audio_file, video_clip, music_clip=None):
     try:
@@ -210,57 +148,38 @@ def combine_audio_video(audio_file, video_clip, music_clip=None):
 
 def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch, keywords):
     try:
-        # Validar entrada de texto
         if text.strip():
             final_text = text
         elif txt_file is not None:
             final_text = txt_file.decode("utf-8")
         else:
-            # Retornar None en lugar de string de error
-            return None
+            return "No input provided"
 
-        # Validar voces
         voices = asyncio.run(get_voices())
         if selected_voice not in voices:
-            return None
+            return f"La voz '{selected_voice}' no es válida. Por favor, seleccione una de las siguientes voces: {', '.join(voices.keys())}"
 
-        # Generar audio
         try:
             audio_file = asyncio.run(text_to_speech(final_text, selected_voice, rate, pitch))
         except Exception as e:
-            print(f"Error generando audio: {e}")
-            return None
+            return f"Error generando audio: {e}"
 
-        # Procesar videos
         try:
             video_clip = concatenate_pexels_videos(keywords, num_videos_per_keyword=1)
         except Exception as e:
-            print(f"Error concatenando videos: {e}")
-            return None
+            return f"Error concatenando videos: {e}"
 
-        # Procesar música de fondo si existe
         if mp3_file is not None:
             music_clip = adjust_background_music(video_clip.duration, mp3_file.name)
         else:
             music_clip = None
 
-        # Combinar audio y video
         final_video_path = combine_audio_video(audio_file, video_clip, music_clip)
-        if final_video_path is None:
-            return None
-
-        # Subir a Google Drive
         upload_to_google_drive(final_video_path)
-
-        # Verificar que el archivo existe antes de retornarlo
-        if os.path.exists(final_video_path):
-            return final_video_path
-        else:
-            return None
+        return final_video_path
 
     except Exception as e:
-        print(f"Error en process_input: {e}")
-        return None
+        return f"Error durante el procesamiento: {e}"
 
 def upload_to_google_drive(file_path):
     try: