PyMuPDF 1.25.0__tar.gz → 1.25.1__tar.gz

{pymupdf-1.25.0 → pymupdf-1.25.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyMuPDF
-Version: 1.25.0
+Version: 1.25.1
 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.25.0 → pymupdf-1.25.1}/changes.txt

@@ -2,6 +2,16 @@ Change Log
 ==========
 
 
+**Changes in version 1.25.1 (2024-12-11)**
+
+* Use MuPDF-1.25.2.
+
+* Fixed issues:
+
+  * **Fixed** `4125 <https://github.com/pymupdf/PyMuPDF/issues/4125>`_: memory leak while convert Pixmap's colorspace
+  * **Fixed** `4034 <https://github.com/pymupdf/PyMuPDF/issues/4034>`_: Possible regression in pdf cleaning during save.
+
+
 **Changes in version 1.25.0 (2024-12-05)**
 
 * Use MuPDF-1.25.1.

{pymupdf-1.25.0 → pymupdf-1.25.1}/pipcl.py

@@ -2444,6 +2444,50 @@ def relpath(path, start=None):
     else:
         return os.path.relpath(path, start)
 
+
+def number_sep( s):
+    '''
+    Simple number formatter, adds commas in-between thousands. `s` can be a
+    number or a string. Returns a string.
+
+    >>> number_sep(1)
+    '1'
+    >>> number_sep(12)
+    '12'
+    >>> number_sep(123)
+    '123'
+    >>> number_sep(1234)
+    '1,234'
+    >>> number_sep(12345)
+    '12,345'
+    >>> number_sep(123456)
+    '123,456'
+    >>> number_sep(1234567)
+    '1,234,567'
+    >>> number_sep(-131072)
+    '-131,072'
+    '''
+    if not isinstance( s, str):
+        s = str( s)
+    ret = ''
+    if s.startswith('-'):
+        ret += '-'
+        s = s[1:]
+    c = s.find( '.')
+    if c==-1:   c = len(s)
+    end = s.find('e')
+    if end == -1:   end = s.find('E')
+    if end == -1:   end = len(s)
+    for i in range( end):
+        ret += s[i]
+        if i<c-1 and (c-i-1)%3==0:
+            ret += ','
+        elif i>c and i<end-1 and (i-c)%3==0:
+            ret += ','
+    ret += s[end:]
+    return ret
+
+
 def _so_suffix(use_so_versioning=True):
     '''
     Filename suffix for shared libraries is defined in pep-3149.  The

{pymupdf-1.25.0 → pymupdf-1.25.1}/setup.py

@@ -1157,9 +1157,9 @@ classifier = [
 # We generate different wheels depending on PYMUPDF_SETUP_FLAVOUR.
 #
 
-version_p = '1.25.0'
-version_b = '1.25.0'
-version_mupdf = '1.25.1'
+version_p = '1.25.1'
+version_b = '1.25.1'
+version_mupdf = '1.25.2'
 
 if os.path.exists(f'{g_root}/{g_pymupdfb_sdist_marker}'):
     

{pymupdf-1.25.0 → pymupdf-1.25.1}/src/__init__.py

@@ -373,9 +373,9 @@ def _int_rc(text):
 
 # Basic version information.
 #
-pymupdf_version = "1.25.0"
+pymupdf_version = "1.25.1"
 mupdf_version = mupdf.FZ_VERSION
-pymupdf_date = "2024-12-05 00:00:01"
+pymupdf_date = "2024-12-11 00:00:01"
 
 # Versions as tuples; useful when comparing versions.
 #
@@ -3010,38 +3010,30 @@ class Document:
                                 #log( f'{handler.open=}')
                                 #log( f'{dir(handler.open)=}')
                                 try:
-                                    if mupdf_version_tuple >= (1, 24):
-                                        stream = mupdf.FzStream(filename)
-                                        accel = mupdf.FzStream()
-                                        archive = mupdf.FzArchive(None)
-                                        if mupdf_version_tuple >= (1, 24, 8):
-                                            doc = mupdf.ll_fz_document_handler_open(
-                                                    handler,
-                                                    stream.m_internal,
-                                                    accel.m_internal,
-                                                    archive.m_internal,
-                                                    None,   # recognize_state
-                                                    )
-                                        else:
-                                            doc = mupdf.ll_fz_document_open_fn_call(
-                                                    handler.open,
-                                                    stream.m_internal,
-                                                    accel.m_internal,
-                                                    archive.m_internal,
-                                                    )
+                                    stream = mupdf.FzStream(filename)
+                                    accel = mupdf.FzStream()
+                                    archive = mupdf.FzArchive(None)
+                                    if mupdf_version_tuple >= (1, 24, 8):
+                                        doc = mupdf.ll_fz_document_handler_open(
+                                                handler,
+                                                stream.m_internal,
+                                                accel.m_internal,
+                                                archive.m_internal,
+                                                None,   # recognize_state
+                                                )
                                     else:
-                                        doc = mupdf.ll_fz_document_open_fn_call( handler.open, filename)
+                                        doc = mupdf.ll_fz_document_open_fn_call(
+                                                handler.open,
+                                                stream.m_internal,
+                                                accel.m_internal,
+                                                archive.m_internal,
+                                                )
                                 except Exception as e:
                                     if g_exceptions_verbose > 1:    exception_info()
                                     raise FileDataError(f'Failed to open file {filename!r} as type {filetype!r}.') from e
                                 doc = mupdf.FzDocument( doc)
                             else:
-                                if mupdf_version_tuple < (1, 24):
-                                    if handler.open_with_stream:
-                                        data = mupdf.fz_open_file( filename)
-                                        doc = mupdf.fz_document_open_with_stream_fn_call( handler.open_with_stream, data)
-                                else:
-                                    assert 0
+                                assert 0
                         else:
                             raise ValueError( MSG_BAD_FILETYPE)
                 else:
@@ -4943,8 +4935,6 @@ class Document:
         lang = mupdf.pdf_document_language(pdf)
         if lang == mupdf.FZ_LANG_UNSET:
             return
-        if mupdf_version_tuple < (1, 23, 7):
-            assert 0, 'not implemented yet'
         return mupdf.fz_string_from_text_language2(lang)
 
     @property
@@ -5703,11 +5693,7 @@ class Document:
         pdf = _as_pdf_document(self)
         # create page sub-pdf via pdf_rearrange_pages2().
         #
-        if mupdf_version_tuple >= (1, 24):
-            mupdf.pdf_rearrange_pages2(pdf, pyliste)
-        else:
-            # mupdf.pdf_rearrange_pages2() not available.
-            extra.rearrange_pages2(pdf, tuple(pyliste))
+        mupdf.pdf_rearrange_pages2(pdf, pyliste)
 
         # remove any existing pages with their kids
         self._reset_page_refs()
@@ -8105,84 +8091,33 @@ class Page:
                     do_have_imask = 0
 
         if do_have_imask:
-            if mupdf_version_tuple >= (1, 24):
-                # `fz_compressed_buffer` is reference counted and
-                # `mupdf.fz_new_image_from_compressed_buffer2()`
-                # is povided as a Swig-friendly wrapper for
-                # `fz_new_image_from_compressed_buffer()`, so we can do things
-                # straightfowardly.
-                #
-                cbuf1 = mupdf.fz_compressed_image_buffer( image)
-                if not cbuf1.m_internal:
-                    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)
-                image = mupdf.fz_new_image_from_compressed_buffer2(
-                        w,
-                        h,
-                        bpc,
-                        colorspace,
-                        xres,
-                        yres,
-                        1,  # interpolate
-                        0,  # imagemask,
-                        list(), # decode
-                        list(), # colorkey
-                        cbuf1,
-                        mask,
-                        )
-            else:
-                #log( 'do_have_imask')
-                # mupdf.FzCompressedBuffer is not copyable, so
-                # mupdf.fz_compressed_image_buffer() does not work - it cannot
-                # return by value. And sharing a fz_compressed_buffer between 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)
-                
-                # 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 implementation 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
+            # `fz_compressed_buffer` is reference counted and
+            # `mupdf.fz_new_image_from_compressed_buffer2()`
+            # is povided as a Swig-friendly wrapper for
+            # `fz_new_image_from_compressed_buffer()`, so we can do things
+            # straightfowardly.
+            #
+            cbuf1 = mupdf.fz_compressed_image_buffer( image)
+            if not cbuf1.m_internal:
+                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)
+            image = mupdf.fz_new_image_from_compressed_buffer2(
+                    w,
+                    h,
+                    bpc,
+                    colorspace,
+                    xres,
+                    yres,
+                    1,  # interpolate
+                    0,  # imagemask,
+                    list(), # decode
+                    list(), # colorkey
+                    cbuf1,
+                    mask,
+                    )
             
         if do_have_image:
             #log( 'do_have_image')
@@ -9927,9 +9862,6 @@ class Pixmap:
         elif (args_match(args, (Pixmap, mupdf.FzPixmap), (float, int), (float, int), None) or
              args_match(args, (Pixmap, mupdf.FzPixmap), (float, int), (float, int))):
             # create pixmap as scaled copy of another one
-            if mupdf_version_tuple < (1, 23, 8):
-                assert 0, f'Cannot handle {args=} because fz_scale_pixmap() and fz_scale_pixmap_cached() are not declared in MuPDF headers'
-
             if len(args) == 3:
                 spix, w, h = args
                 bbox = mupdf.FzIrect(mupdf.fz_infinite_irect)
@@ -10152,10 +10084,7 @@ class Pixmap:
         elif format_ == 5:  mupdf.fz_write_pixmap_as_psd(out, pm)
         elif format_ == 6:  mupdf.fz_write_pixmap_as_ps(out, pm)
         elif format_ == 7:
-            if mupdf_version_tuple < (1, 24):
-                mupdf.fz_write_pixmap_as_jpeg(out, pm, jpg_quality)
-            else:
-                mupdf.fz_write_pixmap_as_jpeg(out, pm, jpg_quality, 0)
+            mupdf.fz_write_pixmap_as_jpeg(out, pm, jpg_quality, 0)
         else:
             mupdf.fz_write_pixmap_as_png(out, pm)
         out.fz_close_output()
@@ -10647,12 +10576,7 @@ class Pixmap:
     @property
     def size(self):
         """Pixmap size."""
-        if mupdf_version_tuple >= (1, 23, 8):
-            return  mupdf.fz_pixmap_size( self.this)
-        # fz_pixmap_size() is not publicly visible, so we implement it
-        # ourselves. fixme: we don't add on sizeof(fz_pixmap).
-        pm = self.this
-        return pm.n() * pm.w() * pm.h()
+        return  mupdf.fz_pixmap_size( self.this)
 
     @property
     def stride(self):
@@ -12690,15 +12614,10 @@ class TextPage:
                 continue
             img = block.i_image()
             img_size = 0
-            if mupdf_version_tuple >= (1, 24):
-                compr_buff = mupdf.fz_compressed_image_buffer(img)
-                if compr_buff.m_internal:
-                    img_size = compr_buff.fz_compressed_buffer_size()
-                    compr_buff = None
-            else:
-                compr_buff = mupdf.ll_fz_compressed_image_buffer(img.m_internal)
-                if compr_buff:
-                    img_size = mupdf.ll_fz_compressed_buffer_size(compr_buff)
+            compr_buff = mupdf.fz_compressed_image_buffer(img)
+            if compr_buff.m_internal:
+                img_size = compr_buff.fz_compressed_buffer_size()
+                compr_buff = None
             if hashes:
                 r = mupdf.FzIrect(FZ_MIN_INF_RECT, FZ_MIN_INF_RECT, FZ_MAX_INF_RECT, FZ_MAX_INF_RECT)
                 assert mupdf.fz_is_infinite_irect(r)
@@ -14834,35 +14753,7 @@ def JM_choice_options(annot):
     '''
     annot_obj = mupdf.pdf_annot_obj( annot.this)
     
