Upload folder using huggingface_hub

app.py

@@ -0,0 +1,322 @@
+import gradio as gr
+import os
+import subprocess
+import tempfile
+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"""
+    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"""
+    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)
+
+        if media_type == 'Unknown':
+            raise Exception("Unsupported file format")
+
+        # Validate output format
+        if output_format not in SUPPORTED_FORMATS[media_type]:
+            raise Exception(f"Unsupported output format for {media_type}: {output_format}")
+
+        # Convert
+        output_data = convert_media(input_file, output_format, media_type)
+
+        # Clean up
+        os.unlink(temp_path)
+
+        return output_data
+
+    except Exception as e:
+        if 'temp_path' in locals():
+            try:
+                os.unlink(temp_path)
+            except:
+                pass
+        raise Exception(f"Error: {str(e)}")
+
+# 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",
+)
+
+# 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)
+
+    Convert media files between various formats using Hugging Face's zero-GPU infrastructure.
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("## Input Media")
+            input_file = gr.File(
+                label="Upload Media File",
+                file_types=[
+                    "audio", "video", "image",
+                    ".pdf", ".docx", ".txt", ".rtf", ".html"
+                ],
+                type="binary"
+            )
+
+            # 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"
+                )
+
+        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
+            )
+
+    # Update format dropdown based on media type
+    def update_formats(media_type):
+        return gr.Dropdown(
+            choices=SUPPORTED_FORMATS.get(media_type, []),
+            value=SUPPORTED_FORMATS.get(media_type, [])[0] if SUPPORTED_FORMATS.get(media_type) else ""
+        )
+
+    media_type_select.change(
+        fn=update_formats,
+        inputs=media_type_select,
+        outputs=format_select
+    )
+
+    # 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)}"
+            }
+
+    convert_btn.click(
+        fn=convert_wrapper,
+        inputs=[input_file, format_select],
+        outputs=[output_file, status_text],
+        api_visibility="public"
+    )
+
+    # Examples
+    gr.Markdown("## 📚 Examples")
+    gr.Examples(
+        examples=[
+            ["https://example.com/sample.mp3", "wav"],
+            ["https://example.com/sample.mp4", "avi"],
+            ["https://example.com/sample.jpg", "png"],
+            ["https://example.com/sample.docx", "pdf"]
+        ],
+        inputs=[input_file, format_select],
+        outputs=[output_file, status_text],
+        fn=convert_wrapper,
+        cache_examples=True,
+        examples_per_page=4
+    )
+
+    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);
+    """
+)

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=6.0
+requests
+Pillow