PyMuPDF 1.23.23__tar.gz → 1.23.24__tar.gz

{PyMuPDF-1.23.23 → PyMuPDF-1.23.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyMuPDF
-Version: 1.23.23
+Version: 1.23.24
 Summary: A high performance Python library for data extraction, analysis, conversion & manipulation of PDF (and other) documents.
 Description-Content-Type: text/markdown
 Author: Artifex

{PyMuPDF-1.23.23 → PyMuPDF-1.23.24}/changes.txt

@@ -2,6 +2,19 @@ Change Log
 ==========
 
 
+**Changes in version 1.23.24 (2024-02-19)**
+
+* Fixed issues:
+
+  * **Fixed** `3148 <https://github.com/pymupdf/PyMuPDF/issues/3148>`_: Table extraction - vertical text not handled correctly
+  * **Fixed** `3179 <https://github.com/pymupdf/PyMuPDF/issues/3179>`_: Table Detection: Incorrect Separation of Vector Graphics Clusters
+  * **Fixed** `3180 <https://github.com/pymupdf/PyMuPDF/issues/3180>`_: Cannot show optional content group: AttributeError: module 'fitz.mupdf' has no attribute 'pdf_array_push_drop'
+
+* Other:
+
+  * Be able to test system install using `sudo pip install` instead of a venv.
+
+
 **Changes in version 1.23.23 (2024-02-18)**
 
 * Fixed issues:

{PyMuPDF-1.23.23 → PyMuPDF-1.23.24}/scripts/sysinstall.py

@@ -24,28 +24,39 @@ Args:
     --mupdf-git <git_args>
         Get or update `mupdf_dir` using git. If `mupdf_dir` already
         exists we run `git pull` in it; otherwise we run `git
-        clone` with `git_args`. For example:
+        clone` with `<git_args> <mupdf_dir>`. For example:
             --mupdf-git "--branch master https://github.com/ArtifexSoftware/mupdf.git"
-    --pymupdf-dir <pymupdf_dir>
-        Path of PyMuPDF checkout; default is 'PyMuPDF'.
+    --mupdf-so-mode <mode>
+        Used with `install -m <mode> ...` when installing MuPDF. For example
+        `--mupdf-so-mode 744`.
+    --packages 0|1
+        If 1 (the default) we install required system packages such as
+        `libfreetype-dev`.
+    --pip 0|venv|sudo
+        Whether/how to install Python packages.
+        If '0' we assume required packages are already available.
+        If 'sudo' we install required Python packages using `sudo pip install
+        ...`.
+        If 'venv' (the default) we install Python packages and run installer
+        and test commands inside venv's.
     --prefix:
         Directory within `root`; default is `/usr/local`. Must start with `/`.
+    --pymupdf-dir <pymupdf_dir>
+        Path of PyMuPDF checkout; default is 'PyMuPDF'.
     --root <root>
         Root of install directory; default is `/`.
     --tesseract5 0|1
         If 1 (the default), we force installation of libtesseract-dev version
         5 (which is not available as a default package in Ubuntu-22.04) from
         package repository ppa:alex-p/tesseract-ocr-devel.
-    --test-venv <venv_path>
-        Run tests in specified venv; the default is a hard-coded venv name. The
-        venv will be created and required packages installed using `pip`. If
-        `venv-path` is empty string, we do not create or use a venv, and will
-        instead attempt to install required packages with `pip` in the current
-        Python environment.
+    --test-venv <test_venv>
+        Set the name of the venv in which we run tests (only with `--pip
+        venv`); the default is a hard-coded venv name. The venv will be
+        created, and required packages installed using `pip`.
     --use-installer 0|1
         If 1 (the default), we use `python -m installer` to install PyMuPDF
-        from a generated wheel. Otherwise we use `pip install`, which refuses
-        to do a system install with `--root /`, referencing PEP-668.
+        from a generated wheel. [Otherwise we use `pip install`, which refuses
+        to do a system install with `--root /`, referencing PEP-668.]
     -m 0|1
         If 1 (the default) we build and install MuPDF, otherwise we just show
         what command we would have run.
@@ -61,12 +72,14 @@ To only show what commands would be run, but not actually run them, specify `-m
 '''
 
 import glob
+import multiprocessing
 import os
 import platform
 import subprocess
 import sys
 import sysconfig
 
+import test as test_py
 
 # Requirements for a system build and install:
 #
@@ -107,6 +120,8 @@ def main():
     mupdf = True
     mupdf_dir = 'mupdf'
     mupdf_git = None
+    mupdf_so_mode = None
+    packages = True
     prefix = '/usr/local'
     pymupdf = True
     pymupdf_dir = os.path.abspath( f'{__file__}/../..')
@@ -114,6 +129,7 @@ def main():
     tesseract5 = True
     test = True
     test_venv = 'venv-pymupdf-sysinstall-test'
+    pip = 'venv'
     
     # Parse command-line.
     #
@@ -128,12 +144,15 @@ def main():
             return
         elif arg == '--mupdf-dir':      mupdf_dir = next(args)
         elif arg == '--mupdf-git':      mupdf_git = next(args)
+        elif arg == '--mupdf-so-mode':  mupdf_so_mode = next(args)
+        elif arg == '--packages':       packages = int(next(args))
         elif arg == '--prefix':         prefix = next(args)
         elif arg == '--pymupdf-dir':    pymupdf_dir = next(args)
         elif arg == '--root':           root = next(args)
         elif arg == '--tesseract5':     tesseract5 = int(next(args))
         elif arg == '--test-venv':      test_venv = next(args)
         elif arg == '--use-installer':  use_installer = int(next(args))
+        elif arg == '--pip':            pip = next(args)
         elif arg == '-m':               mupdf = int(next(args))
         elif arg == '-p':               pymupdf = int(next(args))
         elif arg == '-t':               test = int(next(args))
@@ -141,6 +160,8 @@ def main():
             assert 0, f'Unrecognised arg: {arg!r}'
     
     assert prefix.startswith('/')
+    pip_values = ('0', 'sudo', 'venv')
+    assert pip in pip_values, f'Unrecognised --pip value {pip!r} should be one of: {pip_values!r}'
     root = os.path.abspath(root)
     root_prefix = f'{root}{prefix}'.replace('//', '/')
     
@@ -161,44 +182,54 @@ def main():
             print(f'## Clone MuPDF into {mupdf_dir}.')
             run(f'git clone --recursive --depth 1 --shallow-submodules {mupdf_git} {mupdf_dir}')
     
-    # Install required system packages. We assume a Debian package system.
-    #
-    print('## Install system packages required by MuPDF.')
-    run(f'sudo apt update')
-    run(f'sudo apt install {" ".join(g_sys_packages)}')
-    # Ubuntu-22.04 has freeglut3-dev, not libglut-dev.
-    run(f'sudo apt install libglut-dev | sudo apt install freeglut3-dev')
-    if tesseract5:
-        print(f'## Force installation of libtesseract-dev version 5.')
-        # https://stackoverflow.com/questions/76834972/how-can-i-run-pytesseract-python-library-in-ubuntu-22-04
+    if packages:
+        # Install required system packages. We assume a Debian package system.
         #
-        run('sudo apt install -y software-properties-common')
-        run('sudo add-apt-repository ppa:alex-p/tesseract-ocr-devel')
-        run('sudo apt update')
-        run('sudo apt install -y libtesseract-dev')
-    else:
-        run('sudo apt install libtesseract-dev')
+        print('## Install system packages required by MuPDF.')
+        run(f'sudo apt update')
+        run(f'sudo apt install {" ".join(g_sys_packages)}')
+        # Ubuntu-22.04 has freeglut3-dev, not libglut-dev.
+        run(f'sudo apt install libglut-dev | sudo apt install freeglut3-dev')
+        if tesseract5:
+            print(f'## Force installation of libtesseract-dev version 5.')
+            # https://stackoverflow.com/questions/76834972/how-can-i-run-pytesseract-python-library-in-ubuntu-22-04
+            #
+            run('sudo apt install -y software-properties-common')
+            run('sudo add-apt-repository ppa:alex-p/tesseract-ocr-devel')
+            run('sudo apt update')
+            run('sudo apt install -y libtesseract-dev')
+        else:
+            run('sudo apt install libtesseract-dev')
     
     # Build+install MuPDF. We use mupd:Makefile's install-shared-python target.
     #
+    if pip == 'sudo':
+        print('## Installing Python packages required for building MuPDF and PyMuPDF.')
+        run(f'sudo pip install --upgrade pip')
+        names = (''
+                + test_py.get_pyproject_required(os.path.abspath(f'{__file__}/../../pyproject.toml'))
+                + ' '
+                + test_py.get_pyproject_required(os.path.abspath(f'{mupdf_dir}/pyproject.toml'))
+                )
+        run(f'sudo pip install {names}')
+    
     print('## Build and install MuPDF.')
-    if 1:
-        # Current MuPDF creates softlinks with `ln -s` which breaks if there
-        # was a previous build; it should do `ln -sf`. We make things work by
-        # deleting any existing softlinks here.
-        run(f'rm {root_prefix}/lib/libmupdf.so || true')
-        run(f'rm {root_prefix}/lib/libmupdfcpp.so || true')
     command = f'cd {mupdf_dir}'
     command += f' && {sudo}make'
+    command += f' -j {multiprocessing.cpu_count()}'
     #command += f' EXE_LDFLAGS=-Wl,--trace' # Makes linker generate diagnostics as it runs.
     command += f' DESTDIR={root}'
     command += f' HAVE_LEPTONICA=yes'
     command += f' HAVE_TESSERACT=yes'
     command += f' USE_SYSTEM_LIBS=yes'
+    command += f' VENV_FLAG={"--venv" if pip == "venv" else ""}'
+    if mupdf_so_mode:
+        command += f' SO_INSTALL_MODE={mupdf_so_mode}'
     command += f' build_prefix=system-libs-'
     command += f' prefix={prefix}'
     command += f' verbose=yes'
     command += f' install-shared-python'
+    command += f' INSTALL_MODE=755'
     run( command)
     
     # Build+install PyMuPDF.
@@ -217,23 +248,34 @@ def main():
     env += f'PYMUPDF_SETUP_IMPLEMENTATIONS=b'   # Only build the rebased implementation.
     if use_installer:
         print(f'## Building wheel.')
+        if pip == 'venv':
+            venv_name = 'venv-pymupdf-sysinstall'
         run(f'pwd')
         run(f'rm dist/* || true')
-        run(f'{env} pip wheel -vv -w dist {os.path.abspath(pymupdf_dir)}')
+        if pip == 'venv':
+            run(f'{sys.executable} -m venv {venv_name}')
+            run(f'. {venv_name}/bin/activate && pip install --upgrade pip')
+            run(f'. {venv_name}/bin/activate && pip install --upgrade installer')
+            run(f'{env} {venv_name}/bin/python -m pip wheel -vv -w dist {os.path.abspath(pymupdf_dir)}')
+        elif pip == 'sudo':
+            run(f'sudo pip install --upgrade pip')
+            run(f'sudo pip install installer')
+            run(f'{env} pip wheel -vv -w dist {os.path.abspath(pymupdf_dir)}')
+        else:
+            log(f'Not installing "installer" because {pip=}.')
         wheel = glob.glob(f'dist/*')
         assert len(wheel) == 1, f'{wheel=}'
         wheel = wheel[0]
         print(f'## Installing wheel using `installer`.')
-        venv = 'venv-pymupdf-sysinstall'
-        run(f'{sys.executable} -m venv {venv}')
-        run(f'. {venv}/bin/activate && pip install --upgrade pip')
-        run(f'. {venv}/bin/activate && pip install --upgrade installer')
         pv = '.'.join(platform.python_version_tuple()[:2])
         p = f'{root_prefix}/lib/python{pv}'
         # `python -m installer` fails to overwrite existing files.
         run(f'{sudo}rm -r {p}/site-packages/fitz || true')
         run(f'{sudo}rm -r {p}/site-packages/PyMuPDF-*.dist-info || true')
-        run(f'{sudo}{venv}/bin/python -m installer --destdir {root} --prefix {prefix} {wheel}')
+        if pip == 'venv':
+            run(f'{sudo}{venv_name}/bin/python -m installer --destdir {root} --prefix {prefix} {wheel}')
+        else:
+            run(f'{sudo}{sys.executable} -m installer --destdir {root} --prefix {prefix} {wheel}')
         # It seems that MuPDF Python bindings are installed into
         # `.../dist-packages` (from mupdf:Mafile's call of `$(shell python3
         # -c "import sysconfig; print(sysconfig.get_path('platlib'))")` while
@@ -267,7 +309,7 @@ def main():
         del sys.path[0]
         pythonpath = pipcl.install_dir(root)
     
-    # Show contents of installation director. This is very slow on github,
+    # Show contents of installation directory. This is very slow on github,
     # where /usr/local contains lots of things.
     #run(f'find {root_prefix}|sort')
         
@@ -277,20 +319,27 @@ def main():
     def run(command):
         return run_command(command, doit=test)
     import gh_release
-    # Create venv.
-    run(f'{sys.executable} -m venv {test_venv}')
-    # Install required packages.
-    command = f'. {test_venv}/bin/activate'
-    command += f' && pip install --upgrade pip'
-    command += f' && pip install --upgrade {gh_release.test_packages}'
-    run(command)
+    if pip == 'venv':
+        # Create venv.
+        run(f'{sys.executable} -m venv {test_venv}')
+        # Install required packages.
+        command = f'. {test_venv}/bin/activate'
+        command += f' && pip install --upgrade pip'
+        command += f' && pip install --upgrade {gh_release.test_packages}'
+        run(command)
+    elif pip == 'sudo':
+        run(f'sudo pip install --upgrade {gh_release.test_packages}')
+    else:
+        log(f'Not installing packages for testing because {pip=}.')
     # Run pytest.
     #
     # We need to set PYTHONPATH and LD_LIBRARY_PATH. In particular we
     # use pipcl.install_dir() to find where pipcl will have installed
     # PyMuPDF.
-    command = f'. {test_venv}/bin/activate'
-    command += f' && LD_LIBRARY_PATH={root_prefix}/lib PYTHONPATH={pythonpath}'
+    command = ''
+    if pip == 'venv':
+        command += f'. {test_venv}/bin/activate &&'
+    command += f' LD_LIBRARY_PATH={root_prefix}/lib PYTHONPATH={pythonpath}'
     command += f' pytest -k "not test_color_count and not test_3050" {pymupdf_dir}'
     run(command)
 

{PyMuPDF-1.23.23 → PyMuPDF-1.23.24}/scripts/test.py

@@ -410,12 +410,13 @@ def test(
         log('\n' + venv_info(pytest_args=f'{pytest_options} {pytest_arg}'))
 
 
-def get_pyproject_required():
+def get_pyproject_required(ppt=None):
     '''
     Returns space-separated names of required packages in pyproject.toml.  We
     do not do a proper parse and rely on the packages being in a single line.
     '''
-    ppt = os.path.abspath(f'{__file__}/../../pyproject.toml')
+    if ppt is None:
+        ppt = os.path.abspath(f'{__file__}/../../pyproject.toml')
     with open(ppt) as f:
         for line in f:
             m = re.match('^requires = \\[(.*)\\]$', line)

{PyMuPDF-1.23.23 → PyMuPDF-1.23.24}/setup.py

@@ -1072,7 +1072,7 @@ with open( f'{g_root}/READMErb.md', encoding='utf-8') as f:
 # We generate different wheels depending on g_flavour.
 #
 
-version = '1.23.23'
+version = '1.23.24'
 version_b = '1.23.22'
 
 tag_python = None

{PyMuPDF-1.23.23 → PyMuPDF-1.23.24}/src/__init__.py

@@ -17437,7 +17437,7 @@ def JM_set_ocg_arrays_imp(arr, list_):
             # Not found.
             continue
         obj = mupdf.pdf_new_indirect(pdf, xref, 0)
-        mupdf.pdf_array_push_drop(arr, obj)
+        mupdf.pdf_array_push(arr, obj)
 
 
 def JM_set_resource_property(ref, name, xref):
@@ -21729,8 +21729,8 @@ def int_rc(text):
     return int(text)
 
 VersionFitz = "1.23.10" # MuPDF version.
-VersionBind = "1.23.23" # PyMuPDF version.
-VersionDate = "2024-02-18 00:00:01"
+VersionBind = "1.23.24" # PyMuPDF version.
+VersionDate = "2024-02-19 00:00:01"
 VersionDate2 = VersionDate.replace('-', '').replace(' ', '').replace(':', '')
 version = (VersionBind, VersionFitz, VersionDate2)
 pymupdf_version_tuple = tuple( [int_rc(i) for i in VersionBind.split('.')])

{PyMuPDF-1.23.23 → PyMuPDF-1.23.24}/src/table.py

@@ -71,6 +71,7 @@ This is implemented as new class TableHeader with the properties:
 * external: A bool indicating whether the header is outside the table cells.
 
 """
+
 import inspect
 import itertools
 import string
@@ -361,7 +362,7 @@ class WordExtractor:
         keep_blank_chars: bool = False,
         use_text_flow=False,
         horizontal_ltr=True,  # Should words be read left-to-right?
-        vertical_ttb=True,  # Should vertical words be read top-to-bottom?
+        vertical_ttb=False,  # Should vertical words be read top-to-bottom?
         extra_attrs=None,
         split_at_punctuation=False,
         expand_ligatures=True,
@@ -387,9 +388,20 @@ class WordExtractor:
         x0, top, x1, bottom = objects_to_bbox(ordered_chars)
         doctop_adj = ordered_chars[0]["doctop"] - ordered_chars[0]["top"]
         upright = ordered_chars[0]["upright"]
-
         direction = 1 if (self.horizontal_ltr if upright else self.vertical_ttb) else -1
 
+        matrix = ordered_chars[0]["matrix"]
+
+        rotation = 0
+        if not upright and matrix[1] < 0:
+            ordered_chars = reversed(ordered_chars)
+            rotation = 270
+
+        if matrix[0] < 0 and matrix[3] < 0:
+            rotation = 180
+        elif matrix[1] > 0:
+            rotation = 90
+
         word = {
             "text": "".join(
                 self.expansions.get(c["text"], c["text"]) for c in ordered_chars
@@ -401,6 +413,7 @@ class WordExtractor:
             "bottom": bottom,
             "upright": upright,
             "direction": direction,
+            "rotation": rotation,
         }
 
         for key in self.extra_attrs:
@@ -552,7 +565,8 @@ class WordExtractor:
         return WordMap(list(self.iter_extract_tuples(chars)))
 
     def extract_words(self, chars: list) -> list:
-        return list(word for word, word_chars in self.iter_extract_tuples(chars))
+        words = list(word for word, word_chars in self.iter_extract_tuples(chars))
+        return words
 
 
 def extract_words(chars: list, **kwargs) -> list:
@@ -590,8 +604,21 @@ def extract_text(chars: list, **kwargs) -> str:
             **{k: kwargs[k] for k in WORD_EXTRACTOR_KWARGS if k in kwargs}
         )
         words = extractor.extract_words(chars)
-        lines = cluster_objects(words, itemgetter("doctop"), y_tolerance)
-        return "\n".join(" ".join(word["text"] for word in line) for line in lines)
+        rotation = words[0]["rotation"]  # rotation cannot change within a cell
+
+        if rotation == 90:
+            words.sort(key=lambda w: (w["x1"], -w["top"]))
+            lines = " ".join([w["text"] for w in words])
+        elif rotation == 270:
+            words.sort(key=lambda w: (-w["x1"], w["top"]))
+            lines = " ".join([w["text"] for w in words])
+        else:
+            lines = cluster_objects(words, itemgetter("doctop"), y_tolerance)
+            lines = "\n".join(" ".join(word["text"] for word in line) for line in lines)
+            if rotation == 180:  # needs extra treatment
+                lines = "".join([(c if c != "\n" else " ") for c in reversed(lines)])
+
+        return lines
 
 
 def collate_line(
@@ -1873,49 +1900,78 @@ def make_chars(page, clip=None):
 # else to lines.
 # -----------------------------------------------------------------------------
 def make_edges(page, clip=None, tset=None, add_lines=None):
+    global EDGES
+    snap_x = tset.snap_x_tolerance
+    snap_y = tset.snap_y_tolerance
+    lines_strict = (
+        tset.vertical_strategy == "lines_strict"
+        or tset.horizontal_strategy == "lines_strict"
+    )
+    page_height = page.rect.height
+    doctop_basis = page.number * page_height
+    page_number = page.number + 1
+    prect = page.rect
+    if page.rotation in (90, 270):
+        w, h = prect.br
+        prect = Rect(0, 0, h, w)
+    if clip is not None:
+        clip = Rect(clip)
+    else:
+        clip = prect
+
+    def are_neighbors(r1, r2):
+        """Detect whether r1, r2 are neighbors.
+
+        Defined as:
+        The minimum distance between points of r1 and points of r2 is not
+        larger than some delta.
+
+        This check supports empty rect-likes and thus also lines.
+        """
+        if (
+            r2.x0 - snap_x <= r1.x0 <= r2.x1 + snap_x
+            or r2.x0 - snap_x <= r1.x1 <= r2.x1 + snap_x
+        ) and (
+            r2.y0 - snap_y <= r1.y0 <= r2.y1 + snap_y
+            or r2.y0 - snap_y <= r1.y1 <= r2.y1 + snap_y
+        ):
+            return True
+        return False
+
     def clean_graphics():
         """Detect and join rectangles of connected vector graphics."""
-        lines_strict = (
-            tset.vertical_strategy == "lines_strict"
-            or tset.horizontal_strategy == "lines_strict"
-        )
         # exclude irrelevant graphics
         paths = []
         for p in page.get_drawings():
-            if (
+            if (  # ignore fill-only graphics if they are no lines
                 p["type"] == "f"
                 and lines_strict
-                and p["rect"].width > tset.snap_x_tolerance
-                and p["rect"].height > tset.snap_y_tolerance
-            ):  # ignore fill-only graphics if they are no lines
+                and p["rect"].width > snap_x
+                and p["rect"].height > snap_y
+            ):
                 continue
             paths.append(p)
 
         prects = sorted([p["rect"] for p in paths], key=lambda r: (r.y1, r.x0))
         new_rects = []  # the final list of joined rectangles
-
         # -------------------------------------------------------------------------
-        # Strategy: join rects that have at least one point in common.
+        # Strategy: Join rectangles that "almost touch" each other,
+        # Extend first rectangle with any remaining in the list that touches it.
+        # Then move it to final list and continue with the rest.
         # -------------------------------------------------------------------------
         while prects:  # the algorithm will empty this list
             r = prects[0]  # first rectangle
             repeat = True
-            while repeat:
-                repeat = False
+            while repeat:  # this loop extends first rect in list
+                repeat = False  # will be set to true if any other rect touches
                 for i in range(len(prects) - 1, -1, -1):  # run backwards
                     if i == 0:  # don't touch first rectangle
                         continue
-                    ri = prects[i]
-                    if (
-                        r.x0 <= ri.x0 <= r.x1
-                        or r.x0 <= ri.x1 <= r.x1
-                        or r.y0 <= ri.y0 <= r.y1
-                        or r.y0 <= ri.y1 <= r.y1
-                    ):
-                        r |= ri  # join in to first rect
-                        prects[0] = r  # update first
+                    if are_neighbors(r, prects[i]):  # touches rect 0!
+                        r |= prects[i]  # extend first rect
+                        prects[0] = +r  # update it in list
                         del prects[i]  # delete this rect
-                        repeat = True
+                        repeat = True  # check remaining
 
             # move first item over to result list
             new_rects.append(prects.pop(0))
@@ -1924,26 +1980,11 @@ def make_edges(page, clip=None, tset=None, add_lines=None):
         new_rects = sorted(list(set(new_rects)), key=lambda r: (r.y1, r.x0))
         return [r for r in new_rects if r.width > 5 and r.height > 5], paths
 
-    global EDGES
     bboxes, paths = clean_graphics()
 
-    page_height = page.rect.height
-    doctop_basis = page.number * page_height
-    page_number = page.number + 1
-    x_tolerance = tset.snap_x_tolerance
-    y_tolerance = tset.snap_y_tolerance
-    prect = page.rect
-    if page.rotation in (90, 270):
-        w, h = prect.br
-        prect = Rect(0, 0, h, w)
-    if clip is not None:
-        clip = Rect(clip)
-    else:
-        clip = prect
-
     def is_parallel(p1, p2):
         """Check if line is roughly axis-parallel."""
-        if abs(p1.x - p2.x) <= x_tolerance or abs(p1.y - p2.y) <= y_tolerance:
+        if abs(p1.x - p2.x) <= snap_x or abs(p1.y - p2.y) <= snap_y:
             return True
         return False
 
@@ -2021,10 +2062,10 @@ def make_edges(page, clip=None, tset=None, add_lines=None):
             elif i[0] == "re":  # a rectangle: decompose into 4 lines
                 rect = i[1].normalize()  # rectangle itself
                 # ignore minute rectangles
-                if rect.height <= y_tolerance and rect.width <= x_tolerance:
+                if rect.height <= snap_y and rect.width <= snap_x:
                     continue
 
-                if rect.width <= x_tolerance:  # simulates a vertical line
+                if rect.width <= snap_x:  # simulates a vertical line
                     x = abs(rect.x1 + rect.x0) / 2  # take middle value for x
                     p1 = Point(x, rect.y0)
                     p2 = Point(x, rect.y1)
@@ -2033,7 +2074,7 @@ def make_edges(page, clip=None, tset=None, add_lines=None):
                         EDGES.append(line_to_edge(line_dict))
                     continue
 
-                if rect.height <= y_tolerance:  # simulates a horizontal line
+                if rect.height <= snap_y:  # simulates a horizontal line
                     y = abs(rect.y1 + rect.y0) / 2  # take middle value for y
                     p1 = Point(rect.x0, y)
                     p2 = Point(rect.x1, y)

PyMuPDF-1.23.24/src_classic/version.i

@@ -0,0 +1,7 @@
+%pythoncode %{
+VersionFitz = "1.23.10" # MuPDF version.
+VersionBind = "1.23.24" # PyMuPDF version.
+VersionDate = "2024-02-19 00:00:01"
+version = (VersionBind, VersionFitz, "20240219000001")
+pymupdf_version_tuple = tuple( [int(i) for i in VersionFitz.split('.')])
+%}

{PyMuPDF-1.23.23 → PyMuPDF-1.23.24}/tests/test_optional_content.py

@@ -72,3 +72,68 @@ def test_3143():
     set1 = set([p["layer"] for p in page.get_drawings()])
     set2 = set([b[2] for b in page.get_bboxlog(layers=True)])
     assert set0 == set1 == set2
+
+
+def test_3180():
+    doc = fitz.open()
+    page = doc.new_page()
+
+    # Define the items for the combo box
+    combo_items = ['first', 'second', 'third']
+
+    # Create a combo box field
+    combo_box = fitz.Widget()  # create a new widget
+    combo_box.field_type = fitz.PDF_WIDGET_TYPE_COMBOBOX
+    combo_box.field_name = "myComboBox"
+    combo_box.field_value = combo_items[0]
+    combo_box.choice_values = combo_items
+    combo_box.rect = fitz.Rect(50, 50, 200, 75)  # position of the combo box
+    combo_box.script_change = """
+    var value = event.value;
+    app.alert('You selected: ' + value);
+
+    //var group_id = optional_content_group_ids[value];
+
+    """
+
+    # Insert the combo box into the page
+    # https://pymupdf.readthedocs.io/en/latest/page.html#Page.add_widget
+    page.add_widget(combo_box)
+
+    # Create optional content groups
+    # https://github.com/pymupdf/PyMuPDF-Utilities/blob/master/jupyter-notebooks/optional-content.ipynb
+
+
+    # Load images and create OCGs for each
+    optional_content_group_ids = {}
+    for i, item in enumerate(combo_items):
+        optional_content_group_id = doc.add_ocg(item, on=False)
+        optional_content_group_ids[item] = optional_content_group_id
+        rect = fitz.Rect(50, 100, 250, 300)
+        image_file_name = f'{item}.png'
+        # xref = page.insert_image(
+        #    rect,
+        #    filename=image_file_name,
+        #    oc=optional_content_group_id,
+        # )
+
+
+    first_id = optional_content_group_ids['first']
+    second_id = optional_content_group_ids['second']
+    third_id = optional_content_group_ids['third']
+
+    # https://pymupdf.readthedocs.io/en/latest/document.html#Document.set_layer
+
+
+    doc.set_layer(-1, basestate="OFF")
+    layers = doc.get_layer()
+    doc.set_layer(config=-1, on=[first_id])
+
+    # https://pymupdf.readthedocs.io/en/latest/document.html#Document.set_layer_ui_config
+    # configs = doc.layer_ui_configs()
+    # doc.set_layer_ui_config(0, fitz.PDF_OC_ON)
+    # doc.set_layer_ui_config('third', action=2)
+
+    # Save the PDF
+    doc.save(os.path.abspath(f'{__file__}/../../tests/test_3180.pdf'))
+    doc.close()