Fix CI failure due to spoofers not being updated to Tesseract 3.05 strings

Update release notes
Fix missing error message about trying to use sandwich on old tesseract
2017-09-01 16:17:26 -07:00 · 2017-09-01 12:50:45 -07:00 · 2017-09-01 12:50:36 -07:00 · 2017-09-01 12:47:22 -07:00 · 2017-09-01 01:00:32 -07:00 · 2017-08-30 13:25:54 -07:00
47 changed files with 1933 additions and 693 deletions
@@ -43,6 +43,7 @@ install:

 script:
 - mv ocrmypdf dont_import_this_ocrmypdf
+- tesseract --version
 - pytest -n auto
 - mv dont_import_this_ocrmypdf ocrmypdf

@@ -53,6 +54,7 @@ deploy:
  # OTOH if we ever need separate binary wheels then each version needs its
  # own deploy
 - provider: pypi
+  server: https://upload.pypi.org/legacy/
  user: ocrmypdf-travis
  password:
    secure: "DTFOmmNL6olA0+yXvp4u9jXZlZeqrJsJ0526jzqf4a3gZ6jnGTq5UI6WzRsslSyoMMfXKtHQebqHM6ogSgCZinyZ3ufHJo8fn9brxbEc2gsiWkbj5o3bGwdWMT1vNNE7XW0VCpw87rZ1EEwjl4FJHFudMlPR1yfU5+uq0k0PACo="
@@ -65,7 +67,7 @@ deploy:

  # test pypi
 - provider: pypi
-  server: https://testpypi.python.org/pypi
+  server: https://testpypi.pypi.org/legacy/
  user: ocrmypdf-travis
  password:
    secure: "DTFOmmNL6olA0+yXvp4u9jXZlZeqrJsJ0526jzqf4a3gZ6jnGTq5UI6WzRsslSyoMMfXKtHQebqHM6ogSgCZinyZ3ufHJo8fn9brxbEc2gsiWkbj5o3bGwdWMT1vNNE7XW0VCpw87rZ1EEwjl4FJHFudMlPR1yfU5+uq0k0PACo="
@@ -80,10 +82,9 @@ deploy:
  # we really just want to run after_deploy *after* pypi upload is done, but
  # after_deploy on runs if a given box deployed
 - provider: script
-  script: .travis/null_deploy.sh
+  script: /usr/bin/true
  on:
    branch: master
-    tags: false
    condition: $TRAVIS_OS_NAME == "osx"

 after_deploy: |
@@ -1,3 +1,6 @@
+#!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
+
 from string import Template
 from subprocess import run, PIPE
 import re
@@ -12,6 +15,7 @@ class Ocrmypdf < Formula
  ${ocrmypdf_sha256}

  depends_on :python3
+  depends_on :x11  # Pillow needs XQuartz
  depends_on "pkg-config" => :build
  depends_on "libffi"
  depends_on "tesseract"
@@ -23,9 +27,11 @@ class Ocrmypdf < Formula
  depends_on "openjpeg"
  depends_on "freetype"
  depends_on "libpng"
+  depends_on "libjpeg"
+  depends_on "webp"
+  depends_on "little-cms2"

 ${resources}
-
  def install
    ENV.append ["SETUPTOOLS_SCM_PRETEND_VERSION"], "v${ocrmypdf_version}"
    ENV.each do |key, value|
@@ -1,4 +1,5 @@
 #!/bin/bash
+# © 2017 James R. Barlow: github.com/jbarlow83
 set -euo pipefail
 set -x

@@ -26,5 +27,5 @@ sudo apt-get install -y --no-install-recommends \

 pip install --upgrade pip
 mkdir -p packages
-[ -f packages/unpaper_6.1-1.deb ] || wget -q https://dl.dropboxusercontent.com/u/28971240/unpaper_6.1-1.deb -O packages/unpaper_6.1-1.deb
+[ -f packages/unpaper_6.1-1.deb ] || wget -q 'https://www.dropbox.com/s/vaq0kbwi6e6au80/unpaper_6.1-1.deb?raw=1' -O packages/unpaper_6.1-1.deb
 sudo dpkg -i packages/unpaper_6.1-1.deb
@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-
-exit 0
@@ -1,4 +1,5 @@
 #!/bin/bash
+# © 2017 James R. Barlow: github.com/jbarlow83
 set -euo pipefail
 set -x

@@ -1,11 +1,14 @@
 #!/bin/bash
+# © 2017 James R. Barlow: github.com/jbarlow83
 set -euo pipefail
 set -x

 pip3 install homebrew-pypi-poet
 python3 .travis/autobrew.py
 cat ocrmypdf.rb
-brew audit ocrmypdf.rb
+
+# brew audit crashes Travis
+#brew audit ocrmypdf.rb

 # Important: disable debug output so token is hidden
 set +x
@@ -20,6 +20,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
  tesseract-ocr-spa \
  tesseract-ocr-deu

+ENV LANG=C.UTF-8
+
 RUN python3 -m venv --system-site-packages /appenv

 # This installs the latest binary wheel instead of the code in the current
@@ -30,6 +30,8 @@ RUN apt-get update \
 		tesseract-ocr-rus \
 		tesseract-ocr-chi-sim 

+ENV LANG=C.UTF-8
+
 RUN python3 -m venv --system-site-packages /appenv

 # This installs the latest binary wheel instead of the code in the current
@@ -1,6 +1,15 @@
 OCRmyPDF
 ========

+.. image:: https://travis-ci.org/jbarlow83/OCRmyPDF.svg?branch=master
+    :target: https://travis-ci.org/jbarlow83/OCRmyPDF
+
+.. image:: https://img.shields.io/pypi/v/ocrmypdf.svg   
+    :target: https://pypi.org/project/ocrmypdf/
+
+.. image:: https://img.shields.io/docker/build/jbarlow83/ocrmypdf.svg
+    :target: https://hub.docker.com/r/jbarlow83/ocrmypdf/
+
 OCRmyPDF adds an OCR text layer to scanned PDF files, allowing them to
 be searched or copy-pasted.

@@ -33,20 +33,27 @@ If you want to adjust the amount of time spent on OCR, change ``--tesseract-time
 Overriding default tesseract
 """"""""""""""""""""""""""""

-OCRmyPDF checks the environment variable ``OCRMYPDF_TESSERACT`` for the full path *to the tesseract executable* first. 
+OCRmyPDF checks the environment variable ``OCRMYPDF_TESSERACT`` for the full path *to the tesseract binary* first. 

-For example, if you are testing tesseract 4.00 and don't wish to disturb your tesseract 3.04 installation, you can launch OCRmyPDF as follows:
+.. envvar:: OCRMYPDF_TESSERACT
+
+	Specify the location of the Tesseract binary.
+
+.. envvar:: TESSDATA_PREFIX
+
+	A Tesseract environment variable that overrides the path to Tesseract's data files.
+
+For example, if you are testing tesseract 4.00 and don't wish to disturb use an existing tesseract 3.04 installation, you can launch OCRmyPDF as follows:

 .. code-block:: bash

 	env \
 		OCRMYPDF_TESSERACT=/home/user/src/tesseract4/api/tesseract \
 		TESSDATA_PREFIX=/home/user/src/tesseract4 \
-		ocrmypdf --pdf-renderer tess4 --tesseract-oem 2 input.pdf output.pdf
+		ocrmypdf --tesseract-oem 2 input.pdf output.pdf
+
+In this example ``TESSDATA_PREFIX`` directs tesseract 4.0 to use LSTM training data. ``--tesseract-oem 1`` requests tesseract 4.0's new LSTM engine. (Tesseract 4.0 only.)

-* ``TESSDATA_PREFIX`` directs tesseract 4.0 to use LSTM training data. This is a tesseract environment variable.
-* ``--pdf-renderer tess4`` takes advantage of new tesseract 4.0 PDF renderer in OCRmyPDF. (Tesseract 4.0 only.)
-* ``--tesseract-oem 1`` requests tesseract 4.0's new LSTM engine. (Tesseract 4.0 only.)

 Overriding other support programs
 """""""""""""""""""""""""""""""""
@@ -57,7 +64,20 @@ In addition to tesseract, OCRmyPDF uses the following external binaries:
 * ``unpaper``
 * ``qpdf``

-In each case OCRmyPDF will check the environment variable ``OCRMYPDF_{program}`` before asking the system to find ``{program}`` on the PATH. For example, you could redirect OCRmyPDF to ``OCRMYPDF_GS`` to override Ghostscript.
+In each case OCRmyPDF will check the environment variable ``OCRMYPDF_{program}`` before asking the system to find ``{program}`` on the PATH. For example, you could redirect OCRmyPDF to ``OCRMYPDF_GS`` to override Ghostscript. The full list is below:
+
+.. envvar:: OCRMYPDF_GS
+
+	Specify the location of the Ghostscript binary.
+
+.. envvar:: OCRMYPDF_UNPAPER
+
+	Specify the location of the unpaper binary.
+
+.. envvar:: OCRMYPDF_QPDF
+
+	Specify the location of the qpdf binary.
+

 Changing tesseract configuration variables
 """"""""""""""""""""""""""""""""""""""""""
@@ -95,33 +115,29 @@ rendering
  Creating a new PDF from other data (such as an existing PDF).


-OCRmyPDF has three PDF renderers: ``hocr``, ``tesseract`` and ``tess4``. The renderer may be selected using ``--pdf-renderer``. The default is ``auto`` which lets OCRmyPDF select the renderer to use. Currently, ``auto`` always selects ``hocr``. 
+OCRmyPDF has three PDF renderers: ``sandwich``, ``hocr``, ``tesseract``. The renderer may be selected using ``--pdf-renderer``. The default is ``auto`` which lets OCRmyPDF select the renderer to use. Currently, ``auto`` selects ``sandwich`` for Tesseract 3.05.01, and newer, ``hocr`` for older versions of Tesseract.
+
+The ``sandwich`` renderer
+"""""""""""""""""""""""""
+
+The ``sandwich`` renderer uses Tesseract's new text-only PDF feature, which produces a PDF page that lays out the OCR in invisible text. This page is then "sandwiched" onto the original PDF page, allowing lossless application of OCR even to PDF pages that contain other vector objects.
+
+When image preprocessing features like ``--deskew`` are used, the original PDF will be rendered as a full page and the OCR layer will be placed on top.
+
+This renderer requires Tesseract 3.05.01 or newer.

 The ``hocr`` renderer
 """""""""""""""""""""

-The ``hocr`` renderer is the default because it works in most cases. In this mode the whole PDF is rasterized, the raster image is run through OCR to generate a .hocr file, which is an HTML-like file that specifies the location of all identified words.
-
-The .hocr file is then rendered as a PDF and merged with the image layer.
-
-The image layer is copied from the original PDF page if possible, avoiding potentially lossy transcoding or loss of other PDF information. If preprocessing is specified, then the image layer is a new PDF.
-
-This is the only option for tesseract 3.02 and older.
+The ``hocr`` renderer works with older versions of Tesseract. The image layer is copied from the original PDF page if possible, avoiding potentially lossy transcoding or loss of other PDF information. If preprocessing is specified, then the image layer is a new PDF.

+This works in all versions of Tesseract.

 The ``tesseract`` renderer
 """"""""""""""""""""""""""

-The tesseract renderer uses tesseract's capability to produce a PDF directly. In version 3, tesseract automatically combined the image layer and text, meaning that this mode *always* transcodes and loses potentially loses image quality and other PDF information.
+The ``tesseract`` renderer creates a PDF with the image and text layers precomposed, meaning that it always transcodes, loses image quality and rasterizes and vector objects. It does a better job on non-Latin text and document structure than ``hocr``.

-It does a much better job on non-Latin text.
+If a PDF created with this renderer using Tesseract versions older than 3.05.00 is then passed through Ghostscript's pdfwrite feature, the OCR text *may* be corrupted. The ``--output-type=pdfa`` argument will produce a warning in this situation.

-In a future release this will become the "tess3" renderer and ultimately will be dropped.
-
-
-The ``tess4`` renderer
-""""""""""""""""""""""
-
-The tess4 renderer uses tesseract 4.00 alpha's text-only PDF feature added in January 2017. This combines the advantages of the tesseract and hocr renderers, transcoding the image layer only if required by preprocessing options.
-
-Ghostscript PDF/A still sometimes inserts spaces between words when the tess4 renderer is used, affecting search quality.  ``--output-pdf pdf`` may be used to avoid this issue.
+*This renderer is deprecated and will be removed whenever support for older versions of Tesseract is dropped.*
@@ -11,7 +11,7 @@ ocrmypdf has built-in help.

 .. code-block:: bash

-	ocrmypdf --help
+    ocrmypdf --help


 Add an OCR layer and convert to PDF/A
@@ -19,21 +19,21 @@ Add an OCR layer and convert to PDF/A

 .. code-block:: bash

-	ocrmypdf input.pdf output.pdf
+    ocrmypdf input.pdf output.pdf

 Add an OCR layer and output a standard PDF
 """"""""""""""""""""""""""""""""""""""""""

 .. code-block:: bash

-	ocrmypdf --output-type pdf input.pdf output.pdf
+    ocrmypdf --output-type pdf input.pdf output.pdf

 Create a PDF/A with all color and grayscale images converted to JPEG
 """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

 .. code-block:: bash

-	ocrmypdf --output-type pdfa --pdfa-image-compression jpeg input.pdf output.pdf
+    ocrmypdf --output-type pdfa --pdfa-image-compression jpeg input.pdf output.pdf

 Modify a file in place
 """"""""""""""""""""""
@@ -42,7 +42,7 @@ The file will only be overwritten if OCRmyPDF is successful.

 .. code-block:: bash

-	ocrmypdf myfile.pdf myfile.pdf
+    ocrmypdf myfile.pdf myfile.pdf

 Correct page rotation
 """""""""""""""""""""
@@ -51,7 +51,7 @@ OCR will attempt to automatic correct the rotation of each page. This can help f

 .. code-block:: bash

-	ocrmypdf --rotate-pages myfile.pdf myfile.pdf
+    ocrmypdf --rotate-pages myfile.pdf myfile.pdf

 You can increase (decrease) the parameter ``--rotate-pages-threshold`` to make page rotation more (less) aggressive.

@@ -63,8 +63,8 @@ By default OCRmyPDF assumes the document is English.

 .. code-block:: bash

-	ocrmypdf -l fre LeParisien.pdf LeParisien.pdf
-	ocrmypdf -l eng+fre Bilingual-English-French.pdf Bilingual-English-French.pdf
+    ocrmypdf -l fre LeParisien.pdf LeParisien.pdf
+    ocrmypdf -l eng+fre Bilingual-English-French.pdf Bilingual-English-French.pdf

 Language packs must be installed for all languages specified. See :ref:`Installing additional language packs <lang-packs>`.

@@ -72,19 +72,11 @@ Language packs must be installed for all languages specified. See :ref:`Installi
 Produce PDF and text file containing OCR text
 """""""""""""""""""""""""""""""""""""""""""""

-This produces a file named "output.pdf" and a companion text file named "output.txt". The ``pdftotext`` program from 
-`Poppler <https://poppler.freedesktop.org/>`_ is used to extract text from the finished PDF.
-
+This produces a file named "output.pdf" and a companion text file named "output.txt".

 .. code-block:: bash

-	ocrmypdf input.pdf - | tee output.pdf | pdftotext - output.txt
-
-.. note::
-
-	To get pdftotext, Debian/Ubuntu users may ``apt-get install poppler-utils`` 
-	and macOS users may ``brew install poppler`` respectively.
-
+    ocrmypdf --sidecar output.txt input.pdf output.pdf

 OCR images, not PDFs
 --------------------
@@ -93,21 +85,27 @@ Use a program like `img2pdf <https://gitlab.mister-muffin.de/josch/img2pdf>`_ to

 .. code-block:: bash

-	img2pdf my-images*.jpg | ocrmypdf - myfile.pdf
+    img2pdf my-images*.jpg | ocrmypdf - myfile.pdf

-If given a single image as input, OCRmyPDF will try converting it to a PDF on its own.  If the DPI specified in the image is incorrect, it can be overridden with ``--image-dpi``:
+``img2pdf`` also has features to control the position of images on a page, if desired.
+
+For convenience, OCRmyPDF can convert single images to PDFs on its own. If the resolution (dots per inch, DPI) of an image is not set or is incorrect, it can be overridden with ``--image-dpi``. (As 1 inch is 2.54 cm, 1 dpi = 0.39 dpcm).

 .. code-block:: bash

-	ocrmypdf --image-dpi 300 image.png myfile.pdf
+    ocrmypdf --image-dpi 300 image.png myfile.pdf

-This feature may be removed at some point, because OCRmyPDF does not specialize in converting images to PDFs.
+If you have multiple images, you must use ``img2pdf`` to convert the images to PDF.
+
+.. note::
+
+    ImageMagick ``convert`` can also convert a group of images to PDF, but in the author's experience it takes a long time, transcodes unnecessarily and gives poor results.

 You can also use Tesseract 3.04+ directly to convert single page images or multi-page TIFFs to PDF:

 .. code-block:: bash

-	tesseract my-image.jpg output-prefix pdf 
+    tesseract my-image.jpg output-prefix pdf

 Image processing
 ----------------
@@ -126,11 +124,11 @@ OCRmyPDF perform some image processing on each page of a PDF, if desired.  The s

 .. note::

-	In many cases image processing will rasterize PDF pages as images, potentially losing quality.
+    In many cases image processing will rasterize PDF pages as images, potentially losing quality.

 .. warning::

-	``--clean-final`` and ``-remove-background`` may leave undesirable visual artifacts in some images where their algorithms have shortcomings. Files should be visually reviewed after using these options.
+    ``--clean-final`` and ``-remove-background`` may leave undesirable visual artifacts in some images where their algorithms have shortcomings. Files should be visually reviewed after using these options.


 OCR and correct document skew (crooked scan)
@@ -140,12 +138,31 @@ Deskew:

 .. code-block:: bash

-	ocrmypdf --deskew input.pdf output.pdf
+    ocrmypdf --deskew input.pdf output.pdf

 Image processing commands can be combined. The order in which options are given does not matter. OCRmyPDF always applies the steps of the image processing pipeline in the same order (rotate, remove background, deskew, clean).

 .. code-block:: bash

-	ocrmypdf --deskew --clean --rotate-pages input.pdf output.pdf
+    ocrmypdf --deskew --clean --rotate-pages input.pdf output.pdf


+Don't actually OCR my PDF
+"""""""""""""""""""""""""
+
+If you set ``--tesseract-timeout 0`` OCRmyPDF will apply its image processing without performing OCR, if all you want to is to apply image processing or PDF/A conversion.
+
+.. code-block:: bash
+
+    ocrmypdf --tesseract-timeout=0 --remove-background input.pdf output.pdf
+
+
+Improving OCR quality
+---------------------
+
+The `Image processing`_ features can improve OCR quality.
+
+Rotating pages and deskewing helps to ensure that the page orientation is correct before OCR begins. Removing the background and/or cleaning the page can also improve results. The ``--oversample DPI`` argument can be specified to resample images to higher resolution before attempting OCR; this can improve results as well.
+
+OCR quality will suffer if the resolution of input images is not correct (since the range of pixel sizes that will be checked for possible fonts will also be incorrect).
+
@@ -15,15 +15,19 @@ Users of Debian 9 ("stretch") or later or Ubuntu 16.10 or later may simply
 Installing on macOS
 -------------------

+A `Homebrew <https://brew.sh>`_ tap is available for macOS:
+
 .. code-block:: bash
+
    brew tap jbarlow83/ocrmypdf
    brew install ocrmypdf

+
 .. warning::

    Users who previously installed OCRmyPDF on macOS using ``pip install ocrmypdf`` should remove the pip version (``pip3 uninstall ocrmypdf``) before switching to the Homebrew version.

-.. _Docker:
+.. _Docker-install:

 Installing the Docker image
 ---------------------------
@@ -37,6 +41,7 @@ Follow the Docker installation instructions for your platform.  If you can run t
 successfully, your system is ready to download and execute the image:

 .. code-block:: bash
+
    docker run hello-world
   
 OCRmyPDF will use all available CPU cores.  By default, the VirtualBox machine instance on Windows and macOS has only a single CPU core enabled. Use the VirtualBox Manager to determine the name of your Docker engine host, and then follow these optional steps to enable multiple CPUs:
@@ -209,15 +214,8 @@ follow these steps.
 Installing on Ubuntu 14.04 LTS
 ------------------------------

-Installing on Ubuntu 14.04 LTS (trusty) is more difficult than some other options, because of bugs in Python package installation and because OCRmyPDF depends on some packages newer than are available in the main distribution.
-
-Add new "apt" repositories needed for backports of Ghostscript 9.16, libav-11 (for unpaper 6.1) and Tesseract 4.00 (alpha). This will replace Ghostscript and Tesseract 3.x on your system. If you prefer to not modify your system in this matter, consider using a Docker container.
-
-.. code-block:: bash
-
-    sudo add-apt-repository ppa:vshn/ghostscript -y
-    sudo add-apt-repository ppa:heyarje/libav-11 -y
-    sudo add-apt-repository ppa:alex-p/tesseract-ocr
+Installing on Ubuntu 14.04 LTS (trusty) is more difficult than some other options,
+because it is older.

 Update apt-get:

@@ -234,45 +232,44 @@ Install system dependencies:
        zlib1g-dev \
        libjpeg-dev \
        libffi-dev \
-        libavformat56 libavcodec56 libavutil54 \
+        qpdf
+
+We will need backports of Ghostscript 9.16, libav-11 (for unpaper 6.1),
+Tesseract 4.00 (alpha), and Python 3.6. This will replace Ghostscript and
+Tesseract 3.x on your system. Python 3.6 will be installed alongside the system
+Python 3.
+
+If you prefer to not modify your system in this matter, consider using a Docker container.
+
+.. code-block:: bash
+
+    sudo add-apt-repository ppa:vshn/ghostscript -y
+    sudo add-apt-repository ppa:heyarje/libav-11 -y
+    sudo add-apt-repository ppa:alex-p/tesseract-ocr -y
+    sudo add-apt-repository ppa:jonathonf/python-3.6 -y
+
+    sudo apt-get update
+
+    sudo apt-get install \
+        python3.6 \
        ghostscript \
-        qpdf \
-        python3-pip \
-        python3-pil \
-        python3-pytest \
-        python3-reportlab \
-        python3-wheel \
-        python3-venv \
        tesseract-ocr \
-        tesseract-ocr-eng
+        tesseract-ocr-eng \
+        libavformat56 libavcodec56 libavutil54 \
+        wget

-If you wish install OCRmyPDF to the system Python, then install as follows (note this installs new packages
-into your system Python, which could interfere with other programs):
+Now we need to install ``pip`` and let it install ocrmypdf:

 .. code-block:: bash

