PyMuPDF

https://pymupdf.readthedocs.io/en/latest
Admin
PyMuPDF is a high-performance Python library for data extraction, analysis, conversion, and...
Tokens:727,035
Snippets:4,950
Trust Score:8.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install pytest and run tests

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

Install test dependencies and run PyMuPDF's pytest test suite.

```bash
pip install pytest fontTools
pytest PyMuPDF/tests

```

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

### Ubuntu/Debian: Search and install Tesseract language packs

Source: https://pymupdf.readthedocs.io/en/latest/_sources/ocr/tesseract-language-packs.rst

Use apt-cache to list available tesseract-ocr packages, install a specific language (e.g., German) with sudo apt install tesseract-ocr-deu, or install all languages with tesseract-ocr-all. Packages follow the naming pattern tesseract-ocr-<langcode>.

```bash
# List all available language packs
apt-cache search tesseract-ocr

# Install a specific language (e.g. German)
sudo apt install tesseract-ocr-deu

# Install all available languages at once
sudo apt install tesseract-ocr-all
```

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

### image_profile example output

Source: https://pymupdf.readthedocs.io/en/latest/_sources/functions.rst

Example of calling pymupdf.image_profile on an opened image file and the resulting dictionary with image properties such as width, height, orientation, and colorspace.

```python
pymupdf.image_profile(open("nur-ruhig.jpg", "rb").read())
```

```python
{'width': 439,
'height': 501,
'orientation': 0,  # natural orientation (from EXIF)
'transform': (1.0, 0.0, 0.0, 1.0, 0.0, 0.0),  # orientation matrix
'xres': 96,
'yres': 96,
'colorspace': 3,
'bpc': 8,
'ext': 'jpeg',
'cs-name': 'DeviceRGB'}
```

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

### macOS: Install specific languages manually

Source: https://pymupdf.readthedocs.io/en/latest/_sources/ocr/tesseract-language-packs.rst

Install the Tesseract engine only with brew install tesseract, then find the tessdata directory using brew info tesseract. Look for a line like /opt/homebrew/share/tessdata.

```bash
# Install Tesseract engine only
brew install tesseract

# Find the tessdata directory
brew info tesseract
# Look for a line like: /opt/homebrew/share/tessdata
```

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

### Windows: Verify installed languages with tesseract --list-langs

Source: https://pymupdf.readthedocs.io/en/latest/_sources/ocr/tesseract-language-packs.rst

Run tesseract --list-langs in Command Prompt or PowerShell to verify that the newly installed language appears in the output.

```powershell
tesseract --list-langs
```

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

### Install Tesseract language packs on Ubuntu

Source: https://pymupdf.readthedocs.io/en/latest/pymupdf4llm/index.html

Installs Tesseract language packs on Ubuntu. Required for OCR in languages other than English.

```bash
sudo apt install tesseract-ocr-deu tesseract-ocr-fra

```

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

### resolve_names() output example 2

Source: https://pymupdf.readthedocs.io/en/latest/document.html

Alternative example dictionary from resolve_names() showing a destination name with a /XYZ destination string.

```python
{
    '21154a7c20684ceb91f9c9adc3b677c40': {'page': -1, 'dest': '/XYZ 15.75 1486 0'},
    ...
}

```

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

### macOS: Install all Tesseract languages with Homebrew

Source: https://pymupdf.readthedocs.io/en/latest/_sources/ocr/tesseract-language-packs.rst

Install the tesseract-lang formula to bundle Tesseract with every available language pack.

```bash
brew install tesseract-lang
```

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

### Install test dependencies and run PyMuPDF tests

Source: https://pymupdf.readthedocs.io/en/latest/_sources/installation.rst

Installs pytest and fontTools, then runs the PyMuPDF test suite. To skip a specific failing test, add -k 'not test_textbox3' to the pytest command.

```bash
pip install pytest fontTools
pytest PyMuPDF/tests
```

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

### Example Session 1: Enable journalling, add operations, undo/redo

Source: https://pymupdf.readthedocs.io/en/latest/_sources/recipes-journalling.rst

