DEV Community: Jeremy K.

Changing PDF Page Size with Python

Jeremy K. — Tue, 27 Oct 2026 07:06:00 +0000

In practice, a PDF's page size often determines whether it prints cleanly, archives correctly, or embeds smoothly in another system. A report designed for A3 may need to be reduced to A4 for distribution, or scanned pages may need to be standardized to a custom size. Adjusting pages one by one is slow and error-prone; a Python script is a more reliable way to handle the job in batch.

Free Spire.PDF for Python is a lightweight, capable tool for this task. It has a small footprint and a straightforward API, which makes it well-suited to page-level restructuring. Below, we cover several common ways to change PDF page size with it, from the underlying idea to working code.

Prerequisites

Install it with pip:

pip install spire.pdf.free

The free version limits the number of pages per document (usually to 10 or fewer), so it is best suited to small jobs and proofs of concept.

Core Idea: Why You Can't Just "Change the Size"

PDF page size (MediaBox) is technically an editable property, but changing it in place will throw off text and images that were laid out for the old dimensions. Content may become misaligned or even clipped. A more reliable approach is to rebuild each page:

Load the original document and create a page template for each page, capturing a snapshot of all its content.
Create a new document with blank pages at the target size.
Draw the template onto the new page, using drawing coordinates and a scaling layout to fit the content.
Save the new document and release resources.

Free Spire.PDF's PdfPageBase.CreateTemplate() and PdfTemplate.Draw() are designed for exactly this workflow. The same logic works whether the target size is larger, smaller, or has a different aspect ratio.

Scenario 1: Change to Standard Paper Sizes (A3, B4, Letter, etc.)

Free Spire.PDF includes enums for common standard paper sizes, such as PdfPageSize.A3(), PdfPageSize.B4(), and PdfPageSize.Letter(). The following code converts every page of a PDF to B4:

from spire.pdf.common import *
from spire.pdf import *

input_file = "source.pdf"
output_file = "resized_b4.pdf"

original_pdf = PdfDocument()
original_pdf.LoadFromFile(input_file)

new_pdf = PdfDocument()

for i in range(original_pdf.Pages.Count):
    page = original_pdf.Pages.get_Item(i)

    # Create a new B4-sized page with zero margins to avoid extra whitespace
    new_page = new_pdf.Pages.Add(PdfPageSize.B4(), PdfMargins(0.0))

    # Key: set the text layout to OnePage so the original content is scaled
    # as a whole to fit the new page
    layout = PdfTextLayout()
    layout.Layout = PdfLayoutType.OnePage

    template = page.CreateTemplate()
    template.Draw(new_page, PointF.Empty(), layout)

new_pdf.SaveToFile(output_file)
new_pdf.Close()
original_pdf.Close()

The important setting here is PdfLayoutType.OnePage. Without it, content is drawn at its original scale, and anything beyond the new page bounds is clipped rather than automatically scaled. With it, the template is scaled to fit the available area of the new page, keeping the content fully visible.

Scenario 2: Custom Sizes (Millimeters, Inches, or Any Other Unit)

Real-world targets are rarely standard paper sizes. A print job might call for 200 mm × 280 mm, or a system might require pages to be 6 × 9 inches. Free Spire.PDF uses points (1 point = 1/72 inch). Use PdfUnitConvertor to convert physical units to points, then create a SizeF:

from spire.pdf.common import *
from spire.pdf import *

input_file = "source.pdf"
output_file = "custom_size.pdf"

# Target size: 200 mm × 280 mm
converter = PdfUnitConvertor()
width_pt = converter.ConvertUnits(200, PdfGraphicsUnit.Millimeter, PdfGraphicsUnit.Point)
height_pt = converter.ConvertUnits(280, PdfGraphicsUnit.Millimeter, PdfGraphicsUnit.Point)

original_pdf = PdfDocument()
original_pdf.LoadFromFile(input_file)

new_pdf = PdfDocument()

for i in range(original_pdf.Pages.Count):
    page = original_pdf.Pages.get_Item(i)

    new_page = new_pdf.Pages.Add(SizeF(width_pt, height_pt), PdfMargins(0.0))

    layout = PdfTextLayout()
    layout.Layout = PdfLayoutType.OnePage

    template = page.CreateTemplate()
    template.Draw(new_page, PointF.Empty(), layout)

new_pdf.SaveToFile(output_file)
new_pdf.Close()
original_pdf.Close()

The first argument of ConvertUnits is the value, the second is the source unit, and the third is the target unit. Supported units include Millimeter, Inch, Pixel, Point, and others. If you are unsure of the original page size, read it first for reference:

page = original_pdf.Pages[0]
print(f"Original page size: {page.Size.Width} × {page.Size.Height} points")

Scenario 3: Proportional Scaling (Enlarge or Shrink)

Sometimes you don't have a fixed target size; you just want to enlarge everything by 1.2x or shrink it to 80%. In that case, multiply the original dimensions by a factor—simpler than the previous two approaches:

from spire.pdf.common import *
from spire.pdf import *

input_file = "source.pdf"
output_file = "scaled_120.pdf"

scale = 1.2

original_pdf = PdfDocument()
original_pdf.LoadFromFile(input_file)

new_pdf = PdfDocument()

for i in range(original_pdf.Pages.Count):
    page = original_pdf.Pages.get_Item(i)

    new_width = float(page.Size.Width * scale)
    new_height = float(page.Size.Height * scale)
    new_page = new_pdf.Pages.Add(SizeF(new_width, new_height), PdfMargins(0.0))

    layout = PdfTextLayout()
    layout.Layout = PdfLayoutType.OnePage

    template = page.CreateTemplate()
    template.Draw(new_page, PointF.Empty(), layout)

new_pdf.SaveToFile(output_file)
new_pdf.Close()
original_pdf.Close()

With proportional scaling, the aspect ratio stays the same, so content is not stretched or distorted. PdfLayoutType.OnePage mainly acts as a safeguard here: even if one page's original size differs slightly from the others, the content still fits fully into the new page.

Summary

Redrawing pages through templates is a stable, reliable way to resize PDFs, especially for batch normalization. The core workflow is four steps: read the original page → create a template → create a new page → draw the template onto it. From there, you can adjust the scaling logic, margins, and alignment to fit your needs.

Converting JSON Data to Word Documents with Python

Jeremy K. — Mon, 19 Oct 2026 05:48:32 +0000

JSON is a common format for exchanging data between machines. Word documents, by contrast, are designed for people to read. Converting one to the other is therefore not simply a “format conversion” but a structural mapping problem: JSON key-value pairs, arrays, and nested objects must be translated into human-readable document elements such as paragraphs, tables, and headings.

This article shows how to implement JSON-to-Word conversion with Free Spire.Doc for Python, a free library suitable for learning and lightweight automation.

Environment Setup

Free Spire.Doc for Python is a standalone Word document processing library. It does not require Microsoft Word to create or edit DOCX files. Install the free version with pip:

pip install Spire.Doc.Free

Before using it, note the free version’s capacity limits: a single document can contain at most 500 paragraphs and 25 tables, and content beyond that is truncated. This is sufficient for routine report generation, API data snapshots, and small-to-medium ledgers. If a single output will consistently exceed this scale, consider splitting the data or using another solution.

Understanding the core object hierarchy is essential for all the code that follows:

Document → Section → Paragraph → TextRange
                  ↘ Table → Row → Cell → Paragraph

Document is the root document object.
Section holds page-level settings.
Paragraph is the text container.
TextRange controls formatting for a continuous run of text within a paragraph.

Mapping Principle: JSON Structure Determines Word Form

The same JSON can produce very different Word documents. Defining the mapping rules before writing code is more reliable than adjusting the output while coding. Common correspondences are:

JSON Structure	Word Element	Typical Use Case
Key-value pairs in a flat object	Paragraph (`key: value`)	Configuration notes, personal cards, API snapshots
Array of objects	Table (keys → column headers; objects → rows)	Employee lists, orders, inventory
Nested object	Heading + indented paragraphs (recursive)	Structured reports, hierarchical summaries
Image path field	Inline image	Logos, avatars, chart snapshots

The examples below progress from flat objects → object arrays → nested objects, with a runnable snippet for each scenario.

