Mesclar e Dividir PDFs em Python, Rust, Go

Cobertura de bindings. A mesclagem de PDF está disponível em Python, Rust e Go. A divisão para arquivo via extract_pages funciona em Python e Rust; a variante em memória extract_pages_to_bytes adiciona suporte a Swift e ao C ABI (não ao WASM). O planejamento de divisão por marcadores (plan_split_by_bookmarks) está disponível em Python, Rust, Swift, WASM e C ABI. Para os bindings de divisão de arquivo, o binding C# ainda não expõe essas operações do editor — use o CLI Rust (pdf-oxide merge, pdf-oxide split) como alternativa, ou chame por um dos bindings suportados.

Mesclar dois PDFs em um:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("main.pdf")
doc.merge_from("appendix.pdf")
doc.save("combined.pdf")

WASM

import { WasmPdfDocument } from "pdf-oxide-wasm";

// Load both PDFs as Uint8Array
const mainDoc = new WasmPdfDocument(mainBytes);
const appendixDoc = new WasmPdfDocument(appendixBytes);
// Extract text from both and process as needed
const allText = mainDoc.extractAllText() + "\n" + appendixDoc.extractAllText();
mainDoc.free();
appendixDoc.free();

Rust

use pdf_oxide::editor::DocumentEditor;

let mut editor = DocumentEditor::open("main.pdf")?;
editor.merge_from("appendix.pdf")?;
editor.save("combined.pdf")?;

Go

package main

import (
    "log"
    pdfoxide "github.com/yfedoseev/pdf_oxide/go"
)

func main() {
    editor, err := pdfoxide.OpenEditor("main.pdf")
    if err != nil { log.Fatal(err) }
    defer editor.Close()

    if _, err := editor.MergeFrom("appendix.pdf"); err != nil { log.Fatal(err) }
    if err := editor.Save("combined.pdf"); err != nil { log.Fatal(err) }
}

C++

#include <pdf_oxide/pdf_oxide.hpp>

auto editor = pdf_oxide::DocumentEditor::open("main.pdf");
editor.merge_from("appendix.pdf");
editor.save("combined.pdf");

Swift

import PdfOxide

let editor = try DocumentEditor.open("main.pdf")
try editor.mergeFrom("appendix.pdf")
try editor.save("combined.pdf")

Dart

import 'package:pdf_oxide/pdf_oxide.dart';

final editor = DocumentEditor.open('main.pdf');
editor.mergeFrom('appendix.pdf');
editor.save('combined.pdf');

R

library(pdfoxide)

editor <- pdf_editor_open("main.pdf")
pdf_editor_merge_from(editor, "appendix.pdf")
pdf_editor_save(editor, "combined.pdf")

Julia

using PdfOxide

editor = open_editor("main.pdf")
merge_from(editor, "appendix.pdf")
save(editor, "combined.pdf")

Zig

const pdf_oxide = @import("pdf_oxide");

var editor = try pdf_oxide.DocumentEditor.openEditor("main.pdf");
defer editor.deinit();
try editor.mergeFrom("appendix.pdf");
try editor.save("combined.pdf");

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;

POXDocumentEditor *editor = [POXDocumentEditor openEditor:@"main.pdf" error:&err];
[editor mergeFrom:@"appendix.pdf" error:&err];
[editor saveToPath:@"combined.pdf" error:&err];

Elixir

{:ok, editor} = PdfOxide.open_editor("main.pdf")
:ok = PdfOxide.merge_from(editor, "appendix.pdf")
:ok = PdfOxide.editor_save(editor, "combined.pdf")

O PDF Oxide trata a mesclagem de páginas no nível de objetos PDF — fontes, imagens e anotações são preservadas corretamente entre documentos.

Instalação

pip install pdf_oxide

Mesclar PDFs

Mesclar Todas as Páginas

Adicionar todas as páginas de um segundo PDF ao primeiro:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("report.pdf")
doc.merge_from("charts.pdf")
doc.save("full-report.pdf")

WASM

// WASM API: load and process multiple documents
const report = new WasmPdfDocument(reportBytes);
const charts = new WasmPdfDocument(chartsBytes);
// Process both documents together
const fullText = report.extractAllText() + "\n" + charts.extractAllText();
report.free();
charts.free();

Rust

