Delete app.py

app.py

@@ -1,552 +0,0 @@
-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
-    )