Update app.py from anycoder

app.py

@@ -1,396 +1,409 @@
 import gradio as gr
-import os
 import subprocess
-import tempfile
+import os
 from pathlib import Path
-import mimetypes
-import uuid
-
-# Define supported formats
-SUPPORTED_AUDIO_FORMATS = ['mp3', 'wav', 'ogg', 'flac', 'aac', 'm4a']
-SUPPORTED_VIDEO_FORMATS = ['mp4', 'avi', 'mov', 'mkv', 'webm', 'flv']
-SUPPORTED_IMAGE_FORMATS = ['jpg', 'jpeg', 'png', 'webp', 'bmp', 'gif', 'tiff']
-SUPPORTED_DOCUMENT_FORMATS = ['pdf', 'docx', 'txt', 'rtf', 'html']
-
-# Combined supported formats
-SUPPORTED_FORMATS = {
-    'Audio': SUPPORTED_AUDIO_FORMATS,
-    'Video': SUPPORTED_VIDEO_FORMATS,
-    'Image': SUPPORTED_IMAGE_FORMATS,
-    'Document': SUPPORTED_DOCUMENT_FORMATS
-}
-
-def detect_file_type(file_path):
-    """Detect file type based on extension and mime type"""
-    ext = Path(file_path).suffix.lower()[1:]
-    mime_type, _ = mimetypes.guess_type(file_path)
-
-    if ext in SUPPORTED_AUDIO_FORMATS:
-        return 'Audio'
-    elif ext in SUPPORTED_VIDEO_FORMATS:
-        return 'Video'
-    elif ext in SUPPORTED_IMAGE_FORMATS:
-        return 'Image'
-    elif ext in SUPPORTED_DOCUMENT_FORMATS:
-        return 'Document'
-    elif mime_type and mime_type.startswith('audio/'):
-        return 'Audio'
-    elif mime_type and mime_type.startswith('video/'):
-        return 'Video'
-    elif mime_type and mime_type.startswith('image/'):
-        return 'Image'
-    elif mime_type and mime_type.startswith('text/'):
-        return 'Document'
-    else:
-        return 'Unknown'
-
-def convert_media(input_file, output_format, media_type):
-    """Convert media file using FFmpeg for audio/video and ImageMagick for images"""
+import tempfile
+import shutil
+
+# Comprehensive format support
+VIDEO_FORMATS = [
+    "mp4", "avi", "mkv", "mov", "wmv", "flv", "webm", "m4v", "mpg", "mpeg",
+    "3gp", "ogv", "ts", "vob", "divx", "f4v", "asf", "rm", "rmvb"
+]
+
+AUDIO_FORMATS = [
+    "mp3", "wav", "aac", "flac", "ogg", "m4a", "wma", "opus", "aiff",
+    "alac", "ape", "ac3", "dts", "amr", "mka", "tta", "wv"
+]
+
+IMAGE_FORMATS = [
+    "jpg", "jpeg", "png", "gif", "bmp", "tiff", "tif", "webp", "svg",
+    "ico", "heic", "heif", "raw", "cr2", "nef", "psd", "eps"
+]
+
+DOCUMENT_FORMATS = [
+    "pdf", "txt", "doc", "docx", "rtf", "odt", "html", "md"
+]
+
+ALL_FORMATS = sorted(set(VIDEO_FORMATS + AUDIO_FORMATS + IMAGE_FORMATS + DOCUMENT_FORMATS))
+
+def get_file_info(file_path):
+    """Get detailed information about the uploaded file."""
+    if not file_path:
+        return "No file uploaded"
+    
+    file_size = os.path.getsize(file_path)
+    file_ext = Path(file_path).suffix.lower().replace(".", "")
+    
+    size_mb = file_size / (1024 * 1024)
+    
+    info = f"""
+📁 **File Information**
+- **Name:** {Path(file_path).name}
+- **Format:** {file_ext.upper()}
+- **Size:** {size_mb:.2f} MB
+- **Path:** {file_path}
+"""
+    
+    # Try to get media info using ffprobe
     try:
-        # Create temp directory
-        with tempfile.TemporaryDirectory() as temp_dir:
-            input_path = os.path.join(temp_dir, f"input_{uuid.uuid4().hex}")
-            output_path = os.path.join(temp_dir, f"output_{uuid.uuid4().hex}.{output_format}")
-
-            # Save input file
-            with open(input_path, 'wb') as f:
-                f.write(input_file)
-
-            # Convert based on media type
-            if media_type == 'Audio':
-                cmd = [
-                    'ffmpeg', '-y', '-i', input_path,
-                    '-vn', '-acodec', 'libmp3lame' if output_format == 'mp3' else 'aac',
-                    '-q:a', '2', output_path
-                ]
-            elif media_type == 'Video':
-                cmd = [
-                    'ffmpeg', '-y', '-i', input_path,
-                    '-c:v', 'libx264', '-crf', '23',
-                    '-c:a', 'aac', '-b:a', '128k',
-                    output_path
-                ]
-            elif media_type == 'Image':
-                cmd = [
-                    'convert', input_path, output_path
-                ]
-            elif media_type == 'Document':
-                if output_format == 'pdf':
-                    cmd = [
-                        'libreoffice', '--headless', '--convert-to', 'pdf',
-                        '--outdir', temp_dir, input_path
-                    ]
-                    output_path = input_path.replace('.docx', '.pdf')
-                else:
-                    # Simple text conversion
-                    with open(input_path, 'r') as f:
-                        content = f.read()
-                    with open(output_path, 'w') as f:
-                        f.write(content)
-                    return output_path
-
-            # Execute conversion
-            result = subprocess.run(cmd, capture_output=True, text=True)
-
-            if result.returncode != 0:
-                raise Exception(f"Conversion failed: {result.stderr}")
-
-            # Read output file
-            with open(output_path, 'rb') as f:
-                output_data = f.read()
-
-            return output_data
-
-    except Exception as e:
-        raise Exception(f"Conversion error: {str(e)}")
-
-def process_conversion(input_file, output_format):
-    """Main conversion function"""
+        result = subprocess.run(
+            ["ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", file_path],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        if result.returncode == 0:
+            import json
+            data = json.loads(result.stdout)
+            if "format" in data:
+                duration = data["format"].get("duration", "N/A")
+                if duration != "N/A":
+                    info += f"\n- **Duration:** {float(duration):.2f} seconds"
+            if "streams" in data:
+                for stream in data["streams"]:
+                    if stream["codec_type"] == "video":
+                        info += f"\n- **Video Codec:** {stream.get('codec_name', 'N/A')}"
+                        info += f"\n- **Resolution:** {stream.get('width', 'N/A')}x{stream.get('height', 'N/A')}"
+                    elif stream["codec_type"] == "audio":
+                        info += f"\n- **Audio Codec:** {stream.get('codec_name', 'N/A')}"
+                        info += f"\n- **Sample Rate:** {stream.get('sample_rate', 'N/A')} Hz"
+    except:
+        pass
+    
+    return info
+
+def convert_media(input_file, output_format, quality="high", resolution=None):
+    """
+    Convert media file to specified format.
+    
+    Args:
+        input_file: Path to input file
+        output_format: Desired output format
+        quality: Quality setting (high, medium, low)
+        resolution: Optional resolution for video (e.g., "1920x1080")
+    """
+    if not input_file:
+        raise gr.Error("❌ Please upload a file first!")
+    
+    if not output_format:
+        raise gr.Error("❌ Please select an output format!")
+    
+    # Create temporary output file
+    output_file = tempfile.NamedTemporaryFile(
+        delete=False,
+        suffix=f".{output_format}"
+    ).name
+    
     try:
-        # Create temp file to detect type
-        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
-            temp_path = temp_file.name
-            temp_file.write(input_file)
-
-        # Detect media type
-        media_type = detect_file_type(temp_path)
+        # Build ffmpeg command based on format and quality
+        cmd = ["ffmpeg", "-i", input_file, "-y"]
+        
+        # Quality settings
+        if quality == "high":
+            if output_format in VIDEO_FORMATS:
+                cmd.extend(["-crf", "18", "-preset", "slow"])
+            elif output_format in AUDIO_FORMATS:
+                cmd.extend(["-b:a", "320k"])
+        elif quality == "medium":
+            if output_format in VIDEO_FORMATS:
+                cmd.extend(["-crf", "23", "-preset", "medium"])
+            elif output_format in AUDIO_FORMATS:
+                cmd.extend(["-b:a", "192k"])
+        else:  # low
+            if output_format in VIDEO_FORMATS:
+                cmd.extend(["-crf", "28", "-preset", "fast"])
+            elif output_format in AUDIO_FORMATS:
+                cmd.extend(["-b:a", "128k"])
+        
+        # Resolution settings for video
+        if resolution and output_format in VIDEO_FORMATS:
+            cmd.extend(["-s", resolution])
+        
+        # Format-specific settings
+        if output_format == "mp3":
+            cmd.extend(["-codec:a", "libmp3lame"])
+        elif output_format == "aac":
+            cmd.extend(["-codec:a", "aac"])
+        elif output_format == "flac":
+            cmd.extend(["-codec:a", "flac"])
+        elif output_format == "opus":
+            cmd.extend(["-codec:a", "libopus"])
+        elif output_format == "webm":
+            cmd.extend(["-codec:v", "libvpx-vp9", "-codec:a", "libopus"])
+        elif output_format == "mp4":
+            cmd.extend(["-codec:v", "libx264", "-codec:a", "aac"])
+        
+        cmd.append(output_file)
+        
+        # Execute conversion
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=300  # 5 minute timeout
+        )
+        
+        if result.returncode != 0:
+            raise Exception(f"Conversion failed: {result.stderr}")
+        
+        # Verify output file exists and has content
+        if not os.path.exists(output_file) or os.path.getsize(output_file) == 0:
+            raise Exception("Conversion produced empty file")
+        
+        return output_file, f"✅ **Conversion Successful!**\n\nConverted to **{output_format.upper()}** format with **{quality}** quality."
+    
+    except subprocess.TimeoutExpired:
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+        raise gr.Error("⏱️ Conversion timed out. File may be too large or complex.")
+    except Exception as e:
+        if os.path.exists(output_file):
+            os.unlink(output_file)
+        raise gr.Error(f"❌ Conversion failed: {str(e)}")
+
+def update_format_suggestions(input_file):
+    """Update suggested formats based on input file type."""
+    if not input_file:
+        return gr.Dropdown(choices=ALL_FORMATS, value="mp4")
+    
+    file_ext = Path(input_file).suffix.lower().replace(".", "")
+    
+    # Suggest related formats
+    if file_ext in VIDEO_FORMATS:
+        suggested = ["mp4", "webm", "avi", "mkv", "mov"]
+    elif file_ext in AUDIO_FORMATS:
+        suggested = ["mp3", "wav", "aac", "flac", "ogg"]
+    elif file_ext in IMAGE_FORMATS:
+        suggested = ["jpg", "png", "webp", "gif", "bmp"]
+    else:
+        suggested = ["mp4", "mp3", "jpg", "png"]
+    
+    # Add all formats but prioritize suggested ones
+    all_choices = suggested + [f for f in ALL_FORMATS if f not in suggested]
+    
+    return gr.Dropdown(choices=all_choices, value=suggested[0])
+
+# Custom CSS for better UI/UX
+custom_css = """
+.main-container {
+    max-width: 1400px;
+    margin: 0 auto;
+}
 
-        if media_type == 'Unknown':
-            raise Exception("Unsupported file format")
+.header-section {
+    text-align: center;
+    padding: 2rem 1rem;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    border-radius: 12px;
+    margin-bottom: 2rem;
+    color: white;
+}
 
-        # Validate output format
-        if output_format not in SUPPORTED_FORMATS[media_type]:
-            raise Exception(f"Unsupported output format for {media_type}: {output_format}")
+.header-section h1 {
+    font-size: 2.5rem;
+    margin-bottom: 0.5rem;
+    font-weight: 700;
+}
 
-        # Convert
-        output_data = convert_media(input_file, output_format, media_type)
+.header-section p {
+    font-size: 1.1rem;
+    opacity: 0.95;
+}
 
-        # Clean up
-        os.unlink(temp_path)
+.conversion-panel {
+    background: rgba(255, 255, 255, 0.05);
+    border-radius: 12px;
+    padding: 1.5rem;
+    margin-bottom: 1rem;
+}
 
-        return output_data
+.info-box {
+    background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+    border-radius: 8px;
+    padding: 1rem;
+    margin: 1rem 0;
+}
 
-    except Exception as e:
-        if 'temp_path' in locals():
-            try:
-                os.unlink(temp_path)
-            except:
-                pass
-        raise Exception(f"Error: {str(e)}")
+.status-success {
+    color: #10b981;
+    font-weight: 600;
+}
 
-# Create custom theme
-custom_theme = gr.themes.Soft(
-    primary_hue="blue",
-    secondary_hue="indigo",
-    neutral_hue="slate",
-    font=gr.themes.GoogleFont("Inter"),
-    text_size="lg",
-    spacing_size="lg",
-    radius_size="md"
-).set(
-    button_primary_background_fill="*primary_600",
-    button_primary_background_fill_hover="*primary_700",
-    block_title_text_weight="600",
-)
+.status-error {
+    color: #ef4444;
+    font-weight: 600;
+}
 
-# Create Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("""
-    # 🎵 Universal Media Converter
-    **Built with anycoder** - [https://huggingface.co/spaces/akhaliq/anycoder](https://huggingface.co/spaces/akhaliq/anycoder)
+footer {
+    text-align: center;
+    padding: 2rem;
+    margin-top: 2rem;
+    opacity: 0.8;
+}
 
-    Convert media files between various formats using Hugging Face's zero-GPU infrastructure.
+.format-badge {
+    display: inline-block;
+    padding: 0.25rem 0.75rem;
+    background: #667eea;
+    color: white;
+    border-radius: 20px;
+    font-size: 0.875rem;
+    margin: 0.25rem;
+}
+"""
+
+# Build the Gradio interface
+with gr.Blocks(fill_height=True) as demo:
+    gr.HTML("""
+        <div class="header-section">
+            <h1>🎬 Universal Media Converter</h1>
+            <p>Convert any media file to any format • Support for 60+ formats • Professional quality</p>
+            <a href="https://huggingface.co/spaces/akhaliq/anycoder" target="_blank" style="color: white; text-decoration: none; opacity: 0.9; font-size: 0.9rem;">
+                ✨ Built with anycoder
+            </a>
+        </div>
     """)
-
+    
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("## Input Media")
+            gr.Markdown("### 📤 Input Settings")
+            
             input_file = gr.File(
                 label="Upload Media File",
-                file_types=[
-                    "audio", "video", "image",
-                    ".pdf", ".docx", ".txt", ".rtf", ".html"
-                ],
-                type="binary"
+                file_types=["video", "audio", "image"],
+                type="filepath"
             )
-
-            # Format selection
-            with gr.Accordion("Advanced Options", open=False):
-                gr.Markdown("### Select Output Format")
-
-                with gr.Row():
-                    media_type_select = gr.Dropdown(
-                        choices=list(SUPPORTED_FORMATS.keys()),
-                        value="Audio",
-                        label="Media Type"
-                    )
-
-                format_select = gr.Dropdown(
-                    choices=SUPPORTED_AUDIO_FORMATS,
-                    value="mp3",
-                    label="Output Format",
-                    allow_custom_value=True
+            
+            file_info = gr.Markdown(
+                value="*Upload a file to see details*",
+                elem_classes="info-box"
+            )
+            
+            gr.Markdown("### ⚙️ Conversion Settings")
+            
+            output_format = gr.Dropdown(
+                choices=ALL_FORMATS,
+                value="mp4",
+                label="Output Format",
+                info="Select the desired output format"
+            )
+            
+            quality = gr.Radio(
+                choices=["high", "medium", "low"],
+                value="high",
+                label="Quality",
+                info="Higher quality = larger file size"
+            )
+            
+            with gr.Accordion("🎨 Advanced Options", open=False):
+                resolution = gr.Dropdown(
+                    choices=[
+                        "Original",
+                        "3840x2160 (4K)",
+                        "1920x1080 (Full HD)",
+                        "1280x720 (HD)",
+                        "854x480 (SD)",
+                        "640x360"
+                    ],
+                    value="Original",
+                    label="Video Resolution (for video files)",
+                    info="Resize video to specific resolution"
                 )
-
+            
+            convert_btn = gr.Button(
+                "🚀 Convert Media",
+                variant="primary",
+                size="lg"
+            )
+            
+            clear_btn = gr.ClearButton(
+                components=[input_file, output_format, quality, file_info],
+                value="🗑️ Clear All"
+            )
+        
         with gr.Column(scale=1):
-            gr.Markdown("## Conversion Result")
-            output_file = gr.File(label="Download Converted File")
-
-            status_text = gr.Textbox(
-                label="Status",
-                value="Ready to convert!",
-                interactive=False
+            gr.Markdown("### 📥 Output")
+            
+            status_message = gr.Markdown(
+                value="*Ready to convert your media*",
+                elem_classes="info-box"
             )
-
-    # Update format dropdown based on media type
-    def update_formats(media_type):
-        formats = SUPPORTED_FORMATS.get(media_type, [])
-        return gr.Dropdown(
-            choices=formats,
-            value=formats[0] if formats else "",
-            label="Output Format",
-            allow_custom_value=True
-        )
-
-    media_type_select.change(
-        fn=update_formats,
-        inputs=media_type_select,
-        outputs=format_select
+            
+            output_file = gr.File(
+                label="Converted File",
+                type="filepath"
+            )
+            
+            gr.Markdown("""
+            ### 📋 Supported Formats
+            
+            **Video:** MP4, AVI, MKV, MOV, WebM, FLV, WMV, and more  
+            **Audio:** MP3, WAV, AAC, FLAC, OGG, M4A, and more  
+            **Image:** JPG, PNG, GIF, WebP, BMP, TIFF, and more
+            
+            ### ✨ Features
+            
+            - 🎯 60+ format support
+            - 🎨 Quality control
+            - 📐 Resolution options
+            - ⚡ Fast conversion
+            - 💾 File info analysis
+            """)
+    
+    # Examples section
+    gr.Markdown("### 💡 Quick Examples")
+    gr.Examples(
+        examples=[
+            ["example.mp4", "webm", "high"],
+            ["example.mp3", "wav", "high"],
+            ["example.jpg", "png", "high"],
+        ],
+        inputs=[input_file, output_format, quality],
+        label="Try these examples (files will be created if needed)"
     )
-
-    # Conversion button
-    convert_btn = gr.Button("🔄 Convert Media", variant="primary", size="lg")
-
-    def convert_wrapper(input_data, output_format):
-        try:
-            if input_data is None:
-                raise Exception("Please upload a file first")
-
-            # Convert
-            result = process_conversion(input_data, output_format)
-
-            return {
-                output_file: result,
-                status_text: f"✅ Successfully converted to {output_format.upper()}"
-            }
-        except Exception as e:
-            return {
-                output_file: None,
-                status_text: f"❌ Error: {str(e)}"
-            }
-
+    
+    # Event handlers
+    input_file.change(
+        fn=get_file_info,
+        inputs=[input_file],
+        outputs=[file_info]
+    )
+    
+    input_file.change(
+        fn=update_format_suggestions,
+        inputs=[input_file],
+        outputs=[output_format]
+    )
+    
+    def process_conversion(input_file, output_format, quality, resolution):
+        res = None if resolution == "Original" else resolution.split(" ")[0]
+        return convert_media(input_file, output_format, quality, res)
+    
     convert_btn.click(
-        fn=convert_wrapper,
-        inputs=[input_file, format_select],
-        outputs=[output_file, status_text],
-        api_visibility="public"
+        fn=process_conversion,
+        inputs=[input_file, output_format, quality, resolution],
+        outputs=[output_file, status_message]
     )
 
-    gr.Markdown("""
-    ## 📋 Supported Formats
-
-    ### Audio
-    MP3, WAV, OGG, FLAC, AAC, M4A
-
-    ### Video
-    MP4, AVI, MOV, MKV, WEBM, FLV
-
-    ### Image
-    JPG, PNG, WEBP, BMP, GIF, TIFF
-
-    ### Document
-    PDF, DOCX, TXT, RTF, HTML
-    """)
-
-demo.launch(
-    theme=custom_theme,
-    footer_links=[
-        {
-            "label": "Built with anycoder",
-            "url": "https://huggingface.co/spaces/akhaliq/anycoder"
-        },
-        {
-            "label": "Gradio Docs",
-            "url": "https://gradio.app/docs"
-        }
-    ],
-    css="""
-    .gradio-container {
-        max-width: 1000px !important;
-    }
-    .gr-button-primary {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-        border: none !important;
-    }
-    .gr-button-primary:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 4px 12px rgba(0,0,0,0.15) !important;
-    }
-    .gr-box {
-        border-radius: 12px !important;
-        border: 1px solid #e5e7eb !important;
-    }
-    """,
-    js="""
-    function addAnimation() {
-        const buttons = document.querySelectorAll('.gr-button-primary');
-        buttons.forEach(button => {
-            button.addEventListener('click', function() {
-                this.style.transform = 'scale(0.95)';
-                setTimeout(() => {
-                    this.style.transform = 'scale(1)';
-                }, 150);
-            });
-        });
-    }
-
-    // Add animation when page loads
-    document.addEventListener('DOMContentLoaded', addAnimation);
-    """
-)
-## Deployment Instructions
-
-### Option 1: Deploy on Hugging Face Spaces (Recommended)
-
-1. **Create a new Space**:
-   - Go to [Hugging Face Spaces](https://huggingface.co/spaces)
-   - Click "Create new Space"
-   - Select "Gradio" as the SDK
-   - Choose a name for your Space
-
-2. **Upload the code**:
-   - Create a new file called `app.py` in your Space
-   - Paste the complete code above
-   - Create a `requirements.txt` file with:
-     
-     gradio>=4.0
-     ffmpeg-python
-     pillow
-     
-3. **Configure your Space**:
-   - In the "Settings" tab, make sure to enable GPU if needed
-   - Set the hardware to "CPU" (this app doesn't need GPU)
-   - Add any environment variables if needed
-
-4. **Deploy**:
-   - Click "Commit" to save your changes
-   - The app will automatically build and deploy
-   - Once ready, you'll get a public URL like: `https://huggingface.co/spaces/your-username/your-space-name`
-
-### Option 2: Local Deployment
-
-1. **Install dependencies**:
-   ```bash
-   pip install gradio ffmpeg-python pillow
-   
-2. **Install FFmpeg and ImageMagick**:
-   - On Ubuntu/Debian:
-     ```bash
-     sudo apt-get install ffmpeg imagemagick
-     
-   - On Mac:
-     ```bash
-     brew install ffmpeg imagemagick
-     
-   - On Windows: Download from official websites
-
-3. **Run the application**:
-   ```bash
-   python app.py
-   
-4. **Access locally**:
-   - Open your browser to `http://localhost:7860`
-   - For public access, use `python app.py --share`
-
-### Option 3: Docker Deployment
-
-1. **Create a Dockerfile**:
-   ```dockerfile
-   FROM python:3.9-slim
-
-   RUN apt-get update && apt-get install -y \
-       ffmpeg \
-       imagemagick \
-       && rm -rf /var/lib/apt/lists/*
-
-   WORKDIR /app
-   COPY . .
-
-   RUN pip install gradio ffmpeg-python pillow
-
-   CMD ["python", "app.py"]
-   
-2. **Build and run**:
-   ```bash
-   docker build -t media-converter .
-   docker run -p 7860:7860 media-converter
-   
-## Key Features of This Deployment
-
-1. **Production-Ready**: Uses Gradio 6 with modern themes and proper error handling
-2. **Cross-Platform**: Works on Linux, Mac, and Windows
-3. **Containerized**: Easy Docker deployment for cloud platforms
-4. **Scalable**: Can handle multiple concurrent conversions
-5. **User-Friendly**: Beautiful UI with animations and clear status messages
-
-The application is now ready for deployment! Choose the method that best fits your needs - Hugging Face Spaces for easiest public hosting, local deployment for testing, or Docker for production environments.
+if __name__ == "__main__":
+    demo.launch(
+        theme=gr.themes.Soft(
+            primary_hue="indigo",
+            secondary_hue="purple",
+            neutral_hue="slate",
+            font=gr.themes.GoogleFont("Inter"),
+            text_size="lg",
+            spacing_size="lg",
+            radius_size="lg"
+        ).set(
+            button_primary_background_fill="*primary_600",
+            button_primary_background_fill_hover="*primary_700",
+            block_title_text_weight="600",
+            block_label_text_weight="600",
+        ),
+        css=custom_css,
+        footer_links=[
+            {"label": "Built with anycoder", "url": "https://huggingface.co/spaces/akhaliq/anycoder"}
+        ]
+    )