Scenario 1: Flat Object → Key-Value Paragraphs

This is the simplest mapping: each key-value pair becomes one paragraph. It works well for data with a fixed structure and a small number of fields.

import json
from spire.doc import Document, FileFormat, HorizontalAlignment
from spire.doc.common import *

json_str = '{"Project": "Data Pipeline", "Owner": "Zhang Wei", "Status": "In Progress", "Start Date": "2025-03-01"}'
data = json.loads(json_str)

doc = Document()
section = doc.AddSection()

title = section.AddParagraph()
title.AppendText("Project Information").CharacterFormat.Bold = True
title.Format.HorizontalAlignment = HorizontalAlignment.Center

for key, value in data.items():
    para = section.AddParagraph()
    para.AppendText(f"{key}: {value}").CharacterFormat.FontSize = 12
    para.Format.AfterSpacing = 6

doc.SaveToFile("flat_object.docx", FileFormat.Docx)
doc.Close()

AppendText returns a TextRange object. Character-level formatting such as font, size, and bold is set through it. Paragraph-level spacing and alignment are set through paragraph.Format. The same formatting approach also applies inside table cells.

Scenario 2: Array of Objects → Word Table

An array of objects maps naturally to table rows, with column headers derived from the record keys. However, do not assume that every record has exactly the same keys. Real API responses often omit optional fields, and direct access with record[key] can cause the entire batch conversion to fail because of a single record.

A more robust approach is to scan all records first and collect the union of their keys as column headers:

import json
from spire.doc import (
    Document, FileFormat, HorizontalAlignment, VerticalAlignment,
    TableRowHeightType, Color
)
from spire.doc.common import *

records = [
    {"Product": "Laptop", "Unit Price": 6999, "Stock": 45},
    {"Product": "Wireless Mouse", "Unit Price": 199, "Stock": 200},
    {"Product": "Mechanical Keyboard", "Unit Price": 549, "Stock": 120},
]

# Collect the union of keys so records with different fields are supported
all_keys = []
for record in records:
    for key in record:
        if key not in all_keys:
            all_keys.append(key)

doc = Document()
section = doc.AddSection()

table = section.AddTable(True)
table.ResetCells(len(records) + 1, len(all_keys))

# Header row
header_row = table.Rows[0]
header_row.IsHeader = True
header_row.Height = 24
header_row.HeightType = TableRowHeightType.Exactly

for col, key in enumerate(all_keys):
    cell = header_row.Cells[col]
    cell.CellFormat.BackColor = Color.get_Gray()
    cell.CellFormat.VerticalAlignment = VerticalAlignment.Middle
    p = cell.AddParagraph()
    p.Format.HorizontalAlignment = HorizontalAlignment.Center
    tr = p.AppendText(key)
    tr.CharacterFormat.Bold = True
    tr.CharacterFormat.FontSize = 11

# Data rows
for row_idx, record in enumerate(records, start=1):
    row = table.Rows[row_idx]
    row.Height = 22
    row.HeightType = TableRowHeightType.Exactly
    for col, key in enumerate(all_keys):
        cell = row.Cells[col]
        cell.CellFormat.VerticalAlignment = VerticalAlignment.Middle
        p = cell.AddParagraph()
        p.Format.HorizontalAlignment = HorizontalAlignment.Center
        p.AppendText(str(record.get(key, "—")))

doc.SaveToFile("array_table.docx", FileFormat.Docx)
doc.Close()

Two details are critical:

The row count passed to ResetCells is len(records) + 1, not len(records), because the header row also occupies a row.
Use record.get(key, "—") instead of subscript access. The placeholder keeps the number of columns consistent and prevents a single missing field from crashing the entire script.

Scenario 3: Nested Object → Recursive Heading Structure

Nested JSON represents hierarchical relationships and should not be forced into a two-dimensional table. Use recursive traversal with a level parameter to control indentation and font size, creating a clear visual hierarchy:

from spire.doc import Document, FileFormat
from spire.doc.common import *

def add_nested(section, obj, level=0):
    if isinstance(obj, dict):
        for key, value in obj.items():
            if isinstance(value, (dict, list)):
                heading = section.AddParagraph()
                tr = heading.AppendText(str(key))
                tr.CharacterFormat.Bold = True
                tr.CharacterFormat.FontSize = max(14 - level * 2, 10)
                heading.Format.SetLeftIndent(level * 18)
                add_nested(section, value, level + 1)
            else:
                para = section.AddParagraph()
                para.Format.SetLeftIndent(level * 18)
                tr = para.AppendText(f"{key}: {value}")
                tr.CharacterFormat.FontSize = max(12 - level, 10)
    elif isinstance(obj, list):
        for item in obj:
            add_nested(section, item, level)

nested = {
    "Report": {
        "Title": "Quarterly Operations Summary",
        "Period": "2025 Q2",
        "Metrics": {"Revenue": "5.8 million", "YoY": "+12%"},
        "Notes": "All regions achieved positive growth"
    }
}

doc = Document()
section = doc.AddSection()
add_nested(section, nested)
doc.SaveToFile("nested_report.docx", FileFormat.Docx)
doc.Close()

The recursive approach is depth-agnostic: whether the data is nested two levels or five levels, the logic remains the same. Keep the free version’s 500-paragraph limit in mind, however. Deeply nested structures or very large datasets can quickly consume the paragraph quota, so estimate the output size before using this in production.

Additional: Image Fields in JSON

If the JSON contains an image path, such as "logo": "images/logo.png", insert the image at the appropriate position with AppendPicture. Use Width and Height to control the display size in points:

from spire.doc import Paragraph

para = section.AddParagraph()
pic = para.AppendPicture("images/logo.png")
pic.Width = 80
pic.Height = 50

If the image belongs inside a table cell, attach AppendPicture to the paragraph returned by cell.AddParagraph(), just as you would for a normal text paragraph.

Conclusion

The key to converting JSON to Word is not the library itself, but deciding which layer of the data structure should map to which document element: key-value pairs become paragraphs, record collections become tables, and hierarchical relationships become recursive headings.

Once the mapping rules are defined, the Document → Section → Paragraph / Table object model provided by Free Spire.Doc is direct enough to apply those rules to a DOCX file.

Extracting Excel Worksheet Names with Python

Jeremy K. — Mon, 12 Oct 2026 08:43:08 +0000

When working with Excel files in data engineering or office automation, it is often useful to inspect the workbook structure before reading data. Knowing the worksheet names helps you locate the right data, process multiple sheets in batch, or validate file contents. This guide shows how to retrieve worksheet names using Free Spire.XLS for Python.

Install Free Spire.XLS for Python

pip install Spire.Xls.Free

The library supports both .xls (Excel 97-2003) and .xlsx (Excel 2007+) formats. Microsoft Office is not required.

Get All Worksheet Names

The core API is straightforward:

Workbook.Worksheets returns the worksheet collection.
Each Worksheet object exposes its name through the .Name property.

from spire.xls import *
from spire.xls.common import *

workbook = Workbook()
workbook.LoadFromFile("test.xlsx")

names = [sheet.Name for sheet in workbook.Worksheets]
print(names)  # e.g., ['Report', 'Target Comparison', 'Actual Completion', 'Summary', 'Remarks']

workbook.Dispose()

Worksheets includes all sheets in the workbook, including hidden ones.

Get Only Hidden Worksheet Names

In some cases, you may need to handle hidden worksheets separately, such as when auditing a workbook or recovering accidentally hidden sheets. Use Worksheet.Visibility and compare it with WorksheetVisibility.Hidden.

from spire.xls import *
from spire.xls.common import *

workbook = Workbook()
workbook.LoadFromFile("test.xlsx")

hidden_names = [
    sheet.Name
    for sheet in workbook.Worksheets
    if sheet.Visibility == WorksheetVisibility.Hidden
]

print(hidden_names)  # e.g., ['Summary', 'Remarks']

workbook.Dispose()

Free Version Limitations

Free Spire.XLS for Python is sufficient for basic operations such as reading worksheet names. However, its free version has limits:

For .xls files, each workbook supports up to 5 worksheets, and each worksheet supports up to 200 rows.
For .xlsx files, this limitation does not apply.

