update dropdowns

app.py

@@ -2,9 +2,8 @@
 
 import gradio as gr
 import logging
-from watchdog.observers import Observer
 from app.logging_config import configure_logging
-from app.functions.database_handling import list_databases, setup_db_observer
+from app.functions.database_handling import list_databases
 from ui.chatbot_tab import create_chatbot_tab
 from ui.db_management_tab import create_db_management_tab
 from ui.document_management_tab import create_document_management_tab
@@ -13,41 +12,34 @@ from ui.new_features_tab import create_new_features_tab
 # Configura il logging
 configure_logging()
 
-def update_all_dropdowns():
-    """
-    Aggiorna tutti i dropdown in tutte le tab.
-    """
-    databases = list_databases()
-    logging.info(f"Aggiornamento dropdown con databases: {databases}")
-    return [gr.update(choices=databases, value=databases[0] if databases else None) for _ in range(6)]
-
 def main():
     """Funzione principale che crea e lancia l'app Gradio."""
     logging.info("Avvio applicazione")
     try:
         with gr.Blocks() as rag_chatbot:
-            # Configura l'observer per la cartella db
-            observer = setup_db_observer(update_all_dropdowns)
-            
             gr.Markdown("# Chatbot basato su RAG")
             logging.info("Interfaccia Gradio inizializzata")
             
-            # Crea i vari tab dell'interfaccia
-            create_chatbot_tab()
-            create_db_management_tab(update_all_dropdowns)
-            create_document_management_tab(update_all_dropdowns)
-            create_new_features_tab()
-            logging.info("Tab dell'interfaccia creati con successo")
+            # Prima ottiene tutti i riferimenti
+            doc_refs = create_document_management_tab()    
+            chat_refs = create_chatbot_tab()
+            
+            # Crea dizionario completo dei riferimenti
+            dropdowns = {
+                "document": doc_refs,
+                "chat": chat_refs
+            }
+            
+            # Crea i tab nell'ordine corretto
+            create_db_management_tab(dropdowns)          # Tab 1: DB Management
+            doc_refs                                     # Tab 2: Document Management
+            create_new_features_tab()                    # Tab 3: Features
+            chat_refs                                    # Tab 4: Chatbot (ultima tab)
             
-            # Avvia l'app
             rag_chatbot.launch()
+            
     except Exception as e:
         logging.error(f"Errore durante l'avvio: {str(e)}")
-    finally:
-        # Assicurati che l'observer venga fermato
-        if 'observer' in locals():
-            observer.stop()
-            observer.join()
 
 if __name__ == "__main__":
-    main()
+    main()

ui/chatbot_tab.py

@@ -42,7 +42,7 @@ def create_chatbot_tab():
     with gr.Tab("Chatbot"):
         with gr.Row():
             with gr.Column(scale=2):
-                # Dropdown per selezionare il database
+                # Singolo dropdown per il database
                 db_name_chat = gr.Dropdown(
                     choices=databases,
                     label="Seleziona Database",
@@ -96,4 +96,5 @@ def create_chatbot_tab():
             outputs=[chatbot, chat_state]
         )
 
-    return
+    # Ritorna il riferimento al dropdown corretto
+    return {"db_selector": db_name_chat}

ui/db_management_tab.py

@@ -1,12 +1,14 @@
 import gradio as gr
 from app.functions.database_handling import create_database, modify_database, delete_database, list_databases
 
-def create_db_management_tab(update_all_dropdowns=None):
-    """Crea il tab 'Gestione Database' dell'interfaccia Gradio."""
-    
-    # Ottieni la lista iniziale dei database
+def create_db_management_tab(dropdowns):
     databases = list_databases()
-
+    
+    def update_dropdowns():
+        updated_dbs = list_databases()
+        # Aggiorna tutti i dropdown dell'applicazione (5 invece di 4)
+        return [gr.update(choices=updated_dbs) for _ in range(5)]
+    
     with gr.Tab("Gestione Database"):
         gr.Markdown("## Operazioni sui Database")
         
