Update app.py

app.py

@@ -1,69 +1,79 @@
-import gradio as gr
-from pytube import YouTube
+ import gradio as gr
+import yt_dlp
 import os
-import time
-import random
+import re
+from moviepy.video.io.VideoFileClip import VideoFileClip
 
-def download_video(url, output_path='.'):
-    max_retries = 5
-    retries = 0
-    backoff_factor = 1
+# Function to sanitize the filename
+def sanitize_filename(title):
+    # Replace invalid characters with an underscore
+    return re.sub(r'[<>:"/\\|?*]', '_', title)
 
-    while retries < max_retries:
-        try:
-            # Create a YouTube object with a custom user-agent
-            yt = YouTube(url, use_oauth=False, allow_oauth_cache=True, on_progress_callback=on_progress)
+# Function to download video and return the file path
+def download_video(url):
+    download_path = './downloads'  # Folder to store downloads
+    if not os.path.exists(download_path):
+        os.makedirs(download_path)
 
-            # Get the highest resolution stream
-            video = yt.streams.get_highest_resolution()
+    ydl_opts = {
+        'outtmpl': download_path + '/%(title)s.%(ext)s',
+        'format': 'best',  # Download the best available quality
+    }
+    
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info_dict = ydl.extract_info(url, download=True)  # Set download=True to download the video
+            title = info_dict.get('title', None)
+            if title:
+                sanitized_title = sanitize_filename(title)
+                file_path = os.path.join(download_path, f"{sanitized_title}.mp4")  # Adjust the extension as needed
+                return file_path if os.path.exists(file_path) else None  # Ensure the file exists before returning
+            return None
+    except Exception as e:
+        return str(e)
 
-            # Download the video
-            print(f"Downloading: {yt.title}")
-            video.download(output_path=output_path)
-            print(f"Download completed: {yt.title}")
-            return f"Download completed: {yt.title}"
+# Function to crop the video
+def crop_video(input_path, start_time, end_time):
+    output_path = input_path.replace('.mp4', '_cropped.mp4')
+    try:
+        with VideoFileClip(input_path) as video:
+            cropped_video = video.subclip(start_time, end_time)
+            cropped_video.write_videofile(output_path, codec='libx264')
+        return output_path
+    except Exception as e:
+        return str(e)
 
-        except Exception as e:
-            retries += 1
-            if retries == max_retries:
-                return f"An error occurred after {max_retries} retries: {e}"
-            else:
-                delay = backoff_factor * (2 ** (retries - 1)) + random.uniform(0, 1)
-                print(f"Retrying in {delay:.2f} seconds... (Attempt {retries}/{max_retries})")
-                time.sleep(delay)
+# Create Gradio interface
+def gradio_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("# YouTube Video Downloader and Cropper")
+        gr.Markdown("Enter the YouTube URL to download and crop the video.")
 
-def on_progress(stream, chunk, bytes_remaining):
-    total_size = stream.filesize
-    bytes_downloaded = total_size - bytes_remaining
-    percentage_of_completion = bytes_downloaded / total_size * 100
-    print(f"Download progress: {percentage_of_completion:.2f}%")
+        # Input for YouTube URL
+        url_input = gr.Textbox(label="YouTube URL", placeholder="Enter YouTube video URL here...")
+        
+        # Inputs for cropping
+        start_time_input = gr.Number(label="Start Time (seconds)", value=0)
+        end_time_input = gr.Number(label="End Time (seconds)", value=10)
 
-def validate_url(url):
-    try:
-        # Check if the URL is a valid YouTube video URL
-        yt = YouTube(url)
-        return True
-    except Exception as e:
-        return False
+        # File output for downloaded video
+        output_file = gr.File(label="Download Cropped Video")
+
+        # Download and Crop button
+        process_btn = gr.Button("Download and Crop Video")
 
-def gradio_interface(url, output_directory):
-    if not validate_url(url):
-        return "Invalid YouTube URL"
+        # Define the action on button click
+        def process_video(url, start_time, end_time):
+            video_path = download_video(url)
+            if video_path:
+                cropped_video_path = crop_video(video_path, start_time, end_time)
+                return cropped_video_path
+            return None
 
-    result = download_video(url, output_directory)
-    return result
+        process_btn.click(process_video, inputs=[url_input, start_time_input, end_time_input], outputs=output_file)
 
-# Create the Gradio interface
-iface = gr.Interface(
-    fn=gradio_interface,
-    inputs=[
-        gr.Textbox(label="Enter the YouTube video URL"),
-        gr.Textbox(label="Enter the output directory (leave blank for current directory)")
-    ],
-    outputs=gr.Textbox(label="Download Status"),
-    title="YouTube Video Downloader",
-    description="Enter a YouTube video URL and optionally specify an output directory to download the video."
-)
+    return demo
 
-# Launch the Gradio interface
-iface.launch()
+# Launch the interface
+if __name__ == "__main__":
+    gradio_interface().launch()