Update a.py

a.py

@@ -1,53 +1,379 @@
 import gradio as gr
-from yt_dlp import YoutubeDL
 import os
-from pydub import AudioSegment
+import zipfile
+import tempfile
+import shutil
+from pathlib import Path
+import mimetypes
 
-DOWNLOADS_FOLDER = "downloads"
-os.makedirs(DOWNLOADS_FOLDER, exist_ok=True)
+# Create uploads directory
+UPLOADS_FOLDER = "uploads"
+os.makedirs(UPLOADS_FOLDER, exist_ok=True)
 
-def download_soundcloud(url, file_format, duration_sec):
-    # Download best audio first (usually m4a)
-    ydl_opts = {
-        'format': 'bestaudio/best',
-        'outtmpl': os.path.join(DOWNLOADS_FOLDER, '%(title)s.%(ext)s')
-    }
-    
-    with YoutubeDL(ydl_opts) as ydl:
-        info = ydl.extract_info(url, download=True)
-    
-    original_file = os.path.join(DOWNLOADS_FOLDER, f"{info['title']}.{info['ext']}")
-    
-    # Load audio and trim to duration
-    audio = AudioSegment.from_file(original_file)
-    duration_ms = min(len(audio), int(duration_sec * 1000))
-    trimmed_audio = audio[:duration_ms]
-    
-    # Determine output file path
-    if file_format.lower() == "mp3":
-        output_file = os.path.splitext(original_file)[0] + ".mp3"
-        trimmed_audio.export(output_file, format="mp3")
-    elif file_format.lower() == "opus":
-        output_file = os.path.splitext(original_file)[0] + ".opus"
-        trimmed_audio.export(output_file, format="opus")
-    else:  # keep original format
-        output_file = os.path.splitext(original_file)[0] + f".{info['ext']}"
-        trimmed_audio.export(output_file, format=info['ext'])
-    
-    return output_file
+def process_file(file_obj, file_name, action):
+    """
+    Process uploaded file: return original or create zip
+    """
+    if not file_obj:
+        return None, "❌ No file uploaded"
+    
+    try:
+        # Save uploaded file temporarily
+        temp_dir = tempfile.mkdtemp()
+        original_path = os.path.join(temp_dir, file_name or os.path.basename(file_obj.name))
+        
+        # Copy file to temp location
+        shutil.copy2(file_obj.name, original_path)
+        
+        if action == "original":
+            # Return original file
+            return original_path, f"✅ Ready to download: {os.path.basename(original_path)}"
+        
+        elif action == "zip":
+            # Create zip file
+            base_name = os.path.splitext(os.path.basename(original_path))[0]
+            zip_path = os.path.join(temp_dir, f"{base_name}.zip")
+            
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                zipf.write(original_path, os.path.basename(original_path))
+            
+            return zip_path, f"✅ Zipped as: {os.path.basename(zip_path)}"
+        
+        elif action == "zip_with_password":
+            # Create password-protected zip (requires pyminizip)
+            try:
+                import pyminizip
+                base_name = os.path.splitext(os.path.basename(original_path))[0]
+                zip_path = os.path.join(temp_dir, f"{base_name}_protected.zip")
+                
+                # Compress with password
+                pyminizip.compress(
+                    original_path, 
+                    None, 
+                    zip_path, 
+                    "password123",  # Default password
+                    5  # Compression level
+                )
+                return zip_path, f"✅ Password-protected zip created (password: password123)"
+            
+            except ImportError:
+                return None, "❌ pyminizip not installed. Install with: pip install pyminizip"
+        
+        else:
+            return None, "❌ Invalid action selected"
+    
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
+
+def process_multiple_files(files, action):
+    """
+    Process multiple uploaded files
+    """
+    if not files:
+        return None, "❌ No files uploaded"
+    
+    try:
+        temp_dir = tempfile.mkdtemp()
+        
+        if action == "individual":
+            # Create zip containing all files
+            zip_path = os.path.join(temp_dir, "files.zip")
+            
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                for file_obj in files:
+                    file_path = file_obj.name
+                    zipf.write(file_path, os.path.basename(file_path))
+            
+            return zip_path, f"✅ Created zip with {len(files)} files"
+        
+        elif action == "separate":
+            # Create separate zips for each file
+            zip_path = os.path.join(temp_dir, "separate_files.zip")
+            
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                for file_obj in files:
+                    file_path = file_obj.name
+                    # Create individual zip first
+                    individual_zip = os.path.join(temp_dir, f"{os.path.splitext(os.path.basename(file_path))[0]}.zip")
+                    with zipfile.ZipFile(individual_zip, 'w', zipfile.ZIP_DEFLATED) as ind_zip:
+                        ind_zip.write(file_path, os.path.basename(file_path))
+                    # Add individual zip to main zip
+                    zipf.write(individual_zip, os.path.basename(individual_zip))
+            
+            return zip_path, f"✅ Created zip with {len(files)} individual zips"
+        
+        else:
+            return None, "❌ Invalid action selected"
+    
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
 
