PyMuPDF 1.23.18__tar.gz → 1.23.19__tar.gz

{PyMuPDF-1.23.18 → PyMuPDF-1.23.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyMuPDF
-Version: 1.23.18
+Version: 1.23.19
 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.18 → PyMuPDF-1.23.19}/changes.txt

@@ -2,6 +2,24 @@ Change Log
 ==========
 
 
+**Changes in version 1.23.19 (2024-01-25)**
+
+* Bug fixes:
+
+  * **Fixed** `3087 <https://github.com/pymupdf/PyMuPDF/issues/3087>`_: Exception in insert_image with mask specified
+  * **Fixed** `3094 <https://github.com/pymupdf/PyMuPDF/issues/3094>`_: TypeError: '<' not supported between instances of 'FzLocation' and 'int' in doc.delete_pages
+
+* Other:
+
+  * When finding tables:
+  
+    * Allow addition of user-defined "virtual" vector graphics when finding tables.
+    * Confirm that the enveloping bboxes of vector graphics are inside the clip rectangle.
+    * Avoid slow finding of rectangle intersections.
+
+  * Added `Font.bbox` property.
+
+
 **Changes in version 1.23.18 (2024-01-23)**
 
 * Bug fixes:

{PyMuPDF-1.23.18 → PyMuPDF-1.23.19}/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.18'
+version = '1.23.19'
 version_b = '1.23.9'
 
 tag_python = None

{PyMuPDF-1.23.18 → PyMuPDF-1.23.19}/src/__init__.py

@@ -6038,6 +6038,10 @@ class Font:
         """Return the glyph ascender value."""
         return mupdf.fz_font_ascender(self.this)
 
+    @property
+    def bbox(self):
+        return self.this.fz_font_bbox()
+    
     @property
     def buffer(self):
         buffer_ = mupdf.FzBuffer( mupdf.ll_fz_keep_buffer( self.this.m_internal.buffer))
@@ -7804,24 +7808,68 @@ class Page:
             #log( 'do_have_imask')
             # mupdf.FzCompressedBuffer is not copyable, so
             # mupdf.fz_compressed_image_buffer() does not work - it cannot
-            # return by value. So we need to construct locally from a raw
-            # fz_compressed_buffer.
-            #cbuf1 = mupdf.fz_compressed_image_buffer(image)
-            cbuf1 = mupdf.FzCompressedBuffer( mupdf.ll_fz_compressed_image_buffer( image.m_internal))
-            if not cbuf1.m_internal:
+            # return by value. And sharing a fz_compressed_buffer betwen two
+            # `fz_image`'s doesn't work, so we use a raw fz_compressed_buffer
+            # here, not a mupdf.FzCompressedBuffer.
+            #
+            cbuf1 = mupdf.ll_fz_compressed_image_buffer( image.m_internal)
+            if not cbuf1:
                 raise ValueError( "uncompressed image cannot have mask")
             bpc = image.bpc()
             colorspace = image.colorspace()
             xres, yres = mupdf.fz_image_resolution(image)
             mask = mupdf.fz_new_image_from_buffer(maskbuf)
-            zimg = mupdf.fz_new_image_from_compressed_buffer(
-                    w, h,
-                    bpc, colorspace, xres, yres, 1, 0, None,
-                    None, cbuf1, mask
-                    )
-            image = zimg
-            #goto have_image()
+            if mupdf_version_tuple >= (1, 24):
+                zimg = mupdf.ll_fz_new_image_from_compressed_buffer2(
+                        w,
+                        h,
+                        bpc,
+                        colorspace.m_internal,
+                        xres,
+                        yres,
+                        1,  # interpolate
+                        0,  # imagemask,
+                        None,   # decode
+                        None,   # colorkey
+                        cbuf1,
+                        mask.m_internal,
+                        )
+            else:
+                # mupdf.ll_fz_new_image_from_compressed_buffer() is not usable.
+                zimg = extra.fz_new_image_from_compressed_buffer(
+                        w,
+                        h,
+                        bpc,
+                        colorspace.m_internal,
+                        xres,
+                        yres,
+                        1,  # interpolate
+                        0,  # imagemask,
+                        cbuf1,
+                        mask.m_internal,
+                        )
+
+            zimg = mupdf.FzImage(zimg)
 
