Use PyMuPDF instead of PyPDF (WIP)

Currently it’s impossible to implement horizontal and vertical mirroring
with MuPDF; see pymupdf/PyMuPDF#4822

One other test fails (pdfnup-recursive-links), but this appears to be a
trivial (ignorable) difference in colour quantization.

It’s also noteworthy that PyMuPDF is not yet packaged in Debian.

Author: rrthomas

psutils/command/psjoin.py

@@ -11,7 +11,7 @@
 import warnings
 from typing import IO
 
-from pypdf import PdfReader, PdfWriter
+from pymupdf import Document
 
 from psutils.argparse import HelpFormatter, add_version_argument
 from psutils.io import setup_inputs_and_output
@@ -64,15 +64,15 @@ def join_pdf(
     args: argparse.Namespace, infiles: list[IO[bytes]], outfile: IO[bytes]
 ) -> None:
     # Merge input files
-    out_pdf = PdfWriter()
+    out_pdf = Document()
     for file in infiles:
-        in_pdf = PdfReader(file)
-        out_pdf.append(in_pdf)
-        if args.even and len(in_pdf.pages) % 2 == 1:
-            out_pdf.add_blank_page()
+        in_pdf = Document(stream=file)
+        out_pdf.insert_pdf(in_pdf)
+        if args.even and in_pdf.page_count % 2 == 1:
+            out_pdf.new_page()
 
     # Write output
-    out_pdf.write(outfile)
+    outfile.write(out_pdf.convert_to_pdf())
     sys.stdout.buffer.flush()
 
 

psutils/command/psnup.py

@@ -208,7 +208,7 @@ def psnup(argv: list[str] = sys.argv[1:]) -> None:
                 in_size = paper_size
         if size is None:
             die("output page size not set, and could not get default paper size")
-        assert(in_size)
+        assert in_size
 
         # Take account of flip
         if args.flip:
@@ -281,9 +281,10 @@ def reduce_waste(
         )
 
         # Page centring shifts
-        hshift, vshift = (ppwid / horiz - in_size.width * scale) / 2, (
-            pphgt / vert - in_size.height * scale
-        ) / 2
+        hshift, vshift = (
+            (ppwid / horiz - in_size.width * scale) / 2,
+            (pphgt / vert - in_size.height * scale) / 2,
+        )
 
         # Construct specification list
         spec_list = []