Shows how to enable journalling on a new document, perform updates inside operations, and navigate the journal with undo/redo. Demonstrates that updates outside an operation raise a RuntimeError. Output shows journal position, can_do status, and page text after each step.

```python
>>> import pymupdf
>>> doc=pymupdf.open()
>>> doc.journal_enable()

>>> # try update without an operation:
>>> page = doc.new_page()
mupdf: No journalling operation started
... omitted lines
RuntimeError: No journalling operation started

>>> doc.journal_start_op("op1")
>>> page = doc.new_page()
>>> doc.journal_stop_op()

>>> doc.journal_start_op("op2")
>>> page.insert_text((100,100), "Line 1")
>>> doc.journal_stop_op()

>>> doc.journal_start_op("op3")
>>> page.insert_text((100,120), "Line 2")
>>> doc.journal_stop_op()

>>> doc.journal_start_op("op4")
>>> page.insert_text((100,140), "Line 3")
>>> doc.journal_stop_op()

>>> # show position in journal
>>> doc.journal_position()
(4, 4)
>>> # 4 operations recorded - positioned at bottom
>>> # what can we do?
>>> doc.journal_can_do()
{'undo': True, 'redo': False}
>>> # currently only undos are possible. Print page content:
>>> print(page.get_text())
Line 1
Line 2
Line 3

>>> # undo last insert:
>>> doc.journal_undo()
>>> # show combined status again:
>>> doc.journal_position();doc.journal_can_do()
(3, 4)
{'undo': True, 'redo': True}
>>> print(page.get_text())
Line 1
Line 2

>>> # our position is now second to last
>>> # last text insertion was reverted
>>> # but we can redo / move forward as well:
>>> doc.journal_redo()
>>> # our combined status:
>>> doc.journal_position();doc.journal_can_do()
(4, 4)
{'undo': True, 'redo': False}
>>> print(page.get_text())
Line 1
Line 2
Line 3
>>> # line 3 has appeared again!
```

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

### paper_rect example

Source: https://pymupdf.readthedocs.io/en/latest/_sources/functions.rst

Shows how to get a Rect for a paper format using pymupdf.paper_rect. The example uses 'letter-l' and returns a Rect with width 792.0 and height 612.0.

```python
>>> import pymupdf
>>> pymupdf.paper_rect("letter-l")
pymupdf.Rect(0.0, 0.0, 792.0, 612.0)
>>>
```

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

### Move a page using Document.move_page

Source: https://pymupdf.readthedocs.io/en/latest/_sources/the-basics.rst

Changes the sequence of pages by moving a page to a new position. The example moves the 2nd page to the start.

```python
import pymupdf

doc = pymupdf.open("test.pdf") # open a document
doc.move_page(1,0) # move the 2nd page of the document to the start of the document
doc.save("test-page-moved.pdf") # save the document
```

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

### Run full build, install and test with sysinstall.py

Source: https://pymupdf.readthedocs.io/en/latest/_sources/packaging.rst

Run the sysinstall.py script to perform a full build, install, and test for both a local fake root and the system root. The first command uses the default local root, the second uses the system root.

```shell
./PyMuPDF/scripts/sysinstall.py
./PyMuPDF/scripts/sysinstall.py --root /
```

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

### Create a landscape page with paper_rect

Source: https://pymupdf.readthedocs.io/en/latest/_sources/faq/index.rst

Use the "-l" suffix in the paper size string to get a landscape page. The example also shows how to list all available paper sizes with paper_sizes().

```python
# Use paper size with "-l" suffix for landscape
    mediabox = pymupdf.paper_rect("a4-l")
    page = doc.new_page(width=mediabox.width, height=mediabox.height)

    # See all available paper sizes:
    print(pymupdf.paper_sizes())
```

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

### Import PyMuPDF and check version

Source: https://pymupdf.readthedocs.io/en/latest/_sources/tutorial.rst

Import the pymupdf module and print its docstring to verify the installed version. The output shows the version, version date, and build platform.

