PDF Parsing and Text Extraction

Let's begin by unlocking the secrets of PDF parsing and text extraction. Have you ever found yourself needing to pull out useful information from a PDF? Fear not, for Python has the solution! With powerful libraries such as PyPDF2, FPDF, and ReportLab, you can easily parse PDF files and extract the textual content.

Here’s a brief overview of these libraries:

• PyPDF2: This library excels at managing PDF files with features like merging, splitting, rotating, extracting text, and adding watermarks. It’s user-friendly and versatile for various PDF operations.
• FPDF: A straightforward library designed for creating PDF documents, FPDF allows you to generate PDFs containing text, images, tables, and more using Python code.
• ReportLab: A robust library ideal for crafting complex PDF documents, ReportLab supports a variety of layouts and styles, making it suitable for generating professional reports and data visualizations.

To get started, make sure to install the necessary modules:

pip install PyPDF2 FPDF reportlab

Important Note: When working with the PyPDF2 library, be aware that certain classes will be deprecated in version 3.0.0. It's advisable to transition to the new classes: PdfReader, PdfWriter, and PdfMerger.

Here’s an example of how to extract text from a PDF:

import PyPDF2

# Open the PDF file

with open('example.pdf', 'rb') as file:

reader = PyPDF2.PdfReader(file)

num_pages = len(reader.pages)

# Extract text page by page

for page_num in range(num_pages):

page = reader.pages[page_num]

text = page.extract_text()

print(text)

Now you can extract text from PDFs like a seasoned detective! Give it a shot!

Merging and Splitting PDFs

Next, let’s explore how to merge and split PDF files. If you have multiple PDFs, you can easily combine them into one neat document, or break a larger file into smaller segments. Here’s a fun snippet to demonstrate:

from PyPDF2 import PdfMerger, PdfReader, PdfWriter

# Create a PDF merger

merger = PdfMerger()

# Merge multiple PDF files

merger.append('example.pdf')

merger.append('file2.pdf')

# Save the merged file

merger.write('merged.pdf')

merger.close()

# Split a PDF file

with open('merged.pdf', 'rb') as file:

reader = PdfReader(file)

num_pages = len(reader.pages)

for start in range(0, num_pages, 10):

end = min(start + 9, num_pages - 1)

writer = PdfWriter()

for page_num in range(start, end + 1):

writer.add_page(reader.pages[page_num])

with open(f'part_{start + 1}-{end + 1}.pdf', 'wb') as output_file:

writer.write(output_file)

print("The merging and splitting magic is complete!")

PDF Form Processing

Our third skill is handling PDF forms. Filling out numerous PDF forms can be tedious, but with Python’s help, you can automate this process! Libraries such as PyPDF2, pdfw, and FPDF make it easy to fill in form fields and generate new PDF forms.

Here’s how to automatically fill out a form:

from PyPDF2 import PdfReader, PdfWriter

from reportlab.pdfgen import canvas

def fill_form(input_file, output_file, data):

c = canvas.Canvas(output_file)

c.setFont("Helvetica", 12)

reader = PdfReader(input_file)

for page_num, page in enumerate(reader.pages, start=1):

page_width = float(page.mediabox.width)

page_height = float(page.mediabox.height)

c.setPageSize((page_width, page_height))

c.showPage()

if '/Annots' in page:

for annot in page['/Annots']:

if '/T' in annot and '/V' in annot and annot['/Type'] == '/Annot':

field_name = annot['/T'][1:-1] # Get field name

if field_name in data:

field_value = data[field_name]

c.drawString(annot['/Rect'][0], annot['/Rect'][1], field_value)

c.save()

# Example usage

data = {'name': 'Joe', 'age': '18'}

fill_form('form_template.pdf', 'filled_form.pdf', data)

print("Form processing magic completed!")

Now you’re a wizard at managing forms!

PDF Document Conversion

Moving on, let’s talk about converting PDF documents to other formats like images, HTML, or plain text. When a PDF isn’t in a convenient format, conversion can be a lifesaver!

Here’s how to convert a PDF to images using the pdf2image library:

from pdf2image import convert_from_path

def pdf_to_image(input_file, output_file):

