pdf2image

https://pdf2image.readthedocs.io/en/latest/
Admin
A Python module that converts PDF files into images using the pdftoppm and pdftocairo utilities from...
Tokens:13,713
Snippets:71
Trust Score:9.6
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install pdf2image from source

Source: https://pdf2image.readthedocs.io/en/latest/installation.html

Clones the official pdf2image repository and installs the package from source using setup.py.

```bash
git clone https://github.com/Belval/pdf2image
```

```bash
python3 setup.py install
```

--------------------------------

### Install poppler on macOS

Source: https://pdf2image.readthedocs.io/en/latest/installation.html

Installs poppler on macOS using Homebrew.

```bash
brew install poppler
```

--------------------------------

### Install pdf2image with pip

Source: https://pdf2image.readthedocs.io/en/latest/installation.html

Installs the pdf2image package from PyPI using pip.

```bash
pip install pdf2image
```

--------------------------------

### Install poppler on Ubuntu

Source: https://pdf2image.readthedocs.io/en/latest/installation.html

Installs poppler-utils on Ubuntu, which provides the pdftoppm command required by pdf2image.

```bash
sudo apt-get install poppler-utils
```

--------------------------------

### Install poppler on Arch Linux

Source: https://pdf2image.readthedocs.io/en/latest/installation.html

Installs poppler on Arch Linux using pacman.

```bash
sudo pacman -S poppler
```

--------------------------------

### pdf2image conversion setup: path normalization, format parsing, and Poppler version check

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

This snippet shows the initial setup for converting a PDF to images: normalizing Path objects to strings, retrieving the page count, parsing the output format, and determining whether pdftocairo or pdftoppm is needed. It also fetches the Poppler version to decide which tool to use.

```python
    # We make sure that if passed arguments are Path objects, they're converted to strings
    if isinstance(pdf_path, PurePath):
        pdf_path = pdf_path.as_posix()

    if isinstance(output_folder, PurePath):
        output_folder = output_folder.as_posix()

    if isinstance(poppler_path, PurePath):
        poppler_path = poppler_path.as_posix()

    page_count = pdfinfo_from_path(
        pdf_path, userpw, ownerpw, poppler_path=poppler_path
    )["Pages"]

    # We start by getting the output format, the buffer processing function and if we need pdftocairo
    parsed_fmt, final_extension, parse_buffer_func, use_pdfcairo_format = _parse_format(
        fmt, grayscale
    )

    # We use pdftocairo is the format requires it OR we need a transparent output
    use_pdfcairo = (
        use_pdftocairo
        or use_pdfcairo_format
        or (transparent and parsed_fmt in TRANSPARENT_FILE_TYPES)
    )

    poppler_version_major, poppler_version_minor = _get_poppler_version(
        
```

--------------------------------

### pdfinfo_from_bytes: get PDF info from bytes

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Wraps pdfinfo_from_path for PDF bytes input by writing them to a temporary file, calling pdfinfo_from_path, and cleaning up the temp file in a finally block. Accepts the same password, poppler path, rawdates, and timeout parameters.

```python
[docs]def pdfinfo_from_bytes(
    pdf_bytes: bytes,
    userpw: str = None,
    ownerpw: str = None,
    poppler_path: str = None,
    rawdates: bool = False,
    timeout: int = None,
) -> Dict:
    """Function wrapping poppler's pdfinfo utility and returns the result as a dictionary.

    :param pdf_bytes: Bytes of the PDF that you want to convert
    :type pdf_bytes: bytes
    :param userpw: PDF's password, defaults to None
    :type userpw: str, optional
    :param ownerpw: PDF's owner password, defaults to None
    :type ownerpw: str, optional
    :param poppler_path: Path to look for poppler binaries, defaults to None
    :type poppler_path: Union[str, PurePath], optional
    :param rawdates: Return the undecoded data strings, defaults to False
    :type rawdates: bool, optional
    :param timeout: Raise PDFPopplerTimeoutError after the given time, defaults to None
    :type timeout: int, optional
    :return: Dictionary containing various information on the PDF
    :rtype: Dict
    """
    fh, temp_filename = tempfile.mkstemp()
    try:
        with open(temp_filename, "wb") as f:
            f.write(pdf_bytes)
            f.flush()
        return pdfinfo_from_path(
            temp_filename,
            userpw=userpw,
            ownerpw=ownerpw,
            poppler_path=poppler_path,
            rawdates=rawdates,
            timeout=timeout,
        )
    finally:
        os.close(fh)
        os.remove(temp_filename)
```

--------------------------------

