def GetMatrix(self, evt): parse table contained in rectangle currently, the table is…
- User
def GetMatrix(self, evt): # parse table contained in rectangle # currently, the table is just stored away as a matrix: # add functionality as desired x0 = self.rect_x y0 = self.rect_y x1 = x0 + self.rect_w y1 = y0 + self.rect_h cols = list(self.col_coords.values()) cols.sort() pg = getint(self.TextToPage.Value) - 1 self.parsed_table = ParseTab(self.doc[pg], [x0, y0, x1, y1], columns=cols) if self.parsed_table: r = len(self.parsed_table) c = len(self.parsed_table[0]) t = "\nContents of (%s x %s)-table at [%s,%s] on page %s" print(t % (r, c, x0, y0, pg + 1)) for l in self.parsed_table: print(l) else: print("No text found in rectangle")
- Assistant
The provided function
GetMatrixappears to be a method belonging to a Python class (since it takesselfas the first argument). The method is designed to parse and print the contents of a table located within a rectangular area of a document page.Here's a step-by-step explanation of the method:
-
self.rect_x,self.rect_y,self.rect_w, andself.rect_happear to be instance variables that define a rectangle's upper-left corner (x0, y0) coordinates and its width (self.rect_w) and height (self.rect_h). These are used to compute the lower-right corner (x1, y1) coordinates of the rectangle. -
self.col_coordsis an instance variable likely containing column coordinates in the document page.list(self.col_coords.values())takes the coordinates, and they are sorted to be in order from left to right. -
self.TextToPageis another instance variable that seems to hold a control where the user can enter the page number they're interested in.getintmight be a custom function defined elsewhere that extracts an integer value from this control.pgis then the zero-based index of the page in the document. -
self.parsed_tableis assigned the result ofParseTabwhich seems to be a function (possibly defined elsewhere in the code) that parses a table from a document pageself.doc[pg], located within the coordinates[x0, y0, x1, y1]. Thecolumns=colsargument specifies the column coordinates for parsing the table. -
The
if self.parsed_table:conditional checks whether the table was successfully parsed. If it is, it:- Counts the rows and columns of the parsed table.
- Prints the dimensions of the parsed table and the coordinates of its upper-left corner on the specified page.
- Iterates through each line of the parsed table and prints it.
-
If parsing the table yields no result (
elsecondition), it prints"No text found in rectangle".
This method does not return any value; instead, it operates by side effects (such as printing information to the console and loading data into
self.parsed_table).Please note some additional points:
- The implementation details of
ParseTabfunction are not provided; it's assumed to be responsible for the actual text extraction based on the coordinates and columns provided. - The event parameter
evtis never used in the function body. It may be a placeholder for handling an event in a GUI application. self.doc[pg]suggests that the document is being accessed like a list or dictionary, with pages indexed or keyed from 0.- Without the full class definition or the rest of the codebase, we can't be sure where instance variables like
self.TextToPageandself.rect_xare being set, or where theParseTabfunction comes from. - The language and error handling in
if self.parsed_table:suggest that it expectsParseTabto returnNoneor an empty sequence when no text is found, rather than raising an exception.
-
- User
in italiano
- Assistant
La funzione
GetMatrixsembra essere un metodo che appartiene a una classe Python (dato che prendeselfcome primo argomento). Il metodo è progettato per analizzare e stampare i contenuti di una tabella situata all'interno di un'area rettangolare di una pagina di un documento.Ecco una spiegazione passo passo del metodo:
-
self.rect_x,self.rect_y,self.rect_weself.rect_hsembrano essere variabili d'istanza che definiscono le coordinate dell'angolo in alto a sinistra (x0, y0) e la larghezza (self.rect_w) e l'altezza (self.rect_h) di un rettangolo. Queste sono usate per calcolare le coordinate dell'angolo in basso a destra (x1, y1) del rettangolo. -
self.col_coordsè una variabile d'istanza che probabilmente contiene le coordinate delle colonne della pagina del documento.list(self.col_coords.values())prende queste coordinate e le ordina da sinistra a destra. -
self.TextToPageè un'altra variabile d'istanza che sembra contenere un controllo in cui l'utente può inserire il numero di pagina di interesse.getintpotrebbe essere una funzione personalizzata definita altrove che estrae un valore intero da questo controllo.pgè quindi l'indice della pagina nel documento basato su zero. -
self.parsed_tableviene assegnata al risultato della funzioneParseTabche sembra essere una funzione (probabilmente definita altrove nel codice) che analizza una tabella da una pagina del documentoself.doc[pg], situata all'interno delle coordinate[x0, y0, x1, y1]. L'argomentocolumns=colsspecifica le coordinate delle colonne per l'analisi della tabella. -
La condizione
if self.parsed_table:verifica se la tabella è stata analizzata con successo. Se è così, fa:- Contare le righe e le colonne della tabella analizzata.
- Stampare le dimensioni della tabella analizzata e le coordinate del suo angolo in alto a sinistra sulla pagina specificata.
- Iterare attraverso ogni riga della tabella analizzata e stamparla.
-
Se l'analisi della tabella non produce risultati (
else), stampa"No text found in rectangle".
Questo metodo non restituisce alcun valore; invece, opera tramite effetti collaterali (come stampare informazioni sulla console e caricare dati in
self.parsed_table).Per favore, nota alcuni punti aggiuntivi:
- I dettagli di implementazione della funzione
ParseTabnon sono forniti; si presume che sia responsabile dell'effettiva estrazione del testo in base alle coordinate e alle colonne fornite. - Il parametro dell'evento
evtnon viene mai utilizzato nel corpo della funzione. Potrebbe essere un segnaposto per gestire un evento in un'applicazione con interfaccia grafica. self.doc[pg]suggerisce che il documento viene accesso come una lista o un dizionario, con pagine indicizzate o chiavi a partire da 0.- Senza la definizione completa della classe o il resto del codice, non possiamo essere sicuri di dove le variabili d'istanza come
self.TextToPageeself.rect_xvengano impostate, o da dove provenga la funzioneParseTab. - Il linguaggio e la gestione degli errori in
if self.parsed_table:suggeriscono che ci si aspetta cheParseTabrestituiscaNoneo una sequenza vuota quando non viene trovato alcun testo, piuttosto che sollevare un'eccezione.
-
- User
in italiano
- Assistant
La funzione
GetMatrixsembra essere un metodo appartenente a una classe Python (dato che accettaselfcome primo argomento). Il metodo è progettato per analizzare e stampare i contenuti di una tabella situata all'interno di un'area rettangolare di una pagina di un documento.Ecco una spiegazione passo dopo passo del metodo:
-
self.rect_x,self.rect_y,self.rect_weself.rect_hsembrano essere variabili di istanza che definiscono il punto in alto a sinistra (x0, y0) e le dimensioni (larghezza e altezza) di un rettangolo. Questi vengono utilizzati per calcolare il punto in basso a destra (x1, y1) del rettangolo. -
self.col_coordsè una variabile di istanza che probabilmente contiene le coordinate delle colonne all'interno della pagina del documento.list(self.col_coords.values())crea una lista con queste coordinate e poi le ordina. -
self.TextToPageè un'altra variabile di istanza che sembra contenere un controllo dove l'utente può inserire il numero della pagina di interesse.getintpotrebbe essere una funzione definita in altro luogo nel codice che estrae un valore intero da questo controllo.pgdiventa quindi l'indice della pagina nel documento, partendo da zero. -
self.parsed_tableè assegnata al risultato diParseTab, che sembra essere una funzione (definita probabilmente altrove nel codice) che analizza una tabella della pagina del documentoself.doc[pg], situata all'interno delle coordinate[x0, y0, x1, y1]. L'argomentocolumns=colsspecifica le coordinate delle colonne per l'analisi. -
Il controllo
if self.parsed_table:verifica se la tabella è stata analizzata con successo. In caso affermativo, il metodo:- Calcola quante righe e colonne ci sono nella tabella analizzata.
- Stampa le dimensioni della tabella e le coordinate del suo angolo in alto a sinistra sulla pagina specificata.
- Scorre ogni riga della tabella analizzata stampandola.
-
Se l'analisi della tabella non produce risultati (branch
else), viene stampato il messaggio "Nessun testo trovato nel rettangolo".
Questo metodo non restituisce alcun valore; operando invece per effetti collaterali (quali la stampa di informazioni sul terminale e la memorizzazione dei dati in
self.parsed_table).Alcune note aggiuntive:
- I dettagli implementativi della funzione
ParseTabnon sono forniti; si presume che sia responsabile dell'effettiva estrazione del testo basata sulle coordinate e sulle colonne fornite. - Il parametro evento
evtnon viene utilizzato nel corpo della funzione. Potrebbe essere utilizzato per gestire un evento in un'applicazione con interfaccia grafica. self.doc[pg]suggerisce che il documento venga accesso come una lista o un dizionario, con pagine indicizzate o contrassegnate a partire da 0.- Senza la definizione completa della classe o il resto del codice, non si possono conoscere i dettagli di dove vengano inizializzate variabili di istanza come
self.TextToPageeself.rect_x, o l'origine della funzioneParseTab. - Il linguaggio e la gestione degli errori in
if self.parsed_table:suggeriscono che si aspetti cheParseTabrestituiscaNoneo una sequenza vuota quando non viene trovato testo, anziché sollevare un'eccezione.
-
- User
""" Browse a document with a wxPython GUI to extract tables
License: GNU GPL V3 (c) 2018 Jorj X. McKie
Usage
python wx-extract.py
Notes
Uses the ParseTab.py file which is found in the current directory.
Description
A file selection dialog is displayed to pick a document. Then, the document's first page is displayed. The controls in the dialog allow the following:
-
Browse forward and backward.
-
Jump to a specific page.
-
Paint a rectangle on a page using the "New Rect" button. The selection can be fine-tuned by using the spin controls. Moving the rectangle around with the mouse is now supported as well.
-
If pressing the "New Rect" button again or if leaving the page, the existing rectangle and columns will be removed.
-
After a rectangle has been painted, the "New Col" button allows to paint columns into it. The columns are shown as vertical lines inside the rectangle, and changes can be undone by selecting a column and then changing its coordinates. A column is deleted by entering "0" or by changing its value to something else outside of the rectangle's left/right borders.
-
After a column is painted, rectangles can be changed with the controls. Columns will not be affected by this, however, they will be deleted if leaving the rectangle area. In contrast, if a rectangle is moved with the mouse (hold down the left key) columns will be moved along with it.
-
Any time after a rectangle has been painted, its text can be parsed by pressing the "Get Table" button. The current script just prints the table to STDOUT if doing this. Columns can also be added or deleted while repeatedly pressing this button to evaluate any differences.
Dependencies
PyMuPDF v1.12.0, wxPython phoenix """
from future import print_function import fitz import wx import os from ParseTab import ParseTab
try: from PageFormat import FindFit except:
def FindFit(*args): return "not implemented"try: from icons import ico_pdf
show_icon = Trueexcept: show_icon = False
def getint(v): import types
# extract digits from a string to form an integer try: return int(v) except ValueError: pass if not isinstance(v, types.StringTypes): return 0 a = "0" for d in v: if d in "0123456789": a += d return int(a)start the wx application
app = None app = wx.App()
cursor_hand = wx.Cursor(wx.CURSOR_HAND) cursor_cross = wx.Cursor(wx.CURSOR_CROSS) cursor_vert = wx.Cursor(wx.CURSOR_SIZENS) cursor_norm = wx.Cursor(wx.CURSOR_DEFAULT) bmp_from_buffer = wx.Bitmap.FromBuffer
some abbreviations to get rid of those long pesky names ...
defPos = wx.DefaultPosition defSiz = wx.DefaultSize khaki = wx.Colour(240, 230, 140)
==============================================================================
Define our dialog as a subclass of wx.Dialog.
Only special thing is, that we are being invoked with a filename ...
==============================================================================
class PDFdisplay(wx.Dialog): def init(self, parent, filename): wx.Dialog.init( self, parent, id=wx.ID_ANY, title="Parse Tables in ", pos=defPos, size=defSiz, style=wx.CAPTION | wx.CLOSE_BOX | wx.DEFAULT_DIALOG_STYLE, )
# ====================================================================== # display an icon top left of dialog, append filename to title # ====================================================================== if show_icon: self.SetIcon(ico_pdf.img.GetIcon()) # set a screen icon self.SetBackgroundColour(khaki) self.SetTitle(self.Title + filename) self.set_rectangle = False # ====================================================================== # open the document with MuPDF when dialog gets created # ====================================================================== self.doc = fitz.Document(filename) if self.doc.needs_pass: self.decrypt_doc() if self.doc.is_encrypted: self.Destroy() return # ====================================================================== # forward button # ====================================================================== self.BtnNext = wx.Button( self, wx.ID_ANY, "Forward", defPos, defSiz, wx.BU_EXACTFIT ) # ====================================================================== # backward button # ====================================================================== self.BtnPrev = wx.Button( self, wx.ID_ANY, "Backward", defPos, defSiz, wx.BU_EXACTFIT ) # ====================================================================== # text field for entering a target page. wx.TE_PROCESS_ENTER is # required to get data entry fired as events. # ====================================================================== self.TextToPage = wx.TextCtrl( self, wx.ID_ANY, "1", defPos, wx.Size(40, -1), wx.TE_PROCESS_ENTER | wx.TE_RIGHT, ) # ====================================================================== # displays total pages # ====================================================================== self.statPageMax = wx.StaticText( self, wx.ID_ANY, "of " + str(self.doc.page_count) + " pages.", defPos, defSiz, 0, ) # ====================================================================== # displays page format # ====================================================================== self.paperform = wx.StaticText(self, wx.ID_ANY, "", defPos, defSiz, 0) # ====================================================================== # activate rectangle drawing # ====================================================================== self.BtnRect = wx.Button( self, wx.ID_ANY, "New Rect", defPos, defSiz, wx.BU_EXACTFIT ) # ====================================================================== # "Left" literal # ====================================================================== self.statLeft = wx.StaticText( self, wx.ID_ANY, "Left:", defPos, wx.Size(50, -1), 0 ) # ====================================================================== # modify rectangle left # ====================================================================== self.CtrlLeft = wx.SpinCtrl( self, wx.ID_ANY, "0", defPos, wx.Size(50, -1), wx.SP_ARROW_KEYS | wx.TE_PROCESS_ENTER, 0, 999, 0, ) # ====================================================================== # "Top" literal # ====================================================================== self.statTop = wx.StaticText( self, wx.ID_ANY, "Top:", defPos, wx.Size(50, -1), 0 ) # ====================================================================== # modify rectangle top # ====================================================================== self.CtrlTop = wx.SpinCtrl( self, wx.ID_ANY, "0", defPos, wx.Size(50, -1), wx.SP_ARROW_KEYS | wx.TE_PROCESS_ENTER, 0, 999, 0, ) # ====================================================================== # "Height" literal # ====================================================================== self.statHeight = wx.StaticText( self, wx.ID_ANY, "Height:", defPos, wx.Size(50, -1), 0 ) # ====================================================================== # modify rectangle Height # ====================================================================== self.CtrlHeight = wx.SpinCtrl( self, wx.ID_ANY, "0", defPos, wx.Size(50, -1), wx.SP_ARROW_KEYS | wx.TE_PROCESS_ENTER, 0, 999, 0, ) # ====================================================================== # "Width" literal # ====================================================================== self.statWidth = wx.StaticText( self, wx.ID_ANY, "Width:", defPos, wx.Size(50, -1), 0 ) # ====================================================================== # modify rectangle Width # ====================================================================== self.CtrlWidth = wx.SpinCtrl( self, wx.ID_ANY, "0", defPos, wx.Size(50, -1), wx.SP_ARROW_KEYS | wx.TE_PROCESS_ENTER, 0, 999, 0, ) # ====================================================================== # parse table within rectangle # ====================================================================== self.BtnMatrix = wx.Button( self, wx.ID_ANY, "Get Table", defPos, defSiz, wx.BU_EXACTFIT ) # ====================================================================== # column controls # ====================================================================== self.BtnNewCol = wx.Button( self, wx.ID_ANY, "New Col", defPos, defSiz, wx.BU_EXACTFIT ) self.col_coords = {} self.ColList = wx.Choice(self, wx.ID_ANY, defPos, wx.Size(50, -1)) self.CtrlCols = wx.SpinCtrl( self, wx.ID_ANY, "0", defPos, wx.Size(50, -1), wx.SP_ARROW_KEYS | wx.TE_PROCESS_ENTER, 0, 999, 0, ) # ====================================================================== # image of document page # ====================================================================== self.bitmap = self.pdf_show(1) self.PDFimage = wx.StaticBitmap( self, wx.ID_ANY, self.bitmap, defPos, self.bitmap.Size, wx.NO_BORDER ) # ====================================================================== # horizonzal lines # ====================================================================== l1 = wx.StaticLine(self, wx.ID_ANY, defPos, defSiz, wx.LI_HORIZONTAL) l2 = wx.StaticLine(self, wx.ID_ANY, defPos, defSiz, wx.LI_HORIZONTAL) l3 = wx.StaticLine(self, wx.ID_ANY, defPos, defSiz, wx.LI_HORIZONTAL) """ ======================================================================= Overall Dialog Structure: ------------------------- szr10 (main sizer for the whole dialog - vertical orientation) +-> szr20 (sizer for buttons etc. - horizontal orientation) +-> button forward +-> button backward +-> field for page number to jump to +-> field displaying total pages +-> fields for controlling the rectangle +-> szr30 (sizer for columns) +-> button "New Column" +-> fields for controlling a column +-> button to extract selected table +-> PDF image area ======================================================================= """ # ====================================================================== # sizers # ====================================================================== szr10 = wx.BoxSizer(wx.VERTICAL) # main sizer szr20 = wx.BoxSizer(wx.HORIZONTAL) # paging controls szr30 = wx.BoxSizer(wx.HORIZONTAL) # rect & col controls & image szr40 = wx.BoxSizer(wx.VERTICAL) # rect & col controls # szr20: navigation controls szr20.Add(self.BtnNext, 0, wx.ALL, 5) szr20.Add(self.BtnPrev, 0, wx.ALL, 5) szr20.Add(self.TextToPage, 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5) szr20.Add(self.statPageMax, 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5) szr20.Add(self.paperform, 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5) szr20.Fit(self) # szr40: rectangle & column controls szr40.Add(self.BtnRect, 0, wx.ALL, 5) szr40.Add(self.statLeft, 0, wx.ALL, 5) szr40.Add(self.CtrlLeft, 0, wx.ALL, 5) szr40.Add(self.statTop, 0, wx.ALL, 5) szr40.Add(self.CtrlTop, 0, wx.ALL, 5) szr40.Add(self.statHeight, 0, wx.ALL, 5) szr40.Add(self.CtrlHeight, 0, wx.ALL, 5) szr40.Add(self.statWidth, 0, wx.ALL, 5) szr40.Add(self.CtrlWidth, 0, wx.ALL, 5) szr40.Add(l2, 0, wx.EXPAND | wx.ALL, 5) szr40.Add(self.BtnNewCol, 0, wx.ALL, 5) szr40.Add(self.ColList, 0, wx.ALL, 5) szr40.Add(self.CtrlCols, 0, wx.ALL, 5) szr40.Add(l3, 0, wx.EXPAND | wx.ALL, 5) szr40.Add(self.BtnMatrix, 0, wx.ALL, 5) szr40.Fit(self) # szr30: document image szr30.Add(szr40, 0, wx.EXPAND, 5) szr30.Add(self.PDFimage, 0, wx.ALL, 5) szr30.Fit(self) # szr10: main sizer szr10.Add(szr20, 0, wx.EXPAND, 5) szr10.Add(l1, 0, wx.EXPAND | wx.ALL, 5) szr10.Add(szr30, 0, wx.EXPAND, 5) szr10.Fit(self) self.SetSizer(szr10) self.Layout() self.Centre(wx.BOTH) # ====================================================================== # Bind event handlers # ====================================================================== self.BtnNewCol.Bind(wx.EVT_BUTTON, self.AddCol) self.BtnNext.Bind(wx.EVT_BUTTON, self.NextPage) self.BtnPrev.Bind(wx.EVT_BUTTON, self.PreviousPage) self.TextToPage.Bind(wx.EVT_TEXT_ENTER, self.GotoPage) self.BtnRect.Bind(wx.EVT_BUTTON, self.ActivateRect) self.BtnMatrix.Bind(wx.EVT_BUTTON, self.GetMatrix) self.CtrlTop.Bind(wx.EVT_SPINCTRL, self.resize_rect) self.CtrlHeight.Bind(wx.EVT_SPINCTRL, self.resize_rect) self.CtrlLeft.Bind(wx.EVT_SPINCTRL, self.resize_rect) self.CtrlWidth.Bind(wx.EVT_SPINCTRL, self.resize_rect) self.CtrlCols.Bind(wx.EVT_SPINCTRL, self.UpdateCol) self.ColList.Bind(wx.EVT_CHOICE, self.OnColSelect) self.PDFimage.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown) self.PDFimage.Bind(wx.EVT_LEFT_UP, self.OnLeftUp) self.PDFimage.Bind(wx.EVT_MOTION, self.move_mouse) self.PDFimage.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel) self.disable_fields() def __del__(self): pass # ============================================================================== # Event handlers and other subroutines # ============================================================================== def cursor_in_rect(self, pos): # check whether cursor is in rectangle if self.rect_h <= 0 or self.rect_w <= 0: # does a rect exist? return False if any( ( pos.x < self.rect_x, pos.x > self.rect_x + self.rect_w, pos.y < self.rect_y, pos.y > self.rect_y + self.rect_h, ) ): return False return True def rect_in_img(self, x, y, w, h): # check whether rectangle is inside page image width = self.PDFimage.Size[0] height = self.PDFimage.Size[1] if not (x >= 0 and y >= 0 and x + w <= width and y + h <= height): return False return True def disable_fields(self): # reset controls & buttons (e.g. b/o page scrolling) self.CtrlHeight.Disable() self.CtrlTop.Disable() self.CtrlLeft.Disable() self.CtrlWidth.Disable() self.ColList.Disable() self.CtrlCols.Disable() self.BtnMatrix.Disable() self.BtnNewCol.Disable() self.CtrlCols.Value = 0 self.CtrlTop.Value = 0 self.CtrlLeft.Value = 0 self.CtrlHeight.Value = 0 self.CtrlWidth.Value = 0 self.set_rectangle = False self.col_selected = None self.adding_column = False self.dragging_rect = False self.col_coords = {} self.rect_x = 0 self.rect_y = 0 self.rect_w = 0 self.rect_h = 0 self.ColList.Clear() self.PDFimage.SetCursor(cursor_norm) return def enable_fields(self): # enable fields (after rectangle was made) self.BtnMatrix.Enable() self.CtrlHeight.Enable() self.CtrlTop.Enable() self.CtrlLeft.Enable() self.CtrlWidth.Enable() return def upd_collist(self): # update list of columns self.ColList.Clear() # clear drop down list self.CtrlCols.Disable() # disable spin control vlist = self.col_coords.values() if not vlist: # no columns left? self.ColList.Disable() return self.ColList.Enable() # else recreate column dict self.col_coords = {} vlist.sort() i = 1 for v in vlist: if v > self.rect_x and v < self.rect_x + self.rect_w: cname = "Col" + str(i) self.col_coords[cname] = v self.ColList.Append(cname) i += 1 def resize_rect(self, evt): # change rectangle shape via spin controls if self.CtrlWidth.Value < 5: self.CtrlWidth.Value = 5 if self.CtrlHeight.Value < 5: self.CtrlHeight.Value = 5 x = self.CtrlLeft.Value y = self.CtrlTop.Value w = self.CtrlWidth.Value h = self.CtrlHeight.Value # move no rectangle part outside page image if not self.rect_in_img(x, y, w, h): self.CtrlLeft.Value = self.rect_x # reset invalid coordinates self.CtrlTop.Value = self.rect_y # ... self.CtrlWidth.Value = self.rect_w # ... self.CtrlHeight.Value = self.rect_h # ... return self.rect_x = x self.rect_y = y self.rect_h = h self.rect_w = w self.DrawRect(x, y, w, h) # redraw rectangle self.ColList.Clear() # re-adjust column controls self.ColList.Disable() self.CtrlCols.Disable() self.CtrlCols.Value = 0 self.col_selected = None self.upd_collist() for k in self.col_coords: # also redraw all columns self.DrawColumn(self.col_coords[k], "RED") def move_rect(self, x, y, w, h): # move rectangle around with mouse if not self.rect_in_img(x, y, w, h): return # no rect part outside image dx = x - self.rect_x # remember horizontal movement delta self.rect_x = x self.rect_y = y self.CtrlLeft.Value = x self.CtrlTop.Value = y self.DrawRect(x, y, w, h) # redraw rectangle self.CtrlCols.Value = 0 # set column info to self.ColList.Selection = -1 # none selected self.col_selected = None for k in self.col_coords: # also redraw all columns after self.col_coords[k] += dx # repositioning them self.DrawColumn(self.col_coords[k], "RED") def OnMouseWheel(self, evt): # process wheel as paging operations d = evt.GetWheelRotation() # int indicating direction if d < 0: self.NextPage(evt) elif d > 0: self.PreviousPage(evt) return def OnColSelect(self, evt): # a column from the drop down box was selected self.adding_column = False col = evt.GetString() # selected item self.CtrlCols.Value = self.col_coords[col] # get its coord self.CtrlCols.Enable() # enable spin control self.col_selected = col # store selected string for k in self.col_coords: if k == col: self.DrawColumn(self.col_coords[k], "BLUE") else: self.DrawColumn(self.col_coords[k], "RED") def AddCol(self, evt): # insert new column into rectangle # change cursor to up-down image self.adding_column = True # store state: adding column self.set_rectangle = False self.ColList.Enable() # enable drop-down list self.CtrlCols.Disable() # disable spin control self.col_selected = None # state change: no column selected return def OnLeftDown(self, evt): # left mouse button pressed down pos = evt.GetPosition() if self.set_rectangle: # about to make rectangle, self.rect_x = pos.x self.rect_y = pos.y return elif self.adding_column: # about to make a column # horizontal coord must be within rectangle if not self.cursor_in_rect(pos): return # store new column info n = self.ColList.Count + 1 col_name = "Col" + str(n) self.col_coords[col_name] = pos.x self.ColList.Append("Col" + str(n)) self.CtrlCols.Value = pos.x self.adding_column = False # reset state: not adding column self.DrawColumn(pos.x, "RED") # draw the column return # potentially a rectangle drag request if self.cursor_in_rect(pos): self.dragging_rect = True self.dragstart_x = pos.x - self.rect_x # delta cursor to left self.dragstart_y = pos.y - self.rect_y # delta cursor to top return def OnLeftUp(self, evt): self.dragging_rect = False # reset dragging information self.dragstart_x = 0 self.dragstart_y = 0 if not self.set_rectangle: # out if not making a rectangle return self.PDFimage.SetCursor(cursor_norm) # cursor default again pos = evt.GetPosition() self.rect_w = abs(pos.x - self.rect_x) # get width self.rect_h = abs(pos.y - self.rect_y) # get height if self.rect_x > pos.x: self.rect_x = pos.x # recover from not painting ... if self.rect_y > pos.y: # from top-left self.rect_y = pos.y # to bottom-right self.enable_fields() # enable fields self.set_rectangle = False # reset state: no more making rect self.BtnNewCol.Enable() # making columns now possible return def move_mouse(self, evt): # handle mouse movements pos = evt.GetPosition() if not (self.adding_column or self.set_rectangle): if self.cursor_in_rect(pos): # only adjust cursor self.PDFimage.SetCursor(cursor_hand) else: self.PDFimage.SetCursor(cursor_norm) if self.adding_column: if self.cursor_in_rect(pos): self.PDFimage.SetCursor(cursor_vert) else: self.PDFimage.SetCursor(cursor_norm) return if self.set_rectangle and evt.LeftIsDown(): # if making a rectangle w = abs(pos.x - self.rect_x) h = abs(pos.y - self.rect_y) x = self.rect_x # adjust coordinates ... if pos.x < x: # if not ... x = pos.x # moving from ... y = self.rect_y # top-left to ... if pos.y < y: # bottom-right ... y = pos.y # direction self.rect_w = w self.rect_h = h self.CtrlHeight.Value = h # update ... self.CtrlWidth.Value = w # ... spin ... self.CtrlLeft.Value = x # ... controls self.CtrlTop.Value = y self.DrawRect(x, y, w, h) # draw rectangle return if not evt.LeftIsDown(): self.dragging_rect = False self.dragstart_x = 0 self.dragstart_y = 0 return if self.dragging_rect and evt.LeftIsDown(): new_x = pos.x - self.dragstart_x new_y = pos.y - self.dragstart_y self.move_rect(new_x, new_y, self.rect_w, self.rect_h) return return def UpdateCol(self, evt): # handle changes to spin control self.adding_column = False if not self.col_selected: # only if a column is selected return v = self.CtrlCols.Value # position of column x = self.rect_x # rectangle coord's y = self.rect_y w = self.rect_w h = self.rect_h self.col_coords[self.col_selected] = v # store col coord in dict if v <= x or v >= x + w: # if col coord outside rectangle self.resize_rect(evt) # delete the column self.ColList.SetFocus() # focus to next col selection return # and return self.DrawRect(x, y, w, h) # else redraw everything we have for k in self.col_coords: # redraw all columns if k == self.col_selected: c = "BLUE" else: c = "RED" self.DrawColumn(self.col_coords[k], c) def DrawColumn(self, x, c): # draw a vertical line dc = wx.ClientDC(self.PDFimage) # make a device control out of img dc.SetPen(wx.Pen(c)) # only draw inside the rectangle dc.DrawLine(x, self.rect_y, x, self.rect_y + self.rect_h) self.adding_column = False def DrawRect(self, x, y, w, h): # Draw a rectangle (red border, transparent interior) dc = wx.ClientDC(self.PDFimage) # make a device control out of img dc.SetPen(wx.Pen("RED")) dc.SetBrush(wx.Brush("RED", style=wx.BRUSHSTYLE_TRANSPARENT)) self.redraw_bitmap() dc.DrawRectangle(x, y, w, h) def GetMatrix(self, evt): # parse table contained in rectangle # currently, the table is just stored away as a matrix: # add functionality as desired x0 = self.rect_x y0 = self.rect_y x1 = x0 + self.rect_w y1 = y0 + self.rect_h cols = list(self.col_coords.values()) cols.sort() pg = getint(self.TextToPage.Value) - 1 self.parsed_table = ParseTab(self.doc[pg], [x0, y0, x1, y1], columns=cols) if self.parsed_table: r = len(self.parsed_table) c = len(self.parsed_table[0]) t = "\nContents of (%s x %s)-table at [%s,%s] on page %s" print(t % (r, c, x0, y0, pg + 1)) for l in self.parsed_table: print(l) else: print("No text found in rectangle") def redraw_bitmap(self): w = self.bitmap.Size[0] h = self.bitmap.Size[1] x = y = 0 rect = wx.Rect(x, y, w, h) bm = self.bitmap.GetSubBitmap(rect) dc = wx.ClientDC(self.PDFimage) # make a device control out of img dc.DrawBitmap(bm, x, y) # refresh bitmap before draw return def ActivateRect(self, evt): # Start drawing a rectangle self.disable_fields() self.set_rectangle = True self.PDFimage.SetCursor(cursor_cross) def NextPage(self, event): # means: page forward page = getint(self.TextToPage.Value) + 1 # current page + 1 if page > self.doc.page_count: return page = min(page, self.doc.page_count) # cannot go beyond last page self.TextToPage.Value = str(page) # put target page# in screen self.bitmap = self.pdf_show(page) # get page image self.NeuesImage(page) # refresh the layout event.Skip() def PreviousPage(self, event): # means: page back page = getint(self.TextToPage.Value) - 1 # current page - 1 if page < 1: return page = max(page, 1) # cannot go before page 1 self.TextToPage.Value = str(page) # put target page# in screen self.NeuesImage(page) event.Skip() def GotoPage(self, event): # means: go to page number page = getint(self.TextToPage.Value) # get screen page number page = min(page, self.doc.page_count) # cannot go beyond last page page = max(page, 1) # cannot go before page 1 self.TextToPage.Value = str(page) # make sure it's on the screen self.NeuesImage(page) event.Skip() # ============================================================================== # Read / render a PDF page. Parameters are: pdf = document, page = page# # ============================================================================== def NeuesImage(self, page): self.disable_fields() self.bitmap = self.pdf_show(page) # read page image self.PDFimage.SetSize(self.bitmap.Size) # adjust screen to image size self.PDFimage.SetBitmap(self.bitmap) # put it in screen return def pdf_show(self, pg_nr): # get Pixmap of a page p = self.doc[pg_nr - 1] pix = p.get_pixmap(alpha=0) bitmap = bmp_from_buffer(pix.width, pix.height, pix.samples) self.paperform.Label = "Format: " + FindFit(pix.w, pix.h) return bitmap def decrypt_doc(self): # let user enter document password pw = None dlg = wx.TextEntryDialog( self, "Please enter password below:", "Document needs password to open", "", style=wx.TextEntryDialogStyle | wx.TE_PASSWORD, ) while pw is None: rc = dlg.ShowModal() if rc == wx.ID_OK: pw = str(dlg.GetValue().encode("utf-8")) self.doc.authenticate(pw) else: return if self.doc.is_encrypted: pw = None dlg.SetTitle("Wrong password, enter correct one or cancel") return==============================================================================
main program
==============================================================================
==============================================================================
Show a FileSelect dialog to choose a file
==============================================================================
Wildcard: offer all supported filetypes
wild = "supported files|.pdf;.xps;.oxps;.epub;*.cbz"
==============================================================================
define the file selection dialog
==============================================================================
dlg = wx.FileDialog( None, message="Choose a document", defaultDir=os.getcwd(), defaultFile="", wildcard=wild, style=wx.FD_OPEN | wx.FD_CHANGE_DIR, )
==============================================================================
gimmick: provide an icon
==============================================================================
if show_icon: dlg.SetIcon(ico_pdf.img.GetIcon()) # set a screen icon
==============================================================================
now display and ask for return code in one go
==============================================================================
We got a file only when one was selected and OK pressed
if dlg.ShowModal() == wx.ID_OK: # This returns a Python list of selected files (we only have one though) filename = dlg.GetPaths()[0] else: filename = None
destroy this dialog
dlg.Destroy()
==============================================================================
only continue if we have a filename
==============================================================================
if filename: # create the dialog dlg = PDFdisplay(None, filename) # show it - this will only return for final housekeeping rc = dlg.ShowModal() app = None
-
- Assistant
Il codice Python fornito sembra essere uno script per una GUI (Interfaccia Grafica Utente) realizzata con wxPython, che consente di navigare in un documento e estrarre tabelle utilizzando la libreria PyMuPDF. Di seguito, una breve descrizione in italiano del funzionamento e uso dello script:
Descrizione:
Lo script permette di selezionare un documento attraverso una finestra di dialogo. Successivamente, viene visualizzata la prima pagina del documento. I controlli presenti nella finestra di dialogo consentono di:
- Navigare avanti e indietro tra le pagine del documento.
- Saltare direttamente a una pagina specifica.
- Disegnare un rettangolo sulla pagina (utilizzando il pulsante "New Rect") che potrà essere usato per definire l'area contenente la tabella da estrarre. È possibile affinare la selezione usando i controlli a spin e spostare il rettangolo con il mouse.
- Dopo aver disegnato un rettangolo, il pulsante "New Col" permette di creare colonne all'interno del rettangolo. Le colonne sono visualizzate come linee verticali e possono essere modificate o cancellate.
- In qualsiasi momento, dopo aver disegnato un rettangolo, è possibile analizzare il testo contenuto premendo il pulsante "Get Table". Attualmente, lo script si limita a stampare la tabella nel terminale (STDOUT).
Dipendenze:
Lo script richiede l'installazione di PyMuPDF (versione 1.12.0) e wxPython phoenix.
Uso:
Il programma si avvia eseguendo
python wx-extract.pyda terminale.Il codice include diverse parti importanti:
-
Importazione delle librerie necessarie come
fitz(parte di PyMuPDF),wx,ose altri moduli ausiliari comeParseTab. -
Definizione di alcune funzioni di utilità come
getint(), che estrapola valori interi da stringhe. -
Inizializzazione dell'applicazione wx con l'oggetto
app. -
Definizione di costanti e cursori per l'interfaccia utente.
-
Creazione della classe
PDFdisplay, che è una sottoclasse diwx.Dialoge rappresenta il dialogo principale. All'interno della classe vengono definiti i metodi per gestire eventi come il click sui pulsanti, movimenti del mouse e altre azioni dell'utente. -
La dialog class contiene il metodo
GetMatrix()che è responsabile dell'estrazione della tabella dal rettangolo selezionato. Il metodo usa il valore corrente della pagina, le coordinate del rettangolo e le coordinate delle colonne per invocare la funzioneParseTab, che estrae la tabella e stampa il risultato nel terminale. -
Un blocco di codice principale (
if filename:) che crea e mostra il dialogo all'utente dopo aver selezionato un file.
Il codice è inteso per essere uno script a sé stante, che utilizza una GUI per navigare in un documento PDF e interagire con l'utente per l'estrazione delle tabelle.
- User
possiamo aggiungere qualcosa che mostra le effettiver coordinate delle tabelle?
- Assistant
Certo, possiamo modificare la funzione
GetMatrixper mostrare le coordinate effettive delle tabelle individuate durante l'estrazione dei dati. Le coordinate sono già calcolate all'interno della funzione basandosi sul rettangolo selezionato e ulteriormente raffinate in base alle colonne specificate dall’utente.Per mostrare le coordinate nel momento in cui si ottiene la tabella, possiamo aggiungere delle stampe direttamente dopo la chiamata a
ParseTabche hanno lo scopo di visualizzare le coordinate dei lati del rettangolo e della posizione delle colonne.Ecco come potrebbe essere modificato il corrispondente segmento di codice nella funzione
GetMatrix:def GetMatrix(self, evt): # ... x0 = self.rect_x y0 = self.rect_y x1 = x0 + self.rect_w y1 = y0 + self.rect_h cols = list(self.col_coords.values()) cols.sort() pg = getint(self.TextToPage.Value) - 1 self.parsed_table = ParseTab(self.doc[pg], [x0, y0, x1, y1], columns=cols) # Aggiunta di stampa delle coordinate del rettangolo e delle colonne print(f"Coordinate del rettangolo selezionato: ({x0}, {y0}), ({x1}, {y1})") print("Coordinate delle colonne:", cols) if self.parsed_table: # ... else: # ...In questo segmento di codice, ho aggiunto due righe di stampa (
print). La prima mostra le coordinate del rettangolo (x0,y0,x1,y1), ovvero le coordinate dell'angolo in alto a sinistra e dell'angolo in basso a destra del rettangolo selezionato. La seconda riga stampa la lista ordinata delle colonne, che rappresenta le posizioni orizzontali delle linee verticali definite dall'utente all'interno del rettangolo.Ricorda di inserire queste modifiche nel contesto corretto di
PDFdisplay, perché lo script dipende dalla definizione di tutti i membri dell'istanzaself(comeself.rect_x,self.rect_y, ecc.) che sono definiti altrove nel codice della classe. - User
risultato Coordinate del rettangolo selezionato: (27, 347), (498, 393) Coordinate delle colonne: [59, 95, 226, 277, 331, 412] come trasformarlo x0,y0,x1,y1
- Assistant
Le coordinate del rettangolo selezionato vengono già visualizzate nel formato (x0, y0), (x1, y1) come si vede dall'esempio del risultato che hai fornito, dove:
(x0, y0)rappresenta l'angolo in alto a sinistra del rettangolo(x1, y1)rappresenta l'angolo in basso a destra del rettangolo
Se desideri trasformare e visualizzare le coordinate delle colonne nel formato che si adatti al contesto del rettangolo utilizzando come riferimento gli angoli in alto a sinistra (x0, y0) e in basso a destra (x1, y1) per ogni colonna, dovresti considerare ogni colonna come un rettangolino all'interno del rettangolo principale.
Tenendo conto che le colonne sono rappresentate da linee verticali, e quindi assumiamo che abbiano un'estensione verticale uguale a quella del rettangolo, possiamo trasformare la lista delle coordinate delle colonne in una lista di rettangoli con coordinate (x0, y0, x1, y1) per ciascuna colonna:
ret_y0 = y0 # L'angolo superiore di ogni colonna è uguale a y0 del rettangolo ret_y1 = y1 # L'angolo inferiore di ogni colonna è uguale a y1 del rettangolo # Calcoli le coppie di coordinate x per ogni colonna ret_x_coordinates = [(cols[i], cols[i + 1]) for i in range(len(cols) - 1)] # Usa (x0, y0, x1, y1) per rappresentare i rettangoli per ciascuna colonna rectangles = [(x0, ret_y0, x1, ret_y1) for x0, x1 in ret_x_coordinates] # Stampare i rettangoli delle colonne for i, rect in enumerate(rectangles, start=1): print(f"Colonna {i}: {rect}")Nell'esempio sopra abbiamo:
ret_y0eret_y1rappresentano i lati superiori e inferiori di ogni "colonna rettangolare", che sono uguali per tutte le colonne poiché corrispondono al rettangolo principale.ret_x_coordinatesè una lista di tuple, dove ogni tupla contiene le coordinate x dell'angolo a sinistra (inizio) e a destra (fine) di ciascuna colonna.- Infine
rectanglesè una lista di tuple(x0, y0, x1, y1)dove ogni tupla rappresenta un "rettangolo colonna" all'interno del rettangolo principale.
Questa rappresentazione
rectanglesfornisce una descrizione esplicita delle posizioni delle colonne all'interno del rettangolo principale utilizzando le coordinate dei lati sia orizzontali sia verticali, ed è utile se stai cercando di definire aree precise per ciascuna colonna all'interno del rettangolo principale. - User
e come utilizzarli per fare l'estrazione della tabella
- Assistant
Le coordinate dei rettangoli per ogni colonna che hai generato possono essere utilizzate per estrarre i dati presenti in tali aree del documento, ad esempio per estrarre i dati testuali separati per ogni colonna di una tabella. Tuttavia, nella funzione
ParseTab, se è previsto usarla, dovresti verificare che tale funzione supporti una chiamata con molteplici aree di analisi simultanee, poiché spesso l'estrazione dal PDF prevede il passaggio di un solo rettangolo per la ricerca del testo.Se la funzione
ParseTabnon supporta direttamente l'estrazione dati per più colonne, ma accetta un solo rettangolo alla volta, dovresti iterare su ciascuna colonna separatamente. Questo significa estrarre i dati di una colonna alla volta, passando le coordinate della colonna come rettangolo alla funzioneParseTab. Ecco un esempio di come potrebbe essere modificato il codice:def GetMatrix(self, evt): # ... codice precedente per definire x0, y0, x1, y1 e cols ... # Coordinate del rettangolo selezionato per l'intera tabella x0 = self.rect_x y0 = self.rect_y x1 = x0 + self.rect_w y1 = y0 + self.rect_h # Calcolare le coppie di coordinate x per ogni colonna col_start = x0 col_end = x0 columns_data = [] # Ciclo attraverso le coordinate delle colonne per estrarre i dati di ogni colonna for col in cols: col_end = col col_rect = [col_start, y0, col_end, y1] # Un rettangolo per ogni colonna column_data = ParseTab(self.doc[pg], col_rect) # Estrarre dati per la colonna columns_data.append(column_data) # Aggiungere i dati della colonna alla lista col_start = col_end # Aggiorna il punto di partenza per la prossima colonna # Combinare i dati di tutte le colonne (da elaborare in base al modello specifico di ParseTab) # ... pg = getint(self.TextToPage.Value) - 1 # Numero della pagina da analizzare for i, column_data in enumerate(columns_data): # Stampa o elabora i dati come necessario print(f"Dati della colonna {i+1}:") for row in column_data: print(row) # ... resto del codice ...Assicurati che la funzione
ParseTabpossa gestire un rettangolo di input per la colonna e restituire i dati di quella colonna. SeParseTabnon è definita per supportare l'estrazione in questo modo, potrebbe essere necessario adattare questa funzione o utilizzare un'altra funzione/libreria in grado di estrarre il testo dal PDF data un'area rettangolare specifica. - User
il testo viene estratto per rigo della tabella?
- Assistant
Dal contesto del codice originale che hai fornito, sembra che l'obiettivo della funzione
ParseTabsia quello di estrarre il testo dalla tabella rilevata all'interno del rettangolo definito dall'utente, e la listaself.parsed_tableviene presumibilmente popolata con le righe di testo estratte. Tuttavia, non avendo l'implementazione della funzioneParseTab, non possiamo essere certi del suo comportamento senza vederne il codice sorgente.In generale, la maggior parte degli strumenti di estrazione di tabelle da documenti PDF lavorano estraendo il testo riga per riga all'interno delle aree specificate, mantenendo l'ordine del testo come appare nel PDF. Questo è particolarmente vero quando l'estrazione si basa sull'analisi visuale della tabella (la disposizione del testo nel layout del documento).
Se per "per rigo della tabella" si intende "per riga della tabella" e
ParseTabfunziona come molte funzionalità di estrazione del testo, allora è probabile che estragga il testo ordinandolo per righe, come segue:[ ["Cella1 Riga1", "Cella2 Riga1", "Cella3 Riga1", ...], ["Cella1 Riga2", "Cella2 Riga2", "Cella3 Riga2", ...], ... ]Ogni elemento della lista
self.parsed_tablerappresenterebbe quindi una riga della tabella, e ogni riga sarebbe a sua volta una lista di stringhe, dove ogni stringa rappresenta il contenuto di una cella nella tabella.Per esempio, dopo aver chiamato la funzione
GetMatrixe ottenuto il contenuto della tabella, il testo potrebbe essere stampato in questo modo:if self.parsed_table: print("Contenuto della tabella estratto:") for row in self.parsed_table: print(" | ".join(cell for cell in row)) # Stampa ogni cella della riga separata da " | "Per avere certezza del comportamento di
ParseTab, dovresti controllare la sua documentazione o il codice sorgente. Se il metodo di estrazione è importante per il tuo utilizzo, potrebbe essere necessario adattare la funzioneParseTabo sostituirla con un algoritmo che incontri specificamente i tuoi bisogni di estrazione per riga. - User
from operator import itemgetter from itertools import groupby import fitz
==============================================================================
Function ParseTab - parse a document table into a Python list of lists
==============================================================================
def ParseTab(page, bbox, columns=None): """Returns the parsed table of a page in a PDF / (open) XPS / EPUB document. Parameters: page: fitz.Page object bbox: containing rectangle, list of numbers [xmin, ymin, xmax, ymax] columns: optional list of column coordinates. If None, columns are generated Returns the parsed table as a list of lists of strings. The number of rows is determined automatically from parsing the specified rectangle. """ tab_rect = fitz.Rect(bbox).irect xmin, ymin, xmax, ymax = tuple(tab_rect)
if tab_rect.is_empty or tab_rect.is_infinite: print("Warning: incorrect rectangle coordinates!") return [] if type(columns) is not list or columns == []: coltab = [tab_rect.x0, tab_rect.x1] else: coltab = sorted(columns) if xmin < min(coltab): coltab.insert(0, xmin) if xmax > coltab[-1]: coltab.append(xmax) words = page.get_text("words") if words == []: print("Warning: page contains no text") return [] alltxt = [] # get words contained in table rectangle and distribute them into columns for w in words: ir = fitz.Rect(w[:4]).irect # word rectangle if ir in tab_rect: cnr = 0 # column index for i in range(1, len(coltab)): # loop over column coordinates if ir.x0 < coltab[i]: # word start left of column border cnr = i - 1 break alltxt.append([ir.x0, ir.y0, ir.x1, cnr, w[4]]) if alltxt == []: print("Warning: no text found in rectangle!") return [] alltxt.sort(key=itemgetter(1)) # sort words vertically # create the table / matrix spantab = [] # the output matrix for y, zeile in groupby(alltxt, itemgetter(1)): schema = [""] * (len(coltab) - 1) for c, words in groupby(zeile, itemgetter(3)): entry = " ".join([w[4] for w in words]) schema[c] = entry spantab.append(schema) return spantab - Assistant
Grazie per aver condiviso l'implementazione della funzione
ParseTab. Con questo, possiamo comprendere meglio come funziona l'estrazione del testo dalla tabella nel tuo documento PDF.Diamo uno sguardo al processo di
ParseTab:- Viene definito un rettangolo di delimitazione (bounding box) tramite
bboxall'interno del quale verrà eseguita l'analisi. - Vengono ottenute le coordinate del bounding box e, se necessario, viene creata una lista di coordinate di colonna (
coltab), basata sui valori passati o generando due colonne che corrispondono agli estremi del rettangolo secolumnsnon viene specificato o è vuoto. - La funzione estrae le parole dal
pageoggetto utilizzandoget_text("words"), che restituisce una lista di "parole" con le loro coordinate (bounding boxes). - Successivamente, vengono selezionate le parole all'interno del rettangolo della tabella e vengono distribuite alle colonne appropriate basandosi sulle coordinate x di inizio.
- Le parole vengono ordinate in base alla loro posizione verticale (
yordinata), quindi raggruppate per riga. - Infine, ogni riga della tabella (ottenuta dal raggruppamento) viene trasformata in una lista di stringhe, che rappresentano le celle della tabella.
Il risultato finale è una lista di liste (una lista per ogni riga della tabella), dove ciascuna lista interna contiene stringhe che rappresentano il contenuto delle celle.
Per utilizzare le coordinate di rettangolo per estrarre il testo, tuttavia, la funzione
ParseTabassume che il layout del testo all'interno della tabella segua una disposizione ordinata per riga e colonna. Quindi la variabilespantabconterrà una rappresentazione strutturata della tabella che può essere utilizzata direttamente.Ecco un esempio di come potresti usare
ParseTabper ottenere il contenuto della tabella da una pagina del documento PDF:pdf_document = fitz.open("document.pdf") # Apri il documento con PyMuPDF page_number = 0 # Numero di pagina da cui estrarre la tabella (0-based) page = pdf_document[page_number] # Accedi alla pagina specifica # Definisci il rettangolo di delimitazione della tabella e le coordinate delle colonne se note table_bbox = [27, 347, 498, 393] # Ad esempio, coordinate del rettangolo della tabella column_coords = [59, 95, 226, 277, 331, 412] # Coordinate delle colonne all'interno della tavola # Estrai la tabella usando la funzione ParseTab parsed_table = ParseTab(page, table_bbox, column_coords) # Stampa o elabora il contenuto estratto della tabella for row in parsed_table: print(row) # Ogni 'row' è una lista contenente i testi delle celle di quella riga # Non dimenticare di chiudere il documento quando hai finito pdf_document.close()Nota che dovrai passare le coordinate assolute del rettangolo sulla pagina e la lista facoltativa di coordinate delle colonne come argomenti alla funzione
ParseTabper estrarre il contenuto delle tabelle. - Viene definito un rettangolo di delimitazione (bounding box) tramite
- User
parsetab per la mia versione di python è questa: #!/usr/bin/python from operator import itemgetter from itertools import groupby import fitz """Return a Python list of lists created from the words in a fitz.Document page, depending on a rectangle and an optional list of column (horizontal) coordinates.
Limitations
(1) Works correctly for simple, non-nested tables only.
(2) Line recognition depends on coordinates of the detected words in the rectangle. These will be round to integer( = pixel) values. However, use of different fonts, scan inaccuracies, etc. may lead to artefacts line differences, which must be handled by the caller.
Dependencies
PyMuPDF v1.12.0 or later
Changes
v1.12.0: SQLite and JSON are no longer required.
License
GNU GPL 3.0
(c) 2017-2018 Jorj. X. McKie """ #==============================================================================
Function ParseTab - parse a document table into a Python list of lists
#============================================================================== def ParseTab(page, bbox, columns = None): ''' Returns the parsed table of a page in a PDF / (open) XPS / EPUB document. Parameters: page: fitz.Page object bbox: containing rectangle, list of numbers [xmin, ymin, xmax, ymax] columns: optional list of column coordinates. If None, columns are generated Returns the parsed table as a list of lists of strings. The number of rows is determined automatically from parsing the specified rectangle. ''' tab_rect = fitz.Rect(bbox).irect xmin, ymin, xmax, ymax = tuple(tab_rect)
if tab_rect.isEmpty or tab_rect.isInfinite: print("Warning: incorrect rectangle coordinates!") return [] if type(columns) is not list or columns == []: coltab = [tab_rect.x0, tab_rect.x1] else: coltab = sorted(columns) if xmin < min(coltab): coltab.insert(0, xmin) if xmax > coltab[-1]: coltab.append(xmax) words = page.getTextWords() if words == []: print("Warning: page contains no text") return [] alltxt = [] # get words contained in table rectangle and distribute them into columns for w in words: ir = fitz.Rect(w[:4]).irect # word rectangle if ir in tab_rect: cnr = 0 # column index for i in range(1, len(coltab)): # loop over column coordinates if ir.x0 < coltab[i]: # word start left of column border cnr = i - 1 break alltxt.append([ir.x0, ir.y0, ir.x1, cnr, w[4]]) if alltxt == []: print("Warning: no text found in rectangle!") return [] alltxt.sort(key = itemgetter(1)) # sort words vertically # create the table / matrix spantab = [] # the output matrix for y, zeile in groupby(alltxt, itemgetter(1)): schema = [""] * (len(coltab) - 1) for c, words in groupby(zeile, itemgetter(3)): entry = " ".join([w[4] for w in words]) schema[c] = entry spantab.append(schema) return spantab - Assistant
Grazie per aver condiviso la versione della tua funzione
ParseTab. Questa funzione elabora una pagina di un documento in un formato gestito da fitz (un modulo di PyMuPDF) e punta a estrarre il contenuto delle tabelle in base ad un rettangolo di delimitazione (bbox) e ad una lista opzionale di colonne (columns).La funzione lavora seguendo questi passaggi:
- Converte le coordinate del rettangolo di delimitazione in un'istantanea intera (
irect) per lavorare con valori pixel corrispondenti. - Controlla che il rettangolo non sia vuoto o infinito, il che indica che i dati in ingresso sono corretti.
- Estrae le parole (
words) dalla pagina all'interno del rettangolo specificato, catturando le loro coordinate. - Ordina le parole verticalmente e le raggruppa per riga, usando l'ordinata Y di inizio della parola come chiave di raggruppamento.
- Per ogni riga, raggruppa le parole per colonna in base al loro indice di colonna calcolato.
- Costruisce una lista di liste (
spantab), dove ogni sottolista rappresenta il contenuto di una riga della tabella e ogni voce è un testo che potrebbe rappresentare il contenuto di una cella di quella riga.
Per utilizzare questa funzione per estrarre una tabella da una pagina di un documento PDF, dovrai seguire questi passaggi:
- Apri il documento con PyMuPDF (
fitz.Document()). - Accedi alla pagina da cui desideri estrarre i dati (
doc.loadPage()odoc[page_number]). - Definisci il rettangolo di delimitazione e le coordinate delle colonne, se le conosci.
- Chiama
ParseTab(page, bbox, columns), che tornerà una lista di liste costituenti il contenuto della tabella. - Elabora il contenuto restituito come necessario.
Ecco un esempio d'uso:
import fitz doc = fitz.open("documento.pdf") # Apri il documento page = doc[0] # Prendi la prima pagina (indice 0) # Definisci le coordinate del rettangolo e le colonne bbox = [50, 50, 550, 200] # Sostituisci con le coordinate effettive del rettangolo columns = [100, 200, 300, 400] # Sostituisci con le coordinate effettive delle colonne # Usa ParseTab per estrarre il contenuto della tabella table_content = ParseTab(page, bbox, columns) for row in table_content: print(row) # Stampa il contenuto di ogni riga doc.close() # Chiudi il documentoSeguendo questi passaggi, otterrai il contenuto della tabella estratto dalla pagina del documento PDF. Ricorda di sostituire le coordinate del
bboxe lecolumnseffettive che desideri usare per l'estrazione. - Converte le coordinate del rettangolo di delimitazione in un'istantanea intera (
- User
Traceback (most recent call last): File "C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\Estrazione.py", line 38, in parsed_table = ParseTab(page_num, table_bbox, column_coords) File "C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\ParseTab.py", line 63, in ParseTab words = page.getTextWords() AttributeError: 'int' object has no attribute 'getTextWords'
- Assistant
L'errore che stai riscontrando indica che l'oggetto denominato
page_num, che stai passando come primo argomento alla funzioneParseTab, è un intero (int) e non un oggettofitz.Pagecome previsto dalla funzione. La funzioneParseTabsi aspetta un oggettofitz.Pageche rappresenti una singola pagina del documento su cui chiamare il metodogetTextWords()per estrarre le parole.Per correggere l'errore, devi assicurarti di passare un oggetto pagina valido alla funzione
ParseTab. Ecco come puoi ottenere correttamente una pagina dal documento e passarla alla funzione:import fitz doc = fitz.open("documento.pdf") # Apri il documento # L'indice della pagina va specificato come numero intero. Se vuoi estrarre dalla prima pagina, usa l'indice 0. page_index = 0 page = doc[page_index] # Ottieni l'oggetto 'fitz.Page' della pagina specificata # Definisci le coordinate del rettangolo e le colonne table_bbox = [50, 50, 550, 200] # Sostituisci con le coordinate effettive del rettangolo column_coords = [100, 200, 300, 400] # Sostituisci con le coordinate effettive delle colonne # Usa ParseTab per estrarre il contenuto della tabella passando 'page', non 'page_index' parsed_table = ParseTab(page, table_bbox, column_coords) # Stampa il contenuto estratto dalla tabella for row in parsed_table: print(row) doc.close() # Chiudi il documentoIn questa correzione, al posto di
page_num, viene utilizzatopage, che è ottenuto tramitedoc[page_index], dovepage_indexè l'indice della pagina che vuoi analizzare (per esempio, 0 per la prima pagina). Assicurati che la variabilitable_bboxecolumn_coordssiano impostate sulle coordinate corrette all'interno della pagina che stai analizzando. - User
io cerco la pagina da una ricerca di parola il codice è questo, me lo sistemi per evitare l'errore?:
import fitz # PyMuPDF import pyodbc from ParseTab import ParseTab
Percorso del file PDF e del database MS Access
pdf_file_path = r'C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\02625870817_2024_2793_F24_14989_ALL.PDF' access_db_path = 'percorso/del/tuo/database.accdb'
word_to_search = 'MODELLO DI PAGAMENTO'
Funzione per cercare una parola nel PDF e ritornare la pagina
def search_word_in_pdf(pdf_path, word): with fitz.open(pdf_path) as pdf: for page_num in range(len(pdf)): page = pdf[page_num] if page.search_for(word): return page_num # Ritorna il numero della pagina in cui è stata trovata la parola return None # Se la parola non è stata trovata in nessuna pagina
Funzione per estrarre testo da una specifica area (tabella) di una pagina
def extract_table_text_from_page(pdf_path, page_num, table_coords): with fitz.open(pdf_path) as pdf: page = pdf[page_num] rect = fitz.Rect(table_coords) # Costruisce il rettangolo con le coordinate della tabella text = page.get_text("text", clip=rect) return text.strip()
Cerca la parola nel PDF e ottieni il numero della pagina
page_num = search_word_in_pdf(pdf_file_path, word_to_search)
if page_num is not None: # Definisci il rettangolo di delimitazione della tabella e le coordinate delle colonne se note table_bbox = [27, 347, 498, 393] # Ad esempio, coordinate del rettangolo della tabella column_coords = [59, 95, 226, 277, 331, 412] # Coordinate delle colonne all’interno della tavola # Estrai la tabella usando la funzione ParseTab parsed_table = ParseTab(page_num, table_bbox, column_coords) # Stampa o elabora il contenuto estratto della tabella for row in parsed_table: print(row) # Ogni ‘row’ è una lista contenente i testi delle celle di quella riga
- Assistant
Il problema nel tuo script è che stai passando il numero della pagina (
page_num) alla funzioneParseTab, mentre la funzione si aspetta un oggettofitz.Page.Per correggere lo script in modo da evitare l'errore, devi ottenere l'oggetto della pagina corretta e passarlo alla
ParseTabcome segue:import fitz # PyMuPDF from ParseTab import ParseTab pdf_file_path = r'C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\02625870817_2024_2793_F24_14989_ALL.PDF' word_to_search = 'MODELLO DI PAGAMENTO' # Funzione per cercare una parola nel PDF e ritornare la pagina def search_word_in_pdf(pdf_path, word): with fitz.open(pdf_path) as pdf: for page_num in range(len(pdf)): page = pdf[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 # Cerca la parola nel PDF e ottieni l'oggetto della pagina page = search_word_in_pdf(pdf_file_path, word_to_search) if page is not None: # Definisci il rettangolo di delimitazione della tabella e le coordinate delle colonne se note table_bbox = [27, 347, 498, 393] # Ad esempio, coordinate del rettangolo della tabella column_coords = [59, 95, 226, 277, 331, 412] # Coordinate delle colonne all’interno della tavola # Estrai la tabella usando la funzione ParseTab parsed_table = ParseTab(page, table_bbox, column_coords) # Stampa o elabora il contenuto estratto della tabella for row in parsed_table: print(row) # Ogni ‘row’ è una lista contenente i testi delle celle di quella riga else: print(f"La parola '{word_to_search}' non è stata trovata nel documento.")Nel codice modificato, la funzione
search_word_in_pdfora restituisce l'oggettofitz.Pagein cui è stata trovata la parola, anziché il numero della pagina. Nel blocco di codice che segue, usiamo l'oggettopagerestituito direttamente conParseTab, senza bisogno di accedere nuovamente al documento o di specificare il numero della pagina.Questo dovrebbe risolvere l'errore
AttributeError: 'int' object has no attribute 'getTextWords'che stavi riscontrando, perché ora stai passando correttamente un oggettofitz.Pagealla funzioneParseTab. - User
Traceback (most recent call last): File "C:/Users/Utente/Desktop/PyMuPDF-Utilities-master/examples/extract-table/estrazioni_1.py", line 25, in parsed_table = ParseTab(page, table_bbox, column_coords) File "C:/Users/Utente/Desktop/PyMuPDF-Utilities-master/examples/extract-table\ParseTab.py", line 63, in ParseTab words = page.getTextWords() File "C:\Users\Utente\AppData\Local\Programs\Python\Python36\lib\site-packages\fitz\utils.py", line 459, in getTextWords CheckParent(page) File "C:\Users\Utente\AppData\Local\Programs\Python\Python36\lib\site-packages\fitz\fitz.py", line 2596, in CheckParent raise ValueError("orphaned object: parent is None") ValueError: orphaned object: parent is None
- Assistant
L'errore
ValueError: orphaned object: parent is Noneche stai riscontrando è dovuto al fatto che l'oggettopagefornito alla funzioneParseTabnon ha un riferimento al documento (la "parent") dal quale è stato estratto. Questo può essere causato dalla chiusura del documento prima di utilizzare quell'oggetto, oppure per qualche altra ragione il collegamento tra l'oggetto pagina e il documento è stato perso.Per risolvere il problema, assicurati che il documento sia aperto e rimanga aperto per tutta la durata delle operazioni che coinvolgono l'oggetto pagina. Ecco una revisione del tuo codice con le modifiche necessarie:
import fitz # PyMuPDF from ParseTab import ParseTab pdf_file_path = r'C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\02625870817_2024_2793_F24_14989_ALL.PDF' word_to_search = 'MODELLO DI PAGAMENTO' # 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] 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 # Apri il documento pdf_document = fitz.open(pdf_file_path) # Cerca la parola nel PDF e ottieni l'oggetto della pagina page = search_word_in_pdf(pdf_document, word_to_search) if page is not None: # Definisci il rettangolo di delimitazione della tabella e le coordinate delle colonne se note table_bbox = [27, 347, 498, 393] # Ad esempio, coordinate del rettangolo della tabella column_coords = [59, 95, 226, 277, 331, 412] # Coordinate delle colonne all’interno della tavola # Estrai la tabella usando la funzione ParseTab parsed_table = ParseTab(page, table_bbox, column_coords) # Stampa o elabora il contenuto estratto della tabella for row in parsed_table: print(row) # Ogni ‘row’ è una lista contenente i testi delle celle di quella riga else: print(f"La parola '{word_to_search}' non è stata trovata nel documento.") # Chiudi il documento quando hai finito pdf_document.close()In questo modo, il documento viene aperto all'inizio dello script e viene chiuso solo dopo che tutte le operazioni coinvolgenti l'oggetto pagina sono state completate. Ciò previene che l'oggetto pagina perda il riferimento al documento da cui proviene.
- User
questo codice funziona, ma lo dobbiamo adeguare che importa i dati in ms access: import fitz # PyMuPDF from ParseTab import ParseTab
pdf_file_path = r'C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\02625870817_2024_2793_F24_14989_ALL.PDF' word_to_search = 'MODELLO DI PAGAMENTO'
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] 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
Apri il documento
pdf_document = fitz.open(pdf_file_path)
Cerca la parola nel PDF e ottieni l’oggetto della pagina
page = search_word_in_pdf(pdf_document, word_to_search)
if page is not None: # Definisci il rettangolo di delimitazione della tabella e le coordinate delle colonne se note table_bbox = [118, 104, 353, 121] # Ad esempio, coordinate del rettangolo della tabella column_coords = [] # Coordinate delle colonne all’interno della tavola
# Estrai la tabella usando la funzione ParseTab parsed_table = ParseTab(page, table_bbox, column_coords) # Stampa o elabora il contenuto estratto della tabella for row in parsed_table: print(row) # Ogni ‘row’ è una lista contenente i testi delle celle di quella rigaelse: print(f"La parola ‘{word_to_search}’ non è stata trovata nel documento.")
Chiudi il documento quando hai finito
pdf_document.close()
- Assistant
Per importare i dati estratti dalla tabella PDF in un database MS Access, puoi utilizzare il modulo
pyodbc. È necessario avere il driver ODBC appropriato installato sul tuo sistema per connettersi al database Access.Ecco come potresti modificare il tuo script per inserire i dati estratti nel database:
import pyodbc # Modulo per connessione ODBC a database import fitz # PyMuPDF from ParseTab import ParseTab pdf_file_path = r'C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\02625870817_2024_2793_F24_14989_ALL.PDF' access_db_path = r'percorso\del\tuo\database.accdb' word_to_search = 'MODELLO DI PAGAMENTO' # ... la tua funzione search_word_in_pdf e il codice di apertura del documento PDF # 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() # ... il resto della tua funzione di ricerca e il codice di estrazione dalla tabella if page is not None: # ... codice di definizione del rettangolo della tabella e estrazione dati ... # Assumendo che tu abbia una tabella MS Access chiamata 'TabellaPDF' con colonne appropriatamente nominati for row in parsed_table: # Componi la query di inserimento in base alla struttura della tua tabella query = "INSERT INTO TabellaPDF (Colonna1, Colonna2, ...) VALUES (?, ?, ...)" cursor.execute(query, row) conn.commit() # Conferma trasazione print("Dati importati con successo in database.") else: print(f"La parola ‘{word_to_search}’ non è stata trovata nel documento.") # Chiudi la connessione al database e il documento PDF cursor.close() conn.close() pdf_document.close()Rimpiazza
'TabellaPDF'con il nome effettivo della tua tabella Access e(Colonna1, Colonna2, ...)con i nomi delle colonne. Devi anche assicurarti che il numero di parametri nella query (?) corrispondano al numero di colonne di destinazione nella tua tabella.Nota importante: prima di eseguire il codice, assicurati che la tua tabella Access (
'TabellaPDF') sia definita con le colonne che corrispondano ai campi estratti daparsed_table. Devi anche avere un'attenzione particolare ai tipi di dati e al modo in cui vengono manipolati dati che possono non essere stringhe (come numeri, date, ecc.).Puoi trovare ulteriori informazioni sulla stringa di connessione e su come utilizzare pyodbc nella documentazione ufficiale: pyodbc Wiki
- User
ma i dati non devono essere inseriti per riga?
- Assistant
Sì, hai assolutamente ragione. I dati devono essere inseriti riga per riga nel database Access. Nel codice che ho fornito precedentemente, l'inserimento avviene proprio in questo modo: si itera su ciascuna riga estratta dalla tabella nel PDF e si esegue una query di inserimento per ognuna di queste righe.
Tuttavia, è importante che la query SQL utilizzata per l'inserimento sia allineata con la struttura della tabella nel tuo database, cioè il numero di colonne e i tipi dei dati inseriti devono corrispondere alla definizione della tua tabella in Access.
Ecco come potrebbe apparire il codice aggiustato per inserire i dati per riga:
# ... codice precedente ... if page is not None: # ... il tuo codice per l'estrazione dei dati dalla tabella ... # Per ogni riga nella tabella, esegui una query di inserimento nel database Access for row in parsed_table: # Assicurati che i nomi delle colonne nella query SQL corrispondano a quelle del tuo database # Assicurati anche che i tipi di dati siano coerenti query = "INSERT INTO TabellaPDF (Colonna1, Colonna2, ...) VALUES (?, ?, ...)" # Modifica in base alla tua tabella # Esegui la query con i valori contenuti nella riga corrente cursor.execute(query, *row) # Usa *row per espandere i valori della riga come argomenti separati conn.commit() # Conferma le transazioni (utilizzando il metodo commit() di solito dopo un ciclo di inserimento) print("Dati importati con successo nel database Access.") else: print(f"La parola ‘{word_to_search}’ non è stata trovata nel documento.") # Chiudi la connessione al database e il documento PDF cursor.close() conn.close() pdf_document.close()In questo codice,
(Colonna1, Colonna2, ...)deve essere sostituito con i nomi delle colonne della tua tabella in Access, e i punti interrogativi(?, ?, ...)rappresentano i segnaposto per i valori che verranno inseriti nel database per ogni riga. La listarowcontiene i valori per ogni "cella" di quella "riga" della tabella PDF e viene passata alla funzionecursor.execute()dopo essere stata espansa con*row, in modo che ogni elemento della lista corrisponda ad un segnaposto?nella query SQL.Ricorda di gestire gli eventuali errori che possono derivare dal tentativo di inserire dati non compatibili con il tipo di dati definiti per ciascuna colonna nella tabella Access. Ad esempio, potrebbe essere necessario effettuare conversioni di tipo o cleanup sui dati prima di eseguire l'inserimento nel database.
- User
File "C:/Users/Utente/Desktop/PyMuPDF-Utilities-master/examples/extract-table/estrazioni_1.py", line 42, in cursor.execute(query, *row) pyodbc.Error: ('HYS22', "[HYS22] [Microsoft][Driver ODBC Microsoft Access] L'istruzione INSERT INTO contiene il seguente nome di campo sconosciuto: ''Codice fiscale''. Verificare di averlo digitato correttamente, quindi riprovare. (-1507) (SQLExecDirectW)")
- Assistant
L'errore
pyodbc.Errorche stai incontrando indica che uno dei nomi dei campi utilizzati nella query SQL non corrisponde ai nomi dei campi definiti nella tua tabella MS Access. In particolare, il messaggio di errore suggerisce che il nome del campo'Codice fiscale'(con spazi inclusi) non è riconosciuto. Ciò può accadere per diversi motivi:- Il nome del campo nella tabella Access non corrisponde esattamente a quello utilizzato nella query, incluso il caso e gli spazi.
- Il campo potrebbe effettivamente non esistere nella tabella specificata nel database Access.
Per risolvere l'errore:
- Verifica il nome esatto del campo nella tua tabella Access. I nomi dei campi nelle query SQL devono corrispondere esattamente, inclusi gli spazi e il case.
- Se il nome del campo contiene spazi, è una buona prassi racchiuderlo tra parentesi quadre nella query SQL per evitare ambiguità. Ad esempio,
[Codice fiscale].
Adattiamo la query di esempio per riflettere queste considerazioni:
# Modifica questa stringa con i nomi corretti dei tuoi campi della tabella MS Access query = "INSERT INTO TabellaPDF ([Codice fiscale], [Altra Colonna], ...) VALUES (?, ?, ...)" # Resto del codice per la connessione al database e esecuzione della query # ...Assicurati di elencare tutti i campi in cui intendi inserire i dati nella tua tabella Access, e che l'ordine dei campi in questa query corrisponda all'ordine con cui fornisci i dati in
row.Ecco come potrebbe essere modificato il tuo codice:
# ... Resto del tuo codice ... if page is not None: # ... Codice per l'estrazione della tabella ... # Assicurati che ogni colonna corrisponda alla tua struttura di tabella MS Access e al tipo di dati for row in parsed_table: # Modifica la query con i nomi corretti dei campi query = "INSERT INTO TabellaPDF ([Codice fiscale], [AltraColonna1], [AltraColonna2], ...) VALUES (?, ?, ?, ...)" # Se la tua tabella ha meno/maggiori colonne, assicurati che la lunghezza di 'row' coincida con i segnaposto '?' # Aggiungi o rimuovi '?' in base alle tue esigenze cursor.execute(query, *row) conn.commit() print("Dati importati con successo nel database Access.") else: print(f"La parola ‘{word_to_search}’ non è stata trovata nel documento.") cursor.close() conn.close() pdf_document.close()In questo codice di esempio,
[AltraColonna1],[AltraColonna2],...sono da cambiare con i nomi reali delle colonne nella tua tabella di database Access.Ricorda che se i dati estratti dalla tabella PDF non corrispondono direttamente alla struttura della tabella nel tuo database (ad esempio, se ci sono più colonne nel PDF di quante ne sono necessarie nel database o se devi trasformare i dati), dovrai aggiungere la logica necessaria per mappare i dati correttamente o per eseguire la trasformazione dei dati prima di eseguire l'inserimento.
- User
ccome fare a mettere questo risultato: Contents of (1 x 4)-table at [69,8] on page 1 ['CF Int:CCRNNN87D01F061C', 'Invio:09/02/2024', 'Prot:24020919101213118/000001', 'Esito pag.: Addebitato'] nella tabella Testata nei campi solo il numero di protocollo 24020919101213118 nel campo Tele - Protocollo fornitura, il progressivo 000001 nel campo Tele - Progressivo, Addebito nel campo Tele - Progressivo, 24020919101213118-000001, nel campo codice_f24, ed un unixdata nel campo ID_doc
- Assistant
Dalla tua descrizione, sembra che tu desideri inserire selettivamente alcuni dati estratti dalla tua tabella PDF in specifici campi del database Access. Per farlo, dovrai prima estrarre e trasformare i dati interessati dalle stringhe estratte e poi formare la query SQL per inserirli nei campi giusti della tabella Access.
Ecco come potresti procedere per analizzare la riga estratta dalla tabella e inserire i dati nel database in base alle tue specifiche:
import time import re import pyodbc # Modulo per connessione ODBC a database # ... restante del tuo codice ... # Apriamo il documento PDF e cerchiamo la pagina con la parola chiave pdf_document = fitz.open(pdf_file_path) page = search_word_in_pdf(pdf_document, word_to_search) if page is not None: parsed_table = ParseTab(page, table_bbox, column_coords) print(f'Contenuto della tabella su pagina {page.number + 1}: {parsed_table}') # Dato che sappiamo esattamente cosa aspettarci dalla tabella, possiamo manipolare i dati estratti # Assumiamo riga[2] sia 'Prot:24020919101213118/000001' e riga[3] sia 'Esito pag.: Addebitato' protocollo, progressivo = re.findall(r'(\d+)/(\d+)', parsed_table[0][2])[0] # Estrazione con espressione regolare esito_pag = parsed_table[0][3].split(': ')[1] codice_f24 = protocollo + '-' + progressivo # Generiamo un unix timestamp che rappresenta l'ID_doc # Dato che il timestamp è basato sul tempo attuale, ogni esecuzione darà un ID unico unix_timestamp = int(time.time()) # 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() # Inserisci i dati nel database query = """INSERT INTO Testata (Tele_Protocollo_fornitura, Tele_Progressivo, Codice_f24, ID_doc, Esito) VALUES (?, ?, ?, ?, ?)""" cursor.execute(query, protocollo, progressivo, codice_f24, unix_timestamp, esito_pag) conn.commit() print("I dati sono stati importati con successo nel database Access.") cursor.close() conn.close() else: print(f"La parola ‘{word_to_search}’ non è stata trovata nel documento.") pdf_document.close()Nota: Ho usato una libreria standard di espressioni regolari,
re, per estrarre il numero di protocollo e il progressivo dalla stringa di testo estratta. La variabileesito_pagè stata poi popolata spaccando la stringa per': '. Un campo timestamp UNIX è stato generato con la funzionetime.time()e castato adintper l'inserimento inID_doc. Assicurati di adattare i nomi dei campi della query SQL ai campi reali della tua tabella nel database Access.Ricorda di validare ogni dato e gestire eventuali errori o casi in cui l'analisi dei dati potrebbe fallire a causa di input imprevisti o modifiche nel layout del documento PDF.
- User
Traceback (most recent call last): File "C:/Users/Utente/Desktop/PyMuPDF-Utilities-master/examples/extract-table/estrazioni_1.py", line 71, in cursor.execute(query, protocollo, progressivo, codice_f24, unix_timestamp, esito_pag) pyodbc.ProgrammingError: ('42000', "[42000] [Microsoft][Driver ODBC Microsoft Access] Errore di sintassi nell'istruzione INSERT INTO. (-3502) (SQLExecDirectW)")
- Assistant
L'errore
pyodbc.ProgrammingError: ('42000', "[42000] [Microsoft][Driver ODBC Microsoft Access] Errore di sintassi nell'istruzione INSERT INTO. (-3502) (SQLExecDirectW)")indica che c'è un errore di sintassi nella query SQL che stai cercando di eseguire. Questo errore potrebbe essere causato da vari problemi nella tua queryINSERT INTO.Per risolvere l'errore, verifica i seguenti aspetti:
- Assicurati che il nome della tabella e i nomi dei campi siano esattamente quelli presenti nel database MS Access e siano scritti correttamente. Ricorda di racchiudere tra parentesi quadre i nomi di campo che contengono spazi o caratteri speciali.
- Assicurati che l'ordine e il numero di valori
?corrispondano esattamente all'ordine e al numero di campi specificati nell'istruzioneINSERT INTO. - Verifica che i tipi di dati dei valori che stai cercando di inserire corrispondano ai tipi definiti per ciascun campo nella tua tabella Access.
Ecco un esempio di query con la sintassi corretta. Assicurati che rispecchi la struttura della tua tabella in MS Access:
# Esegui la query con i valori estratti e manipolati query = """INSERT INTO Testata (Tele_Protocollo_fornitura, Tele_Progressivo, Codice_f24, ID_doc, Esito) VALUES (?, ?, ?, ?, ?)""" try: cursor.execute(query, protocollo, progressivo, codice_f24, unix_timestamp, esito_pag) conn.commit() print("I dati sono stati importati con successo nel database Access.") except pyodbc.Error as e: print(f"Si è verificato un errore di database: {e}")Se l'errore persiste, prova a eseguire una query statica di test senza parametri per vedere se il problema riguarda la sintassi della tabella o il modo in cui stai inserendo i parametri:
# Query di test per verificare la correttezza della sintassi senza parametri test_query = "INSERT INTO Testata (NomeCampo1, NomeCampo2, ...) VALUES ('valore1', 'valore2', ...)" try: cursor.execute(test_query) conn.commit() print("Inserimento di test riuscito.") except pyodbc.Error as e: print(f"Test fallito, si è verificato un errore: {e}")Con la query di test, sostituisci
NomeCampo1,NomeCampo2, ... con i nomi reali dei campi della tua tabella e'valore1','valore2', ... con valori di esempio validi per quei campi.Dopo aver testato la query statica, dovresti essere in grado di individuare il problema nella tua query originale e apportare le modifiche necessarie.
- User
if page is not None: # Definisci il rettangolo di delimitazione della tabella e le coordinate delle colonne se note
#codice fiscale table_bbox = [118, 104, 353, 121] # Ad esempio, coordinate del rettangolo della tabella column_coords = [] # Coordinate delle colonne all’interno della tavola # Estrai la tabella usando la funzione ParseTab parsed_table = ParseTab(page, table_bbox, column_coords) # Stampa o elabora il contenuto estratto della tabella for row in parsed_table: print(row) # Ogni ‘row’ è una lista contenente i testi delle celle di quella riga codice_fiscale = row print (codice_fiscale) #identificativo f24 table_bbox = [69,8,534,26] # Ad esempio, coordinate del rettangolo della tabella column_coords = [189, 271, 418] # Coordinate delle colonne all’interno della tavola # Estrai la tabella usando la funzione ParseTab parsed_table = ParseTab(page, table_bbox, column_coords) # Stampa o elabora il contenuto estratto della tabella for row in parsed_table: print(row) # Ogni ‘row’ è una lista contenente i testi delle celle di quella riga # Dato che sappiamo esattamente cosa aspettarci dalla tabella, possiamo manipolare i dati estratti # Assumiamo riga[2] sia ‘Prot:24020919101213118/000001’ e riga[3] sia ‘Esito pag.: Addebitato’ protocollo, progressivo = re.findall(r'(\d+)/(\d+)', parsed_table[0][2])[0] # Estrazione con espressione regolare esito_pag = parsed_table[0][3].split(': ')[1] codice_f24 = protocollo + '-' + progressivo # Generiamo un unix timestamp che rappresenta l’ID_doc # Dato che il timestamp è basato sul tempo attuale, ogni esecuzione darà un ID unico unix_timestamp = int(time.time()) # Connettersi al database MS Access # Inserisci i dati nel database query = "INSERT INTO Testa ([Codice fiscale],[Tele - Protocollo fornitura], [Tele - Progressivo], codice_f24, ID_doc, [Tele - Esito fornitura]) VALUES (?,?, ?, ?, ?, ?)" cursor.execute(query, codice_fiscale, protocollo, progressivo, codice_f24, unix_timestamp, esito_pag) conn.commit() print("I dati sono stati importati con successo nel database Access.") conn.commit() # Conferma trasazione print("Dati importati con successo in database.")else: print(f"La parola ‘{word_to_search}’ non è stata trovata nel documento.")
Chiudi il documento quando hai finito
pdf_document.close()
codice fiscale mi da errore di inserimento nella query
- Assistant
Dall'estratto di codice che hai fornito, sembra che tu tenti di usare direttamente l'intera riga (
row) risultante dall'estrazione dal PDF come valore per il campoCodice fiscalenella tua query di inserimento. Se larowè una lista (come suggeriscono i commenti nel tuo stesso codice), l'errore potrebbe esser dovuto a questo, poiché invece ti serve una stringa singola.Per risolvere l'errore, devi assicurarti di prendere la giusta porzione di testo dalla lista risultante dall'estrazione con
ParseTabe usare il valore corrispondente al campoCodice fiscalenella tua tabella MS Access.Considerando che ogni riga estratta da
ParseTabè una lista e il Codice fiscale si trovi alla prima posizione (indice zero), ecco le correzioni da apportare:import re import time import fitz import pyodbc from ParseTab import ParseTab # Codice di connessione al database Access # ... if page is not None: # 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 e prepara il Protocollo, Progressivo e Esito_pag bbox_id = [69,8,534,26] # Coordinate box estrazione ID parsed_id = ParseTab(page, bbox_id, [189, 271, 418]) protocollo, progressivo = re.findall(r'(\d+)/(\d+)', parsed_id[0][2])[0] if parsed_id else ("", "") esito_pag = parsed_id[0][3].split(': ')[1] if parsed_id else "" codice_f24 = f"{protocollo}-{progressivo}" unix_timestamp = int(time.time()) # Inserisci nel database with pyodbc.connect(conn_str) as conn: cursor = conn.cursor() query = "INSERT INTO Testata ([Codice fiscale], [Tele - Protocollo fornitura], [Tele - Progressivo], codice_f24, ID_doc, [Tele - Esito fornitura]) VALUES (?, ?, ?, ?, ?, ?)" cursor.execute(query, 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.") else: print(f"La parola '{word_to_search}' non è stata trovata nel documento.") pdf_document.close()Alcune raccomandazioni per prevenire errori comuni:
- Assicurati che i nomi dei campi usati nella query SQL corrispondano esattamente ai nomi dei campi nel database Access, inclusi gli spazi.
- Utilizza il metodo
strip()per rimuovere eventuali spazi bianchi al principio e alla fine delle stringhe. - Se il campo
Codice fiscalerichiede una porzione di testo specifica (ad esempio, solo il valore del codice fiscale senza etichette aggiuntive come "CF Int:"), dovrai estrapolare solo quella porzione. - Aggiungi il trattamento delle eccezioni per gestire eventuali errori durante l'esecuzione della query di inserimento in modo da ottenere output più informativi sull'errore specifico.
Ricorda di adattare il codice in base alla vera struttura del tuo documento PDF e dei campi della tua tabella MS Access, i quali potrebbero variare rispetto all'esempio fornito.
- User
Traceback (most recent call last): File "C:\Users\Utente\Desktop\PyMuPDF-Utilities-master\examples\extract-table\estrazioni_1.py", line 48, in cursor.execute(query, codice_fiscale.strip(), protocollo.strip(), progressivo.strip(), codice_f24.strip(), unix_timestamp, esito_pag.strip()) pyodbc.ProgrammingError: ('42S02', '[42S02] [Microsoft][Driver ODBC Microsoft Access] Impossibile trovare la tabella di output "Testata". (-1305) (SQLExecDirectW)')
- Assistant
L'errore
pyodbc.ProgrammingError: ('42S02', '[42S02] [Microsoft][Driver ODBC Microsoft Access] Impossibile trovare la tabella di output "Testata". (-1305) (SQLExecDirectW)')indica che la tabella "Testata" non esiste nel database specificato e che quindi la query di inserimento non può essere eseguita.Per risolvere l'errore, verifica che:
- Il nome della tabella sia corretto, comprensivo del case (maiúscolo e minuscolo).
- La tabella "Testata" esista effettivamente nel database Access che stai cercando di modificare.
Una volta che hai verificato questi due punti e che siano corretti, riprova il codice. Se il nome della tabella è diverso o ha dei caratteri speciali, assicurati di utilizzarlo esattamente come è scritto nel database. Se la tabella non esiste, dovrai crearla nel tuo database Access con i campi e i tipi di dati appropriati che corrispondano alla query che stai cercando di eseguire.
Se stai usando MS Access, puoi verificarlo facilmente aprendo il database con Access e guardando l'elenco delle tabelle rispetto ai nomi che stai utilizzando nel tuo codice.
Supponiamo che il nome corretto della tabella non sia "Testata" ma "TestataXYZ". La query andrebbe modificata di conseguenza:
query = """ INSERT INTO TestataXYZ ([Codice fiscale], [Tele - Protocollo fornitura], [Tele - Progressivo], [codice_f24], [ID_doc], [Tele - Esito fornitura]) VALUES (?, ?, ?, ?, ?, ?) """ cursor.execute(query, codice_fiscale.strip(), protocollo.strip(), progressivo.strip(), codice_f24.strip(), unix_timestamp, esito_pag.strip())Nota che anche i nomi dei campi devono corrispondere esattamente a quelli nella tua tabella MS Access. Se ci sono discrepanze anche nei nomi dei campi, devi correggere anche quelle.
Se la tabella non esiste, dovresti creare la tabella dentro MS Access prima di eseguire la query. Assicurati che la struttura della tabella rifletta i tipi e i nomi di campo che prevedi di usare nel tuo script Python.
- User
perche una selezione cosi composta 09 02 2024 il risultato è 09 2004 02
- Assistant
Se stai riscontrando un ordine imprevisto nei valori estratti, potrebbe essere il risultato di come il testo viene interpretato dal PDF durante il processo di estrazione, o come l'ordine dei valori viene manipolato nel tuo codice.
Il PDF può rappresentare internamente i dati in un ordine che non riflette esattamente l'ordine visivo come ci si aspetterebbe di vedere sulla pagina. Ciò può accadere in diversi modi:
-
Estrazione del Testo: Alcuni strumenti di estrazione del testo potrebbero non mantenere l'ordine visivo del testo come appare sul PDF. Ad esempio, se le "parole" del testo vengono estratte basandosi su caselle di delimitazione individuate (bounding boxes), e queste non sono sequenzialmente ordinate, il testo potrebbe essere riportato fuori ordine.
-
Manipolazione dei Dati nel Codice: Se nel tuo codice manipoli i dati dopo l'estrazione (ad esempio, mediante ordinamento, split delle stringhe o altre operazioni), è possibile che ciò alteri l'ordine originale nel quale i dati dovrebbero apparire.
Per correggere questo problema, ti consiglio di controllare passo passo il processo di estrazione e manipolazione dei dati nel tuo codice, per garantire che l'ordine sia preservato o che venga correttamente riorganizzato secondo le tue aspettative.
Se hai accesso al codice che elabora le date e ordina i valori, come un'integrazione al tuo codice, per favore condividilo qui. Questo mi permetterà di fornirti una risposta più mirata alla tua situazione. Nel frattempo, qui hai un esempio di come potresti manipolare una stringa contenente una data:
import re # Dato un testo che contiene una data nel formato "dd mm yyyy" testo_data = "09 02 2024" # Assumendo che il testo sia stato estratto e che il tuo obiettivo sia ricostruirlo nel formato "dd mm yyyy" parti_data = re.split(r'\s+', testo_data) # Separa i componenti della data usando uno o più spazi come separatore data_riordinata = " ".join(parti_data) # Riunisce i componenti con uno spazio print(data_riordinata) # Dovrebbe stampare "09 02 2024"Assicurati che ogni passaggio intermediario che separa il testo della data in parti sia appropriato e mantenga l'ordine come previsto. Se il tuo dato di input è rappresentato in modo diverso o hai ulteriori passi di elaborazione, assicurati di adeguare questo codice di esempio di conseguenza.
-
- User
ho estratto i singoli riferimenti, come trasformarli in data unica 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]
- Assistant
Se hai estratto i componenti della data da tre diverse posizioni all'interno del documento PDF e desideri combinarli in una data unica, puoi assemblarli in una stringa che rappresenti la data nel formato che preferisci. In Python, una volta che hai estratto le parti della data (giorno, mese e anno), puoi unirli facilmente.
Assumendo che
giorno,meseeannosiano liste contenenti rispettivamente i valori estratti come stringhe, devi prima accedere ai valori effettivi all'interno di ogni lista (che presumibilmente sono presenti come primo elemento), e poi formattare questi valori in una stringa di data:# Supponendo che giorno, mese e anno siano liste contenenti una singola stringa ciascuna. # Ad esempio: giorno = ['09'], mese = ['02'], anno = ['2024'] # Accediamo al primo elemento di ciascuna lista dato che conteniamo un solo elemento 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_completa = f"{giorno_str}/{mese_str}/{anno_str}" print(data_completa) # Sarà stampato "09/02/2024" se i valori di giorno, mese e anno sono esatti.Assicurati che i dati estratti siano effettivamente le stringhe dei numeri di “giorno”, “mese” e “anno”, che non ci siano spazi superflui e che siano nel formato corretto. Se necessario, puoi anche includere il metodo
strip()per rimuovere spazi bianchi dalle stringhe estratte.Se vuoi creare un oggetto
datetimeeffettivo dal tuo valore di data, potresti fare qualcosa come questo:from datetime import datetime # Converti le stringhe estratte in un oggetto datetime try: data_obj = datetime.strptime(data_completa, "%d/%m/%Y") print(data_obj) # Stampa l'oggetto datetime except ValueError as e: print(f"Errore nella conversione della data: {e}")Include questi cambiamenti nel punto giusto del tuo script, subito dopo l'estrazione delle singole parti della data. Questo ti permetterà di gestire la data nel modo che preferisci per le successive operazioni, come l'inserimento nel database.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.