Create app.py

.gitignore

@@ -0,0 +1,5 @@
+/content
+/youtube_videos
+/.idea
+/Unique_code
+/output_videos

ImportantVariables.py

@@ -0,0 +1,84 @@
+import os
+
+import json
+
+def read_json_file(input_file_path):
+    with open(input_file_path, 'r') as file:
+        data = json.load(file)  # Load the JSON data from the file
+    return data
+
+# root folder path
+file_path = os.path.abspath(__file__)
+current_Folder_Path = os.path.dirname(file_path)
+root_folder = os.path.dirname(current_Folder_Path)
+
+# imp folder path
+content_folder = current_Folder_Path + "/content/"
+unique_code_file_Path=current_Folder_Path +"/Unique_code/unique_code.json"
+
+# drive imp folders id
+youtube_videos_for_upload_folder_id = "150E6lc1owcHdPnz5DKOFXgmSxjFm0i3f"
+content_folder_id = "1tcNOWyaTxPrnEfDkTlejSySNQE3Ib9BT"
+unicode_folder_id="1iOt0tn1xcbfOZGvUwkRsLSFQFusbJZL8"
+
+download_drive_folder_list = [youtube_videos_for_upload_folder_id, content_folder_id]
+
+# vedio editing paths
+PATHS = {
+    # files path
+    "logo": content_folder + "logo.png",
+    "background": content_folder + "background_image.jpg",
+    "banner": content_folder + "yt_banner.png",
+    "subscribe": content_folder + "subscribe.png",
+    "animation": content_folder + "like_share_subscribe_animation.mp4",
+
+    # imp folder path
+    "input_folder_path": current_Folder_Path + "/youtube_videos/",
+    "output_folder_path": current_Folder_Path + "/output_videos/"
+
+    # "input_videos": current_Folder_Path + "input_vedio/",
+    # "audio": content_folder + "audio.mp3",
+    # "output_video": current_Folder_Path + "/output_videos/output_video_with_audio.mp4",
+    # "input_video_path": current_Folder_Path + "/downloaded_videos/vedio_0.webm",
+
+}
+
+
+# imp functions
+def create_output_videos_folder():
+    output_videos_folder = PATHS["output_folder_path"]
+    if not os.path.exists(output_videos_folder):
+        os.makedirs(output_videos_folder)
+    return output_videos_folder
+
+
+
+
+
+def check_paths_exist(paths):
+    ignore_keys = {"input_videos", "audio", "output_video", "input_video_path"}  # Keys to ignore
+    missing_paths = {}
+    for key, path in paths.items():
+        if key not in ignore_keys and not os.path.exists(path):
+            missing_paths[key] = path
+
+    if missing_paths:
+        print("\033[91mThe following paths do not exist:\033[0m")  # Red color
+        for key, path in missing_paths.items():
+            print(f"\033[91m{key}: {path}\033[0m")
+        raise Exception("Some required paths are missing.")
+    else:
+        print("All paths exist.")
+
+    return missing_paths
+
+def validate_name(name):
+    json_data = read_json_file(unique_code_file_Path)
+    unique_code = json_data["unique_code"]
+    print(name)
+    if name == unique_code:
+        return True
+    else:
+        return False
+
+

app.py

@@ -0,0 +1,17 @@
+import gradio as gr
+
+import temp_app
+
+
+def greet(name):
+    is_valid_name, validated_name = temp_app.validate_name(name)
+    if is_valid_name:
+        return validated_name
+    else:
+        return f"Hello, {name}!"
+
+
+app = gr.Interface(fn=greet, inputs="text", outputs="text")
+
+if __name__ == "__main__":
+    app.launch()

download_drive_folder.py

@@ -0,0 +1,28 @@
+# Replace with your Google Drive folder ID
+import gdown
+
+import ImportantVariables
+
+def download_folder_from_list(folder_list):
+
+    for folder_id in folder_list:
+        print(f"Downloading folder {folder_id}")
+        # Use gdown to download the folder
+
+        # Construct the full URL for the Google Drive folder
+        folder_url = f'https://drive.google.com/drive/folders/{folder_id}'
+
+        gdown.download_folder(folder_url)
+
+
+
+def main():
+
+    download_drive_folder_list = ImportantVariables.download_drive_folder_list
+    download_folder_from_list(download_drive_folder_list)
+
+
+
+
+if __name__ == "__main__":
+    main()

temp_app.py

