Upload 9 files

utility/audio_generator.py

@@ -0,0 +1,32 @@
+import edge_tts
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+async def generate_audio(text, outputFilename):
+    """Generate audio from text using edge_tts
+    
+    Args:
+        text (str): Text to convert to speech
+        outputFilename (str): Path to save the audio file
+        
+    Raises:
+        Exception: If audio generation fails
+    """
+    try:
+        # Ensure output directory exists
+        os.makedirs(os.path.dirname(outputFilename), exist_ok=True)
+        
+        logger.info(f"Generating audio for text length: {len(text)}")
+        # Updated voice parameter below:
+        communicate = edge_tts.Communicate(text, "en-US-GuyNeural")
+        await communicate.save(outputFilename)
+        
+        if not os.path.exists(outputFilename):
+            raise Exception(f"Failed to create audio file at {outputFilename}")
+            
+        logger.info(f"Successfully generated audio at {outputFilename}")
+    except Exception as e:
+        logger.error(f"Error generating audio: {str(e)}")
+        raise Exception(f"Audio generation failed: {str(e)}")

utility/background_video_generator.py

@@ -0,0 +1,71 @@
+import os 
+import requests
+from utility.utils import log_response,LOG_TYPE_PEXEL
+
+PEXELS_API_KEY = os.environ.get('PEXELS_KEY')
+
+def search_videos(query_string, orientation_landscape=True):
+   
+    url = "https://api.pexels.com/videos/search"
+    headers = {
+        "Authorization": PEXELS_API_KEY,
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+    }
+    params = {
+        "query": query_string,
+        "orientation": "landscape" if orientation_landscape else "portrait",
+        "per_page": 15
+    }
+
+    response = requests.get(url, headers=headers, params=params)
+    json_data = response.json()
+    log_response(LOG_TYPE_PEXEL,query_string,response.json())
+   
+    return json_data
+
+
+def getBestVideo(query_string, orientation_landscape=True, used_vids=[]):
+    vids = search_videos(query_string, orientation_landscape)
+    videos = vids['videos']  # Extract the videos list from JSON
+
+    # Filter and extract videos with width and height as 1920x1080 for landscape or 1080x1920 for portrait
+    if orientation_landscape:
+        filtered_videos = [video for video in videos if video['width'] >= 1920 and video['height'] >= 1080 and video['width']/video['height'] == 16/9]
+    else:
+        filtered_videos = [video for video in videos if video['width'] >= 1080 and video['height'] >= 1920 and video['height']/video['width'] == 16/9]
+
+    # Sort the filtered videos by duration in ascending order
+    sorted_videos = sorted(filtered_videos, key=lambda x: abs(15-int(x['duration'])))
+
+    # Extract the top 3 videos' URLs
+    for video in sorted_videos:
+        for video_file in video['video_files']:
+            if orientation_landscape:
+                if video_file['width'] == 1920 and video_file['height'] == 1080:
+                    if not (video_file['link'].split('.hd')[0] in used_vids):
+                        return video_file['link']
+            else:
+                if video_file['width'] == 1080 and video_file['height'] == 1920:
+                    if not (video_file['link'].split('.hd')[0] in used_vids):
+                        return video_file['link']
+    print("NO LINKS found for this round of search with query :", query_string)
+    return None
+
+
+def generate_video_url(timed_video_searches,video_server):
+        timed_video_urls = []
+        if video_server == "pexel":
+            used_links = []
+            for (t1, t2), search_terms in timed_video_searches:
+                url = ""
+                for query in search_terms:
+                  
+                    url = getBestVideo(query, orientation_landscape=True, used_vids=used_links)
+                    if url:
+                        used_links.append(url.split('.hd')[0])
+                        break
+                timed_video_urls.append([[t1, t2], url])
+        elif video_server == "stable_diffusion":
+            timed_video_urls = get_images_for_video(timed_video_searches)
+
+        return timed_video_urls

utility/conf.py