-    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
-
-        opts = pdf_choice_widget_options( annot, 0)
+    opts = mupdf.pdf_choice_widget_options2( annot, 0)
     n = len( opts)
     if n == 0:
         return  # wrong widget type
@@ -16212,12 +16103,8 @@ def JM_image_reporter(page):
         def __init__(self):
             super().__init__()
             self.use_virtual_image_filter()
-        if mupdf_version_tuple >= (1, 23, 11):
-            def image_filter(self, ctx, ctm, name, image, scissor):
-                JM_image_filter(None, mupdf.FzMatrix(ctm), name, image)
-        else:
-            def image_filter(self, ctx, ctm, name, image):
-                JM_image_filter(None, mupdf.FzMatrix(ctm), name, image)
+        def image_filter(self, ctx, ctm, name, image, scissor):
+            JM_image_filter(None, mupdf.FzMatrix(ctm), name, image)
 
     sanitize_filter_options = SanitizeFilterOptions()
 
@@ -20877,97 +20764,8 @@ def paper_sizes():
         "tabloid-extra": (864, 1296),
         }
 
-if mupdf_version_tuple >= (1, 23, 8):
-    def pdf_lookup_page_loc(doc, needle):
-        return mupdf.pdf_lookup_page_loc(doc, needle)
-
-else:
-    def pdf_lookup_page_loc_imp(doc, node, skip, parentp, indexp):
-        assert isinstance(node, mupdf.PdfObj)
-        assert isinstance(skip, list) and len(skip) == 1
-        assert isinstance(indexp, list) and len(indexp) == 1
-        assert isinstance(parentp, list) and len(parentp) == 1 and isinstance(parentp[0], mupdf.PdfObj)
-        # Copy of MuPDF's internal pdf_lookup_page_loc_imp().
-        hit = None
-        stack = []
-        try:
-            while 1:
-                kids = mupdf.pdf_dict_get(node, PDF_NAME('Kids'))
-                len_ = mupdf.pdf_array_len( kids)
-
-                if len_ == 0:
-                    raise Exception("malformed page tree")
-
-                # Every node we need to unmark goes into the stack
-                stack.append(node)
-
-                if mupdf.pdf_mark_obj( node):
-                    raise Exception( "cycle in page tree")
-
-                for i in range(len_):
-                    kid = mupdf.pdf_array_get( kids, i)
-                    type_ = mupdf.pdf_dict_get( kid, PDF_NAME('Type'))
-                    if type_.m_internal:
-                        a = mupdf.pdf_name_eq( type_, PDF_NAME('Pages'))
-                    else:
-                        a = (
-                                mupdf.pdf_dict_get( kid, PDF_NAME('Kids')).m_internal
-                                and not mupdf.pdf_dict_get( kid, PDF_NAME('MediaBox')).m_internal
-                                )
-                    if a:
-                        count = mupdf.pdf_dict_get_int( kid, PDF_NAME('Count'))
-                        if (skip[0] < count):
-                            node = kid
-                            break
-                        else:
-                            skip[0] -= count
-                    else:
-                        if type_.m_internal:
-                            a = not mupdf.pdf_name_eq( type_, PDF_NAME('Page'))
-                        else:
-                            a = not mupdf.pdf_dict_get( kid, PDF_NAME('MediaBox')).m_internal
-                        if a:
-                            mupdf.fz_warn( f"non-page object in page tree ({mupdf.pdf_to_name( type_)})")
-                        if skip[0] == 0:
-                            parentp[0] = node
-                            indexp[0] = i
-                            hit = kid
-                            break
-                        else:
-                            skip[0] -= 1
-
-                # If i < len && hit != NULL the desired page was found in the
-                # Kids array, done. If i < len && hit == NULL the found page tree
-                # node contains a Kids array that contains the desired page, loop
-                # back to top to extract it. When i == len the Kids array has been
-                # exhausted without finding the desired page, give up.
-                if not ((hit is None or hit.m_internal is None) and i < len_):
-                    break
-        finally:
-            for i in range(len(stack), 0, -1): # (i = stack_len; i > 0; i--)
-                mupdf.pdf_unmark_obj( stack[i-1])
-
-        return hit
-
-    def pdf_lookup_page_loc(doc, needle):
-        '''
-        Copy of MuPDF's internal pdf_lookup_page_loc().
-        '''
-        root = mupdf.pdf_dict_get( mupdf.pdf_trailer( doc), PDF_NAME('Root'))
-        node = mupdf.pdf_dict_get( root, PDF_NAME('Pages'))
-        skip = [needle]
-
-        if not node.m_internal:
-            raise Exception("cannot find page tree")
-        parentp = [mupdf.PdfObj()]
-        indexp = [0]
-        hit = pdf_lookup_page_loc_imp(doc, node, skip, parentp, indexp)
-        skip = skip[0]
-        parentp = parentp[0]
-        indexp = indexp[0]
-        if not hit.m_internal:
-            raise Exception("cannot find page %d in page tree" % needle+1)
-        return hit, parentp, indexp  # We don't seem to return skip.
+def pdf_lookup_page_loc(doc, needle):
+    return mupdf.pdf_lookup_page_loc(doc, needle)
 
 
 def pdfobj_string(o, prefix=''):

