app.py

import os
import streamlit as st
import pandas as pd
import math
import matplotlib.pyplot as plt

st.markdown(
    """
    <style>
    .csv_download_button {
        display: none;
    }
    </style>
    """,
    unsafe_allow_html=True
)

directorio = os.getcwd()

def listar_archivos_excel(directorio):
    return [f for f in os.listdir(directorio) if f.endswith(('.xls', '.xlsx', '.csv'))]

def leer_archivo(file):
    try:
        extension_archivo = file.name.split(".")[-1]
        if extension_archivo == "csv":
            return pd.read_csv(file)
        elif extension_archivo in {"xlsx", "xls"}:
            return pd.read_excel(file)
        else:
            st.error("Formato de archivo no soportado. Por favor, suba un archivo CSV o Excel.")
            return None
    except Exception as e:
        st.error(f"Error al leer el archivo: {e}")
        return None

def formatear_datos(datos):
    return datos.applymap(lambda x: f"{x:.0f}" if isinstance(x, (int, float)) else x)

def mostrar_datos(datos, num_filas, pagina=0):
    total_filas = len(datos)
    datos_formateados = formatear_datos(datos)
    if total_filas <= num_filas:
        st.dataframe(datos_formateados.head(num_filas))
    else:
        start_row = pagina * num_filas
        end_row = start_row + num_filas
        df_html = datos_formateados.iloc[start_row:end_row].to_html()
        st.markdown(df_html, unsafe_allow_html=True)
        if start_row > 0:
            if st.button("Anterior", key="prev"):
                st.session_state.pagina -= 1
        if end_row < total_filas:
            if st.button("Siguiente", key="next"):
                st.session_state.pagina += 1

def realizar_calculos(datos):
    try:
        st.write("### Cálculos")
        for columna in datos.columns:
            if pd.api.types.is_numeric_dtype(datos[columna]):
                suma_columna = datos[columna].sum()
                media_columna = datos[columna].mean()
                mediana_columna = datos[columna].median()
                st.write(f"Cálculos para la columna: {columna}")
                st.write(f"Suma: {suma_columna}")
                st.write(f"Media: {media_columna}")
                st.write(f"Mediana: {mediana_columna}")
    except Exception as e:
        st.error(f"Error al realizar cálculos: {e}")

def realizar_operacion_matematica(df, columnas_seleccionadas, operacion):
    try:
        if not columnas_seleccionadas:
            st.error("No se han seleccionado columnas.")
            return df
        
        operaciones = {
            "sqrt": math.sqrt,
            "log": math.log,
            "exp": math.exp,
            "sin": math.sin,
            "cos": math.cos,
            "tan": math.tan
        }
        
        if operacion in operaciones:
            resultado = df[columnas_seleccionadas].applymap(operaciones[operacion])
        elif operacion == "multiply":
            resultado = df[columnas_seleccionadas].prod(axis=1)
        elif operacion == "add":
            resultado = df[columnas_seleccionadas].sum(axis=1)
        elif operacion == "subtract" and len(columnas_seleccionadas) == 2:
            resultado = df[columnas_seleccionadas[0]] - df[columnas_seleccionadas[1]]
        else:
            st.error("Operación no soportada o selección de columnas incorrecta.")
            return df

        df[f"{operacion}_resultado"] = resultado
        return df
    except Exception as e:
        st.error(f"Error al realizar la operación matemática: {e}")
        return df

def graficar_datos(datos, tipo_grafico, variables_x, variables_y):
    try:
        plt.figure(figsize=(8, 6))
        for x_var in variables_x:
            for y_var in variables_y:
                if tipo_grafico == "Dispersión":
                    plt.scatter(datos[x_var], datos[y_var], label=f"{x_var} vs {y_var}")
                elif tipo_grafico == "Línea":
                    plt.plot(datos[x_var], datos[y_var], label=f"{x_var} vs {y_var}")
                elif tipo_grafico == "Barras":
                    plt.bar(range(len(datos)), datos[y_var], label=y_var)
        
        plt.xlabel("Valores de X")
        plt.ylabel("Valores de Y")
        plt.title(f"Gráfico de {tipo_grafico}")
        plt.legend()
        st.pyplot()
    except Exception as e:
        st.error(f"Error al graficar los datos: {e}")

def buscar_en_archivos(archivos, termino):
    resultados = {}
    num_archivos = len(archivos)
    progreso = st.progress(0)
    
    for i, archivo in enumerate(archivos):
        try:
            if archivo.endswith('.csv'):
                datos = pd.read_csv(archivo)
            elif archivo.endswith(('.xlsx', '.xls')):
                datos = pd.read_excel(archivo)
            coincidencias = datos.apply(lambda fila: fila.astype(str).str.contains(termino, case=False).any(), axis=1)
            resultados[archivo] = datos[coincidencias]
        except Exception as e:
            st.error(f"Error al buscar en el archivo {archivo}: {e}")
        progreso.progress((i + 1) / num_archivos)
    
    return resultados

def main():
    try:
        st.title("Base de Datos XLS")
        
        if "pagina" not in st.session_state:
            st.session_state.pagina = 0
        
        st.sidebar.title("Archivos Excel Disponibles")
        archivos_excel = listar_archivos_excel(directorio)
        archivo_seleccionado = st.sidebar.selectbox("Selecciona un archivo Excel", archivos_excel)
        
        termino_busqueda = st.sidebar.text_input("Buscar en todos los archivos", "")
        if st.sidebar.button("Buscar"):
            resultados_busqueda = buscar_en_archivos(archivos_excel, termino_busqueda)
            st.write("### Resultados de la búsqueda global")
            for archivo, resultados in resultados_busqueda.items():
                st.write(f"#### {archivo}")
                st.dataframe(resultados.applymap(lambda x: f"{x:.0f}" if isinstance(x, (int, float)) else x))
        
        if archivo_seleccionado:
            ruta_archivo = os.path.join(directorio, archivo_seleccionado)
            with open(ruta_archivo, "rb") as file:
                datos = leer_archivo(file)
                if datos is not None:
                    num_filas = st.sidebar.slider("Número de filas a mostrar", min_value=1, max_value=10000, value=10)
                    mostrar_datos(datos, num_filas, st.session_state.pagina)
                    
                    if st.sidebar.checkbox("Mostrar opciones adicionales"):
                        realizar_calculos(datos)

                        st.write("### Visualizador de Gráficos")
                        st.write("Selecciona variables para la visualización:")
                        tipo_grafico = st.selectbox("Tipo de Gráfico", options=["Dispersión", "Línea", "Barras"])
                        variables_x = st.multiselect("Variables X", options=datos.columns)
                        variables_y = st.multiselect("Variables Y", options=datos.columns)
                        
                        columnas_seleccionadas = st.multiselect("Selecciona columnas:", options=datos.columns)
                        operacion = st.selectbox("Selecciona una operación:", ["sqrt", "log", "exp", "sin", "cos", "tan", "multiply", "add", "subtract"])

                        if st.button("Calcular"):
                            datos = realizar_operacion_matematica(datos, columnas_seleccionadas, operacion)
                            st.write(datos.applymap(lambda x: f"{x:.0f}" if isinstance(x, (int, float)) else x))
                        if st.button("Graficar"):
                            graficar_datos(datos, tipo_grafico, variables_x, variables_y)
    except Exception as e:
        st.error(f"Ocurrió un error: {e}")

if __name__ == "__main__":
    main()