Skip to content
PDF Oxide

Page-API-Referenz

Ab v0.3.34 stellt jede Sprachbindung ein Page-Objekt bereit, mit dem du ein Dokument seitenweise durchlaufen und Extraktionsmethoden direkt auf der Seite aufrufen kannst, anstatt page_index durch jeden Aufruf zu schleifen. Der Typ heißt in Python, Node.js, C# und Go einheitlich Page; Rust bietet dieselbe Struktur über PdfPage an.

Schnellbeispiel

Python

from pdf_oxide import PdfDocument

with PdfDocument("paper.pdf") as doc:
    for page in doc:                       # len(doc), doc[i], doc[-1] also work
        print(page.text[:80])
        md = page.markdown(detect_headings=True)

Rust

use pdf_oxide::api::Pdf;

let mut doc = Pdf::open("paper.pdf")?;
for i in 0..doc.page_count()? {
    let page = doc.page(i)?;
    println!("{}", &page.text()?[..80]);
}

JavaScript / TypeScript (Node)

const { PdfDocument } = require("pdf-oxide");

const doc = new PdfDocument("paper.pdf");
for (const page of doc) {
  console.log(page.extractText().slice(0, 80));
}
doc.close();

Go

package main

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

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

    pages, _ := doc.Pages()
    for _, page := range pages {
        text, _ := page.ExtractText()
        fmt.Println(text[:80])
    }
}

C#

using PdfOxide;

using var doc = PdfDocument.Open("paper.pdf");
foreach (var page in doc.Pages)
{
    Console.WriteLine(page.ExtractText()[..Math.Min(80, page.ExtractText().Length)]);
}

Java

import fyi.oxide.pdf.PdfDocument;
import java.nio.file.Path;

try (PdfDocument doc = PdfDocument.open(Path.of("paper.pdf"))) {
    for (int i = 0; i < doc.pageCount(); i++) {
        String text = doc.extractText(i);
        System.out.println(text.substring(0, Math.min(80, text.length())));
        String md = doc.toMarkdown(i);
    }
}

Kotlin

import fyi.oxide.pdf.PdfDocument

PdfDocument.open(java.nio.file.Path.of("paper.pdf")).use { doc ->
    for (i in 0 until doc.pageCount()) {
        val text = doc.extractText(i)
        println(text.substring(0, minOf(80, text.length)))
        val md = doc.toMarkdown(i)
    }
}

Scala

import fyi.oxide.pdf.PdfDocument
import scala.util.Using

Using.resource(PdfDocument.open("paper.pdf")) { doc =>
  for (i <- 0 until doc.pageCount()) {
    val text = doc.extractText(i)
    println(text.substring(0, math.min(80, text.length)))
    val md = doc.toMarkdown(i)
  }
}

Clojure

