Upload 5 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+ffmpeg.exe filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,39 @@
----
-title: Python Compresor
-emoji: 🏃
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.44.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Compresor Premium - Aplicación Web
+
+Aplicación web para compresión de archivos multimedia con interfaz Gradio.
+
+## Características
+
+- Interfaz web moderna y responsive
+- Soporte para múltiples formatos de archivo
+- Compresión de videos, imágenes y GIFs
+- Subida y descarga de archivos
+- Procesamiento en tiempo real
+
+## Instalación
+
+1. Instalar dependencias:
+```bash
+pip install -r requirements.txt
+```
+
+2. Ejecutar la aplicación web:
+```bash
+python app.py
+```
+
+3. Abrir en el navegador: `http://localhost:7860`
+
+## Archivos
+
+- `app.py` - Aplicación web principal con Gradio
+- `app_main.py` - Versión alternativa de la aplicación
+- `uploads/` - Carpeta para archivos subidos
+- `requirements.txt` - Dependencias específicas para web
+
+## Uso
+
+1. Acceder a la interfaz web
+2. Subir archivo(s) a comprimir
+3. Seleccionar configuraciones de compresión
+4. Descargar archivo(s) comprimido(s)

app.py

@@ -0,0 +1,552 @@
+import os
+import subprocess
+import logging
+import asyncio
+import threading
+import time
+import psutil
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Optional, List, Tuple, Dict, Any
+from pathlib import Path
+import gradio as gr
+from dataclasses import dataclass
+import json
+import zipfile
+import shutil
+
+
+from io import BytesIO
+
+# Configuración de logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Directorios y rutas
+UPLOAD_DIR = os.path.join(os.getcwd(), "uploads")
+FFMPEG_PATH = os.path.join(os.path.dirname(__file__), "ffmpeg.exe")  # Ruta al ejecutable ffmpeg
+
+# Crear directorios
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+# Definir formatos soportados (solo video y audio)
+VIDEO_FORMATS = ['.mp4', '.avi', '.mov', '.mkv', '.webm', '.flv', '.wmv', '.m4v', '.3gp', '.ts', '.mts', '.mpg', '.mpeg', '.ogv']
+AUDIO_FORMATS = ['.mp3', '.wav', '.aac', '.flac', '.ogg', '.m4a', '.wma', '.opus', '.ac3', '.dts', '.amr', '.aiff']
+
+ALL_SUPPORTED_FORMATS = VIDEO_FORMATS + AUDIO_FORMATS
+
+# Configuraciones de compresión agresiva para reducir tamaño
+QUALITY_PRESETS = {
+    "Compresión Máxima": {
+        "video_bitrate": "200k",
+        "audio_bitrate": "32k",
+        "preset": "slow",
+        "crf": "35"
+    },
+    "Compresión Alta": {
+        "video_bitrate": "400k",
+        "audio_bitrate": "48k",
+        "preset": "medium",
+        "crf": "30"
+    },
+    "Compresión Media": {
+        "video_bitrate": "600k",
+        "audio_bitrate": "64k",
+        "preset": "fast",
+        "crf": "28"
+    },
+    "Compresión Rápida": {
+        "video_bitrate": "800k",
+        "audio_bitrate": "96k",
+        "preset": "veryfast",
+        "crf": "25"
+    }
+}
+
+@dataclass
+class ConversionProgress:
+    filename: str
+    status: str
+    progress: float
+    original_size: int = 0
+    compressed_size: int = 0
+    compression_ratio: float = 0.0
+    output_file: Optional[str] = None
+    error: Optional[str] = None
+
+class UniversalCompressor:
+    def __init__(self):
+        self.conversion_progress = {}
+        self.active_conversions = 0
+        self.cpu_cores = psutil.cpu_count(logical=False)
+        
+    def get_file_size(self, file_path: str) -> int:
+        """Obtener tamaño del archivo en bytes."""
+        try:
+            return os.path.getsize(file_path)
+        except:
+            return 0
+    
+    def detect_file_type(self, file_path: str) -> str:
+        """Detectar tipo de archivo basado en extensión."""
+        ext = os.path.splitext(file_path)[1].lower()
+        if ext in VIDEO_FORMATS:
+            return 'video'
+        elif ext in AUDIO_FORMATS:
+            return 'audio'
+        else:
+            return 'unsupported'
+    
+    def sanitize_filename(self, filename: str) -> str:
+        """Limpiar y validar nombre de archivo."""
+        return ''.join(c for c in filename if c.isalnum() or c in ('.', '_', '-')).rstrip()
+    
+    def ensure_unique_filename(self, directory: str, filename: str) -> str:
+        """Generar nombre único para evitar sobreescrituras."""
+        base, ext = os.path.splitext(filename)
+        counter = 1
+        new_filename = filename
+        while os.path.exists(os.path.join(directory, new_filename)):
+            new_filename = f"{base}_{counter}{ext}"
+            counter += 1
+        return new_filename
+    
+
+    
+    def compress_media(self, input_file: str, quality_preset: str, progress_callback=None) -> str:
+        """Comprimir video/audio con configuraciones optimizadas para CPU."""
+        try:
+            media_type = self.detect_file_type(input_file)
+            base_name = os.path.basename(input_file)
+            file_id = f"{base_name}_{int(time.time())}"
+            
+            # Inicializar progreso
+            original_size = self.get_file_size(input_file)
+            self.conversion_progress[file_id] = ConversionProgress(
+                filename=base_name,
+                status="Iniciando compresión...",
+                progress=0.0,
+                original_size=original_size
+            )
+            
+            if progress_callback:
+                progress_callback(file_id, self.conversion_progress[file_id])
+            
+            # Determinar extensión de salida
+            output_extension = 'mp4' if media_type == 'video' else 'm4a'
+            output_filename = self.ensure_unique_filename(
+                UPLOAD_DIR, 
+                f"{os.path.splitext(base_name)[0]}_compressed.{output_extension}"
+            )
+            output_file = os.path.join(UPLOAD_DIR, output_filename)
+            
+            quality_config = QUALITY_PRESETS[quality_preset]
+            
+            # Configuraciones FFmpeg optimizadas para menor uso de CPU
+            if media_type == 'video':
+                ffmpeg_command = [
+                    FFMPEG_PATH,
+                    '-i', input_file,
+                    '-c:v', 'libx264',
+                    '-crf', quality_config['crf'],
+                    '-preset', quality_config['preset'],
+                    '-c:a', 'aac',
+                    '-b:a', quality_config['audio_bitrate'],
+                    '-movflags', '+faststart',
+                    '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2',
+                    '-threads', str(min(self.cpu_cores, 4)),  # Limitar threads para menor uso CPU
+                    '-y',
+                    output_file
+                ]
+            else:  # audio
+                ffmpeg_command = [
+                    FFMPEG_PATH,
+                    '-i', input_file,
+                    '-vn',
+                    '-c:a', 'aac',
+                    '-b:a', quality_config['audio_bitrate'],
+                    '-ar', '44100',
+                    '-threads', str(min(self.cpu_cores, 2)),
+                    '-y',
+                    output_file
+                ]
+            
+            # Ejecutar conversión
+            self.conversion_progress[file_id].status = "Comprimiendo..."
+            self.conversion_progress[file_id].progress = 25.0
+            if progress_callback:
+                progress_callback(file_id, self.conversion_progress[file_id])
+            
+            process = subprocess.Popen(
+                ffmpeg_command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            # Simular progreso
+            for i in range(25, 90, 10):
+                if process.poll() is None:
+                    self.conversion_progress[file_id].progress = float(i)
+                    if progress_callback:
+                        progress_callback(file_id, self.conversion_progress[file_id])
+                    time.sleep(0.3)
+                else:
+                    break
+            
+            stdout, stderr = process.communicate()
+            
+            if process.returncode != 0:
+                error_msg = f"Error FFmpeg: {stderr}"
+                self.conversion_progress[file_id].status = "Error"
+                self.conversion_progress[file_id].error = error_msg
+                if progress_callback:
+                    progress_callback(file_id, self.conversion_progress[file_id])
+                raise Exception(error_msg)
+            
+            # Finalizar
+            compressed_size = self.get_file_size(output_file)
+            compression_ratio = ((original_size - compressed_size) / original_size) * 100 if original_size > 0 else 0
+            
+            self.conversion_progress[file_id].status = "Completado"
+            self.conversion_progress[file_id].progress = 100.0
+            self.conversion_progress[file_id].compressed_size = compressed_size
+            self.conversion_progress[file_id].compression_ratio = compression_ratio
+            self.conversion_progress[file_id].output_file = output_file
+            
+            if progress_callback:
+                progress_callback(file_id, self.conversion_progress[file_id])
+            
+            logger.info(f"Archivo comprimido: {output_file} (Reducción: {compression_ratio:.1f}%)")
+            return output_file
+            
+        except Exception as e:
+            error_msg = f"Error durante compresión: {str(e)}"
+            logger.error(error_msg)
+            if file_id in self.conversion_progress:
+                self.conversion_progress[file_id].status = "Error"
+                self.conversion_progress[file_id].error = error_msg
+                if progress_callback:
+                    progress_callback(file_id, self.conversion_progress[file_id])
+            raise Exception(error_msg)
+    
+    def compress_archive(self, input_file: str, progress_callback=None) -> str:
+        """Recomprimir archivos comprimidos para mejor ratio."""
+        try:
+            base_name = os.path.basename(input_file)
+            file_id = f"{base_name}_{int(time.time())}"
+            
+            original_size = self.get_file_size(input_file)
+            self.conversion_progress[file_id] = ConversionProgress(
+                filename=base_name,
+                status="Recomprimiendo archivo...",
+                progress=50.0,
+                original_size=original_size
+            )
+            
+            if progress_callback:
+                progress_callback(file_id, self.conversion_progress[file_id])
+            
+            # Crear archivo 7z con máxima compresión
+            output_filename = self.ensure_unique_filename(
+                UPLOAD_DIR, f"{os.path.splitext(base_name)[0]}_compressed.7z"
+            )
+            output_file = os.path.join(UPLOAD_DIR, output_filename)
+            
+            # Usar 7z para recompresión
+            import py7zr
+            with py7zr.SevenZipFile(output_file, 'w', filters=[{"id": py7zr.FILTER_LZMA2, "preset": 9}]) as archive:
+                archive.write(input_file, base_name)
+            
+            compressed_size = self.get_file_size(output_file)
+            compression_ratio = ((original_size - compressed_size) / original_size) * 100 if original_size > 0 else 0
+            
+            self.conversion_progress[file_id].status = "Completado"
+            self.conversion_progress[file_id].progress = 100.0
+            self.conversion_progress[file_id].compressed_size = compressed_size
+            self.conversion_progress[file_id].compression_ratio = compression_ratio
+            self.conversion_progress[file_id].output_file = output_file
+            
+            if progress_callback:
+                progress_callback(file_id, self.conversion_progress[file_id])
+            
+            return output_file
+            
+        except Exception as e:
+            error_msg = f"Error recomprimiendo archivo: {str(e)}"
+            logger.error(error_msg)
+            if file_id in self.conversion_progress:
+                self.conversion_progress[file_id].status = "Error"
+                self.conversion_progress[file_id].error = error_msg
+                if progress_callback:
+                    progress_callback(file_id, self.conversion_progress[file_id])
+            raise Exception(error_msg)
+    
+    def compress_single_file(self, input_file: str, quality_preset: str, progress_callback=None) -> str:
+        """Comprimir un archivo según su tipo."""
+        if not os.path.exists(input_file):
+            raise ValueError(f"El archivo no existe: {input_file}")
+            
+        file_type = self.detect_file_type(input_file)
+        
+        if file_type in ['video', 'audio']:
+            return self.compress_media(input_file, quality_preset, progress_callback)
+        else:
+            raise ValueError(f"Tipo de archivo no soportado: {os.path.splitext(input_file)[1]}. Solo se soportan videos y audios: {', '.join(ALL_SUPPORTED_FORMATS)}")
+    
+    def compress_multiple_files(self, file_paths: List[str], quality_preset: str, max_workers: int = None, progress_callback=None) -> List[str]:
+        """Comprimir múltiples archivos en paralelo con optimización de CPU."""
+        if max_workers is None:
+            max_workers = min(self.cpu_cores, 3)  # Limitar para no saturar CPU
+        
+        compressed_files = []
+        self.active_conversions = len(file_paths)
+        
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            future_to_file = {
+                executor.submit(self.compress_single_file, file_path, quality_preset, progress_callback): file_path 
+                for file_path in file_paths
+            }
+            
+            for future in as_completed(future_to_file):
+                file_path = future_to_file[future]
+                try:
+                    result = future.result()
+                    compressed_files.append(result)
+                except Exception as e:
+                    logger.error(f"Error comprimiendo {file_path}: {e}")
+        
+        self.active_conversions = 0
+        return compressed_files
+
+# Instancia global del compresor
+compressor = UniversalCompressor()
+
+def update_progress_display():
+    """Actualizar visualización del progreso con información detallada."""
+    if not compressor.conversion_progress:
+        return "No hay compresiones en progreso."
+    
+    progress_text = "📊 **Estado de Compresiones:**\n\n"
+    total_original = 0
+    total_compressed = 0
+    
+    for file_id, progress in compressor.conversion_progress.items():
+        status_emoji = {
+            "Iniciando compresión...": "🔄",
+            "Procesando imagen...": "🖼️",
+            "Comprimiendo...": "⚙️",
+            "Recomprimiendo archivo...": "📦",
+            "Completado": "✅",
+            "Error": "❌"
+        }.get(progress.status, "🔄")
+        
+        progress_text += f"{status_emoji} **{progress.filename}**\n"
+        progress_text += f"   Estado: {progress.status}\n"
+        progress_text += f"   Progreso: {progress.progress:.1f}%\n"
+        
+        if progress.original_size > 0:
+            original_mb = progress.original_size / (1024 * 1024)
+            progress_text += f"   Tamaño original: {original_mb:.2f} MB\n"
+            total_original += progress.original_size
+        
+        if progress.compressed_size > 0:
+            compressed_mb = progress.compressed_size / (1024 * 1024)
+            progress_text += f"   Tamaño comprimido: {compressed_mb:.2f} MB\n"
+            progress_text += f"   Reducción: {progress.compression_ratio:.1f}%\n"
+            total_compressed += progress.compressed_size
+        
+        if progress.error:
+            progress_text += f"   Error: {progress.error}\n"
+        progress_text += "\n"
+    
+    # Estadísticas totales
+    if total_original > 0:
+        total_reduction = ((total_original - total_compressed) / total_original) * 100
+        progress_text += f"**📈 Estadísticas Totales:**\n"
+        progress_text += f"Reducción total: {total_reduction:.1f}% ({(total_original - total_compressed) / (1024 * 1024):.2f} MB ahorrados)\n"
+    
+    return progress_text
+
+def gradio_single_compression(file, quality_preset):
+    """Interfaz Gradio para compresión de archivo único."""
+    if not file:
+        raise gr.Error("No se ha subido ningún archivo. Por favor, sube un archivo.")
+    
+    try:
+        compressor.conversion_progress.clear()
+        compressed_file = compressor.compress_single_file(file, quality_preset)
+        return compressed_file, update_progress_display()
+    except Exception as e:
+        raise gr.Error(f"Compresión fallida: {str(e)}")
+
+def gradio_multiple_compression(files, quality_preset, max_workers):
+    """Interfaz Gradio para compresión de múltiples archivos."""
+    if not files:
+        raise gr.Error("No se han subido archivos. Por favor, sube al menos un archivo.")
+    
+    try:
+        compressor.conversion_progress.clear()
+        file_paths = [file.name for file in files]
+        
+        compressed_files = compressor.compress_multiple_files(
+            file_paths, quality_preset, max_workers=max_workers
+        )
+        
+        if len(compressed_files) > 1:
+            zip_filename = os.path.join(UPLOAD_DIR, f"compressed_files_{int(time.time())}.zip")
+            with zipfile.ZipFile(zip_filename, 'w') as zipf:
+                for file_path in compressed_files:
+                    zipf.write(file_path, os.path.basename(file_path))
+            return zip_filename, update_progress_display()
+        elif len(compressed_files) == 1:
+            return compressed_files[0], update_progress_display()
+        else:
+            raise gr.Error("No se pudo comprimir ningún archivo.")
+            
+    except Exception as e:
+        raise gr.Error(f"Compresión fallida: {str(e)}")
+
+def refresh_progress():
+    """Refrescar estado del progreso."""
+    return update_progress_display()
+
+# Interfaz Gradio mejorada
+with gr.Blocks(title="🗜️ Compresor Universal Pro Max", theme=gr.themes.Soft()) as iface:
+    gr.Markdown(
+        """
+        # 🗜️ Compresor Universal Pro Max
+        
+        **El compresor más potente y rápido para todos tus archivos**
+        
+        ✨ **Características Avanzadas:**
+        - 🚀 Compresión inteligente y optimizada para CPU
+        - 🎬 Videos, audios, imágenes, GIFs y documentos
+        - 🖼️ Soporte completo para PNG, JPG, WebP, TIFF, GIF animado
+        - ⚡ Procesamiento paralelo ultra-rápido
+        - 📊 Monitoreo detallado con estadísticas de compresión
+        - 🔧 Algoritmos optimizados para máxima reducción de tamaño
+        - 💾 Ahorro significativo de espacio en disco
+        """
+    )
+    
+    with gr.Tabs():
+        with gr.TabItem("📄 Archivo Único"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    single_file_input = gr.File(
+                        label="📁 Subir Archivo (Todos los formatos soportados)",
+                        type="filepath",
+                        file_types=ALL_SUPPORTED_FORMATS
+                    )
+                    single_quality_input = gr.Dropdown(
+                        choices=list(QUALITY_PRESETS.keys()),
+                        value="Compresión Alta",
+                        label="🎯 Nivel de Compresión"
+                    )
+                    single_compress_btn = gr.Button(
+                        "🗜️ Comprimir Archivo",
+                        variant="primary",
+                        size="lg"
+                    )
+                
+                with gr.Column(scale=1):
+                    single_output = gr.File(
+                        label="📥 Descargar Archivo Comprimido",
+                        type="filepath"
+                    )
+        
+        with gr.TabItem("📁 Múltiples Archivos"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    multiple_files_input = gr.File(
+                        label="📁 Subir Múltiples Archivos",
+                        file_count="multiple",
+                        type="filepath",
+                        file_types=ALL_SUPPORTED_FORMATS
+                    )
+                    with gr.Row():
+                        multiple_quality_input = gr.Dropdown(
+                            choices=list(QUALITY_PRESETS.keys()),
+                            value="Compresión Alta",
+                            label="🎯 Nivel de Compresión"
+                        )
+                        workers_input = gr.Slider(
+                            minimum=1,
+                            maximum=min(psutil.cpu_count(), 6),
+                            value=min(psutil.cpu_count(logical=False), 3),
+                            step=1,
+                            label="⚡ Archivos Simultáneos"
+                        )
+                    multiple_compress_btn = gr.Button(
+                        "🗜️ Comprimir Todos los Archivos",
+                        variant="primary",
+                        size="lg"
+                    )
+                
+                with gr.Column(scale=1):
+                    multiple_output = gr.File(
+                        label="📥 Descargar Archivos Comprimidos",
+                        type="filepath"
+                    )
+    
+    # Panel de progreso mejorado
+    gr.Markdown("## 📊 Estado y Estadísticas de Compresión")
+    progress_display = gr.Markdown(
+        value="No hay compresiones en progreso.",
+        label="Estado"
+    )
+    refresh_btn = gr.Button("🔄 Actualizar Estado", size="sm")
+    
+    # Información detallada
+    with gr.Accordion("ℹ️ Información Detallada", open=False):
+        gr.Markdown(
+            f"""
+            ### 🎯 Niveles de Compresión:
+            
+            - **Compresión Máxima**: Máxima reducción de tamaño, proceso más lento
+            - **Compresión Alta**: Excelente balance compresión/velocidad
+            - **Compresión Media**: Buena compresión, procesamiento rápido
+            - **Compresión Rápida**: Compresión básica, velocidad máxima
+            
+            ### 📁 Formatos Soportados:
+            
+            **🎬 Video**: {', '.join(VIDEO_FORMATS)}
+            
+            **🎵 Audio**: {', '.join(AUDIO_FORMATS)}
+            
+            ### ⚡ Optimizaciones:
+            
+            - **CPU Cores Detectados**: {psutil.cpu_count()} (Lógicos), {psutil.cpu_count(logical=False)} (Físicos)
+            - **Threads Optimizados**: Máximo {min(psutil.cpu_count(logical=False), 4)} para video, {min(psutil.cpu_count(logical=False), 2)} para audio
+            - **Compresión Inteligente**: Algoritmos adaptativos según tipo de archivo
+            - **Gestión de Memoria**: Optimizada para archivos grandes
+            """
+        )
+    
+    # Eventos
+    single_compress_btn.click(
+        fn=gradio_single_compression,
+        inputs=[single_file_input, single_quality_input],
+        outputs=[single_output, progress_display]
+    )
+    
+    multiple_compress_btn.click(
+        fn=gradio_multiple_compression,
+        inputs=[multiple_files_input, multiple_quality_input, workers_input],
+        outputs=[multiple_output, progress_display]
+    )
+    
+    refresh_btn.click(
+        fn=refresh_progress,
+        outputs=[progress_display]
+    )
+
+# Lanzar interfaz
+if __name__ == "__main__":
+    iface.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7861,
+        show_error=True,
+        max_threads=min(psutil.cpu_count(), 10)  # Limitar threads de Gradio
+    )

app_main.py

@@ -0,0 +1,171 @@
+import gradio as gr
+import os
+import subprocess
+import time
+import logging
+import psutil
+from pathlib import Path
+
+# Configuración de logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Configuración de rutas
+FFMPEG_PATH = os.path.join(os.getcwd(), "ffmpeg.exe")
+UPLOADS_DIR = os.path.join(os.getcwd(), "uploads")
+
+# Crear directorio de uploads si no existe
+os.makedirs(UPLOADS_DIR, exist_ok=True)
+
+# Formatos soportados
+VIDEO_FORMATS = ['.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv', '.webm', '.m4v']
+AUDIO_FORMATS = ['.mp3', '.wav', '.flac', '.aac', '.ogg', '.m4a', '.wma']
+SUPPORTED_FORMATS = VIDEO_FORMATS + AUDIO_FORMATS
+
+# Presets de compresión
+COMPRESSION_PRESETS = {
+    "Compresión Rápida": {
+        "video": "-c:v libx264 -preset ultrafast -crf 28",
+        "audio": "-c:a aac -b:a 128k"
+    },
+    "Compresión Media": {
+        "video": "-c:v libx264 -preset medium -crf 23",
+        "audio": "-c:a aac -b:a 128k"
+    },
+    "Compresión Alta": {
+        "video": "-c:v libx264 -preset slow -crf 20",
+        "audio": "-c:a aac -b:a 192k"
+    },
+    "Compresión Máxima": {
+        "video": "-c:v libx264 -preset veryslow -crf 18",
+        "audio": "-c:a aac -b:a 256k"
+    }
+}
+
+def compress_media(file_path, preset="Compresión Alta", progress=gr.Progress()):
+    """Comprimir archivo de media usando FFmpeg"""
+    try:
+        if not os.path.exists(file_path):
+            return None, "Error: Archivo no encontrado"
+        
+        file_ext = Path(file_path).suffix.lower()
+        if file_ext not in SUPPORTED_FORMATS:
+            return None, f"Error: Formato {file_ext} no soportado"
+        
+        # Generar nombre de archivo de salida
+        base_name = Path(file_path).stem
+        output_path = os.path.join(UPLOADS_DIR, f"{base_name}_compressed{file_ext}")
+        
+        # Obtener configuración del preset
+        preset_config = COMPRESSION_PRESETS.get(preset, COMPRESSION_PRESETS["Compresión Alta"])
+        
+        # Construir comando FFmpeg
+        cmd = [
+            FFMPEG_PATH,
+            "-i", file_path,
+            "-y",  # Sobrescribir archivo de salida
+        ]
+        
+        # Agregar configuración según el tipo de archivo
+        if file_ext in VIDEO_FORMATS:
+            cmd.extend(preset_config["video"].split())
+            cmd.extend(preset_config["audio"].split())
+        else:  # Audio
+            cmd.extend(preset_config["audio"].split())
+        
+        cmd.append(output_path)
+        
+        logger.info(f"Ejecutando comando: {' '.join(cmd)}")
+        
+        # Ejecutar FFmpeg
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        # Simular progreso
+        for i in progress.tqdm(range(100), desc="Comprimiendo..."):
+            time.sleep(0.1)
+            if process.poll() is not None:
+                break
+        
+        stdout, stderr = process.communicate()
+        
+        if process.returncode != 0:
+            logger.error(f"Error en FFmpeg: {stderr}")
+            return None, f"Error durante compresión: {stderr[:200]}"
+        
+        if not os.path.exists(output_path):
+            return None, "Error: No se pudo crear el archivo comprimido"
+        
+        # Calcular ratio de compresión
+        original_size = os.path.getsize(file_path)
+        compressed_size = os.path.getsize(output_path)
+        compression_ratio = (1 - compressed_size / original_size) * 100
+        
+        logger.info(f"Compresión completada. Ratio: {compression_ratio:.1f}%")
+        
+        return output_path, f"Compresión exitosa! Reducción: {compression_ratio:.1f}%"
+        
+    except Exception as e:
+        logger.error(f"Error en compress_media: {str(e)}")
+        return None, f"Error durante compresión: {str(e)}"
+
+def run_app():
+    """Ejecutar la aplicación Gradio"""
+    
+    # Verificar que FFmpeg existe
+    if not os.path.exists(FFMPEG_PATH):
+        print(f"Error: FFmpeg no encontrado en {FFMPEG_PATH}")
+        return
+    
+    with gr.Blocks(title="Compresor de Video y Audio", theme=gr.themes.Soft()) as iface:
+        gr.Markdown("# 🎬 Compresor de Video y Audio")
+        gr.Markdown("Comprime tus archivos de video y audio de forma eficiente")
+        
+        with gr.Row():
+            with gr.Column():
+                file_input = gr.File(
+                    label="Seleccionar archivo",
+                    file_types=SUPPORTED_FORMATS
+                )
+                
+                preset_dropdown = gr.Dropdown(
+                    choices=list(COMPRESSION_PRESETS.keys()),
+                    value="Compresión Alta",
+                    label="Nivel de compresión"
+                )
+                
+                compress_btn = gr.Button("🚀 Comprimir", variant="primary")
+            
+            with gr.Column():
+                output_file = gr.File(label="Archivo comprimido")
+                status_text = gr.Textbox(label="Estado", interactive=False)
+        
+        # Información sobre formatos soportados
+        gr.Markdown(
+            f"**Formatos soportados:**\n"
+            f"- Video: {', '.join(VIDEO_FORMATS)}\n"
+            f"- Audio: {', '.join(AUDIO_FORMATS)}"
+        )
+        
+        # Evento de compresión
+        compress_btn.click(
+            fn=compress_media,
+            inputs=[file_input, preset_dropdown],
+            outputs=[output_file, status_text]
+        )
+    
+    # Lanzar interfaz
+    iface.launch(
+        share=False,
+        server_name="127.0.0.1",
+        server_port=7862,
+        show_error=True,
+        inbrowser=True
+    )
+
+if __name__ == "__main__":
+    run_app()

ffmpeg.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fcb0cb525085cc5be3ad4be16799d60786b65cc36951622a018d00f78c0fb5d
+size 98730496

requirements.txt

@@ -0,0 +1,6 @@
+gradio==4.44.0
+ffmpeg-python==0.2.0
+Pillow==10.4.0
+imageio==2.35.1
+numpy==2.1.1
+requests==2.32.3