@@ -0,0 +1,14 @@
+import os
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# ImageMagick configuration
+IMAGEMAGICK_BINARY = r"C:\Program Files\ImageMagick-7.1.1-Q16-HDRI\magick.exe"
+
+# Validate ImageMagick path
+if not Path(IMAGEMAGICK_BINARY).exists():
+    error_msg = f"ImageMagick not found at {IMAGEMAGICK_BINARY}. Please install ImageMagick and update the path."
+    logger.error(error_msg)
+    raise FileNotFoundError(error_msg)

utility/render_engine.py

@@ -0,0 +1,187 @@
+import time
+import os
+import tempfile
+import zipfile
+import platform
+import subprocess
+import logging
+from pathlib import Path
+from moviepy.editor import (AudioFileClip, CompositeVideoClip, CompositeAudioClip, ImageClip,
+                            TextClip, VideoFileClip)
+from moviepy.audio.fx.audio_loop import audio_loop
+from moviepy.audio.fx.audio_normalize import audio_normalize
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+def download_file(url, filename):
+    with open(filename, 'wb') as f:
+        headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        }
+        response = requests.get(url, headers=headers)
+        f.write(response.content)
+
+def search_program(program_name):
+    try: 
+        search_cmd = "where" if platform.system() == "Windows" else "which"
+        return subprocess.check_output([search_cmd, program_name]).decode().strip()
+    except subprocess.CalledProcessError:
+        return None
+
+def get_program_path(program_name):
+    program_path = search_program(program_name)
+    return program_path
+
+def get_output_media(audio_file_path, timed_captions, background_video_data, video_server):
+    """Generate final video with audio and captions
+    
+    Args:
+        audio_file_path (str): Path to audio file
+        timed_captions (list): List of timed captions
+        background_video_data (list): List of background video data
+        video_server (str): Video server URL
+        
+    Returns:
+        str: Path to output video file
+        
+    Raises:
+        Exception: If video rendering fails
+    """
+    OUTPUT_FILE_NAME = "rendered_video.mp4"
+    from utility.conf import IMAGEMAGICK_BINARY
+    from moviepy.config import change_settings
+    
+    try:
+        # Validate input files
+        if not Path(audio_file_path).exists():
+            raise FileNotFoundError(f"Audio file not found at {audio_file_path}")
+            
+        try:
+            change_settings({"IMAGEMAGICK_BINARY": IMAGEMAGICK_BINARY})
+            logger.info(f"Using ImageMagick from: {IMAGEMAGICK_BINARY}")
+        except Exception as e:
+            logger.error(f"Error configuring ImageMagick: {str(e)}")
+            raise Exception(f"ImageMagick configuration failed: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error in initial setup: {str(e)}")
+        raise Exception(f"Initial setup failed: {str(e)}")
+
+
+
+
+
+    
+    visual_clips = []
+    for (t1, t2), video_url in background_video_data:
+        try:
+            # Download the video file
+            video_filename = tempfile.NamedTemporaryFile(delete=False).name
+            logger.info(f"Downloading video from {video_url}")
+            download_file(video_url, video_filename)
+            
+            if not Path(video_filename).exists():
+                raise FileNotFoundError(f"Failed to download video from {video_url}")
+                
+            # Create VideoFileClip from the downloaded file
+            video_clip = VideoFileClip(video_filename)
+            if video_clip is None:
+                raise ValueError(f"Failed to create video clip from {video_filename}")
+                
+            video_clip = video_clip.set_start(t1)
+            video_clip = video_clip.set_end(t2)
+            visual_clips.append(video_clip)
+            logger.info(f"Added video clip from {video_url} ({t1}-{t2}s)")
+            
+        except Exception as e:
+            logger.error(f"Error processing video {video_url}: {str(e)}")
+            raise Exception(f"Failed to process video {video_url}: {str(e)}")
+
+    
+    audio_clips = []
+    try:
+        # Verify audio file exists and is valid
+        if not os.path.exists(audio_file_path):
+            raise FileNotFoundError(f"Audio file not found: {audio_file_path}")
+            
+        audio_file_clip = AudioFileClip(audio_file_path)
+        if audio_file_clip is None:
+            raise ValueError(f"Failed to create audio clip from {audio_file_path}")
+            
+        # Normalize audio volume
+        audio_file_clip = audio_normalize(audio_file_clip)
+        
+        # Verify audio duration
+        if audio_file_clip.duration <= 0:
+            raise ValueError("Audio file has zero or negative duration")
+            
+        audio_clips.append(audio_file_clip)
+        logger.info(f"Added audio clip from {audio_file_path} (duration: {audio_file_clip.duration:.2f}s)")
+
+    except Exception as e:
+        logger.error(f"Error processing audio: {str(e)}")
+        raise Exception(f"Failed to process audio: {str(e)}")
+
+
+    for (t1, t2), text in timed_captions:
+        try:
+            # Updated caption style: changed font, fontsize, and position.
+            text_clip = TextClip(
+                txt=text, 
+                fontsize=70, 
+                font="Arial-Bold", 
+                color="white", 
+                stroke_width=2, 
+                stroke_color="black", 
+                method="label"
+            )
+            # Set the text to appear at the bottom-center
+            text_clip = text_clip.set_start(t1).set_end(t2).set_position(('center','bottom'))
+            visual_clips.append(text_clip)
+            logger.info(f"Added text clip: {text} ({t1}-{t2}s)")
+        except Exception as e:
+            logger.error(f"Error creating text clip: {str(e)}")
+            raise Exception(f"Failed to create text clip: {str(e)}")
+
+
+    try:
+        if not visual_clips:
+            raise ValueError("No visual clips available for rendering")
+            
+        video = CompositeVideoClip(visual_clips)
+        
+        if audio_clips:
+            audio = CompositeAudioClip(audio_clips)
+            # Ensure video duration matches audio and update video with audio properly
+            if video.duration < audio.duration:
+                last_clip = visual_clips[-1]
+                extended_clip = last_clip.set_end(audio.duration)
+                visual_clips[-1] = extended_clip
+                video = CompositeVideoClip(visual_clips)
+                
+            video = video.set_duration(audio.duration)
+            # Updated audio application using set_audio
+            video = video.set_audio(audio)
+            logger.info(f"Audio synchronized with video (duration: {video.duration:.2f}s)")
+
+
+        logger.info(f"Rendering final video to {OUTPUT_FILE_NAME}")
+        video.write_videofile(OUTPUT_FILE_NAME, codec='libx264', audio_codec='aac', fps=25, preset='veryfast')
+        
+        # Clean up downloaded files
+        for (t1, t2), video_url in background_video_data:
+            video_filename = tempfile.NamedTemporaryFile(delete=False).name
+            if Path(video_filename).exists():
+                os.remove(video_filename)
+                logger.info(f"Cleaned up temporary file: {video_filename}")
+
+        if not Path(OUTPUT_FILE_NAME).exists():
+            raise FileNotFoundError(f"Failed to create output video at {OUTPUT_FILE_NAME}")
+            
+        logger.info(f"Successfully rendered video at {OUTPUT_FILE_NAME}")
+        return OUTPUT_FILE_NAME
+        
+    except Exception as e:
+        logger.error(f"Error rendering video: {str(e)}")
+        raise Exception(f"Video rendering failed: {str(e)}")