@@ -42,9 +44,14 @@ def create_db_management_tab(update_all_dropdowns=None):
             inputs=db_name_input,
             outputs=create_output
         ).then(
-            fn=update_all_dropdowns,       # <--- callback globale
-            inputs=[],
-            outputs=[modify_db_old_name, delete_db_dropdown]
+            fn=update_dropdowns,
+            outputs=[
+                modify_db_old_name,                  # db_management_tab
+                delete_db_dropdown,                  # db_management_tab  
+                dropdowns["document"]["upload"],     # document_management_tab
+                dropdowns["document"]["list"],       # document_management_tab
+                dropdowns["chat"]["db_selector"]     # chatbot_tab
+            ]
         )
 
         modify_db_button.click(
@@ -52,9 +59,14 @@ def create_db_management_tab(update_all_dropdowns=None):
             inputs=[modify_db_old_name, modify_db_new_name],
             outputs=modify_output
         ).then(
-            fn=update_all_dropdowns,       # <--- callback globale
-            inputs=[],
-            outputs=[modify_db_old_name, delete_db_dropdown]
+            fn=update_dropdowns,
+            outputs=[
+                modify_db_old_name,                  # db_management_tab
+                delete_db_dropdown,                  # db_management_tab
+                dropdowns["document"]["upload"],     # document_management_tab
+                dropdowns["document"]["list"],       # document_management_tab
+                dropdowns["chat"]["db_selector"]     # chatbot_tab
+            ]
         )
 
         delete_db_button.click(
@@ -62,9 +74,14 @@ def create_db_management_tab(update_all_dropdowns=None):
             inputs=delete_db_dropdown,
             outputs=delete_output
         ).then(
-            fn=update_all_dropdowns,       # <--- callback globale
-            inputs=[],
-            outputs=[modify_db_old_name, delete_db_dropdown]
+            fn=update_dropdowns,
+            outputs=[
+                modify_db_old_name,                  # db_management_tab
+                delete_db_dropdown,                  # db_management_tab
+                dropdowns["document"]["upload"],     # document_management_tab
+                dropdowns["document"]["list"],       # document_management_tab
+                dropdowns["chat"]["db_selector"]     # chatbot_tab
+            ]
         )
     
     # Ritorna i componenti che vogliamo poter aggiornare/agganciare

ui/document_management_tab.py

@@ -3,25 +3,24 @@ import logging
 from app.document_handling import upload_and_index, list_indexed_files, delete_file_from_database
 from app.functions.database_handling import list_databases
 
-def create_document_management_tab(update_all_dropdowns):
+def create_document_management_tab():
     """Crea il tab 'Gestione Documenti' dell'interfaccia Gradio."""
     
-    def refresh_dropdowns():
+    def update_dropdowns():
         """Aggiorna localmente i dropdown con la lista aggiornata dei database."""
-        databases = list_databases()
-        logging.info(f"Aggiornamento dropdown con databases: {databases}")
-        updates = [
-            gr.update(choices=databases, value=databases[0] if databases else None),
-            gr.update(choices=databases, value=databases[0] if databases else None)
+        updated_dbs = list_databases()
+        logging.info(f"Aggiornamento dropdown con databases: {updated_dbs}")
+        return [
+            gr.update(choices=updated_dbs),
+            gr.update(choices=updated_dbs)
         ]
-        return updates
 
     def upload_and_index_callback(files, title, author, db_name):
         """Carica e indicizza i documenti, quindi aggiorna la lista dei file."""
         try:
             status = upload_and_index(files, title, author, db_name)
             logging.info(f"Upload completato: {status}")
-            return status
+            return status, update_dropdowns()[0], update_dropdowns()[1]
         except Exception as e:
             logging.error(f"Errore durante l'upload: {str(e)}")
             return f"Errore: {str(e)}"
@@ -50,8 +49,7 @@ def create_document_management_tab(update_all_dropdowns):
                 )
                 db_name_upload = gr.Dropdown(
                     choices=databases, 
-                    label="Seleziona Database", 
-                    value="default_db"
+                    label="Seleziona Database"
                 )
             
             with gr.Row():
