PyMuPDF 1.24.11__cp38-abi3-win_amd64.whl

pymupdf/_apply_pages.py

@@ -0,0 +1,253 @@
+import multiprocessing
+import os
+import time
+
+import pymupdf
+
+
+# Support for concurrent processing of document pages.
+#
+
+class _worker_State:
+    pass
+_worker_state = _worker_State()
+
+
+def _worker_init(
+        path,
+        initfn,
+        initfn_args,
+        initfn_kwargs,
+        pagefn,
+        pagefn_args,
+        pagefn_kwargs,
+        stats,
+        ):
+    # pylint: disable=attribute-defined-outside-init
+    _worker_state.path = path
+    _worker_state.pagefn = pagefn
+    _worker_state.pagefn_args = pagefn_args
+    _worker_state.pagefn_kwargs = pagefn_kwargs
+    _worker_state.stats = stats
+    _worker_state.document = None
+    if initfn:
+        initfn(*initfn_args, **initfn_kwargs)
+
+
+def _stats_write(t, label):
+    t = time.time() - t
+    if t >= 0.1:
+        pymupdf.log(f'{os.getpid()=}: {t:2f}s: {label}.')
+
+
+def _worker_fn(page_number):
+    # Create Document from filename if we haven't already done so.
+    if not _worker_state.document:
+        if _worker_state.stats:
+            t = time.time()
+        _worker_state.document = pymupdf.Document(_worker_state.path)   # pylint: disable=attribute-defined-outside-init
+        if _worker_state.stats:
+            _stats_write(t, 'pymupdf.Document()')
+    
+    if _worker_state.stats:
+        t = time.time()
+    page = _worker_state.document[page_number]
+    if _worker_state.stats:
+        _stats_write(t, '_worker_state.document[page_number]')
+    
+    if _worker_state.stats:
+        t = time.time()
+    ret = _worker_state.pagefn(
+            page,
+            *_worker_state.pagefn_args,
+            **_worker_state.pagefn_kwargs,
+            )
+    if _worker_state.stats:
+        _stats_write(t, '_worker_state.pagefn()')
+    
+    return ret
+    
+
+def _multiprocessing(
+        path,
+        pages,
+        pagefn,
+        pagefn_args,
+        pagefn_kwargs,
+        initfn,
+        initfn_args,
+        initfn_kwargs,
+        concurrency,
+        stats,
+        ):
+    #print(f'_worker_mp(): {concurrency=}', flush=1)
+    with multiprocessing.Pool(
+            concurrency,
+            _worker_init,
+            (
+                path,
+                initfn, initfn_args, initfn_kwargs,
+                pagefn, pagefn_args, pagefn_kwargs,
+                stats,
+            ),
+            ) as pool:
+        result = pool.map_async(_worker_fn, pages)
+        return result.get()
+    
+
+def _fork(
+        path,
+        pages,
+        pagefn,
+        pagefn_args,
+        pagefn_kwargs,
+        initfn,
+        initfn_args,
+        initfn_kwargs,
+        concurrency,
+        stats,
+        ):
+    verbose = 0
+    if concurrency is None:
+        concurrency = multiprocessing.cpu_count()
+    # We write page numbers to `queue_down` and read `(page_num, text)` from
+    # `queue_up`. Workers each repeatedly read the next available page number
+    # from `queue_down`, extract the text and write it onto `queue_up`.
+    #
+    # This is better than pre-allocating a subset of pages to each worker
+    # because it ensures there will never be idle workers until we are near the
+    # end with fewer pages left than workers.
+    #
+    queue_down = multiprocessing.Queue()
+    queue_up = multiprocessing.Queue()
+    def childfn():
+        document = None
+        if verbose:
+            pymupdf.log(f'{os.getpid()=}: {initfn=} {initfn_args=}')
+        _worker_init(
+                path,
+                initfn,
+                initfn_args,
+                initfn_kwargs,
+                pagefn,
+                pagefn_args,
+                pagefn_kwargs,
+                stats,
+                )
+        while 1:
+            if verbose:
+                pymupdf.log(f'{os.getpid()=}: calling get().')
+            page_num = queue_down.get()
+            if verbose:
+                pymupdf.log(f'{os.getpid()=}: {page_num=}.')
+            if page_num is None:
+                break
+            try:
+                if not document:
+                    if stats:
+                        t = time.time()
+                    document = pymupdf.Document(path)
+                    if stats:
+                        _stats_write(t, 'pymupdf.Document(path)')
+                
+                if stats:
+                    t = time.time()
+                page = document[page_num]
+                if stats:
+                    _stats_write(t, 'document[page_num]')
+                
+                if verbose:
+                    pymupdf.log(f'{os.getpid()=}: {_worker_state=}')
+                
+                if stats:
+                    t = time.time()
+                ret = pagefn(
+                        page,
+                        *_worker_state.pagefn_args,
+                        **_worker_state.pagefn_kwargs,
+                        )
+                if stats:
+                    _stats_write(t, f'{page_num=} pagefn()')
+            except Exception as e:
+                if verbose: pymupdf.log(f'{os.getpid()=}: exception {e=}')
+                ret = e
+            if verbose:
+                pymupdf.log(f'{os.getpid()=}: sending {page_num=} {ret=}')
+                
+            queue_up.put( (page_num, ret) )
+
+    error = None
+
+    pids = list()
+    try:
+        # Start child processes.
+        if stats:
+            t = time.time()
+        for i in range(concurrency):
+            p = os.fork()   # pylint: disable=no-member
+            if p == 0:
+                # Child process.
+                try:
+                    try:
+                        childfn()
+                    except Exception as e:
+                        pymupdf.log(f'{os.getpid()=}: childfn() => {e=}')
+                        raise
+                finally:
+                    if verbose:
+                        pymupdf.log(f'{os.getpid()=}: calling os._exit(0)')
+                    os._exit(0)
+            pids.append(p)
+        if stats:
+            _stats_write(t, 'create child processes')
+
+        # Send page numbers.
+        if stats:
+            t = time.time()
+        if verbose:
+            pymupdf.log(f'Sending page numbers.')
+        for page_num in range(len(pages)):
+            queue_down.put(page_num)
+        if stats:
+            _stats_write(t, 'Send page numbers')
+
+        # Collect results. We give up if any worker sends an exception instead
+        # of text, but this hasn't been tested.
+        ret = [None] * len(pages)
+        for i in range(len(pages)):
+            page_num, text = queue_up.get()
+            if verbose:
+                pymupdf.log(f'{page_num=} {len(text)=}')
+            assert ret[page_num] is None
+            if isinstance(text, Exception):
+                if not error:
+                    error = text
+                break
+            ret[page_num] = text
+
+        # Close queue. This should cause exception in workers and terminate
+        # them, but on macos-arm64 this does not seem to happen, so we also
+        # send None, which makes workers terminate.
+        for i in range(concurrency):
+            queue_down.put(None)
+        if verbose: pymupdf.log(f'Closing queues.')
+        queue_down.close()
+
+        if error:
+            raise error
+        if verbose:
+            pymupdf.log(f'After concurrent, returning {len(ret)=}')
+        return ret
+        
+    finally:
+        # Join all child processes.
+        if stats:
+            t = time.time()
+        for pid in pids:
+            if verbose:
+                pymupdf.log(f'waiting for {pid=}.')
+            e = os.waitpid(pid, 0)
+            if verbose:
+                pymupdf.log(f'{pid=} => {e=}')
+        if stats:
+            _stats_write(t, 'Join all child proceses')

