Update app.py

app.py

@@ -24,6 +24,15 @@ def validation(username : str, password : str):
     password_db = row["Contraseña"].to_numpy().tolist()[0]
     return password == password_db
 
+with gr.Blocks(title="Historial de diagnósticos") as ViewingHistory:
+    history_dataframe = gr.Dataframe(visible=False, type="pandas", wrap=True, interactive=False)
+    
+    def update_dataframe(history_dataframe):
+        temp = pd.read_sql_table(table_name="Predicciones", con="sqlite:///database_test.db")
+        return gr.Dataframe(value=temp, visible=True, type="pandas", wrap=True, interactive=False)
+    
+    ViewingHistory.load(fn=update_dataframe, inputs=[history_dataframe], outputs=[history_dataframe])
+
 with gr.Blocks(title="Clasificación") as AIModel:
     with gr.Row():
         with gr.Column():
@@ -31,37 +40,56 @@ with gr.Blocks(title="Clasificación") as AIModel:
             segment_file = gr.File(file_count="single", file_types=[".nii.gz", ".nii"], type="filepath", label="Segmento")
             dropdown_navigator = gr.Dropdown(value="eje X", choices=["eje X", "eje Y", "eje Z"], filterable=True, type="value", label="Eje")
             
-            def change_slider(image, slider_value, axis):
+            slider = gr.Slider(visible=False)
+            image_preview = gr.Image(visible=False)
+            
+            def preview_image(axis, image):
                 brain_volume_data  = nib.load(image).get_fdata()
                 if axis == "eje X":
-                    slice = brain_volume_data[slider_value, :, :]
+                    middle_index = brain_volume_data.shape[0] // 2
+                    max_index = brain_volume_data.shape[0] - 1
+                    slice = brain_volume_data[middle_index, :, :]
                     image = Image.fromarray(slice)
                     image = image.rotate(90)
-                    return image
                 elif axis == "eje Y":
-                    slice = brain_volume_data[:, slider_value, :]
+                    middle_index = brain_volume_data.shape[1] // 2
+                    max_index = brain_volume_data.shape[1] - 1
+                    slice = brain_volume_data[:, middle_index, :]
                     image = Image.fromarray(slice)
                     image = image.rotate(90)
-                    return image
                 else:
-                    slice = brain_volume_data[:, :, slider_value]
+                    middle_index = brain_volume_data.shape[2] // 2
+                    max_index = brain_volume_data.shape[2] - 1
+                    slice = brain_volume_data[:, :, middle_index]
                     image = Image.fromarray(slice)
-                    return image
+                    image = image.rotate(90)
+                
+                return (
+                    gr.Slider(value=middle_index, minimum=0, maximum=max_index, visible=True),
+                    gr.Image(value=image, label="Previsualización", type="pil", visible=True, interactive=False, show_download_button=True)
+                )
             
-            @gr.render(inputs=[image_file, dropdown_navigator])
-            def preview_image (image, axis):
-                if image == None or image == "":
-                    return
+            def slicing_image(axis, image, index):
+                brain_volume_data  = nib.load(image).get_fdata()
+                
                 if axis == "eje X":