### pdfinfo_from_path: get PDF info from file path

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Wraps poppler's pdfinfo utility to return PDF metadata as a dictionary. Supports user/owner passwords, raw dates, a custom poppler path (also added to LD_LIBRARY_PATH), and a timeout that raises PDFPopplerTimeoutError. Raises PDFInfoNotInstalledError on OSError and PDFPageCountError if the output cannot be parsed.

```python
[docs]def pdfinfo_from_path(
    pdf_path: str,
    userpw: str = None,
    ownerpw: str = None,
    poppler_path: str = None,
    rawdates: bool = False,
    timeout: int = None,
) -> Dict:
    """Function wrapping poppler's pdfinfo utility and returns the result as a dictionary.

    :param pdf_path: Path to the PDF that you want to convert
    :type pdf_path: str
    :param userpw: PDF's password, defaults to None
    :type userpw: str, optional
    :param ownerpw: PDF's owner password, defaults to None
    :type ownerpw: str, optional
    :param poppler_path: Path to look for poppler binaries, defaults to None
    :type poppler_path: Union[str, PurePath], optional
    :param rawdates: Return the undecoded data strings, defaults to False
    :type rawdates: bool, optional
    :param timeout: Raise PDFPopplerTimeoutError after the given time, defaults to None
    :type timeout: int, optional
    :raises PDFPopplerTimeoutError: Raised after the timeout for the image processing is exceeded
    :raises PDFInfoNotInstalledError: Raised if pdfinfo is not installed
    :raises PDFPageCountError: Raised if the output could not be parsed
    :return: Dictionary containing various information on the PDF
    :rtype: Dict
    """
    try:
        command = [_get_command_path("pdfinfo", poppler_path), pdf_path]

        if userpw is not None:
            command.extend(["-upw", userpw])

        if ownerpw is not None:
            command.extend(["-opw", ownerpw])

        if rawdates:
            command.extend(["-rawdates"])

        # Add poppler path to LD_LIBRARY_PATH
        env = os.environ.copy()
        if poppler_path is not None:
            env["LD_LIBRARY_PATH"] = poppler_path + ":" + env.get("LD_LIBRARY_PATH", "")
        proc = Popen(command, env=env, stdout=PIPE, stderr=PIPE)

        try:
            out, err = proc.communicate(timeout=timeout)
        except TimeoutExpired:
            proc.kill()
            outs, errs = proc.communicate()
            raise PDFPopplerTimeoutError("Run poppler poppler timeout.")

        d = {}
        for field in out.decode("utf8", "ignore").split("\n"):
            sf = field.split(":")
            key, value = sf[0], ":".join(sf[1:])
            if key != "":
                d[key] = (
                    int(value.strip())
                    if key in PDFINFO_CONVERT_TO_INT
                    else value.strip()
                )

        if "Pages" not in d:
            raise ValueError

        return d

    except OSError:
        raise PDFInfoNotInstalledError(
            "Unable to get page count. Is poppler installed and in PATH?"
        )
    except ValueError:
        raise PDFPageCountError(
            f"Unable to get page count.\n{err.decode('utf8', 'ignore')}"
        )
```

--------------------------------

### string

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

string

```string
string
```

--------------------------------

### _build_command: construct poppler command arguments

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Builds the command-line arguments for the poppler tool. Appends flags like -cropbox, -hide-annotations, -transp, -f, -l, -singlefile, -upw, -opw, -gray, and scale options based on the provided parameters. Raises ValueError if size is not a tuple or an integer.

```python
def _build_command(
    args: List,
    output_folder: str,
    first_page: int,
    last_page: int,
    fmt: str,
    jpegopt: Dict,
    output_file: str,
    userpw: str,
    ownerpw: str,
    use_cropbox: bool,
    transparent: bool,
    single_file: bool,
    grayscale: bool,
    size: Union[int, Tuple[int, int]],
    hide_annotations: bool,
) -> List[str]:
    if use_cropbox:
        args.append("-cropbox")

    if hide_annotations:
        args.append("-hide-annotations")

    if transparent and fmt in TRANSPARENT_FILE_TYPES:
        args.append("-transp")

    if first_page is not None:
        args.extend(["-f", str(first_page)])

    if last_page is not None:
        args.extend(["-l", str(last_page)])

    if fmt not in ["pgm", "ppm"]:
        args.append("-" + fmt)

    if fmt in ["jpeg", "jpg"] and jpegopt:
        args.extend(["-jpegopt", _parse_jpegopt(jpegopt)])

    if single_file:
        args.append("-singlefile")

    if output_folder is not None:
        args.append(os.path.join(output_folder, output_file))

    if userpw is not None:
        args.extend(["-upw", userpw])

    if ownerpw is not None:
        args.extend(["-opw", ownerpw])

    if grayscale:
        args.append("-gray")

    if size is None:
        pass
    elif isinstance(size, tuple) and len(size) == 2:
        if size[0] is not None:
            args.extend(["-scale-to-x", str(int(size[0]))])
        else:
            args.extend(["-scale-to-x", str(-1)])
        if size[1] is not None:
            args.extend(["-scale-to-y", str(int(size[1]))])
        else:
            args.extend(["-scale-to-y", str(-1)])
    elif isinstance(size, tuple) and len(size) == 1:
        args.extend(["-scale-to", str(int(size[0]))])
    elif isinstance(size, int) or isinstance(size, float):
        args.extend(["-scale-to", str(int(size))])
    else:
        raise ValueError(f"Size {size} is not a tuple or an integer")

    return args
```