-    sudo pip3 install ocrmypdf
-
-If you wish to install OCRmyPDF to a virtual environment to isolate the system Python, you can
-follow these steps.  This includes a workaround `for a known, unresolved issue in Ubuntu 14.04's ensurepip
-package <http://www.thefourtheye.in/2014/12/Python-venv-problem-with-ensurepip-in-Ubuntu.html>`_:
-
-.. code-block:: bash
-
-    sudo apt-get install python3-venv
-    python3 -m venv venv-ocrmypdf --without-pip
-    source venv-ocrmypdf/bin/activate
-    wget -O - -o /dev/null https://bootstrap.pypa.io/get-pip.py | python
-    deactivate
-    python3 -m venv --system-site-packages venv-ocrmypdf
-    source venv-ocrmypdf/bin/activate
-    pip install ocrmypdf
+    wget -O - -o /dev/null https://bootstrap.pypa.io/get-pip.py | python3.6
+    pip3.6 install ocrmypdf

 These installation instructions omit the optional dependency ``unpaper``, which is only available at version 0.4.2 in Ubuntu 14.04. The author could not find a backport of ``unpaper``, and created a .deb package to do the job of installing unpaper 6.1 (for x86 64-bit only):

 .. code-block:: bash

-    wget -q https://dl.dropboxusercontent.com/u/28971240/unpaper_6.1-1.deb -O unpaper_6.1-1.deb
+    wget -q 'https://www.dropbox.com/s/vaq0kbwi6e6au80/unpaper_6.1-1.deb?raw=1' -O unpaper_6.1-1.deb
    sudo dpkg -i unpaper_6.1-1.deb


@@ -281,7 +278,7 @@ Installing on ArchLinux

 The author is aware of an `ArchLinux package for ocrmypdf <https://aur.archlinux.org/packages/ocrmypdf/>`_. It seems like the following command might work.

-.. code-block::
+.. code-block:: bash

    pacman -S ocrmypdf

@@ -302,6 +299,8 @@ The command line syntax to run ocrmypdf from a command prompt will resemble:

 where /c/Users/sampleuser is a Unix representation of the Windows path C:\\Users\\sampleuser, assuming a user named "sampleuser" is running ocrmypdf on a file in their home directory, and the files "test.pdf" and "output.pdf" are in the sampleuser folder. The Windows user must have read and write permissions.

+`Bash on Ubuntu on Windows <https://github.com/Microsoft/BashOnWindows>`_ should also be a viable route for running the OCRmyPDF Docker container.
+
 Installing HEAD revision from sources
 -------------------------------------

@@ -56,9 +56,11 @@ Depending on the settings selected, OCRmyPDF may "graft" the OCR layer into the
 Why you shouldn't do this manually
 ----------------------------------

-There are two routes to manually applying OCR to an existing PDF, both of which destroy information in the original PDF.
+A PDF is similar to an HTML file, in that it contains document structure along with images.  Sometimes a PDF does nothing more than present a full page image, but often there is additional content that would be lost.

-1. Rasterize each page as an image, OCR the images, and combine the output into a PDF. This preserves the appearance of each page, but resamples all images (possibly losing quality, increasing file size, introducing compression artifacts, etc.)
+A manual process could work like either of these:
+
+1. Rasterize each page as an image, OCR the images, and combine the output into a PDF. This preserves the layout of each page, but resamples all images (possibly losing quality, increasing file size, introducing compression artifacts, etc.).

 2. Extract each image, OCR, and combine the output into a PDF. This loses the context in which images are used in the PDF, meaning that cropping, rotation and scaling of pages may be lost. Some scanned PDFs use multiple images segmented into black and white, grayscale and color regions, with stencil masks to prevent overlap, as this can enhance the appearance of a file while reducing file size. Clearly, reassembling these images will be easy. This also loses and text or vector art on any pages in a PDF with both scanned and pure digital content.

@@ -101,4 +103,7 @@ To the author's knowledge, OCRmyPDF is the most feature-rich and thoroughly test
 * pdf2pdfocr
 * pdfsandwich
 * pypdfocr
-* pdfbeads
+* pdfbeads
+
+If you are looking for a micro web-frontend for OCRmyPDF, consider the third-party `OCRmyPDF-web <https://github.com/sseemayer/OCRmyPDF-web>`_. Bear in mind that OCRmyPDF is not designed to be secure against malware-bearing PDFs (see `Using OCRmyPDF online`_).
+
@@ -1,7 +1,59 @@
 Release notes
 =============

