import requests_proxy import gradio as gr from tts_module import get_voices, text_to_speech from moviepy.editor import ( AudioFileClip, ImageClip, CompositeAudioClip, concatenate_audioclips, concatenate_videoclips, vfx, CompositeVideoClip, ColorClip ) import asyncio import os import json import time import requests import random from googleapiclient.discovery import build from google.oauth2 import service_account from googleapiclient.http import MediaFileUpload from io import BytesIO from PIL import Image import numpy as np MIN_WIDTH = 1920 MIN_HEIGHT = 1080 TARGET_ASPECT_RATIO = 16 / 9 output_folder = "outputs" temp_dir = "temp_files" os.makedirs(output_folder, exist_ok=True) os.makedirs(temp_dir, exist_ok=True) FOLDER_ID = "12S6adpanAXjf71pKKGRRPqpzbJa5XEh3" # Función para cargar proxies desde un archivo def load_proxies(proxy_file="proxys.txt"): try: with open(proxy_file, 'r') as f: proxies = [line.strip() for line in f if line.strip()] print(f"Loaded {len(proxies)} proxies from file") return [{"http": f"http://{proxy}", "https": f"http://{proxy}"} for proxy in proxies] except Exception as e: print(f"Error loading proxies: {e}") return [] # Función para buscar imágenes en Google Custom Search API def search_google_images(query, num_images=1): try: api_key = os.getenv('GOOGLE_API_KEY') cse_id = os.getenv('GOOGLE_CSE_ID') proxies = load_proxies() print(f"Buscando imágenes para: {query}") # Intenta con proxies si están disponibles if proxies: for proxy in proxies: try: print(f"Trying with proxy: {proxy['http']}") result = requests.get( "https://www.googleapis.com/customsearch/v1", params={ "q": query, "cx": cse_id, "searchType": "image", "num": num_images * 3, "safe": "off", "imgSize": "LARGE", "rights": "cc_publicdomain|cc_attribute|cc_sharealike", "key": api_key }, proxies=proxy, timeout=10 ).json() break # Sale del bucle si la solicitud es exitosa except Exception as e: print(f"Error using proxy {proxy['http']}: {e}") continue else: print("No proxies available, trying without proxy") result = requests.get( "https://www.googleapis.com/customsearch/v1", params={ "q": query, "cx": cse_id, "searchType": "image", "num": num_images * 3, "safe": "off", "imgSize": "LARGE", "rights": "cc_publicdomain|cc_attribute|cc_sharealike", "key": api_key }, timeout=10 ).json() if 'items' in result: image_urls = [] for item in result.get('items', []): if 'image' in item: width = int(item['image'].get('width', 0)) height = int(item['image'].get('height', 0)) if width >= MIN_WIDTH and height >= MIN_HEIGHT: image_urls.append(item['link']) if len(image_urls) >= num_images: break print(f"Encontradas {len(image_urls)} imágenes de tamaño adecuado") return image_urls print("No se encontraron imágenes después de probar todos los proxies") return [] except Exception as e: print(f"Error general en la búsqueda de imágenes: {str(e)}") return [] # Procesa una imagen para ajustar su tamaño def process_image(image): try: width, height = image.size current_ratio = width / height if current_ratio > TARGET_ASPECT_RATIO: new_width = max(MIN_WIDTH, width) new_height = int(new_width / TARGET_ASPECT_RATIO) else: new_height = max(MIN_HEIGHT, height) new_width = int(new_height * TARGET_ASPECT_RATIO) 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') 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 # Descarga una imagen desde una URL def download_image(url): proxies = load_proxies() if not proxies: proxies = [None] for proxy in proxies: try: response = requests.get(url, proxies=proxy, timeout=10) image = Image.open(BytesIO(response.content)) 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 processed_image = process_image(image) if processed_image: return processed_image except Exception as e: print(f"Error downloading image with proxy {proxy}: {e}") continue return None # Crea un clip animado a partir de una imagen def create_animated_clip(image, duration=5, zoom_factor=1.1): img_array = np.array(image) img_clip = ImageClip(img_array).set_duration(duration) 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) # Concatena clips de video basados en palabras clave def concatenate_google_images(keywords, clip_duration=5, num_images_per_keyword=1): keyword_list = [keyword.strip() for keyword in keywords.split(",") if keyword.strip()] if not keyword_list: keyword_list = ["nature"] video_clips = [] for keyword in keyword_list: try: print(f"Searching images for keyword '{keyword}'...") image_urls = search_google_images(keyword, num_images=num_images_per_keyword) for url in image_urls: image = download_image(url) if image: clip = create_animated_clip(image, duration=clip_duration) video_clips.append(clip) time.sleep(1) except Exception as e: print(f"Error processing keyword '{keyword}': {e}") continue if not video_clips: return ColorClip(size=(MIN_WIDTH, MIN_HEIGHT), color=[0, 0, 0], duration=5) random.shuffle(video_clips) return concatenate_videoclips(video_clips, method="compose") # Ajusta la música de fondo para que coincida con la duración del video 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 # Combina audio y video en un solo archivo 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 # Sube un archivo al Google Drive 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 # Limpia archivos temporales def cleanup_temp_files(): try: if os.path.exists(temp_dir) and os.path.isdir(temp_dir): shutil.rmtree(temp_dir) os.makedirs(temp_dir, exist_ok=True) print("Temporal files cleaned up successfully.") except Exception as e: print(f"Error cleaning up temporary files: {e}") # Procesa la entrada del usuario y genera el video 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: 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() # Interfaz Gradio with gr.Blocks() as demo: gr.Markdown("# Text-to-Video Generator") with gr.Row(): with gr.Column(): text_input = gr.Textbox(label="Write your text here", lines=5) txt_file_input = gr.File(label="Or upload a .txt file", file_types=[".txt"]) mp3_file_input = gr.File(label="Upload background music (.mp3)", file_types=[".mp3"]) keyword_input = gr.Textbox( label="Enter keywords separated by commas", value="nature, landscape, city, people" ) voices = asyncio.run(get_voices()) voice_dropdown = gr.Dropdown(choices=list(voices.keys()), label="Select Voice") rate_slider = gr.Slider(minimum=-50, maximum=50, value=0, label="Speech Rate Adjustment (%)", step=1) pitch_slider = gr.Slider(minimum=-20, maximum=20, value=0, label="Pitch Adjustment (Hz)", step=1) with gr.Column(): output_link = gr.Markdown("") btn = gr.Button("Generate Video") btn.click( process_input, inputs=[text_input, txt_file_input, mp3_file_input, voice_dropdown, rate_slider, pitch_slider, keyword_input], outputs=output_link ) port = int(os.getenv("PORT", 7860)) demo.launch(server_name="0.0.0.0", server_port=port, share=True, show_error=True)