--------------------------------

### Convert PDF to images with output_folder

Source: https://pdf2image.readthedocs.io/en/latest/overview.html

Use an output_folder with a temporary directory to avoid holding images in memory. Pillow loads the images on demand from the folder.

```python
import tempfile

from pdf2image import convert_from_path


with tempfile.TemporaryDirectory() as path:
    images_from_path = convert_from_path("/home/user/example.pdf", output_folder=path)

```

--------------------------------

### pdf2image module imports and convert_from_path function definition

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

The module imports the required standard library, Pillow, and internal pdf2image modules, then defines constants for transparent file types and PDF info conversion. The convert_from_path function is the main entry point that wraps pdftoppm and pdftocairo, with many optional parameters controlling DPI, output format, page range, threading, passwords, and more. It raises NotImplementedError for conflicting parameters (e.g., hide_annotations with pdftocairo), PDFPopplerTimeoutError on timeout, and PDFSyntaxError when strict is True.

```python
"""
    pdf2image is a light wrapper for the poppler-utils tools that can convert your
    PDFs into Pillow images.
"""

import os
import platform
import tempfile
import types
import shutil
import subprocess
from subprocess import Popen, PIPE, TimeoutExpired
from typing import Any, Union, Tuple, List, Dict, Callable
from pathlib import PurePath
from PIL import Image

from pdf2image.generators import uuid_generator, counter_generator, ThreadSafeGenerator

from pdf2image.parsers import (
    parse_buffer_to_pgm,
    parse_buffer_to_ppm,
    parse_buffer_to_jpeg,
    parse_buffer_to_png,
)

from pdf2image.exceptions import (
    PDFInfoNotInstalledError,
    PDFPageCountError,
    PDFSyntaxError,
    PDFPopplerTimeoutError,
)

TRANSPARENT_FILE_TYPES = ["png", "tiff"]
PDFINFO_CONVERT_TO_INT = ["Pages"]
```

```python
[docs]def convert_from_path(
    pdf_path: Union[str, PurePath],
    dpi: int = 200,
    output_folder: Union[str, PurePath] = None,
    first_page: int = None,
    last_page: int = None,
    fmt: str = "ppm",
    jpegopt: Dict = None,
    thread_count: int = 1,
    userpw: str = None,
    ownerpw: str = None,
    use_cropbox: bool = False,
    strict: bool = False,
    transparent: bool = False,
    single_file: bool = False,
    output_file: Any = uuid_generator(),
    poppler_path: Union[str, PurePath] = None,
    grayscale: bool = False,
    size: Union[Tuple, int] = None,
    paths_only: bool = False,
    use_pdftocairo: bool = False,
    timeout: int = None,
    hide_annotations: bool = False,
) -> List[Image.Image]:
    """Function wrapping pdftoppm and pdftocairo

    :param pdf_path: Path to the PDF that you want to convert
    :type pdf_path: Union[str, PurePath]
    :param dpi: Image quality in DPI (default 200), defaults to 200
    :type dpi: int, optional
    :param output_folder: Write the resulting images to a folder (instead of directly in memory), defaults to None
    :type output_folder: Union[str, PurePath], optional
    :param first_page: First page to process, defaults to None
    :type first_page: int, optional
    :param last_page: Last page to process before stopping, defaults to None
    :type last_page: int, optional
    :param fmt: Output image format, defaults to "ppm"
    :type fmt: str, optional
    :param jpegopt: jpeg options `quality`, `progressive`, and `optimize` (only for jpeg format), defaults to None
    :type jpegopt: Dict, optional
    :param thread_count: How many threads we are allowed to spawn for processing, defaults to 1
    :type thread_count: int, optional
    :param userpw: PDF's password, defaults to None
    :type userpw: str, optional
    :param ownerpw: PDF's owner password, defaults to None
    :type ownerpw: str, optional
    :param use_cropbox: Use cropbox instead of mediabox, defaults to False
    :type use_cropbox: bool, optional
    :param strict: When a Syntax Error is thrown, it will be raised as an Exception, defaults to False
    :type strict: bool, optional
    :param transparent: Output with a transparent background instead of a white one, defaults to False
    :type transparent: bool, optional
    :param single_file: Uses the -singlefile option from pdftoppm/pdftocairo, defaults to False
    :type single_file: bool, optional
    :param output_file: What is the output filename or generator, defaults to uuid_generator()
    :type output_file: Any, optional
    :param poppler_path: Path to look for poppler binaries, defaults to None
    :type poppler_path: Union[str, PurePath], optional
    :param grayscale: Output grayscale image(s), defaults to False
    :type grayscale: bool, optional
    :param size: Size of the resulting image(s), uses the Pillow (width, height) standard, defaults to None
    :type size: Union[Tuple, int], optional
    :param paths_only: Don't load image(s), return paths instead (requires output_folder), defaults to False
    :type paths_only: bool, optional
    :param use_pdftocairo: Use pdftocairo instead of pdftoppm, may help performance, defaults to False
    :type use_pdftocairo: bool, optional
    :param timeout: Raise PDFPopplerTimeoutError after the given time, defaults to None
    :type timeout: int, optional
    :param hide_annotations: Hide PDF annotations in the output, defaults to False
    :type hide_annotations: bool, optional
    :raises NotImplementedError: Raised when conflicting parameters are given (hide_annotations for pdftocairo)
    :raises PDFPopplerTimeoutError: Raised after the timeout for the image processing is exceeded
    :raises PDFSyntaxError: Raised if there is a syntax error in the PDF and strict=True
    :return: A list of Pillow images, one for each page between first_page and last_page
    :rtype: List[Image.Image]
    """

    if use_pdftocairo and fmt == "ppm":
        fmt = "png"
```