@@ -303,12 +304,12 @@ def reduce_waste(
                 xoff = args.margin + across * ppwid / horiz + hshift
             yoff = args.margin + up * pphgt / vert + vshift
             spec_list.append(
-                f'{page}{"L" if rotate else ""}@{scale:f}({xoff:f},{yoff:f})'
+                f"{page}{'L' if rotate else ''}@{scale:f}({xoff:f},{yoff:f})"
             )
 
         # Rearrange pages
         specs, modulo, flipped = parsespecs(
-            f'{args.nup}:{"+".join(spec_list)}', paper_context
+            f"{args.nup}:{'+'.join(spec_list)}", paper_context
         )
         transform = document_transform(
             doc, outfile, size, orig_in_size, specs, args.draw, in_size_guessed

psutils/readers.py

@@ -7,23 +7,20 @@
 import re
 from typing import IO
 
-from pypdf import PdfReader as PdfReaderBase
-from pypdf._utils import StrByteType
+from pymupdf import Document
 
 from .types import Rectangle
 from .warnings import die
 
 
-class PdfReader(PdfReaderBase):
+class PdfReader(Document):
     def __init__(
         self,
-        stream: StrByteType,
-        strict: bool = False,
-        password: str | bytes | None = None,
+        stream: IO[bytes],
     ) -> None:
-        super().__init__(stream, strict, password)
-        assert len(self.pages) > 0
-        mediabox = self.pages[0].mediabox
+        super().__init__(stream=stream)
+        assert self.page_count > 0
+        mediabox = self[0].mediabox
         self.size = Rectangle(mediabox.width, mediabox.height)
         self.size_guessed = False
 

psutils/transformers.py

@@ -4,7 +4,6 @@
 Released under the GPL version 3, or (at your option) any later version.
 """
 
-import io
 import shutil
 import sys
 from abc import ABC, abstractmethod
@@ -13,8 +12,7 @@
 from typing import IO
 from warnings import warn
 
-from pypdf import PdfWriter, Transformation
-from pypdf.annotations import PolyLine
+from pymupdf import Document, Identity, Matrix
 
 from .argparse import parserange
 from .io import setup_input_and_output
@@ -384,20 +382,20 @@ def __init__(
         super().__init__()
         self.outfile = outfile
         self.reader = reader
-        self.writer = PdfWriter()
+        self.writer = Document()
         self.draw = draw
         self.specs = specs
 
         if in_size is None:
             in_size = reader.size
         if size is None:
             size = in_size
-
+        assert size is not None
         self.size = size
         self.in_size = in_size
 
     def pages(self) -> int:
-        return len(self.reader.pages)
+        return self.reader.page_count
 
     def write_header(self, maxpage: int, modulo: int) -> None:
         pass
@@ -423,78 +421,67 @@ def write_page(
             len(page_specs) == 1
             and not page_specs[0].has_transform()
             and page_number < page_list.num_pages()
-            and 0 <= real_page < len(self.reader.pages)
+            and 0 <= real_page < self.reader.page_count
             and self.draw == 0
             and self.size == self.in_size
             and (
                 self.in_size.width is None
                 or (
-                    self.in_size.width == self.reader.pages[real_page].mediabox.width
-                    and self.in_size.height
-                    == self.reader.pages[real_page].mediabox.height
+                    self.in_size.width == self.reader[real_page].mediabox.width
+                    and self.in_size.height == self.reader[real_page].mediabox.height
                 )
             )
         ):
-            self.writer.add_page(self.reader.pages[real_page])
+            self.writer.insert_pdf(self.reader, from_page=real_page, to_page=real_page)
         else:
             # Add a blank page of the correct size to the end of the document
-            outpdf_page = self.writer.add_blank_page(self.size.width, self.size.height)
+            outpdf_page = self.writer.new_page(-1, self.size.width, self.size.height)
             for spec in page_specs:
                 page_number = page_index_to_page_number(spec, maxpage, modulo, pagebase)
                 real_page = page_list.real_page(page_number)
-                if page_number < page_list.num_pages() and 0 <= real_page < len(
-                    self.reader.pages
+                if (
+                    page_number < page_list.num_pages()
+                    and 0 <= real_page < self.reader.page_count
                 ):
                     # Calculate input page transformation
-                    t = Transformation()
+                    t = Matrix(Identity)
+                    mbox = self.reader[real_page].mediabox
                     if spec.hflip:
-                        t = t.transform(
-                            Transformation((-1, 0, 0, 1, self.in_size.width, 0))
-                        )
+                        t.concat(t, Matrix(-1, 0, 0, 1, self.in_size.width, 0))
                     elif spec.vflip:
-                        t = t.transform(
-                            Transformation((1, 0, 0, -1, 0, self.in_size.height))
-                        )
+                        t.concat(t, Matrix(1, 0, 0, -1, 0, self.in_size.height))
                     if spec.rotate != 0:
-                        t = t.rotate(spec.rotate % 360)
+                        t.prerotate(spec.rotate % 360)
                     if spec.scale != 1.0:
-                        t = t.scale(spec.scale, spec.scale)
+                        t.prescale(spec.scale, spec.scale)
                     if spec.off != Offset(0.0, 0.0):
-                        t = t.translate(spec.off.x, spec.off.y)
+                        # (t.prerotate applies translation according to original axes)
+                        t.e += spec.off.x
+                        t.f += spec.off.y
+                    # Transform input page mediabox
+                    t.concat(t, outpdf_page.transformation_matrix)
+                    mbox.transform(t)
                     # Merge input page into the output document
-                    outpdf_page.merge_transformed_page(self.reader.pages[real_page], t)
-                    if self.draw > 0:  # FIXME: draw the line at the requested width
-                        mediabox = self.reader.pages[real_page].mediabox
-                        line = PolyLine(
-                            vertices=[
-                                (
-                                    mediabox.left + spec.off.x,
-                                    mediabox.bottom + spec.off.y,
-                                ),
-                                (mediabox.left + spec.off.x, mediabox.top + spec.off.y),
-                                (
-                                    mediabox.right + spec.off.x,
-                                    mediabox.top + spec.off.y,
-                                ),
-                                (
-                                    mediabox.right + spec.off.x,
-                                    mediabox.bottom + spec.off.y,
-                                ),
-                                (
-                                    mediabox.left + spec.off.x,
-                                    mediabox.bottom + spec.off.y,
-                                ),
-                            ],
-                        )
-                        self.writer.add_annotation(outpdf_page, line)
+                    # FIXME: use Document.insert_pdf when outputting only
+                    # one page per page with only rotation. Otherwise, use
+                    # Document.bake() to get annotations & fields.
+                    outpdf_page.show_pdf_page(
+                        mbox, self.reader, real_page, rotate=spec.rotate % 360
+                    )
+                    if self.draw > 0:
+                        line = [
+                            (int(mbox.x0), int(mbox.y1)),
+                            (int(mbox.x0), int(mbox.y0)),
+                            (int(mbox.x1), int(mbox.y0)),
+                            (int(mbox.x1), int(mbox.y1)),
+                            (int(mbox.x0), int(mbox.y1)),
+                        ]
+                        outpdf_page.draw_polyline(line, width=self.draw)
 
     def finalize(self) -> None:
-        # PyPDF seeks, so write to a buffer first in case outfile is stdout.
-        buf = io.BytesIO()
-        self.writer.write(buf)
-        buf.seek(0)
-        self.outfile.write(buf.read())
+        self.outfile.write(self.writer.convert_to_pdf())
         self.outfile.flush()
+        self.writer.close()
 
 
 def document_transform(

pyproject.toml

@@ -11,7 +11,7 @@ urls = {Homepage = "https://github.com/rrthomas/psutils"}
 requires-python = ">= 3.12"
 dependencies = [
     "puremagic >= 1.26",
-    "pypdf >= 4.3.0",
+    "pymupdf",
 ]
 classifiers = [
     "Environment :: Console",
@@ -39,7 +39,7 @@ test = [
 requires = [
     "argparse-manpage[setuptools] >= 4.2",
     "puremagic >= 1.26",
-    "pypdf >= 4.3.0",
+    "pymupdf",
 ]
 
 [tool.build_manpages]

tox.ini

@@ -3,8 +3,10 @@ envlist = py312,py313
 
 [testenv]
 deps =
+    Wand
     argparse-manpage >= 4.2
     pyright
+    pytest
     ruff
     setuptools
     types-colorama