For large workbooks with many worksheets, prefer the .xlsx format.

Resource Cleanup

After using a Workbook object, call workbook.Dispose() to release memory. This is especially important when processing multiple files.

For safer cleanup, use try/finally:

workbook = Workbook()
try:
    workbook.LoadFromFile("test.xlsx")
    names = [sheet.Name for sheet in workbook.Worksheets]
    print(names)
finally:
    workbook.Dispose()

Comparison with Other Options

Option	How to get sheet names	Install footprint	Requires Office?
Free Spire.XLS	`[sheet.Name for sheet in workbook.Worksheets]`	Medium	No
openpyxl	`wb.sheetnames`	Lightweight	No
pandas	`pd.ExcelFile(path).sheet_names`	Heavier (includes numpy dependency)	No

When to use which

pandas: Best if your project already uses pandas for data analysis.
openpyxl: A good lightweight choice when you only need to read sheet names.
Free Spire.XLS: Useful when you also need read/write and formatting operations. If you later need to rename, copy, or format worksheets, you can continue using the same API and avoid switching dependencies.

Key APIs

API	Purpose
`Workbook.Worksheets`	Access all worksheets in the workbook
`Worksheet.Name`	Get a worksheet name
`Worksheet.Visibility`	Check whether a worksheet is hidden
`WorksheetVisibility.Hidden`	Enum value for hidden worksheets

Summary

Extracting Excel worksheet names is a lightweight but frequent task. Free Spire.XLS for Python covers two common needs with minimal code:

Get all sheet names using Worksheet.Name
Filter hidden sheet names using Worksheet.Visibility

In real projects, choose the tool that best fits your existing Excel workflow to avoid unnecessary dependencies.

Import Multiple CSVs into One Excel Workbook with Python

Jeremy K. — Tue, 29 Sep 2026 07:15:27 +0000

In daily data processing, you often need to combine a set of CSV files into a single Excel workbook—one worksheet per CSV—so they are easier to review and share. Python’s built-in csv module can read the data, but writing each file to a separate Excel sheet requires extra logic. With Free Spire.XLS for Python, you can load a CSV directly as a workbook object and copy its worksheet into a target workbook with very little code.

Prerequisites

Install the free library via pip. It supports Python 3.6+ on Windows, macOS, and Linux:

pip install Spire.Xls.Free

Free Spire.XLS for Python does not require Microsoft Excel, so it works on servers and in headless environments.

Note that the free version limits .xls files to 5 worksheets per workbook and 200 rows per worksheet. These limits do not apply to .xlsx, so use .xlsx for larger or more numerous sheets.

Key Steps

Create a target Workbook.
For each CSV file, load it into a temporary Workbook with LoadFromFile().
Copy its first worksheet into the target workbook using AddCopy().
Rename the copied sheet safely.
Save the target workbook as .xlsx.

AddCopy() copies both data and formatting. Passing WorksheetCopyType.CopyAll ensures the entire worksheet is preserved.

Complete Code

The following Python script merges all CSV files in a directory into one Excel workbook. It also handles invalid worksheet names and duplicate names automatically.

import os
import glob
import re
from spire.xls import *
from spire.xls.common import *

INVALID_SHEET_CHARS = re.compile(r'[\\/?*\[\]:]')

def safe_sheet_name(name, max_len=31):
    """Return a valid Excel worksheet name."""
    name = INVALID_SHEET_CHARS.sub('_', name)
    name = name[:max_len].strip()
    return name or "Sheet"

def unique_sheet_name(workbook, base_name):
    """Return a worksheet name that is unique in the workbook."""
    existing = {workbook.Worksheets[i].Name for i in range(workbook.Worksheets.Count)}
    name = safe_sheet_name(base_name)
    if name not in existing:
        return name

    i = 1
    while True:
        suffix = f"_{i}"
        candidate = safe_sheet_name(base_name[:31 - len(suffix)] + suffix)
        if candidate not in existing:
            return candidate
        i += 1

def merge_csv_to_excel(csv_dir, output_path, delimiter=","):
    csv_files = glob.glob(os.path.join(csv_dir, "*.csv"))
    if not csv_files:
        print("No CSV files found.")
        return

    target_book = Workbook()
    try:
        # Remove default worksheets so only imported sheets remain.
        while target_book.Worksheets.Count > 0:
            target_book.Worksheets.RemoveAt(0)

        for file_path in csv_files:
            file_name = os.path.splitext(os.path.basename(file_path))[0]

            source_book = Workbook()
            try:
                source_book.LoadFromFile(file_path, delimiter, 1, 1)
                source_sheet = source_book.Worksheets[0]

                new_name = unique_sheet_name(target_book, file_name)
                target_book.Worksheets.AddCopy(source_sheet, WorksheetCopyType.CopyAll)
                new_sheet = target_book.Worksheets[target_book.Worksheets.Count - 1]
                new_sheet.Name = new_name

                print(f"Imported: {file_name}")
            finally:
                source_book.Dispose()

        target_book.SaveToFile(output_path, FileFormat.Version2016)
        print(f"\nMerge completed: {output_path}")
    finally:
        target_book.Dispose()

if __name__ == "__main__":
    merge_csv_to_excel(
        csv_dir="./csv_files",
        output_path="./merged_output.xlsx",
        delimiter=","
    )

Key Points

LoadFromFile parameters

LoadFromFile(fileName, separator, startRow, startColumn) lets you specify the delimiter and starting cell. For TSV files, pass "\t"; for semicolon-separated files, pass ";".
Worksheet naming

Excel worksheet names are limited to 31 characters and cannot contain \ / ? * [ ] :. The code above replaces invalid characters and truncates long names. It also ensures duplicate names do not occur.
Default worksheets

A new Workbook() normally contains three blank sheets. The code removes them before importing, so the final workbook contains only the imported sheets. If your library version errors when AddCopy is called on an empty collection, keep one temporary sheet, perform the first copy, then delete the temporary sheet.
Non-UTF-8 CSVs

If a CSV uses an encoding such as GBK, LoadFromFile may not parse it correctly. In that case, transcode the file to UTF-8 first (for example, with Python’s csv module) or check whether your library version supports specifying an encoding.
Resource cleanup

Source workbooks are disposed after each import, and the target workbook is disposed in a finally block to avoid file locks and memory leaks.

Conclusion

This script is well suited for lightweight automation where scattered CSV files need to be collected into a single Excel workbook, one sheet per file. Free Spire.XLS for Python runs without an Office installation and provides a concise CSV import API, so you do not need to read and write cells row by row.

Extract PDF Tables to SQLite Database with Python

Jeremy K. — Mon, 21 Sep 2026 03:14:18 +0000

Importing tables from PDFs into SQLite is a common data task. Quarterly reports, bank statements, business ledgers—business teams send PDFs, and you need structured data for analysis.

This guide shows a complete Python workflow for:

extracting tables from PDFs
cleaning field names and text
creating SQLite tables dynamically
inserting rows in batches

PDF parsing uses the Free Spire.PDF library. Everything else relies on the standard library, so deployment is simple.

Requirements and Limitations

Install the PDF library:

pip install Spire.Pdf.Free

Import it:

import re
import sqlite3

from spire.pdf import *
from spire.pdf.common import *

Before you start, note two important limitations:

The free version processes only the first 10 pages of a PDF. Content after page 10 is not returned.
Table extraction depends on visible border lines in the PDF. Scanned documents and borderless tables are not supported and require OCR.

Workflow at a Glance

The process has three main steps:

Extract the raw text matrix of every table, page by page.
Normalize and deduplicate headers to create valid column names.
Dynamically create one SQLite table per PDF table and batch-insert the rows.

This approach is useful when a single PDF contains multiple tables with different structures. You do not need to know the column layout in advance.

Step 1: Clean Text and Fix Ligatures

PDFs often replace ligatures with Unicode Private Use Area characters. For example, fi or ff may appear as \ue005 or \ue000.

If inserted directly, these become garbled boxes. Normalize them first.

