proyecto

Dockerfile

@@ -0,0 +1,37 @@
+# Imagen base con Python
+FROM python:3.10-slim
+
+# Instalar R y herramientas necesarias del sistema
+RUN apt-get update && apt-get install -y \
+    r-base \
+    libcurl4-openssl-dev \
+    libssl-dev \
+    libxml2-dev \
+    libfontconfig1 \
+    libfreetype6 \
+    libpng-dev \
+    libtiff5 \
+    libjpeg62-turbo-dev \
+    build-essential \
+    fonts-dejavu \
+    unzip \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Instalar paquetes de R necesarios
+RUN R -e "install.packages(c('ggplot2', 'dplyr', 'RColorBrewer'), repos='http://cran.rstudio.com/')"
+
+# Establecer directorio de trabajo
+WORKDIR /app
+
+# Copiar archivos del proyecto
+COPY . .
+
+# Instalar dependencias de Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Exponer el puerto de Gradio (por convención)
+EXPOSE 7860
+
+# Ejecutar la aplicación
+CMD ["python", "app.py"]

analisis.py

@@ -0,0 +1,167 @@
+import os
+import tempfile
+import pandas as pd
+from ydata_profiling import ProfileReport
+from load_dataframe import cargar_dataframe, analizar_nulos_por_columna, get_file_metadata
+from graficos_r import generar_histograma_r, generar_barras_r, generar_boxplot_r
+
+class AnalizadorDatos:
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.df = None
+        self.metadata = None
+        self.nulos_por_columna = None
+        self.reporte_path = None
+        self.graficos = {}
+        
+    def cargar_datos(self) -> bool:
+        """Carga y valida los datos"""
+        self.df, error = cargar_dataframe(self.file_path)
+        if error:
+            print(error)
+            return False
+        
+        self.metadata = get_file_metadata(self.file_path)
+        self.nulos_por_columna = analizar_nulos_por_columna(self.df)
+        return True
+    
+    def generar_reporte_nulos(self) -> str:
+        """Genera un reporte detallado de valores nulos por columna"""
+        if not self.nulos_por_columna:
+            return "No hay datos de nulos disponibles"
+            
+        reporte = "=== ANÁLISIS DE VALORES NULOS POR COLUMNA ===\n\n"
+        reporte += f"Total filas en dataset: {len(self.df)}\n"
+        reporte += f"Total columnas: {len(self.df.columns)}\n\n"
+        
+        for col in self.nulos_por_columna:
+            reporte += f"Columna: {col['nombre_columna']} ({col['tipo_dato']})\n"
+            reporte += f"  - Valores nulos: {col['total_nulos']} ({col['porcentaje_nulos']}%)\n"
+            reporte += f"  - Valores no nulos: {col['no_nulos']} ({col['porcentaje_no_nulos']}%)\n"
+            reporte += f"  - Valores únicos: {col['valores_unicos']}\n"
+            
+            if col['ejemplo_valores']:
+                reporte += f"  - Ejemplos: {', '.join(col['ejemplo_valores'])}\n"
+            else:
+                reporte += "  - Ejemplos: TODOS SON NULOS\n"
+            
+            # Recomendación basada en porcentaje de nulos
+            if col['porcentaje_nulos'] > 30:
+                reporte += "  - RECOMENDACIÓN: Considerar eliminar o imputar esta columna\n"
+            elif col['porcentaje_nulos'] > 0:
+                reporte += "  - RECOMENDACIÓN: Evaluar imputación de valores\n"
+            else:
+                reporte += "  - RECOMENDACIÓN: Sin problemas de nulos\n"
+            
+            reporte += "\n"
+        
+        return reporte
+    
+    def generar_reporte(self, minimal: bool = True) -> str:
+        """Genera reporte de profiling"""
+        try:
+            self.reporte_path = tempfile.NamedTemporaryFile(
+                suffix='.html', 
+                delete=False
+            ).name
+            
+            profile = ProfileReport(
+                self.df,
+                title=f"Reporte de Análisis - {self.metadata['nombre']}",
+                minimal=minimal,
+                explorative=True
+            )
+            profile.to_file(self.reporte_path)
+            return self.reporte_path
+        except Exception as e:
+            print(f"Error generando reporte: {e}")
+            return None
+    
+    def generar_graficos(self, columnas_analisis: list) -> dict:
+        """Genera gráficos para las columnas especificadas"""
+        os.makedirs("graficos", exist_ok=True)
+        
+        for col in columnas_analisis:
+            if col not in self.df.columns:
+                continue
+                
+            output_path = f"graficos/{col}.png"
+            
+            if pd.api.types.is_numeric_dtype(self.df[col]):
+                path = generar_histograma_r(self.df, col, output_path)
+                if path:
+                    self.graficos[col] = {'tipo': 'histograma', 'path': path}
+                    
+                # Gráfico adicional si hay una columna categórica adecuada
+                categoricas = [c for c in self.df.columns 
+                             if pd.api.types.is_categorical_dtype(self.df[c]) 
+                             or pd.api.types.is_object_dtype(self.df[c])]
+                if categoricas and len(self.df[categoricas[0]].unique()) <= 10:
+                    path = generar_boxplot_r(self.df, col, categoricas[0], f"graficos/{col}_by_{categoricas[0]}.png")
+                    if path:
+                        self.graficos[f"{col}_by_{categoricas[0]}"] = {'tipo': 'boxplot', 'path': path}
+            else:
+                path = generar_barras_r(self.df, col, output_path)
+                if path:
+                    self.graficos[col] = {'tipo': 'barras', 'path': path}
+        
+        return self.graficos
+    
+    def resumen_analisis(self) -> dict:
+        """Genera un resumen estructurado del análisis"""
+        return {
+            'metadata': self.metadata,
+            'estadisticas': {
+                'filas': len(self.df),
+                'columnas': len(self.df.columns),
+                'columnas_con_nulos': sum(1 for col in self.nulos_por_columna if col['total_nulos'] > 0),
+                'columnas_completas': sum(1 for col in self.nulos_por_columna if col['total_nulos'] == 0)
+            },
+            'nulos_por_columna': self.nulos_por_columna,
+            'graficos_generados': list(self.graficos.keys()),
+            'rutas': {
+                'reporte': self.reporte_path,
+                'graficos': {k: v['path'] for k, v in self.graficos.items()}
+            }
+        }
+
+
+def analisis_completo(file_path: str, columnas_analisis: list = None):
+    """Función principal para ejecutar análisis completo"""
+    analizador = AnalizadorDatos(file_path)
+    
+    if not analizador.cargar_datos():
+        return None
+    
+    # Si no se especifican columnas, usar las que tienen menos del 50% de nulos
+    if not columnas_analisis:
+        columnas_validas = [
+            col['nombre_columna'] for col in analizador.nulos_por_columna 
+            if col['porcentaje_nulos'] < 50
+        ]
+        columnas_analisis = columnas_validas  # Limitar a 5 columnas por defecto
+    
+    # Generar outputs
+    analizador.generar_reporte()
+    analizador.generar_graficos(columnas_analisis)
+    
+    # Imprimir reporte de nulos en consola
+    print(analizador.generar_reporte_nulos())
+    
+    return analizador.resumen_analisis()
+
+
+if __name__ == "__main__":
+    # Ejemplo de uso con análisis mejorado de nulos
+    resumen = analisis_completo(
+        file_path="Grammy Award Nominees and Winners 1958-2024.csv"
+    )
+    
+    if resumen:
+        print("\n=== RESUMEN GENERAL ===")
+        print(f"Columnas con nulos: {resumen['estadisticas']['columnas_con_nulos']}")
+        print(f"Columnas completas: {resumen['estadisticas']['columnas_completas']}")
+        
+        print("\nTop 5 columnas con más nulos:")
+        for col in resumen['nulos_por_columna'][:5]:
+            print(f"- {col['nombre_columna']}: {col['porcentaje_nulos']}% nulos")