```python
>>> import pymupdf
>>> print(pymupdf.__doc__)
PyMuPDF 1.16.0: Python bindings for the MuPDF 1.16.0 library.
Version date: 2019-07-28 07:30:14.
Built for Python 3.7 on win32 (64-bit).
```

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

### PyMuPDF Document Player with Multiprocessing

Source: https://pymupdf.readthedocs.io/en/latest/recipes-multiprocessing.html

This example shows a Qt widget that opens a document, renders pages in a separate process, and displays them. It uses two queues for communication: one for page numbers and one for rendered images. The code includes a timer to send page numbers and another to fetch rendered pages. It supports PyQt6 and PySide6 via conditional imports.

```python
if  module_exists("PyQt6"):
    # PyQt6
    from PyQt6 import QtGui, QtWidgets, QtCore
    from PyQt6.QtCore import pyqtSignal as Signal, pyqtSlot as Slot
    wrapper = "PyQt6"

elif module_exists("PySide6"):
    # PySide6
    from PySide6 import QtGui, QtWidgets, QtCore
    from PySide6.QtCore import Signal, Slot
    wrapper = "PySide6"


my_timer = time.clock if str is bytes else time.perf_counter


class DocForm(QtWidgets.QWidget):
    def __init__(self):
        super().__init__()
        self.process = None
        self.queNum = mp.Queue()
        self.queDoc = mp.Queue()
        self.page_count = 0
        self.curPageNum = 0
        self.lastDir = ""
        self.timerSend = QtCore.QTimer(self)
        self.timerSend.timeout.connect(self.onTimerSendPageNum)
        self.timerGet = QtCore.QTimer(self)
        self.timerGet.timeout.connect(self.onTimerGetPage)
        self.timerWaiting = QtCore.QTimer(self)
        self.timerWaiting.timeout.connect(self.onTimerWaiting)
        self.initUI()

    def initUI(self):
        vbox = QtWidgets.QVBoxLayout()
        self.setLayout(vbox)

        hbox = QtWidgets.QHBoxLayout()
        self.btnOpen = QtWidgets.QPushButton("OpenDocument", self)
        self.btnOpen.clicked.connect(self.openDoc)
        hbox.addWidget(self.btnOpen)

        self.btnPlay = QtWidgets.QPushButton("PlayDocument", self)
        self.btnPlay.clicked.connect(self.playDoc)
        hbox.addWidget(self.btnPlay)

        self.btnStop = QtWidgets.QPushButton("Stop", self)
        self.btnStop.clicked.connect(self.stopPlay)
        hbox.addWidget(self.btnStop)

        self.label = QtWidgets.QLabel("0/0", self)
        self.label.setFont(QtGui.QFont("Verdana", 20))
        hbox.addWidget(self.label)

        vbox.addLayout(hbox)

        self.labelImg = QtWidgets.QLabel("Document", self)
        sizePolicy = QtWidgets.QSizePolicy(
            QtWidgets.QSizePolicy.Policy.Preferred, QtWidgets.QSizePolicy.Policy.Expanding
        )
        self.labelImg.setSizePolicy(sizePolicy)
        vbox.addWidget(self.labelImg)

        self.setGeometry(100, 100, 400, 600)
        self.setWindowTitle("PyMuPDF Document Player")
        self.show()

    def openDoc(self):
        path, _ = QtWidgets.QFileDialog.getOpenFileName(
            self,
            "Open Document",
            self.lastDir,
            "All Supported Files (*.pdf;*.epub;*.xps;*.oxps;*.cbz;*.fb2);;PDF Files (*.pdf);;EPUB Files (*.epub);;XPS Files (*.xps);;OpenXPS Files (*.oxps);;CBZ Files (*.cbz);;FB2 Files (*.fb2)",
            #options=QtWidgets.QFileDialog.Options(),
        )
        if path:
            self.lastDir, self.file = os.path.split(path)
            if self.process:
                self.queNum.put(-1)  # use -1 to notify the process to exit
            self.timerSend.stop()
            self.curPageNum = 0
            self.page_count = 0
            self.process = mp.Process(
                target=openDocInProcess, args=(path, self.queNum, self.queDoc)
            )
            self.process.start()
            self.timerGet.start(40)
            self.label.setText("0/0")
            self.queNum.put(0)
            self.startTime = time.perf_counter()
            self.timerWaiting.start(40)

    def playDoc(self):
        self.timerSend.start(500)

    def stopPlay(self):
        self.timerSend.stop()

    def onTimerSendPageNum(self):
        if self.curPageNum < self.page_count - 1:
            self.queNum.put(self.curPageNum + 1)
        else:
            self.timerSend.stop()

    def onTimerGetPage(self):
        try:
            ret = self.queDoc.get(False)
            if isinstance(ret, int):
                self.timerWaiting.stop()
                self.page_count = ret
                self.label.setText("{}/{}".format(self.curPageNum + 1, self.page_count))
            else:  # tuple, pixmap info
                num, samples, width, height, stride, alpha = ret
                self.curPageNum = num
                self.label.setText("{}/{}".format(self.curPageNum + 1, self.page_count))
                fmt = (
                    QtGui.QImage.Format.Format_RGBA8888
                    if alpha
                    else QtGui.QImage.Format.Format_RGB888
                )
                qimg = QtGui.QImage(samples, width, height, stride, fmt)
                self.labelImg.setPixmap(QtGui.QPixmap.fromImage(qimg))
        except queue.Empty as ex:
            pass

    def onTimerWaiting(self):
        self.labelImg.setText(
            'Loading "{}", {:.2f}s'.format(
                self.file, time.perf_counter() - self.startTime
            )
        )

    def closeEvent(self, event):
        self.queNum.put(-1)
        event.accept()
```

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