def normalize_text(text: str) -> str:
    if not text:
        return ""

    ligature_map = {
        '\ue000': 'ff',
        '\ue001': 'ft',
        '\ue002': 'ffi',
        '\ue003': 'ffl',
        '\ue004': 'ti',
        '\ue005': 'fi',
    }

    for k, v in ligature_map.items():
        text = text.replace(k, v)

    return text.strip()

You do not need to map every possible character upfront. Add new mappings as you encounter them.

Step 2: Normalize and Deduplicate Column Names

Raw PDF headers often contain spaces, mixed case, Chinese characters, or symbols. They cannot be used directly as database column names.

This step does two things:

Converts non-alphanumeric characters to underscores.
Falls back to column_N for empty headers.
Resolves duplicate column names, such as two columns both named "Amount".

def normalize_column_name(name: str, index: int) -> str:
    if not name:
        return f"column_{index}"

    name = name.lower()
    name = re.sub(r'[^a-z0-9]+', '_', name).strip('_')

    return name or f"column_{index}"


def deduplicate_columns(columns):
    seen = set()
    result = []

    for col in columns:
        base = col
        count = 1

        while col in seen:
            col = f"{base}_{count}"
            count += 1

        seen.add(col)
        result.append(col)

    return result

The deduplication logic uses an incrementing suffix:

amount
amount_1
amount_2

This prevents columns from overwriting each other.

Step 3: Extract Tables from the PDF

PdfTableExtractor is the core object. Call ExtractTable(page_index) for each page to get all tables on that page.

For each table:

use GetRowCount() and GetColumnCount() to iterate
use GetText(row, col) to read cell text

pdf = PdfDocument()
pdf.LoadFromFile("Quarterly Sales.pdf")

extractor = PdfTableExtractor(pdf)
all_tables = []

for page_index in range(pdf.Pages.Count):
    tables = extractor.ExtractTable(page_index)

    if not tables:
        continue

    for table in tables:
        table_rows = []

        for row in range(table.GetRowCount()):
            row_data = [
                normalize_text(table.GetText(row, col))
                for col in range(table.GetColumnCount())
            ]
            table_rows.append(row_data)

        if table_rows:
            all_tables.append(table_rows)

pdf.Close()

if not all_tables:
    raise ValueError("No tables found in PDF.")

Note the pdf.Close() call. When processing many files, closing the document is important. Otherwise, memory usage will keep growing.

Step 4: Create Tables Dynamically and Insert Rows

Different PDF tables have different columns. The simplest approach is to name each table table_N and generate the DDL dynamically.

All columns are declared as TEXT. Type inference can be handled later during querying.

conn = sqlite3.connect("sales_data.db")
cursor = conn.cursor()

for table_index, table in enumerate(all_tables, start=1):
    if len(table) < 2:
        continue  # Skip tables with headers only

    raw_headers = table[0]

    normalized_headers = [
        normalize_column_name(h, i)
        for i, h in enumerate(raw_headers)
    ]
    normalized_headers = deduplicate_columns(normalized_headers)

    table_name = f"table_{table_index}"

    columns_def = ", ".join(
        [f'"{col}" TEXT' for col in normalized_headers]
    )

    cursor.execute(f"""
        CREATE TABLE IF NOT EXISTS "{table_name}" (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            {columns_def}
        )
    """)

    placeholders = ", ".join(["?" for _ in normalized_headers])
    column_names = ", ".join([f'"{col}"' for col in normalized_headers])

    insert_sql = f"""
        INSERT INTO "{table_name}" ({column_names})
        VALUES ({placeholders})
    """

    batch = []

    for row in table[1:]:
        if not any(row):
            continue

        values = [
            row[i] if i < len(row) else ""
            for i in range(len(normalized_headers))
        ]
        batch.append(values)

    if batch:
        cursor.executemany(insert_sql, batch)

    print(f"Inserted {len(batch)} rows into {table_name}")

conn.commit()
conn.close()

print(f"Processed {len(all_tables)} tables from PDF.")

Implementation Notes

Skip empty tables.

if len(table) < 2 filters out pseudo-tables that contain only headers, or only a single row of empty strings.
Align column counts.

If a row has fewer columns than the header, this expression fills in empty strings:

row[i] if i < len(row) else ""

If a row has more columns than the header, the extra values are discarded. This can happen with merged cells. In production, log rows with abnormal column counts so they can be reviewed later.

Use executemany for batch inserts. Single INSERT statements become slow even on tables with a few hundred rows. Batch execution significantly reduces SQLite transaction overhead.

Final Thoughts

Apart from the PDF parsing library, this solution has no third-party dependencies. It is easy to embed in existing data processing scripts and convenient to run in containers.

If your PDFs are relatively short and have well-structured tables, this code can usually be adapted for production by changing only a few constants.

How to Create Drop-Down Lists in Excel with Python

Jeremy K. — Tue, 15 Sep 2026 06:27:23 +0000

Drop-down lists help enforce consistent data entry in Excel. Manually adding them is fine for a few cells, but Python automation is more efficient when you need to add them across many cells, multiple files, or repeatable templates.

Free Spire.XLS for Python offers two direct approaches:

Inline list — specify options with DataValidation.Values
Cell-range source — reference worksheet cells with DataValidation.DataRange

Prerequisites

Install the free library:

pip install spire.xls.free

Import the required modules:

from spire.xls import *
from spire.xls.common import *

Core Concept: `DataValidation`

In Free Spire.XLS, a drop-down list is a list-type data validation. Every CellRange exposes a DataValidation property. Configure either of these two settings:

DataValidation.Values: a Python list of options
DataValidation.DataRange: a CellRange containing the options

Once configured, each target cell displays a drop-down arrow. Users can select from the preset options, and whether manual input is allowed depends on the error alert settings.

Method 1: Inline List with `Values`

Use this method when the options are fixed and few. No extra worksheet area is needed.

from spire.xls import *
from spire.xls.common import *

workbook = Workbook()
sheet = workbook.Worksheets[0]
sheet.Name = "Employee Info"

# Headers
sheet.Range["A1"].Text = "Name"
sheet.Range["C1"].Text = "Position"

# Target cells
cellRange = sheet.Range["C2:C10"]

# Inline options
cellRange.DataValidation.Values = ["Intern", "Technician", "Supervisor", "Director"]

workbook.SaveToFile("PositionDropDownList.xlsx", FileFormat.Version2016)
workbook.Dispose()

Note: Inline list values must stay within Excel’s 255-character limit.

Method 2: Range-Based List with `DataRange`

Use this method when options are numerous or may change over time. Store the options in worksheet cells and reference that range.

from spire.xls import *
from spire.xls.common import *

workbook = Workbook()
sheet = workbook.Worksheets[0]
sheet.Name = "Employee Info"

# Headers
sheet.Range["A1"].Text = "Name"
sheet.Range["C1"].Text = "Department"

# Source options
sheet.Range["F1"].Text = "HR"
sheet.Range["G1"].Text = "Finance"
sheet.Range["H1"].Text = "IT"

# Target cells
cellRange = sheet.Range["C2:C10"]

# Reference source range
cellRange.DataValidation.DataRange = sheet.Range["F1:H1"]

workbook.SaveToFile("DepartmentDropDownList.xlsx", FileFormat.Version2016)
workbook.Dispose()

For best results, use a single row or column as the source range. Multi-row or multi-column ranges may produce unexpected option ordering.

If you are working with an existing workbook:

workbook = Workbook()
workbook.LoadFromFile("Sample.xlsx")

sheet = workbook.Worksheets.get_Item(0)
cellRange = sheet.Range["C3:C7"]
cellRange.DataValidation.DataRange = sheet.Range["F4:H4"]

workbook.SaveToFile("output/DropDownListExcel.xlsx", FileFormat.Version2016)
workbook.Dispose()

Cross-Worksheet Reference

You can also reference options stored on another worksheet:

data_sheet = workbook.Worksheets[1]
data_sheet.Name = "DataSource"
data_sheet.Range["A1"].Text = "HR"
# Add more options as needed

cellRange.DataValidation.DataRange = data_sheet.Range["A1:A10"]

For maximum compatibility, consider using a named range if Excel has trouble with direct cross-sheet validation.

Which Method Should You Use?