let mut editor = DocumentEditor::open("report.pdf")?;
let pages_added = editor.merge_from("charts.pdf")?;
println!("Added {} pages", pages_added);
editor.save("full-report.pdf")?;

Go

editor, _ := pdfoxide.OpenEditor("report.pdf")
defer editor.Close()

added, _ := editor.MergeFrom("charts.pdf")
fmt.Printf("Added %d pages\n", added)
_ = editor.Save("full-report.pdf")

C++

auto editor = pdf_oxide::DocumentEditor::open("report.pdf");
editor.merge_from("charts.pdf");
editor.save("full-report.pdf");

Swift

let editor = try DocumentEditor.open("report.pdf")
try editor.mergeFrom("charts.pdf")
try editor.save("full-report.pdf")

Dart

final editor = DocumentEditor.open('report.pdf');
editor.mergeFrom('charts.pdf');
editor.save('full-report.pdf');

R

editor <- pdf_editor_open("report.pdf")
pdf_editor_merge_from(editor, "charts.pdf")
pdf_editor_save(editor, "full-report.pdf")

Julia

editor = open_editor("report.pdf")
merge_from(editor, "charts.pdf")
save(editor, "full-report.pdf")

Zig

var editor = try pdf_oxide.DocumentEditor.openEditor("report.pdf");
defer editor.deinit();
try editor.mergeFrom("charts.pdf");
try editor.save("full-report.pdf");

Objective-C

POXDocumentEditor *editor = [POXDocumentEditor openEditor:@"report.pdf" error:&err];
[editor mergeFrom:@"charts.pdf" error:&err];
[editor saveToPath:@"full-report.pdf" error:&err];

Elixir

{:ok, editor} = PdfOxide.open_editor("report.pdf")
:ok = PdfOxide.merge_from(editor, "charts.pdf")
:ok = PdfOxide.editor_save(editor, "full-report.pdf")

Mesclar Vários Arquivos

Use o método estático Pdf.merge() para combinar vários PDFs em uma única chamada:

Python

from pdf_oxide import Pdf

pdf = Pdf.merge(["intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf"])
pdf.save("book.pdf")

Você também pode encadear chamadas de merge_from() em um documento existente:

from pdf_oxide import PdfDocument

doc = PdfDocument("intro.pdf")
for f in ["chapter1.pdf", "chapter2.pdf", "appendix.pdf"]:
    doc.merge_from(f)
doc.save("book.pdf")

WASM

// Load and process multiple PDFs sequentially
const files = [introBytes, ch1Bytes, ch2Bytes, appendixBytes];
const allText = [];
for (const bytes of files) {
    const doc = new WasmPdfDocument(bytes);
    allText.push(doc.extractAllText());
    doc.free();
}
console.log(allText.join("\n"));

Rust

let files = ["intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf"];
let mut editor = DocumentEditor::open(files[0])?;
for f in &files[1..] {
    editor.merge_from(f)?;
}
editor.save("book.pdf")?;

Go

// Top-level Merge returns the combined PDF bytes in one call
bytes, err := pdfoxide.Merge([]string{
    "intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf",
})
if err != nil { log.Fatal(err) }
_ = os.WriteFile("book.pdf", bytes, 0644)

C++

