Moduł Pythona do konwersji plików PDF na tekst [zamknięty]

Pakiet PDFMiner zmienił się od czasu opublikowania codeape.

EDIT (again):

PDFMiner został ponownie zaktualizowany w wersji 20100213

Możesz sprawdzić zainstalowaną wersję za pomocą:

>>> import pdfminer
>>> pdfminer.__version__
'20100213'

Oto zaktualizowana wersja (z komentarzami co zmieniłem/dodałem):

def pdf_to_csv(filename):
    from cStringIO import StringIO  #<-- added so you can copy/paste this to try it
    from pdfminer.converter import LTTextItem, TextConverter
    from pdfminer.pdfparser import PDFDocument, PDFParser
    from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter

    class CsvConverter(TextConverter):
        def __init__(self, *args, **kwargs):
            TextConverter.__init__(self, *args, **kwargs)

        def end_page(self, i):
            from collections import defaultdict
            lines = defaultdict(lambda : {})
            for child in self.cur_item.objs:
                if isinstance(child, LTTextItem):
                    (_,_,x,y) = child.bbox                   #<-- changed
                    line = lines[int(-y)]
                    line[x] = child.text.encode(self.codec)  #<-- changed

            for y in sorted(lines.keys()):
                line = lines[y]
                self.outfp.write(";".join(line[x] for x in sorted(line.keys())))
                self.outfp.write("\n")

    # ... the following part of the code is a remix of the 
    # convert() function in the pdfminer/tools/pdf2text module
    rsrc = PDFResourceManager()
    outfp = StringIO()
    device = CsvConverter(rsrc, outfp, codec="utf-8")  #<-- changed 
        # becuase my test documents are utf-8 (note: utf-8 is the default codec)

    doc = PDFDocument()
    fp = open(filename, 'rb')
    parser = PDFParser(fp)       #<-- changed
    parser.set_document(doc)     #<-- added
    doc.set_parser(parser)       #<-- added
    doc.initialize('')

    interpreter = PDFPageInterpreter(rsrc, device)

    for i, page in enumerate(doc.get_pages()):
        outfp.write("START PAGE %d\n" % i)
        interpreter.process_page(page)
        outfp.write("END PAGE %d\n" % i)

    device.close()
    fp.close()

    return outfp.getvalue()

Edit (jeszcze raz):

Oto aktualizacja dla najnowszej wersji w pypi, 20100619p1. W skrócie I zastąpił LTTextItem na LTChar i przekazał instancję LAParams do konstruktora CsvConverter.

def pdf_to_csv(filename):
    from cStringIO import StringIO  
    from pdfminer.converter import LTChar, TextConverter    #<-- changed
    from pdfminer.layout import LAParams
    from pdfminer.pdfparser import PDFDocument, PDFParser
    from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter

    class CsvConverter(TextConverter):
        def __init__(self, *args, **kwargs):
            TextConverter.__init__(self, *args, **kwargs)

        def end_page(self, i):
            from collections import defaultdict
            lines = defaultdict(lambda : {})
            for child in self.cur_item.objs:
                if isinstance(child, LTChar):               #<-- changed
                    (_,_,x,y) = child.bbox                   
                    line = lines[int(-y)]
                    line[x] = child.text.encode(self.codec)

            for y in sorted(lines.keys()):
                line = lines[y]
                self.outfp.write(";".join(line[x] for x in sorted(line.keys())))
                self.outfp.write("\n")

    # ... the following part of the code is a remix of the 
    # convert() function in the pdfminer/tools/pdf2text module
    rsrc = PDFResourceManager()
    outfp = StringIO()
    device = CsvConverter(rsrc, outfp, codec="utf-8", laparams=LAParams())  #<-- changed
        # becuase my test documents are utf-8 (note: utf-8 is the default codec)

    doc = PDFDocument()
    fp = open(filename, 'rb')
    parser = PDFParser(fp)       
    parser.set_document(doc)     
    doc.set_parser(parser)       
    doc.initialize('')

    interpreter = PDFPageInterpreter(rsrc, device)

    for i, page in enumerate(doc.get_pages()):
        outfp.write("START PAGE %d\n" % i)
        if page is not None:
            interpreter.process_page(page)
        outfp.write("END PAGE %d\n" % i)

    device.close()
    fp.close()

    return outfp.getvalue()

EDIT (jeszcze raz):

Zaktualizowano do wersji 20110515 (dzięki Oeufcoque Penteano!):

def pdf_to_csv(filename):
    from cStringIO import StringIO  
    from pdfminer.converter import LTChar, TextConverter
    from pdfminer.layout import LAParams
    from pdfminer.pdfparser import PDFDocument, PDFParser
    from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter

    class CsvConverter(TextConverter):
        def __init__(self, *args, **kwargs):
            TextConverter.__init__(self, *args, **kwargs)

        def end_page(self, i):
            from collections import defaultdict
            lines = defaultdict(lambda : {})
            for child in self.cur_item._objs:                #<-- changed
                if isinstance(child, LTChar):
                    (_,_,x,y) = child.bbox                   
                    line = lines[int(-y)]
                    line[x] = child._text.encode(self.codec) #<-- changed

            for y in sorted(lines.keys()):
                line = lines[y]
                self.outfp.write(";".join(line[x] for x in sorted(line.keys())))
                self.outfp.write("\n")

    # ... the following part of the code is a remix of the 
    # convert() function in the pdfminer/tools/pdf2text module
    rsrc = PDFResourceManager()
    outfp = StringIO()
    device = CsvConverter(rsrc, outfp, codec="utf-8", laparams=LAParams())
        # becuase my test documents are utf-8 (note: utf-8 is the default codec)

    doc = PDFDocument()
    fp = open(filename, 'rb')
    parser = PDFParser(fp)       
    parser.set_document(doc)     
    doc.set_parser(parser)       
    doc.initialize('')

    interpreter = PDFPageInterpreter(rsrc, device)

    for i, page in enumerate(doc.get_pages()):
        outfp.write("START PAGE %d\n" % i)
        if page is not None:
            interpreter.process_page(page)
        outfp.write("END PAGE %d\n" % i)

    device.close()
    fp.close()

    return outfp.getvalue()

Ponieważ żaden dla tych rozwiązań nie obsługuje najnowszej wersji PDFMiner napisałem proste rozwiązanie, które zwróci tekst pdf za pomocą PDFMiner. Będzie to działać dla tych, którzy otrzymują błędy importu z process_pdf

import sys
from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter
from pdfminer.pdfpage import PDFPage
from pdfminer.converter import XMLConverter, HTMLConverter, TextConverter
from pdfminer.layout import LAParams
from cStringIO import StringIO

def pdfparser(data):

    fp = file(data, 'rb')
    rsrcmgr = PDFResourceManager()
    retstr = StringIO()
    codec = 'utf-8'
    laparams = LAParams()
    device = TextConverter(rsrcmgr, retstr, codec=codec, laparams=laparams)
    # Create a PDF interpreter object.
    interpreter = PDFPageInterpreter(rsrcmgr, device)
    # Process each page contained in the document.

    for page in PDFPage.get_pages(fp):
        interpreter.process_page(page)
        data =  retstr.getvalue()

    print data

if __name__ == '__main__':
    pdfparser(sys.argv[1])  

Zobacz poniższy kod, który działa dla Pythona 3:

import sys
from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter
from pdfminer.pdfpage import PDFPage
from pdfminer.converter import XMLConverter, HTMLConverter, TextConverter
from pdfminer.layout import LAParams
import io

def pdfparser(data):

    fp = open(data, 'rb')
    rsrcmgr = PDFResourceManager()
    retstr = io.StringIO()
    codec = 'utf-8'
    laparams = LAParams()
    device = TextConverter(rsrcmgr, retstr, codec=codec, laparams=laparams)
    # Create a PDF interpreter object.
    interpreter = PDFPageInterpreter(rsrcmgr, device)
    # Process each page contained in the document.

    for page in PDFPage.get_pages(fp):
        interpreter.process_page(page)
        data =  retstr.getvalue()

    print(data)

if __name__ == '__main__':
    pdfparser(sys.argv[1])  

PyPDF działa dobrze (zakładając, że pracujesz z dobrze uformowanymi plikami PDF). Jeśli chcesz tylko tekst (ze spacjami), możesz po prostu zrobić:

import pyPdf
pdf = pyPdf.PdfFileReader(open(filename, "rb"))
for page in pdf.pages:
    print page.extractText()

Możesz również łatwo uzyskać dostęp do metadanych, danych obrazu i tak dalej.

Komentarz w kodzie extractText Uwagi:

Zlokalizuj wszystkie polecenia rysowania tekstu, w kolejności są one dostarczane w strumień treści i wyodrębnij tekst. Działa to dobrze w przypadku niektórych plików PDF, ale słabo dla innych, w zależności od generator używany. To będzie / align = "left" / Nie polegaj na kolejność tekstu wychodzącego z tego funkcji, jak to się zmieni, jeśli to funkcja jest bardziej wyrafinowana.

To, czy jest to problem, zależy od tego, co robisz z tekstem (np. jeśli kolejność nie ma znaczenia, jest w porządku, lub jeśli generator dodaje tekst do strumienia w kolejności, w jakiej będzie wyświetlany, jest w porządku). Mam kod ekstrakcji pyPdf w codziennym użyciu, bez żadnych problemy.

Pdftotext program open source (część Xpdf), który możesz wywołać z Pythona (nie to, o co prosiłeś, ale może być przydatny). Używałem go bez żadnych problemów. Myślę, że google używa go w Google desktop.

Możesz również dość łatwo użyć pdfminer jako biblioteki. Masz dostęp do modelu zawartości pliku pdf i możesz utworzyć własną ekstrakcję tekstu. Zrobiłem to, aby przekonwertować zawartość pdf na tekst oddzielony dwukropkiem, używając poniższego kodu.

Funkcja po prostu sortuje Obiekty zawartości TextItem według ich współrzędnych y i x i wyświetla elementy o tej samej współrzędnej y co jedna linia tekstu, oddzielając obiekty w tej samej linii znakami';'.

Używając tego podejścia, I był w stanie wyodrębnić tekst z pliku pdf, z którego żadne inne narzędzie nie było w stanie wyodrębnić zawartości odpowiedniej do dalszej analizy. Inne narzędzia, które wypróbowałem, to pdftotext, ps2ascii i narzędzie online pdftextonline.com.

Pdfminer jest nieocenionym narzędziem do skrobania plików pdf.

def pdf_to_csv(filename):
    from pdflib.page import TextItem, TextConverter
    from pdflib.pdfparser import PDFDocument, PDFParser
    from pdflib.pdfinterp import PDFResourceManager, PDFPageInterpreter

    class CsvConverter(TextConverter):
        def __init__(self, *args, **kwargs):
            TextConverter.__init__(self, *args, **kwargs)

        def end_page(self, i):
            from collections import defaultdict
            lines = defaultdict(lambda : {})
            for child in self.cur_item.objs:
                if isinstance(child, TextItem):
                    (_,_,x,y) = child.bbox
                    line = lines[int(-y)]
                    line[x] = child.text

            for y in sorted(lines.keys()):
                line = lines[y]
                self.outfp.write(";".join(line[x] for x in sorted(line.keys())))
                self.outfp.write("\n")

    # ... the following part of the code is a remix of the 
    # convert() function in the pdfminer/tools/pdf2text module
    rsrc = PDFResourceManager()
    outfp = StringIO()
    device = CsvConverter(rsrc, outfp, "ascii")

    doc = PDFDocument()
    fp = open(filename, 'rb')
    parser = PDFParser(doc, fp)
    doc.initialize('')

    interpreter = PDFPageInterpreter(rsrc, device)

    for i, page in enumerate(doc.get_pages()):
        outfp.write("START PAGE %d\n" % i)
        interpreter.process_page(page)
        outfp.write("END PAGE %d\n" % i)

    device.close()
    fp.close()

    return outfp.getvalue()

UPDATE :

Powyższy kod jest napisany na starej wersji API, zobacz mój komentarz poniżej.

slate jest to projekt, który sprawia, że bardzo proste w użyciu PDFMiner z biblioteki:

>>> with open('example.pdf') as f:
...    doc = slate.PDF(f)
...
>>> doc
[..., ..., ...]
>>> doc[1]
'Text from page 2...'   

Musiałem przekonwertować konkretny plik PDF na zwykły tekst w module Pythona. Użyłem PDFMiner 20110515, po przeczytaniu ich pdf2txt.py Narzędzie napisałem ten prosty fragment:

from cStringIO import StringIO
from pdfminer.pdfinterp import PDFResourceManager, process_pdf
from pdfminer.converter import TextConverter
from pdfminer.layout import LAParams

def to_txt(pdf_path):
    input_ = file(pdf_path, 'rb')
    output = StringIO()

    manager = PDFResourceManager()
    converter = TextConverter(manager, output, laparams=LAParams())
    process_pdf(manager, converter, input_)

    return output.getvalue() 

Repurposing the pdf2txt.py kod dostarczany z pdfminer; możesz utworzyć funkcję, która zajmie ścieżkę do pliku pdf; opcjonalnie, outtype (txt / html / xml / tag) i opcje takie jak linia poleceń pdf2txt {'-o': '/ path / to / outfile.txt"...}. Domyślnie można wywołać:

convert_pdf(path)

Zostanie utworzony plik tekstowy, a w systemie plików do oryginalnego pliku pdf.

def convert_pdf(path, outtype='txt', opts={}):
    import sys
    from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter, process_pdf
    from pdfminer.converter import XMLConverter, HTMLConverter, TextConverter, TagExtractor
    from pdfminer.layout import LAParams
    from pdfminer.pdfparser import PDFDocument, PDFParser
    from pdfminer.pdfdevice import PDFDevice
    from pdfminer.cmapdb import CMapDB

    outfile = path[:-3] + outtype
    outdir = '/'.join(path.split('/')[:-1])

    debug = 0
    # input option
    password = ''
    pagenos = set()
    maxpages = 0
    # output option
    codec = 'utf-8'
    pageno = 1
    scale = 1
    showpageno = True
    laparams = LAParams()
    for (k, v) in opts:
        if k == '-d': debug += 1
        elif k == '-p': pagenos.update( int(x)-1 for x in v.split(',') )
        elif k == '-m': maxpages = int(v)
        elif k == '-P': password = v
        elif k == '-o': outfile = v
        elif k == '-n': laparams = None
        elif k == '-A': laparams.all_texts = True
        elif k == '-D': laparams.writing_mode = v
        elif k == '-M': laparams.char_margin = float(v)
        elif k == '-L': laparams.line_margin = float(v)
        elif k == '-W': laparams.word_margin = float(v)
        elif k == '-O': outdir = v
        elif k == '-t': outtype = v
        elif k == '-c': codec = v
        elif k == '-s': scale = float(v)
    #
    CMapDB.debug = debug
    PDFResourceManager.debug = debug
    PDFDocument.debug = debug
    PDFParser.debug = debug
    PDFPageInterpreter.debug = debug
    PDFDevice.debug = debug
    #
    rsrcmgr = PDFResourceManager()
    if not outtype:
        outtype = 'txt'
        if outfile:
            if outfile.endswith('.htm') or outfile.endswith('.html'):
                outtype = 'html'
            elif outfile.endswith('.xml'):
                outtype = 'xml'
            elif outfile.endswith('.tag'):
                outtype = 'tag'
    if outfile:
        outfp = file(outfile, 'w')
    else:
        outfp = sys.stdout
    if outtype == 'txt':
        device = TextConverter(rsrcmgr, outfp, codec=codec, laparams=laparams)
    elif outtype == 'xml':
        device = XMLConverter(rsrcmgr, outfp, codec=codec, laparams=laparams, outdir=outdir)
    elif outtype == 'html':
        device = HTMLConverter(rsrcmgr, outfp, codec=codec, scale=scale, laparams=laparams, outdir=outdir)
    elif outtype == 'tag':
        device = TagExtractor(rsrcmgr, outfp, codec=codec)
    else:
        return usage()

    fp = file(path, 'rb')
    process_pdf(rsrcmgr, device, fp, pagenos, maxpages=maxpages, password=password)
    fp.close()
    device.close()

    outfp.close()
    return

Dodatkowo istnieje PDFTextStream , która jest komercyjną biblioteką Javy, która może być również używana z Pythona.

Użyłem pdftohtml z argumentem '- xml', odczytałem wynik z podprocesem.Popen(), który daje x coord, y coord, szerokość, wysokość i czcionkę każdego "fragmentu" tekstu w pliku pdf. Myślę, że to jest to, czego prawdopodobnie używa "evince", ponieważ te same komunikaty o błędach wypluwają się.

Jeśli potrzebujesz przetworzyć dane kolumnowe, staje się to nieco bardziej skomplikowane, ponieważ musisz wymyślić algorytm, który pasuje do Twojego pliku pdf. Problem polega na tym, że programy tworzące pliki PDF nie koniecznie ułóż tekst w dowolnym formacie logicznym. Możesz wypróbować proste algorytmy sortowania i czasami to działa, ale może być trochę "maruderów" i "zabłąkanych", kawałków tekstu, które nie są ułożone w kolejności, o której myślałeś, że będą... więc musisz być kreatywny.

Zajęło mi około 5 godzin, aby wymyślić jeden dla plików pdf, nad którymi pracowałem. Ale teraz działa całkiem nieźle. Powodzenia.

PDFminer dał mi chyba jedną linijkę [strona 1 z 7...] na każdej stronie pliku pdf próbowałem z nim.

Najlepsza odpowiedź jaką mam do tej pory to pdftoipe, czyli kod c++ oparty na Xpdf.

Zobacz moje pytanie Jak wygląda wyjście pdftoipe.

Znalazłem to rozwiązanie dzisiaj. Mi pasuje. Nawet renderowanie stron PDF do obrazów PNG. http://www.swftools.org/gfx_tutorial.html