--------------------------------

### _get_command_path: resolve poppler command path

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Returns the full path to a poppler command, appending '.exe' on Windows and joining with poppler_path if provided.

```python
def _get_command_path(command: str, poppler_path: str = None) -> str:
    if platform.system() == "Windows":
        command = command + ".exe"

    if poppler_path is not None:
        command = os.path.join(poppler_path, command)

    return command
```

--------------------------------

### _get_poppler_version: run poppler -v

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Runs the poppler command with '-v' to retrieve its version. Sets LD_LIBRARY_PATH when poppler_path is given. Raises PDFPopplerTimeoutError if the command times out.

```python
def _get_poppler_version(
    command: str, poppler_path: str = None, timeout: int = None
) -> Tuple[int, int]:
    command = [_get_command_path(command, poppler_path), "-v"]

    env = os.environ.copy()
    if poppler_path is not None:
        env["LD_LIBRARY_PATH"] = poppler_path + ":" + env.get("LD_LIBRARY_PATH", "")
    proc = Popen(command, env=env, stdout=PIPE, stderr=PIPE)

    try:
        data, err = proc.communicate(timeout=timeout)
    except TimeoutExpired:
        proc.kill()
        outs, errs = proc.communicate()
        raise PDFPopplerTimeoutError("Run poppler poppler timeout.")
```

--------------------------------

### Convert PDF to JPEG format

Source: https://pdf2image.readthedocs.io/en/latest/overview.html

Set the output format to JPEG using the fmt parameter. The default is PPM, which is uncompressed and large.

```python
images_from_path = convert_from_path("/home/user/example.pdf", fmt="jpeg")
```

--------------------------------

### parse_buffer_to_pgm: Parse PGM buffer to Pillow Images

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/parsers.html

Parses PGM file bytes from pdftoppm/pdftocairo into a list of Pillow Images. Similar to PPM but uses a single-byte grayscale value, so the file size calculation does not multiply by 3.

```python
def parse_buffer_to_pgm(data: bytes) -> List[Image.Image]:
    """Parse PGM file bytes to Pillow Image

    :param data: pdftoppm/pdftocairo output bytes
    :type data: bytes
    :return: List of PGM images parsed from the output
    :rtype: List[Image.Image]
    """

    images = []

    index = 0

    while index < len(data):
        code, size, maxval = tuple(data[index : index + 40].split(b"\n")[0:3])
        size_x, size_y = tuple(size.split(b" "))
        file_size = len(code) + len(size) + len(maxval) + 3 + int(size_x) * int(size_y)
        images.append(Image.open(BytesIO(data[index : index + file_size])))
        index += file_size

    return images
```

--------------------------------

### parse_buffer_to_ppm: Parse PPM buffer to Pillow Images

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/parsers.html

Parses PPM file bytes from pdftoppm/pdftocairo into a list of Pillow Images. It reads the header (code, size, rgb) and calculates the file size based on dimensions, then extracts each image sequentially.

