v11.6.0 release notes

Might fix issue #709, Apple silicon support.

.coveragerc

@@ -1,24 +0,0 @@
-[paths]
-source =
-	src
-	*/site-packages
-
-[run]
-branch = true
-parallel = true
-concurrency =
-	thread
-	multiprocessing
-source =
-	src/ocrmypdf
-
-[report]
-exclude_lines =
-	pragma: no cover
-	def __repr__
-	raise AssertionError
-	raise NotImplementedError
-	if 0:
-	if False:
-	if __name__ == .__main__.:
-	if TYPE_CHECKING:

.github/ISSUE_TEMPLATE/1-general-issues.md

@@ -21,8 +21,12 @@ If applicable, add screenshots to help explain your problem.
 
 **System (please complete the following information):**
  - OS:
- - Python version: 
+ - Python version:
  - OCRmyPDF version:
 
+**Installation**
+How did you install OCRmyPDF? Did you install it from your operating system's
+package manager, or using pip?
+
 **Additional context**
 Add any other context about the problem here.

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v3.1.0
+    rev: v3.4.0
     hooks:
       - id: check-case-conflict
       - id: check-merge-conflict
@@ -12,11 +12,11 @@ repos:
     hooks:
       - id: seed-isort-config
   - repo: https://github.com/pre-commit/mirrors-isort
-    rev: v5.0.5 # pick the isort version you'd like to use from https://github.com/pre-commit/mirrors-isort/releases
+    rev: v5.7.0 # pick the isort version you'd like to use from https://github.com/pre-commit/mirrors-isort/releases
     hooks:
       - id: isort
   - repo: https://github.com/psf/black
-    rev: 19.10b0
+    rev: 20.8b1
     hooks:
       - id: black
         language_version: python

docs/api.rst

@@ -56,6 +56,11 @@ Programs that call ``ocrmypdf.ocr()`` should also install a SIGBUS signal
 handler (except on Windows), to raise an exception if access to a memory
 mapped file fails. OCRmyPDF may use memory mapping.
 
+``ocrmypdf.ocr()`` will take a threading lock to prevent multiple runs of itself
+in the same Python interpreter process. This is not thread-safe, because of how
+OCRmyPDF's plugins and Python's library import system work. If you need to parallelize
+OCRmyPDF, use processes.
+
 .. warning::
 
     On Windows and macOS, the script that calls ``ocrmypdf.ocr()`` must be

docs/apiref.rst

@@ -5,6 +5,15 @@ API Reference
 This page summarizes the rest of the public API. Generally speaking this
 should mainly of interest to plugin developers.
 
+ocrmypdf
+========
+
+.. autoclass:: ocrmypdf.PageContext
+    :members:
+
+.. autoclass:: ocrmypdf.PdfContext
+    :members:
+
 ocrmypdf.exceptions
 ===================
 
@@ -17,6 +26,9 @@ ocrmypdf.helpers
 
 .. automodule:: ocrmypdf.helpers
     :members:
+    :noindex: deprecated
+
+    .. autodecorator:: deprecated
 
 ocrmypdf.hocrtransform
 ======================

docs/installation.rst

@@ -520,7 +520,7 @@ DLLs or other Windows patches, and may require a reboot.
 You may then use ``pip`` to install ocrmypdf. (This can performed by a user or
 Administrator.):
 
-* ``pip install ocrmypdf
+* ``pip install ocrmypdf``
 
 Chocolatey automatically selects appropriate versions of these applications. If you
 are installing them manually, please install 64-bit versions of all applications for
@@ -533,6 +533,12 @@ override the versions OCRmyPDF selects, you can modify the ``PATH`` environment
 variable. `Follow these directions <https://www.computerhope.com/issues/ch000549.htm#dospath>`_
 to change the PATH.
 
+.. warning::
+
+    As of early 2021, users have reported problems with the Microsoft Store version of
+    Python affected most third party Python packages including OCRmyPDF. Please use
+    Python downloaded from Python.org or Chocolatey as recommended here.
+
 Windows Subsystem for Linux
 ---------------------------
 

docs/plugins.rst

@@ -65,6 +65,27 @@ similar to ``pytest`` packages such as ``pytest-cov`` (the package) and
     ``ocrmypdf-`` (for the package name on PyPI) and ``ocrmypdf_`` (for the
     module), just like pytest plugins.
 
+Setuptools plugins
+==================
+
+You can also create a plugin that OCRmyPDF will always automatically load if both are
+installed in the same virtual environment, using a setuptools entrypoint.
+
+Your package's ``setup.py`` would need to contain the following, for a plugin
+named ``ocrmypdf-exampleplugin``:
+
+.. code-block:: python
+
+    # sample ./setup.py file
+    from setuptools import setup
+
+    setup(
+        name="ocrmypdf-exampleplugin",
+        packages=["exampleplugin"],
+        # the following makes a plugin available to pytest
+        entry_points={"ocrmypdf": ["exampleplugin = exampleplugin.pluginmodule"]},
+    )
+
 Plugin requirements
 ===================
 

docs/release_notes.rst

@@ -12,6 +12,46 @@ may be unreliable. Use the API to depend on precise behavior.
 The public API may be useful in scripts that launch OCRmyPDF processes or that
 wish to use some of its features for working with PDFs.
 
