I want a full ready would you rather generator. for that combind all the files I made. 
here is the first file I made, its called 16.py and its for the video generation:
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from moviepy.editor import (
    TextClip,
    ColorClip,
    CompositeVideoClip,
    ImageClip,
)
from moviepy.config import change_settings
import numpy as np
from PIL import Image, ImageDraw
import os

# Configure ImageMagick (Ensure this path is correct for your system)
change_settings(
    {"IMAGEMAGICK_BINARY": r"C:\Program Files\ImageMagick-7.1.1-Q16-HDRI\magick.exe"}
)


class WouldYouRatherGenerator:
    def __init__(self):
        self.window = tk.Tk()
        self.window.title("Would You Rather Generator")
        self.window.geometry("800x700")  # Increased height to accommodate new field

        # Video dimensions (9:16 ratio)
        self.width = 1080
        self.height = 1920
        self.middle_y = self.height // 2

        # Store image paths
        self.image1_path = None  # Top image (Black socks)
        self.image2_path = None  # Bottom image (White socks)

        self.setup_ui()

    def setup_ui(self):
        main_frame = ttk.Frame(self.window, padding="20")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))

        # Configure grid columns for consistent alignment
        for i in range(4):
            main_frame.columnconfigure(i, weight=1, pad=5)

        # Option 1 Section (Top Half - Black Socks)
        option1_frame = ttk.LabelFrame(main_frame, text="Option 1 (Black Socks)", padding="10")
        option1_frame.grid(row=0, column=0, columnspan=4, sticky=(tk.W, tk.E), pady=10)

        ttk.Label(option1_frame, text="Text:").grid(row=0, column=0, sticky=tk.W, pady=5)
        self.option1_text = ttk.Entry(option1_frame, width=50)
        self.option1_text.grid(row=0, column=1, columnspan=2, sticky=(tk.W, tk.E), pady=5)
        self.option1_text.insert(0, "SCHWARZE SOCKEN")  # Default text

        ttk.Label(option1_frame, text="Image:").grid(row=1, column=0, sticky=tk.W, pady=5)
        self.image1_label = ttk.Label(option1_frame, text="No image selected")
        self.image1_label.grid(row=1, column=1, sticky=tk.W, pady=5)
        ttk.Button(
            option1_frame, text="Browse...", command=lambda: self.select_image(1)
        ).grid(row=1, column=2, padx=5, pady=5)

        ttk.Label(option1_frame, text="Percentage:").grid(row=2, column=0, sticky=tk.W, pady=5)
        self.percent1 = ttk.Entry(option1_frame, width=10)
        self.percent1.grid(row=2, column=1, sticky=tk.W, pady=5)
        self.percent1.insert(0, "1,02%")  # Default percentage

        # Option 2 Section (Bottom Half - White Socks)
        option2_frame = ttk.LabelFrame(main_frame, text="Option 2 (White Socks)", padding="10")
        option2_frame.grid(row=1, column=0, columnspan=4, sticky=(tk.W, tk.E), pady=10)

        ttk.Label(option2_frame, text="Text:").grid(row=0, column=0, sticky=tk.W, pady=5)
        self.option2_text = ttk.Entry(option2_frame, width=50)
        self.option2_text.grid(row=0, column=1, columnspan=2, sticky=(tk.W, tk.E), pady=5)
        self.option2_text.insert(0, "WEIßE SOCKEN")  # Default text

        ttk.Label(option2_frame, text="Image:").grid(row=1, column=0, sticky=tk.W, pady=5)
        self.image2_label = ttk.Label(option2_frame, text="No image selected")
        self.image2_label.grid(row=1, column=1, sticky=tk.W, pady=5)
        ttk.Button(
            option2_frame, text="Browse...", command=lambda: self.select_image(2)
        ).grid(row=1, column=2, padx=5, pady=5)

        ttk.Label(option2_frame, text="Percentage:").grid(row=2, column=0, sticky=tk.W, pady=5)
        self.percent2 = ttk.Entry(option2_frame, width=10)
        self.percent2.grid(row=2, column=1, sticky=tk.W, pady=5)
        self.percent2.insert(0, "999,72%")  # Default percentage

        # Timing Controls Section
        timing_frame = ttk.LabelFrame(main_frame, text="Timing Controls", padding="10")
        timing_frame.grid(row=2, column=0, columnspan=4, sticky=(tk.W, tk.E), pady=10)

        ttk.Label(timing_frame, text="Initial Pause (seconds):").grid(
            row=0, column=0, sticky=tk.W, pady=5
        )
        self.initial_pause = ttk.Entry(timing_frame, width=10)
        self.initial_pause.grid(row=0, column=1, sticky=tk.W, pady=5)
        self.initial_pause.insert(0, "2")  # Default 2 seconds

        ttk.Label(timing_frame, text="Timer Delay Before Second Image (seconds):").grid(
            row=1, column=0, sticky=tk.W, pady=5
        )
        self.timer_delay = ttk.Entry(timing_frame, width=10)
        self.timer_delay.grid(row=1, column=1, sticky=tk.W, pady=5)
        self.timer_delay.insert(0, "1")  # Default 1 second

        ttk.Label(timing_frame, text="Wait Before Countdown (seconds):").grid(
            row=2, column=0, sticky=tk.W, pady=5
        )
        self.wait_before_countdown = ttk.Entry(timing_frame, width=10)
        self.wait_before_countdown.grid(row=2, column=1, sticky=tk.W, pady=5)
        self.wait_before_countdown.insert(0, "1")  # Default 1 second

        ttk.Label(timing_frame, text="Countdown (seconds):").grid(
            row=3, column=0, sticky=tk.W, pady=5
        )
        self.countdown_duration = ttk.Entry(timing_frame, width=10)
        self.countdown_duration.grid(row=3, column=1, sticky=tk.W, pady=5)
        self.countdown_duration.insert(0, "5")  # Default 5 seconds

        # Generate Button
        generate_button = ttk.Button(
            main_frame, text="Generate Video", command=self.generate_video
        )
        generate_button.grid(row=4, column=0, columnspan=4, pady=20)

    def select_image(self, option_num):
        """
        Open a file dialog to select an image and update the corresponding label.
        """
        file_path = filedialog.askopenfilename(
            filetypes=[("Image files", "*.png *.jpg *.jpeg *.gif *.bmp")]
        )
        if file_path:
            if option_num == 1:
                self.image1_path = file_path
                self.image1_label.config(text=os.path.basename(file_path))
            elif option_num == 2:
                self.image2_path = file_path
                self.image2_label.config(text=os.path.basename(file_path))

    def process_image(self, image_path, size=(500, 500), start_time=0, duration=0):
        """
        Process the image by converting mode and resizing proportionally without warping.

        :param image_path: Path to the image file.
        :param size: Maximum width and height as a tuple. Increased to (500, 500).
        :param start_time: Time at which the image should appear in the video.
        :param duration: Duration of the image clip.
        :return: An ImageClip object.
        """
        img = Image.open(image_path)

        if img.mode != "RGBA":
            img = img.convert("RGBA")

        # Resize image proportionally if size is provided
        if size:
            img.thumbnail(size, Image.LANCZOS)  # In-place resizing

        img_array = np.array(img)

        clip_duration = duration if duration > 0 else self.total_duration

        clip = ImageClip(img_array).set_duration(clip_duration)

        if start_time > 0:
            clip = clip.set_start(start_time)

        return clip

    def create_styled_text(
        self, text, y_position, duration, start_time=0, fontsize=70, color="yellow",
        stroke_color="black", stroke_width=2
    ):
        """
        Create a styled TextClip.

        :param text: Text content.
        :param y_position: Vertical position of the text.
        :param duration: Duration for which the text is visible.
        :param start_time: Time at which the text appears.
        :param fontsize: Font size of the text.
        :param color: Text color.
        :param stroke_color: Stroke (outline) color.
        :param stroke_width: Width of the stroke.
        :return: A TextClip object.
        """
        text_clip = TextClip(
            text,
            font="Arial-Bold",
            color=color,
            fontsize=fontsize,
            method="label",  # Changed to 'label' for better positioning
            stroke_color=stroke_color,
            stroke_width=stroke_width,
        ).set_duration(duration)

        if start_time > 0:
            text_clip = text_clip.set_start(start_time)

        return text_clip.set_position(("center", y_position))

    def create_timer_clips(self, start_time, countdown_seconds, total_duration):
        """
        Create countdown timer clips from countdown_seconds to 1 (excluding 0).

        :param start_time: The time at which the countdown starts.
        :param countdown_seconds: Number of seconds to count down from.
        :param total_duration: Total duration of the video.
        :return: A list of TextClip objects for the countdown.
        """
        timer_clips = []
        for i in range(countdown_seconds, 0, -1):  # Excludes 0
            current_time = countdown_seconds - i
            timer_text = str(i)
            timer_duration = 1  # Each number shows for 1 second
            timer_clip = self.create_styled_text(
                timer_text,
                self.middle_y - 100,  # Positioned slightly above the center
                timer_duration,
                start_time + current_time,
                fontsize=150,
                color="white",
                stroke_color="black",
                stroke_width=3
            )
            timer_clips.append(timer_clip)
        return timer_clips

    def generate_video(self):
        """
        Generate the 'Would You Rather' video based on user inputs.
        """
        # Validate inputs
        if not self.image1_path or not self.image2_path:
            messagebox.showerror("Input Error", "Please select both images (Option 1 and Option 2).")
            return

        option1_text = self.option1_text.get().strip()
        option2_text = self.option2_text.get().strip()

        if not option1_text or not option2_text:
            messagebox.showerror(
                "Input Error", "Please enter text for both options."
            )
            return

        # Validate timing inputs
        try:
            initial_pause = float(self.initial_pause.get())
            timer_delay = float(self.timer_delay.get())
            countdown_wait = float(self.wait_before_countdown.get())
            countdown_seconds = int(self.countdown_duration.get())
        except ValueError:
            messagebox.showerror(
                "Input Error", "Please enter valid numeric values for timings."
            )
            return

        if countdown_wait < 0:
            messagebox.showerror(
                "Input Error", "Wait Before Countdown cannot be negative."
            )
            return

        # Validate percentage inputs
        try:
            # Replace comma with dot for decimal conversion if used
            percent1_val = self.percent1.get().strip().replace(',', '.').replace('%', '')
            percent2_val = self.percent2.get().strip().replace(',', '.').replace('%', '')
            percent1 = float(percent1_val)
            percent2 = float(percent2_val)
        except ValueError:
            messagebox.showerror(
                "Input Error", "Please enter valid numeric values for percentages (e.g., 1.02%)."
            )
            return

        # Define percentage display duration and desired extra time
        percentage_duration = 3  # seconds (increased from 2)
        desired_extra_time = 0    # seconds (no extra buffer after percentages)

        # Calculate buffer_time as the sum of percentage_duration and desired_extra_time
        buffer_time = percentage_duration + desired_extra_time  # 3 + 0 = 3 seconds

        # Calculate total_duration
        self.total_duration = (
            initial_pause
            + timer_delay
            + countdown_wait
            + countdown_seconds
            + buffer_time
        )  # e.g., 2 + 1 + 1 + 5 + 3 = 12 seconds

        # Create background clips
        red_clip = ColorClip((self.width, self.middle_y), color=(255, 0, 0)).set_duration(
            self.total_duration
        )
        blue_clip = ColorClip((self.width, self.middle_y), color=(0, 0, 255)).set_duration(
            self.total_duration
        )

        clips = [
            red_clip.set_position((0, 0)),
            blue_clip.set_position((0, self.middle_y)),
        ]

        # Fixed Positions

        # Top Half
        top_image_y = 250    # Moved further down from 200 to 250
        top_text_y = 650     # Moved up by 50 pixels from 700 to 650
        top_percentage_y = 750  # Moved up by 50 pixels from 800 to 750

        # Bottom Half
        bottom_image_y = self.middle_y + 350  # Moved further down from self.middle_y + 300 to +350
        bottom_text_y = 1200  # Fixed position for bottom text
        bottom_percentage_y = 1100  # Changed from 1300 to 1100 to place above the bottom text

        # Add top image (Black Socks) with initial_pause delay
        img1_clip = self.process_image(
            self.image1_path,
            size=(500, 500),       # Increased size to 500x500
            start_time=initial_pause,          # Starts after initial_pause
            duration=self.total_duration - initial_pause  # Adjust duration accordingly
        )
        if img1_clip:
            clips.append(img1_clip.set_position(("center", top_image_y)))

        # Add top text with initial_pause delay
        option1_txt = self.create_styled_text(
            option1_text.upper(),
            y_position=top_text_y,
            duration=self.total_duration - initial_pause,  # Duration until end
            start_time=initial_pause,          # Starts after initial_pause
            fontsize=80,
            color="white",
            stroke_color="black",
            stroke_width=3
        )
        clips.append(option1_txt)

        # Add bottom image (White Socks) after initial_pause + timer_delay
        img2_start_time = initial_pause + timer_delay
        img2_clip = self.process_image(
            self.image2_path,
            size=(500, 500),       # Increased size to 500x500
            start_time=img2_start_time,
            duration=self.total_duration - img2_start_time  # Adjust duration accordingly
        )
        if img2_clip:
            clips.append(img2_clip.set_position(("center", bottom_image_y)).set_start(img2_start_time))

        # Add bottom text below the bottom image after initial_pause + timer_delay
        option2_txt = self.create_styled_text(
            option2_text.upper(),
            y_position=bottom_text_y,
            duration=self.total_duration - img2_start_time,  # Duration until the end
            start_time=img2_start_time,
            fontsize=80,
            color="white",
            stroke_color="black",
            stroke_width=3
        )
        clips.append(option2_txt)

        # Add dividing line
        line_thickness = 8
        black_line = ColorClip((self.width, line_thickness), color=(0, 0, 0)).set_duration(self.total_duration)
        black_line = black_line.set_position((0, self.middle_y - line_thickness // 2))
        clips.append(black_line)

        # Add small black circle in the middle of the dividing line
        circle_diameter = 50  # Adjust size as needed
        circle_size = (circle_diameter, circle_diameter)

        # Create a transparent image with a black circle
        circle_img = Image.new("RGBA", circle_size, (0, 0, 0, 0))
        draw = ImageDraw.Draw(circle_img)
        draw.ellipse((0, 0, circle_diameter, circle_diameter), fill=(0, 0, 0, 255))
        circle_array = np.array(circle_img)

        # Create ImageClip for the circle
        circle_clip = ImageClip(circle_array).set_duration(self.total_duration)
        # Position the circle in the middle of the dividing line
        circle_position = (self.width // 2 - circle_diameter // 2, self.middle_y - circle_diameter // 2)
        clips.append(circle_clip.set_position(circle_position))

        # Add countdown timer after initial_pause + timer_delay + countdown_wait
        countdown_start_time = initial_pause + timer_delay + countdown_wait
        timer_clips = self.create_timer_clips(countdown_start_time, countdown_seconds, self.total_duration)
        clips.extend(timer_clips)

        # Add Percentage 1 Text ("1.02%") in Yellow after countdown
        percent1_txt = self.create_styled_text(
            f"{percent1:.2f}%",
            y_position=top_percentage_y,
            duration=percentage_duration,  # 3 seconds
            start_time=countdown_start_time + countdown_seconds,
            fontsize=100,  # Increased font size
            color="yellow",
            stroke_color="black",
            stroke_width=2
        )
        clips.append(percent1_txt)

        # Add Percentage 2 Text ("999.72%") in Yellow above the bottom text after countdown
        percent2_txt = self.create_styled_text(
            f"{percent2:.2f}%",
            y_position=bottom_percentage_y,
            duration=percentage_duration,  # 3 seconds
            start_time=countdown_start_time + countdown_seconds,
            fontsize=100,  # Increased font size
            color="yellow",
            stroke_color="black",
            stroke_width=2
        )
        clips.append(percent2_txt)

        # No additional buffer_time; video will end after percentages are hidden

        # Create final video
        final_clip = CompositeVideoClip(clips, size=(self.width, self.height))

        # Render the video
        final_clip.write_videofile(
            "would_you_rather.mp4",
            fps=30,
            codec="libx264",
            audio=False,
            threads=4,
            preset="medium",
        )
        messagebox.showinfo("Success", "Video generated successfully!")

    def run(self):
        self.window.mainloop()


if __name__ == "__main__":
    app = WouldYouRatherGenerator()
    app.run()
	
	
	
and here is the code I made for the idea and text generatoin.
text_generation.py:
import ollama

def generate_would_you_rather():
    prompt = """Generate 6 funny and weird 'Would You Rather' choices. 
    Format each pair EXACTLY like this example:

    1.
    CHOICE: eat a glowing mushroom
    IMAGE: A luminescent blue mushroom radiating soft light in the darkness, sitting on a bed of moss with tiny sparkles emanating from its cap
    VERSUS
    CHOICE: drink liquid rainbow
    IMAGE: A crystal glass filled with swirling, iridescent liquid that shifts through all colors of the spectrum, leaving trails of light as it moves

    2.
    CHOICE: have clouds for shoes
    IMAGE: Fluffy white cumulus clouds shaped like sneakers, floating inches above the ground, leaving behind small rainbows with each step
    VERSUS
    CHOICE: wear a hat made of living butterflies
    IMAGE: A graceful arrangement of vibrant butterflies forming a crown-like hat, their wings gently fluttering in unison

    Make each pair unique, weird, and entertaining. Write detailed image descriptions that would help create a clear visual."""

    try:
        response = ollama.chat(model='llama3.2', messages=[
            {'role': 'user', 'content': prompt}
        ])
        return response['message']['content'].strip()
        
    except Exception as e:
        print(f"Error: {str(e)}")
        raise

def main():
    print("Generating Would You Rather pairs...")
    print("\n" + "="*50 + "\n")
    
    result = generate_would_you_rather()
    print(result)
    
    # Save to file
    with open('would_you_rather.txt', 'w', encoding='utf-8') as f:
        f.write(result)
    
    print("\n" + "="*50)
    print("\nResults have been saved to would_you_rather.txt")

if __name__ == "__main__":
    main()
	
	


and here for the image you can use this:
image_generation.py:

import websocket
import uuid
import json
import urllib.request
import urllib.parse
import random
import os
from pathlib import Path
from io import BytesIO

class ComfyUIGenerator:
    def __init__(self, server_address="127.0.0.1:8188"):
        self.server_address = server_address
        self.client_id = str(uuid.uuid4())
        
        # Create generate_images folder if it doesn't exist
        Path("generate_images").mkdir(exist_ok=True)
        
    def load_workflow(self, workflow_path):
        """Load workflow JSON from file"""
        with open(workflow_path, 'r') as f:
            return json.load(f)
            
    def queue_prompt(self, prompt):
        """Queue a prompt on the ComfyUI server"""
        p = {"prompt": prompt, "client_id": self.client_id}
        data = json.dumps(p).encode('utf-8')
        req = urllib.request.Request(f"http://{self.server_address}/prompt", data=data)
        return json.loads(urllib.request.urlopen(req).read())

    def get_image(self, filename, subfolder, folder_type):
        """Get image data from the server"""
        data = {"filename": filename, "subfolder": subfolder, "type": folder_type}
        url_values = urllib.parse.urlencode(data)
        with urllib.request.urlopen(f"http://{self.server_address}/view?{url_values}") as response:
            return response.read()

    def get_history(self, prompt_id):
        """Get history data for a prompt"""
        with urllib.request.urlopen(f"http://{self.server_address}/history/{prompt_id}") as response:
            return json.loads(response.read())

    def save_image(self, image_data, filename):
        """Save image data to file"""
        output_path = Path("generate_images") / filename
        with open(output_path, 'wb') as f:
            f.write(image_data)
        print(f"Image saved to: {output_path}")

    def get_images(self, ws, prompt):
        """Get images using the history endpoint"""
        prompt_id = self.queue_prompt(prompt)['prompt_id']
        
        # Wait for execution to complete
        while True:
            out = ws.recv()
            if isinstance(out, str):
                message = json.loads(out)
                if message['type'] == 'executing':
                    data = message['data']
                    if data['node'] is None and data['prompt_id'] == prompt_id:
                        break
            else:
                continue  # Skip binary messages (previews)

        # Get the images from history
        history = self.get_history(prompt_id)[prompt_id]
        output_images = {}
        
        for node_id in history['outputs']:
            node_output = history['outputs'][node_id]
            images_output = []
            if 'images' in node_output:
                for image in node_output['images']:
                    image_data = self.get_image(
                        image['filename'], 
                        image['subfolder'], 
                        image['type']
                    )
                    images_output.append(image_data)
            output_images[node_id] = images_output
            
        return output_images, prompt_id

    def generate_image(self, workflow_path, prompt_text, seed=None):
        """Generate an image using the workflow"""
        # Load the workflow
        workflow = self.load_workflow(workflow_path)
        
        # Generate random seed if none provided
        if seed is None:
            seed = random.randint(0, 1000000000)
            
        # Find the CLIPTextEncode node for positive prompt
        for node_id, node in workflow.items():
            if node.get("class_type") == "CLIPTextEncode" and \
               "_meta" in node and \
               "title" in node["_meta"] and \
               "Positive" in node["_meta"]["title"]:
                node["inputs"]["text"] = prompt_text
                
        # Find the KSampler node to update the seed
        for node_id, node in workflow.items():
            if node.get("class_type") == "KSampler":
                node["inputs"]["seed"] = seed

        # Connect to websocket
        ws = websocket.WebSocket()
        ws.connect(f"ws://{self.server_address}/ws?clientId={self.client_id}")
        
        try:
            # Get images using history endpoint
            images, prompt_id = self.get_images(ws, workflow)
            
            # Save all generated images
            for node_id, image_list in images.items():
                for i, image_data in enumerate(image_list):
                    filename = f"generated_{seed}_{node_id}_{i}.png"
                    self.save_image(image_data, filename)
                    
        finally:
            ws.close()
            
        return seed

def main():
    # Initialize the generator
    generator = ComfyUIGenerator()
    
    # Example prompts
    prompts = [
        "a beautiful landscape with mountains",
        "a cyberpunk city at night",
        "a serene beach at sunset",
        "an enchanted forest with magical creatures"
    ]
    
    # Generate multiple images with different prompts
    workflow_path = "workflow.json"  # Make sure this file exists
    
    for prompt in prompts:
        print(f"\nGenerating image for prompt: {prompt}")
        try:
            seed = generator.generate_image(workflow_path, prompt)
            print(f"Generated image with seed: {seed}")
        except Exception as e:
            print(f"Error generating image for prompt '{prompt}': {str(e)}")

if __name__ == "__main__":
    main()
	
	
	
	
and please use this for the voice generation.
voice_generation.py:
import os
import subprocess
from pathlib import Path
import shutil
import datetime
import argparse

def generate_tts(text, base_dir=None, ref_audio=None, output_dir=None):
    """
    Generate TTS audio using F5-TTS model.
    
    Args:
        text (str): Text to convert to speech
        base_dir (str): Base directory where F5-TTS is installed
        ref_audio (str): Path to reference audio file
        output_dir (str): Directory to save output files
    """
    if base_dir is None:
        base_dir = r"C:\Users\theod\Desktop\AI\text2voice\F5-TTS"
    
    if ref_audio is None:
        ref_audio = os.path.join(base_dir, "tests", "ref_audio", "tiktok.mp3")
    
    if output_dir is None:
        output_dir = os.path.join(r"C:\Users\theod\Desktop\Coding\AI\wouldyourather\generated_audio")
    
    # Create output directory if it doesn't exist
    os.makedirs(output_dir, exist_ok=True)
    
    # Reference text that matches your sample
    ref_text = "Never go to school again. Or, Get paid to go to school. Be able to fly like a bird or be able to swim like a fish. Have a long but ordinary life or have a short but extraordinary life I love God or reject the offer have a ferrari."
    
    # Build the command with proper quoting
    cmd = [
        "python", "inference-cli.py",
        "--model", "F5-TTS",
        "--ref_audio", f'"{ref_audio}"',
        "--ref_text", f'"{ref_text}"',
        "--gen_text", f'"{text}"'
    ]
    
    try:
        # Change to the base directory
        original_dir = os.getcwd()
        os.chdir(base_dir)
        
        # Combine command with proper quoting
        command_str = " ".join(cmd)
        
        # Activate virtual environment and run command
        if os.name == 'nt':  # Windows
            activate_cmd = os.path.join(base_dir, "venv", "Scripts", "activate")
            full_command = f'call "{activate_cmd}" && {command_str}'
            subprocess.run(full_command, shell=True, check=True)
        else:  # Linux/Mac
            activate_cmd = os.path.join(base_dir, "venv", "bin", "activate")
            full_command = f'source "{activate_cmd}" && {command_str}'
            subprocess.run(full_command, shell=True, check=True)
        
        # Copy the output file to our designated output directory
        output_file = os.path.join(base_dir, "tests", "out.wav")
        if os.path.exists(output_file):
            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
            new_filename = f"tts_output_{timestamp}.wav"
            new_filepath = os.path.join(output_dir, new_filename)
            shutil.copy2(output_file, new_filepath)
            print(f"Audio generated successfully: {new_filepath}")
            return new_filepath
        else:
            print("Error: Output file not found")
            return None
            
    except subprocess.CalledProcessError as e:
        print(f"Command execution failed: {str(e)}")
        return None
    except Exception as e:
        print(f"Error occurred: {str(e)}")
        return None
    finally:
        # Return to original directory
        os.chdir(original_dir)

def main():
    parser = argparse.ArgumentParser(description='Generate TTS audio using F5-TTS')
    parser.add_argument('--text', type=str, required=True, help='Text to convert to speech')
    args = parser.parse_args()
    
    output_path = generate_tts(args.text)
    if output_path:
        print(f"Generated audio saved to: {output_path}")

if __name__ == "__main__":
    # Example usage:
    text_to_generate = "This is a test of the TTS system"
    generate_tts(text_to_generate)
    
    # Or you can run it with multiple texts:
    texts = [
        "Welcome to my TikTok channel!",
        "Don't forget to like and subscribe",
        "Check out this amazing trick"
    ]
    
    for text in texts:
        generate_tts(text)
		
		
		
so make it automatically generation a video. 
make sure to change the timings of the video to match the time of the audio recordings that were generated. 
please change the files mentioned here, so that you can easily use their functions.
please import the functions from the python files I have and use them