utility/script_generator.py

@@ -0,0 +1,60 @@
+import os
+from openai import OpenAI
+import json
+
+
+from groq import Groq
+model = "mixtral-8x7b-32768"
+client = Groq(
+    api_key=os.environ.get("GROQ_API_KEY"),
+    )
+
+def generate_script(topic):
+    prompt = (
+        """You are a seasoned content writer for a YouTube Shorts channel, specializing in facts videos. 
+        Your facts shorts are concise, each lasting less than 50 seconds (approximately 140 words). 
+        They are incredibly engaging and original. When a user requests a specific type of facts short, you will create it.
+
+        For instance, if the user asks for:
+        Weird facts
+        You would produce content like this:
+
+        Weird facts you don't know:
+        - Bananas are berries, but strawberries aren't.
+        - A single cloud can weigh over a million pounds.
+        - There's a species of jellyfish that is biologically immortal.
+        - Honey never spoils; archaeologists have found pots of honey in ancient Egyptian tombs that are over 3,000 years old and still edible.
+        - The shortest war in history was between Britain and Zanzibar on August 27, 1896. Zanzibar surrendered after 38 minutes.
+        - Octopuses have three hearts and blue blood.
+
+        You are now tasked with creating the best short script based on the user's requested type of 'facts'.
+
+        Keep it brief, highly interesting, and unique.
+
+        Stictly output the script in a JSON format like below, and only provide a parsable JSON object with the key 'script'.
+
+        # Output
+        {"script": "Here is the script ..."}
+        """
+    )
+
+    response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": topic}
+            ]
+        )
+    content = response.choices[0].message.content
+    try:
+        # Basic cleanup of common JSON formatting issues
+        content = content.strip()
+        # Parse JSON directly
+        response_dict = json.loads(content)
+        script = response_dict["script"]
+    except Exception as e:
+        print(f"Error parsing script: {e}")
+        print("Raw content:", content)
+        script = "Failed to generate script. Please try again."
+
+    return script