```python
def parse_buffer_to_ppm(data: bytes) -> List[Image.Image]:
    """Parse PPM file bytes to Pillow Image

    :param data: pdftoppm/pdftocairo output bytes
    :type data: bytes
    :return: List of PPM images parsed from the output
    :rtype: List[Image.Image]
    """

    images = []

    index = 0

    while index < len(data):
        code, size, rgb = tuple(data[index : index + 40].split(b"\n")[0:3])
        size_x, size_y = tuple(size.split(b" "))
        file_size = len(code) + len(size) + len(rgb) + 3 + int(size_x) * int(size_y) * 3
        images.append(Image.open(BytesIO(data[index : index + file_size])))
        index += file_size

    return images
```

--------------------------------

### Write PDF to temp file and call convert_from_path

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Writes a PDF file to a temporary file and calls convert_from_path with all conversion options. The temporary file is always closed and removed in the finally block.

```python
fh, temp_filename = tempfile.mkstemp()
try:
    with open(temp_filename, "wb") as f:
        f.write(pdf_file)
        f.flush()
        return convert_from_path(
            f.name,
            dpi=dpi,
            output_folder=output_folder,
            first_page=first_page,
            last_page=last_page,
            fmt=fmt,
            jpegopt=jpegopt,
            thread_count=thread_count,
            userpw=userpw,
            ownerpw=ownerpw,
            use_cropbox=use_cropbox,
            strict=strict,
            transparent=transparent,
            single_file=single_file,
            output_file=output_file,
            poppler_path=poppler_path,
            grayscale=grayscale,
            size=size,
            paths_only=paths_only,
            use_pdftocairo=use_pdftocairo,
            timeout=timeout,
            hide_annotations=hide_annotations,
        )
finally:
    os.close(fh)
    os.remove(temp_filename)
```

--------------------------------

### _parse_format: normalize output format

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Normalizes the output format string and returns a tuple with the format name, extension, buffer parser, and a flag indicating whether the format is multi-page. Falls back to ppm when the format is unrecognized.

```python
def _parse_format(fmt: str, grayscale: bool = False) -> Tuple[str, str, Callable, bool]:
    fmt = fmt.lower()
    if fmt[0] == ".":
        fmt = fmt[1:]
    if fmt in ("jpeg", "jpg"):
        return "jpeg", "jpg", parse_buffer_to_jpeg, False
    if fmt == "png":
        return "png", "png", parse_buffer_to_png, False
    if fmt in ("tif", "tiff"):
        return "tiff", "tif", None, True
    if fmt == "ppm" and grayscale:
        return "pgm", "pgm", parse_buffer_to_pgm, False
    # Unable to parse the format so we'll use the default
    return "ppm", "ppm", parse_buffer_to_ppm, False
```

--------------------------------

### Convert PDF to images with pdf2image

Source: https://pdf2image.readthedocs.io/en/latest/overview.html

Basic usage converting a PDF from a file path or from bytes. Be mindful that the images are held in memory, which can exhaust resources with large PDFs.

```python
from pdf2image import convert_from_path, convert_from_bytes

images = convert_from_path("/home/user/example.pdf")

# OR

with open("/home/user/example.pdf") as pdf:
    images = convert_from_bytes(pdf.read())

```

--------------------------------

### convert_from_path

Source: https://pdf2image.readthedocs.io/en/latest/reference.html

Converts a PDF file to a list of Pillow images. Supports various options for DPI, output format, page ranges, and more.

```APIDOC
## convert_from_path

### Description
Function wrapping pdftoppm and pdftocairo. Converts a PDF file to a list of Pillow images, one for each page between first_page and last_page.

### Method
Function call

### Endpoint
pdf2image.pdf2image.convert_from_path

### Parameters
#### Path Parameters
- **pdf_path** (Union[str, PurePath]) - Required - Path to the PDF that you want to convert

#### Optional Parameters
- **dpi** (int, optional) - Image quality in DPI (default 200), defaults to 200
- **output_folder** (Union[str, PurePath], optional) - Write the resulting images to a folder (instead of directly in memory), defaults to None
- **first_page** (int, optional) - First page to process, defaults to None
- **last_page** (int, optional) - Last page to process before stopping, defaults to None
- **fmt** (str, optional) - Output image format, defaults to "ppm"
- **jpegopt** (Dict, optional) - jpeg options quality, progressive, and optimize (only for jpeg format), defaults to None
- **thread_count** (int, optional) - How many threads we are allowed to spawn for processing, defaults to 1
- **userpw** (str, optional) - PDF's password, defaults to None
- **ownerpw** (str, optional) - PDF's owner password, defaults to None
- **use_cropbox** (bool, optional) - Use cropbox instead of mediabox, defaults to False
- **strict** (bool, optional) - When a Syntax Error is thrown, it will be raised as an Exception, defaults to False
- **transparent** (bool, optional) - Output with a transparent background instead of a white one, defaults to False
- **single_file** (bool, optional) - Uses the -singlefile option from pdftoppm/pdftocairo, defaults to False
- **output_file** (Any, optional) - What is the output filename or generator, defaults to uuid_generator()
- **poppler_path** (Union[str, PurePath], optional) - Path to look for poppler binaries, defaults to None
- **grayscale** (bool, optional) - Output grayscale image(s), defaults to False
- **size** (Union[Tuple, int], optional) - Size of the resulting image(s), uses the Pillow (width, height) standard, defaults to None
- **paths_only** (bool, optional) - Don't load image(s), return paths instead (requires output_folder), defaults to False
- **use_pdftocairo** (bool, optional) - Use pdftocairo instead of pdftoppm, may help performance, defaults to False
- **timeout** (int, optional) - Raise PDFPopplerTimeoutError after the given time, defaults to None
- **hide_annotations** (bool, optional) - Hide PDF annotations in the output, defaults to False

### Returns
A list of Pillow images, one for each page between first_page and last_page

### Return Type
List[Image.Image]

### Raises
- **NotImplementedError** - Raised when conflicting parameters are given (hide_annotations for pdftocairo)
- **PDFPopplerTimeoutError** - Raised after the timeout for the image processing is exceeded
- **PDFSyntaxError** - Raised if there is a syntax error in the PDF and strict=True
```

