Update app.py

app.py

@@ -10,25 +10,36 @@ import json
 from datetime import datetime
 import google.generativeai as genai
 
-# Configure Gemini
-genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
-model = genai.GenerativeModel(model_name="gemini-1.5-flash-latest")
-
 class YouTubeDownloader:
     def __init__(self):
         self.download_dir = tempfile.mkdtemp()
+        # Use temp directory for Gradio compatibility
         self.temp_downloads = tempfile.mkdtemp(prefix="youtube_downloads_")
+        # Also create user downloads folder for copying
         self.downloads_folder = os.path.join(os.path.expanduser("~"), "Downloads", "YouTube_Downloads")
         os.makedirs(self.downloads_folder, exist_ok=True)
-
+        self.gemini_model = None
+    
+    def configure_gemini(self, api_key):
+        """Configure Gemini API with the provided key"""
+        try:
+            genai.configure(api_key=api_key)
+            self.gemini_model = genai.GenerativeModel(model_name="gemini-1.5-flash-latest")
+            return True, "✅ Gemini API configured successfully!"
+        except Exception as e:
+            return False, f"❌ Failed to configure Gemini API: {str(e)}"
+    
     def cleanup(self):
+        """Clean up temporary directories and files"""
         try:
             if hasattr(self, 'download_dir') and os.path.exists(self.download_dir):
                 shutil.rmtree(self.download_dir)
+                print(f"✅ Cleaned up temporary directory: {self.download_dir}")
             if hasattr(self, 'temp_downloads') and os.path.exists(self.temp_downloads):
                 shutil.rmtree(self.temp_downloads)
+                print(f"✅ Cleaned up temp downloads directory: {self.temp_downloads}")
         except Exception as e:
-            print(f"⚠️ Cleanup error: {e}")
+            print(f"⚠️ Warning: Could not clean up temporary directory: {e}")
 
     def is_valid_youtube_url(self, url):
         youtube_regex = re.compile(
@@ -38,50 +49,166 @@ class YouTubeDownloader:
         return youtube_regex.match(url) is not None
 
     def generate_scene_breakdown_gemini(self, video_info):
-        title = video_info.get("title", "")
-        description = video_info.get("description", "")
-        duration = video_info.get("duration", 0)
+        """Generate AI-powered scene breakdown using Gemini"""
+        if not self.gemini_model:
+            return self.generate_scene_breakdown_fallback(video_info)
+        
+        try:
+            duration = video_info.get('duration', 0)
+            title = video_info.get('title', '')
+            description = video_info.get('description', '')[:1000]  # Limit description length
+            
+            if not duration:
+                return ["**[Duration Unknown]**: Unable to generate timestamped breakdown - video duration not available"]
+            
+            # Create prompt for Gemini
+            prompt = f"""
+            Analyze this YouTube video and create a detailed scene-by-scene breakdown with timestamps:
+            
+            Title: {title}
+            Duration: {duration} seconds
+            Description: {description}
+            
+            Please provide a scene breakdown with the following format:
+            - Divide the video into logical segments based on typical content flow
+            - For videos under 2 minutes: 10-15 second segments
+            - For videos 2-10 minutes: 30-45 second segments  
+            - For videos over 10 minutes: 60-90 second segments
+            - Maximum 15 scenes total
+            
+            For each scene, provide:
+            **[START_TIME-END_TIME]**: Detailed description of what likely happens in this segment, including visual elements, audio cues, potential dialogue or narration, and scene transitions.
+            
+            Consider the video type (tutorial, music video, vlog, etc.) and provide contextually appropriate descriptions.
+            Format timestamps as MM:SS.
+            """
+            
+            response = self.gemini_model.generate_content(prompt)
+            
+            # Parse the response into individual scenes
+            if response and response.text:
+                scenes = []
+                lines = response.text.split('\n')
+                for line in lines:
+                    line = line.strip()
+                    if line and ('**[' in line or line.startswith('*')):
+                        scenes.append(line)
+                
+                return scenes if scenes else self.generate_scene_breakdown_fallback(video_info)
+            else:
+                return self.generate_scene_breakdown_fallback(video_info)
+                
+        except Exception as e:
+            print(f"Gemini API error: {e}")
+            return self.generate_scene_breakdown_fallback(video_info)
 
+    def generate_scene_breakdown_fallback(self, video_info):
+        """Fallback scene generation when Gemini is not available"""
+        duration = video_info.get('duration', 0)
+        title = video_info.get('title', '').lower()
+        
         if not duration:
-            return ["[Duration Unknown]: Unable to generate scene breakdown."]
-
-        prompt = f"""
-You are a scene breakdown expert. Based on the following video metadata, generate a detailed scene-by-scene breakdown using timestamps.
-Each scene should be 5–15 seconds long (estimate). Format should be:
-
-* **[0:00-0:10]:** A woman opens the door and looks outside.
-
-Use storytelling tone and avoid brand/product mentions. Do not invent company names.
-
-Video Title: {title}
-Description: {description}
-Duration (in seconds): {duration}
+            return ["**[Duration Unknown]**: Unable to generate timestamped breakdown"]
+        
+        # Simple fallback logic
+        if duration <= 120:
+            segment_length = 15
+        elif duration <= 600:
+            segment_length = 45
+        else:
+            segment_length = 90
+            
+        scenes = []
+        num_segments = min(duration // segment_length + 1, 15)
+        
+        for i in range(num_segments):
+            start_time = i * segment_length
+            end_time = min(start_time + segment_length - 1, duration)
+            
+            start_formatted = f"{start_time//60}:{start_time%60:02d}"
+            end_formatted = f"{end_time//60}:{end_time%60:02d}"
+            
+            if i == 0:
+                desc = "Opening sequence with introduction and setup"
+            elif i == num_segments - 1:
+                desc = "Conclusion with final thoughts and call-to-action"
+            else:
+                desc = f"Main content segment {i} with key information and details"
+            
+            scenes.append(f"**[{start_formatted}-{end_formatted}]**: {desc}")
+        
+        return scenes
 
-Now generate the scene breakdown:
-"""
+    def detect_video_type(self, title, description):
+        """Detect video type based on title and description"""
+        text = (title + " " + description).lower()
+        
+        if any(word in text for word in ['music', 'song', 'album', 'artist', 'band', 'lyrics']):
+            return "🎵 Music Video"
+        elif any(word in text for word in ['tutorial', 'how to', 'guide', 'learn', 'teaching']):
+            return "📚 Tutorial/Educational"
+        elif any(word in text for word in ['funny', 'comedy', 'entertainment', 'vlog', 'challenge']):
+            return "🎭 Entertainment/Comedy"
+        elif any(word in text for word in ['news', 'breaking', 'report', 'update']):
+            return "📰 News/Information"
+        elif any(word in text for word in ['review', 'unboxing', 'test', 'comparison']):
+            return "⭐ Review/Unboxing"
+        elif any(word in text for word in ['commercial', 'ad', 'brand', 'product']):
+            return "📺 Commercial/Advertisement"
+        else:
+            return "🎬 General Content"
 
-        try:
-            response = model.generate_content(prompt)
-            if response.text:
-                return response.text.strip().split("\n")
-            else:
-                return ["[Error]: Gemini response was empty."]
-        except Exception as e:
-            return [f"[Error generating scenes with Gemini]: {str(e)}"]
+    def detect_background_music(self, video_info):
+        """Detect background music style"""
+        title = video_info.get('title', '').lower()
+        description = video_info.get('description', '').lower()
+        
+        if any(word in title for word in ['music', 'song', 'soundtrack']):
+            return "🎵 Original Music/Soundtrack - Primary audio content"
+        elif any(word in title for word in ['commercial', 'ad', 'brand']):
+            return "🎶 Upbeat Commercial Music - Designed to enhance brand appeal"
+        elif any(word in title for word in ['tutorial', 'how to', 'guide']):
+            return "🔇 Minimal/No Background Music - Focus on instruction"
+        elif any(word in title for word in ['vlog', 'daily', 'life']):
+            return "🎼 Ambient Background Music - Complementary to narration"
+        else:
+            return "🎵 Background Music - Complementing video mood and pacing"
 
-    def get_video_info(self, url):
-        if not self.is_valid_youtube_url(url):
-            return None, "❌ Invalid YouTube URL"
+    def detect_influencer_status(self, video_info):
+        """Detect influencer status"""
+        subscriber_count = video_info.get('channel_followers', 0)
+        view_count = video_info.get('view_count', 0)
+        
+        if subscriber_count > 10000000:
+            return "🌟 Mega Influencer (10M+ subscribers)"
+        elif subscriber_count > 1000000:
+            return "⭐ Major Influencer (1M+ subscribers)"
+        elif subscriber_count > 100000:
+            return "🎯 Mid-tier Influencer (100K+ subscribers)"
+        elif subscriber_count > 10000:
+            return "📈 Micro Influencer (10K+ subscribers)"
+        elif view_count > 100000:
+            return "🔥 Viral Content Creator"
+        else:
+            return "👤 Regular Content Creator"
 
-        try:
-            ydl_opts = {'noplaylist': True, 'extract_flat': False}
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                info = ydl.extract_info(url, download=False)
-            return info, "✅ Video information extracted"
-        except Exception as e:
-            return None, f"❌ Error: {str(e)}"
+    def format_number(self, num):
+        if num is None or num == 0:
+            return "0"
+        if num >= 1_000_000_000:
+            return f"{num/1_000_000_000:.1f}B"
+        elif num >= 1_000_000:
+            return f"{num/1_000_000:.1f}M"
+        elif num >= 1_000:
+            return f"{num/1_000:.1f}K"
+        return str(num)
 
     def format_video_info(self, video_info):
+        """Streamlined video information formatting"""
+        if not video_info:
+            return "❌ No video information available."
+
+        # Basic information
         title = video_info.get("title", "Unknown")
         uploader = video_info.get("uploader", "Unknown")
         duration = video_info.get("duration", 0)
@@ -90,48 +217,386 @@ Now generate the scene breakdown:
         like_count = video_info.get("like_count", 0)
         comment_count = video_info.get("comment_count", 0)
         upload_date = video_info.get("upload_date", "Unknown")
-        formatted_date = f"{upload_date[:4]}-{upload_date[4:6]}-{upload_date[6:]}" if len(upload_date) == 8 else "Unknown"
+        
+        # Format upload date
+        if len(upload_date) == 8:
+            formatted_date = f"{upload_date[:4]}-{upload_date[4:6]}-{upload_date[6:8]}"
+        else:
+            formatted_date = upload_date
 
+        # Generate enhanced analysis
         scene_descriptions = self.generate_scene_breakdown_gemini(video_info)
+        video_type = self.detect_video_type(title, video_info.get('description', ''))
+        background_music = self.detect_background_music(video_info)
+        influencer_status = self.detect_influencer_status(video_info)
+        
+        # Calculate engagement metrics
+        engagement_rate = (like_count / view_count) * 100 if view_count > 0 else 0
+        
+        # Generate streamlined report
+        report = f"""
+🎬 YOUTUBE VIDEO ANALYSIS REPORT
+{'='*50}
 
-        def fmt(n):
-            if not n: return "0"
-            if n > 1_000_000: return f"{n/1_000_000:.1f}M"
-            if n > 1_000: return f"{n/1_000:.1f}K"
-            return str(n)
-
-        summary = f"""
 📋 BASIC INFORMATION
-{'─'*30}
-📹 Title: {title}
-👤 Uploader: {uploader}
-📅 Upload Date: {formatted_date}
-⏱️ Duration: {duration_str}
-👀 Views: {fmt(view_count)}
-👍 Likes: {fmt(like_count)}
-💬 Comments: {fmt(comment_count)}
-
-🎬 SCENE-BY-SCENE BREAKDOWN
+{'─'*25}
+📹 **Title:** {title}
+👤 **Uploader:** {uploader}
+📅 **Upload Date:** {formatted_date}
+⏱️ **Duration:** {duration_str}
+🆔 **Video ID:** {video_info.get('id', 'Unknown')}
+
+📊 PERFORMANCE METRICS
+{'─'*25}
+👀 **Views:** {self.format_number(view_count)} ({view_count:,})
+👍 **Likes:** {self.format_number(like_count)} ({like_count:,})
+💬 **Comments:** {self.format_number(comment_count)} ({comment_count:,})
+📈 **Engagement Rate:** {engagement_rate:.2f}%
+
+🎯 CONTENT ANALYSIS
+{'─'*25}
+📂 **Video Type:** {video_type}
+🎵 **Background Music:** {background_music}
+👑 **Creator Status:** {influencer_status}
+
+🎬 DETAILED SCENE BREAKDOWN
 {'─'*30}
 {chr(10).join(scene_descriptions)}
+
+📝 DESCRIPTION PREVIEW
+{'─'*25}
+{video_info.get('description', 'No description available')[:500]}
+{'...(truncated)' if len(video_info.get('description', '')) > 500 else ''}
+
+{'='*50}
+📊 **Analysis completed:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+🤖 **AI Enhancement:** {'Gemini AI' if self.gemini_model else 'Standard Analysis'}
 """
-        return summary
+        
+        return report.strip()
 
+    def get_video_info(self, url, progress=gr.Progress(), cookiefile=None):
+        """Extract video information"""
+        if not url or not url.strip():
+            return None, "❌ Please enter a YouTube URL"
+        
+        if not self.is_valid_youtube_url(url):
+            return None, "❌ Invalid YouTube URL format"
+        
+        try:
+            progress(0.1, desc="Initializing YouTube extractor...")
+            
+            ydl_opts = {
+                'noplaylist': True,
+                'extract_flat': False,
+            }
+            
+            if cookiefile and os.path.exists(cookiefile):
+                ydl_opts['cookiefile'] = cookiefile
+            
+            progress(0.5, desc="Extracting video metadata...")
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(url, download=False)
+                
+            progress(1.0, desc="✅ Analysis complete!")
+            
+            return info, "✅ Video information extracted successfully"
+            
+        except Exception as e:
+            return None, f"❌ Error: {str(e)}"
+
+    def download_video(self, url, quality="best", audio_only=False, progress=gr.Progress(), cookiefile=None):
+        """Download video with progress tracking"""
+        if not url or not url.strip():
+            return None, "❌ Please enter a YouTube URL"
+        
+        if not self.is_valid_youtube_url(url):
+            return None, "❌ Invalid YouTube URL format"
+        
+        try:
+            progress(0.1, desc="Preparing download...")
+            
+            # Create unique filename
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            
+            # Download to temp directory first (Gradio compatible)
+            ydl_opts = {
+                'outtmpl': os.path.join(self.temp_downloads, f'%(title)s_{timestamp}.%(ext)s'),
+                'noplaylist': True,
+            }
+            
+            if audio_only:
+                ydl_opts['format'] = 'bestaudio/best'
+                ydl_opts['postprocessors'] = [{
+                    'key': 'FFmpegExtractAudio',
+                    'preferredcodec': 'mp3',
+                    'preferredquality': '192',
+                }]
+            else:
+                if quality == "best":
+                    ydl_opts['format'] = 'best[height<=1080]'
+                elif quality == "720p":
+                    ydl_opts['format'] = 'best[height<=720]'
+                elif quality == "480p":
+                    ydl_opts['format'] = 'best[height<=480]'
+                else:
+                    ydl_opts['format'] = 'best'
+            
+            if cookiefile and os.path.exists(cookiefile):
+                ydl_opts['cookiefile'] = cookiefile
+            
+            # Progress hook
+            def progress_hook(d):
+                if d['status'] == 'downloading':
+                    if 'total_bytes' in d:
+                        percent = (d['downloaded_bytes'] / d['total_bytes']) * 100
+                        progress(0.1 + (percent / 100) * 0.7, desc=f"Downloading... {percent:.1f}%")
+                    else:
+                        progress(0.5, desc="Downloading...")
+                elif d['status'] == 'finished':
+                    progress(0.8, desc="Processing download...")
+            
+            ydl_opts['progress_hooks'] = [progress_hook]
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(url, download=True)
+                
+            progress(0.9, desc="Copying to Downloads folder...")
+            
+            # Find the downloaded file in temp directory
+            downloaded_file_temp = None
+            
+            for file in os.listdir(self.temp_downloads):
+                if timestamp in file:
+                    downloaded_file_temp = os.path.join(self.temp_downloads, file)
+                    break
+            
+            if not downloaded_file_temp:
+                return None, "❌ Downloaded file not found in temp directory"
+            
+            # Copy to user's Downloads folder
+            final_filename = os.path.basename(downloaded_file_temp)
+            final_path = os.path.join(self.downloads_folder, final_filename)
+            
+            try:
+                shutil.copy2(downloaded_file_temp, final_path)
+                copy_success = True
+            except Exception as e:
+                print(f"Warning: Could not copy to Downloads folder: {e}")
+                copy_success = False
+                final_path = "File downloaded to temp location only"
+            
+            progress(1.0, desc="✅ Download complete!")
+            
+            success_msg = f"""✅ Download successful!
+📁 Temp file (for download): {os.path.basename(downloaded_file_temp)}
+📁 Permanent location: {final_path if copy_success else 'Copy failed'}
+🎯 File size: {os.path.getsize(downloaded_file_temp) / (1024*1024):.1f} MB"""
+            
+            return downloaded_file_temp, success_msg
+            
+        except Exception as e:
+            return None, f"❌ Download failed: {str(e)}"
+
+# Initialize global downloader
 downloader = YouTubeDownloader()
 
-def analyze_video(url):
-    info, msg = downloader.get_video_info(url)
-    if not info:
-        return msg
-    return downloader.format_video_info(info)
+def configure_api_key(api_key):
+    """Configure Gemini API key"""
+    if not api_key or not api_key.strip():
+        return "❌ Please enter a valid Google API key", gr.update(visible=False)
+    
+    success, message = downloader.configure_gemini(api_key.strip())
+    
+    if success:
+        return message, gr.update(visible=True)
+    else:
+        return message, gr.update(visible=False)
+
+def analyze_with_cookies(url, cookies_file, progress=gr.Progress()):
+    """Main analysis function"""
+    try:
+        progress(0.05, desc="Starting analysis...")
+        
+        cookiefile = None
+        if cookies_file and os.path.exists(cookies_file):
+            cookiefile = cookies_file
+        
+        info, msg = downloader.get_video_info(url, progress=progress, cookiefile=cookiefile)
+        
+        if info:
+            progress(0.95, desc="Generating comprehensive report...")
+            formatted_info = downloader.format_video_info(info)
+            progress(1.0, desc="✅ Complete!")
+            return formatted_info
+        else:
+            return f"❌ Analysis Failed: {msg}"
+            
+    except Exception as e:
+        return f"❌ System Error: {str(e)}"
 
-iface = gr.Interface(
-    fn=analyze_video,
-    inputs=gr.Textbox(label="YouTube URL"),
-    outputs=gr.Textbox(label="Gemini-Generated Scene Breakdown", lines=30, show_copy_button=True),
-    title="🎬 Gemini Scene Breakdown",
-    description="Generates scene-by-scene descriptions using Gemini Flash based on video metadata"
-)
+def download_with_cookies(url, quality, audio_only, cookies_file, progress=gr.Progress()):
+    """Main download function"""
+    try:
+        progress(0.05, desc="Preparing download...")
+        
+        cookiefile = None
+        if cookies_file and os.path.exists(cookies_file):
+            cookiefile = cookies_file
+        
+        file_path, msg = downloader.download_video(url, quality, audio_only, progress=progress, cookiefile=cookiefile)
+        
+        if file_path:
+            return file_path, msg
+        else:
+            return None, msg
+            
+    except Exception as e:
+        return None, f"❌ System Error: {str(e)}"
+
+def create_interface():
+    """Create and configure the Gradio interface"""
+    with gr.Blocks(theme=gr.themes.Soft(), title="🎥 YouTube Video Analyzer & Downloader Pro") as interface:
+        
+        gr.HTML("<h1>🎥 YouTube Video Analyzer & Downloader Pro</h1>")
+        
+        # API Key Configuration Section
+        with gr.Group():
+            gr.HTML("<h3>🔑 Google Gemini API Configuration</h3>")
+            with gr.Row():
+                api_key_input = gr.Textbox(
+                    label="🔑 Google API Key",
+                    placeholder="Enter your Google API Key for enhanced AI analysis...",
+                    type="password",
+                    value=""
+                )
+                configure_btn = gr.Button("🔧 Configure API", variant="secondary")
+            
+            api_status = gr.Textbox(
+                label="API Status",
+                value="❌ Gemini API not configured - Using fallback analysis",
+                interactive=False,
+                lines=1
+            )
+        
+        # Main Interface (initially hidden until API is configured)
+        main_interface = gr.Group(visible=False)
+        
+        with main_interface:
+            with gr.Row():
+                url_input = gr.Textbox(
+                    label="🔗 YouTube URL",
+                    placeholder="Paste your YouTube video URL here...",
+                    value=""
+                )
+                
+                cookies_input = gr.File(
+                    label="🍪 Upload cookies.txt (Optional)",
+                    file_types=[".txt"],
+                    type="filepath"
+                )
+            
+            with gr.Tabs():
+                with gr.TabItem("📊 Video Analysis"):
+                    analyze_btn = gr.Button("🔍 Analyze Video", variant="primary")
+                    
+                    analysis_output = gr.Textbox(
+                        label="📊 Analysis Report",
+                        lines=25,
+                        show_copy_button=True
+                    )
+                    
+                    analyze_btn.click(
+                        fn=analyze_with_cookies,
+                        inputs=[url_input, cookies_input],
+                        outputs=analysis_output,
+                        show_progress=True
+                    )
+                
+                with gr.TabItem("⬇️ Video Download"):
+                    with gr.Row():
+                        quality_dropdown = gr.Dropdown(
+                            choices=["best", "720p", "480p"],
+                            value="best",
+                            label="📺 Video Quality"
+                        )
+                        
+                        audio_only_checkbox = gr.Checkbox(
+                            label="🎵 Audio Only (MP3)",
+                            value=False
+                        )
+                    
+                    download_btn = gr.Button("⬇️ Download Video", variant="primary")
+                    
+                    download_status = gr.Textbox(
+                        label="📥 Download Status",
+                        lines=5,
+                        show_copy_button=True
+                    )
+                    
+                    download_file = gr.File(
+                        label="📁 Downloaded File",
+                        visible=False
+                    )
+                    
+                    def download_and_update(url, quality, audio_only, cookies_file, progress=gr.Progress()):
+                        file_path, status = download_with_cookies(url, quality, audio_only, cookies_file, progress)
+                        if file_path and os.path.exists(file_path):
+                            return status, gr.update(value=file_path, visible=True)
+                        else:
+                            return status, gr.update(visible=False)
+                    
+                    download_btn.click(
+                        fn=download_and_update,
+                        inputs=[url_input, quality_dropdown, audio_only_checkbox, cookies_input],
+                        outputs=[download_status, download_file],
+                        show_progress=True
+                    )
+        
+        # Configure API key button action
+        configure_btn.click(
+            fn=configure_api_key,
+            inputs=[api_key_input],
+            outputs=[api_status, main_interface]
+        )
+        
+        # Always show interface option (for fallback mode)
+        with gr.Row():
+            show_interface_btn = gr.Button("🚀 Use Without Gemini API (Fallback Mode)", variant="secondary")
+            
+            def show_fallback_interface():
+                return "⚠️ Using fallback analysis mode", gr.update(visible=True)
+            
+            show_interface_btn.click(
+                fn=show_fallback_interface,
+                outputs=[api_status, main_interface]
+            )
+        
+        gr.HTML("""
+        <div style="margin-top: 20px; padding: 15px; background-color: #f0f8ff; border-radius: 10px; border-left: 5px solid #4285f4;">
+            <h3>🔑 How to Get Google API Key:</h3>
+            <ol>
+                <li>Go to <a href="https://console.cloud.google.com/" target="_blank">Google Cloud Console</a></li>
+                <li>Create a new project or select an existing one</li>
+                <li>Enable the "Generative Language API"</li>
+                <li>Go to "Credentials" and create an API key</li>
+                <li>Copy the API key and paste it above</li>
+            </ol>
+            <p><strong>✨ Benefits of using Gemini API:</strong></p>
+            <ul>
+                <li>🤖 AI-powered scene descriptions with contextual understanding</li>
+                <li>🎯 More accurate content type detection</li>
+                <li>📊 Enhanced analysis based on video content</li>
+                <li>⏰ Intelligent timestamp segmentation</li>
+            </ul>
+        </div>
+        """)
+    
+    return interface
 
 if __name__ == "__main__":
-    iface.launch(debug=True)
+    demo = create_interface()
+    import atexit
+    atexit.register(downloader.cleanup)
+    demo.launch(debug=True, show_error=True)