utility/text_audio_cleaner.py

@@ -0,0 +1,44 @@
+import re
+import os
+from pydub import AudioSegment
+
+def clean_text(text):
+    """
+    Removes symbols and cleans the input text.
+    """
+    text = re.sub(r'[^\w\s]', '', text)  # Remove punctuation
+    text = text.strip()  # Remove leading/trailing whitespace
+    return text
+
+def process_audio(audio_path, output_path):
+    """
+    Cleans and normalizes the audio.
+    """
+    try:
+        audio = AudioSegment.from_file(audio_path)
+        # Simple normalization (you can add more sophisticated methods)
+        normalized_audio = audio.normalize()
+        normalized_audio.export(output_path, format="wav")
+        return output_path
+    except Exception as e:
+        print(f"Error processing audio: {e}")
+        return None
+
+def convert_to_wav(input_file):
+    """
+    Convert any audio file to WAV format.
+    """
+    try:
+        # Load the audio file
+        audio = AudioSegment.from_file(input_file)
+        
+        # Define the output WAV file path
+        output_wav = os.path.splitext(input_file)[0] + ".wav"
+        
+        # Export the audio to WAV format
+        audio.export(output_wav, format="wav")
+        
+        return output_wav
+    except Exception as e:
+        print(f"Error converting to WAV: {e}")
+        return None

utility/timed_captions_generator.py