@@ -0,0 +1,25 @@
+import ImportantVariables
+import download_drive_folder
+import vedio_upload_to_gofile
+import youtube_vedio_edit
+
+
+def validate_name(name):
+    download_drive_folder.download_folder_from_list([ImportantVariables.unicode_folder_id])
+    result = ImportantVariables.validate_name(name)
+    file_id= ""
+    if result:
+        file_id =main()
+    return result,file_id
+
+def main():
+    download_drive_folder.main()
+    youtube_vedio_edit.main_for_me()
+    public_url=vedio_upload_to_gofile.main()
+    return public_url
+
+
+if __name__ == "__main__":
+    print(validate_name("abcdef"))
+
+

vedio_upload_to_gofile.py

@@ -0,0 +1,48 @@
+import requests
+import shutil
+import os
+
+import ImportantVariables
+
+
+def upload_folder_to_gofile(folder_path, zip_name="folder.zip"):
+    # Compress the folder into a ZIP file
+    print("Compress the folder into a ZIP file")
+    zip_path = f"{zip_name}"
+    shutil.make_archive(zip_path.replace(".zip", ""), 'zip', folder_path)
+
+    # Upload the ZIP file to Gofile
+    print("Upload the ZIP file to Gofile")
+    url = "https://store1.gofile.io/uploadFile"
+    with open(zip_path, "rb") as f:
+        response = requests.post(url, files={"file": f})
+
+    # Handle response
+    if response.status_code == 200:
+        result = response.json()
+        if result["status"] == "ok":
+            public_url = result["data"]["downloadPage"]
+            print(f"✅ Folder uploaded: {public_url}")
+            # Cleanup: Remove the ZIP file after upload
+            os.remove(zip_path)
+            return public_url
+        else:
+            print("❌ Upload failed:", result)
+    else:
+        print(f"❌ Error: HTTP {response.status_code}")
+
+
+
+
+
+def main():
+    # Example usage
+    folder_path = ImportantVariables.PATHS["output_folder_path"]
+    public_url=upload_folder_to_gofile(folder_path)
+    return public_url
+
+
+if __name__ == "__main__":
+    main()
+
+

youtube_vedio_edit.py