--------------------------------

### parse_buffer_to_ppm

Source: https://pdf2image.readthedocs.io/en/latest/reference.html

Parses PPM file bytes into a list of Pillow Image objects.

```APIDOC
## parse_buffer_to_ppm(data: bytes) -> List[Image]

### Description
Parse PPM file bytes to Pillow Image.

### Method
Function call

### Endpoint
pdf2image.parsers.parse_buffer_to_ppm

### Parameters
- **data** (bytes) - Required - pdftoppm/pdftocairo output bytes

### Returns
List of PPM images parsed from the output

### Return Type
List[Image.Image]
```

--------------------------------

### parse_buffer_to_png: Parse PNG buffer to Pillow Images

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/parsers.html

Parses PNG file bytes from pdftoppm/pdftocairo into a list of Pillow Images. It scans for the IEND chunk, ensuring it is the actual end by checking for the PNG signature or end-of-data, and extracts each image.

```python
def parse_buffer_to_png(data: bytes) -> List[Image.Image]:
    """Parse PNG file bytes to Pillow Image

    :param data: pdftoppm/pdftocairo output bytes
    :type data: bytes
    :return: List of PNG images parsed from the output
    :rtype: List[Image.Image]
    """

    images = []

    c1 = 0
    c2 = 0
    data_len = len(data)
    while c1 < data_len:
        # IEND can appear in a PNG without being the actual end
        if data[c2 : c2 + 4] == b"IEND" and (
            c2 + 8 == data_len or data[c2 + 9 : c2 + 12] == b"PNG"
        ):
            images.append(Image.open(BytesIO(data[c1 : c2 + 8])))
            c1 = c2 + 8
            c2 = c1
        c2 += 1

    return images
```

--------------------------------

### pdf2image._load_from_output_folder function

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Loads images from an output folder, optionally returning paths or in-memory images. It filters files by prefix and extension, and loads image data if in_memory is True.

```python
def _load_from_output_folder(
    output_folder: str,
    output_file: str,
    ext: str,
    paths_only: bool,
    in_memory: bool = False,
) -> List[Image.Image]:
    images = []
    for f in sorted(os.listdir(output_folder)):
        if f.startswith(output_file) and f.split(".")[-1] == ext:
            if paths_only:
                images.append(os.path.join(output_folder, f))
            else:
                images.append(Image.open(os.path.join(output_folder, f)))
                if in_memory:
                    images[-1].load()
    return images
```

--------------------------------

### parse_buffer_to_pgm

Source: https://pdf2image.readthedocs.io/en/latest/reference.html

Parses PGM file bytes into a list of Pillow Image objects.

```APIDOC
## parse_buffer_to_pgm(data: bytes) -> List[Image]

### Description
Parse PGM file bytes to Pillow Image.

### Method
Function call

### Endpoint
pdf2image.parsers.parse_buffer_to_pgm

### Parameters
- **data** (bytes) - Required - pdftoppm/pdftocairo output bytes

### Returns
List of PGM images parsed from the output

### Return Type
List[Image.Image]
```

--------------------------------

### parse_buffer_to_jpeg: Parse JPEG buffer to Pillow Images

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/parsers.html

Parses JPEG file bytes from pdftoppm/pdftocairo into a list of Pillow Images. It splits the data on the JPEG end marker (\xff\xd9) and appends the marker back to each image.

