Update app.py

app.py

@@ -18,22 +18,18 @@ from io import BytesIO
 from PIL import Image
 import numpy as np
 
-# Configuración de dimensiones mínimas para las imágenes
 MIN_WIDTH = 1920
 MIN_HEIGHT = 1080
 TARGET_ASPECT_RATIO = 16/9
 
-# Define output and temp directories
 output_folder = "outputs"
 temp_dir = "temp_files"
 os.makedirs(output_folder, exist_ok=True)
 os.makedirs(temp_dir, exist_ok=True)
 
-# Google Drive folder ID
 FOLDER_ID = "12S6adpanAXjf71pKKGRRPqpzbJa5XEh3"
 
 def load_proxies(proxy_file="proxys.txt"):
-    """Load proxies from a text file."""
     try:
         with open(proxy_file, 'r') as f:
             proxies = [line.strip() for line in f if line.strip()]
@@ -44,7 +40,6 @@ def load_proxies(proxy_file="proxys.txt"):
         return []
 
 def cleanup_temp_files():
-    """Delete all temporary files from the temp_files folder."""
     for filename in os.listdir(temp_dir):
         file_path = os.path.join(temp_dir, filename)
         try:
@@ -54,7 +49,6 @@ def cleanup_temp_files():
             print(f"Error deleting {file_path}: {e}")
 
 def search_google_images(query, num_images=1):
-    """Search for images using Google Custom Search API with size requirements."""
     try:
         api_key = os.getenv('GOOGLE_API_KEY')
         cse_id = os.getenv('GOOGLE_CSE_ID')
@@ -76,16 +70,15 @@ def search_google_images(query, num_images=1):
                     service._http.http = session
                     print(f"Trying with proxy: {proxy['http']}")
                 
-                # Especificar parámetros de búsqueda para imágenes grandes
                 result = service.cse().list(
                     q=query,
                     cx=cse_id,
                     searchType="image",
-                    num=num_images * 3,  # Buscar más imágenes para filtrar por tamaño
+                    num=num_images * 3,
                     safe='off',
-                    imgSize='huge',  # Preferir imágenes grandes
-                    imgType='photo',  # Preferir fotos sobre dibujos
-                    rights='cc_publicdomain|cc_attribute|cc_sharealike',  # Imágenes con licencia apropiada
+                    imgSize='huge',
+                    imgType='photo',
+                    rights='cc_publicdomain|cc_attribute|cc_sharealike'
                 ).execute()
                 
                 if 'items' in result:
@@ -116,43 +109,30 @@ def search_google_images(query, num_images=1):
         return []
 
 def process_image(image):
-    """Process and resize image to meet minimum requirements."""
     try:
-        # Obtener dimensiones actuales
         width, height = image.size
-        
-        # Calcular relación de aspecto actual
         current_ratio = width / height
         
-        # Determinar nuevas dimensiones manteniendo relación 16:9
         if current_ratio > TARGET_ASPECT_RATIO:
-            # Imagen más ancha que 16:9
             new_width = max(MIN_WIDTH, width)
             new_height = int(new_width / TARGET_ASPECT_RATIO)
         else:
-            # Imagen más alta que 16:9
             new_height = max(MIN_HEIGHT, height)
             new_width = int(new_height * TARGET_ASPECT_RATIO)
         
-        # Redimensionar imagen
         image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        background = Image.new('RGB', (max(new_width, MIN_WIDTH), max(new_height, MIN_HEIGHT)), 'black')
         