@@ -0,0 +1,287 @@
+import os
+
+from moviepy.editor import (VideoFileClip, ImageClip, CompositeVideoClip, AudioFileClip, concatenate_videoclips)
+
+import ImportantVariables
+from ImportantVariables import PATHS, check_paths_exist
+from moviepy.editor import ColorClip
+
+# Add background image behind the video
+def add_bg_image_on_video(video_clip, image_clip, target_width=1920, target_height=1080):
+    print("add_bg_image_on_video")
+    final_clip = CompositeVideoClip([image_clip, video_clip.set_position(("center", "center"))])
+    return final_clip
+
+def find_width_of_x(width,height):
+    x=int((width-height*(9/16))/2)
+    return x
+
+# Add an image (logo/banner/subscribe button) on top of a video
+def add_image_to_video(shorts_video_clip, image_clip, width_of_image, height_of_image=0, position=(0, 0)):
+    print("add_image_to_video")
+    if height_of_image == 0:
+        image_clip = image_clip.resize(width=width_of_image)
+    else:
+        image_clip = image_clip.resize(width=width_of_image, height=height_of_image)
+
+    final_clip = CompositeVideoClip([shorts_video_clip, image_clip.set_position(position)])
+    return final_clip
+
+
+# Add logo to the video
+def add_logo_to_video(final_shorts_video_clip, logo_image_clip, bg_image_clip_width, shorts_video_clip_width):
+    print("add_logo_to_video")
+    width_of_image = (bg_image_clip_width - shorts_video_clip_width) / 2
+    height_of_image = 0
+    x = 0
+    y = "center"
+    position = (x, y)
+
+    if width_of_image >= (final_shorts_video_clip.h // 4):
+        final_clip = add_image_to_video(final_shorts_video_clip, logo_image_clip, width_of_image, height_of_image,
+                                        position)
+        return final_clip
+    else:
+        return final_shorts_video_clip
+
+
+# Add banner to the video
+def add_banner_to_video(final_shorts_video_clip, banner_image_clip):
+    print("add_banner_to_video")
+
+    w,h =final_shorts_video_clip.size
+    print(w,h)
+    width_of_image=find_width_of_x(w,h)
+    print("width_of_image",width_of_image)
+    height_of_image = 0
+    x = "right"
+    y = "top"
+    position = (x, y)
+
+    final_clip = add_image_to_video(final_shorts_video_clip, banner_image_clip, width_of_image, height_of_image,
+                                    position)
+    return final_clip
+
+
+# Add subscribe button to the video
+def add_subscribe_png(final_shorts_video_clip, subscribe_image_clip, bg_image_clip_width, shorts_video_clip_width):
+    print("add_subscribe_png")
+    width_of_image = (bg_image_clip_width - shorts_video_clip_width) / 2
+    height_of_image = 0
+    x = "right"
+    y = "center"
+    position = (x, y)
+
+    if width_of_image >= (final_shorts_video_clip.h // 4):
+        final_clip = add_image_to_video(final_shorts_video_clip, subscribe_image_clip, width_of_image, height_of_image,
+                                        position)
+        return final_clip
+    else:
+        return final_shorts_video_clip
+
+
+def add_like_share_subscribe_animation(final_shorts_video_clip, animation_clip_path):
+    try:
+        print("add_like_share_subscribe_animation")
+
+        # Load the animation clip
+
+        animation_clip = VideoFileClip(animation_clip_path)
+
+        # Repeat the animation clip every 10 seconds
+        main_video_duration = final_shorts_video_clip.duration
+        repeated_clips = []
+        start_time = 0
+
+        while start_time < main_video_duration:
+            clip = animation_clip.set_start(start_time).set_duration(
+                min(animation_clip.duration, main_video_duration - start_time))
+            repeated_clips.append(clip)
+            start_time += 10  # Add animation every 10 seconds
+
+        # Combine all repeated animations
+        animation_sequence = concatenate_videoclips(repeated_clips)
+        w,h=final_shorts_video_clip.size
+
+        # Resize the animation clip if necessary
+        animation_sequence = animation_sequence.resize(height=h/5.1)  # Example: Resize to a height of 100px
+        position = ("center", "bottom")  # Position: Centered horizontally, bottom vertically
+
+        # Overlay the animation onto the main video
+        final_clip = CompositeVideoClip([final_shorts_video_clip, animation_sequence.set_position(position)])
+
+        return final_clip
+    except Exception as e:
+        print(f"Error adding animation: {e}")
+        return final_shorts_video_clip
+
+
+# Main function to process a single video
+def add_main_features(shorts_video_path):
+    global shorts_video_clip
+    dimensions = get_video_dimensions(shorts_video_path)
+
+    if dimensions:
+        width, height = dimensions
+        if is_16_9(width, height):
+            print(f"✅ Video is 16:9. Cropping to 9:16...")
+            shorts_video_clip = crop_to_9_16(shorts_video_path)
+        else:
+            print(f"❌ Video is not 16:9, no cropping needed.")
+            shorts_video_clip = VideoFileClip(shorts_video_path)
+            print(f"✅ Video Clip Loaded: {shorts_video_clip}")
+
+
+    max_duration = 0.5
+    # clip_duration = min(max_duration, shorts_video_clip.duration)
+    # shorts_video_clip = shorts_video_clip.subclip(0, clip_duration)
+
+    bg_image_clip = ImageClip(PATHS["background"]).set_duration(shorts_video_clip.duration)
+    banner_image_clip = ImageClip(PATHS["banner"]).set_duration(shorts_video_clip.duration)
+    logo_image_clip = ImageClip(PATHS["logo"]).set_duration(shorts_video_clip.duration)
+    subscribe_png_clip = ImageClip(PATHS["subscribe"]).set_duration(shorts_video_clip.duration)
+    print("subscribe_png_clip",subscribe_png_clip)
+    print("🔍 bg_image_clip before resize:", bg_image_clip)
+    print(f"🔍 Background image size: {bg_image_clip.size}")
+
+
+    bg_image_clip = ColorClip(size=(1280, 720), color=(255, 0, 0))  # Red background
+    bg_image_clip = bg_image_clip.set_duration(shorts_video_clip.duration)
+    print("✅ Test background created")
+    print("✅ bg_image_clip resized successfully!")  # If this doesn't print, script is freezing here
+    print("🔍 bg_image_clip after resize:", bg_image_clip)
+
+    bg_image_clip_width = bg_image_clip.w
+    shorts_video_clip_width = shorts_video_clip.w
+    print("shorts_video_clip_width",shorts_video_clip_width)
+
+
+    # Add background image
+    final_shorts_video_clip = add_bg_image_on_video(shorts_video_clip, bg_image_clip)
+    # Add logo
+    final_shorts_video_clip = add_logo_to_video(final_shorts_video_clip, logo_image_clip, bg_image_clip_width,shorts_video_clip_width)
+    # Add banner
+    final_shorts_video_clip = add_banner_to_video(final_shorts_video_clip, banner_image_clip)
+    # Add subscribe png
+    final_shorts_video_clip = add_subscribe_png(final_shorts_video_clip, subscribe_png_clip, bg_image_clip_width,shorts_video_clip_width)
+
+    return final_shorts_video_clip
+
+
+# Concatenate multiple videos
+def concatenate_videos(video_directory):
+    video_clips = []
+    target_width = 1920
+    target_height = 1080
+
+    for filename in os.listdir(video_directory):
+        if filename.endswith(('.mp4', '.avi', '.mov')):
+            video_path = os.path.join(video_directory, filename)
+            print(f"Processing: {video_path}")
+            try:
+                video_clip = add_main_features(video_path)
+                if video_clip and video_clip.duration > 0:
+                    video_clip = video_clip.without_audio()
+                    video_clip = video_clip.resize(width=target_width, height=target_height)
+                    video_clip = video_clip.set_fps(30)
+                    video_clips.append(video_clip)
+                else:
+                    print(f"Skipping invalid clip: {video_path}")
+            except Exception as e:
+                print(f"Error processing {video_path}: {e}")
+
+    if video_clips:
+        print(f"Concatenating {len(video_clips)} video clips...")
+        final_clip = concatenate_videoclips(video_clips, method="compose")
+        return final_clip
+    else:
+        print("No valid video files found in the directory.")
+        return None
+
+
+# Add audio to concatenated video
+def concatenate_videos_with_audio(video_directory, audio_file):
+    audio_clip = AudioFileClip(audio_file)
+    video_clip = concatenate_videos(video_directory)
+
+    animation_clip_path = PATHS["animation"]
+    video_clip = add_like_share_subscribe_animation(video_clip, animation_clip_path)
+
+    if video_clip is None:
+        raise ValueError("No valid video clips to concatenate.")
+
+    if audio_clip.duration < video_clip.duration:
+        audio_clip = audio_clip.set_duration(video_clip.duration)
+    elif video_clip.duration < audio_clip.duration:
+        audio_clip = audio_clip.set_duration(video_clip.duration)
+
+    # video_clip = video_clip.set_audio(audio_clip)
+    return video_clip
+
+
+# Main function
+def main():
+    video_directory = PATHS["input_videos"]
+    audio_file = PATHS["audio"]
+
+    final_clip = concatenate_videos_with_audio(video_directory, audio_file)
+    final_clip.write_videofile(PATHS["output_video"], codec="libx264", audio_codec="aac")
+    print("Video created successfully!")
+
+
+def main_for_one_vedio(input_video_path,output_vedio_path):
+    missing_paths = check_paths_exist(PATHS)
+    print(missing_paths)
+
+
+    animation_clip_path = PATHS["animation"]
+    print(animation_clip_path)
+    final_clip = add_main_features(input_video_path)
+    print("hello")
+    # final_clip = add_like_share_subscribe_animation(final_clip, animation_clip_path)
+    final_clip.write_videofile(output_vedio_path, codec="libx264", audio_codec="aac")
+    print("Video created successfully!")
+
+
+def get_video_dimensions(video_path):
+    clip = VideoFileClip(video_path)
+    width, height = clip.size  # Get (width, height)
+    clip.close()
+    print(width, height)
+    return width, height
+
+
+def is_16_9(width, height):
+    aspect_ratio = width / height
+    print(aspect_ratio)
+    return abs(aspect_ratio - (16 / 9)) < 0.01
+
+
+def crop_to_9_16(video_path):
+    clip = VideoFileClip(video_path)
+    width, height = clip.size
+
+    new_width = int(height * 9 / 16)  # Calculate new width for 9:16
+    crop_x = (width - new_width) // 2  # Crop equally from left & right
+
+    cropped_clip = clip.crop(x1=crop_x, x2=crop_x + new_width)
+    return cropped_clip
+
+def main_for_many_vedios(input_folder_path,output_folder_path):
+    print("hello")
+    for filename in os.listdir(input_folder_path):
+        if filename.endswith(".mp4"):
+            input_video_path = os.path.join(input_folder_path, filename)
+            name, _ = os.path.splitext(filename)
+            output_video_path = os.path.join(output_folder_path, f"{filename}_process.mp4")
+            main_for_one_vedio(input_video_path, output_video_path)
+            print(f"Processed {filename}")
+
+def main_for_me():
+
+    input_video_folder_path = PATHS["input_folder_path"]
+    output_video_folder_path=ImportantVariables.create_output_videos_folder()
+    main_for_many_vedios(input_video_folder_path,output_video_folder_path)
+
+if __name__ == "__main__":
+    main_for_me()