Update app.py

Fitur YouTube Integration:
1. Dual Input Method

Radio button untuk memilih antara "Upload Video File" atau "YouTube URL"
Dynamic UI yang menampilkan input yang relevan
Smooth transition antar mode input

2. YouTube Download Engine

yt-dlp integration untuk download video berkualitas tinggi
Smart quality selection (maksimal 720p untuk performa optimal di free tier)
URL validation untuk berbagai format YouTube URL
Metadata extraction (title, uploader, duration, views)

3. Supported URL Formats
✅ https://www.youtube.com/watch?v=VIDEO_ID
✅ https://youtu.be/VIDEO_ID
✅ https://www.youtube.com/embed/VIDEO_ID
✅ https://youtube.com/watch?v=VIDEO_ID
4. Smart Limitations untuk Free Tier

Maximum duration: 1 jam untuk YouTube videos
Quality limit: 720p maksimal untuk menghemat bandwidth
Error handling: Validasi URL dan penanganan error yang comprehensive
Progress tracking: Real-time status update

5. Enhanced User Experience

Clear instructions untuk setiap input method
Example URLs yang muncul saat memilih YouTube mode
Better status messages dengan informasi video yang diproses
Source tracking dalam clip analysis

app.py

@@ -14,6 +14,9 @@ import json
 import librosa
 from textblob import TextBlob
 import emoji
+import yt_dlp
+import requests
+from urllib.parse import urlparse, parse_qs
 
 class AIVideoClipper:
     def __init__(self):
@@ -50,7 +53,84 @@ class AIVideoClipper:
             r"wait for it"
         ]
 
-    def extract_audio_features(self, audio_path: str) -> Dict:
+    def download_youtube_video(self, url: str, temp_dir: str) -> Tuple[str, Dict]:
+        """Download YouTube video and return path + metadata"""
+        print(f"Downloading YouTube video: {url}")
+        
+        # Validate YouTube URL
+        if not self.is_valid_youtube_url(url):
+            raise ValueError("Invalid YouTube URL. Please provide a valid YouTube video link.")
+        
+        # Configure yt-dlp options for free tier optimization
+        ydl_opts = {
+            'format': 'best[height<=720][ext=mp4]/best[ext=mp4]/best',  # Limit to 720p for performance
+            'outtmpl': os.path.join(temp_dir, '%(title)s.%(ext)s'),
+            'noplaylist': True,
+            'extractaudio': False,
+            'audioformat': 'mp3',
+            'ignoreerrors': False,
+            'no_warnings': False,
+            'extract_flat': False,
+        }
+        
+        try:
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                # Extract info first
+                info = ydl.extract_info(url, download=False)
+                
+                # Check video duration (limit to 60 minutes for free tier)
+                duration = info.get('duration', 0)
+                if duration > 3600:  # 1 hour limit
+                    raise ValueError("Video too long. Please use videos shorter than 1 hour.")
+                
+                # Download the video
+                ydl.download([url])
+                
+                # Find the downloaded file
+                video_title = info.get('title', 'video')
+                video_ext = info.get('ext', 'mp4')
+                video_path = os.path.join(temp_dir, f"{video_title}.{video_ext}")
+                
+                # Sometimes yt-dlp changes the filename, so find the actual file
+                downloaded_files = [f for f in os.listdir(temp_dir) if f.endswith(('.mp4', '.mkv', '.webm'))]
+                if downloaded_files:
+                    video_path = os.path.join(temp_dir, downloaded_files[0])
+                
+                metadata = {
+                    'title': video_title,
+                    'duration': duration,
+                    'uploader': info.get('uploader', 'Unknown'),
+                    'view_count': info.get('view_count', 0),
+                    'upload_date': info.get('upload_date', 'Unknown')
+                }
+                
+                print(f"Successfully downloaded: {video_title}")
+                return video_path, metadata
+                
+        except Exception as e:
+            raise Exception(f"Failed to download YouTube video: {str(e)}")
+
+    def is_valid_youtube_url(self, url: str) -> bool:
+        """Check if URL is a valid YouTube URL"""
+        youtube_regex = re.compile(
+            r'(https?://)?(www\.)?(youtube|youtu|youtube-nocookie)\.(com|be)/'
+            r'(watch\?v=|embed/|v/|.+\?v=)?([^&=%\?]{11})'
+        )
+        return youtube_regex.match(url) is not None
+
+    def extract_video_id(self, url: str) -> str:
+        """Extract video ID from YouTube URL"""
+        patterns = [
+            r'(?:v=|\/)([0-9A-Za-z_-]{11}).*',
+            r'(?:embed\/)([0-9A-Za-z_-]{11})',
+            r'(?:v\/)([0-9A-Za-z_-]{11})'
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, url)
+            if match:
+                return match.group(1)
+        return None
         """Extract audio features for engagement analysis"""
         y, sr = librosa.load(audio_path)
         
@@ -282,17 +362,39 @@ class AIVideoClipper:
         
         return output_path
 
-def process_video(video_file, clip_duration, num_clips, add_subtitles):
+def process_video(input_type, video_file, youtube_url, clip_duration, num_clips, add_subtitles):
     """Main function to process video and create clips"""
-    if video_file is None:
-        return "Please upload a video file.", [], []
     
     clipper = AIVideoClipper()
     
     try:
         # Create temporary directory
         with tempfile.TemporaryDirectory() as temp_dir:
-            video_path = video_file.name
+            video_path = None
+            video_metadata = {}
+            
+            # Handle input based on type
+            if input_type == "Upload Video File":
+                if video_file is None:
+                    return "Please upload a video file.", [], []
+                video_path = video_file.name
+                video_metadata = {'title': 'Uploaded Video', 'source': 'upload'}
+                
+            elif input_type == "YouTube URL":
+                if not youtube_url or not youtube_url.strip():
+                    return "Please enter a YouTube URL.", [], []
+                
+                try:
+                    video_path, video_metadata = clipper.download_youtube_video(youtube_url.strip(), temp_dir)
+                    video_metadata['source'] = 'youtube'
+                except Exception as e:
+                    return f"Error downloading YouTube video: {str(e)}", [], []
+            
+            else:
+                return "Please select an input method.", [], []
+            
+            if not video_path or not os.path.exists(video_path):
+                return "Video file not found or invalid.", [], []
             
             # Extract audio features
             print("Extracting audio features...")
@@ -338,14 +440,15 @@ def process_video(video_file, clip_duration, num_clips, add_subtitles):
                         'end_time': f"{moment['end']:.1f}s",
                         'duration': f"{moment['duration']:.1f}s",
                         'virality_score': f"{moment['virality_score']:.2f}/10",
-                        'text_preview': moment['text'][:100] + "..." if len(moment['text']) > 100 else moment['text']
+                        'text_preview': moment['text'][:100] + "..." if len(moment['text']) > 100 else moment['text'],
+                        'source_video': video_metadata.get('title', 'Unknown')
                     })
                     
                 except Exception as e:
                     print(f"Error creating clip {i+1}: {str(e)}")
                     continue
             
-            success_msg = f"Successfully created {len(output_videos)} clips!"
+            success_msg = f"✅ Successfully created {len(output_videos)} clips from: {video_metadata.get('title', 'video')}"
             return success_msg, output_videos, clip_info
             
     except Exception as e:
@@ -359,7 +462,7 @@ def create_interface():
             # 🎬 AI Video Clipper
             
             Transform your long videos into viral short clips automatically! 
-            Upload your video and let AI find the most engaging moments.
+            Upload a video file or paste a YouTube URL and let AI find the most engaging moments.
             
             **Features:**
             - 🤖 AI-powered moment detection
@@ -367,15 +470,46 @@ def create_interface():
             - 📝 Automatic subtitles with emojis
             - 📊 Virality scoring
             - 🎯 Multi-language support
+            - 🔗 YouTube video download support
             """
         )
         
         with gr.Row():
             with gr.Column():
+                # Input method selection
+                input_type = gr.Radio(
+                    choices=["Upload Video File", "YouTube URL"],
+                    value="Upload Video File",
+                    label="Choose Input Method",
+                    interactive=True
+                )
+                
+                # Video file upload (conditional)
                 video_input = gr.File(
-                    label="Upload Video",
+                    label="Upload Video File",
                     file_types=[".mp4", ".avi", ".mov", ".mkv", ".webm"],
-                    type="filepath"
+                    type="filepath",
+                    visible=True
+                )
+                
+                # YouTube URL input (conditional)
+                youtube_input = gr.Textbox(
+                    label="YouTube URL",
+                    placeholder="https://www.youtube.com/watch?v=...",
+                    visible=False,
+                    info="Paste any YouTube video URL (supports various formats)"
+                )
+                
+                # Show example URLs
+                gr.Markdown(
+                    """
+                    **Supported URL formats:**
+                    - `https://www.youtube.com/watch?v=VIDEO_ID`
+                    - `https://youtu.be/VIDEO_ID`
+                    - `https://www.youtube.com/embed/VIDEO_ID`
+                    """,
+                    visible=False,
+                    elem_id="url_examples"
                 )
                 
                 with gr.Row():
@@ -410,7 +544,7 @@ def create_interface():
                 status_output = gr.Textbox(
                     label="Status",
                     interactive=False,
-                    lines=2
+                    lines=3
                 )
                 
                 clips_output = gr.Gallery(
@@ -430,18 +564,51 @@ def create_interface():
                 visible=True
             )
         
+        # Dynamic input visibility
+        def update_input_visibility(choice):
+            if choice == "Upload Video File":
+                return (
+                    gr.update(visible=True),   # video_input
+                    gr.update(visible=False),  # youtube_input  
+                    gr.update(visible=False)   # url_examples
+                )
+            else:  # YouTube URL
+                return (
+                    gr.update(visible=False),  # video_input
+                    gr.update(visible=True),   # youtube_input
+                    gr.update(visible=True)    # url_examples
+                )
+        
+        input_type.change(
+            update_input_visibility,
+            inputs=[input_type],
+            outputs=[video_input, youtube_input, gr.Markdown(elem_id="url_examples")]
+        )
+        
         # Example videos section
         gr.Markdown("### 📺 Tips for Best Results:")
         gr.Markdown("""
+        **📁 File Upload:**
         - Upload videos with clear speech (podcasts, interviews, tutorials work great!)
+        - Supported formats: MP4, AVI, MOV, MKV, WebM
+        - Maximum recommended duration: 2 hours
+        
+        **🔗 YouTube Videos:**
+        - Any public YouTube video (no age restrictions)
+        - Automatically downloads in optimal quality (720p max for performance)
+        - Works with livestreams, premieres, and regular videos
+        - Maximum duration: 1 hour for free tier
+        
+        **🎯 Content Tips:**
         - Longer videos (5+ minutes) provide more clip opportunities
         - Videos with engaging content and emotional moments score higher
         - Good audio quality improves transcription accuracy
+        - Educational content, podcasts, and interviews work exceptionally well
         """)
         
         process_btn.click(
             process_video,
-            inputs=[video_input, clip_duration, num_clips, add_subtitles],
+            inputs=[input_type, video_input, youtube_input, clip_duration, num_clips, add_subtitles],
             outputs=[status_output, clips_output, info_output]
         )