Factor	Cell-range source	Inline values
Maintenance	Edit in Excel; no code changes	Edit code and regenerate
Worksheet layout	Requires source cells	No extra cells
Size limit	Limited by Excel rows	255-character total limit
Best for	Dynamic or many options	Fixed or few options

Use inline values for simple, one-off files. Use a cell range when business users need to maintain options directly in the workbook.

Optional: Error and Input Messages

After setting Values or DataRange, you can add user guidance:

# Error alert for invalid input
cellRange.DataValidation.ShowError = True
cellRange.DataValidation.ErrorTitle = "Invalid Input"
cellRange.DataValidation.ErrorMessage = "Please select an option from the drop-down list."

# Input prompt when the cell is selected
cellRange.DataValidation.ShowInput = True
cellRange.DataValidation.InputTitle = "Select an Option"
cellRange.DataValidation.InputMessage = "Choose a value from the drop-down list."

ShowError = True: invalid entries trigger a dialog. AlertStyle can be set to Stop, Warning, or Information.
ShowInput = True: a tooltip appears when the cell is selected.

Summary

Free Spire.XLS for Python makes Excel drop-down lists easy to automate. Use DataValidation.Values for simple inline lists and DataValidation.DataRange for maintainable, range-based lists. Add error and input messages to improve data quality and user experience.

How to Import Excel Data into Python

Jeremy K. — Mon, 07 Sep 2026 09:02:53 +0000

In routine data work, importing Excel files into Python for further analysis is a common need. This article shows how to use Free Spire.XLS for Python—a free library—to read, parse, and import Excel data.

1. Why Choose This Approach

Python offers many libraries for handling Excel files. Free Spire.XLS for Python stands out because it does not require Microsoft Office—it works with .xls and .xlsx files in a pure Python environment. It supports Python 3.6+ and runs on Windows, Linux, and macOS. The free version is more than adequate for most individual and small‑project data import tasks.

2. Environment Setup

Install the library via pip:

pip install Spire.XLS.Free

After installation, import the required modules:

from spire.xls import *
from spire.xls.common import *

3. Core Object Model

Two central objects form the foundation of this library:

Workbook – represents the entire Excel workbook, handling file loading and saving.
Worksheet – represents a single worksheet, providing cell access and data reading.

4. Basic Excel Data Reading

4.1 Loading an Excel File

workbook = Workbook()
workbook.LoadFromFile("data.xlsx")

4.2 Accessing a Worksheet

# First worksheet (index 0)
worksheet = workbook.Worksheets[0]
# Alternative:
worksheet = workbook.Worksheets.get_Item(0)

4.3 Reading Cell Values

Use Worksheet.Range to reference a cell, then access its properties: Value, Text, or NumberValue.

# By row and column (1‑based)
cell_value = worksheet.Range[1, 1].Value   # A1

# By address
cell_text = worksheet.Range["B2"].Text

# Numeric value
cell_number = worksheet.Range["C3"].NumberValue

4.4 Iterating Over All Data

row_count = worksheet.AllocatedRange.RowCount
col_count = worksheet.AllocatedRange.ColumnCount

for row in range(1, row_count + 1):
    row_data = []
    for col in range(1, col_count + 1):
        row_data.append(worksheet.Range[row, col].Value)
    print(row_data)

5. Practical Example: Import into a Python List

This function reads an entire worksheet into a two‑dimensional list:

from spire.xls import Workbook

def excel_to_list(file_path):
    """Load Excel data into a list of lists."""
    workbook = Workbook()
    workbook.LoadFromFile(file_path)
    sheet = workbook.Worksheets[0]

    row_count = sheet.AllocatedRange.RowCount
    col_count = sheet.AllocatedRange.ColumnCount

    data = []
    for row in range(1, row_count + 1):
        row_data = []
        for col in range(1, col_count + 1):
            row_data.append(sheet.Range[row, col].Value)
        data.append(row_data)

    workbook.Dispose()  # Release resources
    return data

# Usage
data = excel_to_list("sales_data.xlsx")
for row in data:
    print(row)

6. Practical Example: Import into a List of Dictionaries (with Headers)

For easier field‑based access, convert data to a list of dictionaries using the first row as keys:

from spire.xls import Workbook

def excel_to_dict_list(file_path):
    """Load Excel data into a list of dictionaries; first row becomes keys."""
    workbook = Workbook()
    workbook.LoadFromFile(file_path)
    sheet = workbook.Worksheets[0]

    row_count = sheet.AllocatedRange.RowCount
    col_count = sheet.AllocatedRange.ColumnCount

    # Read headers from the first row
    headers = [sheet.Range[1, col].Value for col in range(1, col_count + 1)]

    # Read data rows (starting at row 2)
    result = []
    for row in range(2, row_count + 1):
        record = {}
        for col in range(1, col_count + 1):
            record[headers[col - 1]] = sheet.Range[row, col].Value
        result.append(record)

    workbook.Dispose()
    return result

# Usage
records = excel_to_dict_list("employee_info.xlsx")
for emp in records:
    print(f"Name: {emp.get('Name')}, Department: {emp.get('Department')}")

Summary

This article walked through the full workflow for importing Excel data into Python, covering environment setup, basic reading, list conversion, and dictionary‑list conversion. The free library requires no Office dependencies, is easy to install, and offers an intuitive API—making it a practical choice for handling small to medium‑sized Excel import tasks.

Merge and Unmerge Excel Cells in Python

Jeremy K. — Mon, 31 Aug 2026 06:25:54 +0000

Automate Excel cell merging and splitting using Python—without installing Microsoft Office or WPS. This guide covers every common scenario (entire rows, entire columns, custom rectangular ranges, and batch unmerging) using the Free Spire.XLS library. Ideal for CI/CD pipelines, data preprocessing, and automated report generation, this solution reads and writes .xls/.xlsx files natively, focusing purely on document structure and data manipulation.

1. Setup and Installation

Install the required package via pip:

pip install Spire.XLS.Free

Then, import the core modules at the top of your Python script:

from spire.xls import *
from spire.xls.common import *

2. Merging an Entire Row

To collapse all cells in a specific row into a single cell (e.g., for a wide column header), use the Rows[index].Merge() method. Row indices are zero‑based.

# Load the workbook and access the first worksheet
workbook = Workbook()
workbook.LoadFromFile("SalesData.xlsx")
sheet = workbook.Worksheets[0]

# Merge the entire first row
sheet.Rows[0].Merge()
# Only the top‑left cell (A1) retains its value
sheet.Range["A1"].Value = "2026 Annual Sales Summary"

workbook.SaveToFile("MergedRowResult.xlsx", ExcelVersion.Version2013)
workbook.Dispose()

3. Merging an Entire Column

Similarly, to merge all cells in a column (e.g., for a vertical category label), call Columns[index].Merge():

# Merge the second column (index 1 = column B)
sheet.Columns[1].Merge()
# Content is preserved only in cell B1
sheet.Range["B1"].Value = "Region Classification"

4. Merging a Custom Cell Range

For maximum flexibility—such as spanning titles across multiple columns or grouping summary rows—use Range["StartCell:EndCell"].Merge() to target any rectangular block:

# Merge horizontally from A1 to E1 (5 columns)
sheet.Range["A1:E1"].Merge()

# Merge vertically from C3 to C8 (6 rows)
sheet.Range["C3:C8"].Merge()

# Merge a 2×3 block from D4 to F6
sheet.Range["D4:F6"].Merge()

Critical Rule: After a merge, only the value in the upper‑left cell of the range is preserved. All other values within the range are automatically discarded. Always populate data or back up the original file before merging.

5. Unmerging (Splitting Cells)

To reverse a merge, use the UnMerge() method. You can target an individual merged region, an entire row, an entire column, or all merged areas in the sheet.

Unmerge a specific merged region

# Pass any cell that belongs to the merged region
sheet.Range["A1"].UnMerge()

Unmerge an entire row

sheet.Rows[0].UnMerge()

Unmerge an entire column

sheet.Columns[1].UnMerge()

Unmerge all merged regions in the worksheet at once

merged_regions = sheet.MergedCells   # Returns a list of all merged ranges
for cell_range in merged_regions:
    cell_range.UnMerge()

6. End‑to‑End Example Script