-# Gradio interface
-with gr.Blocks() as iface:
-    url_input = gr.Textbox(label="SoundCloud URL", value="https://soundcloud.com/antonio-antetomaso/mutiny-on-the-bounty-closing-titles-cover")
-    format_choice = gr.Dropdown(choices=["mp3", "m4a", "opus"], value="mp3", label="Select format")
-    duration_slider = gr.Slider(minimum=5, maximum=300, value=30, step=5, label="Duration (seconds)")
-    download_button = gr.Button("Download")
-    download_file = gr.File(label="Download your track")
-    
-    download_button.click(
-        fn=download_soundcloud,
-        inputs=[url_input, format_choice, duration_slider],
-        outputs=download_file
+def get_file_info(file_obj):
+    """Get information about uploaded file"""
+    if not file_obj:
+        return "No file selected"
+    
+    try:
+        file_path = file_obj.name
+        file_size = os.path.getsize(file_path)
+        file_ext = os.path.splitext(file_path)[1].lower()
+        
+        # Get file type
+        mime_type, _ = mimetypes.guess_type(file_path)
+        file_type = mime_type.split('/')[0] if mime_type else "Unknown"
+        
+        info = f"""
+        📄 **File Information:**
+        
+        **Name:** {os.path.basename(file_path)}
+        **Size:** {file_size:,} bytes ({file_size/1024:.2f} KB)
+        **Extension:** {file_ext}
+        **Type:** {file_type}
+        **Path:** {file_path}
+        """
+        
+        return info
+    
+    except Exception as e:
+        return f"❌ Error getting file info: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="File Upload & Download Manager", theme=gr.themes.Soft()) as iface:
+    
+    gr.Markdown("# 📁 File Upload & Download Manager")
+    gr.Markdown("Upload files and download them as original or zipped")
+    
+    with gr.Tabs():
+        # Single File Tab
+        with gr.Tab("Single File"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    single_file = gr.File(
+                        label="Upload a File",
+                        file_count="single"
+                    )
+                    
+                    file_name_input = gr.Textbox(
+                        label="Custom Filename (optional)",
+                        placeholder="Leave empty to keep original name...",
+                        info="Enter a custom name for the downloaded file"
+                    )
+                    
+                    single_action = gr.Radio(
+                        choices=[
+                            ("Download Original", "original"),
+                            ("Download as ZIP", "zip"),
+                            ("Password-protected ZIP", "zip_with_password")
+                        ],
+                        label="Select Action",
+                        value="original"
+                    )
+                    
+                    single_btn = gr.Button("Process File", variant="primary")
+                
+                with gr.Column(scale=1):
+                    file_info = gr.Markdown(label="File Information")
+                    single_status = gr.Textbox(label="Status", interactive=False)
+                    single_download = gr.File(label="Download Processed File", interactive=False)
+            
+            # Update file info when file is uploaded
+            single_file.change(
+                fn=get_file_info,
+                inputs=[single_file],
+                outputs=file_info
+            )
+        
+        # Multiple Files Tab
+        with gr.Tab("Multiple Files"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    multi_files = gr.File(
+                        label="Upload Multiple Files",
+                        file_count="multiple",
+                        file_types=["image", "video", "audio", "text", "pdf", ".zip"]
+                    )
+                    
+                    multi_action = gr.Radio(
+                        choices=[
+                            ("Combine all files into one ZIP", "individual"),
+                            ("Create separate ZIPs for each file", "separate")
+                        ],
+                        label="Select Action",
+                        value="individual"
+                    )
+                    
+                    multi_btn = gr.Button("Process Files", variant="primary")
+                
+                with gr.Column(scale=1):
+                    multi_status = gr.Textbox(label="Status", interactive=False)
+                    multi_download = gr.File(label="Download Processed Files", interactive=False)
+        
+        # Batch Processing Tab
+        with gr.Tab("Batch Processing"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Upload Multiple Files for Batch Processing")
+                    
+                    batch_files = gr.File(
+                        label="Upload Files",
+                        file_count="multiple",
+                        file_types=None  # All file types
+                    )
+                    
+                    batch_options = gr.CheckboxGroup(
+                        choices=[
+                            "Create individual ZIPs",
+                            "Create combined ZIP",
+                            "Rename with timestamp",
+                            "Add to existing ZIP"
+                        ],
+                        label="Processing Options",
+                        value=["Create combined ZIP"]
+                    )
+                    
+                    with gr.Row():
+                        batch_format = gr.Dropdown(
+                            choices=[".zip", ".7z", ".tar.gz"],
+                            value=".zip",
+                            label="Archive Format"
+                        )
+                        
+                        compression_level = gr.Slider(
+                            minimum=1,
+                            maximum=9,
+                            value=6,
+                            step=1,
+                            label="Compression Level"
+                        )
+                    
+                    batch_btn = gr.Button("Process Batch", variant="primary", size="lg")
+                
+                with gr.Column():
+                    batch_status = gr.Textbox(label="Status", interactive=False, lines=3)
+                    batch_download = gr.File(label="Download Results", interactive=False)
+    
+    # Instructions
+    with gr.Accordion("📖 Instructions & Features", open=False):
+        gr.Markdown("""
+        ## How to Use:
+        
+        ### Single File Tab:
+        1. **Upload** a single file
+        2. (Optional) Enter a custom filename
+        3. **Choose action**: Download original, as ZIP, or password-protected ZIP
+        4. Click **Process File**
+        
+        ### Multiple Files Tab:
+        1. **Upload** multiple files (Ctrl+Click to select multiple)
+        2. **Choose action**: Combine into one ZIP or create separate ZIPs
+        3. Click **Process Files**
+        
+        ### Batch Processing Tab:
+        1. **Upload** multiple files
+        2. **Select processing options**
+        3. Choose archive format and compression level
+        4. Click **Process Batch**
+        
+        ## Features:
+        - ✅ Single file upload and download
+        - ✅ Multiple file upload and batch processing
+        - ✅ ZIP file creation with compression
+        - ✅ Password-protected ZIPs (requires pyminizip)
+        - ✅ File information display
+        - ✅ Custom filename support
+        - ✅ Multiple archive formats
+        
+        ## Notes:
+        - Files are processed in temporary storage
+        - Original files are not modified
+        - Large files may take time to process
+        - Password for protected ZIPs: `password123`
+        """)
+    
+    # Connect events
+    single_btn.click(
+        fn=process_file,
+        inputs=[single_file, file_name_input, single_action],
+        outputs=[single_download, single_status]
+    )
+    
+    multi_btn.click(
+        fn=process_multiple_files,
+        inputs=[multi_files, multi_action],
+        outputs=[multi_download, multi_status]
+    )
+    
+    # Batch processing function
+    def process_batch(files, options, format_type, compression):
+        if not files:
+            return None, "❌ No files uploaded"
+        
+        try:
+            temp_dir = tempfile.mkdtemp()
+            results = []
+            
+            # Process based on options
+            if "Create combined ZIP" in options:
+                zip_name = f"combined{format_type}"
+                zip_path = os.path.join(temp_dir, zip_name)
+                
+                if format_type == ".zip":
+                    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED, compresslevel=compression) as zipf:
+                        for file_obj in files:
+                            file_path = file_obj.name
+                            arcname = os.path.basename(file_path)
+                            if "Rename with timestamp" in options:
+                                import time
+                                name, ext = os.path.splitext(arcname)
+                                arcname = f"{name}_{int(time.time())}{ext}"
+                            zipf.write(file_path, arcname)
+                    results.append(zip_path)
+            
+            if "Create individual ZIPs" in options:
+                for file_obj in files:
+                    file_path = file_obj.name
+                    base_name = os.path.splitext(os.path.basename(file_path))[0]
+                    if "Rename with timestamp" in options:
+                        import time
+                        base_name = f"{base_name}_{int(time.time())}"
+                    
+                    individual_zip = os.path.join(temp_dir, f"{base_name}{format_type}")
+                    
+                    if format_type == ".zip":
+                        with zipfile.ZipFile(individual_zip, 'w', zipfile.ZIP_DEFLATED, compresslevel=compression) as zipf:
+                            zipf.write(file_path, os.path.basename(file_path))
+                    
+                    results.append(individual_zip)
+            
+            # If multiple results, create a final zip
+            if len(results) > 1:
+                final_zip = os.path.join(temp_dir, f"batch_results{format_type}")
+                with zipfile.ZipFile(final_zip, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                    for result in results:
+                        zipf.write(result, os.path.basename(result))
+                output_file = final_zip
+            elif results:
+                output_file = results[0]
+            else:
+                return None, "⚠️ No processing options selected"
+            
+            return output_file, f"✅ Processed {len(files)} file(s) with {len(options)} option(s)"
+        
+        except Exception as e:
+            return None, f"❌ Error: {str(e)}"
+    
+    batch_btn.click(
+        fn=process_batch,
+        inputs=[batch_files, batch_options, batch_format, compression_level],
+        outputs=[batch_download, batch_status]
     )
 
-iface.launch(show_error=True)
+# Launch the app
+if __name__ == "__main__":
+    iface.launch(
+        server_name="127.0.0.1",
+        server_port=7861,  # Different port to avoid conflict
+        show_error=True,
+        share=False,
+        ssr_mode=False
+    )