Update app.py

app.py

@@ -19,45 +19,49 @@ import fitz
 import re
 import io
 from collections import Counter
-import secrets
 
 st.set_page_config(page_title="Import Fatture AI✨")
+st.title("Import Fatture AI ✨")
 
-from streamlit_google_auth import Authenticate
-google_auth_str = os.getenv("JSON_GOOGLE_SECRET")
-google_auth_data = json.loads(google_auth_str)
-with open("google_credentials.json", "w") as f:
-    json.dump(google_auth_data, f, indent=4)
-
-authenticator = Authenticate(
-    secret_credentials_path='google_credentials.json',
-    cookie_name=f"llm_pdf_digest_{secrets.token_hex(4)}",
-    cookie_key=secrets.token_hex(32),
-    redirect_uri=os.getenv("URL_REDIRECT"),
-)
+# Gestionione LOGIN
+if "logged" not in st.session_state:
+    st.session_state.logged = False
+    st.session_state.model = "gemini-2.0-flash"
+if st.session_state.logged == False:
+    login_placeholder = st.empty()
+    with login_placeholder.container():
+        container = st.container(border=True)
+        username = container.text_input('Username')
+        password = container.text_input('Passowrd', type='password')
+        login = container.button('  Login  ', type='primary')
+    if not login or username != os.getenv("LOGIN_USER") or  password != os.getenv("LOGIN_PASSWORD"):
+        if login:
+            st.error('Password Errata')
+        st.stop()
+    st.session_state.logged = True
+    login_placeholder.empty()
 
-st.title("Import Fatture AI ✨")
 with st.expander("Guida completa"):
     st.write("""Questa applicazione Python, basata su Streamlit, integra servizi di intelligenza artificiale di Gemini per automatizzare l'estrazione e la validazione dei dati dalle fatture. Il sistema gestisce documenti in vari formati (PDF, immagini) e li elabora in maniera modulare per facilitare la conversione e la verifica delle informazioni.
 
 ## Funzionalità Principali
 
 - **Caricamento e Gestione dei Documenti**
-- Supporta il caricamento di file PDF, JPG, JPEG e PNG tramite un’interfaccia Streamlit.
-- Se il file è un PDF con più pagine, viene suddiviso in sezioni (configurabile tramite uno slider) per una gestione più efficace. Più il numero è basso più il risultato è preciso.
+    - Supporta il caricamento di file PDF, JPG, JPEG e PNG tramite un’interfaccia Streamlit.
+    - Se il file è un PDF con più pagine, viene suddiviso in sezioni (configurabile tramite uno slider) per una gestione più efficace. Più il numero è basso più il risultato è preciso.
 
 - **Conversione dei Dati**
-- **Upload e Inoltro a Gemini**: I file vengono caricati e inviati al rispettivo servizio AI.
-- **Estrazione dei Dati**: Il sistema invia il documento a un modello di generazione AI per ottenere una rappresentazione JSON contenente i dati (ad es. numero di documento, data, totale imponibile e articoli).
+    - **Upload e Inoltro a Gemini**: I file vengono caricati e inviati al rispettivo servizio AI.
+    - **Estrazione dei Dati**: Il sistema invia il documento a un modello di generazione AI per ottenere una rappresentazione JSON contenente i dati (ad es. numero di documento, data, totale imponibile e articoli).
 
 - **Validazione e Verifica**
-- **Validazione JSON**: Utilizza Pydantic per verificare la correttezza della struttura e dei dati estratti. In caso di errori, il documento viene riprocessato fino a 3 volte per cercare di correggere le anomalie.
-- **Verifica Incrociata dei Contenuti**: Per i PDF, viene estratto il testo con PyPDF2 e confrontato con i codici articolo per assicurarsi che i dati siano effettivamente presenti nel documento.
-- **Filtraggio Articoli**: Vengono mantenuti solo gli articoli compatibili con i criteri specifici (codici articolo e importi non nulli).
+    - **Validazione JSON**: Utilizza Pydantic per verificare la correttezza della struttura e dei dati estratti. In caso di errori, il documento viene riprocessato fino a 3 volte per cercare di correggere le anomalie.
+    - **Verifica Incrociata dei Contenuti**: Per i PDF, viene estratto il testo con PyPDF2 e confrontato con i codici articolo per assicurarsi che i dati siano effettivamente presenti nel documento.
+    - **Filtraggio Articoli**: Vengono mantenuti solo gli articoli compatibili con i criteri specifici (codici articolo e importi non nulli).
 
 - **Visualizzazione e Highlighting**
-- I dati validati vengono mostrati in formato tabellare e in JSON.
-- Se il documento è un PDF, il sistema evidenzia graficamente (con rettangoli rossi) i testi relativi agli articoli compatibili, semplificando il controllo visivo.
+    - I dati validati vengono mostrati in formato tabellare e in JSON.
+    - Se il documento è un PDF, il sistema evidenzia graficamente (con rettangoli rossi) i testi relativi agli articoli compatibili, semplificando il controllo visivo.
 
 ## Avvertenze per l'Operatore
 
@@ -75,14 +79,6 @@ st.write("🤖 **Sfrutta l'AI di Gemini:** Per ogni documento, estrae i dati in
 st.write("✅ **Mostra Articoli Compatibili:** Filtra e visualizza solo gli articoli che rispettano i criteri richiesti.")
 st.write("🔍 **Anteprima Documento:** Visualizza un'anteprima del documento evidenziando gli articoli compatibili.")
 
-authenticator.check_authentification()
-authenticator.login()
-
-if not st.session_state.get('connected'):
-    with st.sidebar:
-        st.title("Login")
-        st.write("Seleziona l'account aziendale per accedere")    
-    st.stop()
 
 GENERATION_CONFIG = settings_ai.GENERATION_CONFIG
 SYSTEM_INSTRUCTION = settings_ai.SYSTEM_INSTRUCTION
@@ -92,7 +88,7 @@ API_KEY_GEMINI = settings_ai.API_KEY_GEMINI
 # Configura il modello Gemini
 genai.configure(api_key=API_KEY_GEMINI)
 model = genai.GenerativeModel(
-    model_name="gemini-2.0-flash",
+    model_name=st.session_state.model,
     generation_config=GENERATION_CONFIG,
     system_instruction=SYSTEM_INSTRUCTION
 )
@@ -119,7 +115,7 @@ def wait_for_files_active(files):
     print("\n...all files ready")
 
 # Chiamata API Gemini
-def send_message_to_gemini(chat_session, message, max_attempts=3):
+def send_message_to_gemini(chat_session, message, max_attempts=5):
     """Tenta di inviare il messaggio tramite la chat_session, riprovando fino a max_attempts in caso di eccezioni, con un delay di 10 secondi tra i tentativi. """
     for attempt in range(max_attempts):
         try:
@@ -238,7 +234,14 @@ def process_document_splitted(file_path: str, chunk_label: str, use_azure: bool
         files = [upload_to_gemini(file_path, mime_type=mime_type)]
         wait_for_files_active(files)
         chat_history = [{ "role": "user","parts": [files[0]]}]
-        chat_session = model.start_chat(history=chat_history)    
+        for attempt in range(3):
+            try:
+                chat_session = model.start_chat(history=chat_history)
+                break  
+            except Exception as e:
+                print(f"Errore nello Start chat") 
+                time.sleep(10)
+
     max_validation_attempts = 3
     max_number_reprocess = 3
     chunk_document = None
@@ -289,7 +292,7 @@ def process_document(path_file: str, number_pages_split: int, use_azure: bool =
     if mime_type is None:
         mime_type = "application/octet-stream"
     if use_azure:
-        number_pages_split = 2
+        number_pages_split = 1
     if not path_file.lower().endswith(".pdf"):
         print("File non PDF: elaborazione come immagine.")
         documento_finale = process_document_splitted(path_file, chunk_label="(immagine)", use_azure=use_azure)
@@ -325,14 +328,31 @@ def process_document(path_file: str, number_pages_split: int, use_azure: bool =
     if documento_finale is None:
         raise RuntimeError("Nessun documento elaborato.")
 
-    # Controlli aggiuntivi: Se esiste un AVE non possono esistere altri articoli non ave. Se articoli DOPPI segnalo!
+    # Controlli aggiuntivi: Se esiste un AVE non possono esistere altri articoli non ave. 
     if any(articolo.CodiceArticolo.startswith("AVE") for articolo in documento_finale.Articoli):
         documento_finale.Articoli = [articolo for articolo in documento_finale.Articoli if articolo.CodiceArticolo.startswith("AVE")]
-    combinazioni = [(articolo.CodiceArticolo, articolo.TotaleNonIvato) for articolo in documento_finale.Articoli]
-    conta_combinazioni = Counter(combinazioni)
-    for articolo in documento_finale.Articoli:
-        if conta_combinazioni[(articolo.CodiceArticolo, articolo.TotaleNonIvato)] > 1:
-            articolo.Verificato = False    
+    # Controllo occorrenze di doppioni 
+    if path_file.lower().endswith(".pdf"):
+        pdf_text = pdf_to_text(path_file)
+        pdf_text = pdf_text.replace(" ", "")
+        occorrenze = {}
+        for articolo in documento_finale.Articoli:
+            codice_clean = articolo.CodiceArticolo.replace(" ", "")
+            if codice_clean not in occorrenze:
+                occorrenze[codice_clean] = pdf_text.count(codice_clean)
+        articoli_contati = {}
+        for articolo in documento_finale.Articoli:
+            codice_clean = articolo.CodiceArticolo.replace(" ", "")
+            if codice_clean in pdf_text:
+                print(codice_clean)
+                print(occorrenze[codice_clean])
+                articoli_contati[codice_clean] = articoli_contati.get(codice_clean, 0) + 1
+                if articoli_contati[codice_clean] <= occorrenze.get(codice_clean, 0):
+                    articolo.Verificato = True
+                else:
+                    articolo.Verificato = False
+            else:
+                articolo.Verificato = False
     return documento_finale
 
 # Analizza Fattura con AZURE 
@@ -367,11 +387,15 @@ def parse_invoice_to_documento_azure(result) -> Documento:
     if items_field and items_field.value_array:
         for item in items_field.value_array:
             product_code_field = item.value_object.get("ProductCode")
+            description_field = str(item.value_object.get("Description").get("content"))
+            if not description_field:
+                description_field = ""
             codice_articolo = product_code_field.value_string if product_code_field and product_code_field.value_string else ""
             amount_field = item.value_object.get("Amount")
             totale_non_ivato = amount_field.value_currency.amount if amount_field and amount_field.value_currency else 0.0
             articolo = Articolo(
                 CodiceArticolo=codice_articolo,
+                DescrizioneArticolo=description_field,
                 TotaleNonIvato=totale_non_ivato,
                 Verificato=None
             )
@@ -391,9 +415,11 @@ def main():
     #st.set_page_config(page_title="Import Fatture AI", page_icon="✨")
     st.sidebar.title("Caricamento File")
     uploaded_files = st.sidebar.file_uploader("Seleziona uno o più PDF", type=["pdf", "jpg", "jpeg", "png"], accept_multiple_files=True)
-    model_ai = st.sidebar.selectbox("Modello", ['Gemini Flash 2.0']) # 'Azure Intelligence'])
+    model_ai = st.sidebar.selectbox("Modello", ['Gemini Flash 2.0', 'Gemini 2.5 Pro', 'Azure Intelligence'])
+    if model_ai == 'Gemini 2.5 Pro':
+        st.session_state.model = "gemini-2.5-pro-exp-03-25"
     use_azure = True if model_ai == 'Azure Intelligence' else False
-    number_pages_split = st.sidebar.slider('Split Pagine', 1, 30, 2, help="Numero suddivisione pagine del PDF. Più il numero è basso e più il modello AI è preciso, più è alto più è veloce")
+    number_pages_split = st.sidebar.slider('Split Pagine', 1, 30, 1, help="Numero suddivisione pagine del PDF. Più il numero è basso e più il modello AI è preciso, più è alto più è veloce")
     if st.sidebar.button("Importa", type="primary", use_container_width=True):
         if not uploaded_files:
             st.warning("Nessun file caricato!")
@@ -417,15 +443,18 @@ def main():
                             f"- **Articoli Compatibili**: {len(doc.Articoli)}\n"
                             f"- **Totale Documento**: {format_euro(doc.TotaleImponibile)}\n"
                         )
+                        if totale_non_ivato > doc.TotaleImponibile and doc.TotaleImponibile > 0:
+                            st.warning("Totale Ave maggiore di Totale Merce")
                         if totale_non_ivato_non_verificato > 0:
-                            st.error(f"Totale Ave Non Verificato: {format_euro(totale_non_ivato_verificato)}")
-                        elif totale_non_ivato != 0:
+                            st.error(f"Totale Ave Non Verificato: {format_euro(totale_non_ivato_non_verificato)}")
+                        if totale_non_ivato > 0:
                             st.success(f"Totale Ave Verificato: {format_euro(totale_non_ivato_verificato)}")
                         df = pd.DataFrame([{k: v for k, v in Articolo.model_dump().items() if k != ""} for Articolo in doc.Articoli])                                       
                         if 'Verificato' in df.columns:
                             df['Verificato'] = df['Verificato'].apply(lambda x: "✅" if x == 1 else "❌" if x == 0 else "❓" if x == 2 else x)
                         if totale_non_ivato > 0:
-                            st.dataframe(df, use_container_width=True ,column_config={"TotaleNonIvato": st.column_config.NumberColumn("Totale non Ivato",format="€ %.2f")})
+                            df["TotaleNonIvato"] = df["TotaleNonIvato"].apply(format_euro)
+                            st.dataframe(df, use_container_width=True)
                         st.json(doc.model_dump(), expanded=False)
                         if totale_non_ivato == 0:
                             st.info(f"Non sono presenti articoli 'AVE'")