{pymupdf-1.25.0 → pymupdf-1.25.1}/src/__main__.py

@@ -330,12 +330,9 @@ def embedded_del(args):
     ):
         sys.exit("cannot save PDF incrementally")
 
-    exception_types = (ValueError, pymupdf.mupdf.FzErrorBase)
-    if pymupdf.mupdf_version_tuple < (1, 24):
-        exception_types = ValueError
     try:
         doc.embfile_del(args.name)
-    except exception_types as e:    # pylint: disable=catching-non-exception
+    except (ValueError, pymupdf.mupdf.FzErrorBase) as e:
         sys.exit(f'no such embedded file {args.name!r}: {e}')
     if not args.output or args.output == args.input:
         doc.saveIncr()
@@ -347,13 +344,10 @@ def embedded_del(args):
 def embedded_get(args):
     """Retrieve contents of an embedded file."""
     doc = open_file(args.input, args.password, pdf=True)
-    exception_types = (ValueError, pymupdf.mupdf.FzErrorBase)
-    if pymupdf.mupdf_version_tuple < (1, 24):
-        exception_types = ValueError
     try:
         stream = doc.embfile_get(args.name)
         d = doc.embfile_info(args.name)
-    except exception_types as e:    # pylint: disable=catching-non-exception
+    except (ValueError, pymupdf.mupdf.FzErrorBase) as e:
         sys.exit(f'no such embedded file {args.name!r}: {e}')
     filename = args.output if args.output else d["filename"]
     with open(filename, "wb") as output:

{pymupdf-1.25.0 → pymupdf-1.25.1}/src/extra.i

@@ -256,23 +256,6 @@ PyObject* JM_EscapeStrFromBuffer(fz_buffer* buff)
     return val;
 }
 
-// Only used for mupdf < 1.24. mupdf >= 1.24 has pdf_rearrange_pages2().
-void rearrange_pages2(
-        mupdf::PdfDocument& doc,
-        PyObject *new_pages
-    )
-{
-    int len = (int) PyTuple_Size(new_pages);
-    int *pages = (int *) malloc((int) len * sizeof(int));
-    int i;
-    for (i = 0; i < len; i++) {
-        pages[i] = (int) PyLong_AsLong(PyTuple_GET_ITEM(new_pages, (Py_ssize_t) i));
-    }
-    mupdf::pdf_rearrange_pages(doc, len, pages);
-    free(pages);
-}
-
-
 //----------------------------------------------------------------------------
 // Deep-copies a source page to the target.
 // Modified version of function of pdfmerge.c: we also copy annotations, but
@@ -3973,40 +3956,6 @@ 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
-            );
-}
-
 %}
 
 /* Declarations for functions defined above. */
@@ -4129,18 +4078,3 @@ 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
-        );
-
-void rearrange_pages2( mupdf::PdfDocument& doc, PyObject *new_pages);