images = convert_from_path(input_file)

for i, image in enumerate(images):

image.save(f'{output_file}_{i}.jpg', 'JPEG')

pdf_to_image('input.pdf', 'output_image')

For PDF to HTML conversion, you can use PyPDF2 as follows:

from PyPDF2 import PdfReader

def pdf_to_html(input_file, output_file):

with open(input_file, 'rb') as file:

reader = PdfReader(file)

text = ""

for page in reader.pages:

text += page.extract_text()

with open(output_file, 'w') as html_file:

html_file.write(f"{text}")

pdf_to_html('input.pdf', 'output.html')

And for plain text conversion, pdfminer.six is your go-to:

from pdfminer.high_level import extract_text_to_fp

def pdf_to_text(input_file, output_file):

with open(output_file, 'w') as text_file:

with open(input_file, 'rb') as file:

extract_text_to_fp(file, text_file)

pdf_to_text('input.pdf', 'output.txt')

PDF Watermarking and Signing

Next, let’s enhance our PDFs with watermarks and digital signatures. This not only adds a layer of copyright protection but also secures your documents.

Here’s how to add a watermark:

from PyPDF2 import PdfReader, PdfWriter

from reportlab.pdfgen import canvas

import io

def add_watermark(input_file, output_file, watermark_text):

reader = PdfReader(input_file)

writer = PdfWriter()

watermark_buffer = io.BytesIO()

c = canvas.Canvas(watermark_buffer)

c.setFont("Helvetica", 48)

c.rotate(45)

c.translate(-500, -500)

c.setFillAlpha(0.3)

c.drawString(400, 400, watermark_text)

c.save()

watermark_buffer.seek(0)

watermark_pdf = PdfReader(watermark_buffer)

for page in reader.pages:

watermark_page = watermark_pdf.pages[0]

page.merge_page(watermark_page)

writer.add_page(page)

with open(output_file, 'wb') as file:

writer.write(file)

add_watermark('example.pdf', 'watermarked.pdf', 'Confidential')

print("Watermark added successfully!")

PDF Report Generation

Finally, we arrive at generating reports in PDF format. Imagine using Python to create stunning reports filled with charts, tables, and textual information.

Here’s a simple example:

import matplotlib.pyplot as plt

from reportlab.lib.pagesizes import A4

from reportlab.platypus import SimpleDocTemplate, Table, Image

from reportlab.lib.styles import getSampleStyleSheet

from reportlab.platypus import Paragraph, Spacer

def create_report(output_file, data):

doc = SimpleDocTemplate(output_file, pagesize=A4)

styles = getSampleStyleSheet()

elements = []

title = Paragraph("Sales Report", styles["Title"])

elements.append(title)

elements.append(Spacer(1, 20))

table = Table(data)

elements.append(table)

elements.append(Spacer(1, 20))

plt.plot(data[1][1:], marker='o')

plt.xlabel("Date")

plt.ylabel("Sales Revenue")

plt.title("Sales Trend Chart")

plt.savefig("sales_plot.png")

plt.close()

image = Image("sales_plot.png", width=400, height=300)

elements.append(image)

doc.build(elements)

report_data = [["Date", "Sales Revenue"], ["1/1", 100], ["1/2", 200], ["1/3", 150], ["1/4", 300]]

create_report('sales_report.pdf', report_data)

print("Report generation completed!")

OCR (Optical Character Recognition)

Lastly, let’s delve into Optical Character Recognition (OCR). If you have scanned PDF documents, Python can assist you in converting those images into editable text.

Here’s how:

import pdf2image

import pytesseract

def pdf_to_image(input_file):

images = pdf2image.convert_from_path(input_file)

return images

def image_to_text(image):

text = pytesseract.image_to_string(image)

return text

def extract_text_from_pdf(input_file, output_file):

images = pdf_to_image(input_file)

extracted_text = ""

for image in images:

text = image_to_text(image)

extracted_text += text + "n"

with open(output_file, 'w', encoding='utf-8') as file:

file.write(extracted_text)

extract_text_from_pdf('scanned_document.pdf', 'extracted_text.txt')

print("OCR magic completed! Your scanned PDFs are now editable!")