@@ -65,8 +63,7 @@ def create_document_management_tab(update_all_dropdowns):
             with gr.Row():
                 db_name_list = gr.Dropdown(
                     choices=databases,
-                    label="Database",
-                    value="default_db"
+                    label="Database"
                 )
                 list_button = gr.Button("Lista File")
             list_output = gr.Textbox(label="File nel Database")
@@ -80,14 +77,7 @@ def create_document_management_tab(update_all_dropdowns):
         upload_button.click(
             fn=upload_and_index_callback,
             inputs=[file_input, title_input, author_input, db_name_upload],
-            outputs=upload_output
-        ).then(
-            fn=update_all_dropdowns,  # Usa la funzione globale
-            outputs=[db_name_upload, db_name_list]
-        ).then(
-            fn=list_files_callback,
-            inputs=[db_name_list],
-            outputs=list_output
+            outputs=[upload_output, db_name_upload, db_name_list]
         )
 
         list_button.click(
@@ -101,7 +91,7 @@ def create_document_management_tab(update_all_dropdowns):
             inputs=[delete_file_input, db_name_list],
             outputs=delete_file_output
         ).then(
-            fn=update_all_dropdowns,  # Usa la funzione globale
+            fn=update_dropdowns,
             outputs=[db_name_upload, db_name_list]
         ).then(
             fn=list_files_callback,
@@ -109,4 +99,4 @@ def create_document_management_tab(update_all_dropdowns):
             outputs=list_output
         )
 
-    return [db_name_upload, db_name_list]
+    return {"upload": db_name_upload, "list": db_name_list}

ui/management_tabs.py