// Top-level merge returns the combined PDF bytes in one call
auto bytes = pdf_oxide::merge({"intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf"});
std::ofstream("book.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(bytes.data()), bytes.size());

Swift

// Top-level merge returns the combined PDF bytes in one call
let bytes = try merge(["intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf"])
try Data(bytes).write(to: URL(fileURLWithPath: "book.pdf"))

Dart

// Top-level pdfMerge returns the combined PDF bytes in one call
final bytes = pdfMerge(['intro.pdf', 'chapter1.pdf', 'chapter2.pdf', 'appendix.pdf']);
File('book.pdf').writeAsBytesSync(bytes);

R

# Top-level pdf_merge returns the combined PDF bytes in one call
bytes <- pdf_merge(c("intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf"))
writeBin(bytes, "book.pdf")

Julia

# Top-level merge_pdfs returns the combined PDF bytes in one call
bytes = merge_pdfs(["intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf"])
write("book.pdf", bytes)

Zig

const a = std.heap.page_allocator;
const paths = [_][*:0]const u8{ "intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf" };
const bytes = try pdf_oxide.merge(a, &paths); // combined PDF bytes
defer a.free(bytes);
const out = try std.fs.cwd().createFile("book.pdf", .{});
defer out.close();
try out.writeAll(bytes);

Objective-C

// Top-level merge returns the combined PDF bytes in one call
NSData *bytes = [POXTools merge:@[@"intro.pdf", @"chapter1.pdf", @"chapter2.pdf", @"appendix.pdf"]
                          error:&err];
[bytes writeToFile:@"book.pdf" atomically:YES];

Elixir

# Top-level merge returns the combined PDF bytes in one call
{:ok, bytes} = PdfOxide.merge(["intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf"])
File.write!("book.pdf", bytes)

Mesclar Páginas Específicas

Escolha quais páginas mesclar do documento de origem:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("main.pdf")
# Merge only pages 0, 2, and 4 from source
doc.merge_pages_from("source.pdf", [0, 2, 4])
doc.save("selected.pdf")

Rust

let mut editor = DocumentEditor::open("main.pdf")?;
editor.merge_pages_from("source.pdf", &[0, 2, 4])?;
editor.save("selected.pdf")?;

Dividir PDFs

Extrair Páginas para um Novo Arquivo

Extrair páginas específicas de um documento grande:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("book.pdf")
doc.extract_pages([0, 1, 2, 3, 4], "chapter1.pdf")

WASM

// Extract text from specific pages
const doc = new WasmPdfDocument(bytes);
const pages = [0, 1, 2, 3, 4];
for (const i of pages) {
    const text = doc.extractText(i);
    console.log(`Page ${i + 1}: ${text.slice(0, 80)}...`);
}
doc.free();

Rust

let mut editor = DocumentEditor::open("book.pdf")?;
editor.extract_pages(&[0, 1, 2, 3, 4], "chapter1.pdf")?;

Dividir em Páginas Individuais

Salvar cada página como um arquivo separado:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("document.pdf")
for i in range(doc.page_count()):
    doc.extract_pages([i], f"page_{i + 1}.pdf")

Rust

let mut editor = DocumentEditor::open("document.pdf")?;
let page_count = editor.page_count()?;
for i in 0..page_count {
    editor.extract_pages(&[i], &format!("page_{}.pdf", i + 1))?;
}

Dividir em Blocos

Dividir um PDF grande em arquivos menores com N páginas cada:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("large.pdf")
chunk_size = 10

for start in range(0, doc.page_count(), chunk_size):
    end = min(start + chunk_size, doc.page_count())
    pages = list(range(start, end))
    doc.extract_pages(pages, f"chunk_{start // chunk_size + 1}.pdf")

Rust

let mut editor = DocumentEditor::open("large.pdf")?;
let page_count = editor.page_count()?;
let chunk_size = 10;

for start in (0..page_count).step_by(chunk_size) {
    let end = (start + chunk_size).min(page_count);
    let pages: Vec<usize> = (start..end).collect();
    editor.extract_pages(&pages, &format!("chunk_{}.pdf", start / chunk_size + 1))?;
}

Dividir para Bytes em Memória (Sem Arquivos Temporários)

Quando os blocos divididos vão direto para o S3, uma resposta HTTP ou outro passo no processo, use extract_pages_to_bytes para pular completamente a escrita em disco. Ele retorna o novo PDF como bytes e não modifica o documento de origem.

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("large.pdf")
chunk_size = 10
chunks = []

for start in range(0, doc.page_count(), chunk_size):
    end = min(start + chunk_size, doc.page_count())
    pages = list(range(start, end))
    chunk_bytes = doc.extract_pages_to_bytes(pages)  # bytes, not a file
    chunks.append(chunk_bytes)

print(f"Produced {len(chunks)} in-memory chunks")

Rust

let mut editor = DocumentEditor::open("large.pdf")?;
let page_count = editor.page_count()?;
let chunk_size = 10;
let mut chunks: Vec<Vec<u8>> = Vec::new();

for start in (0..page_count).step_by(chunk_size) {
    let end = (start + chunk_size).min(page_count);
    let pages: Vec<usize> = (start..end).collect();
    chunks.push(editor.extract_pages_to_bytes(&pages)?); // Vec<u8>, no file written
}

Swift

let editor = try DocumentEditor(path: "large.pdf")
let pageCount = try editor.pageCount()
let chunkSize = 10
var chunks: [[UInt8]] = []

for start in stride(from: 0, to: pageCount, by: chunkSize) {
    let end = min(start + chunkSize, pageCount)
    chunks.append(try editor.extractPagesToBytes(Array(start..<end)))
}

C++

auto editor = pdf_oxide::DocumentEditor::open("large.pdf");
int page_count = editor.page_count();
const int chunk_size = 10;
std::vector<std::vector<std::uint8_t>> chunks;

for (int start = 0; start < page_count; start += chunk_size) {
    int end = std::min(start + chunk_size, page_count);
    std::vector<int32_t> pages;
    for (int i = start; i < end; ++i) pages.push_back(i);
    chunks.push_back(editor.extract_pages_to_bytes(pages)); // bytes, no file written
}

Dart

final editor = DocumentEditor.open('large.pdf');
final pageCount = editor.pageCount;
const chunkSize = 10;
final chunks = <Uint8List>[];

for (var start = 0; start < pageCount; start += chunkSize) {
  final end = (start + chunkSize).clamp(0, pageCount);
  final pages = [for (var i = start; i < end; i++) i];
  chunks.add(editor.extractPagesToBytes(pages)); // bytes, no file written
}

R

editor <- pdf_editor_open("large.pdf")
page_count <- pdf_editor_page_count(editor)
chunk_size <- 10
chunks <- list()

for (start in seq(0, page_count - 1, by = chunk_size)) {
  end <- min(start + chunk_size, page_count)
  pages <- seq(start, end - 1)
  chunks[[length(chunks) + 1]] <- pdf_editor_extract_pages_to_bytes(editor, pages)
}

Julia

editor = open_editor("large.pdf")
n = page_count(editor)
chunk_size = 10
chunks = Vector{Vector{UInt8}}()

for start in 0:chunk_size:(n - 1)
    stop = min(start + chunk_size, n)
    pages = collect(start:(stop - 1))
    push!(chunks, extract_pages_to_bytes(editor, pages))  # bytes, no file written
end

Zig

const a = std.heap.page_allocator;
var editor = try pdf_oxide.DocumentEditor.openEditor("large.pdf");
defer editor.deinit();
const page_count = try editor.pageCount();
const chunk_size: i32 = 10;

var start: i32 = 0;
while (start < page_count) : (start += chunk_size) {
    const end = @min(start + chunk_size, page_count);
    var pages = std.ArrayList(i32).init(a);
    defer pages.deinit();
    var i = start;
    while (i < end) : (i += 1) try pages.append(i);
    const chunk = try editor.extractPagesToBytes(a, pages.items); // bytes, no file written
    a.free(chunk);
}

Objective-C

POXDocumentEditor *editor = [POXDocumentEditor openEditor:@"large.pdf" error:&err];
NSInteger pageCount = [editor pageCountError:&err];
NSInteger chunkSize = 10;
NSMutableArray<NSData*> *chunks = [NSMutableArray array];

for (NSInteger start = 0; start < pageCount; start += chunkSize) {
    NSInteger end = MIN(start + chunkSize, pageCount);
    NSMutableArray<NSNumber*> *pages = [NSMutableArray array];
    for (NSInteger i = start; i < end; i++) [pages addObject:@(i)];
    [chunks addObject:[editor extractPagesToBytes:pages error:&err]]; // bytes, no file written
}

Elixir

{:ok, editor} = PdfOxide.open_editor("large.pdf")
{:ok, n} = PdfOxide.editor_page_count(editor)
chunk_size = 10

chunks =
  0..(n - 1)
  |> Enum.take_every(chunk_size)
  |> Enum.map(fn start ->
    stop = min(start + chunk_size, n)
    {:ok, bytes} = PdfOxide.extract_pages_to_bytes(editor, Enum.to_list(start..(stop - 1)))
    bytes
  end)

extract_pages_to_bytes está disponível em Python, Rust, Swift, C++, Dart, R, Julia, Zig, Objective-C, Elixir e no C ABI. Não é exposto na build WASM.

Dividir por Marcadores

Para documentos com um índice (sumário), você pode planejar uma divisão nos limites dos marcadores — por exemplo, um PDF por capítulo de nível superior — sem calcular os intervalos de páginas manualmente. plan_split_by_bookmarks é o planejador de simulação: ele retorna o plano de segmentos (intervalos de páginas, títulos, nomes de arquivo seguros para o sistema de arquivos) sem produzir nenhum byte de PDF, para que você possa visualizar, filtrar ou redirecionar a saída antes de escrever qualquer coisa.

Planejar a Divisão (Simulação)

Python

import pdf_oxide

with open("manual.pdf", "rb") as f:
    src = f.read()

# level=1 -> split at top-level bookmarks only (0 = every depth, n = up to depth n)
segments = pdf_oxide.plan_split_by_bookmarks(src, level=1)

for seg in segments:
    # keys: index, start_page, end_page, title, file_stem, page_label
    print(f"#{seg['index']}: pages {seg['start_page']}-{seg['end_page'] - 1} "
          f"=> {seg['file_stem']}.pdf  ({seg['title']})")

Rust

use pdf_oxide::PdfDocument;
use pdf_oxide::split_bookmarks::{plan_split_by_bookmarks, SplitByBookmarksOptions, BookmarkLevel};

let doc = PdfDocument::open("manual.pdf")?;

let opts = SplitByBookmarksOptions {
    level: BookmarkLevel::TopLevel,  // top-level bookmarks only
    ..Default::default()
};

// Cheap: returns Vec<BookmarkSegment>, no PDF bytes produced
let segments = plan_split_by_bookmarks(&doc, &opts)?;
for seg in &segments {
    println!("#{}: pages {}..{} => {}.pdf ({:?})",
        seg.index, seg.start_page, seg.end_page, seg.file_stem, seg.title);
}

Swift

import PdfOxide

let doc = try PdfDocument(path: "manual.pdf")

// Returns a JSON array of segment objects (index, startPage, endPage, ...)
let planJson = try doc.planSplitByBookmarks(optionsJson: #"{"level": 1}"#)
print(planJson)

WASM

import { planSplitByBookmarks } from "pdf-oxide-wasm";

// level 1 = top-level bookmarks; returns an array of segment objects
const segments = planSplitByBookmarks(bytes, null, false, 1, true);
for (const seg of segments) {
  console.log(`#${seg.index}: ${seg.startPage}-${seg.endPage} => ${seg.fileStem}.pdf`);
}

Java

import fyi.oxide.pdf.Pdf;
import java.nio.file.*;

byte[] src = Files.readAllBytes(Path.of("manual.pdf"));

// level 1 = top-level bookmarks; returns the number of segments the split would produce
int segmentCount = Pdf.planSplitByBookmarksCount(src, 1);
System.out.println(segmentCount + " segments");

Ruby

require 'pdf_oxide'

src = File.binread('manual.pdf')

# level 1 = top-level bookmarks; returns the number of segments the split would produce
segment_count = PdfOxide::Pdf.plan_split_by_bookmarks_count(src, 1)
puts "#{segment_count} segments"

C++

auto doc = pdf_oxide::Document::open("manual.pdf");

// Returns a JSON array of segment objects (index, start_page, end_page, ...)
std::string planJson = doc.plan_split_by_bookmarks(R"({"level": 1})");
std::cout << planJson << "\n";

Dart

final doc = PdfDocument.open('manual.pdf');

// Returns a JSON array of segment objects (index, startPage, endPage, ...)
final planJson = doc.planSplitByBookmarks('{"level": 1}');
print(planJson);

R

doc <- pdf_open("manual.pdf")

# Returns a JSON array of segment objects (index, start_page, end_page, ...)
plan_json <- pdf_plan_split_by_bookmarks(doc, '{"level": 1}')
cat(plan_json, "\n")

Julia

doc = open_document("manual.pdf")

# Returns a JSON array of segment objects (index, start_page, end_page, ...)
plan_json = plan_split_by_bookmarks(doc, """{"level": 1}""")
println(plan_json)

Zig

const a = std.heap.page_allocator;
var doc = try pdf_oxide.Document.open("manual.pdf");
defer doc.deinit();

// Returns a JSON array of segment objects (index, start_page, end_page, ...)
const plan_json = try doc.planSplitByBookmarks(a, "{\"level\": 1}");
defer a.free(plan_json);
std.debug.print("{s}\n", .{plan_json});

Objective-C

POXDocument *doc = [POXDocument openPath:@"manual.pdf" error:&err];

// Returns a JSON array of segment objects (index, start_page, end_page, ...)
NSString *planJson = [doc planSplitByBookmarks:@"{\"level\": 1}" error:&err];
NSLog(@"%@", planJson);

Elixir

{:ok, doc} = PdfOxide.open("manual.pdf")

# Returns a JSON array of segment objects (index, start_page, end_page, ...)
{:ok, plan_json} = PdfOxide.plan_split_by_bookmarks(doc, ~s({"level": 1}))
IO.puts(plan_json)

Cada segmento contém: index (ordinal baseado em 1), start_page (inclusivo, baseado em 0), end_page (exclusivo, baseado em 0 — o intervalo é start_page..end_page), title (o título do marcador de origem, null para um segmento de material introdutório), file_stem (nome base sem extensão, deduplicado e seguro para o sistema de arquivos) e page_label.

Opções de Divisão

Opção	Padrão	Descrição
title_prefix	nenhum	Dividir apenas nos marcadores cujo título começa com este prefixo
ignore_case	false	Correspondência de prefixo sem distinção de maiúsculas e minúsculas
level	1 (nível superior)	0 = todas as profundidades, 1 = somente nível superior, n = até a profundidade n
include_front_matter	true	Emitir as páginas antes do primeiro ponto de divisão como segmento inicial

Planejar e Depois Extrair

Como o plano é apenas intervalos de páginas, você pode passar cada segmento diretamente para o extrator em memória — sem precisar recalcular os limites.

import pdf_oxide
from pdf_oxide import PdfDocument

with open("manual.pdf", "rb") as f:
    src = f.read()

doc = PdfDocument.from_bytes(src)
for seg in pdf_oxide.plan_split_by_bookmarks(src, level=1):
    pages = list(range(seg["start_page"], seg["end_page"]))
    chunk = doc.extract_pages_to_bytes(pages)
    with open(f"{seg['file_stem']}.pdf", "wb") as out:
        out.write(chunk)

Cobertura de bindings. plan_split_by_bookmarks está disponível em Python (função de nível de módulo pdf_oxide.plan_split_by_bookmarks), Rust (pdf_oxide::split_bookmarks::plan_split_by_bookmarks), Swift (planSplitByBookmarks), WASM (planSplitByBookmarks) e C ABI (pdf_document_plan_split_by_bookmarks). Lança um erro (Python RuntimeError) quando o documento não tem índice — use uma divisão por página ou por bloco nesses casos.

Perguntas Frequentes

Qual é a diferença entre extract_pages e extract_pages_to_bytes? extract_pages(pages, output) grava o resultado em um caminho de arquivo; extract_pages_to_bytes(pages) retorna o novo PDF como bytes em memória. Ambos aceitam índices de página baseados em 0 e não modificam o documento de origem — escolha a variante em memória quando a saída for transmitida ou armazenada sem tocar no disco.

plan_split_by_bookmarks cria arquivos PDF? Não. É um planejador puro e leve que retorna apenas metadados dos segmentos (intervalos de páginas, títulos, nomes dos arquivos). Para realmente gerar os blocos, combine-o com extract_pages_to_bytes ou use o helper de uma única chamada split_by_bookmarks (Python/Rust/WASM), que retorna pares de segmento mais bytes.

Como dividir um PDF em um arquivo por capítulo? Se o seu PDF tem um índice, chame plan_split_by_bookmarks(src, level=1) para obter um segmento por marcador de nível superior e extraia o intervalo start_page..end_page de cada segmento com extract_pages_to_bytes. Defina level=0 para dividir em todas as profundidades do índice.

Por que a divisão é tão rápida? A divisão opera no nível de objetos PDF no núcleo Rust puro do PDF Oxide — o mesmo motor que aparece nos benchmarks com média de 0,8 ms de extração e 100% de taxa de sucesso. O planejamento de uma divisão toca apenas o índice e a contagem de páginas, então é praticamente instantâneo mesmo para documentos grandes.

Páginas Relacionadas

• Operações de Página — rotação, recorte e reordenação
• Processamento em Lote — padrões de processamento paralelo
• Começando com Python — instalação e conceitos básicos