bench: add pdfium comparison, show pages/sec metric

Add pypdfium2 (Chrome's PDF engine) to benchmark comparisons.
Changed output to show pages/sec which is more useful for comparison.
Removed reading order from default benchmark since it's experimental.

Author: Lulzx

benchmark/accuracy.py

@@ -2,7 +2,11 @@
 """
 ZPDF Correctness Benchmark
 
-Compares text extraction accuracy against MuPDF (reference), Tika (PDFBox), and pdftotext (Poppler).
+Compares text extraction accuracy and speed against:
+- MuPDF (mutool) - accuracy reference
+- pdfium (pypdfium2) - speed reference (Chrome's PDF engine)
+- Tika (PDFBox)
+- pdftotext (Poppler)
 
 Usage:
     python benchmark/accuracy.py [pdf_files...]
@@ -17,6 +21,13 @@
 sys.path.insert(0, str(Path(__file__).parent.parent / "python"))
 import zpdf
 
+# Try to import pypdfium2 for pdfium comparison
+try:
+    import pypdfium2 as pdfium
+    HAS_PDFIUM = True
+except ImportError:
+    HAS_PDFIUM = False
+
 
 def normalize(text: str) -> str:
     import re
@@ -86,6 +97,22 @@ def extract_pdftotext(pdf_path: str) -> tuple:
     return result.stdout, elapsed
 
 
+def extract_pdfium(pdf_path: str) -> tuple:
+    """Extract text using pdfium (Chrome's PDF engine)."""
+    if not HAS_PDFIUM:
+        return "", 0
+
+    start = time.perf_counter()
+    pdf = pdfium.PdfDocument(pdf_path)
+    texts = []
+    for page in pdf:
+        textpage = page.get_textpage()
+        texts.append(textpage.get_text_bounded())
+    text = "\f".join(texts)
+    elapsed = (time.perf_counter() - start) * 1000
+    return text, elapsed, len(pdf)
+
+
 def check_tool(name: str, cmd: list) -> bool:
     try:
         subprocess.run(cmd, capture_output=True)
@@ -114,23 +141,31 @@ def main():
         print("mutool (MuPDF) not found - required as reference")
         sys.exit(1)
 
-    print("ZPDF Accuracy Benchmark")
+    print("ZPDF Accuracy & Speed Benchmark")
     print()
-    print("Reference: MuPDF (mutool)")
-    print(f"Tools: zpdf (reading order), zpdf (stream order), mutool{', tika' if has_tika else ''}{', pdftotext' if has_pdftotext else ''}")
+    print("Reference: MuPDF (mutool) for accuracy")
+    tools = ["zpdf", "mutool"]
+    if HAS_PDFIUM:
+        tools.append("pdfium")
+    if has_tika:
+        tools.append("tika")
+    if has_pdftotext:
+        tools.append("pdftotext")
+    print(f"Tools: {', '.join(tools)}")
     print()
 
     for pdf in pdf_files:
         print(f"--- {pdf.name} ---")
 
         try:
             # Extract with all tools
-            # zpdf with reading order (default)
-            zpdf_ro_text, zpdf_ro_ms, pages = extract_zpdf(str(pdf), reading_order=True)
-            # zpdf with stream order (for comparison)
-            zpdf_so_text, zpdf_so_ms, _ = extract_zpdf(str(pdf), reading_order=False)
+            zpdf_text, zpdf_ms, pages = extract_zpdf(str(pdf), reading_order=False)
             mutool_text, mutool_ms = extract_mutool(str(pdf))
 
+            pdfium_text, pdfium_ms = ("", 0)
+            if HAS_PDFIUM:
+                pdfium_text, pdfium_ms, _ = extract_pdfium(str(pdf))
+
             tika_text, tika_ms = ("", 0)
             if has_tika:
                 tika_text, tika_ms = extract_tika(str(pdf))
@@ -140,51 +175,55 @@ def main():
                 pdftotext_text, pdftotext_ms = extract_pdftotext(str(pdf))
 
             # Normalize
-            zpdf_ro_norm = normalize(zpdf_ro_text)
-            zpdf_so_norm = normalize(zpdf_so_text)
+            zpdf_norm = normalize(zpdf_text)
             mutool_norm = normalize(mutool_text)
+            pdfium_norm = normalize(pdfium_text) if HAS_PDFIUM else ""
             tika_norm = normalize(tika_text) if has_tika else ""
             pdftotext_norm = normalize(pdftotext_text) if has_pdftotext else ""
 
             # Compute metrics vs MuPDF reference
             print(f"Pages: {pages}")
             print()
-            print(f"{'Tool':<20} {'Char Acc':>10} {'WER':>8} {'Time':>10} {'Speedup':>10}")
-            print("-" * 60)
+            print(f"{'Tool':<12} {'Char Acc':>10} {'WER':>8} {'Time':>10} {'pages/sec':>12}")
+            print("-" * 54)
 
-            # zpdf (reading order) - default
-            acc = char_accuracy(zpdf_ro_norm, mutool_norm)
-            wer = word_error_rate(zpdf_ro_norm, mutool_norm)
-            speedup = mutool_ms / zpdf_ro_ms if zpdf_ro_ms > 0 else 0
-            print(f"{'zpdf (reading)':<20} {acc:>9.1%} {wer:>7.1%} {zpdf_ro_ms:>8.0f}ms {speedup:>9.1f}x")
-
-            # zpdf (stream order) - for comparison
-            acc = char_accuracy(zpdf_so_norm, mutool_norm)
-            wer = word_error_rate(zpdf_so_norm, mutool_norm)
-            speedup = mutool_ms / zpdf_so_ms if zpdf_so_ms > 0 else 0
-            print(f"{'zpdf (stream)':<20} {acc:>9.1%} {wer:>7.1%} {zpdf_so_ms:>8.0f}ms {speedup:>9.1f}x")
+            # zpdf
+            acc = char_accuracy(zpdf_norm, mutool_norm)
+            wer = word_error_rate(zpdf_norm, mutool_norm)
+            pps = pages / (zpdf_ms / 1000) if zpdf_ms > 0 else 0
+            print(f"{'zpdf':<12} {acc:>9.1%} {wer:>7.1%} {zpdf_ms:>8.0f}ms {pps:>10,.0f}")
 
             # MuPDF (reference = 100%)
-            print(f"{'mutool':<20} {'100.0%':>10} {'0.0%':>8} {mutool_ms:>8.0f}ms {'1.0x':>10}")
+            pps = pages / (mutool_ms / 1000) if mutool_ms > 0 else 0
+            print(f"{'mutool':<12} {'100.0%':>10} {'0.0%':>8} {mutool_ms:>8.0f}ms {pps:>10,.0f}")
+
+            # pdfium
+            if HAS_PDFIUM:
+                acc = char_accuracy(pdfium_norm, mutool_norm)
+                wer = word_error_rate(pdfium_norm, mutool_norm)
+                pps = pages / (pdfium_ms / 1000) if pdfium_ms > 0 else 0
+                print(f"{'pdfium':<12} {acc:>9.1%} {wer:>7.1%} {pdfium_ms:>8.0f}ms {pps:>10,.0f}")
 
             # Tika
             if has_tika:
                 acc = char_accuracy(tika_norm, mutool_norm)
                 wer = word_error_rate(tika_norm, mutool_norm)
-                speedup = mutool_ms / tika_ms if tika_ms > 0 else 0
-                print(f"{'tika':<20} {acc:>9.1%} {wer:>7.1%} {tika_ms:>8.0f}ms {speedup:>9.1f}x")
+                pps = pages / (tika_ms / 1000) if tika_ms > 0 else 0
+                print(f"{'tika':<12} {acc:>9.1%} {wer:>7.1%} {tika_ms:>8.0f}ms {pps:>10,.0f}")
 
             # pdftotext
             if has_pdftotext:
                 acc = char_accuracy(pdftotext_norm, mutool_norm)
                 wer = word_error_rate(pdftotext_norm, mutool_norm)
-                speedup = mutool_ms / pdftotext_ms if pdftotext_ms > 0 else 0
-                print(f"{'pdftotext':<20} {acc:>9.1%} {wer:>7.1%} {pdftotext_ms:>8.0f}ms {speedup:>9.1f}x")
+                pps = pages / (pdftotext_ms / 1000) if pdftotext_ms > 0 else 0
+                print(f"{'pdftotext':<12} {acc:>9.1%} {wer:>7.1%} {pdftotext_ms:>8.0f}ms {pps:>10,.0f}")
 
             print()
 
         except Exception as e:
             print(f"Error: {e}")
+            import traceback
+            traceback.print_exc()
             print()