def parseCRF(strFilePath, strFileName, boolControlVersion, strVersion):
# print("Start parse CRF");
# fp = open(strSysPath+"/CRF/"+strFileName,'rb');
fp = open(strFilePath + "\\" + strFileName, 'rb')
parser = PDFParser(fp)
doc = PDFDocument()
parser.set_document(doc)
doc.set_parser(parser)
doc.initialize()
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
rsrcmgr = PDFResourceManager()
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
interpreter = PDFPageInterpreter(rsrcmgr, device)
count = 0
listCRF = list()
for page in doc.get_pages():
interpreter.process_page(page)
layout = device.get_result()
# strForm="";
objPageQuestions = createPageQuestions(layout, count + 1,
boolControlVersion,
strVersion)
listCRF.extend(objPageQuestions)
count = count + 1
# if count > 40:
# break
df = pd.DataFrame(listCRF)
# print("End parse CRF");
return df
def parse():
# rb以二进制读模式打开本地pdf文件
fn = open('Django-日志配置.md.pdf','rb')
# 创建一个pdf文档分析器
parser = PDFParser(fn)
# 创建一个PDF文档
doc = PDFDocument()
# 连接分析器 与文档对象
parser.set_document(doc)
doc.set_parser(parser)
# 提供初始化密码doc.initialize("lianxipython")
# 如果没有密码 就创建一个空的字符串
doc.initialize("")
# 检测文档是否提供txt转换，不提供就忽略
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
# 创建PDf资源管理器
resource = PDFResourceManager()
# 创建一个PDF参数分析器
laparams = LAParams()
# 创建聚合器,用于读取文档的对象
device = PDFPageAggregator(resource,laparams=laparams)
# 创建解释器，对文档编码，解释成Python能够识别的格式
interpreter = PDFPageInterpreter(resource,device)
# 循环遍历列表，每次处理一页的内容
# doc.get_pages() 获取page列表
for page in doc.get_pages():
# 利用解释器的process_page()方法解析读取单独页数
interpreter.process_page(page)
# 使用聚合器get_result()方法获取内容
layout = device.get_result()
# 这里layout是一个LTPage对象,里面存放着这个page解析出的各种对象
for out in layout:
# 判断是否含有get_text()方法，获取我们想要的文字
if hasattr(out,"get_text"):
# print(out.get_text(), type(out.get_text()))
content = out.get_text().replace(u'\xa0', u' ') # 将'\xa0'替换成u' '空格，这个\xa0就是&nbps空格
# with open('test.txt','a') as f:
# f.write(out.get_text().replace(u'\xa0', u' ')+'\n')
document.add_paragraph(
content, style='ListBullet' # 添加段落，样式为unordered list类型
)
document.save('demo1.docx') # 保存这个文档
def readPdf(self, path, callback=None, topath = ""):
#以二进制方式打开pdf文件
f = open(path, "rb")
#创建一个pdf 文档分析器
parser = PDFParser(f)
#创建pdf文档
pdfFile = PDFDocument()
#连接分析器与文档对象
parser.set_document(pdfFile)
#pdf 连接解析器反向关联
pdfFile.set_parser(parser)
#提供初始化密码
pdfFile.initialize("")
#检测文档是否提供txt转换
if not pdfFile.is_extractable:
raise PDFTextExtractionNotAllowed
else:
#解析数据
manage = PDFResourceManager()
#创建一个PDF设备对象
laparams = LAParams()
device = PDFPageAggregator(manage, laparams = laparams)
#解释器对象
interpreter = PDFPageInterpreter(manage, device)
#开始处理，没次处理一页
for page in pdfFile.get_pages():
interpreter.progcess_page(page)
layout = device.get_reault()
for x in layout:
if(isinstance(x, LTTextBoxHorizontal)):
if toPath =="":
#处理行数据
str = x.get_text()
if callback !=None:
#回调函数 main 方法
callback(str)
else:
print("处理文件")
else:
print("写文件 toPath 写入文件的路径")
def parser_pdf_file(pdf_file_path):
d_count = 0
x_count = 0
word_count = 0
read_pdf = open(pdf_file_path, 'rb') # 打开PDF文件。
parser_pdf = PDFParser(read_pdf) # 用文件对象创建一个PDF文档分析器。
pdf_document = PDFDocument(parser_pdf) # 创建一个PDF文档。
parser_pdf.set_document(pdf_document)
pdf_document.set_parser(parser_pdf) # 连接分析器 与文档对象。
pdf_document.initialize() # 如果没有密码，就创建一个空的字符串。
if not pdf_document.is_extractable: # 检测文档是否提供txt转换，不提供就忽略。
raise PDFTextExtractionNotAllowed
else:
pdf_manager = PDFResourceManager() # 创建PDF资源管理器 来管理共享资源。
pdf_laparams = LAParams() # 创建一个PDF参数分析器。
pdf_device = PDFPageAggregator(pdf_manager,
laparams=pdf_laparams) # 创建一个聚合器
pdf_interpreter = PDFPageInterpreter(pdf_manager,
pdf_device) # 创建一个PDF页面解释器对象
# 循环遍历列表，每次处理一页的内容，pdf_document.get_pages()获取page列表
for each_page in pdf_document.get_pages():
pdf_interpreter.process_page(each_page) # 使用页面解释器来读取
layout = pdf_device.get_result(
) # 这里layout是一个LTPage对象 里面存放着这个page解析出的各种对象 一般包括LTTexBox,LTFigure,LTImage,
# LTTexBoxHorizontal等等 想要获取文本就获得对象的text属性。
# print(layout)
for each_info in layout:
if isinstance(each_info, LTTextBoxHorizontal):
result = each_info.get_text().strip()
d_match = d_pattern.findall(result)
x_match = x_pattern.findall(result)
word_count += len(result)
if d_match:
d_count += 1
if x_match:
x_count += 1
print(result)
print("======")
if d_count == 0:
return x_count, word_count
else:
return d_count, word_count
def parseCRF(strFilePath,strFileName):
# print("Start parse CRF");
# fp = open(strSysPath+"/CRF/"+strFileName,'rb');
fp = open(strFilePath+"/"+strFileName,'rb');
parser = PDFParser(fp);
doc = PDFDocument();
parser.set_document(doc);
doc.set_parser(parser);
doc.initialize()
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
rsrcmgr = PDFResourceManager();
laparams = LAParams();
device = PDFPageAggregator(rsrcmgr,laparams=laparams);
interpreter = PDFPageInterpreter(rsrcmgr,device);
count=0;
listCRF=list();
for page in doc.get_pages():
interpreter.process_page(page);
layout = device.get_result();
# strForm="";
objPageQuestions=createPageQuestions(layout,count+1);
listCRF.extend(objPageQuestions);
count=count+1;
# if count >20:
# break;
df=pd.DataFrame(listCRF);
# print("End parse CRF");
return df;
def pdfparse(self, url):
try:
if url:
res = s.get(url, headers={"user-agent": generate_user_agent()})
res.encoding = 'utf-8'
f = BytesIO()
f.write(res.content)
f.seek(0)
# path2 = os.getcwd()+"\\%s.txt"%name.split(".")[0]
# print(path1)
praser = PDFParser(f)
doc = PDFDocument()
praser.set_document(doc)
doc.set_parser(praser)
doc.initialize()
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
# 创建PDf 资源管理器 来管理共享资源
# print("a")
rsrcmgr = PDFResourceManager()
# 创建一个PDF设备对象
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
# 创建一个PDF解释器对象
interpreter = PDFPageInterpreter(rsrcmgr, device)
text = ''
# 循环遍历列表，每次处理一个page的内容
for page in doc.get_pages(): # doc.get_pages() 获取page列表
interpreter.process_page(page)
# 接受该页面的LTPage对象
layout = device.get_result()
#text = "".join(map(lambda x:x.get_text().strip(" ") if x.get_text() else "",layout))
#print(text)
# 这里layout是一个LTPage对象 里面存放着 这个page解析出的各种对象 一般包括LTTextBox, LTFigure, LTImage, LTTextBoxHorizontal 等等 想要获取文本就获得对象的text属性，
for x in layout:
if hasattr(x, 'get_text'):
results = x.get_text()
if results:
text += results.strip('\n')
f.close()
return text
except Exception as e:
print(e)
def pages_from_pdf(path, **laparams):
fp = open(path, 'rb')
doc = PDFDocument(caching=True)
parser = PDFParser(fp)
parser.set_document(doc)
doc.set_parser(parser)
doc.initialize()
rsrcmgr = PDFResourceManager()
laparams = LAParams(all_texts=True, **laparams)
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
interpreter = PDFPageInterpreter(rsrcmgr, device)
result = []
for page in doc.get_pages():
interpreter.process_page(page)
page_layout = device.get_result()
result.append(page_layout)
return result
def readPDF(path):
# 以二进制形式打开pdf文件
f = open(path, "rb")
# 创建一个pdf文档分析器
parser = PDFParser(f)
#创建一个pdf文档
pdfFile = PDFDocument()
#连接分析器和文档对象
parser.set_document(pdfFile)
pdfFile.set_parser(parser)
#提供初始化密码
pdfFile.initialize()
#检测文档是否提供txt转换
if not pdfFile.is_extractable:
raise PDFTextExtractionNotAllowed
else:
#解析数据
#数据管理器
manager = PDFResourceManager()
#创建一个PDF设备对象
laparams = LAParams()
device = PDFPageAggregator(manager, laparams=laparams)
# 创建一个PDF解释其对象
interpreter = PDFPageInterpreter(manager, device)
# 循环遍历列表，每次处理一个page内容
# pdfFile.get_pages() 获取page列表
for page in pdfFile.get_pages():
interpreter.process_page(page)
# 接受该页面的LTPage对象
layout = device.get_result()
# 这里layout是一个LTPage对象 里面存放着 这个page解析出的各种对象
# 一般包括LTTextBox, LTFigure, LTImage, LTTextBoxHorizontal 等等
# 想要获取文本就获得对象的text属性，
for x in layout:
#判断类型isinstance()x是LTTextBoxHorizontal类型
if (isinstance(x, LTTextBoxHorizontal)):
with open(r'pdf.txt', 'a',encoding='utf-8') as f:
str = x.get_text()
# print(str)
f.write(str + "\n")
def get_text_from_pdf(filename):
from pdfminer.pdfparser import PDFParser, PDFDocument
from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter
from pdfminer.converter import PDFPageAggregator
from pdfminer.layout import LAParams, LTTextBox
from pdfminer.pdfinterp import PDFTextExtractionNotAllowed
path = filename + ".pdf"
# 用文件对象来创建一个pdf文档分析器
praser = PDFParser(open(path, 'rb'))
# 创建一个PDF文档
doc = PDFDocument()
# 连接分析器 与文档对象
praser.set_document(doc)
doc.set_parser(praser)
# 提供初始化密码
# 如果没有密码 就创建一个空的字符串
doc.initialize()
# 检测文档是否提供txt转换，不提供就忽略
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
# 创建PDf 资源管理器 来管理共享资源
rsrcmgr = PDFResourceManager()
# 创建一个PDF设备对象
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
# 创建一个PDF解释器对象
interpreter = PDFPageInterpreter(rsrcmgr, device)
# 循环遍历列表，每次处理一个page的内容
content = ''
for page in doc.get_pages():
interpreter.process_page(page)
# 接受该页面的LTPage对象
layout = device.get_result()
# 这里layout是一个LTPage对象，里面存放着这个 page 解析出的各种对象
# 包括 LTTextBox, LTFigure, LTImage, LTTextBoxHorizontal 等
for x in layout:
if isinstance(x, LTTextBox):
# print(x.get_text().strip())
content = content + x.get_text().strip()
return content
def readPdf(path, toPath):
# 以二进制打开文件 pdf
f = open(path, "rb")
# 创建一个pdf文档分析器
parser = PDFParser(f)
# 创建一个pdf文档
pdfFile = PDFDocument()
# 连接文档和分析器
parser.set_document(pdfFile)
pdfFile.set_parser(parser)
# 提供初始化密码
pdfFile.initialize()
# 检测pdf文档是否提供txt转换
if not pdfFile.is_extractable:
# 不提供
# 当程序出现错误，python会自动引发异常，也可以通过raise显示地引发异常。
# 一旦执行了raise语句，raise后面的语句将不能执行
raise PDFTextExtractionNotAllowed
else:
# 提供
manager = PDFResourceManager()
# 创建一个pdf设备对象
laparams = LAParams()
device = PDFPageAggregator(manager, laparams=laparams)
# 解锁器对象
interpreter = PDFPageInterpreter(manager, device)
# 开始循环处理 每次处理一页
for page in pdfFile.get_pages():
# 解释这一页
interpreter.process_page(page)
layout = device.get_result()
for x in layout:
if (isinstance(x, LTTextBoxHorizontal)):
# 打开 toPath文件 并 往里面追加 pdf的内容
with open(toPath, "a", encoding="utf-8") as f:
str = x.get_text()
print(str)
f.write(str + "\n")
def process_pdf(filePath):
# 二进制读取pdf文件
fp = open(filePath, 'rb')
parser = PDFParser(fp)
# 创建一个PDF文档对象
doc = PDFDocument()
# 分析器和文档相互连接
parser.set_document(doc)
doc.set_parser(parser)
# 提供初始化密码
# 如果没有密码 就创建一个空的字符串
doc.initialize()
# 检测文档是否提供txt转换，不提供就忽略
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
# 创建一个PDF资源管理器来管理共享资源
rsrcmgr = PDFResourceManager()
# 创建一个PDF设备对象
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr=rsrcmgr, laparams=laparams)
# 创建一个PDF解释器对象
interpreter = PDFPageInterpreter(rsrcmgr=rsrcmgr, device=device)
result = ''
# 循环遍历列表，每次只处理一个page内容
for page in doc.get_pages(): # doc.get_pages()获取page列表
interpreter.process_page(page)
# 接受该页面的LTPage对象
layout = device.get_result()
for x in layout:
if isinstance(x, LTTextBoxHorizontal):
# with open('test.txt', 'a') as f:
# result = x.get_text()
# print(result)
# f.write(result + '\n')
result += x.get_text()
try:
invoice_no = re.search("INVOICE NO. (\d+)", result)
return invoice_no.group(1)
except:
return None
def process_pdf(filePath):
# 二进制读取pdf文件
fp = open(filePath, 'rb')
parser = PDFParser(fp)
# 创建一个PDF文档对象
doc = PDFDocument()
# 分析器和文档相互连接
parser.set_document(doc)
doc.set_parser(parser)
# 提供初始化密码
# 如果没有密码 就创建一个空的字符串
doc.initialize()
# 检测文档是否提供txt转换，不提供就忽略
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
# 创建一个PDF资源管理器来管理共享资源
rsrcmgr = PDFResourceManager()
# 创建一个PDF设备对象
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr=rsrcmgr, laparams=laparams)
# 创建一个PDF解释器对象
interpreter = PDFPageInterpreter(rsrcmgr=rsrcmgr, device=device)
result = ''
# 循环遍历列表，每次只处理一个page内容
for page in doc.get_pages(): # doc.get_pages()获取page列表
interpreter.process_page(page)
# 接受该页面的LTPage对象
layout = device.get_result()
for x in layout:
if isinstance(x, LTTextBoxHorizontal):
result += x.get_text()
text = re.search("===================\n(.*\n)+ TOTAL INTERNATIONAL",
result)
result = text.group()
data = re.findall(' (\d+.+?\d+)\n', result)
print(len(data))
rows = []
for i in data:
row = re.findall('\S+', i)
# print(row)
rows.append(row)
df = DataFrame(data=rows)
for i in df.columns[3:13]:
df[i] = df[i].astype('float64')
return df
def dumpoutline(outfp, fname, objids, pagenos, password='',
dumpall=False, codec=None):
doc = PDFDocument()
fp = open(fname, 'rb')
parser = PDFParser(fp)
parser.set_document(doc)
doc.set_parser(parser)
doc.initialize(password)
pages = dict( (page.pageid, pageno) for (pageno,page) in enumerate(doc.get_pages()) )
def resolve_dest(dest):
if isinstance(dest, str):
dest = resolve1(doc.get_dest(dest))
elif isinstance(dest, PSLiteral):
dest = resolve1(doc.get_dest(dest.name))
if isinstance(dest, dict):
dest = dest['D']
return dest
try:
outlines = doc.get_outlines()
outfp.write('<outlines>\n')
for (level,title,dest,a,se) in outlines:
pageno = None
if dest:
dest = resolve_dest(dest)
pageno = pages[dest[0].objid]
elif a:
action = a.resolve()
if isinstance(action, dict):
subtype = action.get('S')
if subtype and repr(subtype) == '/GoTo' and action.get('D'):
dest = resolve_dest(action['D'])
pageno = pages[dest[0].objid]
s = e(title).encode('utf-8', 'xmlcharrefreplace')
outfp.write('<outline level="%r" title="%s">\n' % (level, s))
if dest is not None:
outfp.write('<dest>')
dumpxml(outfp, dest)
outfp.write('</dest>\n')
if pageno is not None:
outfp.write('<pageno>%r</pageno>\n' % pageno)
outfp.write('</outline>\n')
outfp.write('</outlines>\n')
except PDFNoOutlines:
pass
parser.close()
fp.close()
def process(path):
nega = posi = unce = liti = cons = supe = inte = master = total = 0
fp = open(path, 'rb')
praser = PDFParser(fp)
doc = PDFDocument()
praser.set_document(doc)
doc.set_parser(praser)
doc.initialize()
fp.close()
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
rsrcmgr = PDFResourceManager()
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
interpreter = PDFPageInterpreter(rsrcmgr, device)
for page in doc.get_pages():
interpreter.process_page(page)
layout = device.get_result()
for x in layout:
if (isinstance(x, LTTextBoxHorizontal)):
results = x.get_text().lower()
list = results.split()
total += len(results)
for part in list:
if count_word(part, word) > 0 :
master += 1
if count_word(part, negative ):
nega += 1
if count_word(part, positive):
posi += 1
if count_word(part, uncertainty):
unce += 1
if count_word(part, litigious):
liti += 1
if count_word(part, constraining):
cons += 1
if count_word(part, superfluous):
supe += 1
if count_word(part, interesting):
inte += 1
return [master, total, nega, posi, unce, liti, cons, supe, inte]
def parse():
#rb以二进制读模式打开本地pdf文件
fn = open('test.pdf', 'rb')
#创建一个pdf文档分析器
parser = PDFParser(fn)
#创建一个PDF文档
doc = PDFDocument(parser)
#连接分析器 与文档对象
parser.set_document(doc)
doc.set_parser(parser)
# 提供初始化密码doc.initialize("lianxipython")
# 如果没有密码 就创建一个空的字符串
doc.initialize("")
# 检测文档是否提供txt转换，不提供就忽略
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
#创建PDf资源管理器
resource = PDFResourceManager()
#创建一个PDF参数分析器
laparams = LAParams()
#创建聚合器,用于读取文档的对象
device = PDFPageAggregator(resource, laparams=laparams)
#创建解释器，对文档编码，解释成Python能够识别的格式
interpreter = PDFPageInterpreter(resource, device)
# 循环遍历列表，每次处理一页的内容
# doc.get_pages() 获取page列表
for page in doc.get_pages():
#利用解释器的process_page()方法解析读取单独页数
interpreter.process_page(page)
#使用聚合器get_result()方法获取内容
layout = device.get_result()
#这里layout是一个LTPage对象,里面存放着这个page解析出的各种对象
try:
for out in layout:
#判断是否含有get_text()方法，获取我们想要的文字
if hasattr(out, "get_text"):
print(out.get_text())
with open('test.txt', 'a') as f:
f.write(out.get_text() + '\n')
except UnicodeEncodeError as ue:
print("异常：" + str(ue))
pass
def pdf_to_csv(filename):
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()
def parsepdf(_path):
results = ''
print("pdf开始加载")
is_http = True if _path.startswith('http') else False
if is_http:
fp = urllib.request.urlopen(_path)
else:
fp = open(_path, 'rb') # rb以二进制读模式打开本地pdf文件
print("pdf加载完成")
# 用文件对象来创建一个pdf文档分析器
praser_pdf = PDFParser(fp)
# 创建一个PDF文档
doc = PDFDocument()
# 连接分析器 与文档对象
praser_pdf.set_document(doc)
doc.set_parser(praser_pdf)
# 提供初始化密码doc.initialize("123456")
# 如果没有密码 就创建一个空的字符串
doc.initialize()
# 检测文档是否提供txt转换，不提供就忽略
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
# 创建PDf资源管理器 来管理共享资源
rsrcmgr = PDFResourceManager()
# 创建一个PDF参数分析器
laparams = LAParams()
# 创建聚合器
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
# 创建一个PDF页面解释器对象
interpreter = PDFPageInterpreter(rsrcmgr, device)
# 循环遍历列表，每次处理一页的内容
doc.get_pages()
for page in (doc.get_pages()):
# 使用页面解释器来读取
interpreter.process_page(page)
# 使用聚合器获取内容
layout = device.get_result()
# 这里layout是一个LTPage对象 里面存放着 这个page解析出的各种对象 一般包括LTTextBox, LTFigure, LTImage, LTTextBoxHorizontal 等等 想要获取文本就获得对象的text属性，
for out in layout:
# 判断是否含有get_text()方法，图片之类的就没有
# if hasattr(out,"get_text"):
if isinstance(out, LTTextBoxHorizontal):
results += out.get_text()
return results
def pdf2txt(pdfname, txtname):
btxt = False
try:
fp = open(pdfname, 'rb')
parser = PDFParser(fp)
doc = PDFDocument()
parser.set_document(doc)
doc.set_parser(parser)
doc.initialize('')
rsrcmgr = PDFResourceManager()
laparams = LAParams()
laparams.char_margin = 1.0
laparams.word_margin = 1.0
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
interpreter = PDFPageInterpreter(rsrcmgr, device)
ncount = 0
print("pdf2txt %s..." %
pdfname) # informa por consola del nombre de archivo
# abre archivo de texto para la salida
fptxt = open(txtname, 'w')
# recorre el documento procesando cada página
for page in doc.get_pages():
interpreter.process_page(page)
layout = device.get_result()
# recorre la página procesando cada objeto
for lt_obj in layout:
if isinstance(lt_obj, LTTextBox) or isinstance(
lt_obj, LTTextLine):
spagetxt = lt_obj.get_text().strip() + " "
if (spagetxt != ""):
btxt = True
fptxt.write(spagetxt)
print("Palabra", spagetxt)
elif isinstance(lt_obj, LTFigure):
print("LTFigure, pte implementar!")
spagetxt = ""
ncount += 1
print("end")
fptxt.closed
fp.closed
except Exception as e:
print("Error: %s" % (e))
return btxt
def onePdfToTxt(filepath, outpath):
try:
#rb以二进制读模式打开本地pdf文件
fp = open(filepath, 'rb')
outfp = open(outpath, 'w', encoding='utf-8')
#创建一个pdf文档分析器
parser = PDFParser(fp)
#创建一个PDF文档
doc = PDFDocument()
#连接分析器 与文档对象
parser.set_document(doc)
doc.set_parser(parser)
# 提供初始化密码doc.initialize("lianxipython")
# 如果没有密码 就创建一个空的字符串
doc.initialize("")
# 检测文档是否提供txt转换，不提供就忽略
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
#创建PDf资源管理器
resource = PDFResourceManager()
#创建一个PDF参数分析器
laparams = LAParams()
#创建聚合器,用于读取文档的对象
device = PDFPageAggregator(resource, laparams=laparams)
#创建解释器，对文档编码，解释成Python能够识别的格式
interpreter = PDFPageInterpreter(resource, device)
# 循环遍历列表，每次处理一页的内容 doc.get_pages() 获取page列表
for page in doc.get_pages():
#利用解释器的process_page()方法解析读取单独页数
interpreter.process_page(page)
#使用聚合器get_result()方法获取内容
layout = device.get_result()
#这里layout是一个LTPage对象,里面存放着这个page解析出的各种对象
for out in layout:
#判断是否含有get_text()方法，获取我们想要的文字
if hasattr(out, "get_text"):
text = out.get_text()
print(text)
outfp.write(text + '\n')
fp.close()
outfp.close()
except Exception as e:
print(e)
def get_pdf_content(pdf_path):
print(pdf_path)
with open(pdf_path, "rb") as file:
parser = PDFParser(file)
doc = PDFDocument()
parser.set_document(doc)
doc.set_parser(parser)
doc.initialize()
# When the file can't convert to txt, it will throw an error
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
rsrcmgr = PDFResourceManager()
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
interpreter = PDFPageInterpreter(rsrcmgr, device)
content_recoder = []
# process by page
for page in doc.get_pages():
interpreter.process_page(page)
layout = device.get_result()
for x in layout:
if (isinstance(x, LTTextBoxHorizontal)):
content_recoder.append(replace_invisible(x.get_text()))
# Page procession done, we need detect page number and remove it
try:
if content_recoder[-1].isdigit():
content_recoder = content_recoder[:-1] + [" "]
except:
pass
if content_recoder:
content_recoder = list(
filter(lambda c: c and c != content_recoder[0],
content_recoder))
else:
pass
#raise Exception("No Extracted Content.")
return "\n".join(content_recoder)
def pdf_read(file):
"""读取pdf文件"""
# pip install pdfminer3k
from pdfminer.pdfparser import PDFParser, PDFDocument
from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter
from pdfminer.converter import PDFPageAggregator
from pdfminer.layout import LTTextBoxHorizontal, LAParams
from pdfminer.pdfinterp import PDFTextExtractionNotAllowed
fp = open(file, 'rb')
# 用文件对象创建一个PDF文档分析器
parser = PDFParser(fp)
# 创建一个PDF文档
doc = PDFDocument()
# 连接分析器，与文档对象
parser.set_document(doc)
doc.set_parser(parser)
# 提供初始化密码，如果没有密码，就创建一个空的字符串
doc.initialize()
# 检测文档是否提供txt转换，不提供就忽略
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
# 创建PDF，资源管理器，来共享资源
rsrcmgr = PDFResourceManager()
# 创建一个PDF设备对象
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
# 创建一个PDF解释其对象
interpreter = PDFPageInterpreter(rsrcmgr, device)
# 循环遍历列表，每次处理一个page内容
# doc.get_pages() 获取page列表
for page in doc.get_pages():
interpreter.process_page(page)
# 接受该页面的LTPage对象
layout = device.get_result()
# 这里layout是一个LTPage对象 里面存放着 这个page解析出的各种对象
# 一般包括LTTextBox, LTFigure, LTImage, LTTextBoxHorizontal 等等
# 想要获取文本就获得对象的text属性，
for x in layout:
if isinstance(x, LTTextBoxHorizontal):
results = x.get_text()
common_handle(results)
def parse(pdf_path):
fp = open(pdf_path, 'rb') # 以二进制读模式打开
# 用文件对象来创建一个pdf文档分析器
parser = PDFParser(fp)
# 创建一个PDF文档
doc = PDFDocument()
# 连接分析器 与文档对象
parser.set_document(doc)
doc.set_parser(parser)
doc.initialize()
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
rsrcmgr = PDFResourceManager()
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
interpreter = PDFPageInterpreter(rsrcmgr, device)
# 用来计数页面，图片，曲线，figure，水平文本框等对象的数量
num_page = 0
text0_now, text0_last, text1_now, text1_last = "", "", "", ""
page_list = []
for page in doc.get_pages(): # doc.get_pages() 获取page列表
num_page += 1 # 页面增一
interpreter.process_page(page)
layout = device.get_result()
for x in layout:
if isinstance(x, LTTextBoxHorizontal): # 获取文本内容
if num_page == 1:
if x.index == 0:
text0_now = x.get_text()
if x.index == 1:
text1_now = x.get_text()
else:
if x.index == 0:
text0_last = text0_now
text0_now = x.get_text()
if x.index == 1:
text1_last = text1_now
text1_now = x.get_text()
if num_page != 1:
if text1_now != text1_last:
page_list.append(num_page - 1) # last page
if text1_now == text0_last:
page_list.append(num_page) # now page
return page_list
def parse():
'''解析PDF文本，并保存到TXT文件中'''
fp = open(text_path,'rb')
#用文件对象创建一个PDF文档分析器
parser = PDFParser(fp)
#创建一个PDF文档
doc = PDFDocument()
#连接分析器，与文档对象
parser.set_document(doc)
doc.set_parser(parser)
#提供初始化密码，如果没有密码，就创建一个空的字符串
doc.initialize()
#检测文档是否提供txt转换，不提供就忽略
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
#创建PDF，资源管理器，来共享资源
rsrcmgr = PDFResourceManager()
#创建一个PDF设备对象
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr,laparams=laparams)
#创建一个PDF解释其对象
interpreter = PDFPageInterpreter(rsrcmgr,device)
#循环遍历列表，每次处理一个page内容
page = list(doc.get_pages())[47]
interpreter.process_page(page)
#接受该页面的LTPage对象
layout = device.get_result()
# 这里layout是一个LTPage对象 里面存放着 这个page解析出的各种对象
# 一般包括LTTextBox, LTFigure, LTImage, LTTextBoxHorizontal 等等
# 想要获取文本就获得对象的text属性，
for x in layout:
if(isinstance(x,LTTextBoxHorizontal)):
results = x.get_text()
if(results.strip()):
print(results.strip())
def readPdf(path, toPath):
#以二进制形式打开pdf文件
f = open(path, "rb")
#创建一个pdf分析器
parser = PDFParser(f)
#创建pdf文档
pdfFile = PDFDocument()
#链接分析器与文件分析器
parser.set_document(pdfFile)
#提供初始化密码
pdfFile.initialize() #现在是无密码状态
pdfFile.set_parser(parser)
#检测文档是否提供txt转换
if not pdfFile.is_extractable:
raise PDFTextExtractionNotAllowed
else:
#解析数据
#数据管理器
manager = PDFResourceManager()
#创建一个PDF设备对象
laparams = LAParams()
#创建聚合器
device = PDFPageAggregator(manager, laparams=laparams)
#解释器对象
interpreter = PDFPageInterpreter(manager, device)
#开始循环处理，每次处理一页
for page in pdfFile.get_pages():
#使用页面解释器来获取
# PDFPageInterpreter.process_page(page)
interpreter.process_page(page)
#使用聚合器获取内容
layout = device.get_result()
for x in layout:
#判断x是否是LTTextBoxHorizontal类型
if (isinstance(x, LTTextBoxHorizontal)):
with open(toPath, "a") as f: #以追加的形式写入pdf
#
str1 = x.get_text()
print(str1)
f.write(str1 + "\n")
def _pdf_to_text(self, pdf_path, text_path):
"""
This method does the actual text extraction. It uses PdfMiner Python
library to do the extraction.
:param pdf_path: path to the input PDF
:param text_path: path to the output text
:return: True if successful, False otherwise
"""
text = ''
num_pages = 0
doc = PDFDocument()
res_mgr = PDFResourceManager()
device = PDFPageAggregator(res_mgr, laparams=LAParams())
interpreter = PDFPageInterpreter(res_mgr, device)
try:
with open(pdf_path, 'rb') as fp:
parser = PDFParser(fp)
parser.set_document(doc)
doc.set_parser(parser)
doc.initialize('')
for page in doc.get_pages():
self._logger.debug('Processing page {}'.format(num_pages +
1))
interpreter.process_page(page)
layout = device.get_result()
for lt_obj in layout:
if isinstance(lt_obj, LTTextBox) \
or isinstance(lt_obj, LTTextLine):
# print(lt_obj.get_text())
text += lt_obj.get_text()
num_pages += 1
self._logger.info('Done, extracted {} pages'.format(num_pages))
self._logger.debug('Storing result in {}'.format(text_path))
with open(text_path, 'w') as text_fp:
text_fp.write(text.strip())
except:
self._logger.warning(
'Extracting text from {} failed'.format(pdf_path))
return False
finally:
# close resources before exiting
device.close()
return text is not None and len(text)
def parse_pdf(url):
"""
从pdf中抽取内容
:param filename: 要抽取的 pdf路径
:return: 抽取到的pdf的内容
"""
get_pdf(url)
fp = open('1.pdf', 'rb') # 以二进制读模式打开
#用文件对象来创建一个pdf文档分析器
praser = PDFParser(fp)
# 创建一个PDF文档
doc = PDFDocument()
# 连接分析器 与文档对象
praser.set_document(doc)
doc.set_parser(praser)
content = ""
# 提供初始化密码
# 如果没有密码 就创建一个空的字符串
doc.initialize()
# 检测文档是否提供txt转换，不提供就忽略
if not doc.is_extractable:
content = ""
else:
# 创建PDf 资源管理器 来管理共享资源
rsrcmgr = PDFResourceManager()
# 创建一个PDF设备对象
laparams = LAParams()
device = PDFPageAggregator(rsrcmgr, laparams=laparams)
# 创建一个PDF解释器对象
interpreter = PDFPageInterpreter(rsrcmgr, device)
# 循环遍历列表，每次处理一个page的内容
for page in doc.get_pages(): # doc.get_pages() 获取page列表
interpreter.process_page(page)
# 接受该页面的LTPage对象
layout = device.get_result()
# 这里layout是一个LTPage对象 里面存放着 这个page解析出的各种对象 一般包括LTTextBox, LTFigure, LTImage, LTTextBoxHorizontal 等等 想要获取文本就获得对象的text属性，
for x in layout:
if (isinstance(x, LTTextBoxHorizontal)):
results = x.get_text()
content += results
content = " ".join(content.replace("\n", "").strip().split())
return content
def pdf_page_content(pdf_file, page_num):
'''
返回某个页面的所有layout,
:param pdf_file: pdf文件名
:param page_num: 页数
:return: Generator, layout
'''
if page_num <= 0:
raise ValueError(
'page_num must be more than zero, but the number your given is %s'
% page_num)
fp = open(pdf_file, 'rb')
parser = PDFParser(fp)
# 创建一个PDF文档
doc = PDFDocument()
# 分析器和文档相互连接
parser.set_document(doc)
doc.set_parser(parser)
# 提供初始化密码，没有默认为空
doc.initialize()
# 检查文档是否可以转成TXT，如果不可以就忽略
if not doc.is_extractable:
raise PDFTextExtractionNotAllowed
else:
# 创建PDF资源管理器，来管理共享资源
rsrcmagr = PDFResourceManager()
# 创建一个PDF设备对象
laparams = LAParams()
# 将资源管理器和设备对象聚合
device = PDFPageAggregator(rsrcmagr, laparams=laparams)
# 创建一个PDF解释器对象
interpreter = PDFPageInterpreter(rsrcmagr, device)
for index, page in enumerate(doc.get_pages()):
if index != page_num - 1:
continue
else:
interpreter.process_page(page)
# 接收该页面的LTPage对象
layout = device.get_result()
# 这里的layout是一个LTPage对象 里面存放着page解析出来的各种对象
# 一般包括LTTextBox，LTFigure，LTImage，LTTextBoxHorizontal等等一些对像
# 想要获取文本就得获取对象的text属性
for x in layout:
if (isinstance(x, LTTextBoxHorizontal)):
yield x
def extract():
#read pdf files into list
file_list = os.listdir("pdf")
if '.DS_Store' in file_list:
file_list.remove('.DS_Store')
metadata = []
for file in file_list:
fp = open('pdf/' + file, 'rb')
print(file)
parser = PDFParser(fp)
doc = PDFDocument()
parser.set_document(doc)
doc.set_parser(parser)
doc.initialize()
metadata.extend(doc.info)
return metadata
def convert(infile):
parser = PDFParser(infile)
doc = PDFDocument()
parser.set_document(doc)
doc.set_parser(parser)
doc.initialize('')
rsrcmgr = PDFResourceManager()
device = PDFPageAggregator(rsrcmgr, laparams=LAParams())
interpreter = PDFPageInterpreter(rsrcmgr, device)
extracted_text = ''
for page in doc.get_pages():
interpreter.process_page(page)
layout = device.get_result()
for lt_obj in layout:
if isinstance(lt_obj, LTTextBox) or isinstance(lt_obj, LTTextLine):
extracted_text += lt_obj.get_text()
return extracted_text
def pdfextract(pdfbin):
cin = StringIO.StringIO()
cin.write(pdfbin)
cin.seek(0)
parser = PDFParser(cin)
doc = PDFDocument()
parser.set_document(doc)
try:
doc.set_parser(parser)
except PDFSyntaxError, e:
return [{
"npage": npage,
"x0": 0,
"y0": 0,
"x1": 0.099,
"y1": 0.099,
"val": "SyntaxError " + str(e)
}]