The following script demonstrates a complete workflow: loading a file, applying three different types of merges, saving the result, and then reloading to perform targeted unmerges.

from spire.xls import *
from spire.xls.common import *

def merge_demo():
    # ---------- Phase 1: Load and merge ----------
    workbook = Workbook()
    workbook.LoadFromFile("OriginalReport.xlsx")
    sheet = workbook.Worksheets[0]

    # 1. Merge row 1 as the master title
    sheet.Rows[0].Merge()
    sheet.Range["A1"].Value = "National Store Sales Overview"

    # 2. Merge column B as the region header
    sheet.Columns[1].Merge()
    sheet.Range["B1"].Value = "Region"

    # 3. Merge D2:E4 as a footnote block
    sheet.Range["D2:E4"].Merge()
    sheet.Range["D2"].Value = "Note: Data excludes Hong Kong, Macao, and Taiwan"

    # Save the merged workbook
    workbook.SaveToFile("MergedResult.xlsx", ExcelVersion.Version2013)
    workbook.Dispose()

    # ---------- Phase 2: Reload and unmerge ----------
    workbook2 = Workbook()
    workbook2.LoadFromFile("MergedResult.xlsx")
    sheet2 = workbook2.Worksheets[0]

    # Unmerge the D2:E4 region
    sheet2.Range["D2"].UnMerge()

    # Unmerge the first row
    sheet2.Rows[0].UnMerge()

    # Save the final output
    workbook2.SaveToFile("UnmergedResult.xlsx", ExcelVersion.Version2013)
    workbook2.Dispose()

if __name__ == "__main__":
    merge_demo()

After execution, MergedResult.xlsx will contain all three merged structures, while UnmergedResult.xlsx will restore the split state for the selected areas.

7. Best Practices and Important Tips

Data safety: Since merging deletes all values except the top‑left one, always perform merge operations before writing detailed data, or keep a backup copy of the original file.
Writing to merged cells: After a merge, you can only assign new values using the address of the upper‑left cell (e.g., sheet.Range["A1"].Value = ...). Writing to any other cell within the merged area will have no effect.
Performance: If your worksheet contains hundreds of merged regions, repeated Merge() or UnMerge() calls may slow down execution. For better performance, collect all target ranges first and apply changes in batch.
Conflict handling: Calling Merge() on an already‑merged range does not raise an exception, but it can lead to nested or overlapping merged structures. To avoid unintended behavior, inspect the sheet.MergedCells property beforehand and explicitly unmerge existing regions if necessary.
Resource cleanup: Always call Dispose() on the Workbook object after saving to release underlying system resources—especially important in long‑running automation scripts.

How to Set Excel Cell Backgrounds in C#

Jeremy K. — Wed, 26 Aug 2026 03:38:04 +0000

Customizing cell backgrounds in Excel is one of the fastest ways to transform a plain data dump into a professional, scannable report. Whether you need to highlight headers, flag key metrics, or add visual polish to dashboards, the Free Spire.XLS for .NET library makes it easy to apply solid fills, texture patterns, and gradient effects programmatically.

In this guide, you'll learn how to implement each style with concise C# examples.

Prerequisites

Install the library via NuGet Package Manager:

Install-Package FreeSpire.XLS

Then add the required namespaces to your project:

using Spire.Xls;
using System.Drawing;

1. Solid Fill (Flat Background)

The solid fill is the most common background type—ideal for headers, totals, or status-based highlighting.

using (Workbook workbook = new Workbook())
{
    Worksheet sheet = workbook.Worksheets[0];

    CellRange cell = sheet.Range["B2"];
    cell.Text = "Solid Background";

    // Solid fill requires the pattern to be explicitly set to Solid
    cell.Style.FillPattern = ExcelPatternType.Solid;
    cell.Style.Color = Color.LightGreen;

    workbook.SaveToFile("CellSolidColor.xlsx", ExcelVersion.Version2016);
}

⚠️ Crucial: Always set FillPattern to ExcelPatternType.Solid before assigning a color. If omitted, the color change will be ignored.

2. Texture Fill (Pattern Overlay)

Texture fills overlay a repeating pattern (e.g., brick, checker, or angle) over a base color. They're perfect for subtly distinguishing data categories without overwhelming the reader.

using (Workbook workbook = new Workbook())
{
    Worksheet sheet = workbook.Worksheets[0];

    CellRange cell = sheet.Range["B2"];
    cell.Text = "Texture Background";

    // Angle texture pattern
    cell.Style.FillPattern = ExcelPatternType.Angle;
    cell.Style.Color = Color.LightGray;      // Base background color
    cell.Style.PatternColor = Color.Beige;   // Pattern overlay color

    workbook.SaveToFile("CellPattern.xlsx", ExcelVersion.Version2016);
}

Note: The PatternColor property defines the color of the texture strokes, while Color defines the solid backdrop behind them.

3. Gradient Fill (Smooth Color Transition)

Gradients create a polished, modern look by blending two colors seamlessly. They work exceptionally well for dashboard headers, progress indicators, or visual status meters.

using (Workbook workbook = new Workbook())
{
    Worksheet sheet = workbook.Worksheets[0];

    CellRange cell = sheet.Range["B2"];
    cell.Text = "Gradient Background";

    // Enable gradient fill
    cell.Style.FillPattern = ExcelPatternType.Gradient;

    // Configure gradient direction and colors
    cell.Style.Interior.Gradient.GradientStyle = GradientStyleType.Vertical;
    cell.Style.Interior.Gradient.ForeColor = Color.Orange;
    cell.Style.Interior.Gradient.BackColor = Color.LightYellow;

    workbook.SaveToFile("CellGradient.xlsx", ExcelVersion.Version2016);
}

Tip: Change GradientStyle to Horizontal, DiagonalDown, or DiagonalUp to alter the transition direction.

4. Applying Backgrounds to Cell Ranges

Styling individual cells works well, but for real-world reports, you'll often want to style entire rows or tables in one go. The Range property supports bulk operations:

// Style the entire header row
sheet.Range["A1:E1"].Style.Color = Color.MediumSeaGreen;

// Style a full column of data
sheet.Range["A2:A10"].Style.Color = Color.LightYellow;

Bulk styling is significantly faster than looping through single cells and keeps your code cleaner.

Best Practices & Key Considerations

Pattern Precedence: For solid fills, always set FillPattern = Solid. For gradients, set it to Gradient. Mixing these up is the #1 cause of "why isn't my color showing?"
Custom Colors: Beyond the predefined System.Drawing.Color values, you can define custom RGB colors using Color.FromArgb(red, green, blue) for precise brand alignment.
Performance: When styling large datasets (thousands of rows), apply colors to entire Range objects rather than iterating cell-by-cell to keep performance snappy.
Resource Management: The examples above use using statements to automatically dispose of the Workbook object. This is safer and more concise than manual .Dispose() calls.

Final Thoughts

With just a few lines of code, you can move from monochrome spreadsheets to visually structured reports that communicate insights instantly. The three techniques covered here—solid, texture, and gradient—give you the flexibility to match any reporting style, from conservative financial tables to vibrant executive dashboards.

Apply these patterns to your next C# Excel automation project and see the difference in clarity

Convert PDF to PowerPoint in C# (Offline, .NET-Based Solution)

Jeremy K. — Tue, 18 Aug 2026 03:36:34 +0000

In enterprise document workflows, converting static PDF files into editable PowerPoint presentations is a frequent requirement. However, online conversion tools pose data security risks, while Office Interop solutions require a full Microsoft Office installation on the server—which is often impractical.

This guide presents a lightweight, offline alternative using Free Spire.PDF for .NET. The library operates independently of Adobe Acrobat and Microsoft Office, requiring minimal code for seamless integration into your .NET applications.

1. Environment Setup

1.1 Installation

We’ll use Free Spire.PDF for .NET as our conversion engine. The free edition supports basic conversion capabilities, making it suitable for small-scale document processing and personal projects.

Via NuGet (Recommended):

In Visual Studio, right-click your project → Manage NuGet Packages.
Browse for FreeSpire.PDF and click Install.

Alternatively, run the following command in the Package Manager Console:

PM> Install-Package FreeSpire.PDF