```python
def parse_buffer_to_jpeg(data: bytes) -> List[Image.Image]:
    """Parse JPEG file bytes to Pillow Image

    :param data: pdftoppm/pdftocairo output bytes
    :type data: bytes
    :return: List of JPEG images parsed from the output
    :rtype: List[Image.Image]
    """

    return [
        Image.open(BytesIO(image_data + b"\xff\xd9"))
        for image_data in data.split(b"\xff\xd9")[
            :-1
        ]  # Last element is obviously empty
    ]
```

--------------------------------

### pdfinfo_from_bytes

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Retrieves PDF metadata from a bytes object by writing it to a temporary file and calling pdfinfo_from_path. Returns a dictionary with PDF information, supporting optional passwords, poppler path, raw dates, and timeout.

```APIDOC
## pdfinfo_from_bytes

### Description
Function wrapping poppler's pdfinfo utility and returns the result as a dictionary.

### Method
Function call

### Endpoint
pdfinfo_from_bytes(pdf_bytes, userpw=None, ownerpw=None, poppler_path=None, rawdates=False, timeout=None)

### Parameters
- **pdf_bytes** (bytes) - Required - Bytes of the PDF that you want to convert
- **userpw** (str, optional) - PDF's password, defaults to None
- **ownerpw** (str, optional) - PDF's owner password, defaults to None
- **poppler_path** (Union[str, PurePath], optional) - Path to look for poppler binaries, defaults to None
- **rawdates** (bool, optional) - Return the undecoded data strings, defaults to False
- **timeout** (int, optional) - Raise PDFPopplerTimeoutError after the given time, defaults to None

### Return Value
- **Dict** - Dictionary containing various information on the PDF
```

--------------------------------

### convert_from_bytes

Source: https://pdf2image.readthedocs.io/en/latest/reference.html

Converts PDF bytes into a list of Pillow images. This function wraps pdftoppm and pdftocairo and supports various options for image quality, page selection, output format, and processing behavior.

```APIDOC
## convert_from_bytes

### Description
Converts PDF bytes into a list of Pillow images. This function wraps pdftoppm and pdftocairo and supports various options for image quality, page selection, output format, and processing behavior.

### Method
Function call

### Endpoint
pdf2image.pdf2image.convert_from_bytes

### Parameters
#### Function Parameters
- **pdf_bytes** (bytes) - Required - Bytes of the PDF that you want to convert
- **dpi** (int, optional) - Image quality in DPI (default 200), defaults to 200
- **output_folder** (Union[str, PurePath], optional) - Write the resulting images to a folder (instead of directly in memory), defaults to None
- **first_page** (int, optional) - First page to process, defaults to None
- **last_page** (int, optional) - Last page to process before stopping, defaults to None
- **fmt** (str, optional) - Output image format, defaults to "ppm"
- **jpegopt** (Dict, optional) - jpeg options quality, progressive, and optimize (only for jpeg format), defaults to None
- **thread_count** (int, optional) - How many threads we are allowed to spawn for processing, defaults to 1
- **userpw** (str, optional) - PDF's password, defaults to None
- **ownerpw** (str, optional) - PDF's owner password, defaults to None
- **use_cropbox** (bool, optional) - Use cropbox instead of mediabox, defaults to False
- **strict** (bool, optional) - When a Syntax Error is thrown, it will be raised as an Exception, defaults to False
- **transparent** (bool, optional) - Output with a transparent background instead of a white one, defaults to False
- **single_file** (bool, optional) - Uses the -singlefile option from pdftoppm/pdftocairo, defaults to False
- **output_file** (Any, optional) - What is the output filename or generator, defaults to uuid_generator()
- **poppler_path** (Union[str, PurePath], optional) - Path to look for poppler binaries, defaults to None
- **grayscale** (bool, optional) - Output grayscale image(s), defaults to False
- **size** (Union[Tuple, int], optional) - Size of the resulting image(s), uses the Pillow (width, height) standard, defaults to None
- **paths_only** (bool, optional) - Don't load image(s), return paths instead (requires output_folder), defaults to False
- **use_pdftocairo** (bool, optional) - Use pdftocairo instead of pdftoppm, may help performance, defaults to False
- **timeout** (int, optional) - Raise PDFPopplerTimeoutError after the given time, defaults to None
- **hide_annotations** (bool, optional) - Hide PDF annotations in the output, defaults to False

### Raises
- **NotImplementedError** - Raised when conflicting parameters are given (hide_annotations for pdftocairo)
- **PDFPopplerTimeoutError** - Raised after the timeout for the image processing is exceeded
- **PDFSyntaxError** - Raised if there is a syntax error in the PDF and strict=True

### Returns
A list of Pillow images, one for each page between first_page and last_page

### Return Type
List[Image.Image]
```

--------------------------------

### parse_buffer_to_png

