Update app.py

app.py

@@ -1,213 +1,131 @@
 import gradio as gr
 import pandas as pd
 import plotly.express as px
-import requests
-import msal
-import io
-import os # Importante: Módulo para leer variables de entorno
 from datetime import datetime
+import os
 
-# --- 1. CLASE HELPER PARA LA CONEXIÓN CON ONEDRIVE (MODIFICADA) ---
-
-class OneDriveHelper:
-    """
-    Gestiona la autenticación y operaciones con la API de MS Graph,
-    leyendo la configuración desde las variables de entorno (Secrets de HF).
-    """
-    def __init__(self):
-        # Leer configuración desde los "Secrets" de Hugging Face Spaces
-        self.client_id = os.getenv('CLIENT_ID')
-        self.client_secret = os.getenv('CLIENT_SECRET')
-        self.tenant_id = os.getenv('TENANT_ID')
-        self.user_id = os.getenv('USER_ID')
-        self.file_path = os.getenv('ONEDRIVE_FILE_PATH')
-
-        if not all([self.client_id, self.client_secret, self.tenant_id, self.user_id, self.file_path]):
-            raise ValueError("Faltan una o más variables de entorno (Secrets) para la configuración de OneDrive.")
-
-        self.authority = f"https://login.microsoftonline.com/{self.tenant_id}"
-        self.graph_endpoint = "https://graph.microsoft.com/v1.0"
-        
-        self.app = msal.ConfidentialClientApplication(
-            self.client_id,
-            authority=self.authority,
-            client_credential=self.client_secret
+# --- 1. CONFIGURACIÓN DEL ARCHIVO CSV ---
+CSV_FILE = "cronograma.csv"
+
+# --- 2. LÓGICA DE CARGA Y GUARDADO DE DATOS ---
+
+def load_data_from_csv():
+    """Carga los datos desde el archivo CSV al iniciar la aplicación."""
+    try:
+        # Lee el CSV y convierte las columnas de fecha al formato correcto
+        df = pd.read_csv(
+            CSV_FILE, 
+            parse_dates=['Fecha de Inicio', 'Fecha de Fin']
         )
-        self.token = None
-
-    def get_access_token(self):
-        """Obtiene un token de acceso para la API de Graph."""
-        # Siempre se adquiere un nuevo token para evitar problemas de expiración en entornos serverless
-        result = self.app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
-        if "access_token" in result:
-            self.token = result['access_token']
-            return self.token
-        else:
-            raise Exception("No se pudo obtener el token de acceso: " + result.get("error_description", ""))
-
-    def download_excel_to_dataframe(self):
-        """Descarga el archivo Excel de OneDrive y lo carga en un DataFrame."""
-        try:
-            token = self.get_access_token()
-            headers = {'Authorization': 'Bearer ' + token}
-            url = f"{self.graph_endpoint}/users/{self.user_id}/drive/root:{self.file_path}:/content"
-            response = requests.get(url, headers=headers)
-            
-            if response.status_code == 200:
-                excel_data = io.BytesIO(response.content)
-                df = pd.read_excel(excel_data, engine='openpyxl')
-                df['Fecha de Inicio'] = pd.to_datetime(df['Fecha de Inicio'])
-                df['Fecha de Fin'] = pd.to_datetime(df['Fecha de Fin'])
-                return df
-            elif response.status_code == 404:
-                print("Advertencia: Archivo no encontrado. Se creará uno nuevo al guardar.")
-                return self.create_empty_dataframe()
-            else:
-                response.raise_for_status()
-        except Exception as e:
-            print(f"Error al descargar el archivo: {e}")
-            return self.create_empty_dataframe()
-
-    def upload_dataframe_to_excel(self, df):
-        """Sube un DataFrame a OneDrive, sobrescribiendo el archivo Excel."""
-        try:
-            token = self.get_access_token()
-            headers = {'Authorization': 'Bearer ' + token, 'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'}
-            
-            output_buffer = io.BytesIO()
-            df.to_excel(output_buffer, index=False, engine='openpyxl')
-            output_buffer.seek(0)
-            
-            url = f"{self.graph_endpoint}/users/{self.user_id}/drive/root:{self.file_path}:/content"
-            response = requests.put(url, headers=headers, data=output_buffer.read())
-            response.raise_for_status()
-            print("Archivo guardado exitosamente en OneDrive.")
-            return True
-        except Exception as e:
-            gr.Error(f"Error al guardar en OneDrive: {e}")
-            return False
-
-    @staticmethod
-    def create_empty_dataframe():
-        """Crea la estructura del DataFrame si el archivo no existe."""
-        return pd.DataFrame(columns=[
-            'ID', 'Tarea', 'Fase', 'Responsable', 'Fecha de Inicio', 
-            'Fecha de Fin', 'Estado', 'Progreso (%)', 'Descripción'
-        ])
-
-# --- El resto del código de la aplicación (lógica de UI y funciones) es idéntico ---
-
-# --- 2. INSTANCIACIÓN Y CARGA INICIAL DE DATOS ---
-try:
-    onedrive = OneDriveHelper()
-    initial_df = onedrive.download_excel_to_dataframe()
-except ValueError as e:
-    # Manejar error si los secrets no están configurados
-    gr.Warning(str(e))
-    initial_df = OneDriveHelper.create_empty_dataframe()
-
-
-# --- 3. FUNCIONES DE LÓGICA DE LA APLICACIÓN (SIN CAMBIOS) ---
+        return df
+    except FileNotFoundError:
+        # Si el archivo no existe, crea un DataFrame vacío con las columnas correctas
+        return create_empty_dataframe()
+    except Exception as e:
+        print(f"Error al leer el CSV: {e}")
+        return create_empty_dataframe()
+
+def save_data_to_csv(df):
+    """Guarda el DataFrame completo en el archivo CSV."""
+    try:
+        df.to_csv(CSV_FILE, index=False)
+        print(f"Datos guardados exitosamente en {CSV_FILE}")
+    except Exception as e:
+        gr.Error(f"No se pudo guardar el archivo CSV: {e}")
+
+def create_empty_dataframe():
+    """Crea la estructura del DataFrame si el archivo no existe o está vacío."""
+    columns = ['ID', 'Tarea', 'Fase', 'Responsable', 'Fecha de Inicio', 'Fecha de Fin', 'Estado', 'Progreso (%)', 'Descripción']
+    df = pd.DataFrame(columns=columns)
+    # Asegurar tipos de datos correctos para un df vacío
+    df['ID'] = df['ID'].astype(int)
+    df['Progreso (%)'] = df['Progreso (%)'].astype(int)
+    return df
+
+# --- Carga inicial de datos ---
+initial_df = load_data_from_csv()
+
+# --- 3. FUNCIONES DE LA APLICACIÓN (LÓGICA DE UI) ---
+# (Las funciones create_gantt_chart y populate_form_on_select no cambian)
 
 def create_gantt_chart(df):
-    """Genera un diagrama de Gantt interactivo con Plotly."""
-    if df.empty or 'Fecha de Inicio' not in df.columns or 'Fecha de Fin' not in df.columns:
-        return px.timeline(title="Cronograma de Proyecto (Sin datos)")
-
-    status_colors = {
-        'No Iniciada': 'lightgrey', 'En Progreso': 'blue', 'Completada': 'green',
-        'Retrasada': 'orange', 'Bloqueada': 'red'
-    }
-    fig = px.timeline(
-        df, x_start="Fecha de Inicio", x_end="Fecha de Fin", y="Tarea",
-        color="Estado", color_discrete_map=status_colors, title="Diagrama de Gantt del Proyecto",
-        labels={"Tarea": "Actividades"}
-    )
+    if df.empty or df['Fecha de Inicio'].isnull().all() or df['Fecha de Fin'].isnull().all():
+        return px.timeline(title="Cronograma de Proyecto")
+    
+    status_colors = {'No Iniciada': 'lightgrey', 'En Progreso': 'blue', 'Completada': 'green', 'Retrasada': 'orange', 'Bloqueada': 'red'}
+    df_filtered = df.dropna(subset=['Fecha de Inicio', 'Fecha de Fin'])
+    fig = px.timeline(df_filtered, x_start="Fecha de Inicio", x_end="Fecha de Fin", y="Tarea", color="Estado", color_discrete_map=status_colors, title="Diagrama de Gantt del Proyecto")
     fig.update_yaxes(autorange="reversed")
-    fig.update_layout(title_x=0.5, font=dict(size=12))
     return fig
 
-def filter_data(df, phases, responsibles, statuses):
-    """Filtra el DataFrame según los criterios seleccionados."""
-    filtered_df = df.copy()
-    if phases: filtered_df = filtered_df[filtered_df['Fase'].isin(phases)]
-    if responsibles: filtered_df = filtered_df[filtered_df['Responsable'].isin(responsibles)]
-    if statuses: filtered_df = filtered_df[filtered_df['Estado'].isin(statuses)]
-    return filtered_df
+def populate_form_on_select(df, evt: gr.SelectData):
+    if evt.index is None: return None, "", "", "", None, None, "No Iniciada", 0, ""
+    selected_row = df.iloc[evt.index[0]]
+    start_date = selected_row['Fecha de Inicio'].to_pydatetime().date() if pd.notna(selected_row['Fecha de Inicio']) else None
+    end_date = selected_row['Fecha de Fin'].to_pydatetime().date() if pd.notna(selected_row['Fecha de Fin']) else None
+    return (selected_row['ID'], selected_row['Tarea'], selected_row['Fase'], selected_row['Responsable'], start_date, end_date, selected_row['Estado'], selected_row['Progreso (%)'], selected_row['Descripción'])
 
 def manage_tasks(df_state, *args):
-    """Función central para añadir, actualizar o eliminar tareas."""
-    action, selected_id, task_id, name, phase, responsible, start_date, end_date, status, progress, desc, new_phase, new_resp = args
+    """Función central que ahora también guarda los cambios en el CSV."""
+    action, selected_id, task_id, name, phase, responsible, start_date, end_date, status, progress, desc = args
     df = df_state.copy()
 
+    # Lógica para añadir, actualizar o eliminar
     if action == "add":
         if not name or not start_date or not end_date:
             gr.Warning("Nombre, Fecha de Inicio y Fecha de Fin son obligatorios.")
             return df, create_gantt_chart(df), gr.update(), gr.update()
-        new_id = df['ID'].max() + 1 if not df.empty else 1
-        final_phase = new_phase if new_phase else phase
-        final_resp = new_resp if new_resp else responsible
-        new_task = pd.DataFrame([{'ID': new_id, 'Tarea': name, 'Fase': final_phase, 'Responsable': final_resp,
-            'Fecha de Inicio': start_date, 'Fecha de Fin': end_date, 'Estado': status,
-            'Progreso (%)': progress, 'Descripción': desc}])
+        new_id = int(df['ID'].max() + 1) if not df.empty else 1
+        new_task = pd.DataFrame([{'ID': new_id, 'Tarea': name, 'Fase': phase, 'Responsable': responsible, 'Fecha de Inicio': start_date, 'Fecha de Fin': end_date, 'Estado': status, 'Progreso (%)': progress, 'Descripción': desc}])
         df = pd.concat([df, new_task], ignore_index=True)
-        gr.Info(f"Tarea '{name}' añadida con éxito.")
+        gr.Info(f"Tarea '{name}' añadida.")
     
     elif action == "update":
         if selected_id is None:
-            gr.Warning("Selecciona una tarea de la tabla para actualizar.")
+            gr.Warning("Selecciona una tarea para actualizar.")
             return df, create_gantt_chart(df), gr.update(), gr.update()
-        final_phase = new_phase if new_phase else phase
-        final_resp = new_resp if new_resp else responsible
-        df.loc[df['ID'] == selected_id, ['Tarea', 'Fase', 'Responsable', 'Fecha de Inicio', 'Fecha de Fin', 'Estado', 'Progreso (%)', 'Descripción']] = \
-            [name, final_phase, final_resp, start_date, end_date, status, progress, desc]
+        df.loc[df['ID'] == selected_id, ['Tarea', 'Fase', 'Responsable', 'Fecha de Inicio', 'Fecha de Fin', 'Estado', 'Progreso (%)', 'Descripción']] = [name, phase, responsible, start_date, end_date, status, progress, desc]
         gr.Info(f"Tarea ID {selected_id} actualizada.")
         
     elif action == "delete":
         if selected_id is None:
-            gr.Warning("Selecciona una tarea de la tabla para eliminar.")
+            gr.Warning("Selecciona una tarea para eliminar.")
             return df, create_gantt_chart(df), gr.update(), gr.update()
         task_name = df.loc[df['ID'] == selected_id, 'Tarea'].iloc[0]
-        df = df[df['ID'] != selected_id]
+        df = df[df['ID'] != selected_id].reset_index(drop=True)
         gr.Info(f"Tarea '{task_name}' eliminada.")
 
-    onedrive.upload_dataframe_to_excel(df)
-    all_phases = sorted(df['Fase'].unique().tolist())
-    all_responsibles = sorted(df['Responsable'].unique().tolist())
+    # Asegurar tipos de datos correctos antes de guardar
+    df['Fecha de Inicio'] = pd.to_datetime(df['Fecha de Inicio'])
+    df['Fecha de Fin'] = pd.to_datetime(df['Fecha de Fin'])
+    
+    # **Paso clave: Guardar el DataFrame modificado en el archivo CSV**
+    save_data_to_csv(df)
+    
+    all_phases = sorted(df['Fase'].dropna().unique().tolist())
+    all_responsibles = sorted(df['Responsable'].dropna().unique().tolist())
     return df, create_gantt_chart(df), gr.update(choices=all_phases), gr.update(choices=all_responsibles)
 
-def populate_form_on_select(df, evt: gr.SelectData):
-    """Al seleccionar una fila de la tabla, llena el formulario de edición."""
-    if evt.index is None:
-        return None, "", "", "", None, None, "No Iniciada", 0, ""
-    selected_row = df.iloc[evt.index[0]]
-    return (selected_row['ID'], selected_row['Tarea'], selected_row['Fase'],
-        selected_row['Responsable'], selected_row['Fecha de Inicio'].to_pydatetime().date(),
-        selected_row['Fecha de Fin'].to_pydatetime().date(), selected_row['Estado'],
-        selected_row['Progreso (%)'], selected_row['Descripción'])
-    
-# --- 4. DEFINICIÓN DE LA INTERFAZ CON GRADIO (SIN CAMBIOS) ---
 
-with gr.Blocks(theme=gr.themes.Soft(), title="Gestor de Proyectos con OneDrive") as demo:
+# --- 4. INTERFAZ DE GRADIO ---
+with gr.Blocks(theme=gr.themes.Soft(), title="Gestor de Proyectos con CSV") as demo:
     df_state = gr.State(initial_df)
     selected_task_id = gr.State(None)
-    initial_phases = sorted(initial_df['Fase'].unique().tolist())
-    initial_responsibles = sorted(initial_df['Responsable'].unique().tolist())
+    
+    initial_phases = sorted(initial_df['Fase'].dropna().unique().tolist())
+    initial_responsibles = sorted(initial_df['Responsable'].dropna().unique().tolist())
     status_options = ['No Iniciada', 'En Progreso', 'Completada', 'Retrasada', 'Bloqueada']
 
-    gr.Markdown("# 📊 Gestor de Cronogramas de Proyectos (Desplegado en HF Spaces)")
+    gr.Markdown("# 💾 Gestor de Proyectos (con Guardado en CSV)")
+    gr.Markdown("Los datos se guardan en el 'Space'. **Nota:** Los datos se reiniciarán si el Space está inactivo por mucho tiempo.")
     
     with gr.Row():
         with gr.Column(scale=1):
             with gr.Accordion("📝 Panel de Gestión de Tareas", open=True):
                 txt_task_id = gr.Textbox(label="ID Tarea", interactive=False, visible=False)
                 txt_task_name = gr.Textbox(label="Nombre de la Tarea")
-                with gr.Row():
-                    dd_phase = gr.Dropdown(label="Fase del Proyecto", choices=initial_phases)
-                    txt_new_phase = gr.Textbox(label="O añadir nueva fase...")
-                with gr.Row():
-                    dd_responsible = gr.Dropdown(label="Responsable", choices=initial_responsibles)
-                    txt_new_responsible = gr.Textbox(label="O añadir nuevo responsable...")
+                dd_phase = gr.Dropdown(label="Fase del Proyecto", choices=initial_phases, allow_custom_value=True)
+                dd_responsible = gr.Dropdown(label="Responsable", choices=initial_responsibles, allow_custom_value=True)
                 with gr.Row():
                     date_start = gr.DatePicker(label="Fecha de Inicio")
                     date_end = gr.DatePicker(label="Fecha de Fin")
@@ -219,36 +137,21 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Gestor de Proyectos con OneDrive")
                     btn_update = gr.Button("🔄 Actualizar Tarea", variant="secondary")
                     btn_delete = gr.Button("❌ Eliminar Tarea", variant="stop")
         with gr.Column(scale=2):
-            with gr.Accordion("🔍 Filtros de Visualización"):
-                with gr.Row():
-                    chk_filter_phase = gr.CheckboxGroup(label="Filtrar por Fase", choices=initial_phases)
-                    chk_filter_resp = gr.CheckboxGroup(label="Filtrar por Responsable", choices=initial_responsibles)
-                    chk_filter_status = gr.CheckboxGroup(label="Filtrar por Estado", choices=status_options)
             gr.Markdown("### 🗓️ Tabla de Actividades")
             df_table = gr.DataFrame(value=initial_df, headers=list(initial_df.columns), interactive=True, height=300)
             gr.Markdown("### 📈 Diagrama de Gantt")
             gantt_plot = gr.Plot(create_gantt_chart(initial_df))
 
-    # --- 5. LÓGICA DE EVENTOS (SIN CAMBIOS) ---
-    task_inputs = [txt_task_id, txt_task_name, dd_phase, dd_responsible, date_start, date_end, 
-        dd_status, slider_progress, txt_description, txt_new_phase, txt_new_responsible]
-    filter_inputs = [df_state, chk_filter_phase, chk_filter_resp, chk_filter_status]
-
-    btn_add.click(fn=lambda *args: manage_tasks(*args), inputs=[gr.State("add"), df_state] + task_inputs, outputs=[df_state, gantt_plot, dd_phase, dd_responsible])
+    # --- 5. LÓGICA DE EVENTOS ---
+    task_inputs = [txt_task_id, txt_task_name, dd_phase, dd_responsible, date_start, date_end, dd_status, slider_progress, txt_description]
+    btn_add.click(fn=lambda *args: manage_tasks(*args), inputs=[gr.State("add"), df_state, selected_task_id] + task_inputs, outputs=[df_state, gantt_plot, dd_phase, dd_responsible])
     btn_update.click(fn=lambda *args: manage_tasks(*args), inputs=[gr.State("update"), df_state, selected_task_id] + task_inputs, outputs=[df_state, gantt_plot, dd_phase, dd_responsible])
     btn_delete.click(fn=lambda *args: manage_tasks(*args), inputs=[gr.State("delete"), df_state, selected_task_id] + task_inputs, outputs=[df_state, gantt_plot, dd_phase, dd_responsible])
     
     df_table.select(fn=populate_form_on_select, inputs=[df_state], outputs=[selected_task_id, txt_task_name, dd_phase, dd_responsible, date_start, date_end, dd_status, slider_progress, txt_description])
     
-    def apply_filters_and_update_ui(df, phases, responsibles, statuses):
-        filtered = filter_data(df, phases, responsibles, statuses)
-        return filtered, create_gantt_chart(filtered)
-        
-    for chk_filter in [chk_filter_phase, chk_filter_resp, chk_filter_status]:
-        chk_filter.change(fn=apply_filters_and_update_ui, inputs=filter_inputs, outputs=[df_table, gantt_plot])
-
-    df_state.change(fn=lambda df: (df, create_gantt_chart(df)), inputs=[df_state], outputs=[df_table, gantt_plot])
+    df_state.change(fn=lambda df: df, inputs=[df_state], outputs=[df_table])
+    df_state.change(fn=create_gantt_chart, inputs=[df_state], outputs=[gantt_plot])
 
-# --- El lanzador se gestiona automáticamente por HF Spaces ---
 if __name__ == "__main__":
     demo.launch(debug=True)