1.2 Add the Namespace

Add this using directive to your code file:

using Spire.Pdf;

2. Core Conversion Code

The actual conversion logic is remarkably concise—just three lines of code:

using Spire.Pdf;

namespace PDFtoPowerPoint
{
    class Program
    {
        static void Main(string[] args)
        {
            PdfDocument pdf = new PdfDocument();
            pdf.LoadFromFile(@"C:\Users\Administrator\Desktop\SampleDocument.pdf");
            pdf.SaveToFile("PDFtoPPTResult.pptx", FileFormat.PPTX);
        }
    }
}

3. Code Walkthrough

Step	Description
`PdfDocument pdf = new PdfDocument()`	Instantiates a new `PdfDocument` object to represent the source PDF.
`pdf.LoadFromFile("path")`	Loads the target PDF file from disk into memory.
`pdf.SaveToFile("output.pptx", FileFormat.PPTX)`	Converts and saves the document as a `.pptx` file. Each page in the original PDF becomes an individual slide in PowerPoint.
`pdf.Close()`	(Recommended) Explicitly releases resources associated with the document after processing.

Full Version with Exception Handling

For production code, always wrap the conversion in a try-catch block to handle potential errors (e.g., file access issues or corrupted PDFs):

using System;
using Spire.Pdf;

namespace PDFtoPowerPoint
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputPath = @"C:\Users\Administrator\Desktop\SampleDocument.pdf";
            string outputPath = "PDFtoPPTResult.pptx";

            try
            {
                PdfDocument pdf = new PdfDocument();
                pdf.LoadFromFile(inputPath);
                pdf.SaveToFile(outputPath, FileFormat.PPTX);
                pdf.Close();

                Console.WriteLine("Conversion completed successfully.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Conversion failed: {ex.Message}");
            }
        }
    }
}

4. Important Notes and Limitations

⚠️ 1. Free Version Restrictions

The community edition of Spire.PDF enforces the following limits:

Loading: Supports PDF documents with up to 10 pages.
Conversion: When exporting to PPTX (or other formats like Word/HTML/Image), only the first 3 pages are processed. If you need to convert full documents, you'll need to consider the commercial version.

2. No External Dependencies

Free Spire.PDF for .NET is a fully managed .NET library. It runs without requiring Adobe Acrobat or Microsoft Office to be installed on the host machine.

3. Layout Fidelity

While the converted PPTX files are fully editable, keep in mind that PDF-to-PPT conversion is a reverse-engineering process. Complex elements—such as nested tables, dynamic charts, or non-standard fonts—may require manual touch-ups. Always run a test conversion on a representative sample to evaluate output quality.

5. Advanced Scenarios

1. Handling Encrypted PDFs

Load password-protected PDFs by passing the password as a second parameter:

pdf.LoadFromFile("EncryptedDocument.pdf", "your_password");

2. Batch Conversion

Loop through all PDFs in a directory to convert them in bulk:

using System.IO;