app.py

@@ -0,0 +1,76 @@
+import gradio as gr
+from analisis import AnalizadorDatos
+
+analizador_global = None 
+
+def cargar_y_mostrar(file):
+    global analizador_global
+    analizador = AnalizadorDatos(file.name)
+
+    if not analizador.cargar_datos():
+        return "Error al cargar archivo", None, None
+
+    analizador_global = analizador
+
+    return (
+        f"Archivo cargado correctamente: {analizador.metadata['nombre']}\n"
+        f"- Tamaño: {analizador.metadata['tamaño_mb']} MB\n"
+        f"- Filas: {len(analizador.df)}\n"
+        f"- Columnas: {len(analizador.df.columns)}\n",
+        analizador.df.head(),
+        [col['nombre_columna'] for col in analizador.nulos_por_columna]
+    )
+
+def generar_graficos(columnas):
+    global analizador_global
+    if not analizador_global:
+        return None
+
+    graficos = analizador_global.generar_graficos(columnas)
+    return [gr.Image(value=v['path'], label=k) for k, v in graficos.items()]
+
+def generar_reporte():
+    global analizador_global
+    if not analizador_global:
+        return None, None
+
+    reporte_path = analizador_global.generar_reporte()
+    reporte_nulos = analizador_global.generar_reporte_nulos()
+    return reporte_path, reporte_nulos
+
+with gr.Blocks(title="Análisis exploratorio avanzado con R y Python") as demo:
+    gr.Markdown("## Exploración de datos con R, Python y Gradio")
+
+    with gr.Row():
+        archivo_input = gr.File(label="Sube un archivo", file_types=[".csv", ".xlsx", ".json", ".parquet"])
+        cargar_btn = gr.Button("Cargar archivo")
+
+    estado_carga = gr.Textbox(label="Estado de carga", interactive=False)
+    df_preview = gr.Dataframe(label="Vista previa")
+    columnas_selector = gr.CheckboxGroup(label="Selecciona columnas para análisis", choices=[])
+
+    cargar_btn.click(
+        fn=cargar_y_mostrar,
+        inputs=[archivo_input],
+        outputs=[estado_carga, df_preview, columnas_selector]
+    )
+
+    graficos_output = gr.Group(label="Gráficos generados")
+
+    graficar_btn = gr.Button("Generar gráficos")
+    graficar_btn.click(fn=generar_graficos, inputs=[columnas_selector], outputs=[graficos_output])
+
+    with gr.Row():
+        generar_reporte_btn = gr.Button("Generar reporte")
+        reporte_html = gr.File(label="Descargar reporte")
+        reporte_nulos = gr.Textbox(label="Análisis de nulos")
+
+    generar_reporte_btn.click(
+        fn=generar_reporte,
+        inputs=[],
+        outputs=[reporte_html, reporte_nulos]
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

graficos_r.py

@@ -0,0 +1,167 @@
+import os
+import pandas as pd
+import rpy2.robjects as ro
+from rpy2.robjects import pandas2ri
+from rpy2.robjects.conversion import localconverter
+from rpy2.robjects.packages import importr
+import matplotlib.pyplot as plt
+
+# Configuración de temas y estilos en R
+def configurar_estilos_r():
+    """Configura temas y estilos globales para ggplot2"""
+    ro.r("""
+    library(ggplot2)
+    library(RColorBrewer)
+    
+    # Tema personalizado
+    tema_personalizado <- theme_minimal() +
+        theme(
+            text = element_text(family = "sans", size = 12),
+            plot.title = element_text(size = 16, face = "bold", hjust = 0.5),
+            plot.subtitle = element_text(size = 12, hjust = 0.5),
+            axis.title = element_text(face = "bold"),
+            legend.position = "top",
+            panel.grid.major = element_line(color = "gray90"),
+            panel.grid.minor = element_blank(),
+            plot.margin = unit(c(1, 1, 1, 1), "cm")
+        )
+    
+    # Paleta de colores
+    colores <- brewer.pal(8, "Set2")
+    """)
+
+# Configurar estilos al importar el módulo
+configurar_estilos_r()
+
+def generar_histograma_r(df: pd.DataFrame, columna: str, output_path: str) -> str:
+    """
+    Genera un histograma estilizado con ggplot2
+    """
+    try:
+        with localconverter(ro.default_converter + pandas2ri.converter):
+            r_df = ro.conversion.py2rpy(df[[columna]])
+        
+        ro.r(f"""
+        library(ggplot2)
+        p <- ggplot({r_df.r_repr()}, aes(x={columna})) +
+            geom_histogram(
+                binwidth = diff(range({r_df.r_repr()}${columna}, na.rm=TRUE))/30,
+                fill = "#2c7fb8", 
+                color = "#ffffff", 
+                alpha = 0.8
+            ) +
+            labs(
+                title = "Distribución de {columna}",
+                x = "{columna}",
+                y = "Frecuencia"
+            ) +
+            tema_personalizado +
+            scale_fill_brewer(palette = "Set2")
+        
+        ggsave(
+            filename = "{output_path}",
+            plot = p,
+            width = 10,
+            height = 6,
+            dpi = 300
+        )
+        """)
+        
+        return output_path if os.path.exists(output_path) else None
+    
+    except Exception as e:
+        print(f"Error al generar histograma: {e}")
+        return None
+
+
+def generar_barras_r(df: pd.DataFrame, columna: str, output_path: str) -> str:
+    """
+    Genera gráfico de barras para variables categóricas
+    """
+    try:
+        with localconverter(ro.default_converter + pandas2ri.converter):
+            r_df = ro.conversion.py2rpy(df[[columna]])
+        
+        ro.r(f"""
+        library(ggplot2)
+        library(dplyr)
+        
+        top_data <- {r_df.r_repr()} %>%
+            group_by({columna}) %>%
+            summarise(count = n()) %>%
+            arrange(desc(count)) %>%
+            head(10)
+        
+        p <- ggplot(top_data, aes(
+                x = reorder({columna}, count), 
+                y = count,
+                fill = {columna}
+            )) +
+            geom_bar(stat = "identity") +
+            coord_flip() +
+            labs(
+                title = "Top 10 categorías en {columna}",
+                x = "",
+                y = "Conteo"
+            ) +
+            tema_personalizado +
+            scale_fill_brewer(palette = "Set2") +
+            theme(legend.position = "none")
+        
+        ggsave(
+            filename = "{output_path}",
+            plot = p,
+            width = 10,
+            height = 6,
+            dpi = 300
+        )
+        """)
+        
+        return output_path if os.path.exists(output_path) else None
+    
+    except Exception as e:
+        print(f"Error al generar gráfico de barras: {e}")
+        return None
+
+
+def generar_boxplot_r(df: pd.DataFrame, columna: str, grupo: str, output_path: str) -> str:
+    """
+    Genera boxplot comparativo por grupos
+    """
+    try:
+        with localconverter(ro.default_converter + pandas2ri.converter):
+            r_df = ro.conversion.py2rpy(df[[columna, grupo]])
+        
+        ro.r(f"""
+        p <- ggplot({r_df.r_repr()}, aes(
+                x = {grupo}, 
+                y = {columna},
+                fill = {grupo}
+            )) +
+            geom_boxplot(
+                alpha = 0.7,
+                outlier.color = "#e34a33"
+            ) +
+            labs(
+                title = "Distribución de {columna} por {grupo}",
+                x = "{grupo}",
+                y = "{columna}"
+            ) +
+            tema_personalizado +
+            scale_fill_brewer(palette = "Set2") +
+            theme(axis.text.x = element_text(angle = 45, hjust = 1))
+        
+        ggsave(
+            filename = "{output_path}",
+            plot = p,
+            width = 10,
+            height = 6,
+            dpi = 300
+        )
+        """)
+        
+        return output_path if os.path.exists(output_path) else None
+    
+    except Exception as e:
+        print(f"Error al generar boxplot: {e}")
+        return None

load_dataframe.py

@@ -0,0 +1,94 @@
+import os
+import pandas as pd
+from typing import Tuple, Optional, Dict, List
+import datetime
+
+def cargar_dataframe(file_path: str) -> Tuple[Optional[pd.DataFrame], Optional[str]]:
+    """
+    Carga un DataFrame desde múltiples formatos con validación robusta
+    """
+    if not os.path.exists(file_path):
+        return None, f"Error: El archivo {file_path} no existe"
+    
+    try:
+        ext = os.path.splitext(file_path)[1].lower()
+        
+        if ext == '.csv':
+            df = pd.read_csv(file_path, encoding='utf-8', na_values=['', 'NA', 'NULL', 'NaN'])
+        elif ext in ('.xls', '.xlsx'):
+            df = pd.read_excel(file_path, na_values=['', 'NA', 'NULL', 'NaN'])
+        elif ext == '.parquet':
+            df = pd.read_parquet(file_path)
+        elif ext == '.json':
+            df = pd.read_json(file_path)
+        else:
+            return None, f"Error: Formato {ext} no soportado"
+        
+        # Convertir strings a categorías para optimización
+        for col in df.select_dtypes(include=['object']):
+            if len(df[col].unique()) / len(df[col]) < 0.5:
+                df[col] = df[col].astype('category')
+                
+        return df, None
+        
+    except Exception as e:
+        return None, f"Error al cargar {file_path}: {str(e)}"
+
+def analizar_nulos_por_columna(df: pd.DataFrame) -> List[Dict]:
+    """
+    Analiza valores nulos por columna con métricas detalladas
+    
+    Returns:
+        Lista de diccionarios con:
+        - nombre_columna
+        - tipo_dato
+        - total_nulos
+        - porcentaje_nulos
+        - no_nulos
+        - porcentaje_no_nulos
+        - ejemplo_valores (3 primeros no nulos)
+    """
+    analisis = []
+    total_filas = len(df)
+    
+    for columna in df.columns:
+        nulos = df[columna].isnull().sum()
+        no_nulos = total_filas - nulos
+        porcentaje_nulos = (nulos / total_filas) * 100 if total_filas > 0 else 0
+        valores_unicos = df[columna].nunique()
+        
+        # Ejemplos de valores (excluyendo nulos)
+        ejemplos = []
+        if no_nulos > 0:
+            ejemplos = df[columna].dropna().head(3).tolist()
+            # Convertir a string si es necesario para serialización
+            ejemplos = [str(x) for x in ejemplos]
+        
+        analisis.append({
+            'nombre_columna': columna,
+            'tipo_dato': str(df[columna].dtype),
+            'total_nulos': nulos,
+            'porcentaje_nulos': round(porcentaje_nulos, 2),
+            'no_nulos': no_nulos,
+            'porcentaje_no_nulos': round(100 - porcentaje_nulos, 2),
+            'valores_unicos': valores_unicos,
+            'ejemplo_valores': ejemplos
+        })
+    
+    # Ordenar por porcentaje de nulos descendente
+    return sorted(analisis, key=lambda x: x['porcentaje_nulos'], reverse=True)
+
+def get_file_metadata(file_path: str) -> Dict:
+    """
+    Obtiene metadatos detallados del archivo
+    """
+    stats = os.stat(file_path)
+    return {
+        'nombre': os.path.basename(file_path),
+        'ruta': os.path.abspath(file_path),
+        'tamaño_bytes': stats.st_size,
+        'tamaño_mb': round(stats.st_size / (1024 * 1024), 2),
+        'fecha_modificacion': datetime.datetime.fromtimestamp(stats.st_mtime),
+        'extension': os.path.splitext(file_path)[1].lower(),
+        'encoding': 'utf-8'  # Se puede detectar con chardet si es necesario
+    }

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+numpy
+pandas
+matplotlib
+seaborn
+rpy2
+ydata-profiling