+v11.6.0
+=======
+
+-  OCRmyPDF will now automatically register plugins from the same virtual environment
+   with an appropriate setuptools entrypoint.
+-  Refactor the plugin manager to remove unnecessary complications and make plugin
+   registration more automatic.
+-  ``PageContext`` and ``PdfContext`` are now formally part of the API, as they
+   should have been, since they were part of ``ocrmypdf.pluginspec``.
+
+v11.5.0
+=======
+
+-  Fixed an issue where the output page size might differ by a fractional amount
+   due to rounding, when ``--force-ocr`` was used and the page contained objects
+   with multiple resolutions.
+-  When determining the resolution at which to rasterize a page, we now consider
+   printed text on the page as requiring a higher resolution. This fixes issues
+   with certain pages being rendered with unacceptably low resolution text, but
+   may increase output file sizes in some workflows where low resolution text
+   is acceptable.
+-  Added a workaround to fix an exception that occurs when trying to
+   ``import ocrmypdf.leptonica`` on Apple ARM silicon (or potentially, other
+   platforms that do not permit write+executable memory).
+
+v11.4.5
+=======
+
+-  Fixed an issue where files may not be closed when the API is used.
+-  Improved ``setup.cfg`` with better settings for test coverage.
+
+v11.4.4
+=======
+
+-  Fixed ``AttributeError: 'NoneType' object has no attribute 'userunit'``, issue #700,
+   related to OCRmyPDF not properly forwarded an error message from pdfminer.six.
+-  Adjusted typing of some arguments.
+-  ``ocrmypdf.ocr`` now takes a ``threading.Lock`` for reasons outlined in the
+   documentation.
+
 v11.4.3
 =======
 

setup.cfg

@@ -15,6 +15,8 @@ filterwarnings =
 	ignore:.*XMLParser.*:DeprecationWarning
 markers =
 	slow
+addopts =
+	-n auto
 
 [isort]
 multi_line_output=3
@@ -27,3 +29,30 @@ known_third_party = PIL,_cffi_backend,cffi,flask,img2pdf,pdfminer,pikepdf,pkg_re
 
 [metadata]
 license_file = LICENSE
+
+[coverage:paths]
+source =
+	src/
+
+[coverage:run]
+branch = true
+parallel = true
+concurrency = multiprocessing
+source =
+	src/ocrmypdf
+
+[coverage:report]
+# Regexes for lines to exclude from consideration
+exclude_lines =
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+	if False:
+    if __name__ == .__main__.:
+	if TYPE_CHECKING:

src/ocrmypdf/__init__.py

@@ -8,6 +8,7 @@
 from pluggy import HookimplMarker as _HookimplMarker
 
 from ocrmypdf import helpers, hocrtransform, leptonica, pdfa, pdfinfo