### Convert PDF to DOCX using pdf2docx

Source: https://pymupdf.readthedocs.io/en/latest/_sources/converting-files.rst

Uses the pdf2docx library to convert a PDF file to DOCX format. Requires installing pdf2docx. The example creates a Converter object, converts all pages by default, and closes the converter.

```python
from pdf2docx import Converter

pdf_file = 'input.pdf'
docx_file = 'output.docx'

# convert pdf to docx
cv = Converter(pdf_file)
cv.convert(docx_file) # all pages by default
cv.close()
```

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

### Convert PDF page to SVG with Page.get_svg_image

Source: https://pymupdf.readthedocs.io/en/latest/_sources/converting-files.rst

Exports a single PDF page to an SVG string and writes it to a file. Requires an input PDF and outputs an SVG file. The example opens the document, gets the first page, calls get_svg_image(), writes the content to 'output.svg', and closes the document.

```python
import pymupdf

doc = pymupdf.open("input.pdf")
page = doc[0]

# Convert page to SVG
svg_content = page.get_svg_image()

# Save to file
with open("output.svg", "w", encoding="utf-8") as f:
    f.write(svg_content)

doc.close()
```

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

### Extract image data and metadata with doc.extract_image()

Source: https://pymupdf.readthedocs.io/en/latest/document.html

Shows how to call extract_image() on a document to get a dictionary with image metadata and bytes, then write the bytes to a file. The output dictionary includes keys like 'ext', 'smask', 'width', 'height', 'colorspace', 'xres', 'yres', 'cs-name', and 'image'. The example writes the image data to a file using the extension from the dictionary.

```python
>>> d = doc.extract_image(1373)
>>> d
{'ext': 'png', 'smask': 2934, 'width': 5, 'height': 629, 'colorspace': 3, 'xres': 96,
'yres': 96, 'cs-name': 'DeviceRGB',
'image': b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x05\ ...'}
>>> imgout = open(f"image.{d['ext']}", "wb")
>>> imgout.write(d["image"])
102
>>> imgout.close()
```

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

### Pixmap.__init__(source, width, height, clip=None)

Source: https://pymupdf.readthedocs.io/en/latest/pixmap.html

Constructor for copying and scaling a pixmap.