@@ -0,0 +1,71 @@
+import whisper_timestamped as whisper
+from whisper_timestamped import load_model, transcribe_timestamped
+import re
+
+def generate_timed_captions(audio_filename,model_size="base"):
+    WHISPER_MODEL = load_model(model_size)
+   
+    gen = transcribe_timestamped(WHISPER_MODEL, audio_filename, verbose=False, fp16=False)
+   
+    return getCaptionsWithTime(gen)
+
+def splitWordsBySize(words, maxCaptionSize):
+   
+    halfCaptionSize = maxCaptionSize / 2
+    captions = []
+    while words:
+        caption = words[0]
+        words = words[1:]
+        while words and len(caption + ' ' + words[0]) <= maxCaptionSize:
+            caption += ' ' + words[0]
+            words = words[1:]
+            if len(caption) >= halfCaptionSize and words:
+                break
+        captions.append(caption)
+    return captions
+
+def getTimestampMapping(whisper_analysis):
+   
+    index = 0
+    locationToTimestamp = {}
+    for segment in whisper_analysis['segments']:
+        for word in segment['words']:
+            newIndex = index + len(word['text'])+1
+            locationToTimestamp[(index, newIndex)] = word['end']
+            index = newIndex
+    return locationToTimestamp
+
+def cleanWord(word):
+   
+    return re.sub(r'[^\w\s\-_"\'\']', '', word)
+
+def interpolateTimeFromDict(word_position, d):
+   
+    for key, value in d.items():
+        if key[0] <= word_position <= key[1]:
+            return value
+    return None
+
+def getCaptionsWithTime(whisper_analysis, maxCaptionSize=15, considerPunctuation=False):
+   
+    wordLocationToTime = getTimestampMapping(whisper_analysis)
+    position = 0
+    start_time = 0
+    CaptionsPairs = []
+    text = whisper_analysis['text']
+    
+    if considerPunctuation:
+        sentences = re.split(r'(?<=[.!?]) +', text)
+        words = [word for sentence in sentences for word in splitWordsBySize(sentence.split(), maxCaptionSize)]
+    else:
+        words = text.split()
+        words = [cleanWord(word) for word in splitWordsBySize(words, maxCaptionSize)]
+    
+    for word in words:
+        position += len(word) + 1
+        end_time = interpolateTimeFromDict(position, wordLocationToTime)
+        if end_time and word:
+            CaptionsPairs.append(((start_time, end_time), word))
+            start_time = end_time
+
+    return CaptionsPairs

utility/utils.py

@@ -0,0 +1,34 @@
+import os
+from datetime import datetime
+import json
+
+# Log types
+LOG_TYPE_GPT = "GPT"
+LOG_TYPE_PEXEL = "PEXEL"
+
+# log directory paths
+DIRECTORY_LOG_GPT = ".logs/gpt_logs"
+DIRECTORY_LOG_PEXEL = ".logs/pexel_logs"
+
+# method to log response from pexel and openai
+def log_response(log_type, query,response):
+    log_entry = {
+        "query": query,
+        "response": response,
+        "timestamp": datetime.now().isoformat()
+    }
+    if log_type == LOG_TYPE_GPT:
+        if not os.path.exists(DIRECTORY_LOG_GPT):
+            os.makedirs(DIRECTORY_LOG_GPT)
+        filename = '{}_gpt3.txt'.format(datetime.now().strftime("%Y%m%d_%H%M%S"))
+        filepath = os.path.join(DIRECTORY_LOG_GPT, filename)
+        with open(filepath, "w") as outfile:
+            outfile.write(json.dumps(log_entry) + '\n')
+
+    if log_type == LOG_TYPE_PEXEL:
+        if not os.path.exists(DIRECTORY_LOG_PEXEL):
+            os.makedirs(DIRECTORY_LOG_PEXEL)
+        filename = '{}_pexel.txt'.format(datetime.now().strftime("%Y%m%d_%H%M%S"))
+        filepath = os.path.join(DIRECTORY_LOG_PEXEL, filename)
+        with open(filepath, "w") as outfile:
+            outfile.write(json.dumps(log_entry) + '\n')

utility/video_search_query_generator.py