string[] pdfFiles = Directory.GetFiles(@"C:\PDFFolder\", "*.pdf");

foreach (string file in pdfFiles)
{
    using (PdfDocument doc = new PdfDocument())
    {
        doc.LoadFromFile(file);
        string output = Path.ChangeExtension(file, ".pptx");
        doc.SaveToFile(output, FileFormat.PPTX);
    }
}

Tip: Wrapping the PdfDocument in a using statement ensures that Dispose() is called automatically, which internally handles resource cleanup.

6. Summary

This local conversion approach offers three major benefits:

Secure – No file uploads to third-party services.
Lightweight – No dependency on bulky office suites.
Developer-friendly – Integrates into your C# project with minimal boilerplate.

It's an ideal solution for internal system integrations, automated document pre-processing, and batch workflows.

However, set realistic expectations: perfect format restoration is not guaranteed. For high-stakes presentations with strict layout requirements, we strongly recommend performing a manual review and adjusting the slide layout after conversion.

Change Fonts in a Word Document with Python

Jeremy K. — Tue, 11 Aug 2026 08:50:20 +0000

Standardizing fonts across multiple Word documents is a common yet tedious task in daily office work. Whether you are preparing corporate reports, cleaning up inconsistent user submissions, or replacing missing fonts to prevent layout shifts, doing this manually—page by page—is inefficient and prone to missing text inside tables, headers, or text boxes.

By programmatically controlling document fonts with Python, you can automate this entire workflow. This guide explores how to use the Free Spire.Doc for Python library to modify font styles efficiently.

Setting Up the Environment

Start by installing the library via pip:

pip install spire.doc.free

Once installed, import the necessary modules into your script:

from spire.doc import *
from spire.doc.common import *

Core Concepts: CharacterFormat and ParagraphStyle

In the Free Spire.Doc object model, all font-related attributes—such as typeface, size, color, bold, and italic—are managed through the CharacterFormat property. Whether you are styling an entire paragraph or tweaking a specific word, your changes ultimately target this CharacterFormat object.

The ParagraphStyle class lets you define reusable custom styles. It includes a CharacterFormat property to control the visual appearance of text. Once you define a style, you add it to the document using Styles.Add() and apply it to any paragraph with ApplyStyle().

Scenario 1: Changing the Font of an Entire Paragraph

When you need to uniformly reformat all the text within a specific paragraph, creating and applying a paragraph style is the cleanest approach.

Code Example

from spire.doc import *
from spire.doc.common import *

# Load the document
doc = Document()
doc.LoadFromFile('Sample.docx')

# Target a specific paragraph (index starts at 0)
section = doc.Sections[0]
paragraph = section.Paragraphs[2]

# Define a new paragraph style
style = ParagraphStyle(doc)
style.Name = 'ParaFont'
style.CharacterFormat.FontName = 'Arial'
style.CharacterFormat.FontSize = 12
style.CharacterFormat.Bold = True
style.CharacterFormat.Italic = True
style.CharacterFormat.TextColor = Color.get_Red()

# Register and apply the style
doc.Styles.Add(style)
paragraph.ApplyStyle(style.Name)

# Save the updated document
doc.SaveToFile('output/ChangeParaFont.docx', FileFormat.Docx)
doc.Dispose()

How It Works

ParagraphStyle(doc) initializes a new style container.
The CharacterFormat properties define the exact font appearance (name, size, weight, color).
ApplyStyle() attaches your custom style to the target paragraph in one go.

This method is ideal for bulk formatting of headings, subheadings, or standard body text.

Scenario 2: Finding and Modifying Specific Text

If you only want to change the font for certain keywords or phrases, use the FindAllString method for precise text targeting.

Code Example

from spire.doc import Document, Color

doc = Document()
doc.LoadFromFile('Sample.docx')

# Locate all occurrences of the target text (case-sensitive)
selections = doc.FindAllString('target text', False, True)

# Update the font for each match
for selection in selections:
    text_range = selection.GetAsOneRange()
    text_range.CharacterFormat.FontName = 'Cambria'
    text_range.CharacterFormat.FontSize = 14
    text_range.CharacterFormat.TextColor = Color.get_Red()
    text_range.CharacterFormat.Bold = True

doc.SaveToFile('output/ChangeTextFont.docx', FileFormat.Docx)
doc.Dispose()

How It Works

FindAllString() scans the document and returns a list of TextSelection objects representing the found instances.
GetAsOneRange() converts a selection into a TextRange object, allowing direct manipulation of its CharacterFormat.

This approach is perfect for highlighting keywords, updating product names, or correcting specific terminology.

Important Considerations

Free Version Limits: The free edition of Spire.Doc is capped at processing 500 paragraphs per document. This is sufficient for most small-to-medium projects and evaluation purposes.
Resource Management: Always call Dispose() (or Close()) after saving to properly release system resources and avoid memory leaks.
Full Document Overhaul: To change the font of every piece of text in a document, you can iterate through Sections, then Paragraphs, then inspect each ChildObject. Whenever you encounter a TextRange, apply your font changes directly.

Summary

This article demonstrated two practical techniques for modifying fonts in Word documents using Python:

Paragraph-wide changes – using ParagraphStyle for consistent, reusable formatting.
Targeted text changes – using FindAllString to locate and update specific words or phrases.

Both methods operate entirely within Python and do not require Microsoft Office to be installed, making them highly suitable for server-side or automated batch-processing tasks.

How to Batch Extract PDF Form Data Using C#

Jeremy K. — Wed, 05 Aug 2026 01:46:00 +0000

In enterprise workflows, PDF forms are widely used for data collection. After users fill out a form, systems typically need to automatically extract the field values for storage, validation, or downstream processing. This article demonstrates how to read interactive PDF form fields—including text boxes, checkboxes, radio buttons, list boxes, and combo boxes—using C#.

1. Approach Overview

Every form field in a PDF has a unique name, a type indicator, and a current value. The overall process is straightforward:

Load the PDF document.
Access the form collection.
Iterate through all fields.
Extract the value according to each field’s type.

We’ll use the Free Spire.PDF for .NET library, which offers the PdfFormWidget class for form manipulation and supports field lookup by index or name.

2. Prerequisites

2.1 Install the NuGet Package

Install FreeSpire.PDF via the Visual Studio NuGet Package Manager, or run the following command in the Package Manager Console:

Install-Package FreeSpire.PDF

Once installed, the Spire.Pdf.dll reference is added automatically. Note that the free version limits processing to the first 10 pages per document, which is typically sufficient for form extraction.

2.2 Import Required Namespaces

using Spire.Pdf;
using Spire.Pdf.Widget;
using System;
using System.Text;

3. Basic Workflow for Reading Form Fields

3.1 Load the Document and Retrieve the Form

PdfDocument doc = new PdfDocument();
doc.LoadFromFile("YourForm.pdf");

// Cast to PdfFormWidget to access the full field collection
PdfFormWidget formWidget = doc.Form as PdfFormWidget;

The doc.Form property returns a generic form object; casting to PdfFormWidget gives you the complete field list.

3.2 Iterate Over All Fields

for (int i = 0; i < formWidget.FieldsWidget.List.Count; i++)
{
    PdfField field = formWidget.FieldsWidget.List[i] as PdfField;
    Console.WriteLine($"Field Name: {field.Name}");
}

4. Extracting Values by Field Type

Different field types store their values in different properties. Use type checking and casting to retrieve the correct data.

4.1 Text Box (`PdfTextBoxFieldWidget`)

if (field is PdfTextBoxFieldWidget textBoxField)
{
    Console.WriteLine($"TextBox - Name: {textBoxField.Name}, Value: {textBoxField.Text}");
}

4.2 Checkbox (`PdfCheckBoxWidgetFieldWidget`)

if (field is PdfCheckBoxWidgetFieldWidget checkBoxField)
{
    Console.WriteLine($"CheckBox - Name: {checkBoxField.Name}, Checked: {checkBoxField.Checked}");
}

4.3 Radio Button Group (`PdfRadioButtonListFieldWidget`)

if (field is PdfRadioButtonListFieldWidget radioBtnField)
{
    Console.WriteLine($"RadioButton - Name: {radioBtnField.Name}, SelectedValue: {radioBtnField.SelectedValue}");
}

4.4 List Box (`PdfListBoxWidgetFieldWidget`)

if (field is PdfListBoxWidgetFieldWidget listBoxField)
{
    Console.WriteLine($"ListBox - Name: {listBoxField.Name}, SelectedValue: {listBoxField.SelectedValue}");

    // List all available options
    foreach (PdfListWidgetItem item in listBoxField.Values)
    {
        Console.WriteLine($"  Option: {item.Value}");
    }
}

4.5 Combo Box (Drop‑down) (`PdfComboBoxWidgetFieldWidget`)

if (field is PdfComboBoxWidgetFieldWidget comboField)
{
    Console.WriteLine($"ComboBox - Name: {comboField.Name}, SelectedValue: {comboField.SelectedValue}");
}

5. Important Notes and Troubleshooting

5.1 Check for Empty Forms

Not all PDFs contain interactive forms. If doc.Form cannot be cast to PdfFormWidget, or if formWidget.FieldsWidget.Count is zero, the document has no form fields. In such cases, fall back to plain text extraction.

5.2 AcroForm vs. XFA Forms

PDF forms come in two standards:

AcroForm – Adobe’s native format, which is what this article covers (handled by PdfFormWidget).
XFA Forms – XML‑based forms, often created with Adobe LiveCycle. These require separate handling via formWidget.XFAForm, as their field structure and value access are entirely different.

5.3 Release Resources

Always close the document to free up resources:

doc.Close();

6. Summary

Successfully reading PDF form fields hinges on correctly identifying each field’s type and using the appropriate property to retrieve its value. The PdfFormWidget class provides a unified interface, and pattern matching with as makes type conversion clean and safe, covering most AcroForm scenarios.

In practice, it’s wise to first explore the field structure and naming conventions of your target PDF by iterating all fields. Then encapsulate the extracted data into a strongly typed model for business logic. This approach ensures accuracy, maintainability, and ease of future extension.

DEV Community: Jeremy K.

Changing PDF Page Size with Python

Prerequisites

Core Idea: Why You Can't Just "Change the Size"

Scenario 1: Change to Standard Paper Sizes (A3, B4, Letter, etc.)

Scenario 2: Custom Sizes (Millimeters, Inches, or Any Other Unit)

Scenario 3: Proportional Scaling (Enlarge or Shrink)

Summary

Converting JSON Data to Word Documents with Python

Environment Setup

Mapping Principle: JSON Structure Determines Word Form

Scenario 1: Flat Object → Key-Value Paragraphs

Scenario 2: Array of Objects → Word Table

Scenario 3: Nested Object → Recursive Heading Structure

Additional: Image Fields in JSON

Conclusion

Extracting Excel Worksheet Names with Python

Install Free Spire.XLS for Python

Get All Worksheet Names

Get Only Hidden Worksheet Names

Free Version Limitations

Resource Cleanup

Comparison with Other Options

When to use which

Key APIs

Summary

Import Multiple CSVs into One Excel Workbook with Python

Prerequisites

Key Steps

Complete Code

Key Points

Conclusion

Extract PDF Tables to SQLite Database with Python

Requirements and Limitations

Workflow at a Glance

Step 1: Clean Text and Fix Ligatures

Step 2: Normalize and Deduplicate Column Names

Step 3: Extract Tables from the PDF

Step 4: Create Tables Dynamically and Insert Rows

Implementation Notes

Final Thoughts

How to Create Drop-Down Lists in Excel with Python

Prerequisites

Core Concept: DataValidation

Method 1: Inline List with Values

Method 2: Range-Based List with DataRange

Cross-Worksheet Reference

Which Method Should You Use?

Optional: Error and Input Messages

Summary

How to Import Excel Data into Python

1. Why Choose This Approach

2. Environment Setup

3. Core Object Model

4. Basic Excel Data Reading

4.1 Loading an Excel File

4.2 Accessing a Worksheet

4.3 Reading Cell Values

4.4 Iterating Over All Data

5. Practical Example: Import into a Python List

6. Practical Example: Import into a List of Dictionaries (with Headers)

Summary

Merge and Unmerge Excel Cells in Python

1. Setup and Installation

2. Merging an Entire Row

3. Merging an Entire Column

4. Merging a Custom Cell Range

5. Unmerging (Splitting Cells)

Unmerge a specific merged region

Unmerge an entire row

Unmerge an entire column

Unmerge all merged regions in the worksheet at once

6. End‑to‑End Example Script

7. Best Practices and Important Tips

How to Set Excel Cell Backgrounds in C#

Prerequisites

1. Solid Fill (Flat Background)

2. Texture Fill (Pattern Overlay)

3. Gradient Fill (Smooth Color Transition)

4. Applying Backgrounds to Cell Ranges

Core Concept: `DataValidation`

Method 1: Inline List with `Values`

Method 2: Range-Based List with `DataRange`

4.1 Text Box (`PdfTextBoxFieldWidget`)

4.2 Checkbox (`PdfCheckBoxWidgetFieldWidget`)

4.3 Radio Button Group (`PdfRadioButtonListFieldWidget`)

4.4 List Box (`PdfListBoxWidgetFieldWidget`)

4.5 Combo Box (Drop‑down) (`PdfComboBoxWidgetFieldWidget`)