```APIDOC
## Pixmap.__init__(source, width, height, clip=None)

### Description
Creates a new pixmap by copying the source pixmap and scaling it to the given width and height. Supports partial copying and can add an alpha channel if width or height are not integers.

### Parameters
#### Path Parameters
- **source** (Pixmap) - Required - The source pixmap.
- **width** (float) - Required - Desired target width.
- **height** (float) - Required - Desired target height.
- **clip** (irect_like) - Optional - Restrict the resulting pixmap to this region of the scaled pixmap.

### Notes
- If width or height are not integers (i.e., value.is_integer() != True), the resulting pixmap will have an alpha channel.

```

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

### Windows: Create and activate virtual environment

Source: https://pymupdf.readthedocs.io/en/latest/_sources/installation.rst

Creates a virtual environment on Windows, activates it, and updates pip.

```shell
py -m venv pymupdf-venv
.\pymupdf-venv\Scripts\activate
python -m pip install --upgrade pip
```

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

### PyMuPDF Story layout around no-go areas - script setup and analyze_page

Source: https://pymupdf.readthedocs.io/en/latest/recipes-stories.html

Starts the demo script for laying out text around images in a target PDF using PyMuPDF's Story class. It sets up imports, file paths, and global parameters (BORDER, FONTSIZE, COLS) and begins the analyze_page function that computes free rectangles on a page.

```python
"""
This is a demo script using PyMuPDF's Story class to output text as a PDF with
a two-column page layout.

The script demonstrates the following features:
* Layout text around images of an existing ("target") PDF.
* Based on a few global parameters, areas on each page are identified, that
  can be used to receive text layouted by a Story.
* These global parameters are not stored anywhere in the target PDF and
  must therefore be provided in some way.
  - The width of the border(s) on each page.
  - The fontsize to use for text. This value determines whether the provided
    text will fit in the empty spaces of the (fixed) pages of target PDF. It
    cannot be predicted in any way. The script ends with an exception if
    target PDF has not enough pages, and prints a warning message if not all
    pages receive at least some text. In both cases, the FONTSIZE value
    can be changed (a float value).
  - Use of a 2-column page layout for the text.
* The layout creates a temporary (memory) PDF. Its produced page content
  (the text) is used to overlay the corresponding target page. If text
  requires more pages than are available in target PDF, an exception is raised.
  If not all target pages receive at least some text, a warning is printed.
* The script reads "image-no-go.pdf" in its own folder. This is the "target" PDF.
  It contains 2 pages with each 2 images (from the original article), which are
  positioned at places that create a broad overall test coverage. Otherwise the
  pages are empty.
* The script produces "quickfox-image-no-go.pdf" which contains the original pages
  and image positions, but with the original article text laid out around them.

Note:
--------------
This script version uses just image positions to derive "No-Go areas" for
layouting the text. Other PDF objects types are detectable by PyMuPDF and may
be taken instead or in addition, without influencing the layouting.
The following are candidates for other such "No-Go areas". Each can be detected
and located by PyMuPDF:
* Annotations
* Drawings
* Existing text

--------------
The text and images are taken from the somewhat modified Wikipedia article
https://en.wikipedia.org/wiki/The_quick_brown_fox_jumps_over_the_lazy_dog.
--------------
"""

import io
import os
import zipfile
import pymupdf


thisdir = os.path.dirname(os.path.abspath(__file__))
myzip = zipfile.ZipFile(os.path.join(thisdir, "quickfox.zip"))

docname = os.path.join(thisdir, "image-no-go.pdf")  # "no go" input PDF file name
outname = os.path.join(thisdir, "quickfox-image-no-go.pdf")  # output PDF file name
BORDER = 36  # global parameter
FONTSIZE = 12.5  # global parameter
COLS = 2  # number of text columns, global parameter


def analyze_page(page):
    """Compute MediaBox and rectangles on page that are free to receive text.

```

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

### Install PyMuPDF with pip

Source: https://pymupdf.readthedocs.io/en/latest/_sources/faq/index.rst