+            # `image` and `zimage` both have pointers to the same
+            # `fz_compressed_buffer`, which is not reference counted, and they
+            # both think that they own it.
+            #
+            # So we do what the classic implementataion does, and simply ensure
+            # that `fz_drop_image(image)` is never called. This will leak
+            # some of `image`'s allocations (for example the main `fz_image`
+            # allocation), but it's not trivial to avoid this.
+            #
+            # Perhaps we could manually set `fz_image`'s
+            # `fz_compressed_buffer*` to null? Trouble is we'd have to
+            # cast the `fz_image*` to a `fz_compressed_image*` to see the
+            # `fz_compressed_buffer*`, which is probably not possible from
+            # Python?
+            #
+            image.m_internal = None
+            
+            image = zimg
+            
         if do_have_image:
             #log( 'do_have_image')
             ref = mupdf.pdf_add_image(pdf, image)
@@ -14083,7 +14131,8 @@ def _remove_dest_range(pdf, numbers):
                 target = mupdf.pdf_array_get( dest, 0)
                 pno = mupdf.pdf_lookup_page_number( pdf, target)
             elif mupdf.pdf_is_string( dest):
-                pno, _, _ = mupdf.fz_resolve_link( pdf.super(), mupdf.pdf_to_text_string( dest))
+                location, _, _ = mupdf.fz_resolve_link( pdf.super(), mupdf.pdf_to_text_string( dest))
+                pno = location.page
             if pno < 0: # page number lookup did not work
                 continue
             n1 = pno
