Skip to main content

Cookbook

This page provides complete, copy-paste ready examples for common PDF manipulation scenarios.

Creating a New PDF​

Create PDF from Scratch​

from pdfdancer import PDFDancer, Color

def create_new_pdf(output_path: str) -> None:
    """Create a new PDF with multiple pages and content."""
    # Create a new blank PDF with Letter size pages (612 x 792 points)
    pdf = PDFDancer.new(page_size={"width": 612, "height": 792})

    # Add title on first page
    pdf.new_paragraph() \
        .text("Sample Document") \
        .font("Helvetica-Bold", 24) \
        .color(Color(0, 0, 128)) \
        .at(page_number=1, x=100, y=720) \
        .add()

    # Add body text
    pdf.new_paragraph() \
        .text("This is a new PDF document created from scratch.") \
        .font("Helvetica", 12) \
        .color(Color(0, 0, 0)) \
        .at(page_number=1, x=100, y=680) \
        .add()

    # Add a second page
    pdf.new_page().page_size({"width": 612, "height": 792}).add()

    # Add content to second page
    pdf.new_paragraph() \
        .text("Page 2 Content") \
        .font("Helvetica-Bold", 18) \
        .color(Color(0, 0, 0)) \
        .at(page_number=1, x=100, y=720) \
        .add()

    # Add footer on both pages
    for page_num in range(2):
        pdf.new_paragraph() \
            .text(f"Page {page_num + 1} of 2") \
            .font("Helvetica", 10) \
            .color(Color(128, 128, 128)) \
            .at(page_number=page_num, x=280, y=30) \
            .add()

    pdf.save(output_path)


# Usage
create_new_pdf("output/new_document.pdf")

Invoice Processing​

Mark Invoice as Paid​

from pathlib import Path
from pdfdancer import PDFDancer, Color

def mark_invoice_paid(input_path: str, output_path: str, invoice_number: str) -> None:
    """Mark an invoice as paid with a green stamp."""
    with PDFDancer.open(input_path) as pdf:
        # Find the invoice number paragraph
        invoice_paras = pdf.select_paragraphs_starting_with(f"Invoice #{invoice_number}")

        if invoice_paras:
            # Update status to PAID
            invoice_paras[0].edit() \
                .replace(f"Invoice #{invoice_number} - PAID") \
                .color(Color(0, 128, 0)) \
                .apply()

        # Add large PAID watermark
        pdf.new_paragraph() \
            .text("PAID") \
            .font("Helvetica-Bold", 72) \
            .color(Color(0, 200, 0, alpha=0.3)) \
            .at(page_number=1, x=180, y=400) \
            .add()

        # Add payment date
        from datetime import datetime
        pdf.new_paragraph() \
            .text(f"Paid: {datetime.now().strftime('%Y-%m-%d')}") \
            .font("Helvetica", 10) \
            .color(Color(0, 128, 0)) \
            .at(page_number=1, x=400, y=50) \
            .add()

        pdf.save(output_path)


# Usage
mark_invoice_paid(
    "invoices/INV-001.pdf",
    "invoices/paid/INV-001.pdf",
    "001"
)

Form Filling​

Complete Contract Form​

from pdfdancer import PDFDancer
from dataclasses import dataclass
from typing import Dict

@dataclass
class ContractData:
    client_name: str
    client_email: str
    client_address: str
    start_date: str
    end_date: str
    total_amount: str


def fill_contract_form(
    template_path: str,
    output_path: str,
    contract_data: ContractData
) -> None:
    """Fill a contract template with client data."""
    with PDFDancer.open(template_path) as pdf:
        # Define field mappings
        field_mapping = {
            "clientName": contract_data.client_name,
            "clientEmail": contract_data.client_email,
            "clientAddress": contract_data.client_address,
            "startDate": contract_data.start_date,
            "endDate": contract_data.end_date,
            "totalAmount": contract_data.total_amount
        }

        # Fill all fields
        for field_name, value in field_mapping.items():
            fields = pdf.select_form_fields_by_name(field_name)
            if fields:
                fields[0].edit().value(value).apply()
                print(f"Filled {field_name}: {value}")

        # Add signature image
        pdf.new_image() \
            .from_file("signatures/company_signature.png") \
            .at(page=1, x=400, y=100) \
            .add()

        pdf.save(output_path)


# Usage
contract = ContractData(
    client_name="Acme Corporation",
    client_email="contact@acme.com",
    client_address="123 Business St, City, State 12345",
    start_date="2024-01-01",
    end_date="2024-12-31",
    total_amount="$50,000"
)