-                    slider = gr.Slider(value=int(nib.load(image).get_fdata().shape[0] // 2), minimum=0, maximum=nib.load(image).get_fdata().shape[0] - 1, label="Control deslizante")
+                    slice = brain_volume_data[index, :, :]
+                    image = Image.fromarray(slice)
+                    image = image.rotate(90)
                 elif axis == "eje Y":
-                    slider = gr.Slider(value=int(nib.load(image).get_fdata().shape[1] // 2), minimum=0, maximum=nib.load(image).get_fdata().shape[1] - 1, label="Control deslizante")
+                    slice = brain_volume_data[:, index, :]
+                    image = Image.fromarray(slice)
+                    image = image.rotate(90)
                 else:
-                    slider = gr.Slider(value=int(nib.load(image).get_fdata().shape[2] // 2), minimum=0, maximum=nib.load(image).get_fdata().shape[2] - 1, label="Control deslizante")
-            
-                image_preview = gr.Image(label="Previsualización", interactive=False, type="pil")
-                slider.change(fn=change_slider, inputs=[image_file, slider, dropdown_navigator], outputs=[image_preview])
-            
+                    slice = brain_volume_data[:, :, index]
+                    image = Image.fromarray(slice)
+                
+                return (
+                    gr.Image(value=image, label="Previsualización", type="pil", visible=True, interactive=False, show_download_button=True)
+                )
+            dropdown_navigator.change(fn=preview_image, inputs=[dropdown_navigator, image_file], outputs=[slider, image_preview])
+            image_file.upload(fn=preview_image, inputs=[dropdown_navigator, image_file], outputs=[slider, image_preview])
+            slider.change(fn=slicing_image, inputs=[dropdown_navigator, image_file, slider], outputs=[image_preview])
         with gr.Column():
           label_output = gr.Label(label="Resultado")
           comment_output = gr.Textbox(label="Observación", type="text", interactive=True)
@@ -69,135 +97,208 @@ with gr.Blocks(title="Clasificación") as AIModel:
         with gr.Column():
             with gr.Row():
                 with gr.Column():
-                    clear_button = gr.ClearButton(value="Borrar", components=[image_file, segment_file, label_output, comment_output])
+                    clear_button = gr.ClearButton(value="Borrar", components=[image_file, segment_file, label_output, comment_output, dropdown_navigator])
                 with gr.Column():
                     submit_button = gr.Button(value="Enviar", variant="primary")
+                
+                def clear_image_preview(image_preview, slider):
+                    return (gr.Image(visible=False), gr.Slider(visible=False))
+                
+                clear_button.click(fn=clear_image_preview, inputs=[image_preview, slider], outputs=[image_preview, slider])    
         with gr.Column():
-            flag_button = gr.Button(value="Marcar")       
+            flag_button = gr.Button(value="Guardar")
 
-    def make_prediction(image, label_output, comment_output):
-        grade1 = list(label_output.values())[0]
-        grade2 = list(label_output.values())[1]
-        engine = sqlalchemy.create_engine("sqlite:///database_test.db", echo=False)
-        Session = sessionmaker(bind=engine)
-        session = Session()
-        metadata = sqlalchemy.MetaData()
-        predictions_table = sqlalchemy.Table("Predicciones", metadata, autoload_with=engine)
-
-        new_prediction = {
-            "Imagen": image,
-            "Grado 1":grade1,
-            "Grado 2": grade2,
-            "Observacion": comment_output,
-            "Usuario ID": 1,
-            "Ultima actualizacion": datetime.utcnow(),
-            "Creado el": datetime.utcnow()
-        }
+            def save_prediction(image, label_output, comment_output):
+                grade1 = list(label_output.values())[0]
+                grade2 = list(label_output.values())[1]
+                engine = sqlalchemy.create_engine("sqlite:///database_test.db", echo=False)
+                Session = sessionmaker(bind=engine)
+                session = Session()
+                metadata = sqlalchemy.MetaData()
+                predictions_table = sqlalchemy.Table("Predicciones", metadata, autoload_with=engine)
         
-        stmt = predictions_table.insert().values(**new_prediction)
-        session.execute(stmt)
-        session.commit()
+                new_prediction = {
+                    "Imagen": image,
+                    "Grado 1":grade1,
+                    "Grado 2": grade2,
+                    "Observacion": comment_output,
+                    "Usuario ID": 1,
+                    "Ultima actualizacion": datetime.utcnow(),
+                    "Creado el": datetime.utcnow()
+                }
+                
+                stmt = predictions_table.insert().values(**new_prediction)
+                session.execute(stmt)
+                session.commit()
+                return gr.Info("Se ha guardado exitosamente")
         
-    def image_classifier(image, segment):
-        features3D = extractor3D.execute(imageFilepath=image, maskFilepath=segment)
-        dict = {}
-        for key, value in zip(features3D.keys(), features3D.values()):
-            if isinstance(value, np.ndarray):
-                dict[key] = [value.tolist()]
-            else:
-                dict[key] = [value]
-        temp = pd.DataFrame(dict).select_dtypes(exclude=["object"]).to_numpy()
-        prediction = loaded_model.predict_proba(temp).tolist()[0]
-        return {"Grado 1": prediction[0], "Grado 2": prediction[1]}
+            def classify_image(image, segment):
+                features3D = extractor3D.execute(imageFilepath=image, maskFilepath=segment)
+                dict = {}
+                for key, value in zip(features3D.keys(), features3D.values()):
+                    if isinstance(value, np.ndarray):
+                        dict[key] = [value.tolist()]
+                    else:
+                        dict[key] = [value]
+                temp = pd.DataFrame(dict).select_dtypes(exclude=["object"]).to_numpy()
+                prediction = loaded_model.predict_proba(temp).tolist()[0]
+                return {"Grado 1": prediction[0], "Grado 2": prediction[1]}
 
-    flag_button.click(fn=make_prediction, inputs=[image_file, label_output, comment_output])
-    submit_button.click(fn=image_classifier, inputs=[image_file, segment_file], outputs=[label_output])
+    flag_button.click(fn=save_prediction, inputs=[image_file, label_output, comment_output]).success(update_dataframe, history_dataframe, history_dataframe) 
+    submit_button.click(fn=classify_image, inputs=[image_file, segment_file], outputs=[label_output])
     
-
-with gr.Blocks(title="Historial de diagnósticos") as ViewingHistory:
-    temp = pd.read_sql_table("Predicciones", "sqlite:///database_test.db")
-    gr.Dataframe(temp, type="pandas", wrap=True, interactive=False)
-
 with gr.Blocks(title="Base de datos") as Database:
+    with gr.Row():
+        table_dropdown = gr.Dropdown(value="Usuarios", choices=["Usuarios", "Predicciones"],
+        filterable=True, label="Tabla")
     with gr.Row():
         with gr.Column():
-          dropdown = gr.Dropdown(choices=["Usuarios", "Predicciones"],
-          filterable=False, label="Tabla")
+            action_dropdown = gr.Dropdown(choices=["Eliminar", "Descargar"], filterable=True, label="Acciones")
         with gr.Column():
-          button = gr.Button(value="Buscar", variant="primary")
+            id_dropdown = gr.Dropdown(visible=False, filterable=True, label="Identificador (ID)")
+        with gr.Column():
+            action_button = gr.Button(visible=False)
     with gr.Row():
-        dataframe = gr.Dataframe(type="pandas", wrap=True, interactive=False)
-  
-    def on_selected(selected_value):
-        return pd.read_sql_table(selected_value, "sqlite:///database_test.db")
-    
-    button.click(on_selected, dropdown, dataframe)
-    
-with gr.Blocks(title="Información de usuario", delete_cache=[60, 120]) as AdminInformation:
-    
-    username : str = "" 
-    first_names : str = ""
-    last_names : str = ""
-    email : str = ""
-    phone : int = 0
-    is_admin : bool = False
-    
-    table = pd.read_sql_table(table_name="Usuarios", con="sqlite:///database_test.db")
-    row = table[table["ID"] == 1]
-    
-    def make_interactive(input_first_names, input_username, input_last_names, input_email, input_phone):
+        database_dataframe = gr.Dataframe(visible=False, type="pandas", wrap=True, interactive=False)
+
+    def on_table_dropdown_change(table_dropdown, database_dataframe, id_dropdown):
+        temp = pd.read_sql_table(table_dropdown, "sqlite:///database_test.db")
+        ids = temp["ID"].values.flatten().tolist()        
         return (
-            gr.Textbox(label="Nombres", interactive=True, max_lines=1),
-            gr.Textbox(label="Usuario", interactive=True, max_lines=1),
-            gr.Textbox(label="Apellidos", interactive=True, max_lines=1),
-            gr.Textbox(label="Correo electrónico", interactive=True, max_lines=1),
-            gr.Textbox(label="Número de teléfono", interactive=True, max_lines=1)
+            gr.Dataframe(value=temp, visible=True, type="pandas", wrap=True, interactive=False),
+            gr.Dropdown(choices=ids, visible=True, filterable=True, label="Identificador (ID)"),
         )
     
-    def save(input_first_names, input_username, input_last_names, input_email, input_phone):
-        
-        connection = sqlite3.connect("database_test.db")
-        cursor = connection.cursor()
-        data = cursor.execute(f'''UPDATE Usuarios SET Nombres = '{input_first_names}', Usuario = '{input_username}', Apellidos = '{input_last_names}', "Correo electronico" = '{input_email}', Telefono = '{input_phone}'  WHERE ID==1;''')
-        connection.commit()
-        connection.close()
-        
-        return (
-            gr.Textbox(value=input_first_names, label="Nombres", interactive=False, max_lines=1),
-            gr.Textbox(value=input_username, label="Usuario", interactive=False, max_lines=1),
-            gr.Textbox(value=input_last_names, label="Apellidos", interactive=False, max_lines=1),
-            gr.Textbox(value=input_email, label="Correo electrónico", interactive=False, max_lines=1),
-            gr.Textbox(value=input_phone, label="Número de teléfono", interactive=False, max_lines=1)
-        )
+    def on_database_load(table_dropdown, database_dataframe):
+        temp = pd.read_sql_table(table_dropdown, "sqlite:///database_test.db")
+        return gr.Dataframe(value=temp, visible=True, type="pandas", wrap=True, interactive=False)
+    
+    def on_action_dropdown_change(action_dropdown):
+        return gr.Button(value=action_dropdown, visible=True, variant="primary")
+    
+    def on_action_button_click(table_dropdown, action_dropdown, id_dropdown, database_dataframe):
+        if action_dropdown == "Eliminar":
+            engine = sqlalchemy.create_engine("sqlite:///database_test.db", echo=False)
+            Session = sessionmaker(bind=engine)
+            session = Session()
+            metadata = sqlalchemy.MetaData()
+            table = sqlalchemy.Table(table_dropdown, metadata, autoload_with=engine)
+            stmt = sqlalchemy.delete(table).where(table.c.ID == id_dropdown)
+            session.execute(stmt)
+            session.commit()
+            return gr.Info(f"Se ha eliminado el registro #{id_dropdown}")
+        elif action_dropdown == "Descargar":
+            if table_dropdown == "Predicciones":
+                file_path = database_dataframe["Imagen"].to_numpy().tolist()[0]
+                print(file_path)
+                return gr.DownloadButton(value=file_path)
+                #return gr.Info(f"Se ha descargado el registro #{id_dropdown}")
     
-    if not row.empty:
-        username = row["Usuario"].to_numpy().tolist()[0]
-        first_names = row["Nombres"].to_numpy().tolist()[0]
-        last_names = row["Apellidos"].to_numpy().tolist()[0]
-        email = row["Correo electronico"].to_numpy().tolist()[0]
-        phone = row["Telefono"].to_numpy().tolist()[0]
-        is_admin = row["Es Administrador"].to_numpy().tolist()[0]
+    table_dropdown.change(fn=on_table_dropdown_change, inputs=[table_dropdown, database_dataframe, id_dropdown], outputs=[database_dataframe, id_dropdown])
+    Database.load(fn=on_database_load, inputs=[table_dropdown, database_dataframe], outputs=[database_dataframe]).success(fn=on_table_dropdown_change, inputs=[table_dropdown, database_dataframe, id_dropdown], outputs=[database_dataframe, id_dropdown])
+    action_dropdown.change(fn=on_action_dropdown_change, inputs=[action_dropdown], outputs=[action_button])
+    action_button.click(fn=on_action_button_click, inputs=[table_dropdown, action_dropdown, id_dropdown, database_dataframe], outputs=[action_dropdown])        
+                
     
+with gr.Blocks(title="Información de usuario") as AdminInformation:   
     with gr.Row():
         with gr.Column():
             input_profile_image = gr.Image(interactive=False)
         with gr.Column():
-            input_first_names = gr.Textbox(value=first_names, label="Nombres", interactive=False, type="text", max_lines=1)
-            input_username = gr.Textbox(value=username, label="Usuario", interactive=False, type="text", max_lines=1)
-            #gr.Textbox(value="Administrador", label="Rol", interactive=False, show_copy_button=True, type="text", max_lines=1, container=False)
+            input_first_names = gr.Textbox(label="Nombres", interactive=False, type="text", max_lines=1)
+            input_username = gr.Textbox(label="Usuario", interactive=False, type="text", max_lines=1)
+            input_is_admin = gr.Textbox(label="Rol", interactive=False, type="text", max_lines=1)
         with gr.Column():
-            input_last_names = gr.Textbox(value=last_names, label="Apellidos", interactive=False, type="text", max_lines=1)
-            input_email = gr.Textbox(value=email, label="Correo electrónico", interactive=False, type="email", max_lines=1)
-            input_phone = gr.Textbox(value=phone, label="Número de teléfono", interactive=False, type="text", max_lines=1)
+            input_last_names = gr.Textbox(label="Apellidos", interactive=False, type="text", max_lines=1)
+            input_email = gr.Textbox(label="Correo electrónico", interactive=False, type="email", max_lines=1)
+            input_phone = gr.Textbox(label="Número de teléfono", interactive=False, type="text", max_lines=1)
     with gr.Row():
         with gr.Row():
             edit_button = gr.Button(value="Editar")
             save_button = gr.Button(value="Guardar", variant="primary")
     
-    edit_button.click(make_interactive, inputs=[input_first_names, input_username, input_last_names, input_email, input_phone],
-                      outputs=[input_first_names, input_username, input_last_names, input_email, input_phone])
-    save_button.click(save, inputs=[input_first_names, input_username, input_last_names, input_email, input_phone], outputs=[input_first_names, input_username, input_last_names, input_email, input_phone])
+    def FillFields(input_username, input_first_names, input_last_names, input_email, input_phone, input_is_admin):
+        
+        table = pd.read_sql_table(table_name="Usuarios", con="sqlite:///database_test.db")
+        row = table[table["ID"] == 1]
+
+        if not row.empty:
+            username_db = row["Usuario"].to_numpy().tolist()[0]
+            first_names_db = row["Nombres"].to_numpy().tolist()[0]
+            last_names_db = row["Apellidos"].to_numpy().tolist()[0]
+            email_db = row["Correo electronico"].to_numpy().tolist()[0]
+            phone_db = row["Telefono"].to_numpy().tolist()[0]
+            is_admin_db = row["Es Administrador"].to_numpy().tolist()[0]
+        else:
+            username_db = ""
+            first_names_db = ""
+            last_names_db = ""
+            email_db = ""
+            phone_db = ""
+            is_admin_db = False
+        
+        return (
+            gr.Textbox(value=username_db, label="Usuario", interactive=False, max_lines=1),
+            gr.Textbox(value=first_names_db, label="Nombres", interactive=False, max_lines=1),
+            gr.Textbox(value=last_names_db, label="Apellidos", interactive=False, max_lines=1),
+            gr.Textbox(value=email_db, label="Correo electrónico", interactive=False, max_lines=1),
+            gr.Textbox(value=phone_db, label="Número de teléfono", interactive=False, max_lines=1),
+            gr.Textbox(value="Administrador" if is_admin_db else "Doctor", label="Rol", interactive=False, type="text", max_lines=1)
+        )
+    
+    def make_editable(edit_button, input_username, input_first_names, input_last_names, input_email, input_phone):
+        
+        if edit_button == "Editar":
+            return (
+                gr.Button(value="Cancelar"),
+                gr.Textbox(value=input_username, interactive=True),
+                gr.Textbox(value=input_first_names, interactive=True),
+                gr.Textbox(value=input_last_names, interactive=True),
+                gr.Textbox(value=input_email, interactive=True),
+                gr.Textbox(value=input_phone, interactive=True),
+            )
+        else:
+            return (
+                gr.Button(value="Editar"),
+                gr.Textbox(value=input_username, interactive=True),
+                gr.Textbox(value=input_first_names, interactive=True),
+                gr.Textbox(value=input_last_names, interactive=True),
+                gr.Textbox(value=input_email, interactive=True),
+                gr.Textbox(value=input_phone, interactive=True),
+            )
+    
+    def save_values(input_username, input_first_names, input_last_names, input_email, input_phone):
+        #connection = sqlite3.connect("database_test.db")
+        #cursor = connection.cursor()
+        #data = cursor.execute(f'''UPDATE Usuarios SET Nombres = '{input_first_names}', Usuario = '{input_username}', Apellidos = '{input_last_names}', "Correo electronico" = '{input_email}', Telefono = '{input_phone}'  WHERE ID==1;''')
+        #connection.commit()
+        #connection.close()
+        engine = sqlalchemy.create_engine("sqlite:///database_test.db", echo=False)
+        Session = sessionmaker(bind=engine)
+        session = Session()
+        metadata = sqlalchemy.MetaData()
+        table = sqlalchemy.Table("Usuarios", metadata, autoload_with=engine)
+        new_user = {
+            "Usuario": input_username,
+            "Nombres": input_first_names,
+            "Apellidos": input_last_names,
+            "Correo electronico": input_email,
+            "Telefono": input_phone
+        }
+        stmt = sqlalchemy.update(table).where(table.c.ID == 1).values(**new_user)
+        session.execute(stmt)
+        session.commit()
+        return (
+            gr.Textbox(value=input_username, interactive=False),
+            gr.Textbox(value=input_first_names, interactive=False),
+            gr.Textbox(value=input_last_names, interactive=False),
+            gr.Textbox(value=input_email, interactive=False),
+            gr.Textbox(value=input_phone, interactive=False),
+        )
     
+    AdminInformation.load(fn=FillFields, inputs=[input_username, input_first_names, input_last_names, input_email, input_phone, input_is_admin], outputs=[input_username, input_first_names, input_last_names, input_email, input_phone, input_is_admin])
+    edit_button.click(fn=make_editable, inputs=[edit_button, input_username, input_first_names, input_last_names, input_email, input_phone], outputs=[edit_button, input_username, input_first_names, input_last_names, input_email, input_phone])
+    save_button.click(fn=save_values, inputs=[input_username, input_first_names, input_last_names, input_email, input_phone], outputs=[input_username, input_first_names, input_last_names, input_email, input_phone])
 
 Demo = gr.TabbedInterface(
   interface_list=[AIModel, ViewingHistory, Database, AdminInformation],