Use this command to install the PyMuPDF package. Ensure you install 'pymupdf', not 'pymypdf' or 'mupdf'. Also, verify your IDE uses the same Python interpreter and virtual environment where the package is installed.

```bash
pip install pymupdf
```

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

### DisplayList.__init__(mediabox)

Source: https://pymupdf.readthedocs.io/en/latest/_sources/displaylist.rst

Creates a new display list with the given mediabox rectangle.

```APIDOC
## DisplayList.__init__(mediabox)

### Description
Creates a new display list.

### Method
Constructor

### Parameters
- **mediabox** (Rect) - Required - The page's rectangle.

### Returns
- **DisplayList** - The newly created display list.
```

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

### Install PyMuPDF Pro via pip

Source: https://pymupdf.readthedocs.io/en/latest/pymupdf-pro/index.html

Install the PyMuPDF Pro package using pip. This is the required installation step before using the extended features.

```bash
pip install pymupdfpro
```

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

### Pixmap.__init__(self, colorspace, source)

Source: https://pymupdf.readthedocs.io/en/latest/_sources/pixmap.rst

Creates a new pixmap by copying the source pixmap and converting its colorspace. Any colorspace combination is possible, but the source colorspace must not be None.

```APIDOC
## Pixmap.__init__(self, colorspace, source)

### Description
Creates a new pixmap by copying the source pixmap and converting its colorspace. Any colorspace combination is possible, but the source colorspace must not be `None`.

### Method
Constructor

### Parameters
- **colorspace** (Colorspace) - Required - The target colorspace for the new pixmap.
- **source** (Pixmap) - Required - The source pixmap to copy.

### Request Example
```python
pix = fitz.Pixmap(fitz.csRGB, source_pixmap)
```

### Response
#### Success Response
- **pixmap** (Pixmap) - The newly created pixmap object with the converted colorspace.

#### Response Example
```python
<pixmap object>
```
```

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

### Fedora/RHEL: Search and install Tesseract language packs

Source: https://pymupdf.readthedocs.io/en/latest/_sources/ocr/tesseract-language-packs.rst

Use dnf search to find tesseract packages, install a specific language (e.g., German) with sudo dnf install tesseract-langpack-deu, or install all language packs with tesseract-langpack-*. Packages are named tesseract-langpack-<langcode>.

```bash
# Search for available language packs
dnf search tesseract

# Install a specific language (e.g. German)
sudo dnf install tesseract-langpack-deu

# Install all language packs
sudo dnf install tesseract-langpack-*
```

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

### Pixmap.__init__(filename)

Source: https://pymupdf.readthedocs.io/en/latest/pixmap.html

Constructor for creating a pixmap from a file.

```APIDOC
## Pixmap.__init__(filename)

### Description
Creates a pixmap from an image file. All properties are inferred from the input; the origin of the resulting pixmap is (0,0).

### Parameters
#### Path Parameters
- **filename** (str) - Required - Path of the image file.

```

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

### set_layer() example with basestate

Source: https://pymupdf.readthedocs.io/en/latest/document.html

Shows setting the base state to OFF and then retrieving the layer dictionary, which now includes the 'basestate' key.

```python
>>> doc.set_layer(-1, basestate="OFF")  # only changes the base state
>>> pprint(doc.get_layer())
{'basestate': 'OFF', 'off': [8, 9, 10], 'on': [5, 6, 7], 'rbgroups': [[7, 10]]}
```

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

### Pixmap.__init__(colorspace, width, height, samples, alpha)

Source: https://pymupdf.readthedocs.io/en/latest/pixmap.html

Constructor for creating a pixmap from raw pixel data.

```APIDOC
## Pixmap.__init__(colorspace, width, height, samples, alpha)

### Description
Creates a pixmap from raw pixel samples. Each pixel must be represented by a number of bytes as controlled by colorspace and alpha parameters. The origin of the resulting pixmap is (0,0). Useful when raw image data are provided by another program.

### Parameters
#### Path Parameters
- **colorspace** (Colorspace) - Required - Colorspace of image.
- **width** (int) - Required - Image width.
- **height** (int) - Required - Image height.
- **samples** (bytes, bytearray, BytesIO) - Required - Area containing all pixels of the image. Must include alpha values if specified.
- **alpha** (bool) - Required - Whether a transparency channel is included.

### Notes
The following equation must be true: (colorspace.n + alpha) * width * height == len(samples). Starting with version 1.14.13, the samples data are copied to the pixmap.

```

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