@@ -14628,34 +14677,35 @@ def JM_choice_options(annot):
     '''
     annot_obj = mupdf.pdf_annot_obj( annot.this)
     
-    # pdf_choice_widget_options() is not usable from python, so we implement it
-    # ourselves here.
-    #
-    # fixme: put this in mupdf python bindings.
-    #
-    def pdf_choice_widget_options( annot, exportval):
-        #log( '{=type(annot)}')
-        optarr = mupdf.pdf_dict_get_inheritable( mupdf.pdf_annot_obj(annot.this), PDF_NAME('Opt'))
-        #log( '{optarr=}')
-        n = mupdf.pdf_array_len(optarr)
-        opts = []
-        if not n:
+    if mupdf_version_tuple >= (1, 24):
+        opts = mupdf.pdf_choice_widget_options2( annot, 0)
+    else:
+        # pdf_choice_widget_options() is not usable from python, so we
+        # implement it ourselves here.
+        #
+        def pdf_choice_widget_options( annot, exportval):
+            #log( '{=type(annot)}')
+            optarr = mupdf.pdf_dict_get_inheritable( mupdf.pdf_annot_obj(annot.this), PDF_NAME('Opt'))
+            #log( '{optarr=}')
+            n = mupdf.pdf_array_len(optarr)
+            opts = []
+            if not n:
+                return opts
+            optarr = mupdf.pdf_dict_get(annot_obj, PDF_NAME('Opt'))
+            for i in range(n):
+                m = mupdf.pdf_array_len(mupdf.pdf_array_get(optarr, i))
+                if m == 2:
+                    val = (
+                            mupdf.pdf_to_text_string(mupdf.pdf_array_get(mupdf.pdf_array_get(optarr, i), 0)),
+                            mupdf.pdf_to_text_string(mupdf.pdf_array_get(mupdf.pdf_array_get(optarr, i), 1)),
+                            )
+                    opts.append(val)
+                else:
+                    val = JM_UnicodeFromStr(mupdf.pdf_to_text_string(mupdf.pdf_array_get(optarr, i)))
+                    opts.append(val)
             return opts
-        optarr = mupdf.pdf_dict_get(annot_obj, PDF_NAME('Opt'))
-        for i in range(n):
-            m = mupdf.pdf_array_len(mupdf.pdf_array_get(optarr, i))
-            if m == 2:
-                val = (
-                        mupdf.pdf_to_text_string(mupdf.pdf_array_get(mupdf.pdf_array_get(optarr, i), 0)),
-                        mupdf.pdf_to_text_string(mupdf.pdf_array_get(mupdf.pdf_array_get(optarr, i), 1)),
-                        )
-                opts.append(val)
-            else:
-                val = JM_UnicodeFromStr(mupdf.pdf_to_text_string(mupdf.pdf_array_get(optarr, i)))
-                opts.append(val)
-        return opts
 
-    opts = pdf_choice_widget_options( annot, 0)
+        opts = pdf_choice_widget_options( annot, 0)
     n = len( opts)
     if n == 0:
         return  # wrong widget type
@@ -21748,8 +21798,8 @@ def int_rc(text):
     return int(text)
 
 VersionFitz = "1.23.9" # MuPDF version.
-VersionBind = "1.23.18" # PyMuPDF version.
-VersionDate = "2024-01-23 00:00:01"
+VersionBind = "1.23.19" # PyMuPDF version.
+VersionDate = "2024-01-25 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.18 → PyMuPDF-1.23.19}/src/extra.i

@@ -4294,6 +4294,39 @@ no_more_matches:;
     return quads;
 }
 
+/* MuPDF-1.23.x has an incorrect and unusable
+fz_new_image_from_compressed_buffer() wrapper that thinks the `decode` and
+`colorkey` args are out-params. So we provide an alternative wrapper where
+we always set these to args to null, which is sufficient for PyMuPDF caller
+`Document._insert_image()`. */
+fz_image* fz_new_image_from_compressed_buffer(
+        int w,
+        int h,
+        int bpc,
+        fz_colorspace *colorspace,
+        int xres,
+        int yres,
+        int interpolate,
+        int imagemask,
+        fz_compressed_buffer *buffer,
+        fz_image *mask
+        )
+{
+    return mupdf::ll_fz_new_image_from_compressed_buffer(
+            w,
+            h,
+            bpc,
+            colorspace,
+            xres,
+            yres,
+            interpolate,
+            imagemask,
+            nullptr,
+            nullptr,
+            buffer,
+            mask
+            );
+}
 
 %}
 
@@ -4468,3 +4501,16 @@ int pixmap_n(mupdf::FzPixmap& pixmap);
 PyObject* JM_search_stext_page(fz_stext_page *page, const char *needle);
 
 PyObject *set_pixel(fz_pixmap* pm, int x, int y, PyObject *color);
+
+fz_image* fz_new_image_from_compressed_buffer(
+        int w,
+        int h,
+        int bpc,
+        fz_colorspace *colorspace,
+        int xres,
+        int yres,
+        int interpolate,
+        int imagemask,
+        fz_compressed_buffer *buffer,
+        fz_image *mask
+        );

{PyMuPDF-1.23.18 → PyMuPDF-1.23.19}/src/table.py

@@ -1872,42 +1872,26 @@ def make_chars(page, clip=None):
 # We are ignoring Bézier curves completely and are converting everything
 # else to lines.
 # -----------------------------------------------------------------------------
-def make_edges(page, clip=None, tset=None):
-    def has_text(bbox):
-        text = page.get_text(clip=bbox).replace("\n", "").strip()
-        if text:
-            return True
-        return False
-
+def make_edges(page, clip=None, tset=None, add_lines=None):
     def clean_graphics():
         """Detect and join rectangles of connected vector graphics."""
-        # we need to exclude meaningless graphics that e.g. paint a white
-        # rectangle on the full page.
-
-        parea = abs(page.rect) * 0.8  # area of the full page (80%)
-
+        lines_strict = (
+            tset.vertical_strategy == "lines_strict"
+            or tset.horizontal_strategy == "lines_strict"
+        )
         # exclude irrelevant graphics
         paths = []
         for p in page.get_drawings():
-            if abs(p["rect"]) >= parea:
-                continue
-            if "s" in p["type"]:
-                paths.append(p)
-                continue
             if (
-                p["rect"].width > 3
-                and p["rect"].height > 3
-                and (
-                    tset.vertical_strategy == "lines_strict"
-                    or tset.horizontal_strategy == "lines_strict"
-                )
-            ):
+                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
                 continue
             paths.append(p)
 
-        # make a list of vector graphics rectangles (IRects are sufficient)
         prects = sorted([p["rect"] for p in paths], key=lambda r: (r.y1, r.x0))
-
         new_rects = []  # the final list of joined rectangles
 
         # -------------------------------------------------------------------------
@@ -1921,9 +1905,15 @@ def make_edges(page, clip=None, tset=None):
                 for i in range(len(prects) - 1, -1, -1):  # run backwards
                     if i == 0:  # don't touch first rectangle
                         continue
-                    if r.intersects(prects[i]):
-                        r |= prects[i]  # join in to first rect
-                        prects[0] = +r  # update first
+                    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
                         del prects[i]  # delete this rect
                         repeat = True
 
@@ -1932,9 +1922,7 @@ def make_edges(page, clip=None, tset=None):
             prects = sorted(list(set(prects)), key=lambda r: (r.y1, r.x0))
 
         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 and has_text(r)
-        ], paths
+        return [r for r in new_rects if r.width > 5 and r.height > 5], paths
 
     global EDGES
     bboxes, paths = clean_graphics()
@@ -2091,18 +2079,33 @@ def make_edges(page, clip=None, tset=None):
                     EDGES.append(line_to_edge(line_dict))
 
     path = {"color": (0, 0, 0), "fill": None, "width": 1}
-    for bbox in bboxes:
+    for bbox in bboxes:  # add the border lines for all enveloping bboxes
         line_dict = make_line(path, bbox.tl, bbox.tr, clip)
-        EDGES.append(line_to_edge(line_dict))
+        if line_dict:
+            EDGES.append(line_to_edge(line_dict))
 
         line_dict = make_line(path, bbox.bl, bbox.br, clip)
-        EDGES.append(line_to_edge(line_dict))
+        if line_dict:
+            EDGES.append(line_to_edge(line_dict))
 
         line_dict = make_line(path, bbox.tl, bbox.bl, clip)
-        EDGES.append(line_to_edge(line_dict))
+        if line_dict:
+            EDGES.append(line_to_edge(line_dict))
 
         line_dict = make_line(path, bbox.tr, bbox.br, clip)
-        EDGES.append(line_to_edge(line_dict))
+        if line_dict:
+            EDGES.append(line_to_edge(line_dict))
+
+    if add_lines is not None:  # add user-specified lines
+        assert isinstance(add_lines, (tuple, list))
+    else:
+        add_lines = []
+    for p1, p2 in add_lines:
+        p1 = Point(p1)
+        p2 = Point(p2)
+        line_dict = make_line(path, p1, p2, clip)
+        if line_dict:
+            EDGES.append(line_to_edge(line_dict))
 
 
 def page_rotation_set0(page):
@@ -2152,7 +2155,7 @@ def page_rotation_set0(page):
 def page_rotation_reset(page, xref, rot, mediabox):
     """Reset page rotation to original values.
 
-    To be used before we return tabes."""
+    To be used before we return tables."""
     doc = page.parent  # document of the page
     doc.update_stream(xref, b" ")  # remove de-rotation matrix
     page.set_mediabox(mediabox)  # set mediabox to old value
@@ -2185,6 +2188,7 @@ def find_tables(
     text_x_tolerance=3,
     text_y_tolerance=3,
     strategy=None,  # offer abbreviation
+    add_lines=None,  # optional user-specified lines
 ):
     global CHARS, EDGES
     CHARS = []
@@ -2237,7 +2241,9 @@ def find_tables(
     page.table_settings = tset
 
     make_chars(page, clip=clip)  # create character list of page
-    make_edges(page, clip=clip, tset=tset)  # create lines and curves
+    make_edges(
+        page, clip=clip, tset=tset, add_lines=add_lines
+    )  # create lines and curves
     tables = TableFinder(page, settings=tset)
 
     TOOLS.set_small_glyph_heights(old_small)

PyMuPDF-1.23.19/src_classic/version.i

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

{PyMuPDF-1.23.18 → PyMuPDF-1.23.19}/tests/test_font.py

@@ -16,6 +16,13 @@ def test_font1():
         assert cl[i] == font.glyph_advance(ord(text[i])) * 20
     font2 = fitz.Font(fontbuffer=font.buffer)
     assert font2.valid_codepoints() == font.valid_codepoints()
+    
+    # Also check we can get font's bbox.
+    bbox1 = font.bbox
+    print(f'{bbox1=}')
+    if hasattr(fitz, 'mupdf'):
+        bbox2 = font.this.fz_font_bbox()
+        assert bbox2 == bbox1
 
 
 def test_font2():

{PyMuPDF-1.23.18 → PyMuPDF-1.23.19}/tests/test_insertimage.py

@@ -45,3 +45,22 @@ def test_compress():
             deflate_fonts=True,
             pretty=True,
             )
+
+def test_3087():
+    path = os.path.abspath(f'{__file__}/../../tests/resources/test_3087.pdf')
+    
+    doc = fitz.open(path)
+    page = doc[0]
+    print(page.get_images())
+    base = doc.extract_image(5)["image"]
+    mask = doc.extract_image(5)["image"]
+    page = doc.new_page()
+    page.insert_image(page.rect, stream=base, mask=mask)
+    
+    doc = fitz.open(path)
+    page = doc[0]
+    print(page.get_images())
+    base = doc.extract_image(5)["image"]
+    mask = doc.extract_image(6)["image"]
+    page = doc.new_page()
+    page.insert_image(page.rect, stream=base, mask=mask)

{PyMuPDF-1.23.18 → PyMuPDF-1.23.19}/tests/test_pagedelete.py

@@ -13,6 +13,8 @@ Then delete some pages and verify:
 - the remaining TOC items still point to the correct page
 - the document has no more links at all
 """
+import os
+
 import fitz
 
 page_count = 100  # initial document length
@@ -67,3 +69,9 @@ def test_deletion():
     doc.copy_page(0)
     doc.move_page(0)
     doc.fullcopy_page(0)
+
+def test_3094():
+    path = os.path.abspath(f'{__file__}/../../tests/resources/test_2871.pdf')
+    document = fitz.open(path)
+    pnos = [i for i in range(0, document.page_count, 2)]
+    document.delete_pages(pnos)

{PyMuPDF-1.23.18 → PyMuPDF-1.23.19}/tests/test_tables.py

@@ -182,3 +182,35 @@ def test_3062():
     tab1 = page.find_tables()[0]
     cells1 = tab1.cells
     assert cells1 == cells0
+
+
+def test_strict_lines():
+    """Confirm that ignoring borderless rectangles improves table detection."""
+    filename = os.path.join(scriptdir, "resources", "strict-yes-no.pdf")
+    doc = fitz.open(filename)
+    page = doc[0]
+
+    tab1 = page.find_tables()[0]
+    tab2 = page.find_tables(strategy="lines_strict")[0]
+    assert tab2.row_count < tab1.row_count
+    assert tab2.col_count < tab1.col_count
+
+
+def test_add_lines():
+    """Test new parameter add_lines for table recognition."""
+    filename = os.path.join(scriptdir, "resources", "small-table.pdf")
+    doc = fitz.open(filename)
+    page = doc[0]
+    tab1 = page.find_tables()[0]
+    assert tab1.col_count == 1
+    assert tab1.row_count == 5
+    more_lines = [
+        ((238.9949951171875, 200.0), (238.9949951171875, 300.0)),
+        ((334.5559997558594, 200.0), (334.5559997558594, 300.0)),
+        ((433.1809997558594, 200.0), (433.1809997558594, 300.0)),
+    ]
+
+    # these 3 additional vertical lines should additional 3 columns
+    tab2 = page.find_tables(add_lines=more_lines)[0]
+    assert tab2.col_count == 4
+    assert tab2.row_count == 5

PyMuPDF-1.23.18/src_classic/version.i

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