Update app.py

app.py

@@ -84,63 +84,101 @@ def resize_and_blur_video(clip, target_width=1920, target_height=1080):
         print(f"Error en resize_and_blur_video: {e}")
         return clip
 
-def concatenate_pexels_videos(keywords, num_videos_per_keyword=1):
+def concatenate_pexels_videos(keywords, num_videos_per_keyword=1, target_width=1920, target_height=1080):
     """
-    Concatena videos de Pexels basados en palabras clave proporcionadas por el usuario.
-    :param keywords: Palabras clave separadas por comas (ejemplo: "universo, galaxia, bosque, gato").
+    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
     """
     keyword_list = [keyword.strip() for keyword in keywords.split(",") if keyword.strip()]
     if not keyword_list:
-        raise Exception("No se proporcionaron palabras clave válidas.")
+        raise ValueError("No se proporcionaron palabras clave válidas.")
 
     video_clips = []
+    processed_keywords = []
 
     for keyword in keyword_list:
         try:
-            print(f"Buscando videos para la palabra clave '{keyword}'...")
-            links = search_pexels(keyword, num_results=num_videos_per_keyword)
+            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)
             if not links:
-                print(f"No se encontraron videos para la palabra clave '{keyword}'.")
-                continue
-
-            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}")
+                print(f"No se encontraron videos para: '{keyword}'")
                 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)
+            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}")
 
         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.")
+        raise Exception("No se pudieron obtener videos válidos para ninguna palabra clave.")
 
-    # Aleatorizar el orden de los clips si es necesario
+    print(f"Videos procesados exitosamente para las palabras: {', '.join(processed_keywords)}")
+    
+    # Aleatorizar el orden de los clips
     random.shuffle(video_clips)
-
-    return concatenate_videoclips(video_clips, method="compose")
-
-def adjust_background_music(video_duration, music_file):
+    
+    # Concatenar los clips
     try:
-        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
+        final_clip = concatenate_videoclips(video_clips, method="compose")
+        print(f"Video final generado: {final_clip.size}")
+        return final_clip
     except Exception as e:
-        print(f"Error ajustando música: {e}")
-        return None
+        raise Exception(f"Error concatenando clips: {e}")
 
 def combine_audio_video(audio_file, video_clip, music_clip=None):
     try: