This article mainly introduces Python to use Pdfminer parsing PDF code example, small series feel very good, and now share to everyone, but also for everyone to do a reference. Let's take a look at it with a little knitting.
In recent times when doing reptiles sometimes encounter the site only provide PDF, so that you can not use Scrapy directly crawl page content, only by parsing PDF processing, the current solution is roughly only pypdf and Pdfminer. Because Pdfminer is said to be more suitable for parsing text, and I need to parse the text, I finally chose to use Pdfminer (which means I know nothing about pypdf).
The first explanation is that parsing the PDF is a very painful thing, even if the Pdfminer for the format of the PDF is not neat, so even pdfminer developers are spit slot pdf is evil. But that doesn't matter.
One. Installation:
1. First download the source package pypi.python.org/pypi/pdfminer/, unzip, and then command-line installation: Python setup.py install
2. Use the command line test after installation is complete: pdf2txt.py samples/simple1.pdf, if the following is displayed, the installation is successful:
Hello World Hello World H e l l o w o R l D H e l l o w o R l D
3. If you want to use CJK text, you need to compile and install it first:
# make cmap
python tools/conv_cmap.py pdfminer/cmap Adobe-CNS1 cmaprsrc/cid2code_Adobe_CNS1.txtreading 'cmaprsrc/cid2code_Adobe_CNS1.txt'...writing 'CNS1_H.py'......(this may take several minutes)
# python setup.py install
Two Use
Because parsing PDFs is a time-consuming and memory-intensive task, Pdfminer uses a strategy called lazy parsing to parse only when needed to reduce time and memory usage. At least two classes are required to parse a PDF: Pdfparser and Pdfdocument,pdfparser extract data from the file, pdfdocument save the data. Also need to pdfpageinterpreter to deal with the content of the page, Pdfdevice to convert it to what we need. Pdfresourcemanager is used to save shared content such as fonts or pictures.
Figure 1. Relationships between Pdfminer classes
More important is layout, which consists mainly of the following components:
Ltpage
Represents an entire page. May contain child objects like Lttextbox, Ltfigure, Ltimage, Ltrect, Ltcurve and Ltline.
Lttextbox
Represents a group of text chunks that can is contained in a rectangular area. Note that this box is created by geometric analysis and does not necessarily represents a logical boundary of the text. It contains a list of Lttextline objects. Get_text () method returns the text content.
Lttextline
Contains a list of Ltchar objects that represent a single text line. The characters is aligned either horizontaly or vertically, depending on the text ' s writing mode. Get_text () method returns the text content.
Ltchar
Ltanno
represent an actual letter in the text as a Unicode string. Note that while a Ltchar object had actual boundaries, Ltanno objects does not, as these is "virtual" characters, insert Ed by a layout analyzer according to the relationship between and characters (e.g. a space).
Ltfigure
Represents an area used by PDF Form objects. PDF Forms can be used to present figures or pictures by embedding yet another PDF document within a page. Note that Ltfigure objects can appear recursively.
Ltimage
Represents an Image object. Embedded images can is in JPEG or other formats, but currently Pdfminer does does pay much attention to graphical objects.
Ltline
Represents a single straight line. Could is used for separating text or figures.
Ltrect
Represents a rectangle. Could is used for framing another pictures or figures.
Ltcurve
Represents a generic Bézier curve.
The official document gave several demos but it was too brief, although gave a detailed demo, but the link address is old now has expired, but eventually found a new address: denis.papathanasiou.org/posts/2010.08.04.post.html
This demo is more detailed, the source code is as follows:
#!/usr/bin/python
import sys
import os
from binascii import b2a_hex
###
### pdf-miner requirements
###
from pdfminer.pdfparser import PDFParser
from pdfminer.pdfdocument import PDFDocument, PDFNoOutlines
from pdfminer.pdfpage import PDFPage
from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter
from pdfminer.converter import PDFPageAggregator
from pdfminer.layout import LAParams, LTTextBox, LTTextLine, LTFigure, LTImage, LTChar
def with_pdf (pdf_doc, fn, pdf_pwd, *args):
"""Open the pdf document, and apply the function, returning the results"""
result = None
try:
# open the pdf file
fp = open(pdf_doc, 'rb')
# create a parser object associated with the file object
parser = PDFParser(fp)
# create a PDFDocument object that stores the document structure
doc = PDFDocument(parser, pdf_pwd)
# connect the parser and document objects
parser.set_document(doc)
# supply the password for initialization
if doc.is_extractable:
# apply the function and return the result
result = fn(doc, *args)
# close the pdf file
fp.close()
except IOError:
# the file doesn't exist or similar problem
pass
return result
###
### Table of Contents
###
def _parse_toc (doc):
"""With an open PDFDocument object, get the table of contents (toc) data
[this is a higher-order function to be passed to with_pdf()]"""
toc = []
try:
outlines = doc.get_outlines()
for (level,title,dest,a,se) in outlines:
toc.append( (level, title) )
except PDFNoOutlines:
pass
return toc
def get_toc (pdf_doc, pdf_pwd=''):
"""Return the table of contents (toc), if any, for this pdf file"""
return with_pdf(pdf_doc, _parse_toc, pdf_pwd)
###
### Extracting Images
###
def write_file (folder, filename, filedata, flags='w'):
"""Write the file data to the folder and filename combination
(flags: 'w' for write text, 'wb' for write binary, use 'a' instead of 'w' for append)"""
result = False
if os.path.isdir(folder):
try:
file_obj = open(os.path.join(folder, filename), flags)
file_obj.write(filedata)
file_obj.close()
result = True
except IOError:
pass
return result
def determine_image_type (stream_first_4_bytes):
"""Find out the image file type based on the magic number comparison of the first 4 (or 2) bytes"""
file_type = None
bytes_as_hex = b2a_hex(stream_first_4_bytes)
if bytes_as_hex.startswith('ffd8'):
file_type = '.jpeg'
elif bytes_as_hex == '89504e47':
file_type = '.png'
elif bytes_as_hex == '47494638':
file_type = '.gif'
elif bytes_as_hex.startswith('424d'):
file_type = '.bmp'
return file_type
def save_image (lt_image, page_number, images_folder):
"""Try to save the image data from this LTImage object, and return the file name, if successful"""
result = None
if lt_image.stream:
file_stream = lt_image.stream.get_rawdata()
if file_stream:
file_ext = determine_image_type(file_stream[0:4])
if file_ext:
file_name = ''.join([str(page_number), '_', lt_image.name, file_ext])
if write_file(images_folder, file_name, file_stream, flags='wb'):
result = file_name
return result
###
### Extracting Text
###
def to_bytestring (s, enc='utf-8'):
"""Convert the given unicode string to a bytestring, using the standard encoding,
unless it's already a bytestring"""
if s:
if isinstance(s, str):
return s
else:
return s.encode(enc)
def update_page_text_hash (h, lt_obj, pct=0.2):
"""Use the bbox x0,x1 values within pct% to produce lists of associated text within the hash"""
x0 = lt_obj.bbox[0]
x1 = lt_obj.bbox[2]
key_found = False
for k, v in h.items():
hash_x0 = k[0]
if x0 >= (hash_x0 * (1.0-pct)) and (hash_x0 * (1.0+pct)) >= x0:
hash_x1 = k[1]
if x1 >= (hash_x1 * (1.0-pct)) and (hash_x1 * (1.0+pct)) >= x1:
# the text inside this LT* object was positioned at the same
# width as a prior series of text, so it belongs together
key_found = True
v.append(to_bytestring(lt_obj.get_text()))
h[k] = v
if not key_found:
# the text, based on width, is a new series,
# so it gets its own series (entry in the hash)
h[(x0,x1)] = [to_bytestring(lt_obj.get_text())]
return h
def parse_lt_objs (lt_objs, page_number, images_folder, text=[]):
"""Iterate through the list of LT* objects and capture the text or image data contained in each"""
text_content = []
page_text = {} # k=(x0, x1) of the bbox, v=list of text strings within that bbox width (physical column)
for lt_obj in lt_objs:
if isinstance(lt_obj, LTTextBox) or isinstance(lt_obj, LTTextLine):
# text, so arrange is logically based on its column width
page_text = update_page_text_hash(page_text, lt_obj)
elif isinstance(lt_obj, LTImage):
# an image, so save it to the designated folder, and note its place in the text
saved_file = save_image(lt_obj, page_number, images_folder)
if saved_file:
# use html style <img /> tag to mark the position of the image within the text
text_content.append('<img src="'+os.path.join(images_folder, saved_file)+'" />')
else:
print >> sys.stderr, "error saving image on page", page_number, lt_obj.__repr__
elif isinstance(lt_obj, LTFigure):
# LTFigure objects are containers for other LT* objects, so recurse through the children
text_content.append(parse_lt_objs(lt_obj, page_number, images_folder, text_content))
for k, v in sorted([(key,value) for (key,value) in page_text.items()]):
# sort the page_text hash by the keys (x0,x1 values of the bbox),
# which produces a top-down, left-to-right sequence of related columns
text_content.append(''.join(v))
return '\n'.join(text_content)
###
### Processing Pages
###
def _parse_pages (doc, images_folder):
"""With an open PDFDocument object, get the pages and parse each one
[this is a higher-order function to be passed to with_pdf()]"""
rsrcmgr = PDFResourceManager()
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
interpreter = PDFPageInterpreter(rsrcmgr, device)
text_content = []
for i, page in enumerate(PDFPage.create_pages(doc)):
interpreter.process_page(page)
# receive the LTPage object for this page
layout = device.get_result()
# layout is an LTPage object which may contain child objects like LTTextBox, LTFigure, LTImage, etc.
text_content.append(parse_lt_objs(layout, (i+1), images_folder))
return text_content
def get_pages (pdf_doc, pdf_pwd='', images_folder='/tmp'):
"""Process each of the pages in this pdf file and return a list of strings representing the text found in each page"""
return with_pdf(pdf_doc, _parse_pages, pdf_pwd, *tuple([images_folder]))
a = open('a.txt','a')
for i in get_pages('/home/jamespei/nova.pdf'):
a.write(i)
a.close()
This code is focused on line 128th, you can see Pdfminer is a coordinate-based parsing framework, the PDF can be resolved in the components all include the upper and lower left and right edge of the coordinates, such as X0 = Lt_obj.bbox[0] is the lt_obj element of the left edge of the coordinates, the same x1 is the right edge. The above code means that all x0 and X1 coordinates within 20% of the elements are divided into a group, so that the implementation of the direct extraction from the PDF file content.
----------------Supplement--------------------
There is a need to note that when parsing some PDFs, the exception is reported: Pdfminer.pdfdocument.PDFEncryptionError:Unknown algorithm:param={' CF ': {' STDCF ': {' Length ': +, ' CFM ':/aesv2, ' authevent ':/docopen}}, ' O ': ' \xe4\xe74\xb86/\xa8 ' \xa6x\xe6\xa3/u\xdf\x0fwr\x9cph\xac\ xae\x88b\x06_\xb0\x93@\x9f\x8d ', ' Filter ':/standard, ' P ': -1340, ' Length ': +, ' R ': 4, ' U ': ' | Utx#f\xc9v\x18\x87z\x10\xcb\xf5{\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 ', ' V ': 4, ' STMF ':/STDCF, ' strf ':/STDCF}
The literal meaning is because this PDF is an encrypted PDF, so it cannot be parsed, but if the direct opening of the PDF is possible and does not require a password or anything, because this PDF is too dense, but the password is empty, so there is such a problem.
The solution to this problem is to decrypt the file with the Qpdf command (to make sure that the qpdf is already installed) and to invoke the command in Python simply by using call:
from subprocess import call
call('qpdf --password=%s --decrypt %s %s' %('', file_path, new_file_path), shell=True)
Where the parameter file_path is the path of the PDF to be decrypted, New_file_path is the decrypted PDF file path, and then use the decrypted file to parse it OK