{pymupdf-1.25.0 → pymupdf-1.25.1}/src/utils.py

@@ -784,9 +784,6 @@ def get_textpage_ocr(
         bbox = pymupdf.Rect(block["bbox"])
         if bbox.width <= 3 or bbox.height <= 3:  # ignore tiny stuff
             continue
-        exception_types = (RuntimeError, mupdf.FzErrorBase)
-        if pymupdf.mupdf_version_tuple < (1, 24):
-            exception_types = RuntimeError
         try:
             pix = pymupdf.Pixmap(block["image"])  # get image pixmap
             if pix.n - pix.alpha != 3:  # we need to convert this to RGB!
@@ -805,7 +802,7 @@ def get_textpage_ocr(
             mat = shrink * block["transform"]
             imgpage.extend_textpage(tpage, flags=0, matrix=mat)
             imgdoc.close()
-        except exception_types:
+        except (RuntimeError, mupdf.FzErrorBase):
             if 0 and g_exceptions_verbose:
                 # Don't show exception info here because it can happen in
                 # normal operation (see test_3842b).
@@ -4418,14 +4415,11 @@ def apply_redactions(
         Returns:
             A rectangle to use instead of the annot rectangle.
         """
-        exception_types = (ValueError, mupdf.FzErrorBase)
-        if pymupdf.mupdf_version_tuple < (1, 24):
-            exception_types = ValueError
         if not new_text or annot_rect.width <= pymupdf.EPSILON:
             return annot_rect
         try:
             text_width = pymupdf.get_text_length(new_text, font, fsize)
-        except exception_types:  # unsupported font
+        except (ValueError, mupdf.FzErrorBase):  # unsupported font
             if g_exceptions_verbose:
                 pymupdf.exception_info()
             return annot_rect