@@ -0,0 +1,163 @@
+import gradio as gr
+import logging
+from app.document_handling import upload_and_index, list_indexed_files, delete_file_from_database
+from app.functions.database_handling import (
+    create_database, 
+    modify_database, 
+    delete_database, 
+    list_databases
+)
+
+class ManagementTabs:
+    def __init__(self, update_all_dropdowns):
+        self.update_all_dropdowns = update_all_dropdowns
+        self.databases = list_databases()
+        
+    def create_tabs(self):
+        with gr.Tabs():
+            self._create_db_management_tab()
+            self._create_document_management_tab()
+            
+    def _create_db_management_tab(self):
+        with gr.Tab("Gestione Database"):
+            gr.Markdown("## Operazioni sui Database")
+            
+            with gr.Row():
+                # Creazione Database
+                with gr.Column():
+                    gr.Markdown("### Crea Database")
+                    self.db_name_input = gr.Textbox(label="Nome Nuovo Database")
+                    self.create_db_button = gr.Button("Crea Database")
+                    self.create_output = gr.Textbox(label="Stato Creazione")
+                
+                # Modifica Database
+                with gr.Column():
+                    gr.Markdown("### Rinomina Database")
+                    self.modify_db_old_name = gr.Dropdown(
+                        choices=self.databases, 
+                        label="Database da Rinominare"
+                    )
+                    self.modify_db_new_name = gr.Textbox(label="Nuovo Nome")
+                    self.modify_db_button = gr.Button("Rinomina Database")
+                    self.modify_output = gr.Textbox(label="Stato Modifica")
+                
+                # Eliminazione Database
+                with gr.Column():
+                    gr.Markdown("### Elimina Database")
+                    self.delete_db_dropdown = gr.Dropdown(
+                        choices=self.databases, 
+                        label="Database da Eliminare"
+                    )
+                    self.delete_db_button = gr.Button("Elimina Database")
+                    self.delete_output = gr.Textbox(label="Stato Eliminazione")
+            
+            self._setup_db_events()
+    
+    def _create_document_management_tab(self):
+        with gr.Tab("Gestione Documenti"):
+            with gr.Column():
+                # Upload Documenti
+                gr.Markdown("### Carica Documenti")
+                with gr.Row():
+                    self.file_input = gr.File(
+                        label="Carica i tuoi documenti",
+                        file_types=[".txt", ".pdf", ".docx"],
+                        file_count="multiple"
+                    )
+                    self.db_name_upload = gr.Dropdown(
+                        choices=self.databases,
+                        label="Seleziona Database",
+                        value="default_db"
+                    )
+                
+                with gr.Row():
+                    self.title_input = gr.Textbox(label="Titolo del documento")
+                    self.author_input = gr.Textbox(label="Autore")
+                
+                self.upload_button = gr.Button("Indicizza Documenti")
+                self.upload_output = gr.Textbox(label="Stato Upload")
+                
+                # Gestione File
+                self._setup_file_management()
+            
+            self._setup_document_events()
+    
+    def _setup_file_management(self):
+        gr.Markdown("### Gestione File")
+        with gr.Row():
+            self.db_name_list = gr.Dropdown(
+                choices=self.databases,
+                label="Database",
+                value="default_db"
+            )
+            self.list_button = gr.Button("Lista File")
+        self.list_output = gr.Textbox(label="File nel Database")
+        
+        with gr.Row():
+            self.delete_file_input = gr.Textbox(label="Nome File da Eliminare")
+            self.delete_file_button = gr.Button("Elimina File")
+        self.delete_file_output = gr.Textbox(label="Stato Eliminazione")
+    
+    def _setup_db_events(self):
+        # Eventi per la gestione del database
+        self.create_db_button.click(
+            fn=create_database,
+            inputs=self.db_name_input,
+            outputs=self.create_output
+        ).then(fn=self.update_all_dropdowns)
+        
+        self.modify_db_button.click(
+            fn=modify_database,
+            inputs=[self.modify_db_old_name, self.modify_db_new_name],
+            outputs=self.modify_output
+        ).then(fn=self.update_all_dropdowns)
+        
+        self.delete_db_button.click(
+            fn=delete_database,
+            inputs=self.delete_db_dropdown,
+            outputs=self.delete_output
+        ).then(fn=self.update_all_dropdowns)
+    
+    def _setup_document_events(self):
+        # Eventi per la gestione dei documenti
+        self.upload_button.click(
+            fn=self._upload_and_index_callback,
+            inputs=[self.file_input, self.title_input, self.author_input, self.db_name_upload],
+            outputs=self.upload_output
+        ).then(fn=self.update_all_dropdowns).then(
+            fn=self._list_files_callback,
+            inputs=[self.db_name_list],
+            outputs=self.list_output
+        )
+        
+        self.list_button.click(
+            fn=self._list_files_callback,
+            inputs=[self.db_name_list],
+            outputs=self.list_output
+        )
+        
+        self.delete_file_button.click(
+            fn=self._delete_file_callback,
+            inputs=[self.delete_file_input, self.db_name_list],
+            outputs=self.delete_file_output
+        ).then(fn=self.update_all_dropdowns)
+    
+    def _upload_and_index_callback(self, files, title, author, db_name):
+        try:
+            status = upload_and_index(files, title, author, db_name)
+            logging.info(f"Upload completato: {status}")
+            return status
+        except Exception as e:
+            logging.error(f"Errore durante l'upload: {str(e)}")
+            return f"Errore: {str(e)}"
+    
+    def _list_files_callback(self, db_name):
+        return list_indexed_files(db_name)
+    
+    def _delete_file_callback(self, file_name, db_name):
+        return delete_file_from_database(file_name, db_name)
+
+def create_management_tabs(update_all_dropdowns):
+    tabs = ManagementTabs(update_all_dropdowns)
+    tabs.create_tabs()
+    return tabs