fill_contract_form(
    "templates/contract_template.pdf",
    "contracts/acme_contract.pdf",
    contract
)

Document Redaction​

Redact Sensitive Information​

from pdfdancer import PDFDancer, Color
import re

def redact_document(input_path: str, output_path: str) -> None:
    """Redact sensitive information from a document."""
    # Patterns to redact
    patterns = {
        "SSN": r"\d{3}-\d{2}-\d{4}",
        "Email": r"[\w\.-]+@[\w\.-]+\.\w+",
        "Phone": r"\(\d{3}\)\s*\d{3}-\d{4}",
        "Credit Card": r"\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}"
    }

    with PDFDancer.open(input_path) as pdf:
        all_paragraphs = pdf.select_paragraphs()
        redaction_count = 0

        for paragraph in all_paragraphs:
            text = paragraph.text
            redacted = False

            # Check each pattern
            for pattern_name, pattern in patterns.items():
                if re.search(pattern, text):
                    # Replace entire paragraph with [REDACTED]
                    paragraph.edit() \
                        .replace("[REDACTED]") \
                        .color(Color(0, 0, 0)) \
                        .font("Helvetica-Bold", 12) \
                        .apply()

                    redaction_count += 1
                    print(f"Redacted {pattern_name} in paragraph")
                    redacted = True
                    break

        # Add redaction notice
        pdf.new_paragraph() \
            .text(f"This document contains {redaction_count} redaction(s)") \
            .font("Helvetica", 8) \
            .color(Color(128, 128, 128)) \
            .at(page_number=1, x=50, y=30) \
            .add()

        pdf.save(output_path)


# Usage
redact_document(
    "documents/confidential.pdf",
    "documents/redacted/confidential_redacted.pdf"
)

Report Generation​

Generate Monthly Report​

from pdfdancer import PDFDancer, Color
from datetime import datetime
from typing import List, Dict

def generate_monthly_report(
    template_path: str,
    output_path: str,
    report_data: Dict,
    charts: List[str]
) -> None:
    """Generate a monthly report from template."""
    with PDFDancer.open(template_path) as pdf:
        # Add report header
        pdf.new_paragraph() \
            .text(f"Monthly Report - {report_data['month']} {report_data['year']}") \
            .font("Helvetica-Bold", 20) \
            .color(Color(0, 0, 128)) \
            .at(page_number=1, x=100, y=750) \
            .add()

        # Add summary stats
        y_position = 680
        for key, value in report_data['stats'].items():
            pdf.new_paragraph() \
                .text(f"{key}: {value}") \
                .font("Helvetica", 12) \
                .at(page_number=1, x=100, y=y_position) \
                .add()
            y_position -= 25

        # Add charts
        chart_y = 500
        for i, chart_path in enumerate(charts):
            pdf.new_image() \
                .from_file(chart_path) \
                .at(page=1, x=100, y=chart_y - (i * 150)) \
                .add()

        # Add footer
        pdf.new_paragraph() \
            .text(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}") \
            .font("Helvetica", 8) \
            .color(Color(128, 128, 128)) \
            .at(page_number=1, x=250, y=30) \
            .add()

        pdf.save(output_path)


# Usage
report_data = {
    'month': 'January',
    'year': 2024,
    'stats': {
        'Total Sales': '$125,000',
        'New Customers': '47',
        'Revenue Growth': '+15%'
    }
}

generate_monthly_report(
    'templates/report_template.pdf',
    'reports/2024-01.pdf',
    report_data,
    ['charts/sales.png', 'charts/customers.png']
)

Watermarking​

Add Confidential Watermark​

from pdfdancer import PDFDancer, Color

def add_watermark(input_path: str, output_path: str, watermark_text: str) -> None:
    """Add a diagonal watermark to all pages."""
    with PDFDancer.open(input_path) as pdf:
        pages = pdf.pages()

        for i, page in enumerate(pages):
            # Add semi-transparent watermark text
            pdf.new_paragraph() \
                .text(watermark_text) \
                .font("Helvetica-Bold", 60) \
                .color(Color(200, 200, 200)) \
                .at(page_number=i, x=150, y=400) \
                .add()

        pdf.save(output_path)


# Usage
add_watermark(
    "documents/report.pdf",
    "documents/watermarked/report.pdf",
    "CONFIDENTIAL"
)

Next Steps​