Source: https://pdf2image.readthedocs.io/en/latest/reference.html

Parses PNG file bytes into a list of Pillow Image objects.

```APIDOC
## parse_buffer_to_png(data: bytes) -> List[Image]

### Description
Parse PNG file bytes to Pillow Image.

### Method
Function call

### Endpoint
pdf2image.parsers.parse_buffer_to_png

### Parameters
- **data** (bytes) - Required - pdftoppm/pdftocairo output bytes

### Returns
List of PNG images parsed from the output

### Return Type
List[Image.Image]
```

--------------------------------

### pdfinfo_from_path

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Retrieves PDF metadata from a file path using the poppler pdfinfo utility. Returns a dictionary with information such as page count, and supports optional passwords, poppler path, raw dates, and timeout.

```APIDOC
## pdfinfo_from_path

### Description
Function wrapping poppler's pdfinfo utility and returns the result as a dictionary.

### Method
Function call

### Endpoint
pdfinfo_from_path(pdf_path, userpw=None, ownerpw=None, poppler_path=None, rawdates=False, timeout=None)

### Parameters
- **pdf_path** (str) - Required - Path to the PDF that you want to convert
- **userpw** (str, optional) - PDF's password, defaults to None
- **ownerpw** (str, optional) - PDF's owner password, defaults to None
- **poppler_path** (Union[str, PurePath], optional) - Path to look for poppler binaries, defaults to None
- **rawdates** (bool, optional) - Return the undecoded data strings, defaults to False
- **timeout** (int, optional) - Raise PDFPopplerTimeoutError after the given time, defaults to None

### Return Value
- **Dict** - Dictionary containing various information on the PDF

### Exceptions
- **PDFPopplerTimeoutError** - Raised after the timeout for the image processing is exceeded
- **PDFInfoNotInstalledError** - Raised if pdfinfo is not installed
- **PDFPageCountError** - Raised if the output could not be parsed
```

--------------------------------

### _parse_jpegopt: convert dict to jpegopt string

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Converts a dictionary of JPEG options into a comma-separated string of key=value pairs. Boolean values are converted to 'y' or 'n'.

```python
def _parse_jpegopt(jpegopt: Dict) -> str:
    parts = []
    for k, v in jpegopt.items():
        if v is True:
            v = "y"
        if v is False:
            v = "n"
        parts.append("{}={}".format(k, v))
    return ",".join(parts)
```

--------------------------------

### parse_buffer_to_jpeg

Source: https://pdf2image.readthedocs.io/en/latest/reference.html

Parses JPEG file bytes into a list of Pillow Image objects.

```APIDOC
## parse_buffer_to_jpeg(data: bytes) -> List[Image]

### Description
Parse JPEG file bytes to Pillow Image.

### Method
Function call

### Endpoint
pdf2image.parsers.parse_buffer_to_jpeg

### Parameters
- **data** (bytes) - Required - pdftoppm/pdftocairo output bytes

### Returns
List of JPEG images parsed from the output

### Return Type
List[Image.Image]
```

--------------------------------

### Parse poppler version from error message

Source: https://pdf2image.readthedocs.io/en/latest/_modules/pdf2image/pdf2image.html

Parses the poppler version from an error message, returning a tuple of major and minor version integers. Falls back to (0, 17) on any parsing failure, which is the lowest version that includes pdftocairo (2011).

```python
    try:
        # TODO: Make this more robust
        version = err.decode("utf8", "ignore").split("\n")[0].split(" ")[-1].split(".")
        return int(version[0]), int(version[1])
    except:
        # Lowest version that includes pdftocairo (2011)
        return 0, 17
```

--------------------------------

### pdfinfo_from_bytes

Source: https://pdf2image.readthedocs.io/en/latest/reference.html

Extracts PDF information using poppler's pdfinfo utility and returns it as a dictionary.

```APIDOC
## pdfinfo_from_bytes

### Description
Function wrapping poppler's pdfinfo utility and returns the result as a dictionary.

### Method
Function call

### Endpoint
pdf2image.pdf2image.pdfinfo_from_bytes

### Parameters
#### Path Parameters
- **pdf_bytes** (bytes) - Required - Bytes of the PDF that you want to convert

#### Optional Parameters
- **userpw** (str, optional) - PDF's password, defaults to None
- **ownerpw** (str, optional) - PDF's owner password, defaults to None
- **poppler_path** (Union[str, PurePath], optional) - Path to look for poppler binaries, defaults to None
- **rawdates** (bool, optional) - Return the undecoded data strings, defaults to False
- **timeout** (int, optional) - Raise PDFPopplerTimeoutError after the given time, defaults to None

### Returns
Dictionary containing various information on the PDF

### Return Type
Dict
```
Tokens:
Raw