+from ocrmypdf._jobcontext import PageContext, PdfContext
 from ocrmypdf._version import PROGRAM_NAME, __version__
 from ocrmypdf.api import Verbosity, configure_logging, ocr
 from ocrmypdf.exceptions import (

src/ocrmypdf/_concurrent.py

@@ -109,15 +109,11 @@ def exec_progress_pool(
         )
         try:
             results = pool.imap_unordered(task, task_arguments)
-            while True:
+            for result in results:
-                try:
+                if task_finished:
-                    result = results.next()
+                    task_finished(result, pbar)
-                    if task_finished:
+                else:
-                        task_finished(result, pbar)
+                    pbar.update()
-                    else:
-                        pbar.update()
-                except StopIteration:
-                    break
         except KeyboardInterrupt:
             # Terminate pool so we exit instantly
             pool.terminate()

src/ocrmypdf/_exec/ghostscript.py

@@ -15,7 +15,7 @@ from os import fspath
 from pathlib import Path
 from shutil import which
 from subprocess import PIPE, CalledProcessError
-from typing import Optional, cast
+from typing import Optional
 
 from PIL import Image
 
@@ -56,16 +56,14 @@ def version():
 def jpeg_passthrough_available() -> bool:
     """Returns True if the installed version of Ghostscript supports JPEG passthru
 
-    Prior to 9.23, Ghostscript decode and re-encoded JPEGs internally. In 9.23
+    Prior to 9.23, Ghostscript decoded and re-encoded JPEGs internally. In 9.23
     it gained the ability to keep JPEGs unmodified. However, the 9.23
     implementation was buggy and would deletes the last two bytes of images in
     some cases, as reported here.
     https://bugs.ghostscript.com/show_bug.cgi?id=699216
 
     The issue was fixed for 9.24, hence that is the first version we consider
-    the feature available. (However, we don't use 9.24 at all, so the first
+    the feature available. (Ghostscript 9.24 has its own problems is blacklisted.)
-    version that allows JPEG passthrough is 9.25.
-
     """
     return version() >= '9.24'
 

src/ocrmypdf/_exec/pngquant.py

@@ -9,10 +9,8 @@
 
 from contextlib import contextmanager
 from io import BytesIO
-from os import fspath
 from pathlib import Path
 from subprocess import PIPE
-from tempfile import NamedTemporaryFile
 
 from PIL import Image
 

src/ocrmypdf/_exec/tesseract.py

@@ -14,7 +14,7 @@ from collections import namedtuple
 from os import fspath
 from pathlib import Path
 from subprocess import PIPE, STDOUT, CalledProcessError, TimeoutExpired
-from typing import List
+from typing import List, Optional
 
 from PIL import Image
 
@@ -118,7 +118,7 @@ def get_languages():
     return set(lang.strip() for lang in rest)
 
 
-def tess_base_args(langs: List[str], engine_mode: int) -> List[str]:
+def tess_base_args(langs: List[str], engine_mode: Optional[int]) -> List[str]:
     args = ['tesseract']
     if langs:
         args.extend(['-l', '+'.join(langs)])
@@ -127,7 +127,7 @@ def tess_base_args(langs: List[str], engine_mode: int) -> List[str]:
     return args
 
 
-def get_orientation(input_file: Path, engine_mode: int, timeout: float):
+def get_orientation(input_file: Path, engine_mode: Optional[int], timeout: float):
     args_tesseract = tess_base_args(['osd'], engine_mode) + [
         '--psm',
         '0',

src/ocrmypdf/_jobcontext.py

@@ -10,15 +10,22 @@ import shutil
 import sys
 from argparse import Namespace
 from copy import copy
-from io import IOBase
 from pathlib import Path
 from typing import Iterator
 
+from pluggy import PluginManager
+
 from ocrmypdf.pdfinfo import PdfInfo
+from ocrmypdf.pdfinfo.info import PageInfo
 
 
 class PdfContext:
-    """Holds our context for a particular run of the pipeline"""
+    """Holds the context for a particular run of the pipeline."""
+
+    options: Namespace  #: The specified options for processing this PDF.
+    origin: Path  #: The filename of the original input file.
+    pdfinfo: PdfInfo  #: Detailed data for this PDF.
+    plugin_manager: PluginManager  #: PluginManager for processing the current PDF.
 
     def __init__(
         self,
@@ -35,21 +42,33 @@ class PdfContext:
         self.plugin_manager = plugin_manager
 
     def get_path(self, name: str) -> Path:
+        """Generate a ``Path`` for an intermediate file involved in processing.
+
+        The path will be in a temporary folder that is common for all processing
+        of this particular PDF.
+        """
         return self.work_folder / name
 
     def get_page_contexts(self) -> Iterator['PageContext']:
+        """Get all ``PageContext`` for this PDF."""
         npages = len(self.pdfinfo)
         for n in range(npages):
             yield PageContext(self, n)
 
 
 class PageContext:
-    """Holds our context for a page
+    """Holds our context for a page.
 
     Must be pickable, so stores only intrinsic/simple data elements or those
-    capable of their serializing themselves via __getstate__.
+    capable of their serializing themselves via ``__getstate__``.
     """
 
+    options: Namespace  #: The specified options for processing this PDF.
+    origin: Path  #: The filename of the original input file.
+    pageno: int  #: This page number (zero-based).
+    pageinfo: PageInfo  #: Information on this page.
+    plugin_manager: PluginManager  #: PluginManager for processing the current PDF.
+
     def __init__(self, pdf_context: PdfContext, pageno):
         self.work_folder = pdf_context.work_folder
         self.origin = pdf_context.origin
@@ -59,6 +78,11 @@ class PageContext:
         self.plugin_manager = pdf_context.plugin_manager
 
     def get_path(self, name: str) -> Path:
+        """Generate a ``Path`` for a file that is part of processing this page.
+
+        The path will be based in a common temporary folder and have a prefix based
+        on the page number.
+        """
         return self.work_folder / ("%06d_%s" % (self.pageno + 1, name))
 
     def __getstate__(self):

src/ocrmypdf/_pipeline.py

@@ -206,17 +206,21 @@ def validate_pdfinfo_options(context: PdfContext):
     context.plugin_manager.hook.validate(pdfinfo=pdfinfo, options=options)
 
 
+def _vector_page_dpi(pageinfo):
+    return VECTOR_PAGE_DPI if pageinfo.has_vector or pageinfo.has_text else 0.0
+
+
 def get_page_dpi(pageinfo, options):
     "Get the DPI when nonsquare DPI is tolerable"
     xres = max(
         pageinfo.dpi.x or VECTOR_PAGE_DPI,
         options.oversample or 0.0,
-        VECTOR_PAGE_DPI if pageinfo.has_vector else 0.0,
+        _vector_page_dpi(pageinfo),
     )
     yres = max(
         pageinfo.dpi.y or VECTOR_PAGE_DPI,
         options.oversample or 0,
-        VECTOR_PAGE_DPI if pageinfo.has_vector else 0.0,
+        _vector_page_dpi(pageinfo),
     )
     return Resolution(float(xres), float(yres))
 
@@ -230,7 +234,7 @@ def get_page_square_dpi(pageinfo, options) -> Resolution:
         max(
             (xres * userunit) or VECTOR_PAGE_DPI,
             (yres * userunit) or VECTOR_PAGE_DPI,
-            VECTOR_PAGE_DPI if pageinfo.has_vector else 0.0,
+            _vector_page_dpi(pageinfo),
             options.oversample or 0.0,
         )
     )
@@ -243,7 +247,7 @@ def get_canvas_square_dpi(pageinfo, options) -> Resolution:
         max(
             (pageinfo.dpi.x) or VECTOR_PAGE_DPI,
             (pageinfo.dpi.y) or VECTOR_PAGE_DPI,
-            VECTOR_PAGE_DPI if pageinfo.has_vector else 0.0,
+            _vector_page_dpi(pageinfo),
             options.oversample or 0.0,
         )
     )
@@ -588,12 +592,17 @@ def create_pdf_page_from_image(image: Path, page_context: PageContext):
     # except that the hocr renderer does not understand non-square DPI. The
     # sandwich renderer would be fine.
     output_file = page_context.get_path('visible.pdf')
-    dpi = get_page_square_dpi(page_context.pageinfo, page_context.options)
+
-    layout_fun = img2pdf.get_fixed_dpi_layout_fun(dpi)
+    pageinfo = page_context.pageinfo
+    pagesize = 72.0 * float(pageinfo.width_inches), 72.0 * float(pageinfo.height_inches)
+    if pageinfo.rotation % 180 == 90:
+        pagesize = pagesize[1], pagesize[0]
 
     # This create a single page PDF
     with open(image, 'rb') as imfile, open(output_file, 'wb') as pdf:
         log.debug('convert')
+
+        layout_fun = img2pdf.get_layout_fun(pagesize)
         img2pdf.convert(
             imfile, with_pdfrw=False, layout_fun=layout_fun, outputstream=pdf
         )

src/ocrmypdf/_plugin_manager.py

@@ -8,13 +8,14 @@
 import argparse
 import importlib
 import importlib.util
+import pkgutil
 import sys
-from functools import partial
 from pathlib import Path
-from typing import Callable, List, Tuple, Union
+from typing import List, Tuple, Union
 
 import pluggy
 
+import ocrmypdf.builtin_plugins
 from ocrmypdf import pluginspec
 from ocrmypdf.cli import get_parser, plugins_only_parser
 
@@ -30,62 +31,69 @@ class OcrmypdfPluginManager(pluggy.PluginManager):
     """
 
     def __init__(
-        self, *args, setup_func: Callable[[pluggy.PluginManager], None], **kwargs
+        self,
+        *args,
+        plugins: List[Union[str, Path]],
+        builtins: bool = True,
+        **kwargs,
     ):
-        self._init_args = args
+        self.__init_args = args
-        self._setup_func = setup_func
+        self.__init_kwargs = kwargs
-        self._init_kwargs = kwargs
+        self.__plugins = plugins
+        self.__builtins = builtins
         super().__init__(*args, **kwargs)
-        setup_func(self)
+        self.setup_plugins()
 
     def __getstate__(self):
         state = dict(
-            _init_args=self._init_args,
+            init_args=self.__init_args,
-            _setup_func=self._setup_func,
+            plugins=self.__plugins,
-            _init_kwargs=self._init_kwargs,
+            builtins=self.__builtins,
+            init_kwargs=self.__init_kwargs,
         )
         return state
 
     def __setstate__(self, state):
         self.__init__(
-            *state['_init_args'],
+            *state['init_args'],
-            setup_func=state['_setup_func'],
+            plugins=state['plugins'],
-            **state['_init_kwargs'],
+            builtins=state['builtins'],
+            **state['init_kwargs'],
         )
 
+    def setup_plugins(self):
+        self.add_hookspecs(pluginspec)
 
-def _setup_plugins(
+        # 1. Register builtins
-    pm: pluggy.PluginManager, plugins: List[Union[str, Path]], builtins: bool = True
+        if self.__builtins:
-):
+            for module in pkgutil.iter_modules(ocrmypdf.builtin_plugins.__path__):
-    pm.add_hookspecs(pluginspec)
+                name = f'ocrmypdf.builtin_plugins.{module.name}'
+                module = importlib.import_module(name)
+                self.register(module)
 
-    all_plugins: List[Union[str, Path]] = []
+        # 2. Register setuptools plugins
-    if builtins:
+        self.load_setuptools_entrypoints('ocrmypdf')
-        all_plugins.extend(
+
-            [
+        # 3. Register plugins specified on command line
-                'ocrmypdf.builtin_plugins.ghostscript',
+        for name in self.__plugins:
-                'ocrmypdf.builtin_plugins.tesseract_ocr',
+            if isinstance(name, Path) or name.endswith('.py'):
-            ]
+                # Import by filename
-        )
+                module_name = Path(name).stem
-    all_plugins.extend(plugins)
+                spec = importlib.util.spec_from_file_location(module_name, name)
-    for name in all_plugins:
+                module = importlib.util.module_from_spec(spec)
-        if isinstance(name, Path) or name.endswith('.py'):
+                sys.modules[module_name] = module
-            # Import by filename
+                spec.loader.exec_module(module)
-            module_name = Path(name).stem
+            else:
-            spec = importlib.util.spec_from_file_location(module_name, name)
+                # Import by dotted module name
-            module = importlib.util.module_from_spec(spec)
+                module = importlib.import_module(name)
-            sys.modules[module_name] = module
+            self.register(module)
-            spec.loader.exec_module(module)
-        else:
-            # Import by dotted module name
-            module = importlib.import_module(name)
-        pm.register(module)
 
 
 def get_plugin_manager(plugins: List[Union[str, Path]], builtins=True):
     pm = OcrmypdfPluginManager(
         project_name='ocrmypdf',
-        setup_func=partial(_setup_plugins, plugins=plugins, builtins=builtins),
+        plugins=plugins,
+        builtins=builtins,
     )
     return pm
 

src/ocrmypdf/_sync.py

@@ -302,7 +302,7 @@ def exec_concurrent(context: PdfContext):
     copy_final(pdf, options.output_file, context)
 
 
-def configure_debug_logging(log_filename, prefix: str = ''):
+def configure_debug_logging(log_filename: Path, prefix: str = ''):
     """
     Create a debug log file at a specified location.
 
@@ -338,7 +338,11 @@ def run_pipeline(options, *, plugin_manager, api=False):
         and not api
     ):
         # Debug log for command line interface only with verbose output
-        debug_log_handler = configure_debug_logging(Path(work_folder) / "debug.log")
+        # See https://github.com/pytest-dev/pytest/issues/5502 for why we skip this
+        # when pytest is running
+        debug_log_handler = configure_debug_logging(
+            Path(work_folder) / "debug.log"
+        )  # pragma: no cover
 
     pikepdf_enable_mmap()
 

src/ocrmypdf/api.py

@@ -8,6 +8,7 @@
 import logging
 import os
 import sys
+import threading
 from enum import IntEnum
 from io import IOBase
 from pathlib import Path
@@ -30,6 +31,8 @@ except ModuleNotFoundError:
 StrPath = Union[os.PathLike, AnyStr]
 PathOrIO = Union[BinaryIO, StrPath]
 
+_api_lock = threading.Lock()
+
 
 class Verbosity(IntEnum):
     """Verbosity level for configure_logging."""
@@ -306,12 +309,18 @@ def ocr(  # pylint: disable=unused-argument
 
     parser = get_parser()
     create_options_kwargs['parser'] = parser
-    plugin_manager = get_plugin_manager(plugins)
-    plugin_manager.hook.add_options(parser=parser)  # pylint: disable=no-member
 
-    if 'verbose' in kwargs:
+    with _api_lock:
-        warn("ocrmypdf.ocr(verbose=) is ignored. Use ocrmypdf.configure_logging().")
+        # We can't allow multiple ocrmypdf.ocr() threads to run in parallel, because
+        # they might install different plugins, and generally speaking we have areas
+        # of code that use global state.
 
-    options = create_options(**create_options_kwargs)
+        plugin_manager = get_plugin_manager(plugins)
-    check_options(options, plugin_manager)
+        plugin_manager.hook.add_options(parser=parser)  # pylint: disable=no-member
-    return run_pipeline(options=options, plugin_manager=plugin_manager, api=True)
+
+        if 'verbose' in kwargs:
+            warn("ocrmypdf.ocr(verbose=) is ignored. Use ocrmypdf.configure_logging().")
+
+        options = create_options(**create_options_kwargs)
+        check_options(options, plugin_manager)
+        return run_pipeline(options=options, plugin_manager=plugin_manager, api=True)

src/ocrmypdf/helpers.py

@@ -17,7 +17,7 @@ from functools import wraps
 from io import StringIO
 from math import isclose
 from pathlib import Path
-from typing import Any, Sequence, TypeVar
+from typing import Any, Sequence
 
 import pikepdf
 
@@ -63,8 +63,13 @@ class NeverRaise(Exception):
 
 
 def safe_symlink(input_file: os.PathLike, soft_link_name: os.PathLike):
-    """
+    """Create a symbolic link at ``soft_link_name``, which references ``input_file``.
-    Helper function: relinks soft symbolic link if necessary
+
+    Think of this as copying ``input_file`` to ``soft_link_name`` with less overhead.
+
+    Use symlinks safely. Self-linking loops are prevented. On Windows, file copy is
+    used since symlinks may require administrator privileges. An existing link at the
+    destination is removed.
     """
     input_file = os.fspath(input_file)
     soft_link_name = os.fspath(soft_link_name)
@@ -72,8 +77,8 @@ def safe_symlink(input_file: os.PathLike, soft_link_name: os.PathLike):
     # Guard against soft linking to oneself
     if input_file == soft_link_name:
         log.warning(
-            "No symbolic link made. You are using "
+            "No symbolic link created. You are using  the original data directory "
-            "the original data directory as the working directory."
+            "as the working directory."
         )
         return
 
@@ -114,7 +119,7 @@ def is_iterable_notstr(thing: Any) -> bool:
 
 
 def monotonic(L: Sequence) -> bool:
-    """Does list increase monotonically?"""
+    """Does this sequence increase monotonically?"""
     return all(b > a for a, b in zip(L, L[1:]))
 
 
@@ -173,7 +178,8 @@ def is_file_writable(test_file: os.PathLike) -> bool:
 def check_pdf(input_file: Path) -> bool:
     """Check if a PDF complies with the PDF specification.
 
-    Checks for proper formatting and proper linearization.
+    Checks for proper formatting and proper linearization. Uses pikepdf (which in
+    turn, uses QPDF) to perform the checks.
     """
     pdf = None
     try:
@@ -217,7 +223,7 @@ def check_pdf(input_file: Path) -> bool:
 
 
 def clamp(n, smallest, largest):  # mypy doesn't understand types for this
-    """Clamps the value of n to between smallest and largest."""
+    """Clamps the value of ``n`` to between ``smallest`` and ``largest``."""
     return max(smallest, min(n, largest))
 
 
@@ -235,7 +241,7 @@ def pikepdf_enable_mmap():
 
 
 def deprecated(func):
-    """Warn that function is deprecated"""
+    """Warn that function is deprecated."""
 
     @wraps(func)
     def new_func(*args, **kwargs):

src/ocrmypdf/hocrtransform.py

@@ -31,11 +31,10 @@
 import argparse
 import os
 import re
-from collections import namedtuple
 from itertools import chain
 from math import atan, cos, sin
 from pathlib import Path
-from typing import Optional, Tuple, Union
+from typing import Any, NamedTuple, Optional, Tuple, Union
 from xml.etree import ElementTree
 
 from reportlab.lib.colors import black, cyan, magenta, red
@@ -44,7 +43,14 @@ from reportlab.pdfgen.canvas import Canvas
 
 Element = ElementTree.Element
 
-Rect = namedtuple('Rect', ['x1', 'y1', 'x2', 'y2'])
+
+class Rect(NamedTuple):  # pylint: disable=inherit-non-class
+    """A rectangle for managing PDF coordinates."""
+
+    x1: Any
+    y1: Any
+    x2: Any
+    y2: Any
 
 
 class HocrTransformError(Exception):

src/ocrmypdf/leptonica.py

@@ -170,20 +170,6 @@ tls = threading.local()
 tls.trap = None
 
 
-@ffi.callback("void(char *)")
-def _stderr_handler(cstr):
-    msg = ffi.string(cstr).decode(errors='replace')
-    if msg.startswith("Error"):
-        logger.error(msg)
-    elif msg.startswith("Warning"):
-        logger.warning(msg)
-    else:
-        logger.debug(msg)
-    if tls.trap is not None:
-        tls.trap.append(msg)
-    return
-
-
 class _LeptonicaErrorTrap_Queue:
     def __init__(self):
         self.queue = deque()
@@ -213,9 +199,25 @@ class _LeptonicaErrorTrap_Queue:
 
 
 try:
+
+    @ffi.callback("void(char *)")
+    def _stderr_handler(cstr):
+        msg = ffi.string(cstr).decode(errors='replace')
+        if msg.startswith("Error"):
+            logger.error(msg)
+        elif msg.startswith("Warning"):
+            logger.warning(msg)
+        else:
+            logger.debug(msg)
+        if tls.trap is not None:
+            tls.trap.append(msg)
+        return
+
     lept.leptSetStderrHandler(_stderr_handler)
-except ffi.error:
+except (ffi.error, MemoryError):
     # Pre-1.79 Leptonica does not have leptSetStderrHandler
+    # And some platforms, notably Apple ARM 64, do not allow the write+execute
+    # memory needed to set up the callback function.
     _LeptonicaErrorTrap = _LeptonicaErrorTrap_Redirect
 else:
     # 1.79 have this new symbol

src/ocrmypdf/optimize.py

@@ -10,11 +10,9 @@ import sys
 import tempfile
 from collections import defaultdict
 from functools import partial
-from io import BytesIO
 from os import fspath
 from pathlib import Path
 from typing import (
-    Any,
     Callable,
     Dict,
     Iterator,
@@ -49,7 +47,7 @@ DEFAULT_PNG_QUALITY = 70
 Xref = NewType('Xref', int)
 
 
-class XrefExt(NamedTuple):
+class XrefExt(NamedTuple):  # pylint: disable=inherit-non-class
     xref: Xref
     ext: str
 
@@ -212,7 +210,10 @@ def extract_image_generic(
 
 
 def extract_images(
-    pike: Pdf, root: Path, options, extract_fn: Callable[..., Optional[XrefExt]],
+    pike: Pdf,
+    root: Path,
+    options,
+    extract_fn: Callable[..., Optional[XrefExt]],
 ) -> Iterator[Tuple[int, XrefExt]]:
     """Extract image using extract_fn
 
@@ -498,7 +499,7 @@ def transcode_pngs(
 
 
 @deprecated
-def rewrite_png_as_g4(pike: Pdf, im_obj: Object, compdata) -> None:
+def rewrite_png_as_g4(pike: Pdf, im_obj: Object, compdata) -> None:  # pragma: no cover
     im_obj.BitsPerComponent = 1
     im_obj.Width = compdata.w
     im_obj.Height = compdata.h
@@ -519,7 +520,7 @@ def rewrite_png_as_g4(pike: Pdf, im_obj: Object, compdata) -> None:
 
 
 @deprecated
-def rewrite_png(pike: Pdf, im_obj: Object, compdata) -> None:
+def rewrite_png(pike: Pdf, im_obj: Object, compdata) -> None:  # pragma: no cover
     # When a PNG is inserted into a PDF, we more or less copy the IDAT section from
     # the PDF and transfer the rest of the PNG headers to PDF image metadata.
     # One thing we have to do is tell the PDF reader whether a predictor was used
@@ -564,10 +565,10 @@ def rewrite_png(pike: Pdf, im_obj: Object, compdata) -> None:
         # ncolors == 0 means we are using a colorspace without a palette
         if compdata.spp == 1:
             cs = Name.DeviceGray
-        elif compdata.spp == 3:
-            cs = Name.DeviceRGB
         elif compdata.spp == 4:
             cs = Name.DeviceCMYK
+        else:  # spp == 3
+            cs = Name.DeviceRGB
     im_obj.ColorSpace = cs
     im_obj.write(compdata.read(), filter=Name.FlateDecode, decode_parms=dparms)
 

src/ocrmypdf/pdfa.py

@@ -112,7 +112,7 @@ def generate_pdfa_ps(target_filename: Path, icc: str = 'sRGB'):
 
 
 def file_claims_pdfa(filename: Path):
-    """Determines if the file claims to be PDF/A compliant
+    """Determines if the file claims to be PDF/A compliant.
 
     This only checks if the XMP metadata contains a PDF/A marker. It does not
     do full PDF/A validation.

src/ocrmypdf/pdfinfo/info.py

@@ -15,14 +15,14 @@ from functools import partial
 from math import hypot, isclose
 from os import PathLike
 from pathlib import Path
-from typing import Any, Container, Dict, Iterator, List, Optional, Tuple, Union
+from typing import Container, Iterator, Optional, Tuple, Union
 from warnings import warn
 
 import pikepdf
 from pikepdf import Object, Pdf, PdfMatrix
 
 from ocrmypdf._concurrent import exec_progress_pool
-from ocrmypdf.exceptions import EncryptedPdfError
+from ocrmypdf.exceptions import EncryptedPdfError, InputFileError
 from ocrmypdf.helpers import Resolution, available_cpu_count, pikepdf_enable_mmap
 from ocrmypdf.pdfinfo.layout import get_page_analysis, get_text_boxes
 
@@ -598,6 +598,8 @@ def _pdf_pageinfo_concurrent(
 
     def update_pageinfo(result, pbar):
         page = result
+        if not page:
+            raise InputFileError("Could read a page in the PDF")
         pages[page.pageno] = page
         pbar.update()
 

src/ocrmypdf/pdfinfo/layout.py

@@ -21,7 +21,7 @@ from pdfminer.pdffont import PDFSimpleFont, PDFUnicodeNotDefined
 from pdfminer.pdfpage import PDFPage
 from pdfminer.utils import bbox2str, matrix2str
 
-from ocrmypdf.exceptions import EncryptedPdfError
+from ocrmypdf.exceptions import EncryptedPdfError, InputFileError
 
 STRIP_NAME = re.compile(r'[0-9]+')
 
@@ -236,8 +236,13 @@ def get_page_analysis(infile, pageno, pscript5_mode):
 
     try:
         with Path(infile).open('rb') as f:
-            page = PDFPage.get_pages(f, pagenos=[pageno], maxpages=0)
+            page_iter = PDFPage.get_pages(f, pagenos=[pageno], maxpages=0)
-            interp.process_page(next(page))
+            page = next(page_iter, None)
+            if page is None:
+                raise InputFileError(
+                    f"pdfminer could not process page {pageno} (counting from 0)."
+                )
+            interp.process_page(page)
     except PDFTextExtractionNotAllowed as e:
         raise EncryptedPdfError() from e
     finally:

src/ocrmypdf/subprocess/__init__.py

@@ -77,20 +77,19 @@ def run_polling_stderr(args, *, callback, check=False, env=None, **kwargs):
     args, env, process_log, text = _fix_process_args(args, env, kwargs)
     assert text, "Must use text=True"
 
-    proc = Popen(args, env=env, **kwargs)
+    with Popen(args, env=env, **kwargs) as proc:
+        lines = []
+        while proc.poll() is None:
+            for msg in iter(proc.stderr.readline, ''):
+                if process_log.isEnabledFor(logging.DEBUG):
+                    process_log.debug(msg.strip())
+                callback(msg)
+                lines.append(msg)
+        stderr = ''.join(lines)
 
-    lines = []
+        if check and proc.returncode != 0:
-    while proc.poll() is None:
+            raise CalledProcessError(proc.returncode, args, output=None, stderr=stderr)
-        for msg in iter(proc.stderr.readline, ''):
+        return CompletedProcess(args, proc.returncode, None, stderr=stderr)
-            if process_log.isEnabledFor(logging.DEBUG):
-                process_log.debug(msg.strip())
-            callback(msg)
-            lines.append(msg)
-    stderr = ''.join(lines)
-
-    if check and proc.returncode != 0:
-        raise CalledProcessError(proc.returncode, args, output=None, stderr=stderr)
-    return CompletedProcess(args, proc.returncode, None, stderr=stderr)
 
 
 def _fix_process_args(args, env, kwargs):

tests/conftest.py

@@ -137,16 +137,7 @@ def run_ocrmypdf(input_file, output_file, *args, text=True):
         + [str(input_file), str(output_file)]
     )
 
-    # Tell subprocess where to find coverage.py configuration
-    # This has no unless except when coverage is running
-    # Details: https://coverage.readthedocs.io/en/coverage-5.0/subprocess.html
-    coverage_rc = Path(__file__).parent.parent / '.coveragerc'
     env = os.environ.copy()
-    if coverage_rc.exists():
-        env['COVERAGE_PROCESS_START'] = os.fspath(coverage_rc)
-    elif not running_in_docker():
-        assert False, "could not find .coveragerc"
-
     p = run(
         p_args,
         stdout=PIPE,

tests/test_logging.py

@@ -0,0 +1,21 @@
+# © 2021 James R. Barlow: github.com/jbarlow83
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import logging
+
+import pytest
+
+from ocrmypdf._sync import configure_debug_logging
+
+
+def test_debug_logging(tmp_path):
+    # Just exercise the debug logger but don't validate it
+    # See https://github.com/pytest-dev/pytest/issues/5502 for pytest logging quirks
+    prefix = 'test_debug_logging'
+    log = logging.getLogger(prefix)
+    handler = configure_debug_logging(tmp_path / 'test.log', prefix)
+    log.info("test message")
+    log.removeHandler(handler)

tests/test_optimize.py

@@ -173,3 +173,15 @@ def test_multiple_pngs(resources, outdir):
             inim = next(iter(inpdf.pages[n].images.values()))
             outim = next(iter(outpdf.pages[n].images.values()))
             assert len(outim.read_raw_bytes()) < len(inim.read_raw_bytes()), n
+
+
+def test_optimize_off(resources, outpdf):
+    check_ocrmypdf(
+        resources / 'trivial.pdf',
+        outpdf,
+        '--optimize=0',
+        '--output-type',
+        'pdf',
+        '--plugin',
+        'tests/plugins/tesseract_noop.py',
+    )

tests/test_pdfinfo.py

@@ -4,28 +4,31 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-
 import pickle
+from io import BytesIO
 from math import isclose
 
 import img2pdf
 import pikepdf
 import pytest
 from PIL import Image
+from reportlab.lib.units import inch
 from reportlab.pdfgen.canvas import Canvas
 
 from ocrmypdf import pdfinfo
+from ocrmypdf.exceptions import InputFileError
 from ocrmypdf.pdfinfo import Colorspace, Encoding
+from ocrmypdf.pdfinfo.layout import PDFPage
 
 # pylint: disable=protected-access
 
 
 def test_single_page_text(outdir):
     filename = outdir / 'text.pdf'
-    pdf = Canvas(str(filename), pagesize=(8 * 72, 6 * 72))
+    pdf = Canvas(str(filename), pagesize=(8 * inch, 6 * inch))
     text = pdf.beginText()
     text.setFont('Helvetica', 12)
-    text.setTextOrigin(1 * 72, 3 * 72)
+    text.setTextOrigin(1 * inch, 3 * inch)
     text.textLine(
         "Methink'st thou art a general offence and every" " man should beat thee."
     )
@@ -42,25 +45,32 @@ def test_single_page_text(outdir):
     assert len(page.images) == 0
 
 
-def test_single_page_image(outdir):
+@pytest.fixture(scope='session')
-    filename = outdir / 'image-mono.pdf'
+def eight_by_eight():
-
-    im_tmp = outdir / 'tmp.png'
     im = Image.new('1', (8, 8), 0)
     for n in range(8):
         im.putpixel((n, n), 1)
-    im.save(str(im_tmp), format='PNG')
+    return im
+
+
+def test_single_page_image(eight_by_eight, outpdf):
+    im = eight_by_eight
+    bio = BytesIO()
+    im.save(bio, format='PNG')
+    bio.seek(0)
 
     imgsize = ((img2pdf.ImgSize.dpi, 8), (img2pdf.ImgSize.dpi, 8))
     layout_fun = img2pdf.get_layout_fun(None, imgsize, None, None, None)
 
-    im_bytes = im_tmp.read_bytes()
+    with outpdf.open('wb') as f:
-    pdf_bytes = img2pdf.convert(
+        img2pdf.convert(
-        im_bytes, producer="img2pdf", with_pdfrw=False, layout_fun=layout_fun
+            bio,
-    )
+            producer="img2pdf",
-    filename.write_bytes(pdf_bytes)
+            with_pdfrw=False,
-
+            layout_fun=layout_fun,
-    info = pdfinfo.PdfInfo(filename)
+            outputstream=f,
+        )
+    info = pdfinfo.PdfInfo(outpdf)
 
     assert len(info) == 1
     page = info[0]
@@ -77,16 +87,12 @@ def test_single_page_image(outdir):
     assert isclose(pdfimage.dpi.y, 8)
 
 
-def test_single_page_inline_image(outdir):
+def test_single_page_inline_image(eight_by_eight, outdir):
     filename = outdir / 'image-mono-inline.pdf'
     pdf = Canvas(str(filename), pagesize=(8 * 72, 6 * 72))
 
-    im = Image.new('1', (8, 8), 0)
-    for n in range(8):
-        im.putpixel((n, n), 1)
-
     # Draw image in a 72x72 pt or 1"x1" area
-    pdf.drawInlineImage(im, 0, 0, width=72, height=72)
+    pdf.drawInlineImage(eight_by_eight, 0, 0, width=72, height=72)
     pdf.showPage()
     pdf.save()
 
@@ -179,3 +185,18 @@ def test_stack_abuse():
     with pytest.warns(None):
         with pytest.raises(RuntimeError):
             pdfinfo.info._interpret_contents(stream)
+
+
+def test_pages_issue700(monkeypatch, resources):
+    def get_no_pages(*args, **kwargs):
+        return iter([])
+
+    monkeypatch.setattr(PDFPage, 'get_pages', get_no_pages)
+
+    with pytest.raises(InputFileError, match="pdfminer"):
+        pdfinfo.PdfInfo(
+            resources / 'cardinal.pdf',
+            detailed_analysis=True,
+            progbar=False,
+            max_workers=1,
+        )

tests/test_pipeline.py

@@ -0,0 +1,63 @@
+# © 2021 James R. Barlow: github.com/jbarlow83
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+from unittest.mock import Mock
+
+import pytest
+from PIL import Image
+from reportlab.lib.units import inch
+from reportlab.lib.utils import ImageReader
+from reportlab.pdfgen.canvas import Canvas
+
+from ocrmypdf import _pipeline, pdfinfo
+from ocrmypdf.helpers import Resolution
+
+
+@pytest.fixture(scope='session')
+def rgb_image():
+    im = Image.new('RGB', (8, 8))
+    im.putpixel((4, 4), (255, 0, 0))
+    im.putpixel((5, 5), (0, 255, 0))
+    im.putpixel((6, 6), (0, 0, 255))
+    return ImageReader(im)
+
+
+DUMMY_OVERSAMPLE_RESOLUTION = Resolution(42.0, 42.0)
+VECTOR_RESOLUTION = Resolution(_pipeline.VECTOR_PAGE_DPI, _pipeline.VECTOR_PAGE_DPI)
+
+
+@pytest.mark.parametrize(
+    'image, text, vector, result',
+    [
+        (False, False, False, VECTOR_RESOLUTION),
+        (False, True, False, VECTOR_RESOLUTION),
+        (True, False, False, DUMMY_OVERSAMPLE_RESOLUTION),
+        (True, True, False, VECTOR_RESOLUTION),
+        (False, False, True, VECTOR_RESOLUTION),
+        (False, True, True, VECTOR_RESOLUTION),
+        (True, False, True, VECTOR_RESOLUTION),
+        (True, True, True, VECTOR_RESOLUTION),
+    ],
+)
+def test_dpi_needed(image, text, vector, result, rgb_image, outdir):
+
+    c = Canvas(str(outdir / 'dpi.pdf'), pagesize=(5 * inch, 5 * inch))
+    if image:
+        c.drawImage(rgb_image, 1 * inch, 1 * inch, width=1 * inch, height=1 * inch)
+    if text:
+        c.drawString(1 * inch, 4 * inch, "Actual text")
+    if vector:
+        c.ellipse(3 * inch, 3 * inch, 4 * inch, 4 * inch)
+    c.showPage()
+    c.save()
+
+    mock = Mock()
+    mock.oversample = DUMMY_OVERSAMPLE_RESOLUTION[0]
+
+    pi = pdfinfo.PdfInfo(outdir / 'dpi.pdf')
+
+    assert _pipeline.get_canvas_square_dpi(pi[0], mock) == result
+    assert _pipeline.get_page_square_dpi(pi[0], mock) == result

tests/test_tesseract.py

@@ -45,7 +45,8 @@ def test_skip_pages_does_not_replicate(resources, basename, outdir):
         assert len(page.images) == 1, "skipped page was replicated"
 
     for n, info_out_n in enumerate(info):
-        assert info_out_n.width_inches == info_in[n].width_inches
+        assert info_out_n.width_inches == info_in[n].width_inches, "output resized"
+        assert info_out_n.height_inches == info_in[n].height_inches, "output resized"
 
 
 def test_content_preservation(resources, outpdf):