-OCRmyPDF uses `semantic versioning <http://semver.org/>`_.
+OCRmyPDF uses `semantic versioning <http://semver.org/>`_ for its command line interface.
+
+The OCRmyPDF package itself does not contain a public API, although it is fairly stable and breaking changes are usually timed with a major release. A future release will clearly define the stable public API.
+
+
+v5.3.3
+------
+
+-   Fixed missing error message that should occur when trying to force ``--pdf-renderer sandwich`` on old versions of Tesseract
+-   Update copyright information in test files
+-   Set system ``LANG`` to UTF-8 in Dockerfiles to avoid UTF-8 encoding errors
+
+
+v5.3.2
+------
+
+-   Fixed a broken test case related to language packs
+
+
+v5.3.1
+------
+
+-   Fixed wrong return code given for missing Tesseract language packs
+-   Fixed "brew audit" crashing on Travis when trying to auto-brew
+
+
+v5.3
+----
+
+-   Added ``--user-words`` and ``--user-patterns`` arguments which are forwarded to Tesseract OCR as words and regular expressions respective to use to guide OCR. Supplying a list of subject-domain words should assist Tesseract with resolving words. (#165)
+-   Using a non Latin-1 language with the "hocr" renderer now warns about possible OCR quality and recommends workarounds (#176)
+-   Output file path added to error message when that location is not writable (#175)
+-   Otherwise valid PDFs with leading whitespace at the beginning of the file are now accepted
+
+
+v5.2
+----
+
+-   When using Tesseract 3.05.01 or newer, OCRmyPDF will select the "sandwich" PDF renderer by default, unless another PDF renderer is specified with the ``--pdf-renderer`` argument. The previous behavior was to select ``--pdf-renderer=hocr``.
+-   The "tesseract" PDF renderer is now deprecated, since it can cause problems with Ghostscript on Tesseract 3.05.00
+-   The "tess4" PDF renderer has been renamed to "sandwich". "tess4" is now a deprecated alias for "sandwich".
+
+
+v5.1
+----
+
+-   Files with pages larger than 200" (5080 mm) in either dimension are now supported with ``--output-type=pdf`` with the page size preserved (in the PDF specification this feature is called UserUnit scaling). Due to Ghostscript limitations this is not available in conjunction with PDF/A output.
+
+
+v5.0.1
+------
+
+-   Fixed issue #169, exception due to failure to create sidecar text files on some versions of Tesseract 3.04, including the jbarlow83/ocrmypdf Docker image


 v5.0
@@ -9,9 +61,9 @@ v5.0

 -   Backward incompatible changes

-    + Support for Python 3.4 dropped. Python 3.5 is now required.
-    + Support for Tesseract 3.02 and 3.03 dropped. Tesseract 3.04 or newer is required. Tesseract 4.00 (alpha) is supported.
-    + The OCRmyPDF.sh script was removed.
+     + Support for Python 3.4 dropped. Python 3.5 is now required.
+     + Support for Tesseract 3.02 and 3.03 dropped. Tesseract 3.04 or newer is required. Tesseract 4.00 (alpha) is supported.
+     + The OCRmyPDF.sh script was removed.

 -   Add a new feature, ``--sidecar``, which allows creating "sidecar" text files which contain the OCR results in plain text. These OCR text is more reliable than extracting text from PDFs. Closes #126.
 -   New feature: ``--pdfa-image-compression``, which allows overriding Ghostscript's lossy-or-lossless image encoding heuristic and making all images JPEG encoded or lossless encoded as desired. Fixes #163.
@@ -45,242 +97,242 @@ v4.5.4
 v4.5.3
 ------

-  Added a workaround for Ghostscript 9.21 and probably earlier versions would fail with the error message "VMerror -25", due to a Ghostscript bug in XMP metadata handling
-  High Unicode characters (U+10000 and up) are no longer accepted for setting metadata on the command line, as Ghostscript may not handle them correctly.
-  Fixed an issue where the ``tess4`` renderer would duplicate content onto output pages if tesseract failed or timed out
-  Fixed ``tess4`` renderer not recognized when lossless reconstruction is possible
+-   Added a workaround for Ghostscript 9.21 and probably earlier versions would fail with the error message "VMerror -25", due to a Ghostscript bug in XMP metadata handling
+-   High Unicode characters (U+10000 and up) are no longer accepted for setting metadata on the command line, as Ghostscript may not handle them correctly.
+-   Fixed an issue where the ``tess4`` renderer would duplicate content onto output pages if tesseract failed or timed out
+-   Fixed ``tess4`` renderer not recognized when lossless reconstruction is possible


 v4.5.2
 ------

-  Fix issue #147. ``--pdf-renderer tess4 --clean`` will produce an oversized page containing the original image in the bottom left corner, due to loss DPI information.
-  Make "using Tesseract 4.0" warning less ominous
-  Set up machinery for homebrew OCRmyPDF tap
+-   Fix issue #147. ``--pdf-renderer tess4 --clean`` will produce an oversized page containing the original image in the bottom left corner, due to loss DPI information.
+-   Make "using Tesseract 4.0" warning less ominous
+-   Set up machinery for homebrew OCRmyPDF tap


 v4.5.1
 ------

-  Fix issue #137, proportions of images with a non-square pixel aspect ratio would be distorted in output for ``--force-ocr`` and some other combinations of flags
+-   Fix issue #137, proportions of images with a non-square pixel aspect ratio would be distorted in output for ``--force-ocr`` and some other combinations of flags


 v4.5
 ----

-  Exotic PDFs containing "Form XObjects" are now supported (issue #134; PDF reference manual 8.10), and images they contain are taken into account when determining the resolution for rasterizing
-  The Tesseract 4 Docker image no longer includes all languages, because it took so long to build something would tend to fail
-  OCRmyPDF now warns about using ``--pdf-renderer tesseract`` with Tesseract 3.04 or lower due to issues with Ghostscript corrupting the OCR text in these cases
+-   Exotic PDFs containing "Form XObjects" are now supported (issue #134; PDF reference manual 8.10), and images they contain are taken into account when determining the resolution for rasterizing
+-   The Tesseract 4 Docker image no longer includes all languages, because it took so long to build something would tend to fail
+-   OCRmyPDF now warns about using ``--pdf-renderer tesseract`` with Tesseract 3.04 or lower due to issues with Ghostscript corrupting the OCR text in these cases


 v4.4.2
 ------

-  The Docker images (ocrmypdf, ocrmypdf-polyglot, ocrmypdf-tess4) are now based on Ubuntu 16.10 instead of Debian stretch
+-   The Docker images (ocrmypdf, ocrmypdf-polyglot, ocrmypdf-tess4) are now based on Ubuntu 16.10 instead of Debian stretch

-   + This makes supporting the Tesseract 4 image easier
-   + This could be a disruptive change for any Docker users who built customized these images with their own changes, and made those changes in a way that depends on Debian and not Ubuntu
+    + This makes supporting the Tesseract 4 image easier
+    + This could be a disruptive change for any Docker users who built customized these images with their own changes, and made those changes in a way that depends on Debian and not Ubuntu

-  OCRmyPDF now prevents running the Tesseract 4 renderer with Tesseract 3.04, which was permitted in v4.4 and v4.4.1 but will not work
+-   OCRmyPDF now prevents running the Tesseract 4 renderer with Tesseract 3.04, which was permitted in v4.4 and v4.4.1 but will not work


 v4.4.1
 ------

-  To prevent a `TIFF output error <https://github.com/python-pillow/Pillow/issues/2206>`_ caused by img2pdf >= 0.2.1 and Pillow <= 3.4.2, dependencies have been tightened
-  The Tesseract 4.00 simultaneous process limit was increased from 1 to 2, since it was observed that 1 lowers performance
-  Documentation improvements to describe the ``--tesseract-config`` feature 
-  Added test cases and fixed error handling for ``--tesseract-config``
-  Tweaks to setup.py to deal with issues in the v4.4 release
+-   To prevent a `TIFF output error <https://github.com/python-pillow/Pillow/issues/2206>`_ caused by img2pdf >= 0.2.1 and Pillow <= 3.4.2, dependencies have been tightened
+-   The Tesseract 4.00 simultaneous process limit was increased from 1 to 2, since it was observed that 1 lowers performance
+-   Documentation improvements to describe the ``--tesseract-config`` feature 
+-   Added test cases and fixed error handling for ``--tesseract-config``
+-   Tweaks to setup.py to deal with issues in the v4.4 release

 v4.4
 ----

-  Tesseract 4.00 is now supported on an experimental basis.
+-   Tesseract 4.00 is now supported on an experimental basis.

-   +  A new rendering option ``--pdf-renderer tess4`` exploits Tesseract 4's new text-only output PDF mode. See the documentation on PDF Renderers for details.
-   +  The ``--tesseract-oem`` argument allows control over the Tesseract 4 OCR engine mode (tesseract's ``--oem``). Use ``--tesseract-oem 2`` to enforce the new LSTM mode.
-   +  Fixed poor performance with Tesseract 4.00 on Linux
+    +  A new rendering option ``--pdf-renderer tess4`` exploits Tesseract 4's new text-only output PDF mode. See the documentation on PDF Renderers for details.
+    +  The ``--tesseract-oem`` argument allows control over the Tesseract 4 OCR engine mode (tesseract's ``--oem``). Use ``--tesseract-oem 2`` to enforce the new LSTM mode.
+    +  Fixed poor performance with Tesseract 4.00 on Linux

-  Fixed an issue that caused corruption of output to stdout in some cases
-  Removed test for Pillow JPEG and PNG support, as the minimum supported version of Pillow now enforces this
-  OCRmyPDF now tests that the intended destination file is writable before proceeding
-  The test suite now requires ``pytest-helpers-namespace`` to run (but not install)
-  Significant code reorganization to make OCRmyPDF re-entrant and improve performance. All changes should be backward compatible for the v4.x series.
+-   Fixed an issue that caused corruption of output to stdout in some cases
+-   Removed test for Pillow JPEG and PNG support, as the minimum supported version of Pillow now enforces this
+-   OCRmyPDF now tests that the intended destination file is writable before proceeding
+-   The test suite now requires ``pytest-helpers-namespace`` to run (but not install)
+-   Significant code reorganization to make OCRmyPDF re-entrant and improve performance. All changes should be backward compatible for the v4.x series.

-   + However, OCRmyPDF's dependency "ruffus" is not re-entrant, so no Python API is available. Scripts should continue to use the command line interface.
+    + However, OCRmyPDF's dependency "ruffus" is not re-entrant, so no Python API is available. Scripts should continue to use the command line interface.


 v4.3.5
 ------

-  Update documentation to confirm Python 3.6.0 compatibility. No code changes were needed, so many earlier versions are likely supported.
+-   Update documentation to confirm Python 3.6.0 compatibility. No code changes were needed, so many earlier versions are likely supported.


 v4.3.4
 ------

-  Fixed "decimal.InvalidOperation: quantize result has too many digits" for high DPI images
+-   Fixed "decimal.InvalidOperation: quantize result has too many digits" for high DPI images


 v4.3.3
 ------

-  Fixed PDF/A creation with Ghostscript 9.20 properly
-  Fixed an exception on inline stencil masks with a missing optional parameter
+-   Fixed PDF/A creation with Ghostscript 9.20 properly
+-   Fixed an exception on inline stencil masks with a missing optional parameter


 v4.3.2
 ------

-  Fixed a PDF/A creation issue with Ghostscript 9.20 (note: this fix did not actually work)
+-   Fixed a PDF/A creation issue with Ghostscript 9.20 (note: this fix did not actually work)


 v4.3.1
 ------

-  Fixed an issue where pages produced by the "hocr" renderer after a Tesseract timeout would be rotated incorrectly if the input page was rotated with a /Rotate marker
-  Fixed a file handle leak in LeptonicaErrorTrap that would cause a "too many open files" error for files around hundred pages of pages long when ``--deskew`` or ``--remove-background`` or other Leptonica based image processing features were in use, depending on the system value of ``ulimit -n``
-  Ability to specify multiple languages for multilingual documents is now advertised in documentation
-  Reduced the file sizes of some test resources
-  Cleaned up debug output
-  Tesseract caching in test cases is now more cautious about false cache hits and reproducing exact output, not that any problems were observed
+-   Fixed an issue where pages produced by the "hocr" renderer after a Tesseract timeout would be rotated incorrectly if the input page was rotated with a /Rotate marker
+-   Fixed a file handle leak in LeptonicaErrorTrap that would cause a "too many open files" error for files around hundred pages of pages long when ``--deskew`` or ``--remove-background`` or other Leptonica based image processing features were in use, depending on the system value of ``ulimit -n``
+-   Ability to specify multiple languages for multilingual documents is now advertised in documentation
+-   Reduced the file sizes of some test resources
+-   Cleaned up debug output
+-   Tesseract caching in test cases is now more cautious about false cache hits and reproducing exact output, not that any problems were observed


 v4.3
 ----

-  New feature ``--remove-background`` to detect and erase the background of color and grayscale images
-  Better documentation
-  Fixed an issue with PDFs that draw images when the raster stack depth is zero 
-  ocrmypdf can now redirect its output to stdout for use in a shell pipeline
+-   New feature ``--remove-background`` to detect and erase the background of color and grayscale images
+-   Better documentation
+-   Fixed an issue with PDFs that draw images when the raster stack depth is zero 
+-   ocrmypdf can now redirect its output to stdout for use in a shell pipeline

-   +  This does not improve performance since temporary files are still used for buffering
-   +  Some output validation is disabled in this mode
+    +  This does not improve performance since temporary files are still used for buffering
+    +  Some output validation is disabled in this mode

 v4.2.5
 ------

-  Fixed an issue (#100) with PDFs that omit the optional /BitsPerComponent parameter on images
-  Removed non-free file milk.pdf
+-   Fixed an issue (#100) with PDFs that omit the optional /BitsPerComponent parameter on images
+-   Removed non-free file milk.pdf


 v4.2.4
 ------

-  Fixed an error (#90) caused by PDFs that use stencil masks properly
-  Fixed handling of PDFs that try to draw images or stencil masks without properly setting up the graphics state (such images are now ignored for the purposes of calculating DPI)
+-   Fixed an error (#90) caused by PDFs that use stencil masks properly
+-   Fixed handling of PDFs that try to draw images or stencil masks without properly setting up the graphics state (such images are now ignored for the purposes of calculating DPI)

 v4.2.3
 ------

-  Fixed an issue with PDFs that store page rotation (/Rotate) in an indirect object
-  Integrated a few fixes to simplify downstream packaging (Debian)
+-   Fixed an issue with PDFs that store page rotation (/Rotate) in an indirect object
+-   Integrated a few fixes to simplify downstream packaging (Debian)

-   +  The test suite no longer assumes it is installed
-   +  If running Linux, skip a test that passes Unicode on the command line
+    +  The test suite no longer assumes it is installed
+    +  If running Linux, skip a test that passes Unicode on the command line

-  Added a test case to check explicit masks and stencil masks
-  Added a test case for indirect objects and linearized PDFs
-  Deprecated the OCRmyPDF.sh shell script
+-   Added a test case to check explicit masks and stencil masks
+-   Added a test case for indirect objects and linearized PDFs
+-   Deprecated the OCRmyPDF.sh shell script


 v4.2.2
 ------

-  Improvements to documentation
+-   Improvements to documentation


 v4.2.1
 ------

-  Fixed an issue where PDF pages that contained stencil masks would report an incorrect DPI and cause Ghostscript to abort
-  Implemented stdin streaming
+-   Fixed an issue where PDF pages that contained stencil masks would report an incorrect DPI and cause Ghostscript to abort
+-   Implemented stdin streaming


 v4.2
 ----

-  ocrmypdf will now try to convert single image files to PDFs if they are provided as input (#15)
+-   ocrmypdf will now try to convert single image files to PDFs if they are provided as input (#15)

-   +  This is a basic convenience feature. It only supports a single image and always makes the image fill the whole page.
-   +  For better control over image to PDF conversion, use ``img2pdf`` (one of ocrmypdf's dependencies)
+    +  This is a basic convenience feature. It only supports a single image and always makes the image fill the whole page.
+    +  For better control over image to PDF conversion, use ``img2pdf`` (one of ocrmypdf's dependencies)

-  New argument ``--output-type {pdf|pdfa}`` allows disabling Ghostscript PDF/A generation
+-   New argument ``--output-type {pdf|pdfa}`` allows disabling Ghostscript PDF/A generation

-   +  ``pdfa`` is the default, consistent with past behavior
-   +  ``pdf`` provides a workaround for users concerned about the increase in file size from Ghostscript forcing JBIG2 images to CCITT and transcoding JPEGs
-   +  ``pdf`` preserves as much as it can about the original file, including problems that PDF/A conversion fixes
+    +  ``pdfa`` is the default, consistent with past behavior
+    +  ``pdf`` provides a workaround for users concerned about the increase in file size from Ghostscript forcing JBIG2 images to CCITT and transcoding JPEGs
+    +  ``pdf`` preserves as much as it can about the original file, including problems that PDF/A conversion fixes

-  PDFs containing images with "non-square" pixel aspect ratios, such as 200x100 DPI, are now handled and converted properly (fixing a bug that caused to be cropped)
-  ``--force-ocr`` rasterizes pages even if they contain no images
+-   PDFs containing images with "non-square" pixel aspect ratios, such as 200x100 DPI, are now handled and converted properly (fixing a bug that caused to be cropped)
+-   ``--force-ocr`` rasterizes pages even if they contain no images

-   +  supports users who want to use OCRmyPDF to reconstruct text information in PDFs with damaged Unicode maps (copy and paste text does not match displayed text)
-   +  supports reinterpreting PDFs where text was rendered as curves for printing, and text needs to be recovered
-   +  fixes issue #82
+    +  supports users who want to use OCRmyPDF to reconstruct text information in PDFs with damaged Unicode maps (copy and paste text does not match displayed text)
+    +  supports reinterpreting PDFs where text was rendered as curves for printing, and text needs to be recovered
+    +  fixes issue #82

-  Fixes an issue where, with certain settings, monochrome images in PDFs would be converted to 8-bit grayscale, increasing file size (#79)
-  Support for Ubuntu 12.04 LTS "precise" has been dropped in favor of (roughly) Ubuntu 14.04 LTS "trusty" 
+-   Fixes an issue where, with certain settings, monochrome images in PDFs would be converted to 8-bit grayscale, increasing file size (#79)
+-   Support for Ubuntu 12.04 LTS "precise" has been dropped in favor of (roughly) Ubuntu 14.04 LTS "trusty" 

-   +  Some Ubuntu "PPAs" (backports) are needed to make it work
-      
-  Support for some older dependencies dropped
+    +  Some Ubuntu "PPAs" (backports) are needed to make it work

-   +  Ghostscript 9.15 or later is now required (available in Ubuntu trusty with backports)
-   +  Tesseract 3.03 or later is now required (available in Ubuntu trusty)
+-   Support for some older dependencies dropped

-  Ghostscript now runs in "safer" mode where possible
+    +  Ghostscript 9.15 or later is now required (available in Ubuntu trusty with backports)
+    +  Tesseract 3.03 or later is now required (available in Ubuntu trusty)
+
+-   Ghostscript now runs in "safer" mode where possible

 v4.1.4
 ------

-  Bug fix: monochrome images with an ICC profile attached were incorrectly converted to full color images if lossless reconstruction was not possible due to other settings; consequence was increased file size for these images
+-   Bug fix: monochrome images with an ICC profile attached were incorrectly converted to full color images if lossless reconstruction was not possible due to other settings; consequence was increased file size for these images


 v4.1.3
 ------

-  More helpful error message for PDFs with version 4 security handler
-  Update usage instructions for Windows/Docker users
-  Fix order of operations for matrix multiplication (no effect on most users)
-  Add a few leptonica wrapper functions (no effect on most users)
+-   More helpful error message for PDFs with version 4 security handler
+-   Update usage instructions for Windows/Docker users
+-   Fix order of operations for matrix multiplication (no effect on most users)
+-   Add a few leptonica wrapper functions (no effect on most users)


 v4.1.2
 ------

-  Replace IEC sRGB ICC profile with Debian's sRGB (from icc-profiles-free) which is more compatible with the MIT license
-  More helpful error message for an error related to certain types of malformed PDFs
+-   Replace IEC sRGB ICC profile with Debian's sRGB (from icc-profiles-free) which is more compatible with the MIT license
+-   More helpful error message for an error related to certain types of malformed PDFs


 v4.1
 ----

-  ``--rotate-pages`` now only rotates pages when reasonably confidence in the orientation. This behavior can be adjusted with the new argument ``--rotate-pages-threshold``
-  Fixed problems in error checking if ``unpaper`` is uninstalled or missing at run-time
-  Fixed problems with "RethrownJobError" errors during error handling that suppressed the useful error messages
+-   ``--rotate-pages`` now only rotates pages when reasonably confidence in the orientation. This behavior can be adjusted with the new argument ``--rotate-pages-threshold``
+-   Fixed problems in error checking if ``unpaper`` is uninstalled or missing at run-time
+-   Fixed problems with "RethrownJobError" errors during error handling that suppressed the useful error messages


 v4.0.7
 ------

-  Minor correction to Ghostscript output settings
+-   Minor correction to Ghostscript output settings


 v4.0.6
 ------

-  Update install instructions
-  Provide a sRGB profile instead of using Ghostscript's
+-   Update install instructions
+-   Provide a sRGB profile instead of using Ghostscript's


 v4.0.5
 ------

-  Remove some verbose debug messages from v4.0.4
-  Fixed temporary that wasn't being deleted
-  DPI is now calculated correctly for cropped images, along with other image transformations
-  Inline images are now checked during DPI calculation instead of rejecting the image
+-   Remove some verbose debug messages from v4.0.4
+-   Fixed temporary that wasn't being deleted
+-   DPI is now calculated correctly for cropped images, along with other image transformations
+-   Inline images are now checked during DPI calculation instead of rejecting the image

 v4.0.4
 ------
@@ -294,16 +346,16 @@ v4.0.3
 New features
 ^^^^^^^^^^^^

-  Page orientations detected are now reported in a summary comment
+-   Page orientations detected are now reported in a summary comment


 Fixes
 ^^^^^

-  Show stack trace if unexpected errors occur
-  Treat "too few characters" error message from Tesseract as a reason to skip that page rather than
-   abort the file
-  Docker: fix blank JPEG2000 issue by insisting on Ghostscript versions that have this fixed
+-   Show stack trace if unexpected errors occur
+-   Treat "too few characters" error message from Tesseract as a reason to skip that page rather than
+    abort the file
+-   Docker: fix blank JPEG2000 issue by insisting on Ghostscript versions that have this fixed


 v4.0.2
@@ -312,10 +364,10 @@ v4.0.2
 Fixes
 ^^^^^

-  Fixed compatibility with Tesseract 3.04.01 release, particularly its different way of outputting
-   orientation information
-  Improved handling of Tesseract errors and crashes
-  Fixed use of chmod on Docker that broke most test cases
+-   Fixed compatibility with Tesseract 3.04.01 release, particularly its different way of outputting
+    orientation information
+-   Improved handling of Tesseract errors and crashes
+-   Fixed use of chmod on Docker that broke most test cases


 v4.0.1
@@ -324,7 +376,7 @@ v4.0.1
 Fixes
 ^^^^^

-  Fixed a KeyError if tesseract fails to find page orientation information
+-   Fixed a KeyError if tesseract fails to find page orientation information


 v4.0
@@ -333,33 +385,33 @@ v4.0
 New features
 ^^^^^^^^^^^^

-  Automatic page rotation (``-r``) is now available. It uses ignores any prior rotation information
-   on PDFs and sets rotation based on the dominant orientation of detectable text. This feature is
-   fairly reliable but some false positives occur especially if there is not much text to work with. (#4) 
-  Deskewing is now performed using Leptonica instead of unpaper. Leptonica is faster and more reliable
-   at image deskewing than unpaper.
+-   Automatic page rotation (``-r``) is now available. It uses ignores any prior rotation information
+    on PDFs and sets rotation based on the dominant orientation of detectable text. This feature is
+    fairly reliable but some false positives occur especially if there is not much text to work with. (#4) 
+-   Deskewing is now performed using Leptonica instead of unpaper. Leptonica is faster and more reliable
+    at image deskewing than unpaper.


 Fixes
 ^^^^^

-  Fixed an issue where lossless reconstruction could cause some pages to be appear incorrectly
-   if the page was rotated by the user in Acrobat after being scanned (specifically if it a /Rotate tag)
-  Fixed an issue where lossless reconstruction could misalign the graphics layer with respect to
-   text layer if the page had been cropped such that its origin is not (0, 0) (#49)
+-   Fixed an issue where lossless reconstruction could cause some pages to be appear incorrectly
+    if the page was rotated by the user in Acrobat after being scanned (specifically if it a /Rotate tag)
+-   Fixed an issue where lossless reconstruction could misalign the graphics layer with respect to
+    text layer if the page had been cropped such that its origin is not (0, 0) (#49)


 Changes
 ^^^^^^^

-  Logging output is now much easier to read
-  ``--deskew`` is now performed by Leptonica instead of unpaper (#25)
-  libffi is now required
-  Some changes were made to the Docker and Travis build environments to support libffi
-  ``--pdf-renderer=tesseract`` now displays a warning if the Tesseract version is less than 3.04.01,
-   the planned release that will include fixes to an important OCR text rendering bug in Tesseract 3.04.00.
-   You can also manually install ./share/sharp2.ttf on top of pdf.ttf in your Tesseract tessdata folder
-   to correct the problem.
+-   Logging output is now much easier to read
+-   ``--deskew`` is now performed by Leptonica instead of unpaper (#25)
+-   libffi is now required
+-   Some changes were made to the Docker and Travis build environments to support libffi
+-   ``--pdf-renderer=tesseract`` now displays a warning if the Tesseract version is less than 3.04.01,
+    the planned release that will include fixes to an important OCR text rendering bug in Tesseract 3.04.00.
+    You can also manually install ./share/sharp2.ttf on top of pdf.ttf in your Tesseract tessdata folder
+    to correct the problem.


 v3.2.1
@@ -368,8 +420,8 @@ v3.2.1
 Changes
 ^^^^^^^

-  Fixed issue #47 "convert() got and unexpected keyword argument 'dpi'" by upgrading to img2pdf 0.2
-  Tweaked the Dockerfiles
+-   Fixed issue #47 "convert() got and unexpected keyword argument 'dpi'" by upgrading to img2pdf 0.2
+-   Tweaked the Dockerfiles


 v3.2
@@ -378,19 +430,19 @@ v3.2
 New features
 ^^^^^^^^^^^^

-  Lossless reconstruction: when possible, OCRmyPDF will inject text layers without 
-   otherwise manipulating the content and layout of a PDF page. For example, a PDF containing a mix
-   of vector and raster content would see the vector content preserved. Images may still be transcoded
-   during PDF/A conversion.  (``--deskew`` and ``--clean-final`` disable this mode, necessarily.)
-  New argument ``--tesseract-pagesegmode`` allows you to pass page segmentation arguments to Tesseract OCR.
-   This helps for two column text and other situations that confuse Tesseract.
-  Added a new "polyglot" version of the Docker image, that generates Tesseract with all languages packs installed,
-   for the polyglots among us. It is much larger.
+-   Lossless reconstruction: when possible, OCRmyPDF will inject text layers without 
+    otherwise manipulating the content and layout of a PDF page. For example, a PDF containing a mix
+    of vector and raster content would see the vector content preserved. Images may still be transcoded
+    during PDF/A conversion.  (``--deskew`` and ``--clean-final`` disable this mode, necessarily.)
+-   New argument ``--tesseract-pagesegmode`` allows you to pass page segmentation arguments to Tesseract OCR.
+    This helps for two column text and other situations that confuse Tesseract.
+-   Added a new "polyglot" version of the Docker image, that generates Tesseract with all languages packs installed,
+    for the polyglots among us. It is much larger.

 Changes
 ^^^^^^^

-  JPEG transcoding quality is now 95 instead of the default 75. Bigger file sizes for less degradation.
+-   JPEG transcoding quality is now 95 instead of the default 75. Bigger file sizes for less degradation.



@@ -400,7 +452,7 @@ v3.1.1
 Changes
 ^^^^^^^

-  Fixed bug that caused incorrect page size and DPI calculations on documents with mixed page sizes
+-   Fixed bug that caused incorrect page size and DPI calculations on documents with mixed page sizes

 v3.1
 ----
@@ -408,17 +460,17 @@ v3.1
 Changes
 ^^^^^^^

-  Default output format is now PDF/A-2b instead of PDF/A-1b
-  Python 3.5 and macOS El Capitan are now supported platforms - no changes were
-   needed to implement support
-  Improved some error messages related to missing input files
-  Fixed issue #20 - uppercase .PDF extension not accepted
-  Fixed an issue where OCRmyPDF failed to text that certain pages contained previously OCR'ed text, 
-   such as OCR text produced by Tesseract 3.04
-  Inserts /Creator tag into PDFs so that errors can be traced back to this project
-  Added new option ``--pdf-renderer=auto``, to let OCRmyPDF pick the best PDF renderer. 
-   Currently it always chooses the 'hocrtransform' renderer but that behavior may change.
-  Set up Travis CI automatic integration testing
+-   Default output format is now PDF/A-2b instead of PDF/A-1b
+-   Python 3.5 and macOS El Capitan are now supported platforms - no changes were
+    needed to implement support
+-   Improved some error messages related to missing input files
+-   Fixed issue #20 - uppercase .PDF extension not accepted
+-   Fixed an issue where OCRmyPDF failed to text that certain pages contained previously OCR'ed text, 
+    such as OCR text produced by Tesseract 3.04
+-   Inserts /Creator tag into PDFs so that errors can be traced back to this project
+-   Added new option ``--pdf-renderer=auto``, to let OCRmyPDF pick the best PDF renderer. 
+    Currently it always chooses the 'hocrtransform' renderer but that behavior may change.
+-   Set up Travis CI automatic integration testing

 v3.0
 ----
@@ -426,55 +478,55 @@ v3.0
 New features
 ^^^^^^^^^^^^

-  Easier installation with a Docker container or Python's ``pip`` package manager 
-  Eliminated many external dependencies, so it's easier to setup
-  Now installs ``ocrmypdf`` to ``/usr/local/bin`` or equivalent for system-wide
-   access and easier typing
-  Improved command line syntax and usage help (``--help``)
-  Tesseract 3.03+ PDF page rendering can be used instead for better positioning
-   of recognized text (``--pdf-renderer tesseract``)
-  PDF metadata (title, author, keywords) are now transferred to the 
-   output PDF
-  PDF metadata can also be set from the command line (``--title``, etc.)
-  Automatic repairs malformed input PDFs if possible
-  Added test cases to confirm everything is working
-  Added option to skip extremely large pages that take too long to OCR and are 
-   often not OCRable (e.g. large scanned maps or diagrams); other pages are still
-   processed (``--skip-big``)
-  Added option to kill Tesseract OCR process if it seems to be taking too long on
-   a page, while still processing other pages (``--tesseract-timeout``)
-  Less common colorspaces (CMYK, palette) are now supported by conversion to RGB
-  Multiple images on the same PDF page are now supported
+-   Easier installation with a Docker container or Python's ``pip`` package manager 
+-   Eliminated many external dependencies, so it's easier to setup
+-   Now installs ``ocrmypdf`` to ``/usr/local/bin`` or equivalent for system-wide
+    access and easier typing
+-   Improved command line syntax and usage help (``--help``)
+-   Tesseract 3.03+ PDF page rendering can be used instead for better positioning
+    of recognized text (``--pdf-renderer tesseract``)
+-   PDF metadata (title, author, keywords) are now transferred to the 
+    output PDF
+-   PDF metadata can also be set from the command line (``--title``, etc.)
+-   Automatic repairs malformed input PDFs if possible
+-   Added test cases to confirm everything is working
+-   Added option to skip extremely large pages that take too long to OCR and are 
+    often not OCRable (e.g. large scanned maps or diagrams); other pages are still
+    processed (``--skip-big``)
+-   Added option to kill Tesseract OCR process if it seems to be taking too long on
+    a page, while still processing other pages (``--tesseract-timeout``)
+-   Less common colorspaces (CMYK, palette) are now supported by conversion to RGB
+-   Multiple images on the same PDF page are now supported

 Changes
 ^^^^^^^

-  New, robust rewrite in Python 3.4+ with ruffus_ pipelines
-  Now uses Ghostscript 9.14's improved color conversion model to preserve PDF colors
-  OCR text is now rendered in the PDF as invisible text. Previous versions of OCRmyPDF
-   incorrectly rendered visible text with an image on top.
-  All "tasks" in the pipeline can be executed in parallel on any
-   available CPUs, increasing performance
-  The ``-o DPI`` argument has been phased out, in favor of ``--oversample DPI``, in
-   case we need ``-o OUTPUTFILE`` in the future
-  Removed several dependencies, so it's easier to install.  We no 
-   longer use:
-   
-   - GNU parallel_
-   - ImageMagick_
-   - Python 2.7
-   - Poppler
-   - MuPDF_ tools
-   - shell scripts
-   - Java and JHOVE_
-   - libxml2
+-   New, robust rewrite in Python 3.4+ with ruffus_ pipelines
+-   Now uses Ghostscript 9.14's improved color conversion model to preserve PDF colors
+-   OCR text is now rendered in the PDF as invisible text. Previous versions of OCRmyPDF
+    incorrectly rendered visible text with an image on top.
+-   All "tasks" in the pipeline can be executed in parallel on any
+    available CPUs, increasing performance
+-   The ``-o DPI`` argument has been phased out, in favor of ``--oversample DPI``, in
+    case we need ``-o OUTPUTFILE`` in the future
+-   Removed several dependencies, so it's easier to install.  We no 
+    longer use:
+    
+    - GNU parallel_
+    - ImageMagick_
+    - Python 2.7
+    - Poppler
+    - MuPDF_ tools
+    - shell scripts
+    - Java and JHOVE_
+    - libxml2

-  Some new external dependencies are required or optional, compared to v2.x:
+-   Some new external dependencies are required or optional, compared to v2.x:

-   - Ghostscript 9.14+
-   - qpdf_ 5.0.0+
-   - Unpaper_ 6.1 (optional)
-   - some automatically managed Python packages
+    - Ghostscript 9.14+
+    - qpdf_ 5.0.0+
+    - Unpaper_ 6.1 (optional)
+    - some automatically managed Python packages
  
 .. _ruffus: http://www.ruffus.org.uk/index.html
 .. _parallel: https://www.gnu.org/software/parallel/
@@ -487,87 +539,87 @@ Changes
 Release candidates
 ^^^^^^^^^^^^^^^^^^

-  rc9:
+-   rc9:

-   - fix issue #118: report error if ghostscript iccprofiles are missing
-   - fixed another issue related to #111: PDF rasterized to palette file
-   - add support image files with a palette
-   - don't try to validate PDF file after an exception occurs
+    - fix issue #118: report error if ghostscript iccprofiles are missing
+    - fixed another issue related to #111: PDF rasterized to palette file
+    - add support image files with a palette
+    - don't try to validate PDF file after an exception occurs

-  rc8:
+-   rc8:

-   - fix issue #111: exception thrown if PDF is missing DocumentInfo dictionary
+    - fix issue #111: exception thrown if PDF is missing DocumentInfo dictionary

-  rc7:
+-   rc7:

-   - fix error when installing direct from pip, "no such file 'requirements.txt'"
+    - fix error when installing direct from pip, "no such file 'requirements.txt'"

-  rc6:
+-   rc6:

-   - dropped libxml2 (Python lxml) since Python 3's internal XML parser is sufficient
-   - set up Docker container
-   - fix Unicode errors if recognized text contains Unicode characters and system locale is not UTF-8
+    - dropped libxml2 (Python lxml) since Python 3's internal XML parser is sufficient
+    - set up Docker container
+    - fix Unicode errors if recognized text contains Unicode characters and system locale is not UTF-8

-  rc5:
+-   rc5:

-   - dropped Java and JHOVE in favour of qpdf
-   - improved command line error output
-   - additional tests and bug fixes
-   - tested on Ubuntu 14.04 LTS
+    - dropped Java and JHOVE in favour of qpdf
+    - improved command line error output
+    - additional tests and bug fixes
+    - tested on Ubuntu 14.04 LTS

-  rc4:
+-   rc4:

-   - dropped MuPDF in favour of qpdf
-   - fixed some installer issues and errors in installation instructions
-   - improve performance: run Ghostscript with multithreaded rendering
-   - improve performance: use multiple cores by default
-   - bug fix: checking for wrong exception on process timeout 
+    - dropped MuPDF in favour of qpdf
+    - fixed some installer issues and errors in installation instructions
+    - improve performance: run Ghostscript with multithreaded rendering
+    - improve performance: use multiple cores by default
+    - bug fix: checking for wrong exception on process timeout 

-  rc3: skipping version number intentionally to avoid confusion with Tesseract
-  rc2: first release for public testing to test-PyPI, Github
-  rc1: testing release process
+-   rc3: skipping version number intentionally to avoid confusion with Tesseract
+-   rc2: first release for public testing to test-PyPI, Github
+-   rc1: testing release process

 Compatibility notes
 -------------------

-  ``./OCRmyPDF.sh`` script is still available for now
-  Stacking the verbosity option like ``-vvv`` is no longer supported
+-   ``./OCRmyPDF.sh`` script is still available for now
+-   Stacking the verbosity option like ``-vvv`` is no longer supported

-  The configuration file ``config.sh`` has been removed.  Instead, you can
-   feed a file to the arguments for common settings:
+-   The configuration file ``config.sh`` has been removed.  Instead, you can
+    feed a file to the arguments for common settings:

 ::

-   ocrmypdf input.pdf output.pdf @settings.txt
+    ocrmypdf input.pdf output.pdf @settings.txt

 where ``settings.txt`` contains *one argument per line*, for example:

 ::

-   -l 
-   deu 
-   --author 
-   A. Merkel 
-   --pdf-renderer 
-   tesseract
+    -l 
+    deu 
+    --author 
+    A. Merkel 
+    --pdf-renderer 
+    tesseract


 Fixes
 ^^^^^

-  Handling of filenames containing spaces: fixed
+-   Handling of filenames containing spaces: fixed

 Notes and known issues
 ^^^^^^^^^^^^^^^^^^^^^^

-  Some dependencies may work with lower versions than tested, so try
-   overriding dependencies if they are "in the way" to see if they work.
+-   Some dependencies may work with lower versions than tested, so try
+    overriding dependencies if they are "in the way" to see if they work.

-  ``--pdf-renderer tesseract`` will output files with an incorrect page size in Tesseract 3.03,
-   due to a bug in Tesseract.
+-   ``--pdf-renderer tesseract`` will output files with an incorrect page size in Tesseract 3.03,
+    due to a bug in Tesseract.

-  PDF files containing "inline images" are not supported and won't be for the 3.0 release. Scanned
-   images almost never contain inline images.
+-   PDF files containing "inline images" are not supported and won't be for the 3.0 release. Scanned
+    images almost never contain inline images.


 v2.2-stable (2014-09-29)
@@ -1,3 +1,5 @@
+# © 2017 James R. Barlow: github.com/jbarlow83
+
 import pkg_resources

 PROGRAM_NAME = 'ocrmypdf'
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# © 2015-16 James R. Barlow: github.com/jbarlow83
+# © 2015-17 James R. Barlow: github.com/jbarlow83

 from contextlib import suppress
 from tempfile import mkdtemp
@@ -41,6 +41,9 @@ warnings.simplefilter('ignore', pypdf.utils.PdfReadWarning)

 MINIMUM_TESS_VERSION = '3.04'

+HOCR_OK_LANGS = frozenset([
+    'eng', 'deu', 'spa', 'ita', 'por'
+])

 def complain(message):
    print(*textwrap.wrap(message), file=sys.stderr)
@@ -250,15 +253,18 @@ advanced.add_argument(
         "3 - default.")
    )
 advanced.add_argument(
-    '--pdf-renderer', choices=['auto', 'tesseract', 'hocr', 'tess4'], default='auto',
+    '--pdf-renderer',
+    choices=['auto', 'tesseract', 'hocr', 'tess4', 'sandwich'], default='auto',
    help="Choose OCR PDF renderer - the default option is to let OCRmyPDF "
-         "choose.  The 'tesseract' PDF renderer is more accurate and does a "
-         "better job and document structure such as recognizing columns. It "
-         "also does a better job on non-Latin languages. However, it does "
-         "not work as well when older versions of Tesseract or Ghostscript "
-         "are installed, and some combinations of arguments to do not work "
-         "with --pdf-renderer tesseract.  The 'tess4' PDF renderer is similar "
-         "to 'tesseract', requires tesseract 4, and gives superior results.")
+         "choose."
+         "auto - let OCRmyPDF choose; "
+         "sandwich - default renderer for Tesseract 3.05.01 and newer; "
+         "hocr - default renderer for older versions of Tesseract; "
+         "tesseract - gives better results for non-Latin languages and "
+         "Tesseract older than 3.05.01 but has problems with some versions "
+         " of Ghostscript; deprecated"
+         "tess4 - deprecated alias for 'sandwich'"
+    )
 advanced.add_argument(
    '--tesseract-timeout', default=180.0, type=float, metavar='SECONDS',
    help='Give up on OCR after the timeout, but copy the preprocessed page '
@@ -278,6 +284,15 @@ advanced.add_argument(
         "are applied to all pages, including those for which OCR was "
         "skipped.  Not supported for --output-type=pdf ; that setting "
         "preserves the original compression of all images.")
+advanced.add_argument(
+    '--user-words', metavar='FILE',
+    help="Specify the location of the Tesseract user words file. This is a "
+         "list of words Tesseract should consider while performing OCR in "
+         "addition to its standard language dictionaries. This can improve "
+         "OCR quality especially for specialized and technical documents.")
+advanced.add_argument(
+    '--user-patterns', metavar='FILE',
+    help="Specify the location of the Tesseract user patterns file.")

 debugging = parser.add_argument_group(
    "Debugging",
@@ -307,33 +322,41 @@ def check_options_languages(options, _log):
            "data for the following requested languages: \n")
        for lang in (set(options.language) - tesseract.languages()):
            msg += lang + '\n'
-        raise argparse.ArgumentError(None, msg)
+        raise MissingDependencyError(msg)


 def check_options_output(options, log):
    if options.pdf_renderer == 'auto':
-        options.pdf_renderer = 'hocr'
+        if tesseract.has_textonly_pdf():
+            options.pdf_renderer = 'sandwich'
+        else:
+            options.pdf_renderer = 'hocr'

-    if options.pdf_renderer in ('tesseract', 'tess4'):
-        if tesseract.version() < '3.05':
-            log.warning(
-                "The setting --pdf-renderer=tesseract is not recommend for "
-                " use with tesseract versions less than 3.05, because it "
-                " produces OCR text that is incompatible with Ghostscript and "
-                " some other software.")
-        elif tesseract.version() == '4.00.00alpha':
-            log.warning(
-                "The setting --pdf-renderer={tesseract,tess4} is not"
-                " recommended for builds of tesseract 4.00.00alpha older than"
-                " February 2017. Make sure you are using a recent build.")
+    if options.pdf_renderer == 'sandwich' and not tesseract.has_textonly_pdf():
+        raise MissingDependencyError(
+            "The 'sandwich' renderer requires Tesseract 3.05.01 or newer; "
+            "or Tesseract 4.00 alpha newer than February 2017.")

-    if options.debug_rendering and options.pdf_renderer == 'tesseract':
+    if options.pdf_renderer == 'tess4':
+        log.warning("The 'tess4' PDF renderer has been renamed to 'sandwich'. "
+                    "Please use --pdf-renderer=sandwich.")
+        options.pdf_renderer = 'sandwich'
+
+    if options.pdf_renderer == 'tesseract':
+        log.warning("The 'tesseract' PDF renderer is deprecated.")
+        if tesseract.version() < '3.05' and options.output_type == 'pdfa':
+            log.warning(
+                "For best results use --pdf-renderer=tesseract "
+                "--output-type=pdf to disable PDF/A generation via "
+                "Ghostscript, which is known to corrupt the OCR text of "
+                "some PDFs produced your version of Tesseract.")
+
+    if options.debug_rendering and options.pdf_renderer != 'hocr':
        log.info(
-            "Ignoring --debug-rendering because it is not supported with"
-            "--pdf-renderer=tesseract.")
+            "Ignoring --debug-rendering because it requires --pdf-renderer=hocr")

    lossless_reconstruction = False
-    if options.pdf_renderer in ('hocr', 'tess4'):
+    if options.pdf_renderer in ('hocr', 'sandwich'):
        if not any((options.deskew, options.clean_final, options.force_ocr,
                   options.remove_background)):
            lossless_reconstruction = True
@@ -380,12 +403,20 @@ def check_options_ocr_behavior(options, log):
    #     raise argparse.ArgumentError(
    #         "Error: --redo-ocr and other OCR options are incompatible.")

-    if set(options.language) & {'chi_sim', 'chi_tra'} and \
-            (options.pdf_renderer == 'hocr' or options.output_type == 'pdfa'):
-        log.warning(
-            "Your settings are known to cause problems with OCR of Chinese text. "
-            "Try adding these arguments: "
-            "    ocrmypdf --pdf-renderer tesseract --output-type pdf")
+    if options.pdf_renderer == 'hocr' and \
+            not set(options.language).issubset(HOCR_OK_LANGS):
+        msg = (
+            "The 'hocr' PDF renderer is known to cause problems with one "
+            "or more of the languages in your document. ")
+
+        if tesseract.has_textonly_pdf():
+            msg += (
+                "Use --pdf-renderer auto (the default) to avoid this issue.")
+        else:
+            msg += (
+                "Use --pdf-renderer tesseract --output-type pdf to avoid "
+                "this issue")
+        log.warning(msg)


 def check_options_advanced(options, log):
@@ -660,8 +691,9 @@ def run_pipeline():
                    file."""))
                return ExitCode.bad_args
        elif not is_file_writable(options.output_file):
-            _log.error(textwrap.dedent("""\
-                Output file location is not writable."""))
+            _log.error(
+                "Output file location (" + options.output_file + ") " +
+                "is not writable.")
            return ExitCode.file_access_error

        manager = JobContextManager()
@@ -734,7 +766,7 @@ def run_pipeline():
                 180: 's', 270: 'w'}
    orientations = []
    for n, page in enumerate(pdfinfo):
-        angle = pdfinfo[n].get('rotated', 0)
+        angle = pdfinfo[n].rotation or 0
        if angle != 0:
            orientations.append('{0}{1}'.format(
                n + 1,
@@ -6,8 +6,11 @@ from subprocess import run, PIPE, STDOUT, CalledProcessError
 from shutil import copy
 from functools import lru_cache
 import re
+import sys
 from . import get_program
 from ..exceptions import SubprocessOutputError
+from PIL import Image
+from ..helpers import fspath


@lru_cache(maxsize=1)
@@ -33,7 +36,28 @@ def _gs_error_reported(stream):


 def rasterize_pdf(input_file, output_file, xres, yres, raster_device, log,
-                  pageno=1):
+                  pageno=1, page_dpi=None):
+    """
+    Rasterize one page of a PDF at resolution (xres, yres) in canvas units.
+    
+    The image is sized to match the integer pixels dimensions implied by 
+    (xres, yres) even if those numbers are noninteger. The image's DPI will
+     be overridden with the values in page_dpi.
+    
+    :param input_file: pathlike
+    :param output_file: pathlike
+    :param xres: resolution at which to rasterize page
+    :param yres: 
+    :param raster_device: 
+    :param log: 
+    :param pageno: page number to rasterize
+    :param page_dpi: resolution tuple (x, y) overriding output image DPI 
+    :return: 
+    """
+    res = xres, yres
+    int_res = round(xres), round(yres)
+    if not page_dpi:
+        page_dpi = res
    with NamedTemporaryFile(delete=True) as tmp:
        args_gs = [
            get_program('gs'),
@@ -45,8 +69,8 @@ def rasterize_pdf(input_file, output_file, xres, yres, raster_device, log,
            '-dFirstPage=%i' % pageno,
            '-dLastPage=%i' % pageno,
            '-o', tmp.name,
-            '-r{0}x{1}'.format(str(round(xres)), str(round(yres))),
-            input_file
+            '-r{0}x{1}'.format(str(int_res[0]), str(int_res[1])),
+            fspath(input_file)
        ]

        p = run(args_gs, stdout=PIPE, stderr=STDOUT,
@@ -56,14 +80,30 @@ def rasterize_pdf(input_file, output_file, xres, yres, raster_device, log,
        else:
            log.debug(p.stdout)

-        if p.returncode == 0:
-            copy(tmp.name, output_file)
-        else:
+        if p.returncode != 0:
            log.error('Ghostscript rasterizing failed')
            raise SubprocessOutputError()

+        # Ghostscript only accepts integers for output resolution
+        # if the resolution happens to be fractional, then the discrepancy
+        # would change the size of the output page, especially if the DPI
+        # is quite low. Resize the image to the expected size
+        tmp.seek(0)
+        with Image.open(tmp) as im:
+            expected_size = round(im.size[0] / int_res[0] * res[0]), \
+                            round(im.size[1] / int_res[1] * res[1])
+            if expected_size != im.size or page_dpi != (xres, yres):
+                log.debug(
+                    "Ghostscript: resize output image {} -> {}".format(
+                        im.size, expected_size))
+                im.resize(expected_size).save(
+                    fspath(output_file), dpi=page_dpi)
+            else:
+                copy(tmp.name, fspath(output_file))

-def generate_pdfa(pdf_pages, output_file, compression, log, threads=1):
+
+def generate_pdfa(pdf_pages, output_file, compression, log,
+                  threads=1, pdf_version='1.5'):
    compression_args = []
    if compression == 'jpeg':
        compression_args = [
@@ -91,7 +131,8 @@ def generate_pdfa(pdf_pages, output_file, compression, log, threads=1):
            "-dQUIET",
            "-dBATCH",
            "-dNOPAUSE",
-            '-dNumRenderingThreads=' + str(threads),
+            "-dCompatibilityLevel=" + str(pdf_version),
+            "-dNumRenderingThreads=" + str(threads),
            "-sDEVICE=pdfwrite",
            "-dAutoRotatePages=/None",
            "-sColorConversionStrategy=/RGB",
@@ -120,13 +120,18 @@ def split_pages(input_file, work_folder, npages):
        run(args_qpdf, check=True)


-def merge(input_files, output_file):
+def merge(input_files, output_file, min_version=None):
    """Merge the list of input files (all filenames) into the output file.

    The input files may contain one or more pages.
    """
+    version_arg = ['--min-version={}'.format(min_version)] \
+                  if min_version else []
+
    args_qpdf = [
-        get_program('qpdf'), input_files[0], '--pages'
+        get_program('qpdf')
+    ] + version_arg + [
+        input_files[0], '--pages'
    ] + input_files + ['--', output_file]
    run(args_qpdf, check=True)

@@ -21,27 +21,22 @@ OrientationConfidence = namedtuple(
    'OrientationConfidence',
    ('angle', 'confidence'))

-HOCR_TEMPLATE = '''<?xml version="1.0" encoding="UTF-8"?>
+HOCR_TEMPLATE = """<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
  <title></title>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-  <meta name='ocr-system' content='tesseract 3.02.02' />
+<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
+  <meta name='ocr-system' content='tesseract 3.05.00' />
  <meta name='ocr-capabilities' content='ocr_page ocr_carea ocr_par ocr_line ocrx_word'/>
- </head>
- <body>
-  <div class='ocr_page' id='page_1' title='image "x.tif"; bbox 0 0 {0} {1}; ppageno 0'>
-   <div class='ocr_carea' id='block_1_1' title="bbox 0 1 {0} {1}">
-    <p class='ocr_par' dir='ltr' id='par_1' title="bbox 0 1 {0} {1}">
-     <span class='ocr_line' id='line_1' title="bbox 0 1 {0} {1}"><span class='ocrx_word' id='word_1' title="bbox 0 1 {0} {1}"> </span>
-     </span>
-    </p>
-   </div>
+</head>
+<body>
+  <div class='ocr_page' id='page_1' title='image "_blank.png"; bbox 0 0 {0} {1}; ppageno 0'>
  </div>
 </body>
-</html>'''
+</html>
+"""


@lru_cache(maxsize=1)
@@ -68,26 +63,28 @@ def v4():
    return (version() >= '4')


+@lru_cache(maxsize=1)
 def has_textonly_pdf():
-    if version() == '4.00.00alpha':
-        # textonly_pdf added during the 4.00.00alpha cycle, so we must test
-        # more carefully to see if it is present
-        args_tess = [
-            get_program('tesseract'),
-            '--print-parameters'
-        ]
-        try:
-            params = check_output(
-                    args_tess, close_fds=True, universal_newlines=True,
-                    stderr=STDOUT)
-        except CalledProcessError as e:
-            print("Could not --print-parameters from tesseract",
-                  file=sys.stderr)
-            raise MissingDependencyError from e
-        if 'textonly_pdf' in params:
-            return True
-    else:
-        return v4()
+    """Does Tesseract have textonly_pdf capability?
+    
+    Available in 3.05.01, and v4.00.00alpha since January 2017. Best to 
+    parse the parameter list
+    """
+    args_tess = [
+        get_program('tesseract'),
+        '--print-parameters'
+    ]
+    try:
+        params = check_output(
+                args_tess, close_fds=True, universal_newlines=True,
+                stderr=STDOUT)
+    except CalledProcessError as e:
+        print("Could not --print-parameters from tesseract",
+              file=sys.stderr)
+        raise MissingDependencyError from e
+    if 'textonly_pdf' in params:
+        return True
+    return False


 def psm():
@@ -216,7 +213,8 @@ def _generate_null_hocr(output_hocr, output_sidecar, image):

 def generate_hocr(input_file, output_files, language: list, engine_mode,
                  tessconfig: list,
-                  timeout: float, pagesegmode: int, log):
+                  timeout: float, pagesegmode: int, user_words, user_patterns,
+                  log):

    output_hocr = next(o for o in output_files if o.endswith('.hocr'))
    output_sidecar = next(o for o in output_files if o.endswith('.txt'))
@@ -227,13 +225,22 @@ def generate_hocr(input_file, output_files, language: list, engine_mode,
    if pagesegmode is not None:
        args_tesseract.extend([psm(), str(pagesegmode)])

+    if user_words:
+        args_tesseract.extend(['--user-words', user_words])
+
+    if user_patterns:
+        args_tesseract.extend(['--user-patterns', user_patterns])
+
    # Reminder: test suite tesseract spoofers will break after any changes
    # to the number of order parameters here
+    # Tesseract 3.04 requires the order here to be "hocr txt" and will fail
+    # on "txt hocr"
+
    args_tesseract.extend([
        input_file,
        prefix,
-        'txt',
-        'hocr'
+        'hocr',
+        'txt'
    ] + tessconfig)
    try:
        log.debug(args_tesseract)
@@ -286,7 +293,8 @@ def use_skip_page(text_only, skip_pdf, output_pdf, output_text):

 def generate_pdf(*, input_image, skip_pdf, output_pdf, output_text,
                 language: list, engine_mode, text_only: bool,
-                 tessconfig: list, timeout: float, pagesegmode: int, log):
+                 tessconfig: list, timeout: float, pagesegmode: int,
+                 user_words, user_patterns, log):
    '''Use Tesseract to render a PDF.

    input_image -- image to analyze
@@ -309,15 +317,22 @@ def generate_pdf(*, input_image, skip_pdf, output_pdf, output_text,
    if text_only:
        args_tesseract.extend(['-c', 'textonly_pdf=1'])

+    if user_words:
+        args_tesseract.extend(['--user-words', user_words])
+
+    if user_patterns:
+        args_tesseract.extend(['--user-patterns', user_patterns])
+
    prefix = os.path.splitext(output_pdf)[0]  # Tesseract appends suffixes

-    # Reminder: test suite tesseract spoofers will break after any changes
+    # Reminder: test suite tesseract spoofers might break after any changes
    # to the number of order parameters here
+
    args_tesseract.extend([
        input_image,
        prefix,
-        'txt',
        'pdf',
+        'txt'
    ] + tessconfig)

    try:
@@ -3,7 +3,7 @@

 from functools import partial
 from collections.abc import Iterable
-from contextlib import suppress
+from contextlib import suppress, contextmanager
 import sys
 import os

@@ -77,3 +77,45 @@ def is_file_writable(test_file):
            with suppress(OSError):
                os.unlink(test_file)
        return True
+
+
+if sys.version_info[0:2] <= (3, 5):
+    def universal_open(p, *args, **kwargs):
+        "Work around Python 3.5's inability to open(pathlib.Path())"
+        try:
+            return p.open(*args, **kwargs)
+        except AttributeError:
+            return open(p, *args, **kwargs)
+
+
+    def fspath(path):
+        import pathlib
+        '''https://www.python.org/dev/peps/pep-0519/#os'''
+        if isinstance(path, (str, bytes)):
+            return path
+
+        # Work from the object's type to match method resolution of other magic
+        # methods.
+        path_type = type(path)
+        try:
+            path = path_type.__fspath__(path)
+        except AttributeError:
+            # Added for Python 3.5 support.
+            if isinstance(path, pathlib.Path):
+                return str(path)
+            elif hasattr(path_type, '__fspath__'):
+                raise
+        else:
+            if isinstance(path, (str, bytes)):
+                return path
+            else:
+                raise TypeError("expected __fspath__() to return str or bytes, "
+                                "not " + type(path).__name__)
+
+        raise TypeError(
+            "expected str, bytes, pathlib.Path or os.PathLike object, not "
+            + path_type.__name__)
+
+else:
+    universal_open = open
+    fspath = os.fspath
@@ -14,6 +14,7 @@ from ctypes.util import find_library
 from .lib._leptonica import ffi
 from functools import lru_cache
 from enum import Enum
+from .helpers import fspath

 lept = ffi.dlopen(find_library('lept'))

@@ -208,26 +209,27 @@ class Pix:
            return 'P'

    @classmethod
-    def read(cls, filename):
+    def read(cls, path):
        """Load an image file into a PIX object.

        Leptonica can load TIFF, PNM (PBM, PGM, PPM), PNG, and JPEG.  If
        loading fails then the object will wrap a C null pointer.
        """
+        filename = fspath(path)
        with LeptonicaErrorTrap():
-            return cls(lept.pixRead(
-                filename.encode(sys.getfilesystemencoding())))
+            return cls(lept.pixRead(os.fsencode(filename)))

    def write_implied_format(
-            self, filename, jpeg_quality=0, jpeg_progressive=0):
+            self, path, jpeg_quality=0, jpeg_progressive=0):
        """Write pix to the filename, with the extension indicating format.

        jpeg_quality -- quality (iff JPEG; 1 - 100, 0 for default)
        jpeg_progressive -- (iff JPEG; 0 for baseline seq., 1 for progressive)
        """
+        filename = fspath(path)
        with LeptonicaErrorTrap():
            lept.pixWriteImpliedFormat(
-                filename.encode(sys.getfilesystemencoding()),
+                os.fsencode(filename),
                self._pix, jpeg_quality, jpeg_progressive)

    def topil(self):
@@ -1 +1,2 @@
 """Bindings to external libraries"""
+# © 2017 James R. Barlow: github.com/jbarlow83
@@ -1,3 +1,5 @@
+# © 2017 James R. Barlow: github.com/jbarlow83
+
 from cffi import FFI

 ffibuilder = FFI()
@@ -8,8 +8,12 @@ import re
 import sys
 import PyPDF2 as pypdf
 from collections import namedtuple
+import warnings


+warnings.warn("ocrmypdf.pageinfo is deprecated'; use ocrmypdf.pdfinfo",
+              DeprecationWarning)
+
 matrix_mult = pypdf.pdf.utils.matrixMultiply

 FRIENDLY_COLORSPACE = {
@@ -0,0 +1,729 @@
+#!/usr/bin/env python3
+# © 2015 James R. Barlow: github.com/jbarlow83
+
+from subprocess import Popen, PIPE
+from decimal import Decimal
+from math import hypot, isclose
+import re
+import sys
+import PyPDF2 as pypdf
+from collections import namedtuple
+from collections.abc import MutableMapping, Mapping
+import warnings
+from pathlib import Path
+from enum import Enum
+from .helpers import universal_open
+
+
+matrix_mult = pypdf.pdf.utils.matrixMultiply
+
+Colorspace = Enum('Colorspace',
+                  'gray rgb cmyk lab icc index sep devn pattern jpeg2000')
+
+Encoding = Enum('Encoding',
+                'ccitt jpeg jpeg2000 jbig2 asciihex ascii85 lzw flate ' + \
+                'runlength')
+
+
+FRIENDLY_COLORSPACE = {
+    '/DeviceGray': Colorspace.gray,
+    '/CalGray': Colorspace.gray,
+    '/DeviceRGB': Colorspace.rgb,
+    '/CalRGB': Colorspace.rgb,
+    '/DeviceCMYK': Colorspace.cmyk,
+    '/Lab': Colorspace.lab,
+    '/ICCBased': Colorspace.icc,
+    '/Indexed': Colorspace.index,
+    '/Separation': Colorspace.sep,
+    '/DeviceN': Colorspace.devn,
+    '/Pattern': Colorspace.pattern,
+    '/G': Colorspace.gray,  # Abbreviations permitted in inline images
+    '/RGB': Colorspace.rgb,
+    '/CMYK': Colorspace.cmyk,
+    '/I': Colorspace.index,
+}
+
+FRIENDLY_ENCODING = {
+    '/CCITTFaxDecode': Encoding.ccitt,
+    '/DCTDecode': Encoding.jpeg,
+    '/JPXDecode': Encoding.jpeg2000,
+    '/JBIG2Decode': Encoding.jbig2,
+    '/CCF': Encoding.ccitt,  # Abbreviations permitted in inline images
+    '/DCT': Encoding.jpeg,
+    '/AHx': Encoding.asciihex,
+    '/A85': Encoding.ascii85,
+    '/LZW': Encoding.lzw,
+    '/Fl': Encoding.flate,
+    '/RL': Encoding.runlength
+}
+
+FRIENDLY_COMP = {
+    Colorspace.gray: 1,
+    Colorspace.rgb: 3,
+    Colorspace.cmyk: 4,
+    Colorspace.lab: 3,
+    Colorspace.index: 1
+}
+
+
+UNIT_SQUARE = (1.0, 0.0, 0.0, 1.0, 0.0, 0.0)
+
+
+def _matrix_from_shorthand(shorthand):
+    """Convert from PDF matrix shorthand to full matrix
+
+    PDF 1.7 spec defines a shorthand for describing the entries of a matrix
+    since the last column is always (0, 0, 1).
+    """
+
+    a, b, c, d, e, f = map(float, shorthand)
+    return ((a, b, 0),
+            (c, d, 0),
+            (e, f, 1))
+
+
+def _shorthand_from_matrix(matrix):
+    """Convert from transformation matrix to PDF shorthand."""
+    a, b = matrix[0][0], matrix[0][1]
+    c, d = matrix[1][0], matrix[1][1]
+    e, f = matrix[2][0], matrix[2][1]
+    return tuple(map(float, (a, b, c, d, e, f)))
+
+
+def _is_unit_square(shorthand):
+    values = map(float, shorthand)
+    pairwise = zip(values, UNIT_SQUARE)
+    return all([isclose(a, b, rel_tol=1e-3) for a, b in pairwise])
+
+XobjectSettings = namedtuple('XobjectSettings',
+    ['name', 'shorthand', 'stack_depth'])
+
+InlineSettings = namedtuple('InlineSettings',
+    ['settings', 'shorthand', 'stack_depth'])
+
+ContentsInfo = namedtuple('ContentsInfo', ['xobject_settings', 'inline_images'])
+
+
+def _normalize_stack(operations):
+    """Fix runs of qQ's in the stack
+
+    For some reason PyPDF2 converts runs of qqq, QQ, QQQq, etc. into single
+    operations.  Break this silliness up and issue each stack operation
+    individually so we don't lose count.
+
+    """
+    for operands, command in operations:
+        if re.match(br'Q*q+$', command):   # Zero or more Q, one or more q
+            for char in command:           # Split into individual bytes
+                yield ([], bytes([char]))  # Yield individual bytes
+        else:
+            yield (operands, command)
+
+
+def _interpret_contents(contentstream, initial_shorthand=UNIT_SQUARE):
+    """Interpret the PDF content stream
+
+    The stack represents the state of the PDF graphics stack.  We are only
+    interested in the current transformation matrix (CTM) so we only track
+    this object; a full implementation would need to track many other items.
+
+    The CTM is initialized to the mapping from user space to device space.
+    PDF units are 1/72".  In a PDF viewer or printer this matrix is initialized
+    to the transformation to device space.  For example if set to
+    (1/72, 0, 0, 1/72, 0, 0) then all units would be calculated in inches.
+
+    Images are always considered to be (0, 0) -> (1, 1).  Before drawing an
+    image there should be a 'cm' that sets up an image coordinate system
+    where drawing from (0, 0) -> (1, 1) will draw on the desired area of the
+    page.
+
+    PDF units suit our needs so we initialize ctm to the identity matrix.
+
+    PyPDF2 replaces inline images with a fake "INLINE IMAGE" operator.
+
+    """
+
+    operations = contentstream.operations
+    stack = []
+    ctm = _matrix_from_shorthand(initial_shorthand)
+    xobject_settings = []
+    inline_images = []
+
+    for n, op in enumerate(_normalize_stack(operations)):
+        operands, command = op
+        if command == b'q':
+            stack.append(ctm)
+            if len(stack) > 32:
+                raise RuntimeError(
+                    "PDF graphics stack overflow, command %i" % n)
+        elif command == b'Q':
+            try:
+                ctm = stack.pop()
+            except IndexError:
+                raise RuntimeError(
+                    "PDF graphics stack underflow, command %i" % n)
+        elif command == b'cm':
+            ctm = matrix_mult(
+                _matrix_from_shorthand(operands), ctm)
+        elif command == b'Do':
+            image_name = operands[0]
+            settings = XobjectSettings(
+                name=image_name, shorthand=_shorthand_from_matrix(ctm),
+                stack_depth=len(stack))
+            xobject_settings.append(settings)
+        elif command == b'INLINE IMAGE':
+            settings = operands['settings']
+            inline = InlineSettings(
+                settings=settings, shorthand=_shorthand_from_matrix(ctm),
+                stack_depth=len(stack))
+            inline_images.append(inline)
+
+    return ContentsInfo(
+        xobject_settings=xobject_settings,
+        inline_images=inline_images)
+
+
+def _get_dpi(ctm_shorthand, image_size):
+    """Given the transformation matrix and image size, find the image DPI.
+
+    PDFs do not include image resolution information within image data.
+    Instead, the PDF page content stream describes the location where the
+    image will be rasterized, and the effective resolution is the ratio of the
+    pixel size to raster target size.
+
+    Normally a scanned PDF has the paper size set appropriately but this is
+    not guaranteed. The most common case is a cropped image will change the
+    page size (/CropBox) without altering the page content stream. That means
+    it is not sufficient to assume that the image fills the page, even though
+    that is the most common case.
+
+    A PDF image may be scaled (always), cropped, translated, rotated in place
+    to an arbitrary angle (rarely) and skewed. Only equal area mappings can
+    be expressed, that is, it is not necessary to consider distortions where
+    the effective DPI varies with position.
+
+    To determine the image scale, transform an offset axis vector v0 (0, 0),
+    width-axis vector v0 (1, 0), height-axis vector vh (0, 1) with the matrix,
+    which gives the dimensions of the image in PDF units. From there we can
+    compare to actual image dimensions. PDF uses
+    row vector * matrix_tranposed unlike the traditional
+    matrix * column vector.
+
+    The offset, width and height vectors can be combined in a matrix and
+    multiplied by the transform matrix. Then we want to calculated
+        magnitude(width_vector - offset_vector)
+    and
+        magnitude(height_vector - offset_vector)
+
+    When the above is worked out algebraically, the effect of translation
+    cancels out, and the vector magnitudes become functions of the nonzero
+    transformation matrix indices. The results of the derivation are used
+    in this code.
+
+    pdfimages -list does calculate the DPI in some way that is not completely
+    naive, but it does not get the DPI of rotated images right, so cannot be
+    used anymore to validate this. Photoshop works, or using Acrobat to
+    rotate the image back to normal.
+
+    It does not matter if the image is partially cropped, or even out of the
+    /MediaBox.
+
+    """
+
+    a, b, c, d, _, _ = ctm_shorthand
+
+    # Calculate the width and height of the image in PDF units
+    image_drawn_width = hypot(a, b)
+    image_drawn_height = hypot(c, d)
+
+    # The scale of the image is pixels per unit of default user space (1/72")
+    scale_w = image_size[0] / image_drawn_width
+    scale_h = image_size[1] / image_drawn_height
+
+    # DPI = scale * 72
+    dpi_w = scale_w * 72.0
+    dpi_h = scale_h * 72.0
+
+    return dpi_w, dpi_h
+
+
+class ImageInfo:
+    DPI_PREC = Decimal('1.000')
+
+    def __init__(self, *, name='', pdfimage=None, inline=None,
+                 shorthand=None):
+
+        self._name = name
+        self._shorthand = shorthand
+        if inline:
+            # Fixme does not work for inline images with non abbreviated
+            # fields
+            self._origin = 'inline'
+            self._width = inline.settings['/W']
+            self._height = inline.settings['/H']
+            self._bpc = inline.settings.get('/BPC', 8)
+            try:
+                self._color = FRIENDLY_COLORSPACE[inline.settings['/CS']]
+            except Exception:
+                self._color = '-'
+            self._comp = FRIENDLY_COMP.get(self._color, '?')
+            if '/F' in inline.settings:
+                filter_ = inline.settings['/F']
+                if isinstance(filter_, pypdf.generic.ArrayObject):
+                    filter_ = filter_[0]
+                self._enc = FRIENDLY_ENCODING.get(filter_, 'image')
+            else:
+                self._enc = 'image'
+        elif pdfimage:
+            self._origin = 'xobject'
+            self._width = pdfimage['/Width']
+            self._height = pdfimage['/Height']
+            if '/BitsPerComponent' in pdfimage:
+                self._bpc = pdfimage['/BitsPerComponent']
+            else:
+                self._bpc = 8
+
+            # Fixme: this is incorrectly treats explicit masks as stencil masks,
+            # but good enough for now. Explicit masks have /ImageMask true but are
+            # never called for in content stream, instead are drawn as a /Mask on
+            # other images. For our purposes finding out the details of /Mask
+            # will seldom matter.
+            if '/ImageMask' in pdfimage:
+                self._type = 'stencil' if pdfimage['/ImageMask'].value \
+                    else 'image'
+            else:
+                self._type = 'image'
+            if '/Filter' in pdfimage:
+                filter_ = pdfimage['/Filter']
+                if isinstance(filter_, pypdf.generic.ArrayObject):
+                    filter_ = filter_[0]
+                self._enc = FRIENDLY_ENCODING.get(filter_, 'image')
+            else:
+                self._enc = 'image'
+            if '/ColorSpace' in pdfimage:
+                cs = pdfimage['/ColorSpace']
+                if isinstance(cs, pypdf.generic.ArrayObject):
+                    cs = cs[0]
+                self._color = FRIENDLY_COLORSPACE.get(cs, '-')
+            else:
+                self._color = FRIENDLY_COLORSPACE[Colorspace.jpeg2000] \
+                    if self._enc == Encoding.jpeg2000 else '?'
+
+            self._comp = FRIENDLY_COMP.get(self._color, '?')
+
+            # Bit of a hack... infer grayscale if component count is uncertain
+            # but encoding must be monochrome. This happens if a monochrome image
+            # has an ICC profile attached. Better solution would be to examine
+            # the ICC profile.
+            if self._comp == '?' and self._enc in (Encoding.ccitt, 'jbig2'):
+                self._comp = FRIENDLY_COMP[Colorspace.gray]
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def type_(self):
+        return self._type
+
+    @property
+    def width(self):
+        return self._width
+
+    @property
+    def height(self):
+        return self._height
+
+    @property
+    def bpc(self):
+        return self._bpc
+
+    @property
+    def color(self):
+        return self._color
+
+    @property
+    def comp(self):
+        return self._comp
+
+    @property
+    def enc(self):
+        return self._enc
+
+    @property
+    def xres(self):
+        return _get_dpi(self._shorthand, (self._width, self._height))[0]
+
+    @property
+    def yres(self):
+        return _get_dpi(self._shorthand, (self._width, self._height))[1]
+
+    def __getitem__(self, item):
+        warnings.warn("ImageInfo.__getitem__", DeprecationWarning)
+        if item in ('name', 'width', 'height', 'bpc', 'color', 'comp', 'enc'):
+            return getattr(self, item)
+        elif item == 'dpi_w':
+            return Decimal(self.xres).quantize(self.DPI_PREC)
+        elif item == 'dpi_h':
+            return Decimal(self.yres).quantize(self.DPI_PREC)
+        elif item == 'dpi':
+            return Decimal(self.xres * self.yres).sqrt().quantize(
+                self.DPI_PREC)
+        else:
+            raise KeyError(item)
+
+    def __repr__(self):
+        class_locals = {attr: getattr(self, attr, None) for attr in dir(self)
+                        if not attr.startswith('_')}
+        return (
+            "<ImageInfo '{name}' {type_} {width}x{height} {color} "
+            "{comp} {bpc} {enc} {xres}x{yres}>").format(**class_locals)
+
+
+def _find_inline_images(contentsinfo):
+    "Find inline images in the contentstream"
+
+    for n, inline in enumerate(contentsinfo.inline_images):
+        yield ImageInfo(name='inline-%02d' % n, shorthand=inline.shorthand,
+                        inline=inline)
+
+
+def _image_xobjects(container):
+    """Search for all XObject-based images in the container
+
+    Usually the container is a page, but it could also be a Form XObject
+    that contains images. Filter out the Form XObjects which are dealt with
+    elsewhere.
+
+    Generate a sequence of tuples (image, xobj container), where container,
+    where xobj is the name of the object and image is the object itself,
+    since the object does not know its own name.
+
+    """
+
+    if '/Resources' not in container:
+        return
+    resources = container['/Resources']
+    if '/XObject' not in resources:
+        return
+    for xobj in resources['/XObject']:
+        candidate = resources['/XObject'][xobj]
+        if candidate['/Subtype'] == '/Image':
+            pdfimage = candidate
+            yield (pdfimage, xobj)
+
+
+def _find_regular_images(container, contentsinfo):
+    """Find images stored in the container's /Resources /XObject
+
+    Usually the container is a page, but it could also be a Form XObject
+    that contains images.
+
+    Generates images with their DPI at time of drawing.
+
+    """
+
+    for pdfimage, xobj in _image_xobjects(container):
+
+        # For each image that is drawn on this, check if we drawing the
+        # current image - yes this is O(n^2), but n == 1 almost always
+        for draw in contentsinfo.xobject_settings:
+            if draw.name != xobj:
+                continue
+
+            if draw.stack_depth == 0 and _is_unit_square(draw.shorthand):
+                # At least one PDF in the wild (and test suite) draws an image
+                # when the graphics stack depth is 0, meaning that the image
+                # gets drawn into a square of 1x1 PDF units (or 1/72",
+                # or 0.35 mm).  The equivalent DPI will be >100,000.  Exclude
+                # these from our DPI calculation for the page.
+                continue
+
+            yield ImageInfo(name=draw.name, pdfimage=pdfimage, shorthand=
+                            draw.shorthand)
+
+
+def _find_form_xobject_images(pdf, container, contentsinfo):
+    """Find any images that are in Form XObjects in the container
+
+    The container may be a page, or a parent Form XObject.
+
+    """
+    if '/Resources' not in container:
+        return
+    resources = container['/Resources']
+    if '/XObject' not in resources:
+        return
+    for xobj in resources['/XObject']:
+        candidate = resources['/XObject'][xobj]
+        if candidate['/Subtype'] != '/Form':
+            continue
+
+        form_xobject = candidate
+        for settings in contentsinfo.xobject_settings:
+            if settings.name != xobj:
+                continue
+
+            # Find images once for each time this Form XObject is drawn.
+            # This could be optimized to cache the multiple drawing events
+            # but in practice both Form XObjects and multiple drawing of the
+            # same object are both very rare.
+            ctm_shorthand = settings.shorthand
+            yield from _find_images(
+                pdf=pdf, container=form_xobject, shorthand=ctm_shorthand)
+
+
+def _find_images(*, pdf, container, shorthand=None):
+    """Find all individual instances of images drawn in the container
+
+    Usually the container is a page, but it may also be a Form XObject.
+
+    On a typical page images are stored inline or as regular images
+    in an XObject.
+
+    Form XObjects may include inline images, XObject images,
+    and recursively, other Form XObjects; and also vector drawing commands.
+
+    Every instance of an image being drawn somewhere is flattened and
+    treated as a unique image, since if the same image is drawn multiple times
+    on one page it may be drawn at differing resolutions, and our objective
+    is to find the resolution at which the page can be rastered without
+    downsampling.
+
+    """
+
+    if container.get('/Type') == '/Page' and '/Contents' in container:
+        # For a /Page the content stream is attached to the page's /Contents
+        page = container
+        contentstream = pypdf.pdf.ContentStream(page.getContents(), pdf)
+        initial_shorthand = shorthand or UNIT_SQUARE
+    elif container.get('/Type') == '/XObject' and \
+            container['/Subtype'] == '/Form':
+        # For a Form XObject that content stream is attached to the XObject
+        contentstream = pypdf.pdf.ContentStream(container, pdf)
+
+        # Set the CTM to the state it was when the "Do" operator was
+        # encountered that is drawing this instance of the Form XObject
+        ctm = _matrix_from_shorthand(shorthand or UNIT_SQUARE)
+
+        # A Form XObject may provide its own matrix to map form space into
+        # user space. Get this if one exists
+        form_matrix = _matrix_from_shorthand(
+                container.get('/Matrix', UNIT_SQUARE))
+
+        # Concatenate form matrix with CTM to ensure CTM is correct for
+        # drawing this instance of the XObject
+        ctm = matrix_mult(form_matrix, ctm)
+        initial_shorthand = _shorthand_from_matrix(ctm)
+    else:
+        return
+
+    contentsinfo = _interpret_contents(contentstream, initial_shorthand)
+
+    yield from _find_inline_images(contentsinfo)
+    yield from _find_regular_images(container, contentsinfo)
+    yield from _find_form_xobject_images(pdf, container, contentsinfo)
+
+
+def _page_has_text(pdf, page):
+    if not '/Contents' in page:
+        return False
+
+    # Simple test
+    text = page.extractText()
+    if text.strip() != '':
+        return True
+
+    # More nuanced test to deal with quirks of Tesseract PDF generation
+    # Check if there's a Glyphless font
+    try:
+        font = page['/Resources']['/Font']
+    except KeyError:
+        pass
+    else:
+        font_objects = list(font.keys())
+        for font_object in font_objects:
+            basefont = font[font_object]['/BaseFont']
+            if basefont.endswith('GlyphLessFont'):
+                return True
+
+    return False
+
+
+def _pdf_get_pageinfo(pdf, pageno: int):
+    pageinfo = {}
+    pageinfo['pageno'] = pageno
+    pageinfo['images'] = []
+
+    if isinstance(pdf, Path):
+        pdf = pypdf.PdfFileReader(str(pdf))
+    elif isinstance(pdf, str):
+        pdf = pypdf.PdfFileReader(pdf)
+
+    page = pdf.pages[pageno]
+
+    pageinfo['has_text'] = _page_has_text(pdf, page)
+
+    width_pt = page.mediaBox.getWidth()
+    height_pt = page.mediaBox.getHeight()
+
+    userunit = page.get('/UserUnit', Decimal(1.0))
+    pageinfo['userunit'] = userunit
+    pageinfo['width_inches'] = width_pt * userunit / Decimal(72.0)
+    pageinfo['height_inches'] = height_pt * userunit / Decimal(72.0)
+
+    try:
+        pageinfo['rotate'] = int(page['/Rotate'])
+    except KeyError:
+        pageinfo['rotate'] = 0
+
+    userunit_shorthand = (userunit, 0, 0, userunit, 0, 0)
+    pageinfo['images'] = [im for im in
+                          _find_images(pdf=pdf, container=page,
+                                       shorthand=userunit_shorthand)]
+    if pageinfo['images']:
+        xres = max(image['dpi_w'] for image in pageinfo['images'])
+        yres = max(image['dpi_h'] for image in pageinfo['images'])
+        pageinfo['xres'], pageinfo['yres'] = xres, yres
+        pageinfo['width_pixels'] = \
+            int(round(xres * pageinfo['width_inches']))
+        pageinfo['height_pixels'] = \
+            int(round(yres * pageinfo['height_inches']))
+
+    return pageinfo
+
+
+def _pdf_get_all_pageinfo(infile):
+    with universal_open(infile, 'rb') as f:
+        pdf = pypdf.PdfFileReader(f)
+        return [PageInfo(pdf, n) for n in range(pdf.numPages)]
+
+
+class PageInfo:
+    def __init__(self, pdf, pageno):
+        self._pageno = pageno
+        self._pageinfo = _pdf_get_pageinfo(pdf, pageno)
+
+    @property
+    def pageno(self):
+        return self._pageno
+
+    @property
+    def has_text(self):
+        return self._pageinfo['has_text']
+
+    @property
+    def width_inches(self):
+        return self._pageinfo['width_inches']
+
+    @property
+    def height_inches(self):
+        return self._pageinfo['height_inches']
+
+    @property
+    def width_pixels(self):
+        return int(round(self.width_inches * self.xres))
+
+    @property
+    def height_pixels(self):
+        return int(round(self.height_inches * self.yres))
+
+    @property
+    def rotation(self):
+        return self._pageinfo.get('rotate', None)
+
+    @rotation.setter
+    def rotation(self, value):
+        if value in (0, 90, 180, 270, 360, -90, -180, -270):
+            self._pageinfo['rotate'] = value
+        else:
+            raise ValueError("rotation must be a cardinal angle")
+
+    @property
+    def images(self):
+        return self._pageinfo['images']
+
+    @property
+    def xres(self):
+        return self._pageinfo.get('xres', None)
+
+    @property
+    def yres(self):
+        return self._pageinfo.get('yres', None)
+
+    @property
+    def userunit(self):
+        return self._pageinfo.get('userunit', None)
+
+    @property
+    def min_version(self):
+        if self.userunit is not None:
+            return '1.6'
+        else:
+            return '1.5'
+
+    @property
+    def images(self):
+        return self._pageinfo['images']
+
+    def __repr__(self):
+        return (
+            '<PageInfo '
+            'pageno={} {}"x{}" rotation={} res={}x{} has_text={}>').format(
+            self.pageno, self.width_inches, self.height_inches,
+            self.rotation,
+            self.xres, self.yres, self.has_text
+        )
+
+
+class PdfInfo:
+    """Get summary information about a PDF
+    
+    """
+    def __init__(self, infile):
+        self._infile = infile
+        self._pages = _pdf_get_all_pageinfo(infile)
+
+    @property
+    def pages(self):
+        return self._pages
+
+    @property
+    def min_version(self):
+        # The minimum PDF is the maximum version that any particular page needs
+        return max(page.min_version for page in self.pages)
+
+    @property
+    def has_userunit(self):
+        return any(page.userunit != 1.0 for page in self.pages)
+
+    def __getitem__(self, item):
+        return self._pages[item]
+
+    def __len__(self):
+        return len(self._pages)
+
+    def __repr__(self):
+        return "<PdfInfo('...'), page count={}>".format(len(self))
+
+    # def __getstate__(self):
+    #     state = {'_infile': self._infile}
+    #     return state
+    #
+    # def __setstate__(self, state):
+    #     self._infile = state['_infile']
+    #     self._pages = _pdf_get_all_pageinfo(self._infile)
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('infile')
+    args = parser.parse_args()
+    info = _pdf_get_all_pageinfo(args.infile)
+    from pprint import pprint
+    pprint(info)
+
+
+if __name__ == '__main__':
+    main()
@@ -22,7 +22,7 @@ from PIL import Image
 from ruffus import formatter, regex, Pipeline, suffix

 from .hocrtransform import HocrTransform
-from .pageinfo import pdf_get_all_pageinfo
+from .pdfinfo import PdfInfo, Encoding, Colorspace
 from .pdfa import generate_pdfa_ps, file_claims_pdfa
 from .helpers import re_symlink, is_iterable_notstr, page_number
 from .exec import ghostscript, tesseract, qpdf
@@ -50,7 +50,10 @@ class JobContext:
    """

    def __init__(self):
-        self.pdfinfo = []
+        self.pdfinfo = None
+
+    def generate_pdfinfo(self, infile):
+        self.pdfinfo = PdfInfo(infile)

    def get_pdfinfo(self):
        "What we know about the input PDF"
@@ -72,8 +75,8 @@ class JobContext:
        self.work_folder = work_folder


-from multiprocessing.managers import BaseManager
-class JobContextManager(BaseManager):
+from multiprocessing.managers import SyncManager
+class JobContextManager(SyncManager):
    pass


@@ -162,8 +165,8 @@ def triage(
    options = context.get_options()
    try:
        with open(input_file, 'rb') as f:
-            signature = f.read(4)
-            if signature == b'%PDF':
+            signature = f.read(1024)
+            if b'%PDF' in signature:
                if options.image_dpi:
                    log.warning("Argument --image-dpi ignored because the "
                                "input file is a PDF, not an image.")
@@ -181,38 +184,59 @@ def repair_pdf(
        output_file,
        log,
        context):
-
+    options = context.get_options()
    qpdf.repair(input_file, output_file, log)
-    pdfinfo = pdf_get_all_pageinfo(output_file)
+    pdfinfo = PdfInfo(output_file)
+
+    if pdfinfo.has_userunit and options.output_type == 'pdfa':
+        log.error("This input file uses a PDF feature that is not supported "
+            "by Ghostscript, so you cannot use --output-type=pdfa for this "
+            "file. (Specifically, it uses the PDF-1.6 /UserUnit feature to "
+            "support very large or small page sizes, and Ghostscript cannot "
+            "output these files.)  Use --output-type=pdf instead."
+        )
+        raise InputFileError()
+
    context.set_pdfinfo(pdfinfo)
    log.debug(pdfinfo)


 def get_pageinfo(input_file, context):
-    pageno = int(os.path.basename(input_file)[0:6]) - 1
+    pageno = page_number(input_file) - 1
    pageinfo = context.get_pdfinfo()[pageno]
    return pageinfo


 def get_page_dpi(pageinfo, options):
    "Get the DPI when nonsquare DPI is tolerable"
-    xres = max(pageinfo.get('xres', VECTOR_PAGE_DPI), options.oversample or 0)
-    yres = max(pageinfo.get('yres', VECTOR_PAGE_DPI), options.oversample or 0)
+    xres = max(pageinfo.xres or VECTOR_PAGE_DPI, options.oversample or 0)
+    yres = max(pageinfo.yres or VECTOR_PAGE_DPI, options.oversample or 0)
    return (float(xres), float(yres))


 def get_page_square_dpi(pageinfo, options):
-    "Get the DPI when we require xres == yres"
+    "Get the DPI when we require xres == yres, scaled to physical units"
+    xres = pageinfo.xres or 0
+    yres = pageinfo.yres or 0
+    userunit = pageinfo.userunit or 1
    return float(max(
-        pageinfo.get('xres', VECTOR_PAGE_DPI),
-        pageinfo.get('yres', VECTOR_PAGE_DPI),
+        (xres * userunit) or VECTOR_PAGE_DPI,
+        (yres * userunit) or VECTOR_PAGE_DPI,
+        options.oversample or 0))
+
+
+def get_canvas_square_dpi(pageinfo, options):
+    """Get the DPI when we require xres == yres, in Postscript units"""
+    return float(max(
+        (pageinfo.xres) or VECTOR_PAGE_DPI,
+        (pageinfo.yres) or VECTOR_PAGE_DPI,
        options.oversample or 0))


 def is_ocr_required(pageinfo, log, options):
-    page = pageinfo['pageno'] + 1
+    page = pageinfo.pageno + 1
    ocr_required = True
-    if not pageinfo['images']:
+    if not pageinfo.images:
        if options.force_ocr and options.oversample:
            # The user really wants to reprocess this file
            log.info(
@@ -234,7 +258,7 @@ def is_ocr_required(pageinfo, log, options):
                "skipping all processing on this page".format(page))
            ocr_required = False

-    elif pageinfo['has_text']:
+    elif pageinfo.has_text:
        msg = "{0:4d}: page already has text! – {1}"

        if not options.force_ocr and not options.skip_text:
@@ -250,8 +274,8 @@ def is_ocr_required(pageinfo, log, options):
                                "skipping all processing on this page"))
            ocr_required = False

-    if ocr_required and options.skip_big and pageinfo['images']:
-        pixel_count = pageinfo['width_pixels'] * pageinfo['height_pixels']
+    if ocr_required and options.skip_big and pageinfo.images:
+        pixel_count = pageinfo.width_pixels * pageinfo.height_pixels
        if pixel_count > (options.skip_big * 1000000):
            ocr_required = False
            log.warning(
@@ -309,13 +333,14 @@ def rasterize_preview(
        output_file,
        log,
        context):
+    pageinfo = get_pageinfo(input_file, context)
+    options = context.get_options()
+    canvas_dpi = get_canvas_square_dpi(pageinfo, options) / 2
+    page_dpi = get_page_square_dpi(pageinfo, options) / 2
+
    ghostscript.rasterize_pdf(
-        input_file=input_file,
-        output_file=output_file,
-        xres=200,
-        yres=200,
-        raster_device='jpeggray',
-        log=log)
+        input_file, output_file, xres=canvas_dpi, yres=canvas_dpi,
+        raster_device='jpeggray', log=log, page_dpi=(page_dpi, page_dpi))


 def orient_page(
@@ -381,9 +406,9 @@ def orient_page(
        with open(output_file, 'wb') as out:
            writer.write(out)

-        pageno = int(os.path.basename(page_pdf)[0:6]) - 1
+        pageno = page_number(page_pdf) - 1
        pdfinfo = context.get_pdfinfo()
-        pdfinfo[pageno]['rotated'] = orient_conf.angle
+        pdfinfo[pageno].rotation = orient_conf.angle
        context.set_pdfinfo(pdfinfo)


@@ -396,26 +421,28 @@ def rasterize_with_ghostscript(
    pageinfo = get_pageinfo(input_file, context)

    device = 'png16m'  # 24-bit
-    if pageinfo['images']:
-        if all(image['comp'] == 1 for image in pageinfo['images']):
-            if all(image['bpc'] == 1 for image in pageinfo['images']):
+    if pageinfo.images:
+        if all(image.comp == 1 for image in pageinfo.images):
+            if all(image.bpc == 1 for image in pageinfo.images):
                device = 'pngmono'
-            elif all(image['bpc'] > 1 and image['color'] == 'index'
-                     for image in pageinfo['images']):
+            elif all(image.bpc > 1 and image.color == Colorspace.index
+                     for image in pageinfo.images):
                device = 'png256'
-            elif all(image['bpc'] > 1 and image['color'] == 'gray'
-                     for image in pageinfo['images']):
+            elif all(image.bpc > 1 and image.color == Colorspace.gray
+                     for image in pageinfo.images):
                device = 'pnggray'

    log.debug("Rasterize {0} with {1}".format(
              os.path.basename(input_file), device))

    # Produce the page image with square resolution or else deskew and OCR
-    # will not work properly
-    dpi = get_page_square_dpi(pageinfo, options)
+    # will not work properly.
+    canvas_dpi = get_canvas_square_dpi(pageinfo, options)
+    page_dpi = get_page_square_dpi(pageinfo, options)
+
    ghostscript.rasterize_pdf(
-        input_file, output_file, xres=dpi, yres=dpi, raster_device=device,
-        log=log)
+        input_file, output_file, xres=canvas_dpi, yres=canvas_dpi,
+        raster_device=device, log=log, page_dpi=(page_dpi, page_dpi))


 def preprocess_remove_background(
@@ -430,11 +457,11 @@ def preprocess_remove_background(

    pageinfo = get_pageinfo(input_file, context)

-    if any(image['bpc'] > 1 for image in pageinfo['images']):
+    if any(image.bpc > 1 for image in pageinfo.images):
        leptonica.remove_background(input_file, output_file)
    else:
        log.info("{0:4d}: background removal skipped on mono page".format(
-            pageinfo['pageno']))
+            pageinfo.pageno))
        re_symlink(input_file, output_file, log)


@@ -475,7 +502,7 @@ def select_ocr_image(
        infiles,
        output_file,
        log,
-        contenxt):
+        context):
    """Select the image we send for OCR. May not be the same as the display
    image depending on preprocessing."""

@@ -498,6 +525,8 @@ def ocr_tesseract_hocr(
        tessconfig=options.tesseract_config,
        timeout=options.tesseract_timeout,
        pagesegmode=options.tesseract_pagesegmode,
+        user_words=options.user_words,
+        user_patterns=options.user_patterns,
        log=log
        )

@@ -521,8 +550,8 @@ def select_visible_page_image(
    image = next(ii for ii in infiles if ii.endswith(image_suffix))

    pageinfo = get_pageinfo(image, context)
-    if pageinfo['images'] and \
-            all(im['enc'] == 'jpeg' for im in pageinfo['images']):
+    if pageinfo.images and \
+            all(im['enc'] == 'jpeg' for im in pageinfo.images):
        log.debug('{:4d}: JPEG input -> JPEG output'.format(
            page_number(image)))
        # If all images were JPEGs originally, produce a JPEG as output
@@ -568,7 +597,7 @@ def select_image_layer(
        # as it accurately describes the image. It would be possible to
        # resample the image at this stage back to non-square DPI to more
        # closely resemble the input, except that the hocr renderer does not
-        # understand non-square DPI. The tess4 renderer would be fine.
+        # understand non-square DPI. The sandwich renderer would be fine.
        dpi = get_page_square_dpi(pageinfo, options)
        layout_fun = img2pdf.get_fixed_dpi_layout_fun((dpi, dpi))

@@ -689,6 +718,12 @@ def combine_layers(
    pdf_output = pypdf.PdfFileWriter()
    pdf_output.addPage(page_text)

+    # If the input was scaled, re-apply the scaling
+    pageinfo = get_pageinfo(text, context)
+    if pageinfo.userunit != 1:
+        page_text[pypdf.generic.NameObject('/UserUnit')] = pageinfo.userunit
+        pdf_output._header = b'%PDF-1.6'  # Hack header to correct version
+
    with open(output_file, "wb") as out:
        pdf_output.write(out)

@@ -722,6 +757,8 @@ def ocr_tesseract_and_render_pdf(
        tessconfig=options.tesseract_config,
        timeout=options.tesseract_timeout,
        pagesegmode=options.tesseract_pagesegmode,
+        user_words=options.user_words,
+        user_patterns=options.user_patterns,
        log=log)


@@ -750,6 +787,8 @@ def ocr_tesseract_textonly_pdf(
        tessconfig=options.tesseract_config,
        timeout=options.tesseract_timeout,
        pagesegmode=options.tesseract_pagesegmode,
+        user_words=options.user_words,
+        user_patterns=options.user_patterns,
        log=log)


@@ -779,9 +818,16 @@ def get_pdfmark(base_pdf, options):
    if options.subject:
        pdfmark['/Subject'] = options.subject

-    pdfmark['/Creator'] = '{0} {1} / Tesseract OCR{2} {3}'.format(
+    if options.pdf_renderer == 'tesseract':
+        renderer_tag = 'OCR+PDF'
+    elif options.pdf_renderer == 'sandwich':
+        renderer_tag = 'OCR-PDF'
+    else:
+        renderer_tag = 'OCR'
+
+    pdfmark['/Creator'] = '{0} {1} / Tesseract {2} {3}'.format(
            PROGRAM_NAME, VERSION,
-            '+PDF' if options.pdf_renderer == 'tesseract' else '',
+            renderer_tag,
            tesseract.version())
    return pdfmark

@@ -823,7 +869,7 @@ def merge_pages_ghostscript(
        right that way.'''
        if s.endswith('.ps'):
            return 99999999
-        key = int(os.path.basename(s)[0:6]) * 10
+        key = page_number(s) * 10
        if 'debug' in os.path.basename(s):
            key += 1
        return key
@@ -832,9 +878,14 @@ def merge_pages_ghostscript(
                   if not f.endswith('.txt'))
    pdf_pages = sorted(input_files, key=input_file_order)
    log.debug("Final pages: " + "\n".join(pdf_pages))
+    input_pdfinfo = context.get_pdfinfo()
    ghostscript.generate_pdfa(
-        pdf_pages, output_file, options.pdfa_image_compression,
-        log, options.jobs or 1)
+        pdf_version=input_pdfinfo.min_version,
+        pdf_pages=pdf_pages,
+        output_file=output_file,
+        compression=options.pdfa_image_compression,
+        log=log,
+        threads=options.jobs or 1)


 def merge_pages_qpdf(
@@ -853,7 +904,7 @@ def merge_pages_qpdf(
    def input_file_order(s):
        '''Sort order: All rendered pages followed
        by their debug page.'''
-        key = int(os.path.basename(s)[0:6]) * 10
+        key = page_number(s) * 10
        if 'debug' in os.path.basename(s):
            key += 1
        return key
@@ -876,7 +927,8 @@ def merge_pages_qpdf(

    pdf_pages[0] = writer_file

-    qpdf.merge(pdf_pages, output_file)
+    qpdf.merge(input_files=pdf_pages, output_file=output_file,
+               min_version=context.get_pdfinfo().min_version)


 def merge_sidecars(
@@ -1044,7 +1096,7 @@ def build_pipeline(options, work_folder, log, context):
    task_select_image_layer.graphviz(
        fillcolor='"#00cc66"', shape='diamond')
    task_select_image_layer.active_if(
-        options.pdf_renderer == 'hocr' or options.pdf_renderer == 'tess4')
+        options.pdf_renderer == 'hocr' or options.pdf_renderer == 'sandwich')

    task_render_hocr_page = main_pipeline.transform(
        task_func=render_hocr_page,
@@ -1074,7 +1126,7 @@ def build_pipeline(options, work_folder, log, context):
                os.path.join(work_folder, r'\1.text.txt')],
        extras=[log, context])
    task_ocr_tesseract_textonly_pdf.graphviz(fillcolor='"#ff69b4"')
-    task_ocr_tesseract_textonly_pdf.active_if(options.pdf_renderer == 'tess4')
+    task_ocr_tesseract_textonly_pdf.active_if(options.pdf_renderer == 'sandwich')
    if tesseract.v4():
        task_ocr_tesseract_textonly_pdf.jobs_limit(2)

@@ -1087,7 +1139,7 @@ def build_pipeline(options, work_folder, log, context):
        output=os.path.join(work_folder, r'\1.rendered.pdf'),
        extras=[log, context])
    task_combine_layers.graphviz(fillcolor='"#00cc66"')
-    task_combine_layers.active_if(options.pdf_renderer == 'hocr' or options.pdf_renderer == 'tess4')
+    task_combine_layers.active_if(options.pdf_renderer == 'hocr' or options.pdf_renderer == 'sandwich')

    # Tesseract OCR+PDF
    task_ocr_tesseract_and_render_pdf = main_pipeline.collate(
@@ -185,9 +185,15 @@ if 'upload' in sys.argv[1:]:

 tests_require = open('test_requirements.txt').read().splitlines()

+
+def readme():
+    with open('README.rst') as f:
+        return f.read()
+
 setup(
    name='ocrmypdf',
    description='OCRmyPDF adds an OCR text layer to scanned PDF files, allowing them to be searched',
+    long_description=readme(),
    url='https://github.com/jbarlow83/OCRmyPDF',
    author='James R. Barlow',
    author_email='jim@purplerock.ca',
@@ -66,6 +66,18 @@ def spoof(**kwargs):
    return env


+@pytest.fixture
+def spoof_tesseract_noop():
+    return spoof(tesseract='tesseract_noop.py')
+
+
+@pytest.fixture
+def spoof_tesseract_cache():
+    if running_in_docker():
+        return os.environ.copy()
+    return spoof(tesseract="tesseract_cache.py")
+
+
@pytest.fixture
 def resources():
    return Path(TESTS_ROOT) / 'resources'
@@ -117,7 +129,8 @@ def run_ocrmypdf(input_file, output_file, *args, env=None):
    if env is None:
        env = os.environ

-    p_args = OCRMYPDF + list(args) + [str(input_file), str(output_file)]
+    p_args = OCRMYPDF + [str(arg) for arg in args] + \
+             [str(input_file), str(output_file)]
    p = Popen(
        p_args, close_fds=True, stdout=PIPE, stderr=PIPE,
        universal_newlines=True, env=env)
@@ -129,7 +142,7 @@ def run_ocrmypdf(input_file, output_file, *args, env=None):

@pytest.helpers.register
 def first_page_dimensions(pdf):
-    from ocrmypdf import pageinfo
-    info = pageinfo.pdf_get_all_pageinfo(str(pdf))
+    from ocrmypdf import pdfinfo
+    info = pdfinfo.PdfInfo(pdf)
    page0 = info[0]
-    return (page0['width_inches'], page0['height_inches'])
+    return (page0.width_inches, page0.height_inches)
@@ -88,14 +88,18 @@ under the terms of the license in LICENSE.rst.
    *   - overlay.pdf
        - @maxandersen
        - PDF file generated by PDFPen pro that triggered content stream parse errors
-    *   - no_conentes.pdf
+    *   - no_contents.pdf
        - @jbarlow83
        - synthetic PDF with a blank page that has no /Contents entry
+    *   - crom.png
+        - @jbarlow83
+        - test for non-dictionary words
+

 Assemblies
 ==========

-These test resources are assemblies from other previously mentioned files, released under the same license terms as their input files.
+These test resources are assemblies or derivatives from other previously mentioned files, released under the same license terms as their input files.

 - cardinal.pdf (four cardinal directions, baked-in rotated copies of LinnSequencer.jpg)
 - ccitt.pdf (LinnSequencer.jpg, converted to CCITT encoding)
@@ -107,6 +111,9 @@ These test resources are assemblies from other previously mentioned files, relea
 - rotated_skew.pdf (a /Rotate'd and skewed document from LinnSequencer.jpg)
 - skew.pdf (from LinnSequencer.jpg, skew simulated by adjusting the transformation matrix)
 - skew-encrypted.pdf (skew.pdf with encryption - access supported by PyPDF2)
+- baiona_gray.png (from baiona.png)
+- poster.pdf (from LinnSequencer.jpg)
+


 .. _`Wikimedia: LinnSequencer`: https://upload.wikimedia.org/wikipedia/en/b/b7/LinnSequencer_hardware_MIDI_sequencer_brochure_page_2_300dpi.jpg
@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
+
 import sys
 import os
 from subprocess import check_call
@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
+
 import sys
 import os

@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
+
 import sys
 import os

@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
+
 import sys
 import os

@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
+
 import sys


@@ -1,10 +1,12 @@
 #!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
+
 import sys


-VERSION_STRING = '''tesseract 3.04.00
- leptonica-1.72
-  libjpeg 8d : libpng 1.6.19 : libtiff 4.0.6 : zlib 1.2.5
+VERSION_STRING = '''tesseract 3.05.01
+ leptonica-1.74.4
+  libjpeg 9b : libpng 1.6.32 : libtiff 4.0.8 : zlib 1.2.8
 SPOOFED: return error claiming image too big
 '''

@@ -18,13 +20,16 @@ def main():
        print(VERSION_STRING, file=sys.stderr)
        sys.exit(0)
    elif sys.argv[1] == '--list-langs':
-        print('List of available languages (1):\neng', file=sys.stderr)
+        print('List of available languages (1):\neng\n', file=sys.stderr)
        sys.exit(0)
-    elif sys.argv[-1] == 'hocr':
+    elif sys.argv[1] == '--print-parameters':
+        print('A parameter list would go here\ntextonly_pdf 0\n', file=sys.stderr)
+        sys.exit(0)
+    elif sys.argv[-2] == 'hocr':
        print("Image too large: (33830, 14959)\n"
              "Error during processing.", file=sys.stderr)
        sys.exit(1)
-    elif sys.argv[-1] == 'pdf':
+    elif sys.argv[-2] == 'pdf':
        print("Image too large: (33830, 14959)\n"
              "Error during processing.", file=sys.stderr)
        sys.exit(1)
@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
+
 import sys
 import os
 import hashlib
@@ -9,18 +11,27 @@ import subprocess
 """Cache output of tesseract to speed up test suite

 The cache is keyed by a hash that includes the tesseract version, some of
-the command line, and the binary dump of the input file. The output file,
-stdout, and stderr are replicated on a cache hit.
+the command line, and the binary dump of the input file, and this file itself.
+ Therefore any updates to this file invalidate cache. Uses SHA-1 because it is
+ fast and defeating a hash collision here is not exactly a priority. :P
+
+The output files, stdout, and stderr are replicated on a cache hit. The output
+files are either a .pdf and .txt or .hocr and .txt.

 Page orientation checks are also cached (-psm 0 stdout)

-Errors and crashes are not cached.
+Errors and crashes are not cached. If the arguments don't match a known
+caching template then real tesseract is called with the same arguments.

 Things not checked:
 -changes to tesseract installation that don't affect --version

+Assumes Tesseract 3.04 or higher.
+
 Will fail on Tesseract 3.02.02 in "hocr" mode because it doesn't produce
-the incorrect file extension.
+the incorrect file extension. Will fail on 3.03 because that has no sidecar
+text support. Will fail to replicate a 3.04 bug if wrong parameter order is
+given.

 """

@@ -35,10 +46,12 @@ def real_tesseract():
    return  # Not reachable

 def main():
-    operation = sys.argv[-1]
+    operation = sys.argv[-2]
    sidecar = False
-    if sys.argv[-2] == 'txt':
+    if sys.argv[-1] == 'txt':
        sidecar = True
+    elif sys.argv[-1] == 'stdout':
+        operation = 'stdout'

    # For anything unexpected operation, defer to real tesseract binary
    # Currently this includes all use of "--tesseract-config"
@@ -72,6 +85,12 @@ def main():
    except ValueError:
        m.update(b'default-lang')

+    try:
+        textonly = sys.argv[sys.argv.index('-c') + 1]
+        m.update(textonly.encode())
+    except ValueError:
+        m.update(b'textonly_pdf=0')
+
    psm_arg = ''
    if '--psm' in sys.argv:
        psm_arg = '--psm'
@@ -1,12 +1,13 @@
 #!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
 import sys
 import os
 import signal


-VERSION_STRING = '''tesseract 3.04.00
- leptonica-1.72
-  libjpeg 8d : libpng 1.6.19 : libtiff 4.0.6 : zlib 1.2.5
+VERSION_STRING = '''tesseract 3.05.01
+ leptonica-1.74.4
+  libjpeg 9b : libpng 1.6.32 : libtiff 4.0.8 : zlib 1.2.8
 SPOOFED: CRASH ON OCR or -psm 0
 '''

@@ -28,10 +29,14 @@ def main():
    elif sys.argv[1] == '--list-langs':
        print('List of available languages (1):\neng', file=sys.stderr)
        sys.exit(0)
-    elif sys.argv[-1] == 'hocr':
+    elif sys.argv[1] == '--print-parameters':
+        print('A parameter list would go here\ntextonly_pdf 0\n',
+              file=sys.stderr)
+        sys.exit(0)
+    elif sys.argv[-2] == 'hocr':
        print("KABOOM! Tesseract failed for some reason", file=sys.stderr)
        sys.exit(128 + signal.SIGSEGV)
-    elif sys.argv[-1] == 'pdf':
+    elif sys.argv[-2] == 'pdf':
        print("KABOOM! Tesseract failed for some reason", file=sys.stderr)
        sys.exit(128 + signal.SIGSEGV)
    elif sys.argv[-1] == 'stdout':
@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
 import sys
 import img2pdf
+import PyPDF2 as pypdf
 from PIL import Image


@@ -16,7 +18,7 @@ In orientation check mode, report the orientation is upright.
 """


-VERSION_STRING = '''tesseract 3.04.00
+VERSION_STRING = '''tesseract 3.05.01
 leptonica-1.72
  libjpeg 8d : libpng 1.6.19 : libtiff 4.0.6 : zlib 1.2.5
 SPOOFED
@@ -52,7 +54,11 @@ def main():
    elif sys.argv[1] == '--list-langs':
        print('List of available languages (1):\neng', file=sys.stderr)
        sys.exit(0)
-    elif sys.argv[-1] == 'hocr':
+    elif sys.argv[1] == '--print-parameters':
+        print("Some parameters", file=sys.stderr)
+        print("textonly_pdf\t1\tSome help text")
+        sys.exit(0)
+    elif sys.argv[-2] == 'hocr':
        inputf = sys.argv[-4]
        output = sys.argv[-3]
        with Image.open(inputf) as im, \
@@ -61,14 +67,28 @@ def main():
            f.write(HOCR_TEMPLATE.format(str(w), str(h)))
        with open(output + '.txt', 'w') as f:
            f.write('')
-    elif sys.argv[-1] == 'pdf':
-        inputf = sys.argv[-4]
-        output = sys.argv[-3]
-        pdf_bytes = img2pdf.convert([inputf], dpi=300)
-        with open(output + '.pdf', 'wb') as f:
-            f.write(pdf_bytes)
-        with open(output + '.txt', 'w') as f:
-            f.write('')
+    elif sys.argv[-2] == 'pdf':
+        if 'textonly_pdf=1' in sys.argv:
+            inputf = sys.argv[-4]
+            output = sys.argv[-3]
+            with Image.open(inputf) as im:
+                dpi = im.info['dpi']
+                imsize = im.size[0] * dpi[0] / 72, im.size[1] * dpi[1] / 72
+
+            pdf_out = pypdf.PdfFileWriter()
+            pdf_out.addBlankPage(imsize[0], imsize[1])
+            with open(output + '.pdf', 'wb') as f:
+                pdf_out.write(f)
+            with open(output + '.txt', 'w') as f:
+                f.write('')
+        else:
+            inputf = sys.argv[-4]
+            output = sys.argv[-3]
+            pdf_bytes = img2pdf.convert([inputf], dpi=300)
+            with open(output + '.pdf', 'wb') as f:
+                f.write(pdf_bytes)
+            with open(output + '.txt', 'w') as f:
+                f.write('')
    elif sys.argv[-1] == 'stdout':
        inputf = sys.argv[-2]
        print("""Orientation: 0
@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# © 2016 James R. Barlow: github.com/jbarlow83
 import sys

 def main():
@@ -4,31 +4,25 @@
 from subprocess import Popen, PIPE, check_output, check_call, DEVNULL
 import os
 import shutil
-from contextlib import suppress
-import sys
 import pytest
-from ocrmypdf.pageinfo import pdf_get_all_pageinfo
+from ocrmypdf.pdfinfo import PdfInfo, Colorspace, Encoding
 import PyPDF2 as pypdf
 from ocrmypdf.exceptions import ExitCode
 from ocrmypdf import leptonica
 from ocrmypdf.pdfa import file_claims_pdfa
-from ocrmypdf.exec import ghostscript
+from ocrmypdf.exec import ghostscript, tesseract
+import logging
+from math import isclose


 check_ocrmypdf = pytest.helpers.check_ocrmypdf
 run_ocrmypdf = pytest.helpers.run_ocrmypdf
 spoof = pytest.helpers.spoof

-@pytest.fixture
-def spoof_tesseract_noop():
-    return spoof(tesseract='tesseract_noop.py')

-
-@pytest.fixture
-def spoof_tesseract_cache():
-    if pytest.helpers.running_in_docker():
-        return os.environ.copy()
-    return spoof(tesseract="tesseract_cache.py")
+RENDERERS = ['hocr', 'tesseract']
+if tesseract.has_textonly_pdf():
+    RENDERERS.append('sandwich')


@pytest.fixture
@@ -78,15 +72,13 @@ def test_deskew(spoof_tesseract_noop, resources, outdir):

    # Now render as an image again and use Leptonica to find the skew angle
    # to confirm that it was deskewed
-    from ocrmypdf.exec.ghostscript import rasterize_pdf
-    import logging
    log = logging.getLogger()

    deskewed_png = outdir / 'deskewed.png'

-    rasterize_pdf(
-        str(deskewed_pdf),
-        str(deskewed_png),
+    ghostscript.rasterize_pdf(
+        deskewed_pdf,
+        deskewed_png,
        xres=150,
        yres=150,
        raster_device='pngmono',
@@ -119,15 +111,13 @@ def test_remove_background(spoof_tesseract_noop, resources, outdir):
        '--image-dpi', '150',
        env=spoof_tesseract_noop)

-    from ocrmypdf.exec.ghostscript import rasterize_pdf
-    import logging
    log = logging.getLogger()

    output_png = outdir / 'remove_bg.png'

-    rasterize_pdf(
-        str(output_pdf),
-        str(output_png),
+    ghostscript.rasterize_pdf(
+        output_pdf,
+        output_png,
        xres=100,
        yres=100,
        raster_device='png16m',
@@ -143,7 +133,7 @@ def test_remove_background(spoof_tesseract_noop, resources, outdir):
@pytest.mark.parametrize(
    "pdf",
    ['palette.pdf', 'cmyk.pdf', 'ccitt.pdf', 'jbig2.pdf', 'lichtenstein.pdf'])
-@pytest.mark.parametrize("renderer", ['hocr', 'tesseract'])
+@pytest.mark.parametrize("renderer", ['auto', 'tesseract'])
@pytest.mark.parametrize("output_type", ['pdf', 'pdfa'])
 def test_exotic_image(spoof_tesseract_cache, pdf, renderer, output_type,
                      resources, outdir):
@@ -225,20 +215,17 @@ def test_high_unicode(spoof_tesseract_noop, resources, no_outpdf):
    assert p.returncode == ExitCode.bad_args, err


-@pytest.mark.parametrize('renderer', [
-    'hocr',
-    'tesseract',
-    ])
+@pytest.mark.parametrize('renderer', RENDERERS)
 def test_oversample(spoof_tesseract_cache, renderer, resources, outpdf):
    oversampled_pdf = check_ocrmypdf(
        resources / 'skew.pdf', outpdf, '--oversample', '350',
        '-f',
        '--pdf-renderer', renderer, env=spoof_tesseract_cache)

-    pdfinfo = pdf_get_all_pageinfo(str(oversampled_pdf))
+    pdfinfo = PdfInfo(oversampled_pdf)

-    print(pdfinfo[0]['xres'])
-    assert abs(pdfinfo[0]['xres'] - 350) < 1
+    print(pdfinfo[0].xres)
+    assert abs(pdfinfo[0].xres - 350) < 1


 def test_repeat_ocr(resources, no_outpdf):
@@ -249,8 +236,8 @@ def test_repeat_ocr(resources, no_outpdf):
 def test_force_ocr(spoof_tesseract_cache, resources, outpdf):
    out = check_ocrmypdf(resources / 'graph_ocred.pdf', outpdf, '-f',
                         env=spoof_tesseract_cache)
-    pdfinfo = pdf_get_all_pageinfo(out)
-    assert pdfinfo[0]['has_text']
+    pdfinfo = PdfInfo(out)
+    assert pdfinfo[0].has_text


 def test_skip_ocr(spoof_tesseract_cache, resources, outpdf):
@@ -271,10 +258,6 @@ def test_argsfile(spoof_tesseract_noop, resources, outdir):
 def check_monochrome_correlation(
        outdir,
        reference_pdf, reference_pageno, test_pdf, test_pageno):
-
-    import ocrmypdf.exec.ghostscript as ghostscript
-    import logging
-
    gslog = logging.getLogger()

    reference_png = outdir / '{}.ref{:04d}.png'.format(
@@ -287,9 +270,7 @@ def check_monochrome_correlation(
            print(png)
            return
        ghostscript.rasterize_pdf(
-            str(pdf),
-            str(png),
-            xres=100, yres=100,
+            pdf, png, xres=100, yres=100,
            raster_device='pngmono', log=gslog, pageno=pageno)

    rasterize(reference_pdf, reference_pageno, reference_png)
@@ -322,10 +303,7 @@ def test_monochrome_correlation(resources, outdir):
    assert corr > 0.90


-@pytest.mark.parametrize('renderer', [
-    'hocr',
-    'tesseract',
-    ])
+@pytest.mark.parametrize('renderer', RENDERERS)
 def test_autorotate(spoof_tesseract_cache, renderer, resources, outdir):
    # cardinal.pdf contains four copies of an image rotated in each cardinal
    # direction - these ones are "burned in" not tagged with /Rotate
@@ -360,25 +338,22 @@ def test_autorotate_threshold(
    assert eval(correlation_test)


-@pytest.mark.parametrize('renderer', [
-    'hocr',
-    'tesseract',
-    ])
+@pytest.mark.parametrize('renderer',RENDERERS)
 def test_ocr_timeout(renderer, resources, outpdf):
    out = check_ocrmypdf(resources / 'skew.pdf', outpdf,
                         '--tesseract-timeout', '1.0')
-    pdfinfo = pdf_get_all_pageinfo(str(out))
-    assert not pdfinfo[0]['has_text']
+    pdfinfo = PdfInfo(out)
+    assert not pdfinfo[0].has_text


 def test_skip_big(spoof_tesseract_cache, resources, outpdf):
    out = check_ocrmypdf(resources / 'enormous.pdf', outpdf,
                         '--skip-big', '10', env=spoof_tesseract_cache)
-    pdfinfo = pdf_get_all_pageinfo(str(out))
-    assert not pdfinfo[0]['has_text']
+    pdfinfo = PdfInfo(out)
+    assert not pdfinfo[0].has_text


-@pytest.mark.parametrize('renderer', ['hocr', 'tesseract'])
+@pytest.mark.parametrize('renderer', RENDERERS)
@pytest.mark.parametrize('output_type', ['pdf', 'pdfa'])
 def test_maximum_options(spoof_tesseract_cache, renderer, output_type,
                         resources, outpdf):
@@ -429,9 +404,13 @@ def test_force_ocr_on_pdf_with_no_images(spoof_tesseract_crash, resources,
@pytest.mark.skipif(
    pytest.helpers.is_macos() and pytest.helpers.running_in_travis(),
    reason="takes too long to install language packs in Travis macOS homebrew")
-def test_french(spoof_tesseract_cache, resources, outpdf):
+def test_french(spoof_tesseract_cache, resources, outdir):
+    # Produce a sidecar too - implicit test that system locale is set up
+    # properly
+    sidecar = outdir / 'francais.txt'
    p, out, err = run_ocrmypdf(
-        resources / 'francais.pdf', outpdf, '-l', 'fra',
+        resources / 'francais.pdf', outdir / 'francais.pdf', '-l', 'fra',
+        '--sidecar', sidecar,
        env=spoof_tesseract_cache)
    print(os.environ)
    assert p.returncode == ExitCode.ok, \
@@ -441,7 +420,7 @@ def test_french(spoof_tesseract_cache, resources, outpdf):
 def test_klingon(resources, outpdf):
    p, out, err = run_ocrmypdf(
        resources / 'francais.pdf', outpdf, '-l', 'klz')
-    assert p.returncode == ExitCode.bad_args
+    assert p.returncode == ExitCode.missing_dependency


 def test_missing_docinfo(spoof_tesseract_noop, resources, outpdf):
@@ -508,10 +487,7 @@ def test_pagesegmode(renderer, spoof_tesseract_cache, resources, outpdf):
        '--pdf-renderer', renderer, env=spoof_tesseract_cache)


-@pytest.mark.parametrize('renderer', [
-    'hocr',
-    'tesseract',
-    ])
+@pytest.mark.parametrize('renderer', RENDERERS)
 def test_tesseract_crash(renderer, spoof_tesseract_crash,
                         resources, no_outpdf):
    p, out, err = run_ocrmypdf(
@@ -534,10 +510,7 @@ def test_tesseract_crash_autorotate(spoof_tesseract_crash,
    print(err)


-@pytest.mark.parametrize('renderer', [
-    'hocr',
-    'tesseract',
-    ])
+@pytest.mark.parametrize('renderer', RENDERERS)
 def test_tesseract_image_too_big(renderer, spoof_tesseract_big_image_error,
                                 resources, outpdf):
    check_ocrmypdf(
@@ -571,31 +544,28 @@ def test_algo4(resources, no_outpdf):
 def test_non_square_resolution(renderer, spoof_tesseract_cache,
                               resources, outpdf):
    # Confirm input image is non-square resolution
-    in_pageinfo = pdf_get_all_pageinfo(str(resources / 'aspect.pdf'))
-    assert in_pageinfo[0]['xres'] != in_pageinfo[0]['yres']
+    in_pageinfo = PdfInfo(resources / 'aspect.pdf')
+    assert in_pageinfo[0].xres != in_pageinfo[0].yres

    check_ocrmypdf(
        resources / 'aspect.pdf', outpdf,
        '--pdf-renderer', renderer, env=spoof_tesseract_cache)

-    out_pageinfo = pdf_get_all_pageinfo(str(outpdf))
+    out_pageinfo = PdfInfo(outpdf)

    # Confirm resolution was kept the same
-    assert in_pageinfo[0]['xres'] == out_pageinfo[0]['xres']
-    assert in_pageinfo[0]['yres'] == out_pageinfo[0]['yres']
+    assert in_pageinfo[0].xres == out_pageinfo[0].xres
+    assert in_pageinfo[0].yres == out_pageinfo[0].yres


-@pytest.mark.parametrize('renderer', [
-    'hocr',
-    'tesseract'
-    ])
+@pytest.mark.parametrize('renderer', RENDERERS)
 def test_convert_to_square_resolution(renderer, spoof_tesseract_cache,
                                      resources, outpdf):
    from math import isclose

    # Confirm input image is non-square resolution
-    in_pageinfo = pdf_get_all_pageinfo(str(resources / 'aspect.pdf'))
-    assert in_pageinfo[0]['xres'] != in_pageinfo[0]['yres']
+    in_pageinfo = PdfInfo(resources / 'aspect.pdf')
+    assert in_pageinfo[0].xres != in_pageinfo[0].yres

    # --force-ocr requires means forced conversion to square resolution
    check_ocrmypdf(
@@ -603,25 +573,25 @@ def test_convert_to_square_resolution(renderer, spoof_tesseract_cache,
        '--force-ocr',
        '--pdf-renderer', renderer, env=spoof_tesseract_cache)

-    out_pageinfo = pdf_get_all_pageinfo(str(outpdf))
+    out_pageinfo = PdfInfo(outpdf)

    in_p0, out_p0 = in_pageinfo[0], out_pageinfo[0]

    # Resolution show now be equal
-    assert out_p0['xres'] == out_p0['yres']
+    assert out_p0.xres == out_p0.yres

    # Page size should match input page size
-    assert isclose(in_p0['width_inches'],
-                   out_p0['width_inches'])
-    assert isclose(in_p0['height_inches'],
-                   out_p0['height_inches'])
+    assert isclose(in_p0.width_inches,
+                   out_p0.width_inches)
+    assert isclose(in_p0.height_inches,
+                   out_p0.height_inches)

    # Because we rasterized the page to produce a new image, it should occupy
    # the entire page
-    out_im_w = out_p0['images'][0]['width'] / out_p0['images'][0]['dpi_w']
-    out_im_h = out_p0['images'][0]['height'] / out_p0['images'][0]['dpi_h']
-    assert isclose(out_p0['width_inches'], out_im_w)
-    assert isclose(out_p0['height_inches'], out_im_h)
+    out_im_w = out_p0.images[0]['width'] / out_p0.images[0]['dpi_w']
+    out_im_h = out_p0.images[0]['height'] / out_p0.images[0]['dpi_h']
+    assert isclose(out_p0.width_inches, out_im_w)
+    assert isclose(out_p0.height_inches, out_im_h)


 def test_image_to_pdf(spoof_tesseract_noop, resources, outpdf):
@@ -637,8 +607,8 @@ def test_jbig2_passthrough(spoof_tesseract_cache, resources, outpdf):
        '--pdf-renderer', 'hocr',
        env=spoof_tesseract_cache)

-    out_pageinfo = pdf_get_all_pageinfo(str(out))
-    assert out_pageinfo[0]['images'][0]['enc'] == 'jbig2'
+    out_pageinfo = PdfInfo(out)
+    assert out_pageinfo[0].images[0].enc == Encoding.jbig2


 def test_stdin(spoof_tesseract_noop, ocrmypdf_exec, resources, outpdf):
@@ -711,27 +681,27 @@ def test_rotated_skew_timeout(resources, outpdf):
    """

    input_file = str(resources / 'rotated_skew.pdf')
-    in_pageinfo = pdf_get_all_pageinfo(input_file)[0]
+    in_pageinfo = PdfInfo(input_file)[0]

-    assert in_pageinfo['height_pixels'] < in_pageinfo['width_pixels'], \
+    assert in_pageinfo.height_pixels < in_pageinfo.width_pixels, \
        "Expected the input page to be landscape"
-    assert in_pageinfo['rotate'] == 90, "Expected a rotated page"
+    assert in_pageinfo.rotation == 90, "Expected a rotated page"

    out = check_ocrmypdf(
        input_file, outpdf,
        '--pdf-renderer', 'hocr',
        '--deskew', '--tesseract-timeout', '0')

-    out_pageinfo = pdf_get_all_pageinfo(str(out))[0]
+    out_pageinfo = PdfInfo(out)[0]

-    assert out_pageinfo['height_pixels'] > out_pageinfo['width_pixels'], \
+    assert out_pageinfo.height_pixels > out_pageinfo.width_pixels, \
        "Expected the output page to be portrait"

-    assert out_pageinfo['rotate'] == 0, \
+    assert out_pageinfo.rotation == 0, \
        "Expected no page rotation for output"

-    assert in_pageinfo['width_pixels'] == out_pageinfo['height_pixels'] and \
-        in_pageinfo['height_pixels'] == out_pageinfo['width_pixels'], \
+    assert in_pageinfo.width_pixels == out_pageinfo.height_pixels and \
+        in_pageinfo.height_pixels == out_pageinfo.width_pixels, \
        "Expected page rotation to be baked in"


@@ -752,11 +722,11 @@ def test_very_high_dpi(spoof_tesseract_cache, resources, outpdf):
    "Checks for a Decimal quantize error with high DPI, etc"
    check_ocrmypdf(resources / '2400dpi.pdf', outpdf,
                   env=spoof_tesseract_cache)
-    pdfinfo = pdf_get_all_pageinfo(outpdf)
+    pdfinfo = PdfInfo(outpdf)

-    image = pdfinfo[0]['images'][0]
-    assert image['dpi_w'] == image['dpi_h']
-    assert image['dpi_w'] == 2400
+    image = pdfinfo[0].images[0]
+    assert isclose(image.xres, image.yres)
+    assert isclose(image.xres, 2400)


 def test_overlay(spoof_tesseract_noop, resources, outpdf):
@@ -789,28 +759,22 @@ language_model_penalty_non_freq_dict_word 0

    check_ocrmypdf(
        resources / 'ccitt.pdf', outdir / 'out.pdf',
-        '--tesseract-config', str(cfg_file))
+        '--tesseract-config', cfg_file)


-@pytest.mark.parametrize('renderer', [
-    'hocr',
-    'tesseract',
-    ])
+@pytest.mark.parametrize('renderer', RENDERERS)
 def test_tesseract_config_notfound(renderer, resources, outdir):
    cfg_file = outdir / 'nofile.cfg'

    p, out, err = run_ocrmypdf(
        resources / 'ccitt.pdf', outdir / 'out.pdf',
        '--pdf-renderer', renderer,
-        '--tesseract-config', str(cfg_file))
+        '--tesseract-config', cfg_file)
    assert "Can't open" in err, "No error message about missing config file"
    assert p.returncode == ExitCode.ok


-@pytest.mark.parametrize('renderer', [
-    'hocr',
-    'tesseract',
-    ])
+@pytest.mark.parametrize('renderer', RENDERERS)
 def test_tesseract_config_invalid(renderer, resources, outdir):
    cfg_file = outdir / 'test.cfg'
    with cfg_file.open('w') as f:
@@ -821,21 +785,50 @@ THIS FILE IS INVALID
    p, out, err = run_ocrmypdf(
        resources / 'ccitt.pdf', outdir / 'out.pdf',
        '--pdf-renderer', renderer,
-        '--tesseract-config', str(cfg_file))
+        '--tesseract-config', cfg_file)
    assert "parameter not found" in err, "No error message"
    assert p.returncode == ExitCode.invalid_config


+def test_user_words(resources, outdir):
+    word_list = outdir / 'wordlist.txt'
+    sidecar_before = outdir / 'sidecar_before.txt'
+    sidecar_after = outdir / 'sidecar_after.txt'
+
+    # Don't know how to make this test pass on various versions and platforms
+    # so weaken to merely testing that the argument is accepted
+    consistent = False
+
+    if consistent:
+        check_ocrmypdf(
+            resources / 'crom.png', outdir / 'out.pdf',
+            '--image-dpi', 150,
+            '--sidecar', sidecar_before
+        )
+
+        assert 'cromulent' not in sidecar_before.open().read()
+
+    with word_list.open('w') as f:
+        f.write('cromulent\n')  # a perfectly cromulent word
+
+    check_ocrmypdf(
+        resources / 'crom.png', outdir / 'out.pdf',
+        '--image-dpi', 150,
+        '--sidecar', sidecar_after,
+        '--user-words', word_list
+    )
+
+    if consistent:
+        assert 'cromulent' in sidecar_after.open().read()
+
+
 def test_form_xobject(spoof_tesseract_noop, resources, outpdf):
    check_ocrmypdf(resources / 'formxobject.pdf', outpdf,
                   '--force-ocr',
                   env=spoof_tesseract_noop)


-@pytest.mark.parametrize('renderer', [
-    'hocr',
-    'tesseract',
-])
+@pytest.mark.parametrize('renderer', RENDERERS)
 def test_pagesize_consistency(renderer, resources, outpdf):
    from math import isclose

@@ -909,21 +902,21 @@ def test_compression_preserved(spoof_tesseract_noop, ocrmypdf_exec,

        assert p.returncode == ExitCode.ok

-    pdfinfo = pdf_get_all_pageinfo(output_file)
+    pdfinfo = PdfInfo(output_file)

-    pdfimage = pdfinfo[0]['images'][0]
+    pdfimage = pdfinfo[0].images[0]

    if input_file.endswith('.png'):
-        assert pdfimage['enc'] != 'jpeg', \
+        assert pdfimage.enc != Encoding.jpeg, \
            "Lossless compression changed to lossy!"
    elif input_file.endswith('.jpg'):
-        assert pdfimage['enc'] == 'jpeg', \
+        assert pdfimage.enc == Encoding.jpeg, \
            "Lossy compression changed to lossless!"
    if im.mode.startswith('RGB') or im.mode.startswith('BGR'):
-        assert pdfimage['color'] == 'rgb', \
+        assert pdfimage.color == Colorspace.rgb, \
            "Colorspace changed"
    elif im.mode.startswith('L'):
-        assert pdfimage['color'] == 'gray', \
+        assert pdfimage.color == Colorspace.gray, \
            "Colorspace changed"


@@ -954,20 +947,20 @@ def test_compression_changed(spoof_tesseract_noop, ocrmypdf_exec,

        assert p.returncode == ExitCode.ok

-    pdfinfo = pdf_get_all_pageinfo(output_file)
+    pdfinfo = PdfInfo(output_file)

-    pdfimage = pdfinfo[0]['images'][0]
+    pdfimage = pdfinfo[0].images[0]

-    if compression == 'jpeg':
-        assert pdfimage['enc'] == 'jpeg'
+    if compression == "jpeg":
+        assert pdfimage.enc == Encoding.jpeg
    elif compression == 'lossless':
-        assert pdfimage['enc'] == 'image'
+        assert pdfimage.enc not in (Encoding.jpeg, Encoding.jpeg2000)

    if im.mode.startswith('RGB') or im.mode.startswith('BGR'):
-        assert pdfimage['color'] == 'rgb', \
+        assert pdfimage.color == Colorspace.rgb, \
            "Colorspace changed"
    elif im.mode.startswith('L'):
-        assert pdfimage['color'] == 'gray', \
+        assert pdfimage.color == Colorspace.gray, \
            "Colorspace changed"


@@ -979,7 +972,7 @@ def test_sidecar_pagecount(spoof_tesseract_cache, resources, outpdf):
        '--sidecar', sidecar,
        env=spoof_tesseract_cache)

-    pdfinfo = pdf_get_all_pageinfo(str(resources / 'multipage.pdf'))
+    pdfinfo = PdfInfo(resources / 'multipage.pdf')
    num_pages = len(pdfinfo)

    with open(sidecar, 'r') as f:
@@ -0,0 +1,47 @@
+
+from ocrmypdf.pdfinfo import PdfInfo, PageInfo
+from ocrmypdf.pipeline import JobContext, JobContextManager
+from multiprocessing import Process
+from multiprocessing.managers import BaseProxy
+
+
+def test_jobcontext_proxy(resources):
+    # Prove that managers are set up correctly to share state among processes
+    manager = JobContextManager()
+    manager.register('JobContext', JobContext)
+
+    # Start the manager in a child process (or maybe thread)
+    manager.start()
+
+    # Tell the manager process to retrieve pdf info
+    context = manager.JobContext()
+    context.generate_pdfinfo(resources / 'graph.pdf')
+
+    # Get a copy of that information for this process
+    pdfinfo = context.get_pdfinfo()
+    assert len(pdfinfo) == 1
+    assert pdfinfo[0].rotation == 0
+
+    # Update information and send back to manager
+    pdfinfo[0].rotation = 90
+    context.set_pdfinfo(pdfinfo)
+
+    # Retrieve again, ensure it stayed changed
+    pdfinfo2 = context.get_pdfinfo()
+    assert pdfinfo2[0].rotation == 90
+
+    # Start a new process which gets its own proxy object
+    def client(context):
+        assert isinstance(context, BaseProxy)
+        pdfinfo = context.get_pdfinfo()
+        page = pdfinfo[0]
+        assert page.rotation == 90
+        page.rotation += 90
+        context.set_pdfinfo(pdfinfo)
+
+    p = Process(target=client, args=(context,))
+    p.start()
+    p.join()
+    assert p.exitcode == 0, "Child process failed"
+
+    assert context.get_pdfinfo()[0].rotation == 180
@@ -1,10 +1,12 @@
 #!/usr/bin/env python3
 # © 2015 James R. Barlow: github.com/jbarlow83

-from ocrmypdf import pageinfo
+from ocrmypdf import pdfinfo
 from reportlab.pdfgen.canvas import Canvas
 from PIL import Image
 from tempfile import NamedTemporaryFile
+from math import isclose
+from ocrmypdf.pdfinfo import Colorspace, Encoding
 from contextlib import suppress
 import os
 import shutil
@@ -26,13 +28,13 @@ def test_single_page_text(outdir):
    pdf.showPage()
    pdf.save()

-    pdfinfo = pageinfo.pdf_get_all_pageinfo(str(filename))
+    info = pdfinfo.PdfInfo(filename)

-    assert len(pdfinfo) == 1
-    page = pdfinfo[0]
+    assert len(info) == 1
+    page = info[0]

-    assert page['has_text']
-    assert len(page['images']) == 0
+    assert page.has_text
+    assert len(page.images) == 0


 def test_single_page_image(outdir):
@@ -53,21 +55,21 @@ def test_single_page_image(outdir):
            layout_fun=layout_fun)
    filename.write_bytes(pdf_bytes)

-    pdfinfo = pageinfo.pdf_get_all_pageinfo(str(filename))
+    info = pdfinfo.PdfInfo(filename)

-    assert len(pdfinfo) == 1
-    page = pdfinfo[0]
+    assert len(info) == 1
+    page = info[0]

-    assert not page['has_text']
-    assert len(page['images']) == 1
+    assert not page.has_text
+    assert len(page.images) == 1

-    pdfimage = page['images'][0]
-    assert pdfimage['width'] == 8
-    assert pdfimage['color'] == 'gray'
+    pdfimage = page.images[0]
+    assert pdfimage.width == 8
+    assert pdfimage.color == Colorspace.gray

    # DPI in a 1"x1" is the image width
-    assert abs(pdfimage['dpi_w'] - 8) < 1e-5
-    assert abs(pdfimage['dpi_h'] - 8) < 1e-5
+    assert isclose(pdfimage.xres, 8)
+    assert isclose(pdfimage.yres, 8)


 def test_single_page_inline_image(outdir):
@@ -83,35 +85,41 @@ def test_single_page_inline_image(outdir):
        pdf.showPage()
        pdf.save()

-    pdfinfo = pageinfo.pdf_get_all_pageinfo(str(filename))
-    print(pdfinfo)
-    pdfimage = pdfinfo[0]['images'][0]
-    assert (pdfimage['dpi_w'] - 8) < 1e-5
-    assert pdfimage['color'] != '-'
-    assert pdfimage['width'] == 8
+    pdf = pdfinfo.PdfInfo(filename)
+    print(pdf)
+    pdfimage = pdf[0].images[0]
+    assert isclose(pdfimage.xres, 8)
+    assert pdfimage.color == Colorspace.rgb  # reportlab produces color image
+    assert pdfimage.width == 8


 def test_jpeg(resources, outdir):
    filename = resources / 'c02-22.pdf'

-    pdfinfo = pageinfo.pdf_get_all_pageinfo(str(filename))
+    pdf = pdfinfo.PdfInfo(filename)

-    pdfimage = pdfinfo[0]['images'][0]
-    assert pdfimage['enc'] == 'jpeg'
-    assert (pdfimage['dpi_w'] - 150) < 1e-5
+    pdfimage = pdf[0].images[0]
+    assert pdfimage.enc == Encoding.jpeg
+    assert isclose(pdfimage.xres, 150)


 def test_form_xobject(resources):
    filename = resources / 'formxobject.pdf'

-    pdfinfo = pageinfo.pdf_get_all_pageinfo(str(filename))
-    pdfimage = pdfinfo[0]['images'][0]
-    assert pdfimage['width'] == 50
+    pdf = pdfinfo.PdfInfo(filename)
+    pdfimage = pdf[0].images[0]
+    assert pdfimage.width == 50


 def test_no_contents(resources):
    filename = resources / 'no_contents.pdf'

-    pdfinfo = pageinfo.pdf_get_all_pageinfo(str(filename))
-    assert len(pdfinfo[0]['images']) == 0
-    assert pdfinfo[0]['has_text'] == False
+    pdf = pdfinfo.PdfInfo(filename)
+    assert len(pdf[0].images) == 0
+    assert pdf[0].has_text == False
+
+
+def test_oversized_page(resources):
+    pdf = pdfinfo.PdfInfo(resources / 'poster.pdf')
+    image = pdf[0].images[0]
+    assert image.width * image.xres > 200, "this is supposed to be oversized"
@@ -11,14 +11,26 @@ pytestmark = pytest.mark.skipif(tesseract.v4(),
                                reason="tesseract 3.x required")


-def test_textonly_pdf_on_tess3(resources, no_outpdf):
+@pytest.mark.skipif(tesseract.has_textonly_pdf(),
+                    reason="check that missing dep is reported on old tess3")
+def test_textonly_pdf_on_older_tess3(resources, no_outpdf):
    p, _, _ = pytest.helpers.run_ocrmypdf(
        resources / 'linn.pdf',
-        no_outpdf, '--pdf-renderer', 'tess4')
+        no_outpdf, '--pdf-renderer', 'sandwich')

    assert p.returncode == ExitCode.missing_dependency


+@pytest.mark.skipif(not tesseract.has_textonly_pdf(),
+                    reason="check that feature is exercised on new test3")
+def test_textonly_pdf_on_newer_tess3(resources, no_outpdf):
+    p, _, _ = pytest.helpers.run_ocrmypdf(
+        resources / 'linn.pdf',
+        no_outpdf, '--pdf-renderer', 'sandwich')
+
+    assert p.returncode == ExitCode.ok
+
+
 def test_oem_on_tess3(resources, no_outpdf):
    p, _, err = pytest.helpers.run_ocrmypdf(
        resources / 'aspect.pdf',
@@ -4,10 +4,11 @@
 import pytest
 from ocrmypdf.exceptions import ExitCode
 from ocrmypdf.exec import tesseract
-from ocrmypdf import pageinfo
+from ocrmypdf import pdfinfo
 import sys
 import os
 import PyPDF2 as pypdf
+from contextlib import contextmanager


 spoof = pytest.helpers.spoof
@@ -32,14 +33,25 @@ def ensure_tess4():
    raise EnvironmentError("Can't find Tesseract 4")


+@contextmanager
+def modified_os_environ(env):
+    old_env = os.environ.copy()
+    os.environ = env
+    yield
+    os.environ = old_env
+
+
 def tess4_available():
    """Check if a tesseract 4 binary is available, even if it's not the
    official "tesseract" on PATH

    """
    try:
-        ensure_tess4()
-        return True
+        # ensure_tess4 locates the tess4 binary we are going to check
+        env = ensure_tess4()
+        with modified_os_environ(env):
+            # Now jump into this environment and make sure it really is Tess4
+            return tesseract.v4() and tesseract.has_textonly_pdf()
    except EnvironmentError:
        pass

@@ -63,7 +75,6 @@ def test_textonly_pdf(ensure_tess4, resources, outdir):
        env=ensure_tess4)


-@pytest.mark.skipif(sys.version_info < (3, 5), reason="needs math.isclose")
 def test_pagesize_consistency_tess4(ensure_tess4, resources, outpdf):
    from math import isclose

@@ -96,14 +107,14 @@ def test_skip_pages_does_not_replicate(
        env=ensure_tess4
    )

-    info_in = pageinfo.pdf_get_all_pageinfo(str(infile))
+    info_in = pdfinfo.PdfInfo(infile)

-    info = pageinfo.pdf_get_all_pageinfo(str(outpdf))
+    info = pdfinfo.PdfInfo(outpdf)
    for page in info:
-        assert len(page['images']) == 1, "skipped page was replicated"
+        assert len(page.images) == 1, "skipped page was replicated"

    for n in range(len(info_in)):
-        assert info[n]['width_inches'] == info_in[n]['width_inches']
+        assert info[n].width_inches == info_in[n].width_inches


 def test_content_preservation(ensure_tess4, resources, outpdf):
@@ -115,6 +126,6 @@ def test_content_preservation(ensure_tess4, resources, outpdf):
        env=ensure_tess4
    )

-    info = pageinfo.pdf_get_all_pageinfo(str(outpdf))
+    info = pdfinfo.PdfInfo(outpdf)
    page = info[0]
-    assert len(page['images']) > 1, "masked were rasterized"
+    assert len(page.images) > 1, "masks were rasterized"
@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# © 2017 James R. Barlow: github.com/jbarlow83
+
+from subprocess import Popen, PIPE, check_output, check_call, DEVNULL
+import os
+import shutil
+import pytest
+from ocrmypdf.pdfinfo import PdfInfo, Colorspace, Encoding
+import PyPDF2 as pypdf
+from ocrmypdf.exceptions import ExitCode
+from ocrmypdf import leptonica
+from ocrmypdf.pdfa import file_claims_pdfa
+from ocrmypdf.exec import ghostscript
+import logging
+from math import isclose
+
+
+check_ocrmypdf = pytest.helpers.check_ocrmypdf
+run_ocrmypdf = pytest.helpers.run_ocrmypdf
+spoof = pytest.helpers.spoof
+
+
+@pytest.fixture
+def poster(resources):
+    return resources / 'poster.pdf'
+
+
+def test_userunit_ghostscript_fails(poster, no_outpdf):
+    p, out, err = run_ocrmypdf(poster, no_outpdf, '--output-type=pdfa')
+    assert p.returncode == ExitCode.input_file
+
+
+def test_userunit_qpdf_passes(spoof_tesseract_cache, poster, outpdf):
+    before = PdfInfo(poster)
+    check_ocrmypdf(poster, outpdf, '--output-type=pdf',
+                   env=spoof_tesseract_cache)
+
+    after = PdfInfo(outpdf)
+    assert isclose(before[0].width_inches, after[0].width_inches)
+
+
+def test_rotate_interaction(spoof_tesseract_cache, poster, outpdf):
+    check_ocrmypdf(poster, outpdf, '--output-type=pdf',
+                   '--rotate-pages',
+                   env=spoof_tesseract_cache)
Author	SHA1	Message	Date
James R. Barlow	6af7d61ee5	Fix CI failure due to spoofers not being updated to Tesseract 3.05 strings	2017-09-01 16:17:26 -07:00
James R. Barlow	bafd08391d	Update release notes	2017-09-01 12:50:45 -07:00
James R. Barlow	82ebd8ef1a	Fix missing error message about trying to use sandwich on old tesseract	2017-09-01 12:50:36 -07:00
James R. Barlow	4ed1aa4d23	Release notes: fix indentation	2017-09-01 12:47:22 -07:00
James R. Barlow	d04e43d46d	Update copyright info for test files [ci skip]	2017-09-01 01:00:32 -07:00
James R. Barlow	952f0cca15	Dockerfiles: set LANG=C.UTF-8 Issue #184 to avoid issue with printing UTF-8 text to sidecar	2017-08-30 13:25:54 -07:00
James R. Barlow	f6a4d8f1f8	Fix Ubuntu 14.04 install instructions to account for dropping Py3.4 support [ci skip]	2017-08-27 13:53:36 -07:00
James R. Barlow	b3097a2384	Fix broken test case related to language packs	2017-08-24 13:01:02 -07:00
James R. Barlow	6d9ddbe98b	v5.3.1 notes	2017-08-24 01:09:19 -07:00
James R. Barlow	9bb42c0229	Wrong error type used for missing language	2017-08-24 01:07:23 -07:00
James R. Barlow	bd7226b27a	Merge branch 'master' of github.com:jbarlow83/OCRmyPDF	2017-08-23 23:30:19 -07:00
James R. Barlow	5b413e3873	Cookbook: add "don't OCR" examples	2017-08-23 23:29:41 -07:00
James R. Barlow	be5831a629	Offer the readme as a long description for new PyPI	2017-08-23 23:29:21 -07:00
jbarlow83andGitHub	084d2bf8e2	More badges	2017-08-23 23:19:29 -07:00
James R. Barlow	da79e6bac7	macos: Skip brew audit because it seems to crash ruby on travis	2017-07-27 16:00:41 -07:00
James R. Barlow	c4831ac00c	v5.3 release notes	2017-07-27 00:11:12 -07:00
James R. Barlow	93a954ef9f	Fix missing import for Py3.5	2017-07-26 23:40:01 -07:00
James R. Barlow	f7ce8f44e9	Weaken the --user-words test so it will pass on Travis	2017-07-26 21:03:51 -07:00
James R. Barlow	0b012697e5	Whitelist the Latin-1 languages that work with HOCR Omitted French because the rare 'oe' and 'ÿ' glyphs are not in Latin-1. Basically steer people away from HOCR renderer but avoid a potential disruptive behavior change.	2017-07-26 21:03:18 -07:00
James R. Barlow	58e357c992	Report location of attempted output_file that fails to write	2017-07-22 17:49:56 -07:00
James R. Barlow	71fbad83ad	Fix py3.5 test	2017-07-21 17:01:06 -07:00
James R. Barlow	52483072dc	Add a differential test that checks tesseract uses supplied word list	2017-07-21 16:40:20 -07:00
James R. Barlow	7f0b8621f3	Tests: accept rich path objects without having to str() everything	2017-07-21 16:39:22 -07:00
James R. Barlow	cd8db60b06	Crash test all renderers, not just two	2017-07-21 14:10:02 -07:00
James R. Barlow	1aa34f5d2e	Make some interfaces accepting of both str-paths and Path objects	2017-07-21 13:28:30 -07:00
James R. Barlow	dfa1d88ce9	Fix missing user_words/user_patterns from textonly_pdf case	2017-07-20 17:14:04 -07:00
James R. Barlow	dd38519f07	Merge branch 'feature/user-words' into develop # Conflicts: # ocrmypdf/exec/tesseract.py	2017-07-20 16:25:20 -07:00
James R. Barlow	098f5d4f0b	docs: remove deprecated example of pdftotext	2017-07-20 16:20:17 -07:00
James R. Barlow	ffc685d536	docs: envvar markup	2017-07-20 16:19:57 -07:00
James R. Barlow	cd1a99a0de	Refactor int(os.path.basename(s)[0:6]) -> page_number(s)	2017-06-26 13:29:40 -07:00
James R. Barlow	48e3b267fc	Accept PDFs with whitespace ahead of %PDF marker Noticed in @aagahi 's fork	2017-06-26 13:17:47 -07:00
James R. Barlow	3a7c3417bb	Don’t check tags and branch at the same time as Travis doesn’t get this Travis is weird	2017-06-13 13:14:34 -07:00
James R. Barlow	d792ef7222	Give the ‘auto’ renderer setting more test covfefe	2017-06-13 13:13:58 -07:00
James R. Barlow	2c24f67deb	Rename “tess4” renderer to “sandwich” and make it default in Tess 3.05.01 Tesseract 3.05.01 backported the textonly_pdf=1 which allows the use of this superior PDF renderer prior to 4.00 alpha. This means that the tess4 name is no longer accurate, so call it a sandwich because of its merge-preserve characteristic. Preserve the tess4 name. Fix the documentation and tests to reflect this. Make it the default, because it’s better. It does not have the issues the “tesseract” renderer does prior to Tess 3.05.00 with rendering PDFs that Ghostscript corrupts, and it produces better output without re-rastering. Deprecate some old stuff to avoid the test suite growing obscenely large.	2017-06-13 13:09:12 -07:00
James R. Barlow	9e75e28d0c	Homebrew needs x11 to compile Pillow	2017-06-13 11:03:26 -07:00
James R. Barlow	3232643809	Support “textonly PDF” renderer in Tesseract 3.05.01	2017-06-13 10:18:08 -07:00
James R. Barlow	f7ee9e90ce	Document what is meant by the ocrmypdf “API”	2017-06-13 10:15:11 -07:00
James R. Barlow	47298be132	Remove Python <3.5 test	2017-06-13 10:14:28 -07:00
James R. Barlow	a88fa83515	Travis: fix deploy conditions for homebrew autobrew	2017-05-31 02:29:32 -07:00
James R. Barlow	12bfe20385	v5.1 release notes	2017-05-29 14:36:50 -07:00
James R. Barlow	3d2f6f0772	Fix tess4 test using old-style pageinfo API	2017-05-29 13:51:21 -07:00
James R. Barlow	1cb607f64b	Merge UserUnit	2017-05-29 13:22:55 -07:00
James R. Barlow	d3c54fbbde	For —rotate-pages, rasterize preview at half DPI instead of 200 DPI Ensures that time is not wasted on previews at higher resolution than the input as was sometimes the case	2017-05-29 13:01:18 -07:00
James R. Barlow	28341b755f	Refactor common test fixtures	2017-05-29 12:47:55 -07:00
James R. Barlow	4b5cd420e1	Add new test file	2017-05-29 12:16:08 -07:00
James R. Barlow	1d57bcc99e	Fix Ghostscript rasterizing of UserUnit pages and related sizing issues	2017-05-29 12:14:10 -07:00
James R. Barlow	facdd13879	Ghostscript: refactor image output resizing	2017-05-29 11:42:27 -07:00
James R. Barlow	6e891f91d3	ghostscript, qpdf: Restore API backward compatibility	2017-05-29 11:13:06 -07:00
James R. Barlow	9b50ede977	Partially solve ghostscript rasterize_pdf producing wrong file size Kludge. Assumes JPEG for now. Messy.	2017-05-25 01:17:43 -07:00
James R. Barlow	82cf010333	Error out if trying to produce PDF/A >200” due to Ghostscript limitation	2017-05-25 00:07:29 -07:00
James R. Barlow	6ff6c8614f	—output-type=pdf now outputs /UserUnit PDFs at the correct size This currently distorts the output size because Tesseract assumes it knows the DPI better than we do. Does not work for Ghostscript, because it emerges that Ghostscript honors /UserUnit for rasterizing but not in pdfwrite (resolve/wontfix). https://bugs.ghostscript.com/show_bug.cgi?id=690781 Ghostscript’s output would need to be patched in a PDF/A safe way for this to work. Temporary route may be to block Ghostscript if /UserUnit.	2017-05-24 23:26:07 -07:00
James R. Barlow	eb1cd38f6c	Add an open helper that is compatible with pathlib	2017-05-24 16:19:15 -07:00
James R. Barlow	148b632b4f	Prove multiprocessing works, although it is still racy in some places	2017-05-23 16:32:13 -07:00
James R. Barlow	591e213713	Add more dependencies for autobrew	2017-05-23 13:52:28 -07:00
James R. Barlow	75f2262659	Ensure JobContext stuff is actually tested for IPC consistency	2017-05-19 17:57:07 -07:00
James R. Barlow	d9005a1074	pdfinfo: replace most remaining dict-style access	2017-05-19 16:17:36 -07:00
James R. Barlow	3e73fa81bf	pageinfo: deprecation warning	2017-05-19 16:17:07 -07:00
James R. Barlow	ba6e290231	Restore old pageinfo.py to avoid breaking compatibility	2017-05-19 15:49:23 -07:00
James R. Barlow	08e47117a3	Rename pageinfo to pdfinfo	2017-05-19 15:48:23 -07:00
James R. Barlow	532ef38157	/UserUnit is a scalar, not an array	2017-05-19 14:19:50 -07:00
James R. Barlow	4c09875890	docs: upload unpaper Dropbox link, .rst typo blocking macOS install [ci skip]	2017-05-19 12:18:09 -07:00
James R. Barlow	0e98139712	Upload to upload.pypi.org/legacy as recommend by PyPA https://github.com/pypa/warehouse/issues/1996#issuecomment-302784126	2017-05-19 12:06:24 -07:00
James R. Barlow	4c04d802d7	Introduce /UserUnit checking	2017-05-19 12:01:19 -07:00
James R. Barlow	b3dc404571	Update unpaper.deb link (fixes #171 ) Shakes fist a Dropbox	2017-05-19 11:28:45 -07:00
James R. Barlow	8694f8d2eb	Replace magic strings colorspace and encoding with Enums	2017-05-18 22:32:27 -07:00
James R. Barlow	263f9b79f4	pageinfo: debug stuff	2017-05-18 21:52:55 -07:00
James R. Barlow	56d2aae963	Refactor from ImageInfo index to attribute accessing	2017-05-18 18:39:14 -07:00
James R. Barlow	127706153d	Refactor dictionary based image info to ImageInfo	2017-05-18 18:26:31 -07:00
James R. Barlow	caee5b1428	Access PageInfo instance variables instead of dictionary	2017-05-18 17:12:04 -07:00
James R. Barlow	6c12e7e944	Refactor pageinfo dictionary to PageInfo()	2017-05-18 16:53:38 -07:00
James R. Barlow	cd04ae6949	Refactor PdfInfo(str(filename)) -> PdfInfo(filename)	2017-05-18 16:43:50 -07:00
James R. Barlow	6a0b68298f	Refactor pdf_get_all_pageinfo to PdfInfo	2017-05-18 16:31:18 -07:00
James R. Barlow	0a2f732267	docs: Fix restructured text typos	2017-05-16 23:27:10 -07:00
James R. Barlow	4bade99f27	docs: Remark that someone got bash on Windows working	2017-05-16 23:24:34 -07:00
James R. Barlow	0b048cd24e	Join the build badge club	2017-05-16 23:24:05 -07:00
James R. Barlow	c69ee63d82	Travis, true is a program, not a keyword	2017-05-15 15:12:14 -07:00
James R. Barlow	744fa104d7	v5.0.1 release notes (anticipating)	2017-05-14 23:59:09 -07:00
James R. Barlow	e24ff0fd64	Travis: don’t update the homebrew version because we pushed to testpypi	2017-05-14 23:55:40 -07:00
James R. Barlow	5de107d44c	tesseract_cache: update explanatory notes	2017-05-14 23:54:09 -07:00
James R. Barlow	131a5b741d	tesseract.py: update canned HOCR template to tess 3.05 output Seems better to not claim the existence of several entities that don’t exist as the older one does	2017-05-14 23:40:09 -07:00
James R. Barlow	65b89687a9	ghostscript: fix missing “import sys”, only applicable for an exception	2017-05-14 23:38:52 -07:00
James R. Barlow	048ae40e75	Update copyrights	2017-05-14 23:38:28 -07:00
James R. Barlow	234183ecd2	Fix: Tesseract 3.04 is sensitive to order of configuration commands “txt hocr” is not acceptable and does not produce expected output .txt while “hocr text” works fine, so switch the order everywhere. Should fix #169	2017-05-14 23:27:46 -07:00
James R. Barlow	fb067dc97b	cookbook: more on improving OCR	2017-05-14 23:16:47 -07:00
James R. Barlow	a1fea0ce16	docs: link to OCRmyPDF-web	2017-05-14 23:16:30 -07:00
James R. Barlow	e1e9135e93	Test suite: tidy up imports	2017-05-14 23:15:29 -07:00
James R. Barlow	aff982036b	autobrew: fix brew audit error on double blank line	2017-05-14 23:15:02 -07:00
James R. Barlow	d087649eab	Remove “null deploy script” since “/usr/bin/true” is equivalent	2017-05-12 15:37:02 -07:00
James R. Barlow	37ebcadfa1	Implement —user-words, —user-patterns	2017-05-09 17:54:56 -07:00