-        # Crear fondo negro del tamaño objetivo
-        background = Image.new('RGB', (MAX(new_width, MIN_WIDTH), MAX(new_height, MIN_HEIGHT)), 'black')
-        
-        # Centrar imagen en el fondo
         offset = ((background.width - image.width) // 2,
                  (background.height - image.height) // 2)
         background.paste(image, offset)
         
         return background
-    
     except Exception as e:
         print(f"Error processing image: {e}")
         return None
 
 def download_image(url):
-    """Download and process image from URL using proxies."""
     proxies = load_proxies()
     if not proxies:
         proxies = [None]
@@ -162,13 +142,11 @@ def download_image(url):
             response = requests.get(url, proxies=proxy, timeout=10)
             image = Image.open(BytesIO(response.content))
             
-            # Convertir a RGB si es necesario
             if image.mode in ('RGBA', 'LA') or (image.mode == 'P' and 'transparency' in image.info):
                 background = Image.new('RGB', image.size, (0, 0, 0))
                 background.paste(image, mask=image.split()[-1])
                 image = background
             
-            # Procesar imagen para cumplir requisitos de tamaño
             processed_image = process_image(image)
             if processed_image:
                 return processed_image
@@ -179,18 +157,15 @@ def download_image(url):
     return None
 
 def create_animated_clip(image, duration=5, zoom_factor=1.1):
-    """Create an animated clip from a still image with a zoom effect."""
     img_array = np.array(image)
     img_clip = ImageClip(img_array).set_duration(duration)
     
-    # Asegurar que el clip tenga el tamaño correcto
     if img_clip.size[0] < MIN_WIDTH or img_clip.size[1] < MIN_HEIGHT:
         img_clip = img_clip.resize(width=MIN_WIDTH, height=MIN_HEIGHT)
     
     return img_clip.resize(lambda t: 1 + (zoom_factor - 1) * t / duration)
 
 def concatenate_google_images(keywords, clip_duration=5, num_images_per_keyword=1):
-    """Concatenate Google Images based on keywords."""
     keyword_list = [keyword.strip() for keyword in keywords.split(",") if keyword.strip()]
     if not keyword_list:
         keyword_list = ["nature"]
@@ -216,9 +191,115 @@ def concatenate_google_images(keywords, clip_duration=5, num_images_per_keyword=
     random.shuffle(video_clips)
     return concatenate_videoclips(video_clips, method="compose")
 
-[... Resto del código se mantiene igual ...]
+def adjust_background_music(video_duration, music_file):
+    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)
+        music = music.subclip(0, video_duration)
+        return music.volumex(0.2)
+    except Exception as e:
+        print(f"Error adjusting music: {e}")
+        return None
+
+def combine_audio_video(audio_file, video_clip, music_clip=None):
+    try:
+        audio_clip = AudioFileClip(audio_file)
+        total_duration = audio_clip.duration + 2
+        
+        video_clip = video_clip.loop(duration=total_duration)
+        video_clip = video_clip.set_duration(total_duration).fadeout(2)
+        
+        final_clip = video_clip.set_audio(audio_clip)
+        if music_clip:
+            music_clip = music_clip.set_duration(total_duration).audio_fadeout(2)
+            final_clip = final_clip.set_audio(CompositeAudioClip([audio_clip, music_clip]))
+        
+        output_filename = f"final_video_{int(time.time())}.mp4"
+        output_path = os.path.join(output_folder, output_filename)
+        
+        final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac", fps=24)
+        
+        final_clip.close()
+        video_clip.close()
+        audio_clip.close()
+        if music_clip:
+            music_clip.close()
+            
+        return output_path
+    except Exception as e:
+        print(f"Error combining audio and video: {e}")
+        if 'final_clip' in locals():
+            final_clip.close()
+        return None
+
+def upload_to_google_drive(file_path, folder_id):
+    try:
+        creds = service_account.Credentials.from_service_account_info(
+            json.loads(os.getenv('GOOGLE_SERVICE_ACCOUNT')),
+            scopes=['https://www.googleapis.com/auth/drive']
+        )
+        service = build('drive', 'v3', credentials=creds)
+
+        file_metadata = {
+            'name': os.path.basename(file_path),
+            'parents': [folder_id]
+        }
+        media = MediaFileUpload(file_path, resumable=True)
+        file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
+
+        permission = {
+            'type': 'anyone',
+            'role': 'reader'
+        }
+        service.permissions().create(fileId=file['id'], body=permission).execute()
+
+        file_id = file['id']
+        download_link = f"https://drive.google.com/uc?export=download&id={file_id}"
+        return download_link
+    except Exception as e:
+        print(f"Error uploading to Google Drive: {e}")
+        return None
+
+def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch, keywords):
+    try:
+        if text.strip():
+            final_text = text
+        elif txt_file is not None:
+            final_text = txt_file.decode("utf-8")
+        else:
+            raise ValueError("No text input provided")
+        
+        audio_file = asyncio.run(text_to_speech(final_text, selected_voice, rate, pitch))
+        if not audio_file:
+            raise ValueError("Failed to generate audio")
+        
+        video_clip = concatenate_google_images(keywords, clip_duration=5, num_images_per_keyword=1)
+        if not video_clip:
+            raise ValueError("Failed to generate video")
+        
+        music_clip = None
+        if mp3_file is not None:
+            music_clip = adjust_background_music(video_clip.duration, mp3_file.name)
+        
+        final_video_path = combine_audio_video(audio_file, video_clip, music_clip)
+        if not final_video_path:
+            raise ValueError("Failed to combine audio and video")
+        
+        download_link = upload_to_google_drive(final_video_path, folder_id=FOLDER_ID)
+        if download_link:
+            print(f"Video uploaded to Google Drive. Download link: {download_link}")
+            return f"[Download video]({download_link})"
+        else:
+            raise ValueError("Error uploading video to Google Drive")
+    except Exception as e:
+        print(f"Error during processing: {e}")
+        return None
+    finally:
+        cleanup_temp_files()
 
-# Gradio interface
 with gr.Blocks() as demo:
     gr.Markdown("# Text-to-Video Generator")
     with gr.Row():
@@ -228,7 +309,7 @@ with gr.Blocks() as demo:
             mp3_file_input = gr.File(label="Upload background music (.mp3)", file_types=[".mp3"])
             keyword_input = gr.Textbox(
                 label="Enter keywords separated by commas",
-                value="fear, religion, god, demons, aliens, possession, galaxy, mysterious"
+                value="fear, religion, god, demons, aliens, possession, galaxy, mysterious, dystopian, astral, warfare, space, space, galaxy, moon, fear, astral, god, evil, mystery, cosmos, stars, paranormal, inexplicable, hidden, enigma, unknown, unusual, intriguing, curious, strange, supernatural, esoteric, arcane, occultism, supernatural, mystery, phenomenon, rare, unusual, enigmatic, sinister, gloomy, dark, shadowy, macabre, eerie, chilling, cursed, fantastic, unreal, unknown, mysterious, enigmatic, inexplicable, unusual, strange, unusual, arcane, esoteric, hidden, shadowy, dark, gloomy, sinister, macabre, eerie, chilling, cursed, fantastic, unreal, paranormal, supernatural, occultism, phenomenon, rare, intriguing, curious"
             )
             voices = asyncio.run(get_voices())
             voice_dropdown = gr.Dropdown(choices=list(voices.keys()), label="Select Voice")