### insert_font

Source: https://pymupdf.readthedocs.io/en/latest/page.html

Installs a font for text output on a page. Returns the xref of the installed font.

```APIDOC
## insert_font

### Description
Installs a font for text output on a page. Returns the xref of the installed font.

### Parameters
- **fontname** (_str_) – The name by which this font shall be referenced when outputting text on this page. If it matches one of the Base14_Fonts or CJK fonts, fontfile and fontbuffer are ignored.
- **fontfile** (_str_) – A path to a font file. If used, fontname must be different from all reserved names.
- **fontbuffer** (_bytes/bytearray_) – The memory image of a font file. If used, fontname must be different from all reserved names.
- **set_simple** (_int_) – Applicable for fontfile/fontbuffer cases only: enforce treatment as a “simple” font, i.e. one that only uses character codes up to 255.
- **encoding** (_int_) – Applicable for the “Helvetica”, “Courier” and “Times” sets of Base14_Fonts only. Select one of the available encodings Latin (0), Cyrillic (2) or Greek (1). Only use the default (0 = Latin) for “Symbol” and “ZapfDingBats”.

### Returns
- **int** – The xref of the installed font.

### Notes
Built-in fonts will not lead to the inclusion of a font file. The resulting PDF file will remain small. However, your PDF viewer software is responsible for generating an appropriate appearance – and there exist differences on whether or how each one of them does this. This is especially true for the CJK fonts. But also Symbol and ZapfDingbats are incorrectly handled in some cases.

#### Base-14 Fonts
| Font Name | Installed Base Font | Comments |
|---|---|---|
| helv | Helvetica | normal |
| heit | Helvetica-Oblique | italic |
| hebo | Helvetica-Bold | bold |
| hebi | Helvetica-BoldOblique | bold-italic |
| cour | Courier | normal |
| coit | Courier-Oblique | italic |
| cobo | Courier-Bold | bold |
| cobi | Courier-BoldOblique | bold-italic |
| tiro | Times-Roman | normal |
| tiit | Times-Italic | italic |
| tibo | Times-Bold | bold |
| tibi | Times-BoldItalic | bold-italic |
| symb | Symbol | [3] |
| zadb | ZapfDingbats | [3] |

#### CJK Fonts
| Font Name | Installed Base Font | Comments |
|---|---|---|
| china-s | Heiti | simplified Chinese |
| china-ss | Song | simplified Chinese (serif) |
| china-t | Fangti | traditional Chinese |
| china-ts | Ming | traditional Chinese (serif) |
| japan | Gothic | Japanese |
| japan-s | Mincho | Japanese (serif) |
| korea | Dotum | Korean |
| korea-s | Batang | Korean (serif) |
```

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

### Device.__init__(textpage, flags=0)

Source: https://pymupdf.readthedocs.io/en/latest/device.html

Constructor for a text page device. It takes a TextPage object and optional flags to control text parsing.

```APIDOC
## Device.__init__(textpage, flags=0)

### Description
Constructor for a text page device.

### Method
Constructor

### Parameters
- **textpage** (TextPage) - Required - `TextPage` object.
- **flags** (int) - Optional - Control the way how text is parsed into the text page. Currently 3 options can be coded into this parameter, see Font Properties. To set these options use something like `flags=0 | TEXT_PRESERVE_LIGATURES | ...`.

```

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

### Install PyMuPDF4LLM with pip

Source: https://pymupdf.readthedocs.io/en/latest/_sources/pymupdf4llm/index.rst

Installs the PyMuPDF4LLM package via pip before using its conversion methods.

```bash
pip install pymupdf4llm
```
Tokens:
Raw