(require '[pdf-oxide.core :as pdf])

(with-open [doc (pdf/open "paper.pdf")]
  (doseq [i (range (pdf/page-count doc))]
    (let [text (pdf/extract-text doc i)]
      (println (subs text 0 (min 80 (count text))))
      (pdf/to-markdown doc i))))

Ruby

require 'pdf_oxide'

PdfOxide::PdfDocument.open('paper.pdf') do |doc|
  (0...doc.page_count).each do |i|
    text = doc.extract_text(i)
    puts text[0, 80]
    md = doc.to_markdown(i)
  end
end

PHP

use PdfOxide\PdfDocument;

$doc = PdfDocument::open('paper.pdf');
for ($i = 0; $i < $doc->pageCount(); $i++) {
    $text = $doc->extractText($i);
    echo substr($text, 0, 80), "\n";
    $md = $doc->toMarkdown($i);
}
$doc->close();

C++

#include <pdf_oxide/pdf_oxide.hpp>

auto doc = pdf_oxide::Document::open("paper.pdf");
for (int i = 0; i < doc.page_count(); i++) {
    auto text = doc.extract_text(i);
    std::cout << text.substr(0, 80) << "\n";
    auto md = doc.to_markdown(i);
}

Swift

import PdfOxide

let doc = try Document.open("paper.pdf")
for i in 0..<(try doc.pageCount()) {
    let text = try doc.extractText(i)
    print(text.prefix(80))
    let md = try doc.toMarkdown(i)
}

Dart

import 'package:pdf_oxide/pdf_oxide.dart';

final doc = PdfDocument.open('paper.pdf');
for (var i = 0; i < doc.pageCount; i++) {
  final text = doc.extractText(i);
  print(text.substring(0, text.length < 80 ? text.length : 80));
  final md = doc.toMarkdown(i);
}
doc.close();

R

library(pdfoxide)

doc <- pdf_open("paper.pdf")
for (i in 0:(pdf_page_count(doc) - 1)) {
  text <- pdf_extract_text(doc, i)
  cat(substr(text, 1, 80), "\n")
  md <- pdf_to_markdown(doc, i)
}

Julia

using PdfOxide

doc = open_document("paper.pdf")
for i in 0:(page_count(doc) - 1)
    text = extract_text(doc, i)
    println(first(text, 80))
    md = to_markdown(doc, i)
end

Zig

const pdf_oxide = @import("pdf_oxide");
const a = std.heap.page_allocator;

var doc = try pdf_oxide.Document.open("paper.pdf");
var i: usize = 0;
while (i < try doc.pageCount()) : (i += 1) {
    const text = try doc.extractText(a, i);
    std.debug.print("{s}\n", .{text[0..@min(80, text.len)]});
    const md = try doc.toMarkdown(a, i);
}

Objective-C

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

POXDocument *doc = [POXDocument openPath:@"paper.pdf" error:&err];
for (NSInteger i = 0; i < [doc pageCountError:&err]; i++) {
    NSString *text = [doc extractText:i error:&err];
    NSLog(@"%@", [text substringToIndex:MIN(80, text.length)]);
    NSString *md = [doc toMarkdown:i error:&err];
}

Elixir

{:ok, doc} = PdfOxide.open("paper.pdf")
{:ok, n} = PdfOxide.page_count(doc)
for i <- 0..(n - 1) do
  {:ok, text} = PdfOxide.extract_text(doc, i)
  IO.puts(String.slice(text, 0, 80))
  {:ok, md} = PdfOxide.to_markdown(doc, i)
end

Python — Page

Lazy Properties — der Inhalt wird beim ersten Zugriff geparst und auf dem Page-Objekt gecacht.

Member Rückgabe Beschreibung
page.text str Extrahierter Text (spaltenorientiert)
page.chars list[Char] Zeichenebenen-Einträge mit Bounding Box und Schriftart
page.words list[Word] Wortebenen-Einträge mit Bounding Box
page.lines list[TextLine] Textzeilen mit Bounding Box
page.spans list[Span] Formatierte Spans (Schriftart, Größe, Gewicht)
page.tables list[Table] Strukturierte Tabellenzeilen und Zell-Bounding-Boxes
page.images list[Image] Bildmetadaten
page.paths list[Path] Vektorpfad-Einträge
page.annotations list[Annotation] Annotationen auf dieser Seite
page.markdown(detect_headings=True) str Markdown-Konvertierung
page.plain_text() str Reiner Text (ohne Layout-Hinweise)
page.html() str HTML-Konvertierung
page.render(format="png") bytes Seite als PNG / JPEG rendern
page.search(term, case_sensitive=False) list[SearchResult] Text auf dieser Seite suchen
page.region(rect) PageRegion Extraktion auf einen Bereich eingrenzen 
with PdfDocument("paper.pdf") as doc:
    page = doc[0]                 # or doc.page(0)
    for word in page.words:       # first access parses; subsequent calls cached
        print(word.text, word.bbox)

    # Scoped extraction
    header = page.region((0, 700, 612, 92)).extract_text()

Die vorhandene Editor-Klasse PdfPage (zum Schreiben) bleibt unverändert; das neue Page ist ausschließlich lesend.

Rust — PdfPage

use pdf_oxide::api::Pdf;

let mut doc = Pdf::open("paper.pdf")?;
let page = doc.page(0)?;

let text = page.text()?;
let words = page.extract_words()?;
let tables = page.extract_tables()?;
let md = page.to_markdown(true)?;

Verfügbare Methoden auf PdfPage:

  • text(), plain_text(), to_markdown(detect_headings), to_html()
  • extract_chars(), extract_words(), extract_lines(), extract_spans()
  • extract_tables(), extract_paths(), extract_images()
  • annotations(), render(format)
  • search(term) — seitengebundene Suche
  • find_text_containing(substring) — DOM-Treffer-Liste mit IDs

Node.js — Page

const { PdfDocument } = require("pdf-oxide");

const doc = new PdfDocument("paper.pdf");
const page = doc.page(0);

console.log(page.width, page.height, page.rotation);  // cached
console.log(page.extractText());
const words = page.extractWords();
const tables = page.extractTables();
const md = page.toMarkdown();

PdfDocument unterstützt for..of über Symbol.iterator sowie doc.page(i) und doc.pageCount().

Sechs bisher rein native Methoden stehen nun über den TS-Layer sowohl auf Page als auch auf PdfDocument zur Verfügung:

  • extractWords
  • extractTextLines
  • extractTables
  • extractPaths
  • getEmbeddedImages
  • ocrExtractText

Jede Methode hat ein asynchrones Pendant — extractTextAsync, toMarkdownAsync usw.

Go — Page

doc, _ := pdfoxide.Open("paper.pdf")
defer doc.Close()

page, _ := doc.Page(0)
text, _ := page.ExtractText()
md, _   := page.ToMarkdown()
tables, _ := page.ExtractTables()

// Iterate every page
all, _ := doc.Pages()
for i, p := range all {
    t, _ := p.ExtractText()
    fmt.Printf("page %d: %d chars\n", i, len(t))
}

Go’s Page-Struct bietet die vollständige Methodenoberfläche: ExtractText, ToMarkdown, ToHtml, ToPlainText, ExtractWords, ExtractTextLines, ExtractTables, ExtractChars, ExtractPaths, Annotations, Images, Fonts, RenderPage, Search.

C# — Page

using PdfOxide;

using var doc = PdfDocument.Open("paper.pdf");

Page page = doc[0];                            // or doc.Pages[0] or doc.Page(0)
string text = page.ExtractText();
string md   = page.ToMarkdown();
Table[] tables = page.ExtractTables();

// Async variants
string textAsync = await page.ExtractTextAsync();
string mdAsync   = await page.ToMarkdownAsync();

doc.Pages ist eine IReadOnlyList<Page>. Jede synchrone Methode hat ein async Task<T>-Pendant mit CancellationToken-Unterstützung.

Struktur von Tabellen

extract_tables() (verfügbar auf PdfDocument und Page) gibt sprachübergreifend einen einheitlichen Table-Typ zurück:

Sprache Typ Zellzugriff
Rust Table rows[i].cells[j] iterieren
Python dict row["cells"][i]["text"]
Go Table table.CellText(row, col)
C# Table table.CellText(row, col)
Node.js Table-Interface table.cells[row][col]

Jede Zelle enthält den Text sowie eine Bounding Box, sodass du die Extraktion den Koordinaten auf der Seite zuordnen kannst.

Migration von doc.extract_*(page_index)

Alt (weiterhin unterstützt):

doc = PdfDocument("paper.pdf")
for i in range(doc.page_count()):
    print(doc.extract_text(i))
    print(doc.to_markdown(i, detect_headings=True))
    print(doc.extract_tables(i))

Neu (v0.3.34+):

with PdfDocument("paper.pdf") as doc:
    for page in doc:
        print(page.text)
        print(page.markdown(detect_headings=True))
        print(page.tables)

Beide Stile bleiben unterstützt; der Page-Stil ist bei seitenweise verarbeitenden Pipelines lesbarer und erspart das laufende Mitführen von Seitenindizes.

Verwandte Seiten