pymupdf/_build.py

@@ -0,0 +1 @@
+mupdf_location='https://mupdf.com/downloads/archive/mupdf-1.24.10-source.tar.gz'

pymupdf/extra.py

@@ -0,0 +1,214 @@
+# This file was automatically generated by SWIG (https://www.swig.org).
+# Version 4.2.1
+#
+# Do not make changes to this file unless you know what you are doing - modify
+# the SWIG interface file instead.
+
+from sys import version_info as _swig_python_version_info
+# Import the low-level C/C++ module
+if __package__ or "." in __name__:
+    from . import _extra
+else:
+    import _extra
+
+try:
+    import builtins as __builtin__
+except ImportError:
+    import __builtin__
+
+def _swig_repr(self):
+    try:
+        strthis = "proxy of " + self.this.__repr__()
+    except __builtin__.Exception:
+        strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+
+def _swig_setattr_nondynamic_instance_variable(set):
+    def set_instance_attr(self, name, value):
+        if name == "this":
+            set(self, name, value)
+        elif name == "thisown":
+            self.this.own(value)
+        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
+            set(self, name, value)
+        else:
+            raise AttributeError("You cannot add instance attributes to %s" % self)
+    return set_instance_attr
+
+
+def _swig_setattr_nondynamic_class_variable(set):
+    def set_class_attr(cls, name, value):
+        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
+            set(cls, name, value)
+        else:
+            raise AttributeError("You cannot add class attributes to %s" % cls)
+    return set_class_attr
+
+
+def _swig_add_metaclass(metaclass):
+    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
+    def wrapper(cls):
+        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
+    return wrapper
+
+
+class _SwigNonDynamicMeta(type):
+    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
+    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
+
+
+
+# pylint: disable=all
+
+
+def page_merge(doc_des, doc_src, page_from, page_to, rotate, links, copy_annots, graft_map):
+    return _extra.page_merge(doc_des, doc_src, page_from, page_to, rotate, links, copy_annots, graft_map)
+
+def JM_merge_range(doc_des, doc_src, spage, epage, apage, rotate, links, annots, show_progress, graft_map):
+    return _extra.JM_merge_range(doc_des, doc_src, spage, epage, apage, rotate, links, annots, show_progress, graft_map)
+
+def FzDocument_insert_pdf(doc, src, from_page, to_page, start_at, rotate, links, annots, show_progress, final, graft_map):
+    return _extra.FzDocument_insert_pdf(doc, src, from_page, to_page, start_at, rotate, links, annots, show_progress, final, graft_map)
+
+def page_xref(this_doc, pno):
+    return _extra.page_xref(this_doc, pno)
+
+def _newPage(*args):
+    return _extra._newPage(*args)
+
+def JM_add_annot_id(annot, stem):
+    return _extra.JM_add_annot_id(annot, stem)
+
+def JM_get_annot_id_list(page):
+    return _extra.JM_get_annot_id_list(page)
+
+def _add_caret_annot(*args):
+    return _extra._add_caret_annot(*args)
+
+def Tools_parse_da(this_annot):
+    return _extra.Tools_parse_da(this_annot)
+
+def Annot_getAP(annot):
+    return _extra.Annot_getAP(annot)
+
+def Tools_update_da(this_annot, da_str):
+    return _extra.Tools_update_da(this_annot, da_str)
+
+def JM_point_from_py(p):
+    return _extra.JM_point_from_py(p)
+
+def Annot_rect(annot):
+    return _extra.Annot_rect(annot)
+
+def util_transform_rect(rect, matrix):
+    return _extra.util_transform_rect(rect, matrix)
+
+def Annot_rect3(annot):
+    return _extra.Annot_rect3(annot)
+
+def Page_derotate_matrix(*args):
+    return _extra.Page_derotate_matrix(*args)
+
+def JM_get_annot_xref_list(page_obj):
+    return _extra.JM_get_annot_xref_list(page_obj)
+
+def xref_object(*args):
+    return _extra.xref_object(*args)
+
+def Link_is_external(this_link):
+    return _extra.Link_is_external(this_link)
+
+def Page_addAnnot_FromString(*args):
+    return _extra.Page_addAnnot_FromString(*args)
+
+def Link_next(this_link):
+    return _extra.Link_next(this_link)
+
+def page_count_fz2(document):
+    return _extra.page_count_fz2(document)
+
+def page_count_fz(document):
+    return _extra.page_count_fz(document)
+
+def page_count_pdf(pdf):
+    return _extra.page_count_pdf(pdf)
+
+def page_count(*args):
+    return _extra.page_count(*args)
+
+def page_annot_xrefs(*args):
+    return _extra.page_annot_xrefs(*args)
+
+def Outline_is_external(outline):
+    return _extra.Outline_is_external(outline)
+
+def Document_extend_toc_items(*args):
+    return _extra.Document_extend_toc_items(*args)
+
+def ll_fz_absi(i):
+    return _extra.ll_fz_absi(i)
+
+def JM_new_texttrace_device(out):
+    return _extra.JM_new_texttrace_device(out)
+
+def JM_char_bbox(line, ch):
+    return _extra.JM_char_bbox(line, ch)
+
+def JM_char_quad(line, ch):
+    return _extra.JM_char_quad(line, ch)
+
+def JM_print_stext_page_as_text(res, page):
+    return _extra.JM_print_stext_page_as_text(res, page)
+
+def set_skip_quad_corrections(on):
+    return _extra.set_skip_quad_corrections(on)
+
+def set_subset_fontnames(on):
+    return _extra.set_subset_fontnames(on)
+
+def set_small_glyph_heights(on):
+    return _extra.set_small_glyph_heights(on)
+
+def JM_cropbox(page_obj):
+    return _extra.JM_cropbox(page_obj)
+
+def get_cdrawings(page, extended=None, callback=None, method=None):
+    return _extra.get_cdrawings(page, extended, callback, method)
+
+def JM_make_spanlist(line_dict, line, raw, buff, tp_rect):
+    return _extra.JM_make_spanlist(line_dict, line, raw, buff, tp_rect)
+
+def extractWORDS(this_tpage, delimiters):
+    return _extra.extractWORDS(this_tpage, delimiters)
+
+def extractBLOCKS(_self):
+    return _extra.extractBLOCKS(_self)
+
+def link_uri(link):
+    return _extra.link_uri(link)
+
+def page_get_textpage(_self, clip, flags, matrix):
+    return _extra.page_get_textpage(_self, clip, flags, matrix)
+
+def JM_make_textpage_dict(tp, page_dict, raw):
+    return _extra.JM_make_textpage_dict(tp, page_dict, raw)
+
+def pixmap_pixel(pm, x, y):
+    return _extra.pixmap_pixel(pm, x, y)
+
+def pixmap_n(pixmap):
+    return _extra.pixmap_n(pixmap)
+
+def JM_search_stext_page(page, needle):
+    return _extra.JM_search_stext_page(page, needle)
+
+def set_pixel(pm, x, y, color):
+    return _extra.set_pixel(pm, x, y, color)
+
+def fz_new_image_from_compressed_buffer(w, h, bpc, colorspace, xres, yres, interpolate, imagemask, buffer, mask):
+    return _extra.fz_new_image_from_compressed_buffer(w, h, bpc, colorspace, xres, yres, interpolate, imagemask, buffer, mask)
+
+def rearrange_pages2(doc, new_pages):
+    return _extra.rearrange_pages2(doc, new_pages)
+