Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· openaiHugging Face Suzhen/CodeChat

questo codice funziona, ma anche se la parola è presente in più pagine estrae solo i…

  1. User

    questo codice funziona, ma anche se la parola è presente in più pagine estrae solo i dati della prima pagina:

    import pyodbc # Modulo per connessione ODBC a database import fitz # PyMuPDF from ParseTab import ParseTab import time from datetime import timedelta, datetime, tzinfo, timezone import pytz import re import locale import os locale.setlocale(locale.LC_NUMERIC, 'italian') # o locale corrispondente from decimal import Decimal

    access_db_path = r'C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\F24.accdb' #pdf_file_path = r'J:\PyMuPDF-Utilities-master\extract-table\PNCNNN67S23B521W_2022_2321_F24_11962_ALL.PDF' word_to_search = 'MODELLO DI PAGAMENTO' def safe_float_convert(value): try: # Rimuovere spazi e separatore delle migliaia, sostituire la virgola con il punto se necessario value = value.strip().replace(',', '.').replace(' ', '').replace('\xa0', '') return float(value) except ValueError: # La conversione è fallita, gestirla come migliore si crede (log, valore di default, ecc.) print(f"Warning: Could not convert '{value}' to a float.") return None # o un valore di default, come 0.0

    Funzione per cercare una parola nel PDF e ritornare la pagina

    def search_word_in_pdf(pdf, word): for page_num in range(len(pdf)): page = pdf[page_num] print(page_num) if page.search_for(word): return page # Ritorna l’oggetto pagina in cui è stata trovata la parola return None # Se la parola non è stata trovata in nessuna pagina

    Sostituisci ‘path_to_directory’ con il percorso effettivo della cartella che contiene i file PDF

    path_to_directory = r'C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\F24'

    Ottieni tutti i file nella directory e filtra quelli che terminano con ‘.pdf’

    pdf_files = [file for file in os.listdir(path_to_directory) if file.lower().endswith('.pdf')]

    def unixTime(): dt = datetime.now(tz=pytz.utc) return str(int(dt.timestamp() * 1000))

    Stampa i nomi dei file PDF

    for pdf_file in pdf_files: pdf_path = os.path.join(path_to_directory, pdf_file) print(pdf_file)

    # Apri il documento
    pdf_document = fitz.open(pdf_path)
    
    
    # Cerca la parola nel PDF e ottieni l’oggetto della pagina
    page = search_word_in_pdf(pdf_document, word_to_search)
    
    # Connettersi al database MS Access
    conn_str = (
        r'DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};'
        rf'DBQ={access_db_path};'
    )
    conn = pyodbc.connect(conn_str)
    cursor = conn.cursor()
     
    if page is not None:
            unix_timestamp=""
            unix_timestamp = unixTime()
            print(unix_timestamp)
            # Estrai e prepara il Codice Fiscale
            bbox_cf = [118, 104, 353, 121]  # Coordinate box estrazione CF
            parsed_cf = ParseTab(page, bbox_cf, [])
            codice_fiscale = parsed_cf[0] if parsed_cf else None  # Assicuriamoci che ci sia una riga
            codice_fiscale = codice_fiscale[0] if codice_fiscale else ""  # Prendi il primo elemento se presente
            # Estrai codice ufficio
            bbox_cod_uff = [27,312,72,326]  # Coordinate box estrazione
            parsed_cod_uff = ParseTab(page, bbox_cod_uff, [])
            cod_uff = parsed_cod_uff[0] if parsed_cod_uff else None  # Assicuriamoci che ci sia una riga
            cod_uff = cod_uff[0] if cod_uff else ""  # Prendi il primo elemento se presente
            # Estrai codice atto
            bbox_cod_atto = [97,312,261,324]  # Coordinate box estrazione
            parsed_cod_atto  = ParseTab(page, bbox_cod_atto , [])
            cod_atto  = parsed_cod_atto [0] if parsed_cod_atto  else None  # Assicuriamoci che ci sia una riga
            cod_atto  = cod_atto [0] if cod_atto  else ""  # Prendi il primo elemento se presente
           
    
            # Estrai IBAN
            bbox_iban = [114,803,347,817]
            parsed_iban = ParseTab(page, bbox_iban, [])
            codice_iban = parsed_iban[0] if parsed_iban else None  # Assicuriamoci che ci sia una riga
            codice_iban = codice_iban[0] if codice_iban else ""  # Prendi il primo elemento se presente
            bbox_saldo = [502,708,579,721]
            parsed_saldo = ParseTab(page, bbox_saldo, [])
            saldo = parsed_saldo[0] if parsed_saldo else None  # Assicuriamoci che ci sia una riga
            saldo = saldo[0] if saldo else ""  # Prendi il primo elemento se presente
            bbox_giorno = [33,776,62,794]
            parsed_giorno = ParseTab(page, bbox_giorno, [])
            giorno= parsed_giorno[0]
            bbox_mese = [62,776,91,794]
            parsed_mese = ParseTab(page, bbox_mese, [])
            mese= parsed_mese[0]
            bbox_anno = [92,776,150,794]
            parsed_anno = ParseTab(page, bbox_anno, [])
            anno= parsed_anno[0]
            giorno_str = parsed_giorno[0][0] if parsed_giorno and parsed_giorno[0] else ""
            mese_str = parsed_mese[0][0] if parsed_mese and parsed_mese[0] else ""
            anno_str = parsed_anno[0][0] if parsed_anno and parsed_anno[0] else ""
            # Combina i valori in una data formattata come stringa “gg/mm/aaaa”
            data = f"{giorno_str}/{mese_str}/{anno_str}"
            try:
                data_obj = datetime.strptime(data, "%d/%m/%Y")
                ##print(data_obj)  # Stampa l’oggetto datetime
            except ValueError as e:
                print(f"Errore nella conversione della data: {e}")
                    
            # Estrai e prepara il Protocollo, Progressivo e Esito_pag
            #bbox_id = [69,8,534,26]  # Coordinate box estrazione ID
            bbox_id = [42,7,559,25]  # Coordinate box estrazione ID
            parsed_id = ParseTab(page, bbox_id,[])
            # Inizializza variabili
            testo= parsed_id[0]
            protocollo = ""
            progressivo = ""
            esito_pag = ""
            codice_f24 = ""
            
            # Espressione regolare per catturare i dati richiesti
            pattern = re.compile(r"Prot:(\d+)/(0{4,6}\d+)\sEsito pag.: (\w+\s*\w*)")
            # Eseguo la ricerca sull’intero testo
            matches = pattern.finditer(str(testo).strip())
            # Per ogni corrispondenza trovata, stampo i risultati
            for match in matches:
                protocollo, progressivo,  esito_pag = match.groups()
                codice_f24 = f"{protocollo}-{progressivo}"
        
                print(f"protocollo {protocollo}")
                print(f"progressivo {progressivo}")
                print(f"esito {esito_pag}")
                print(f"codice_f24 {codice_f24}\n")
            
            
            #protocollo, progressivo = re.findall(r'(\d+)/(\d+)', parsed_id[0][2])[0].split() if parsed_id else ("", "")
            #esito_pag = parsed_id[0][3].split(': ')[1] if parsed_id else ""
            #codice_f24 = f"{protocollo}-{progressivo}"
        
              
            # Inserisci nel database
            with pyodbc.connect(conn_str) as conn:
                cursor = conn.cursor()
                query = "INSERT INTO Testa ([Codice atto], [Ufficio - Codice],[Data versamento], Saldo, IBAN, [Codice fiscale], [Tele - Protocollo fornitura], [Tele - Progressivo], codice_f24, ID_doc, [Tele - Esito fornitura]) VALUES (?,?,?,?,?,?, ?, ?, ?, ?, ?)"
                cursor.execute(query, cod_atto , cod_uff, data, saldo,  codice_iban.strip(), codice_fiscale.strip(), protocollo.strip(), progressivo.strip(), codice_f24.strip(), unix_timestamp, esito_pag.strip())
                conn.commit()
                print("I dati sono stati importati con successo nel database Access.")
            # Estrai la tabella usando la funzione ParseTab
    
    
            #Sezione erario
    
    
            table_bbox = [162,239,496,311] # Ad esempio, coordinate del rettangolo della tabella
            column_coords = [228,279,327,414]  # Coordinate delle colonne all’interno della tavola
            parsed_table = ParseTab(page, table_bbox, column_coords)
                # Stampa o elabora il contenuto estratto della tabella
            if parsed_table:
                # Assumiamo che parsed_table sia una lista di liste, dove ogni lista interna rappresenta una riga della tabella
                for row in parsed_table:
                    # Assicurati che ‘row’ contenga dati validi prima di procedere all’inserimento
                    if any(row):
                        # Procedi con l’inserimento solo se ‘row’ contiene elementi non-vuoti
                        
                       
                        insert_query = "INSERT INTO righi (Codice_fiscale, ID_doc, codice_f24, Sezione, [Codice tributo], rata, anno, Importo, importo_credito) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
                        cursor.execute(insert_query, (codice_fiscale, unix_timestamp, codice_f24, 'ERARIO', row[0], row[1], row[2], safe_float_convert(row[3]) , safe_float_convert(row[4])))
                        conn.commit()
                    else:
                        print("Una riga della tabella estratta è vuota o non contiene dati validi. La riga non è stata inserita nel database.")
            else:
                print("La tabella estratta è vuota o non contiene dati validi. Nessun dato inserito nel database.")
    
         # Sezione INPS
            table_bbox = [28,347,497,395] # Ad esempio, coordinate del rettangolo della tabella
            column_coords = [62,98,227,279,328,415]  # Coordinate delle colonne all’interno della tavola
            parsed_table = ParseTab(page, table_bbox, column_coords)
                # Stampa o elabora il contenuto estratto della tabella
            if parsed_table:
                # Assumiamo che parsed_table sia una lista di liste, dove ogni lista interna rappresenta una riga della tabella
                for row in parsed_table:
                    # Assicurati che ‘row’ contenga dati validi prima di procedere all’inserimento
                    if any(row):
                        # Procedi con l’inserimento solo se ‘row’ contiene elementi non-vuoti
                        
                       
                        insert_query = "INSERT INTO righi (Codice_fiscale, ID_doc, codice_f24, Sezione, codice_sede,[Codice tributo], matricola, mm_aa, mm_aa_1,  Importo, importo_credito) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
                        cursor.execute(insert_query, (codice_fiscale, unix_timestamp, codice_f24, 'INPS', row[0], row[1], row[2], row[3], row[4], safe_float_convert(row[5]), safe_float_convert(row[6])))
                        conn.commit()
                    else:
                        print("Una riga della tabella estratta è vuota o non contiene dati validi. La riga non è stata inserita nel database.")
            else:
                print("La tabella estratta è vuota o non contiene dati validi. Nessun dato inserito nel database.")
    
    
            #Sezione regioni
                
            table_bbox = [24,432,498,480] # Ad esempio, coordinate del rettangolo della tabella
            column_coords = [162,227,278,329,416]  # Coordinate delle colonne all’interno della tavola
            parsed_table = ParseTab(page, table_bbox, column_coords)
                # Stampa o elabora il contenuto estratto della tabella
            if parsed_table:
                # Assumiamo che parsed_table sia una lista di liste, dove ogni lista interna rappresenta una riga della tabella
                for row in parsed_table:
                    # Assicurati che ‘row’ contenga dati validi prima di procedere all’inserimento
                    if any(row):
                        # Procedi con l’inserimento solo se ‘row’ contiene elementi non-vuoti
                        
                       
                        insert_query = "INSERT INTO righi (Codice_fiscale, ID_doc, codice_f24, Sezione, codice_sede,[Codice tributo], rata, anno, Importo, importo_credito) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
                        cursor.execute(insert_query, (codice_fiscale, unix_timestamp, codice_f24, 'REGIONI', row[0], row[1], row[2], row[3], safe_float_convert(row[4]), safe_float_convert(row[5])))
                        conn.commit()
                    else:
                        print("Una riga della tabella estratta è vuota o non contiene dati validi. La riga non è stata inserita nel database.")
            else:
                print("La tabella estratta è vuota o non contiene dati validi. Nessun dato inserito nel database.")
    
            #Sezione imu e altri tributi locali
            
                
            table_bbox = [27,516,500,565] # Ad esempio, coordinate del rettangolo della tabella
            column_coords = [74, 90, 104, 117, 133, 161, 228, 279, 327, 414]  # Coordinate delle colonne all’interno della tavola
            parsed_table = ParseTab(page, table_bbox, column_coords)
                # Stampa o elabora il contenuto estratto della tabella
            if parsed_table:
                # Assumiamo che parsed_table sia una lista di liste, dove ogni lista interna rappresenta una riga della tabella
                for row in parsed_table:
                    # Assicurati che ‘row’ contenga dati validi prima di procedere all’inserimento
                    if any(row):
                        # Procedi con l’inserimento solo se ‘row’ contiene elementi non-vuoti
                        
                       
                        insert_query = "INSERT INTO righi (Codice_fiscale, ID_doc, codice_f24, Sezione, codice_sede,[Codice tributo], rata, anno, Importo, importo_credito) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
                        cursor.execute(insert_query, (codice_fiscale, unix_timestamp, codice_f24, 'ENTI LOCALI', row[0], row[6], row[7], row[8], safe_float_convert(row[9]), safe_float_convert(row[10])))
                        conn.commit()
                    else:
                        print("Una riga della tabella estratta è vuota o non contiene dati validi. La riga non è stata inserita nel database.")
            else:
                print("La tabella estratta è vuota o non contiene dati validi. Nessun dato inserito nel database.")
    
            #Sezione INAIL
            
                
            table_bbox = [103,599,497,637] # Ad esempio, coordinate del rettangolo della tabella
            column_coords = [149, 214, 243, 293, 327, 415]  # Coordinate delle colonne all’interno della tavola
            parsed_table = ParseTab(page, table_bbox, column_coords)
                # Stampa o elabora il contenuto estratto della tabella
            if parsed_table:
                # Assumiamo che parsed_table sia una lista di liste, dove ogni lista interna rappresenta una riga della tabella
                for row in parsed_table:
                    # Assicurati che ‘row’ contenga dati validi prima di procedere all’inserimento
                    if any(row):
                        # Procedi con l’inserimento solo se ‘row’ contiene elementi non-vuoti
                        
                       
                        insert_query = "INSERT INTO righi (Codice_fiscale, ID_doc, codice_f24, Sezione, codice_sede, matricola, cc, numero_rif, causale, Importo, importo_credito) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
                        cursor.execute(insert_query, (codice_fiscale, unix_timestamp, codice_f24, 'INAIL', row[0], row[1], row[2], row[3], row[4], safe_float_convert(row[5]), safe_float_convert(row[6])))
                        conn.commit()
                    else:
                        print("Una riga della tabella estratta è vuota o non contiene dati validi. La riga non è stata inserita nel database.")
            else:
                print("La tabella estratta è vuota o non contiene dati validi. Nessun dato inserito nel database.")
    
            # Sezione altri enti
            table_bbox = [29,659,498,685] # Ad esempio, coordinate del rettangolo della tabella
            column_coords = [70, 113, 149, 228, 278, 328, 416]  # Coordinate delle colonne all’interno della tavola
            parsed_table = ParseTab(page, table_bbox, column_coords)
                # Stampa o elabora il contenuto estratto della tabella
            if parsed_table:
                # Assumiamo che parsed_table sia una lista di liste, dove ogni lista interna rappresenta una riga della tabella
                for row in parsed_table:
                    # Assicurati che ‘row’ contenga dati validi prima di procedere all’inserimento
                    if any(row):
                        # Procedi con l’inserimento solo se ‘row’ contiene elementi non-vuoti
                        
                       
                        insert_query = "INSERT INTO righi (Codice_fiscale, ID_doc, codice_f24, Sezione,codice_ente, codice_sede,[Codice tributo], matricola, mm_aa, mm_aa_1,  Importo, importo_credito) VALUES (?,?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
                        cursor.execute(insert_query, (codice_fiscale, unix_timestamp, codice_f24, 'ALTRI ENTI', row[0], row[1], row[2], row[3], row[4], row[5],safe_float_convert(row[6]), safe_float_convert(row[7])))
                        conn.commit()
                    else:
                        print("Una riga della tabella estratta è vuota o non contiene dati validi. La riga non è stata inserita nel database.")
            else:
                print("La tabella estratta è vuota o non contiene dati validi. Nessun dato inserito nel database.")    
        
    
    
    else:
        print(f"La parola '{word_to_search}' non è stata trovata nel documento.")
    pdf_document.close()
    cursor.close()
    
  2. Assistant

    Il codice che hai fornito cerca una parola (in questo caso 'MODELLO DI PAGAMENTO') all'interno di file PDF e, quando la trova nella prima pagina che la contiene, estrae e processa i dati di quella pagina per poi inserirli in un database MS Access. Tuttavia, il codice come è stato scritto interrompe la ricerca non appena trova la parola nella prima pagina che soddisfa il criterio di ricerca, senza proseguire con l'analisi delle eventuali pagine successive che potrebbero contenere la stessa parola.

    Per modificare questo comportamento e fare in modo che il programma elabori tutte le pagine che contengono la parola cercata, è necessario adattare la funzione search_word_in_pdf per restituire una lista di pagine invece di una singola pagina, e poi iterare su questa lista per eseguire l'elaborazione su ogni pagina trovata.

    Ecco come potrebbe essere modificata la funzione search_word_in_pdf per restituire una lista di pagine:

    # Funzione modificata per cercare una parola nel PDF e ritornare una lista di pagine
    def search_word_in_pdf(pdf, word):
        pages_found = []  # Lista per tenere traccia delle pagine in cui è stata trovata la parola
        for page_num in range(len(pdf)):
            page = pdf[page_num]
            print(page_num)
            if page.search_for(word):
                pages_found.append(page)  # Aggiungi l'oggetto pagina alla lista
        return pages_found  # Ritorna la lista delle pagine in cui è stata trovata la parola
    

    Successivamente, devi adattare il codice che effettua l'elaborazione per iterare su questa lista di pagine anziché operare su una singola pagina. Cambia la porzione del codice che utilizza il risultato della search_word_in_pdf come segue:

    # Cerca la parola nel PDF e ottieni la lista delle pagine
    pages = search_word_in_pdf(pdf_document, word_to_search)
    
    # Itera su ogni pagina trovata
    for page in pages:
        # [Inserisci qui il resto del codice per l'elaborazione]
        # Ricorda di sostituire ogni riferimento precedente a 'page'
        # con 'page' definito qui nell'iterazione
    
    # Il resto del tuo codice di elaborazione va qui, indentato correttamente per far parte del ciclo 'for'
    

    Assicurati che il codice che esegue l'effettiva elaborazione dei dati estratti dal PDF (estrarre dati specifici, connettersi al database, eseguire query, ecc.) sia posizionato all'interno del ciclo for in modo che possa essere eseguito per ogni pagina che contiene la parola cercata.

    Ricorda che con queste modifiche il codice eseguirà l'intero blocco di elaborazione per ogni pagina che contiene la parola chiave, quindi assicurati che tutte le variabili siano adeguatamente inizializzate e gestite all'interno del ciclo per evitare sovrascritture o conflitti.

  3. User

    Traceback (most recent call last): File "C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\estrazioni_1.py", line 75, in parsed_cf = ParseTab(page, bbox_cf, []) File "C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\ParseTab.py", line 63, in ParseTab words = page.getTextWords() AttributeError: 'list' object has no attribute 'getTextWords'

  4. Assistant

    L'errore che stai riscontrando indica che stai tentando di chiamare il metodo getTextWords() su un oggetto di tipo list invece che sull'oggetto page proveniente da PyMuPDF (fitz). Questo errore è molto probabilmente dovuto a modifiche non correttamente implementate dopo l'adattamento della funzione search_word_in_pdf per restituire una lista di pagine.

    Dato che search_word_in_pdf adesso restituisce una lista di oggetti pagina, devi assicurarti di accedere correttamente a ciascuna pagina individuale quando iteri sulla lista di pagine ritornate. È possibile che tu stia passando accidentalmente l'intera lista a ParseTab invece di una singola pagina.

    Ecco il modo corretto per iterare sulla lista di pagine e assicurarsi di passare una singola pagina alla volta alla funzione ParseTab (o ad altre funzioni che si aspettano un oggetto page come argomento):

    # Cerca la parola nel PDF e ottieni la lista delle pagine
    pages = search_word_in_pdf(pdf_document, word_to_search)
    
    # Itera su ogni pagina trovata
    for page in pages:
        # Ora 'page' è un singolo oggetto pagina, non una lista
        # Esegui l'elaborazione per la singola pagina 'page'
        
        # Adesso puoi chiamare correttamente ParseTab passando l'oggetto 'page'
        parsed_cf = ParseTab(page, bbox_cf, [])
        # Ora 'page' è correttamente passato come oggetto singolo, non una lista
        
        # Continua con il resto delle operazioni per la pagina corrente,
        # come facevi in precedenza nel tuo script.
    

    Assicurati che altre parti del tuo codice che utilizzano la variabile page (o qualsiasi operazione che tu faccia specificamente su oggetti pagina) siano all'interno di questo ciclo for. Questo garantirà che ogni operazione che richiede un oggetto pagina venga eseguita su una singola pagina per volta, evitando così l'errore AttributeError: 'list' object has no attribute 'getTextWords'.

  5. User

    ottimo funziona

  6. Assistant

    Sono contento di sapere che i suggerimenti forniti hanno risolto il problema e che il codice ora funziona come previsto. Se hai altre domande o incontri nuove sfide con i tuoi progetti di programmazione, non esitare a chiedere. Sono qui per aiutarti!

    Ricorda che la programmazione è un processo iterativo: scrivere codice, testarlo, risolvere eventuali errori e ottimizzarlo. Ogni problema risolto costruisce le tue competenze e ti porta un passo avanti nella tua carriera da sviluppatore. Buona programmazione!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.