@@ -0,0 +1,117 @@
+from openai import OpenAI
+import os
+import json
+import re
+from datetime import datetime
+from utility.utils import log_response,LOG_TYPE_GPT
+
+from groq import Groq
+model = "llama3-70b-8192"
+client = Groq(
+    api_key=os.environ.get("GROQ_API_KEY"),
+    )
+
+log_directory = ".logs/gpt_logs"
+
+prompt = """# Instructions
+
+Given the following video script and timed captions, extract three visually concrete and specific keywords for each time segment that can be used to search for background videos. The keywords should be short and capture the main essence of the sentence. They can be synonyms or related terms. If a caption is vague or general, consider the next timed caption for more context. If a keyword is a single word, try to return a two-word keyword that is visually concrete. If a time frame contains two or more important pieces of information, divide it into shorter time frames with one keyword each. Ensure that the time periods are strictly consecutive and cover the entire length of the video. Each keyword should cover between 2-4 seconds. The output should be in JSON format, like this: [[[t1, t2], ["keyword1", "keyword2", "keyword3"]], [[t2, t3], ["keyword4", "keyword5", "keyword6"]], ...]. Please handle all edge cases, such as overlapping time segments, vague or general captions, and single-word keywords.
+
+For example, if the caption is 'The cheetah is the fastest land animal, capable of running at speeds up to 75 mph', the keywords should include 'cheetah running', 'fastest animal', and '75 mph'. Similarly, for 'The Great Wall of China is one of the most iconic landmarks in the world', the keywords should be 'Great Wall of China', 'iconic landmark', and 'China landmark'.
+
+Important Guidelines:
+
+Use only English in your text queries.
+Each search string must depict something visual.
+The depictions have to be extremely visually concrete, like rainy street, or cat sleeping.
+'emotional moment' <= BAD, because it doesn't depict something visually.
+'crying child' <= GOOD, because it depicts something visual.
+The list must always contain the most relevant and appropriate query searches.
+['Car', 'Car driving', 'Car racing', 'Car parked'] <= BAD, because it's 4 strings.
+['Fast car'] <= GOOD, because it's 1 string.
+['Un chien', 'une voiture rapide', 'une maison rouge'] <= BAD, because the text query is NOT in English.
+
+Note: Your response should be the response only and no extra text or data.
+  """
+
+def fix_json(json_str):
+    # Replace typographical apostrophes with straight quotes
+    json_str = json_str.replace("’", "'")
+    # Replace any incorrect quotes (e.g., mixed single and double quotes)
+    json_str = json_str.replace("“", "\"").replace("”", "\"").replace("‘", "\"").replace("’", "\"")
+    # Add escaping for quotes within the strings
+    json_str = json_str.replace('"you didn"t"', '"you didn\'t"')
+    return json_str
+
+def getVideoSearchQueriesTimed(script,captions_timed):
+    end = captions_timed[-1][0][1]
+    try:
+        
+        out = [[[0,0],""]]
+        while out[-1][0][1] != end:
+            content = call_OpenAI(script,captions_timed).replace("'",'"')
+            try:
+                out = json.loads(content)
+            except Exception as e:
+                print("content: \n", content, "\n\n")
+                print(e)
+                content = fix_json(content.replace("```json", "").replace("```", ""))
+                out = json.loads(content)
+        return out
+    except Exception as e:
+        print("error in response",e)
+   
+    return None
+
+def call_OpenAI(script,captions_timed):
+    user_content = """Script: {}
+Timed Captions:{}
+""".format(script,"".join(map(str,captions_timed)))
+    print("Content", user_content)
+    
+    response = client.chat.completions.create(
+        model= model,
+        temperature=1,
+        messages=[
+            {"role": "system", "content": prompt},
+            {"role": "user", "content": user_content}
+        ]
+    )
+    
+    text = response.choices[0].message.content.strip()
+    text = re.sub('\s+', ' ', text)
+    print("Text", text)
+    log_response(LOG_TYPE_GPT,script,text)
+    return text
+
+def merge_empty_intervals(segments):
+    if segments is None:
+        return []
+        
+    merged = []
+    i = 0
+    while i < len(segments):
+
+        interval, url = segments[i]
+        if url is None:
+            # Find consecutive None intervals
+            j = i + 1
+            while j < len(segments) and segments[j][1] is None:
+                j += 1
+            
+            # Merge consecutive None intervals with the previous valid URL
+            if i > 0:
+                prev_interval, prev_url = merged[-1]
+                if prev_url is not None and prev_interval[1] == interval[0]:
+                    merged[-1] = [[prev_interval[0], segments[j-1][0][1]], prev_url]
+                else:
+                    merged.append([interval, prev_url])
+            else:
+                merged.append([interval, None])
+            
+            i = j
+        else:
+            merged.append([interval, url])
+            i += 1
+    
+    return merged