Upload 18 files

.env.example

@@ -0,0 +1,32 @@
+# See EnvironmentVariables.md for more information.
+
+# Necessary API Keys
+# -------------------
+
+# TikTok Session ID
+# Obtain your session ID by logging into TikTok and copying the sessionid cookie.
+TIKTOK_SESSION_ID=""
+
+# ImageMagick Binary Path
+# Download ImageMagick from https://imagemagick.org/script/download.php
+IMAGEMAGICK_BINARY=""
+
+# Pexels API Key
+# Register at https://www.pexels.com/api/ to get your API key.
+PEXELS_API_KEY=""
+
+# Optional API Keys
+# -----------------
+
+# OpenAI API Key
+# Visit https://openai.com/api/ for details on obtaining an API key.
+OPENAI_API_KEY=""
+
+# AssemblyAI API Key
+# Sign up at https://www.assemblyai.com/ to receive an API key.
+ASSEMBLY_AI_API_KEY=""
+
+# Google API Key
+# Generate your API key through https://makersuite.google.com/app/apikey
+GOOGLE_API_KEY=""
+ 

.gitignore

@@ -0,0 +1,18 @@
+__pycache__
+.env
+temp/*
+sounds/*
+output/*
+images/*
+*.zip
+*.srt
+*.mp4
+*.mp3
+.history
+subtitles/*
+/venv
+client_secret.json
+main.py-oauth2.json
+.DS_Store
+Backend/output*
+Songs/

Backend/gpt.py

@@ -0,0 +1,263 @@
+import re
+import json
+import g4f
+import openai
+from typing import Tuple, List  
+from termcolor import colored
+from dotenv import load_dotenv
+import os
+import google.generativeai as genai
+
+# Load environment variables
+load_dotenv("../.env")
+
+# Set environment variables
+OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
+openai.api_key = OPENAI_API_KEY
+GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
+genai.configure(api_key=GOOGLE_API_KEY)
+
+
+def generate_response(prompt: str, ai_model: str) -> str:
+    """
+    Generate a script for a video, depending on the subject of the video.
+
+    Args:
+        video_subject (str): The subject of the video.
+        ai_model (str): The AI model to use for generation.
+
+
+    Returns:
+
+        str: The response from the AI model.
+
+    """
+
+    if ai_model == 'g4f':
+
+        response = g4f.ChatCompletion.create(
+
+            model=g4f.models.gpt_35_turbo_16k_0613,
+
+            messages=[{"role": "user", "content": prompt}],
+
+        )
+
+    elif ai_model in ["gpt3.5-turbo", "gpt4"]:
+
+        model_name = "gpt-3.5-turbo" if ai_model == "gpt3.5-turbo" else "gpt-4-1106-preview"
+
+        response = openai.chat.completions.create(
+
+            model=model_name,
+
+            messages=[{"role": "user", "content": prompt}],
+
+        ).choices[0].message.content
+    elif ai_model == 'gemmini':
+        model = genai.GenerativeModel('gemini-pro')
+        response_model = model.generate_content(prompt)
+        response = response_model.text
+
+    else:
+
+        raise ValueError("Invalid AI model selected.")
+
+    return response
+
+def generate_script(video_subject: str, paragraph_number: int, ai_model: str, voice: str, customPrompt: str) -> str:
+
+    """
+    Generate a script for a video, depending on the subject of the video, the number of paragraphs, and the AI model.
+
+
+
+    Args:
+
+        video_subject (str): The subject of the video.
+
+        paragraph_number (int): The number of paragraphs to generate.
+
+        ai_model (str): The AI model to use for generation.
+
+
+
+    Returns:
+
+        str: The script for the video.
+
+    """
+
+    # Build prompt
+    
+    if customPrompt:
+        prompt = customPrompt
+    else:
+        prompt = """
+            Generate a script for a video, depending on the subject of the video.
+
+            The script is to be returned as a string with the specified number of paragraphs.
+
+            Here is an example of a string:
+            "This is an example string."
+
+            Do not under any circumstance reference this prompt in your response.
+
+            Get straight to the point, don't start with unnecessary things like, "welcome to this video".
+
+            Obviously, the script should be related to the subject of the video.
+
+            YOU MUST NOT INCLUDE ANY TYPE OF MARKDOWN OR FORMATTING IN THE SCRIPT, NEVER USE A TITLE.
+            YOU MUST WRITE THE SCRIPT IN THE LANGUAGE SPECIFIED IN [LANGUAGE].
+            ONLY RETURN THE RAW CONTENT OF THE SCRIPT. DO NOT INCLUDE "VOICEOVER", "NARRATOR" OR SIMILAR INDICATORS OF WHAT SHOULD BE SPOKEN AT THE BEGINNING OF EACH PARAGRAPH OR LINE. YOU MUST NOT MENTION THE PROMPT, OR ANYTHING ABOUT THE SCRIPT ITSELF. ALSO, NEVER TALK ABOUT THE AMOUNT OF PARAGRAPHS OR LINES. JUST WRITE THE SCRIPT.
+
+        """
+
+    prompt += f"""
+    
+    Subject: {video_subject}
+    Number of paragraphs: {paragraph_number}
+    Language: {voice}
+
+    """
+
+    # Generate script
+    response = generate_response(prompt, ai_model)
+
+    print(colored(response, "cyan"))
+
+    # Return the generated script
+    if response:
+        # Clean the script
+        # Remove asterisks, hashes
+        response = response.replace("*", "")
+        response = response.replace("#", "")
+
+        # Remove markdown syntax
+        response = re.sub(r"\[.*\]", "", response)
+        response = re.sub(r"\(.*\)", "", response)
+
+        # Split the script into paragraphs
+        paragraphs = response.split("\n\n")
+
+        # Select the specified number of paragraphs
+        selected_paragraphs = paragraphs[:paragraph_number]
+
+        # Join the selected paragraphs into a single string
+        final_script = "\n\n".join(selected_paragraphs)
+
+        # Print to console the number of paragraphs used
+        print(colored(f"Number of paragraphs used: {len(selected_paragraphs)}", "green"))
+
+        return final_script
+    else:
+        print(colored("[-] GPT returned an empty response.", "red"))
+        return None
+
+
+def get_search_terms(video_subject: str, amount: int, script: str, ai_model: str) -> List[str]:
+    """
+    Generate a JSON-Array of search terms for stock videos,
+    depending on the subject of a video.
+
+    Args:
+        video_subject (str): The subject of the video.
+        amount (int): The amount of search terms to generate.
+        script (str): The script of the video.
+        ai_model (str): The AI model to use for generation.
+
+    Returns:
+        List[str]: The search terms for the video subject.
+    """
+
+    # Build prompt
+    prompt = f"""
+    Generate {amount} search terms for stock videos,
+    depending on the subject of a video.
+    Subject: {video_subject}
+
+    The search terms are to be returned as
+    a JSON-Array of strings.
+
+    Each search term should consist of 1-3 words,
+    always add the main subject of the video.
+    
+    YOU MUST ONLY RETURN THE JSON-ARRAY OF STRINGS.
+    YOU MUST NOT RETURN ANYTHING ELSE. 
+    YOU MUST NOT RETURN THE SCRIPT.
+    
+    The search terms must be related to the subject of the video.
+    Here is an example of a JSON-Array of strings:
+    ["search term 1", "search term 2", "search term 3"]
+
+    For context, here is the full text:
+    {script}
+    """
+
+    # Generate search terms
+    response = generate_response(prompt, ai_model)
+
+    # Parse response into a list of search terms
+    search_terms = []
+    
+    try:
+        search_terms = json.loads(response)
+        if not isinstance(search_terms, list) or not all(isinstance(term, str) for term in search_terms):
+            raise ValueError("Response is not a list of strings.")
+
+    except (json.JSONDecodeError, ValueError):
+        print(colored("[*] GPT returned an unformatted response. Attempting to clean...", "yellow"))
+
+        # Attempt to extract list-like string and convert to list
+        match = re.search(r'\["(?:[^"\\]|\\.)*"(?:,\s*"[^"\\]*")*\]', response)
+        if match:
+            try:
+                search_terms = json.loads(match.group())
+            except json.JSONDecodeError:
+                print(colored("[-] Could not parse response.", "red"))
+                return []
+
+
+
+    # Let user know
+    print(colored(f"\nGenerated {len(search_terms)} search terms: {', '.join(search_terms)}", "cyan"))
+
+    # Return search terms
+    return search_terms
+
+
+def generate_metadata(video_subject: str, script: str, ai_model: str) -> Tuple[str, str, List[str]]:  
+    """  
+    Generate metadata for a YouTube video, including the title, description, and keywords.  
+  
+    Args:  
+        video_subject (str): The subject of the video.  
+        script (str): The script of the video.  
+        ai_model (str): The AI model to use for generation.  
+  
+    Returns:  
+        Tuple[str, str, List[str]]: The title, description, and keywords for the video.  
+    """  
+  
+    # Build prompt for title  
+    title_prompt = f"""  
+    Generate a catchy and SEO-friendly title for a YouTube shorts video about {video_subject}.  
+    """  
+  
+    # Generate title  
+    title = generate_response(title_prompt, ai_model).strip()  
+    
+    # Build prompt for description  
+    description_prompt = f"""  
+    Write a brief and engaging description for a YouTube shorts video about {video_subject}.  
+    The video is based on the following script:  
+    {script}  
+    """  
+  
+    # Generate description  
+    description = generate_response(description_prompt, ai_model).strip()  
+  
+    # Generate keywords  
+    keywords = get_search_terms(video_subject, 6, script, ai_model)  
+
+    return title, description, keywords  

Backend/main.py

@@ -0,0 +1,354 @@
+import os
+from utils import *
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv("../.env")
+# Check if all required environment variables are set
+# This must happen before importing video which uses API keys without checking
+check_env_vars()
+
+from gpt import *
+from video import *
+from search import *
+from uuid import uuid4
+from tiktokvoice import *
+from flask_cors import CORS
+from termcolor import colored
+from youtube import upload_video
+from apiclient.errors import HttpError
+from flask import Flask, request, jsonify
+from moviepy.config import change_settings
+
+
+
+# Set environment variables
+SESSION_ID = os.getenv("TIKTOK_SESSION_ID")
+openai_api_key = os.getenv('OPENAI_API_KEY')
+change_settings({"IMAGEMAGICK_BINARY": os.getenv("IMAGEMAGICK_BINARY")})
+
+# Initialize Flask
+app = Flask(__name__)
+CORS(app)
+
+# Constants
+HOST = "0.0.0.0"
+PORT = 8080
+AMOUNT_OF_STOCK_VIDEOS = 5
+GENERATING = False
+
+
+# Generation Endpoint
+@app.route("/api/generate", methods=["POST"])
+def generate():
+    try:
+        # Set global variable
+        global GENERATING
+        GENERATING = True
+
+        # Clean
+        clean_dir("../temp/")
+        clean_dir("../subtitles/")
+
+
+        # Parse JSON
+        data = request.get_json()
+        paragraph_number = int(data.get('paragraphNumber', 1))  # Default to 1 if not provided
+        ai_model = data.get('aiModel')  # Get the AI model selected by the user
+        n_threads = data.get('threads')  # Amount of threads to use for video generation
+        subtitles_position = data.get('subtitlesPosition')  # Position of the subtitles in the video
+        text_color = data.get('color') # Color of subtitle text
+
+        # Get 'useMusic' from the request data and default to False if not provided
+        use_music = data.get('useMusic', False)
+
+        # Get 'automateYoutubeUpload' from the request data and default to False if not provided
+        automate_youtube_upload = data.get('automateYoutubeUpload', False)
+
+        # Get the ZIP Url of the songs
+        songs_zip_url = data.get('zipUrl')
+
+        # Download songs
+        if use_music:
+            # Downloads a ZIP file containing popular TikTok Songs
+            if songs_zip_url:
+                fetch_songs(songs_zip_url)
+            else:
+                # Default to a ZIP file containing popular TikTok Songs
+                fetch_songs("https://filebin.net/2avx134kdibc4c3q/drive-download-20240209T180019Z-001.zip")
+
+        # Print little information about the video which is to be generated
+        print(colored("[Video to be generated]", "blue"))
+        print(colored("   Subject: " + data["videoSubject"], "blue"))
+        print(colored("   AI Model: " + ai_model, "blue"))  # Print the AI model being used
+        print(colored("   Custom Prompt: " + data["customPrompt"], "blue"))  # Print the AI model being used
+
+
+
+        if not GENERATING:
+            return jsonify(
+                {
+                    "status": "error",
+                    "message": "Video generation was cancelled.",
+                    "data": [],
+                }
+            )
+        
+        voice = data["voice"]
+        voice_prefix = voice[:2]
+
+
+        if not voice:
+            print(colored("[!] No voice was selected. Defaulting to \"en_us_001\"", "yellow"))
+            voice = "en_us_001"
+            voice_prefix = voice[:2]
+
+
+        # Generate a script
+        script = generate_script(data["videoSubject"], paragraph_number, ai_model, voice, data["customPrompt"])  # Pass the AI model to the script generation
+
+        # Generate search terms
+        search_terms = get_search_terms(
+            data["videoSubject"], AMOUNT_OF_STOCK_VIDEOS, script, ai_model
+        )
+
+        # Search for a video of the given search term
+        video_urls = []
+
+        # Defines how many results it should query and search through
+        it = 15
+
+        # Defines the minimum duration of each clip
+        min_dur = 10
+
+        # Loop through all search terms,
+        # and search for a video of the given search term
+        for search_term in search_terms:
+            if not GENERATING:
+                return jsonify(
+                    {
+                        "status": "error",
+                        "message": "Video generation was cancelled.",
+                        "data": [],
+                    }
+                )
+            found_urls = search_for_stock_videos(
+                search_term, os.getenv("PEXELS_API_KEY"), it, min_dur
+            )
+            # Check for duplicates
+            for url in found_urls:
+                if url not in video_urls:
+                    video_urls.append(url)
+                    break
+
+        # Check if video_urls is empty
+        if not video_urls:
+            print(colored("[-] No videos found to download.", "red"))
+            return jsonify(
+                {
+                    "status": "error",
+                    "message": "No videos found to download.",
+                    "data": [],
+                }
+            )
+            
+        # Define video_paths
+        video_paths = []
+
+        # Let user know
+        print(colored(f"[+] Downloading {len(video_urls)} videos...", "blue"))
+
+        # Save the videos
+        for video_url in video_urls:
+            if not GENERATING:
+                return jsonify(
+                    {
+                        "status": "error",
+                        "message": "Video generation was cancelled.",
+                        "data": [],
+                    }
+                )
+            try:
+                saved_video_path = save_video(video_url)
+                video_paths.append(saved_video_path)
+            except Exception:
+                print(colored(f"[-] Could not download video: {video_url}", "red"))
+
+        # Let user know
+        print(colored("[+] Videos downloaded!", "green"))
+
+        # Let user know
+        print(colored("[+] Script generated!\n", "green"))
+
+        if not GENERATING:
+            return jsonify(
+                {
+                    "status": "error",
+                    "message": "Video generation was cancelled.",
+                    "data": [],
+                }
+            )
+
+        # Split script into sentences
+        sentences = script.split(". ")
+
+        # Remove empty strings
+        sentences = list(filter(lambda x: x != "", sentences))
+        paths = []
+
+        # Generate TTS for every sentence
+        for sentence in sentences:
+            if not GENERATING:
+                return jsonify(
+                    {
+                        "status": "error",
+                        "message": "Video generation was cancelled.",
+                        "data": [],
+                    }
+                )
+            current_tts_path = f"../temp/{uuid4()}.mp3"
+            tts(sentence, voice, filename=current_tts_path)
+            audio_clip = AudioFileClip(current_tts_path)
+            paths.append(audio_clip)
+
+        # Combine all TTS files using moviepy
+        final_audio = concatenate_audioclips(paths)
+        tts_path = f"../temp/{uuid4()}.mp3"
+        final_audio.write_audiofile(tts_path)
+
+        try:
+            subtitles_path = generate_subtitles(audio_path=tts_path, sentences=sentences, audio_clips=paths, voice=voice_prefix)
+        except Exception as e:
+            print(colored(f"[-] Error generating subtitles: {e}", "red"))
+            subtitles_path = None
+
+        # Concatenate videos
+        temp_audio = AudioFileClip(tts_path)
+        combined_video_path = combine_videos(video_paths, temp_audio.duration, 5, n_threads or 2)
+
+        # Put everything together
+        try:
+            final_video_path = generate_video(combined_video_path, tts_path, subtitles_path, n_threads or 2, subtitles_position, text_color or "#FFFF00")
+        except Exception as e:
+            print(colored(f"[-] Error generating final video: {e}", "red"))
+            final_video_path = None
+
+        # Define metadata for the video, we will display this to the user, and use it for the YouTube upload
+        title, description, keywords = generate_metadata(data["videoSubject"], script, ai_model)
+
+        print(colored("[-] Metadata for YouTube upload:", "blue"))
+        print(colored("   Title: ", "blue"))
+        print(colored(f"   {title}", "blue"))
+        print(colored("   Description: ", "blue"))
+        print(colored(f"   {description}", "blue"))
+        print(colored("   Keywords: ", "blue"))
+        print(colored(f"  {', '.join(keywords)}", "blue"))
+
+        if automate_youtube_upload:
+            # Start Youtube Uploader
+            # Check if the CLIENT_SECRETS_FILE exists
+            client_secrets_file = os.path.abspath("./client_secret.json")
+            SKIP_YT_UPLOAD = False
+            if not os.path.exists(client_secrets_file):
+                SKIP_YT_UPLOAD = True
+                print(colored("[-] Client secrets file missing. YouTube upload will be skipped.", "yellow"))
+                print(colored("[-] Please download the client_secret.json from Google Cloud Platform and store this inside the /Backend directory.", "red"))
+
+            # Only proceed with YouTube upload if the toggle is True  and client_secret.json exists.
+            if not SKIP_YT_UPLOAD:
+                # Choose the appropriate category ID for your videos
+                video_category_id = "28"  # Science & Technology
+                privacyStatus = "private"  # "public", "private", "unlisted"
+                video_metadata = {
+                    'video_path': os.path.abspath(f"../temp/{final_video_path}"),
+                    'title': title,
+                    'description': description,
+                    'category': video_category_id,
+                    'keywords': ",".join(keywords),
+                    'privacyStatus': privacyStatus,
+                }
+
+                # Upload the video to YouTube
+                try:
+                    # Unpack the video_metadata dictionary into individual arguments
+                    video_response = upload_video(
+                        video_path=video_metadata['video_path'],
+                        title=video_metadata['title'],
+                        description=video_metadata['description'],
+                        category=video_metadata['category'],
+                        keywords=video_metadata['keywords'],
+                        privacy_status=video_metadata['privacyStatus']
+                    )
+                    print(f"Uploaded video ID: {video_response.get('id')}")
+                except HttpError as e:
+                    print(f"An HTTP error {e.resp.status} occurred:\n{e.content}")
+
+        video_clip = VideoFileClip(f"../temp/{final_video_path}")
+        if use_music:
+            # Select a random song
+            song_path = choose_random_song()
+
+            # Add song to video at 30% volume using moviepy
+            original_duration = video_clip.duration
+            original_audio = video_clip.audio
+            song_clip = AudioFileClip(song_path).set_fps(44100)
+
+            # Set the volume of the song to 10% of the original volume
+            song_clip = song_clip.volumex(0.1).set_fps(44100)
+
+            # Add the song to the video
+            comp_audio = CompositeAudioClip([original_audio, song_clip])
+            video_clip = video_clip.set_audio(comp_audio)
+            video_clip = video_clip.set_fps(30)
+            video_clip = video_clip.set_duration(original_duration)
+            video_clip.write_videofile(f"../{final_video_path}", threads=n_threads or 1)
+        else:
+            video_clip.write_videofile(f"../{final_video_path}", threads=n_threads or 1)
+
+
+        # Let user know
+        print(colored(f"[+] Video generated: {final_video_path}!", "green"))
+
+        # Stop FFMPEG processes
+        if os.name == "nt":
+            # Windows
+            os.system("taskkill /f /im ffmpeg.exe")
+        else:
+            # Other OS
+            os.system("pkill -f ffmpeg")
+
+        GENERATING = False
+
+        # Return JSON
+        return jsonify(
+            {
+                "status": "success",
+                "message": "Video generated! See MoneyPrinter/output.mp4 for result.",
+                "data": final_video_path,
+            }
+        )
+    except Exception as err:
+        print(colored(f"[-] Error: {str(err)}", "red"))
+        return jsonify(
+            {
+                "status": "error",
+                "message": f"Could not retrieve stock videos: {str(err)}",
+                "data": [],
+            }
+        )
+
+
+@app.route("/api/cancel", methods=["POST"])
+def cancel():
+    print(colored("[!] Received cancellation request...", "yellow"))
+
+    global GENERATING
+    GENERATING = False
+
+    return jsonify({"status": "success", "message": "Cancelled video generation."})
+
+
+if __name__ == "__main__":
+
+    # Run Flask App
+    app.run(debug=True, host=HOST, port=PORT)

Backend/search.py

@@ -0,0 +1,66 @@
+import requests
+
+from typing import List
+from termcolor import colored
+
+def search_for_stock_videos(query: str, api_key: str, it: int, min_dur: int) -> List[str]:
+    """
+    Searches for stock videos based on a query.
+
+    Args:
+        query (str): The query to search for.
+        api_key (str): The API key to use.
+
+    Returns:
+        List[str]: A list of stock videos.
+    """
+    
+    # Build headers
+    headers = {
+        "Authorization": api_key
+    }
+
+    # Build URL
+    qurl = f"https://api.pexels.com/videos/search?query={query}&per_page={it}"
+
+    # Send the request
+    r = requests.get(qurl, headers=headers)
+
+    # Parse the response
+    response = r.json()
+
+    # Parse each video
+    raw_urls = []
+    video_url = []
+    video_res = 0
+    try:
+        # loop through each video in the result
+        for i in range(it):
+            #check if video has desired minimum duration
+            if response["videos"][i]["duration"] < min_dur:
+                continue
+            raw_urls = response["videos"][i]["video_files"]
+            temp_video_url = ""
+            
+            # loop through each url to determine the best quality
+            for video in raw_urls:
+                # Check if video has a valid download link
+                if ".com/external" in video["link"]:
+                    # Only save the URL with the largest resolution
+                    if (video["width"]*video["height"]) > video_res:
+                        temp_video_url = video["link"]
+                        video_res = video["width"]*video["height"]
+                        
+            # add the url to the return list if it's not empty
+            if temp_video_url != "":
+                video_url.append(temp_video_url)
+                
+    except Exception as e:
+        print(colored("[-] No Videos found.", "red"))
+        print(colored(e, "red"))
+
+    # Let user know
+    print(colored(f"\t=> \"{query}\" found {len(video_url)} Videos", "cyan"))
+
+    # Return the video url
+    return video_url

Backend/tiktokvoice.py

@@ -0,0 +1,207 @@
+# author: GiorDior aka Giorgio
+# date: 12.06.2023
+# topic: TikTok-Voice-TTS
+# version: 1.0
+# credits: https://github.com/oscie57/tiktok-voice
+
+# --- MODIFIED VERSION --- #
+
+import base64
+import requests
+import threading
+
+from typing import List
+from termcolor import colored
+from playsound import playsound
+
+
+VOICES = [
+    # DISNEY VOICES
+    "en_us_ghostface",  # Ghost Face
+    "en_us_chewbacca",  # Chewbacca
+    "en_us_c3po",  # C3PO
+    "en_us_stitch",  # Stitch
+    "en_us_stormtrooper",  # Stormtrooper
+    "en_us_rocket",  # Rocket
+    # ENGLISH VOICES
+    "en_au_001",  # English AU - Female
+    "en_au_002",  # English AU - Male
+    "en_uk_001",  # English UK - Male 1
+    "en_uk_003",  # English UK - Male 2
+    "en_us_001",  # English US - Female (Int. 1)
+    "en_us_002",  # English US - Female (Int. 2)
+    "en_us_006",  # English US - Male 1
+    "en_us_007",  # English US - Male 2
+    "en_us_009",  # English US - Male 3
+    "en_us_010",  # English US - Male 4
+    # EUROPE VOICES
+    "fr_001",  # French - Male 1
+    "fr_002",  # French - Male 2
+    "de_001",  # German - Female
+    "de_002",  # German - Male
+    "es_002",  # Spanish - Male
+    # AMERICA VOICES
+    "es_mx_002",  # Spanish MX - Male
+    "br_001",  # Portuguese BR - Female 1
+    "br_003",  # Portuguese BR - Female 2
+    "br_004",  # Portuguese BR - Female 3
+    "br_005",  # Portuguese BR - Male
+    # ASIA VOICES
+    "id_001",  # Indonesian - Female
+    "jp_001",  # Japanese - Female 1
+    "jp_003",  # Japanese - Female 2
+    "jp_005",  # Japanese - Female 3
+    "jp_006",  # Japanese - Male
+    "kr_002",  # Korean - Male 1
+    "kr_003",  # Korean - Female
+    "kr_004",  # Korean - Male 2
+    # SINGING VOICES
+    "en_female_f08_salut_damour",  # Alto
+    "en_male_m03_lobby",  # Tenor
+    "en_female_f08_warmy_breeze",  # Warmy Breeze
+    "en_male_m03_sunshine_soon",  # Sunshine Soon
+    # OTHER
+    "en_male_narration",  # narrator
+    "en_male_funny",  # wacky
+    "en_female_emotional",  # peaceful
+]
+
+ENDPOINTS = [
+    "https://tiktok-tts.weilnet.workers.dev/api/generation",
+    "https://tiktoktts.com/api/tiktok-tts",
+]
+current_endpoint = 0
+# in one conversion, the text can have a maximum length of 300 characters
+TEXT_BYTE_LIMIT = 300
+
+
+# create a list by splitting a string, every element has n chars
+def split_string(string: str, chunk_size: int) -> List[str]:
+    words = string.split()
+    result = []
+    current_chunk = ""
+    for word in words:
+        if (
+            len(current_chunk) + len(word) + 1 <= chunk_size
+        ):  # Check if adding the word exceeds the chunk size
+            current_chunk += f" {word}"
+        else:
+            if current_chunk:  # Append the current chunk if not empty
+                result.append(current_chunk.strip())
+            current_chunk = word
+    if current_chunk:  # Append the last chunk if not empty
+        result.append(current_chunk.strip())
+    return result
+
+
+# checking if the website that provides the service is available
+def get_api_response() -> requests.Response:
+    url = f'{ENDPOINTS[current_endpoint].split("/a")[0]}'
+    response = requests.get(url)
+    return response
+
+
+# saving the audio file
+def save_audio_file(base64_data: str, filename: str = "output.mp3") -> None:
+    audio_bytes = base64.b64decode(base64_data)
+    with open(filename, "wb") as file:
+        file.write(audio_bytes)
+
+
+# send POST request to get the audio data
+def generate_audio(text: str, voice: str) -> bytes:
+    url = f"{ENDPOINTS[current_endpoint]}"
+    headers = {"Content-Type": "application/json"}
+    data = {"text": text, "voice": voice}
+    response = requests.post(url, headers=headers, json=data)
+    return response.content
+
+
+# creates an text to speech audio file
+def tts(
+    text: str,
+    voice: str = "none",
+    filename: str = "output.mp3",
+    play_sound: bool = False,
+) -> None:
+    # checking if the website is available
+    global current_endpoint
+
+    if get_api_response().status_code == 200:
+        print(colored("[+] TikTok TTS Service available!", "green"))
+    else:
+        current_endpoint = (current_endpoint + 1) % 2
+        if get_api_response().status_code == 200:
+            print(colored("[+] TTS Service available!", "green"))
+        else:
+            print(colored("[-] TTS Service not available and probably temporarily rate limited, try again later..." , "red"))
+            return
+
+    # checking if arguments are valid
+    if voice == "none":
+        print(colored("[-] Please specify a voice", "red"))
+        return
+
+    if voice not in VOICES:
+        print(colored("[-] Voice not available", "red"))
+        return
+
+    if not text:
+        print(colored("[-] Please specify a text", "red"))
+        return
+
+    # creating the audio file
+    try:
+        if len(text) < TEXT_BYTE_LIMIT:
+            audio = generate_audio((text), voice)
+            if current_endpoint == 0:
+                audio_base64_data = str(audio).split('"')[5]
+            else:
+                audio_base64_data = str(audio).split('"')[3].split(",")[1]
+
+            if audio_base64_data == "error":
+                print(colored("[-] This voice is unavailable right now", "red"))
+                return
+
+        else:
+            # Split longer text into smaller parts
+            text_parts = split_string(text, 299)
+            audio_base64_data = [None] * len(text_parts)
+
+            # Define a thread function to generate audio for each text part
+            def generate_audio_thread(text_part, index):
+                audio = generate_audio(text_part, voice)
+                if current_endpoint == 0:
+                    base64_data = str(audio).split('"')[5]
+                else:
+                    base64_data = str(audio).split('"')[3].split(",")[1]
+
+                if audio_base64_data == "error":
+                    print(colored("[-] This voice is unavailable right now", "red"))
+                    return "error"
+
+                audio_base64_data[index] = base64_data
+
+            threads = []
+            for index, text_part in enumerate(text_parts):
+                # Create and start a new thread for each text part
+                thread = threading.Thread(
+                    target=generate_audio_thread, args=(text_part, index)
+                )
+                thread.start()
+                threads.append(thread)
+
+            # Wait for all threads to complete
+            for thread in threads:
+                thread.join()
+
+            # Concatenate the base64 data in the correct order
+            audio_base64_data = "".join(audio_base64_data)
+
+        save_audio_file(audio_base64_data, filename)
+        print(colored(f"[+] Audio file saved successfully as '{filename}'", "green"))
+        if play_sound:
+            playsound(filename)
+
+    except Exception as e:
+        print(colored(f"[-] An error occurred during TTS: {e}", "red"))

Backend/utils.py

@@ -0,0 +1,118 @@
+import os
+import sys
+import json
+import random
+import logging
+import zipfile
+import requests
+
+from termcolor import colored
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def clean_dir(path: str) -> None:
+    """
+    Removes every file in a directory.
+
+    Args:
+        path (str): Path to directory.
+
+    Returns:
+        None
+    """
+    try:
+        if not os.path.exists(path):
+            os.mkdir(path)
+            logger.info(f"Created directory: {path}")
+
+        for file in os.listdir(path):
+            file_path = os.path.join(path, file)
+            os.remove(file_path)
+            logger.info(f"Removed file: {file_path}")
+
+        logger.info(colored(f"Cleaned {path} directory", "green"))
+    except Exception as e:
+        logger.error(f"Error occurred while cleaning directory {path}: {str(e)}")
+
+def fetch_songs(zip_url: str) -> None:
+    """
+    Downloads songs into songs/ directory to use with geneated videos.
+
+    Args:
+        zip_url (str): The URL to the zip file containing the songs.
+
+    Returns:
+        None
+    """
+    try:
+        logger.info(colored(f" => Fetching songs...", "magenta"))
+
+        files_dir = "../Songs"
+        if not os.path.exists(files_dir):
+            os.mkdir(files_dir)
+            logger.info(colored(f"Created directory: {files_dir}", "green"))
+        else:
+            # Skip if songs are already downloaded
+            return
+
+        # Download songs
+        response = requests.get(zip_url)
+
+        # Save the zip file
+        with open("../Songs/songs.zip", "wb") as file:
+            file.write(response.content)
+
+        # Unzip the file
+        with zipfile.ZipFile("../Songs/songs.zip", "r") as file:
+            file.extractall("../Songs")
+
+        # Remove the zip file
+        os.remove("../Songs/songs.zip")
+
+        logger.info(colored(" => Downloaded Songs to ../Songs.", "green"))
+
+    except Exception as e:
+        logger.error(colored(f"Error occurred while fetching songs: {str(e)}", "red"))
+
+def choose_random_song() -> str:
+    """
+    Chooses a random song from the songs/ directory.
+
+    Returns:
+        str: The path to the chosen song.
+    """
+    try:
+        songs = os.listdir("../Songs")
+        song = random.choice(songs)
+        logger.info(colored(f"Chose song: {song}", "green"))
+        return f"../Songs/{song}"
+    except Exception as e:
+        logger.error(colored(f"Error occurred while choosing random song: {str(e)}", "red"))
+
+
+def check_env_vars() -> None:
+    """
+    Checks if the necessary environment variables are set.
+
+    Returns:
+        None
+
+    Raises:
+        SystemExit: If any required environment variables are missing.
+    """
+    try:
+        required_vars = ["PEXELS_API_KEY", "TIKTOK_SESSION_ID", "IMAGEMAGICK_BINARY"]
+        missing_vars = [var + os.getenv(var)  for var in required_vars if os.getenv(var) is None or (len(os.getenv(var)) == 0)]  
+
+        if missing_vars:
+            missing_vars_str = ", ".join(missing_vars)
+            logger.error(colored(f"The following environment variables are missing: {missing_vars_str}", "red"))
+            logger.error(colored("Please consult 'EnvironmentVariables.md' for instructions on how to set them.", "yellow"))
+            sys.exit(1)  # Aborts the program
+    except Exception as e:
+        logger.error(f"Error occurred while checking environment variables: {str(e)}")
+        sys.exit(1)  # Aborts the program if an unexpected error occurs
+

Backend/video.py

@@ -0,0 +1,248 @@
+import os
+import uuid
+
+import requests
+import srt_equalizer
+import assemblyai as aai
+
+from typing import List
+from moviepy.editor import *
+from termcolor import colored
+from dotenv import load_dotenv
+from datetime import timedelta
+from moviepy.video.fx.all import crop
+from moviepy.video.tools.subtitles import SubtitlesClip
+
+load_dotenv("../.env")
+
+ASSEMBLY_AI_API_KEY = os.getenv("ASSEMBLY_AI_API_KEY")
+
+
+def save_video(video_url: str, directory: str = "../temp") -> str:
+    """
+    Saves a video from a given URL and returns the path to the video.
+
+    Args:
+        video_url (str): The URL of the video to save.
+        directory (str): The path of the temporary directory to save the video to
+
+    Returns:
+        str: The path to the saved video.
+    """
+    video_id = uuid.uuid4()
+    video_path = f"{directory}/{video_id}.mp4"
+    with open(video_path, "wb") as f:
+        f.write(requests.get(video_url).content)
+
+    return video_path
+
+
+def __generate_subtitles_assemblyai(audio_path: str, voice: str) -> str:
+    """
+    Generates subtitles from a given audio file and returns the path to the subtitles.
+
+    Args:
+        audio_path (str): The path to the audio file to generate subtitles from.
+
+    Returns:
+        str: The generated subtitles
+    """
+
+    language_mapping = {
+        "br": "pt",
+        "id": "en", #AssemblyAI doesn't have Indonesian 
+        "jp": "ja",
+        "kr": "ko",
+    }
+
+    if voice in language_mapping:
+        lang_code = language_mapping[voice]
+    else:
+        lang_code = voice
+
+    aai.settings.api_key = ASSEMBLY_AI_API_KEY
+    config = aai.TranscriptionConfig(language_code=lang_code)
+    transcriber = aai.Transcriber(config=config)
+    transcript = transcriber.transcribe(audio_path)
+    subtitles = transcript.export_subtitles_srt()
+
+    return subtitles
+
+
+def __generate_subtitles_locally(sentences: List[str], audio_clips: List[AudioFileClip]) -> str:
+    """
+    Generates subtitles from a given audio file and returns the path to the subtitles.
+
+    Args:
+        sentences (List[str]): all the sentences said out loud in the audio clips
+        audio_clips (List[AudioFileClip]): all the individual audio clips which will make up the final audio track
+    Returns:
+        str: The generated subtitles
+    """
+
+    def convert_to_srt_time_format(total_seconds):
+        # Convert total seconds to the SRT time format: HH:MM:SS,mmm
+        if total_seconds == 0:
+            return "0:00:00,0"
+        return str(timedelta(seconds=total_seconds)).rstrip('0').replace('.', ',')
+
+    start_time = 0
+    subtitles = []
+
+    for i, (sentence, audio_clip) in enumerate(zip(sentences, audio_clips), start=1):
+        duration = audio_clip.duration
+        end_time = start_time + duration
+
+        # Format: subtitle index, start time --> end time, sentence
+        subtitle_entry = f"{i}\n{convert_to_srt_time_format(start_time)} --> {convert_to_srt_time_format(end_time)}\n{sentence}\n"
+        subtitles.append(subtitle_entry)
+
+        start_time += duration  # Update start time for the next subtitle
+
+    return "\n".join(subtitles)
+
+
+def generate_subtitles(audio_path: str, sentences: List[str], audio_clips: List[AudioFileClip], voice: str) -> str:
+    """
+    Generates subtitles from a given audio file and returns the path to the subtitles.
+
+    Args:
+        audio_path (str): The path to the audio file to generate subtitles from.
+        sentences (List[str]): all the sentences said out loud in the audio clips
+        audio_clips (List[AudioFileClip]): all the individual audio clips which will make up the final audio track
+
+    Returns:
+        str: The path to the generated subtitles.
+    """
+
+    def equalize_subtitles(srt_path: str, max_chars: int = 10) -> None:
+        # Equalize subtitles
+        srt_equalizer.equalize_srt_file(srt_path, srt_path, max_chars)
+
+    # Save subtitles
+    subtitles_path = f"../subtitles/{uuid.uuid4()}.srt"
+
+    if ASSEMBLY_AI_API_KEY is not None and ASSEMBLY_AI_API_KEY != "":
+        print(colored("[+] Creating subtitles using AssemblyAI", "blue"))
+        subtitles = __generate_subtitles_assemblyai(audio_path, voice)
+    else:
+        print(colored("[+] Creating subtitles locally", "blue"))
+        subtitles = __generate_subtitles_locally(sentences, audio_clips)
+        # print(colored("[-] Local subtitle generation has been disabled for the time being.", "red"))
+        # print(colored("[-] Exiting.", "red"))
+        # sys.exit(1)
+
+    with open(subtitles_path, "w") as file:
+        file.write(subtitles)
+
+    # Equalize subtitles
+    equalize_subtitles(subtitles_path)
+
+    print(colored("[+] Subtitles generated.", "green"))
+
+    return subtitles_path
+
+
+def combine_videos(video_paths: List[str], max_duration: int, max_clip_duration: int, threads: int) -> str:
+    """
+    Combines a list of videos into one video and returns the path to the combined video.
+
+    Args:
+        video_paths (List): A list of paths to the videos to combine.
+        max_duration (int): The maximum duration of the combined video.
+        max_clip_duration (int): The maximum duration of each clip.
+        threads (int): The number of threads to use for the video processing.
+
+    Returns:
+        str: The path to the combined video.
+    """
+    video_id = uuid.uuid4()
+    combined_video_path = f"../temp/{video_id}.mp4"
+    
+    # Required duration of each clip
+    req_dur = max_duration / len(video_paths)
+
+    print(colored("[+] Combining videos...", "blue"))
+    print(colored(f"[+] Each clip will be maximum {req_dur} seconds long.", "blue"))
+
+    clips = []
+    tot_dur = 0
+    # Add downloaded clips over and over until the duration of the audio (max_duration) has been reached
+    while tot_dur < max_duration:
+        for video_path in video_paths:
+            clip = VideoFileClip(video_path)
+            clip = clip.without_audio()
+            # Check if clip is longer than the remaining audio
+            if (max_duration - tot_dur) < clip.duration:
+                clip = clip.subclip(0, (max_duration - tot_dur))
+            # Only shorten clips if the calculated clip length (req_dur) is shorter than the actual clip to prevent still image
+            elif req_dur < clip.duration:
+                clip = clip.subclip(0, req_dur)
+            clip = clip.set_fps(30)
+
+            # Not all videos are same size,
+            # so we need to resize them
+            if round((clip.w/clip.h), 4) < 0.5625:
+                clip = crop(clip, width=clip.w, height=round(clip.w/0.5625), \
+                            x_center=clip.w / 2, \
+                            y_center=clip.h / 2)
+            else:
+                clip = crop(clip, width=round(0.5625*clip.h), height=clip.h, \
+                            x_center=clip.w / 2, \
+                            y_center=clip.h / 2)
+            clip = clip.resize((1080, 1920))
+
+            if clip.duration > max_clip_duration:
+                clip = clip.subclip(0, max_clip_duration)
+
+            clips.append(clip)
+            tot_dur += clip.duration
+
+    final_clip = concatenate_videoclips(clips)
+    final_clip = final_clip.set_fps(30)
+    final_clip.write_videofile(combined_video_path, threads=threads)
+
+    return combined_video_path
+
+
+def generate_video(combined_video_path: str, tts_path: str, subtitles_path: str, threads: int, subtitles_position: str,  text_color : str) -> str:
+    """
+    This function creates the final video, with subtitles and audio.
+
+    Args:
+        combined_video_path (str): The path to the combined video.
+        tts_path (str): The path to the text-to-speech audio.
+        subtitles_path (str): The path to the subtitles.
+        threads (int): The number of threads to use for the video processing.
+        subtitles_position (str): The position of the subtitles.
+
+    Returns:
+        str: The path to the final video.
+    """
+    # Make a generator that returns a TextClip when called with consecutive
+    generator = lambda txt: TextClip(
+        txt,
+        font="../fonts/bold_font.ttf",
+        fontsize=100,
+        color=text_color,
+        stroke_color="black",
+        stroke_width=5,
+    )
+
+    # Split the subtitles position into horizontal and vertical
+    horizontal_subtitles_position, vertical_subtitles_position = subtitles_position.split(",")
+
+    # Burn the subtitles into the video
+    subtitles = SubtitlesClip(subtitles_path, generator)
+    result = CompositeVideoClip([
+        VideoFileClip(combined_video_path),
+        subtitles.set_pos((horizontal_subtitles_position, vertical_subtitles_position))
+    ])
+
+    # Add the audio
+    audio = AudioFileClip(tts_path)
+    result = result.set_audio(audio)
+
+    result.write_videofile("../temp/output.mp4", threads=threads or 2)
+
+    return "output.mp4"

Backend/youtube.py

@@ -0,0 +1,198 @@
+import os
+import sys
+import time
+import random
+import httplib2
+
+from termcolor import colored
+from oauth2client.file import Storage
+from apiclient.discovery import build
+from apiclient.errors import HttpError
+from apiclient.http import MediaFileUpload
+from oauth2client.tools import argparser, run_flow
+from oauth2client.client import flow_from_clientsecrets
+
+# Explicitly tell the underlying HTTP transport library not to retry, since
+# we are handling retry logic ourselves.
+httplib2.RETRIES = 1
+
+# Maximum number of times to retry before giving up.
+MAX_RETRIES = 10
+
+# Always retry when these exceptions are raised.
+RETRIABLE_EXCEPTIONS = (httplib2.HttpLib2Error, IOError, httplib2.ServerNotFoundError)
+
+# Always retry when an apiclient.errors.HttpError with one of these status
+# codes is raised.
+RETRIABLE_STATUS_CODES = [500, 502, 503, 504]
+
+# The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
+# the OAuth 2.0 information for this application, including its client_id and
+# client_secret.
+CLIENT_SECRETS_FILE = "./client_secret.json"
+
+# This OAuth 2.0 access scope allows an application to upload files to the
+# authenticated user's YouTube channel, but doesn't allow other types of access.
+# YOUTUBE_UPLOAD_SCOPE = "https://www.googleapis.com/auth/youtube.upload"
+SCOPES = ['https://www.googleapis.com/auth/youtube.upload',
+          'https://www.googleapis.com/auth/youtube',
+          'https://www.googleapis.com/auth/youtubepartner']
+YOUTUBE_API_SERVICE_NAME = "youtube"  
+YOUTUBE_API_VERSION = "v3"  
+
+# This variable defines a message to display if the CLIENT_SECRETS_FILE is
+# missing.
+MISSING_CLIENT_SECRETS_MESSAGE = f"""
+WARNING: Please configure OAuth 2.0
+
+To make this sample run you will need to populate the client_secrets.json file
+found at:
+  
+{os.path.abspath(os.path.join(os.path.dirname(__file__), CLIENT_SECRETS_FILE))}
+
+with information from the API Console
+https://console.cloud.google.com/
+
+For more information about the client_secrets.json file format, please visit:
+https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
+"""
+
+VALID_PRIVACY_STATUSES = ("public", "private", "unlisted")  
+  
+  
+def get_authenticated_service():
+    """
+    This method retrieves the YouTube service.
+
+    Returns:
+        any: The authenticated YouTube service.
+    """
+    flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE,
+                                   scope=SCOPES,
+                                   message=MISSING_CLIENT_SECRETS_MESSAGE)
+
+    storage = Storage(f"{sys.argv[0]}-oauth2.json")
+    credentials = storage.get()
+
+    if credentials is None or credentials.invalid:
+        flags = argparser.parse_args()
+        credentials = run_flow(flow, storage, flags)
+
+    return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
+                 http=credentials.authorize(httplib2.Http()))
+
+def initialize_upload(youtube: any, options: dict):
+    """
+    This method uploads a video to YouTube.
+
+    Args:
+        youtube (any): The authenticated YouTube service.
+        options (dict): The options to upload the video with.
+
+    Returns:
+        response: The response from the upload process.
+    """
+
+    tags = None
+    if options['keywords']:
+        tags = options['keywords'].split(",")
+
+    body = {
+        'snippet': {
+            'title': options['title'],
+            'description': options['description'],
+            'tags': tags,
+            'categoryId': options['category']
+        },
+        'status': {
+            'privacyStatus': options['privacyStatus'],
+            'madeForKids': False,  # Video is not made for kids
+            'selfDeclaredMadeForKids': False  # You declare that the video is not made for kids
+        }
+    }
+
+    # Call the API's videos.insert method to create and upload the video.
+    insert_request = youtube.videos().insert(
+        part=",".join(body.keys()),
+        body=body,
+        media_body=MediaFileUpload(options['file'], chunksize=-1, resumable=True)
+    )
+
+    return resumable_upload(insert_request)
+
+def resumable_upload(insert_request: MediaFileUpload):
+    """
+    This method implements an exponential backoff strategy to resume a  
+    failed upload.
+
+    Args:
+        insert_request (MediaFileUpload): The request to insert the video.
+
+    Returns:
+        response: The response from the upload process.
+    """
+    response = None
+    error = None
+    retry = 0
+    while response is None:
+        try:
+            print(colored(" => Uploading file...", "magenta"))
+            status, response = insert_request.next_chunk()
+            if 'id' in response:
+                print(f"Video id '{response['id']}' was successfully uploaded.")
+                return response
+        except HttpError as e:
+            if e.resp.status in RETRIABLE_STATUS_CODES:
+                error = f"A retriable HTTP error {e.resp.status} occurred:\n{e.content}"
+            else:
+                raise
+        except RETRIABLE_EXCEPTIONS as e:
+            error = f"A retriable error occurred: {e}"
+
+        if error is not None:
+            print(colored(error, "red"))
+            retry += 1
+            if retry > MAX_RETRIES:
+                raise Exception("No longer attempting to retry.")
+
+            max_sleep = 2 ** retry 
+            sleep_seconds = random.random() * max_sleep
+            print(colored(f" => Sleeping {sleep_seconds} seconds and then retrying...", "blue"))
+            time.sleep(sleep_seconds)  
+  
+def upload_video(video_path, title, description, category, keywords, privacy_status):
+    try:
+        # Get the authenticated YouTube service
+        youtube = get_authenticated_service()
+
+        # Retrieve and print the channel ID for the authenticated user
+        channels_response = youtube.channels().list(mine=True, part='id').execute()
+        for channel in channels_response['items']:
+            print(colored(f" => Channel ID: {channel['id']}", "blue"))
+
+        # Initialize the upload process
+        video_response = initialize_upload(youtube, {
+            'file': video_path, # The path to the video file
+            'title': title,
+            'description': description,
+            'category': category, 
+            'keywords': keywords,
+            'privacyStatus': privacy_status
+        })
+        return video_response # Return the response from the upload process
+    except HttpError as e:
+        print(colored(f"[-] An HTTP error {e.resp.status} occurred:\n{e.content}", "red"))
+        if e.resp.status in [401, 403]:
+            # Here you could refresh the credentials and retry the upload  
+            youtube = get_authenticated_service() # This will prompt for re-authentication if necessary
+            video_response = initialize_upload(youtube, {
+                'file': video_path,
+                'title': title,
+                'description': description,
+                'category': category,
+                'keywords': keywords,
+                'privacyStatus': privacy_status
+            })
+            return video_response
+        else:
+            raise e 

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim-buster
+
+RUN apt-get update && apt-get install --no-install-recommends -y \
+    build-essential autoconf pkg-config wget ghostscript curl libpng-dev
+
+RUN wget https://github.com/ImageMagick/ImageMagick/archive/refs/tags/7.1.0-31.tar.gz && \
+    tar xzf 7.1.0-31.tar.gz && \
+    rm 7.1.0-31.tar.gz && \
+    apt-get clean && \
+    apt-get autoremove
+
+RUN sh ./ImageMagick-7.1.0-31/configure --prefix=/usr/local --with-bzlib=yes --with-fontconfig=yes --with-freetype=yes --with-gslib=yes --with-gvc=yes --with-jpeg=yes --with-jp2=yes --with-png=yes --with-tiff=yes --with-xml=yes --with-gs-font-dir=yes && \
+    make -j && make install && ldconfig /usr/local/lib/
+
+WORKDIR /tmp
+
+RUN pip install --upgrade pip
+
+WORKDIR /app
+
+ADD ./requirements.txt .
+
+RUN pip install -r requirements.txt

EnvironmentVariables.md

@@ -0,0 +1,19 @@
+# Environment Variables
+
+## Required
+
+- TIKTOK_SESSION_ID: Your TikTok session ID is required. Obtain it by logging into TikTok in your browser and copying the value of the `sessionid` cookie.
+
+- IMAGEMAGICK_BINARY: The filepath to the ImageMagick binary (.exe file) is needed. Obtain it [here](https://imagemagick.org/script/download.php).
+
+- PEXELS_API_KEY: Your unique Pexels API key is required. Obtain yours [here](https://www.pexels.com/api/).
+
+## Optional
+
+- OPENAI_API_KEY: Your unique OpenAI API key is required. Obtain yours [here](https://platform.openai.com/api-keys), only nessecary if you want to use the OpenAI models.
+
+- GOOGLE_API_KEY: Your Gemini API key is essential for Gemini Pro Model. Generate one securely at [Get API key | Google AI Studio](https://makersuite.google.com/app/apikey)
+
+* ASSEMBLY_AI_API_KEY: Your unique AssemblyAI API key is required. You can obtain one [here](https://www.assemblyai.com/app/). This field is optional; if left empty, the subtitle will be created based on the generated script. Subtitles can also be created locally.
+
+Join the [Discord](https://dsc.gg/fuji-community) for support and updates.

Frontend/app.js

@@ -0,0 +1,168 @@
+const videoSubject = document.querySelector("#videoSubject");
+const aiModel = document.querySelector("#aiModel");
+const voice = document.querySelector("#voice");
+const zipUrl = document.querySelector("#zipUrl");
+const paragraphNumber = document.querySelector("#paragraphNumber");
+const youtubeToggle = document.querySelector("#youtubeUploadToggle");
+const useMusicToggle = document.querySelector("#useMusicToggle");
+const customPrompt = document.querySelector("#customPrompt");
+const generateButton = document.querySelector("#generateButton");
+const cancelButton = document.querySelector("#cancelButton");
+
+const advancedOptionsToggle = document.querySelector("#advancedOptionsToggle");
+
+advancedOptionsToggle.addEventListener("click", () => {
+  // Change Emoji, from ▼ to ▲ and vice versa
+  const emoji = advancedOptionsToggle.textContent;
+  advancedOptionsToggle.textContent = emoji.includes("▼")
+    ? "Show less Options ▲"
+    : "Show Advanced Options ▼";
+  const advancedOptions = document.querySelector("#advancedOptions");
+  advancedOptions.classList.toggle("hidden");
+});
+
+
+const cancelGeneration = () => {
+  console.log("Canceling generation...");
+  // Send request to /cancel
+  fetch("http://localhost:8080/api/cancel", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+  })
+    .then((response) => response.json())
+    .then((data) => {
+      alert(data.message);
+      console.log(data);
+    })
+    .catch((error) => {
+      alert("An error occurred. Please try again later.");
+      console.log(error);
+    });
+
+  // Hide cancel button
+  cancelButton.classList.add("hidden");
+
+  // Enable generate button
+  generateButton.disabled = false;
+  generateButton.classList.remove("hidden");
+};
+
+const generateVideo = () => {
+  console.log("Generating video...");
+  // Disable button and change text
+  generateButton.disabled = true;
+  generateButton.classList.add("hidden");
+
+  // Show cancel button
+  cancelButton.classList.remove("hidden");
+
+  // Get values from input fields
+  const videoSubjectValue = videoSubject.value;
+  const aiModelValue = aiModel.value;
+  const voiceValue = voice.value;
+  const paragraphNumberValue = paragraphNumber.value;
+  const youtubeUpload = youtubeToggle.checked;
+  const useMusicToggleState = useMusicToggle.checked;
+  const threads = document.querySelector("#threads").value;
+  const zipUrlValue = zipUrl.value;
+  const customPromptValue = customPrompt.value;
+  const subtitlesPosition = document.querySelector("#subtitlesPosition").value;
+  const colorHexCode = document.querySelector("#subtitlesColor").value;
+
+
+  const url = "http://localhost:8080/api/generate";
+
+  // Construct data to be sent to the server
+  const data = {
+    videoSubject: videoSubjectValue,
+    aiModel: aiModelValue,
+    voice: voiceValue,
+    paragraphNumber: paragraphNumberValue,
+    automateYoutubeUpload: youtubeUpload,
+    useMusic: useMusicToggleState,
+    zipUrl: zipUrlValue,
+    threads: threads,
+    subtitlesPosition: subtitlesPosition,
+    customPrompt: customPromptValue,
+    color: colorHexCode,
+  };
+
+  // Send the actual request to the server
+  fetch(url, {
+    method: "POST",
+    body: JSON.stringify(data),
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+  })
+    .then((response) => response.json())
+    .then((data) => {
+      console.log(data);
+      alert(data.message);
+      // Hide cancel button after generation is complete
+      generateButton.disabled = false;
+      generateButton.classList.remove("hidden");
+      cancelButton.classList.add("hidden");
+    })
+    .catch((error) => {
+      alert("An error occurred. Please try again later.");
+      console.log(error);
+    });
+};
+
+generateButton.addEventListener("click", generateVideo);
+cancelButton.addEventListener("click", cancelGeneration);
+
+videoSubject.addEventListener("keyup", (event) => {
+  if (event.key === "Enter") {
+    generateVideo();
+  }
+});
+
+// Load the data from localStorage on page load
+document.addEventListener("DOMContentLoaded", (event) => {
+  const voiceSelect = document.getElementById("voice");
+  const storedVoiceValue = localStorage.getItem("voiceValue");
+
+  if (storedVoiceValue) {
+    voiceSelect.value = storedVoiceValue;
+  }
+});
+
+// Save the data to localStorage when the user changes the value
+toggles = ["youtubeUploadToggle", "useMusicToggle", "reuseChoicesToggle"];
+fields = ["aiModel", "voice", "paragraphNumber", "videoSubject", "zipUrl", "customPrompt", "threads", "subtitlesPosition", "subtitlesColor"];
+
+document.addEventListener("DOMContentLoaded", () => {
+  toggles.forEach((id) => {
+    const toggle = document.getElementById(id);
+    const storedValue = localStorage.getItem(`${id}Value`);
+    const storedReuseValue = localStorage.getItem("reuseChoicesToggleValue");
+
+    if (toggle && storedValue !== null && storedReuseValue === "true") {
+        toggle.checked = storedValue === "true";
+    }
+    // Attach change listener to update localStorage
+    toggle.addEventListener("change", (event) => {
+        localStorage.setItem(`${id}Value`, event.target.checked);
+    });
+  });
+
+  fields.forEach((id) => {
+    const select = document.getElementById(id);
+    const storedValue = localStorage.getItem(`${id}Value`);
+    const storedReuseValue = localStorage.getItem("reuseChoicesToggleValue");
+
+    if (storedValue && storedReuseValue === "true") {
+      select.value = storedValue;
+    }
+    // Attach change listener to update localStorage
+    select.addEventListener("change", (event) => {
+      localStorage.setItem(`${id}Value`, event.target.value);
+    });
+  });
+});

Frontend/index.html

@@ -0,0 +1,239 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>MoneyPrinter</title>
+    <link
+      rel="icon"
+      href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>💸</text></svg>"
+    />
+
+    <link
+      rel="stylesheet"
+      href="https://cdnjs.cloudflare.com/ajax/libs/tailwindcss/2.0.2/tailwind.min.css"
+    />
+  </head>
+
+  <body class="bg-blue-100 min-h-screen justify-center p-40">
+    <h1 class="text-4xl text-center mb-4">MoneyPrinter</h1>
+    <p class="text-center text-gray-700">
+      This Application is intended to automate the creation and uploads of
+      YouTube Shorts.
+    </p>
+
+    <div class="flex justify-center mt-8">
+      <div class="max-w-xl flex flex-col space-y-4 w-full">
+        <label for="videoSubject" class="text-blue-600">Subject</label>
+          <textarea
+              rows="3"
+              type="text"
+              name="videoSubject"
+              id="videoSubject"
+              class="border-2 border-blue-300 p-2 rounded-md focus:outline-none focus:border-blue-500"
+          ></textarea>
+        <button id="advancedOptionsToggle" class="text-blue-600">
+          Show Advanced Options ▼
+        </button>
+        <div
+          class="flex flex-col space-y-4 hidden transition-all duration-150 linear"
+          id="advancedOptions"
+        >
+          <label for="aiModel" class="text-blue-600">AI Model</label>
+          <select
+            name="aiModel"
+            id="aiModel"
+            class="w-full border-2 border-blue-300 p-2 rounded-md focus:outline-none focus:border-blue-500"
+          >
+            <option value="g4f">g4f (Free)</option>
+            <option value="gpt3.5-turbo">OpenAI GPT-3.5</option>
+            <option value="gpt4">OpenAI GPT-4</option>
+            <option value="gemmini">Gemini Pro</option>
+          </select>
+          <label for="voice" class="text-blue-600">Voice</label>
+          <select
+            name="voice"
+            id="voice"
+            class="w-min border-2 border-blue-300 p-2 rounded-md focus:outline-none focus:border-blue-500"
+          >
+            <option value="en_us_ghostface">Ghost Face</option>
+            <option value="en_us_chewbacca">Chewbacca</option>
+            <option value="en_us_c3po">C3PO</option>
+            <option value="en_us_stitch">Stitch</option>
+            <option value="en_us_stormtrooper">Stormtrooper</option>
+            <option value="en_us_rocket">Rocket</option>
+            <option value="en_au_001">English AU - Female</option>
+            <option value="en_au_002">English AU - Male</option>
+            <option value="en_uk_001">English UK - Male 1</option>
+            <option value="en_uk_003">English UK - Male 2</option>
+            <option value="en_us_001">English US - Female (Int. 1)</option>
+            <option value="en_us_002">English US - Female (Int. 2)</option>
+            <option value="en_us_006">English US - Male 1</option>
+            <option value="en_us_007">English US - Male 2</option>
+            <option value="en_us_009">English US - Male 3</option>
+            <option value="en_us_010">English US - Male 4</option>
+            <option value="fr_001">French - Male 1</option>
+            <option value="fr_002">French - Male 2</option>
+            <option value="de_001">German - Female</option>
+            <option value="de_002">German - Male</option>
+            <option value="es_002">Spanish - Male</option>
+            <option value="es_mx_002">Spanish MX - Male</option>
+            <option value="br_001">Portuguese BR - Female 1</option>
+            <option value="br_003">Portuguese BR - Female 2</option>
+            <option value="br_004">Portuguese BR - Female 3</option>
+            <option value="br_005">Portuguese BR - Male</option>
+            <option value="id_001">Indonesian - Female</option>
+            <option value="jp_001">Japanese - Female 1</option>
+            <option value="jp_003">Japanese - Female 2</option>
+            <option value="jp_005">Japanese - Female 3</option>
+            <option value="jp_006">Japanese - Male</option>
+            <option value="kr_002">Korean - Male 1</option>
+            <option value="kr_003">Korean - Female</option>
+            <option value="kr_004">Korean - Male 2</option>
+            <option value="en_female_f08_salut_damour">Alto</option>
+            <option value="en_male_m03_lobby">Tenor</option>
+            <option value="en_female_f08_warmy_breeze">Warmy Breeze</option>
+            <option value="en_male_m03_sunshine_soon">Sunshine Soon</option>
+            <option value="en_male_narration">narrator</option>
+            <option value="en_male_funny">wacky</option>
+            <option value="en_female_emotional">peaceful</option>
+          </select>
+          <label for="subtitlesPosition" class="text-blue-600"
+            >Subtitles Position</label
+          >
+          <select
+            name="subtitlesPosition"
+            id="subtitlesPosition"
+            class="w-min border-2 border-blue-300 p-2 rounded-md focus:outline-none focus:border-blue-500"
+          >
+            <option value="center,top">Center - Top</option>
+            <option value="center,bottom">Center - Bottom</option>
+            <option value="center,center">Center - Center</option>
+            <option value="left,center">Left - Center</option>
+            <option value="left,bottom">Left - Bottom</option>
+            <option value="right,center">Right - Center</option>
+            <option value="right,bottom">Right - Bottom</option>
+          </select>
+          <label for="subtitlesColor" class="text-blue-600"
+            >Subtitles Color</label>
+          <select
+            name="subtitlesColor"
+            id="subtitlesColor"
+            class="w-min border-2 border-blue-300 p-2 rounded-md focus:outline-none focus:border-blue-500"
+          >
+            <option value="#FFFF00">Yellow (Default)</option>
+            <option value="#f4a261">Orange</option>
+            <option value="#e63946">Red</option>
+            <option value="#1d3557">Blue</option>
+            <option value="#fff">White</option>
+            <option value="#03071e">Black</option>
+          </select>
+          <label for="zipUrl" class="text-blue-600"
+            >Zip URL (Leave empty for default)</label
+          >
+          <input
+            type="text"
+            name="zipUrl"
+            id="zipUrl"
+            class="border-2 border-blue-300 p-2 rounded-md focus:outline-none focus:border-blue-500"
+          />
+          <label for="threads" class="text-blue-600">Threads</label>
+          <input
+            type="number"
+            name="threads"
+            id="threads"
+            class="border-2 border-blue-300 p-2 rounded-md focus:outline-none focus:border-blue-500"
+            value="2"
+            min="1"
+            max="100"
+            placeholder="2 (Default)"
+          />
+          <label for="paragraphNumber" class="text-blue-600"
+            >Paragraph Number</label
+          >
+          <input
+            type="number"
+            name="paragraphNumber"
+            id="paragraphNumber"
+            class="border-2 border-blue-300 p-2 rounded-md focus:outline-none focus:border-blue-500"
+            value="1"
+            min="1"
+            max="100"
+          />
+          <label for="customPrompt" class="text-blue-600">Custom Prompt:</label>
+            <textarea
+              rows="3"
+              type="text"
+              name="customPrompt"
+              id="customPrompt"
+              class="border-2 border-blue-300 p-2 rounded-md focus:outline-none focus:border-blue-500"
+              placeholder="only use it if you want to replace the default prompt"
+            ></textarea>
+          <label
+            for="youtubeUploadToggle"
+            class="flex items-center text-blue-600"
+          >
+            <input
+              type="checkbox"
+              name="youtubeUploadToggle"
+              id="youtubeUploadToggle"
+              class="mr-2"
+            />
+            Upload to YouTube
+          </label>
+          <label for="useMusicToggle" class="flex items-center text-blue-600">
+            <input
+              type="checkbox"
+              name="useMusicToggle"
+              id="useMusicToggle"
+              class="mr-2"
+            />
+            Use Music
+          </label>
+          <label
+            for="reuseChoicesToggle"
+            class="flex items-center text-blue-600"
+          >
+            <input
+              type="checkbox"
+              name="reuseChoicesToggle"
+              id="reuseChoicesToggle"
+              class="mr-2"
+            />
+            Reuse Choices?
+          </label>
+        </div>
+        <button
+          id="generateButton"
+          class="bg-blue-500 hover:bg-blue-700 duration-100 linear text-white px-4 py-2 rounded-md"
+        >
+          Generate
+        </button>
+        <button
+          id="cancelButton"
+          class="bg-red-500 hover:bg-red-700 duration-100 linear text-white px-4 py-2 rounded-md hidden"
+        >
+          Cancel
+        </button>
+
+      </div>
+    </div>
+
+    <footer class="flex justify-center mt-8">
+      <div class="flex flex-col space-y-4">
+        <p class="text-center text-gray-700">
+          Made with ❤️ by
+          <a
+            class="text-blue-600"
+            target="href"
+            href="https://github.com/FujiwaraChoki"
+          >
+            Fuji Codes
+          </a>
+        </p>
+      </div>
+    </footer>
+
+    <script src="app.js"></script>
+  </body>
+</html>

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 FujiwaraChoki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,3 +1,129 @@
----
-license: mit
----
+# MoneyPrinter 💸
+
+THIS IS DEPRECATED; CHECK OUT VERSION 2 [HERE](https://github.com/FujiwaraChoki/MoneyPrinterV2).
+
+Automate the creation of YouTube Shorts locally, simply by providing a video topic to talk about.
+
+> **Important** Please make sure you look through existing/closed issues before opening your own. If it's just a question, please join our [discord](https://dsc.gg/fuji-community) and ask there.
+
+> **🎥** Watch the video on [YouTube](https://youtu.be/mkZsaDA2JnA?si=pNne3MnluRVkWQbE).
+
+## Installation 📥
+
+`MoneyPrinter` requires Python 3.11 to run effectively. If you don't have Python installed, you can download it from [here](https://www.python.org/downloads/).
+
+After you finished installing Python, you can install `MoneyPrinter` by following the steps below:
+
+```bash
+git clone https://github.com/FujiwaraChoki/MoneyPrinter.git
+cd MoneyPrinter
+
+# Install requirements
+pip install -r requirements.txt
+
+# Copy .env.example and fill out values
+cp .env.example .env
+
+# Run the backend server
+cd Backend
+python main.py
+
+# Run the frontend server
+cd ../Frontend
+python -m http.server 3000
+```
+
+See [`.env.example`](.env.example) for the required environment variables.
+
+If you need help, open [EnvironmentVariables.md](EnvironmentVariables.md) for more information.
+
+## Usage 🛠️
+
+1. Copy the `.env.example` file to `.env` and fill in the required values
+1. Open `http://localhost:3000` in your browser
+1. Enter a topic to talk about
+1. Click on the "Generate" button
+1. Wait for the video to be generated
+1. The video's location is `MoneyPrinter/output.mp4`
+
+## Music 🎵
+
+To use your own music, compress all your MP3 Files into a ZIP file and upload it somewhere. Provide the link to the ZIP file in the Frontend.
+
+It is recommended to use Services such as [Filebin](https://filebin.net) to upload your ZIP file. If you decide to use Filebin, provide the Frontend with the absolute path to the ZIP file by using More -> Download File, e.g. (use this [Popular TT songs ZIP](https://filebin.net/klylrens0uk2pnrg/drive-download-20240209T180019Z-001.zip), not this [Popular TT songs](https://filebin.net/2avx134kdibc4c3q))
+
+You can also just move your MP3 files into the `Songs` folder. 
+
+## Fonts 🅰
+
+Add your fonts to the `fonts/` folder, and load them by specifying the font name on line `124` in `Backend/video.py`.
+
+## Automatic YouTube Uploading 🎥
+
+MoneyPrinter now includes functionality to automatically upload generated videos to YouTube.
+
+To use this feature, you need to:
+
+1. Create a project inside your Google Cloud Platform -> [GCP](https://console.cloud.google.com/).
+1. Obtain `client_secret.json` from the project and add it to the Backend/ directory.
+1. Enable the YouTube v3 API in your project -> [GCP-API-Library](https://console.cloud.google.com/apis/library/youtube.googleapis.com)
+1. Create an `OAuth consent screen` and add yourself (the account of your YouTube channel) to the testers.
+1. Enable the following scopes in the `OAuth consent screen` for your project:
+
+```
+'https://www.googleapis.com/auth/youtube'
+'https://www.googleapis.com/auth/youtube.upload'
+'https://www.googleapis.com/auth/youtubepartner'
+```
+
+After this, you can generate the videos and you will be prompted to authenticate yourself.
+
+The authentication process creates and stores a `main.py-oauth2.json` file inside the Backend/ directory. Keep this file to maintain authentication, or delete it to re-authenticate (for example, with a different account).
+
+Videos are uploaded as private by default. For a completely automated workflow, change the privacyStatus in main.py to your desired setting ("public", "private", or "unlisted").
+
+For videos that have been locked as private due to upload via an unverified API service, you will not be able to appeal. You’ll need to re-upload the video via a verified API service or via the YouTube app/site. The unverified API service can also apply for an API audit. So make sure to verify your API, see [OAuth App Verification Help Center](https://support.google.com/cloud/answer/13463073) for more information.
+
+## FAQ 🤔
+
+### How do I get the TikTok session ID?
+
+You can obtain your TikTok session ID by logging into TikTok in your browser and copying the value of the `sessionid` cookie.
+
+### My ImageMagick binary is not being detected
+
+Make sure you set your path to the ImageMagick binary correctly in the `.env` file, it should look something like this:
+
+```env
+IMAGEMAGICK_BINARY="C:\\Program Files\\ImageMagick-7.1.0-Q16\\magick.exe"
+```
+
+Don't forget to use double backslashes (`\\`) in the path, instead of one.
+
+### I can't install `playsound`: Wheel failed to build
+
+If you're having trouble installing `playsound`, you can try installing it using the following command:
+
+```bash
+pip install -U wheel
+pip install -U playsound
+```
+
+If you were not able to find your solution, please ask in the discord or create a new issue, so that the community can help you.
+
+## Donate 🎁
+
+If you like and enjoy `MoneyPrinter`, and would like to donate, you can do that by clicking on the button on the right hand side of the repository. ❤️
+You will have your name (and/or logo) added to this repository as a supporter as a sign of appreciation.
+
+## Contributing 🤝
+
+Pull Requests will not be accepted for the time-being.
+
+## Star History 🌟
+
+[![Star History Chart](https://api.star-history.com/svg?repos=FujiwaraChoki/MoneyPrinter&type=Date)](https://star-history.com/#FujiwaraChoki/MoneyPrinter&Date)
+
+## License 📝
+
+See [`LICENSE`](LICENSE) file for more information.

docker-compose.yml

@@ -0,0 +1,37 @@
+version: "3"
+services:
+  frontend:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: "frontend"
+    ports:
+      - "8001:8001"
+    command: ["python3", "-m", "http.server", "8001", "--directory", "frontend"]
+    volumes:
+      - ./Frontend:/app/frontend
+    restart: always
+  backend:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: "backend"
+    ports:
+      - "8080:8080"
+    command: ["python3", "backend/main.py"]
+    volumes:
+      - ./files:/temp
+      - ./Backend:/app/backend
+      - ./fonts:/app/fonts
+    environment:
+      - ASSEMBLY_AI_API_KEY=${ASSEMBLY_AI_API_KEY}
+      - TIKTOK_SESSION_ID=${TIKTOK_SESSION_ID}
+      - IMAGEMAGICK_BINARY=/usr/local/bin/magick
+      - PEXELS_API_KEY=${PEXELS_API_KEY}
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+    depends_on:
+      - frontend
+    restart: always
+
+volumes:
+  files:

requirements.txt

@@ -0,0 +1,20 @@
+g4f==0.2.0.7
+setuptools
+wheel
+requests==2.31.0
+moviepy==1.0.3
+termcolor==2.4.0
+flask==3.0.0
+flask-cors==4.0.0
+playsound==1.3.0
+Pillow==9.5.0
+python-dotenv==1.0.0
+srt_equalizer==0.1.8
+platformdirs==4.1.0
+undetected_chromedriver
+assemblyai
+brotli
+google-api-python-client 
+oauth2client
+openai
+google-generativeai