pdf2docx-healer 0.1.2__tar.gz

pdf2docx_healer-0.1.2/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: pdf2docx-healer
+Version: 0.1.2
+Summary: Formatting-preserving PDF-to-DOCX converter that fixes bullet lists, hyperlinks, CJK fonts, and scanned PDFs
+License-Expression: MIT
+Project-URL: homepage, https://github.com/krockxz/pdf2docx-healer
+Project-URL: repository, https://github.com/krockxz/pdf2docx-healer
+Project-URL: issues, https://github.com/krockxz/pdf2docx-healer/issues
+Project-URL: changelog, https://github.com/krockxz/pdf2docx-healer/releases
+Keywords: pdf,docx,converter,pdf-to-docx,formatting,hyperlink,ocr,cjk,bullet-list
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Office/Business :: Office Suites
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pdf2docx>=0.5.0
+Requires-Dist: PyMuPDF>=1.23.0
+Requires-Dist: python-docx>=0.8.11
+Requires-Dist: lxml
+Provides-Extra: ocr
+Requires-Dist: pytesseract>=0.3.10; extra == "ocr"
+
+# pdf2docx-healer
+
+Formatting-preserving PDF-to-DOCX converter that fixes:
+
+- Bullet and numbered lists (proper Word list styles)
+- Hyperlinks (extracted from PDF annotations)
+- CJK and unavailable font fallback
+- Scanned/image-based PDFs (via OCR)
+
+## Usage
+
+```python
+from docx_healer import heal
+
+heal("input.pdf", "output.docx")
+```
+
+```bash
+pdf2docx-heal input.pdf -o output.docx
+```

pdf2docx_healer-0.1.2/README.md

@@ -0,0 +1,20 @@
+# pdf2docx-healer
+
+Formatting-preserving PDF-to-DOCX converter that fixes:
+
+- Bullet and numbered lists (proper Word list styles)
+- Hyperlinks (extracted from PDF annotations)
+- CJK and unavailable font fallback
+- Scanned/image-based PDFs (via OCR)
+
+## Usage
+
+```python
+from docx_healer import heal
+
+heal("input.pdf", "output.docx")
+```
+
+```bash
+pdf2docx-heal input.pdf -o output.docx
+```

pdf2docx_healer-0.1.2/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pdf2docx-healer"
+version = "0.1.2"
+description = "Formatting-preserving PDF-to-DOCX converter that fixes bullet lists, hyperlinks, CJK fonts, and scanned PDFs"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+dependencies = [
+    "pdf2docx>=0.5.0",
+    "PyMuPDF>=1.23.0",
+    "python-docx>=0.8.11",
+    "lxml",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Text Processing",
+    "Topic :: Office/Business :: Office Suites",
+]
+keywords = ["pdf", "docx", "converter", "pdf-to-docx", "formatting", "hyperlink", "ocr", "cjk", "bullet-list"]
+
+[project.optional-dependencies]
+ocr = ["pytesseract>=0.3.10"]
+
+[project.scripts]
+pdf2docx-heal = "docx_healer.cli:main"
+
+[project.urls]
+homepage = "https://github.com/krockxz/pdf2docx-healer"
+repository = "https://github.com/krockxz/pdf2docx-healer"
+issues = "https://github.com/krockxz/pdf2docx-healer/issues"
+changelog = "https://github.com/krockxz/pdf2docx-healer/releases"
+
+[tool.setuptools.packages.find]
+where = ["src"]

pdf2docx_healer-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pdf2docx_healer-0.1.2/src/docx_healer/__init__.py

@@ -0,0 +1,6 @@
+"""pdf2docx-healer: Formatting-preserving PDF-to-DOCX converter."""
+
+from .converter import heal, HealerConfig
+
+__version__ = "0.1.2"
+__all__ = ["heal", "HealerConfig"]

pdf2docx_healer-0.1.2/src/docx_healer/__main__.py

@@ -0,0 +1,6 @@
+"""Allow `python -m docx_healer` to invoke the CLI."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

pdf2docx_healer-0.1.2/src/docx_healer/cli.py

@@ -0,0 +1,60 @@
+"""Command-line interface for pdf2docx-healer."""
+
+import argparse
+import sys
+from pathlib import Path
+from .converter import heal, HealerConfig
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="pdf2docx-heal",
+        description="Convert PDF to DOCX preserving bullet lists, hyperlinks, and CJK fonts.",
+    )
+    parser.add_argument("pdf", type=Path, help="Input PDF file path")
+    parser.add_argument("-o", "--output", type=Path, default=None,
+                        help="Output DOCX file path (default: input filename with .docx extension)")
+    parser.add_argument("--ocr", action="store_true",
+                        help="Enable OCR for scanned/image-based PDFs")
+    parser.add_argument("--ocr-lang", default="eng",
+                        help="Tesseract language code for OCR (default: eng)")
+    parser.add_argument("--ocr-dpi", type=int, default=300,
+                        help="OCR resolution in DPI (default: 300)")
+    parser.add_argument("--ocr-threshold", type=float, default=0.3,
+                        help="Fraction of textless pages to trigger OCR (default: 0.3)")
+    parser.add_argument("--no-lists", action="store_true",
+                        help="Skip bullet/numbered list detection and formatting")
+    parser.add_argument("--no-hyperlinks", action="store_true",
+                        help="Skip hyperlink extraction")
+    parser.add_argument("--no-font-fix", action="store_true",
+                        help="Skip CJK font fallback mapping")
+    parser.add_argument("--aggressive", action="store_true",
+                        help="Use aggressive paragraph splitting for list detection")
+    parser.add_argument("-q", "--quiet", action="store_true",
+                        help="Suppress progress output")
+
+    args = parser.parse_args()
+
+    if not args.pdf.exists():
+        print(f"Error: PDF file not found: {args.pdf}", file=sys.stderr)
+        sys.exit(1)
+
+    output = args.output or args.pdf.with_suffix(".docx")
+
+    config = HealerConfig(
+        ocr_enabled=args.ocr,
+        ocr_lang=args.ocr_lang,
+        ocr_dpi=args.ocr_dpi,
+        ocr_threshold=args.ocr_threshold,
+        fix_lists=not args.no_lists,
+        fix_hyperlinks=not args.no_hyperlinks,
+        fix_fonts=not args.no_font_fix,
+        aggressive_lists=args.aggressive,
+        verbose=not args.quiet,
+    )
+
+    heal(str(args.pdf), str(output), config=config)
+
+
+if __name__ == "__main__":
+    main()

pdf2docx_healer-0.1.2/src/docx_healer/constants.py

@@ -0,0 +1,51 @@
+"""Shared constants for docx_healer."""
+
+# Unicode bullet codepoints
+BULLET_CODEPOINTS = frozenset({
+    0x2022, 0x2023, 0x2043, 0x204C, 0x204D, 0x2219,
+    0x25AA, 0x25CB, 0x25CF, 0x25D8, 0x25E6, 0x2619,
+    0x2765, 0x2767, 0x29BE, 0x29BF, 0xF0B7,
+    0x2013, 0x2014, 0x00B7, 0x2713, 0x2714,
+    0x2610, 0x2611, 0x2612,
+})
+
+# Font fallback chain: PyMuPDF name -> [Windows preferred, macOS, Linux, universal]
+FONT_FALLBACK_MAP = {
+    'SimSun': ['SimSun', '\u5b8b\u4f53', 'Microsoft YaHei', '\u5fae\u8f6f\u96c5\u9ed1', 'Arial Unicode MS', 'Noto Sans CJK SC'],
+    'SimHei': ['SimHei', '\u9ed1\u4f53', 'Microsoft YaHei', '\u5fae\u8f6f\u96c5\u9ed1', 'Arial Unicode MS', 'Noto Sans CJK SC'],
+    'KaiTi': ['KaiTi', '\u6977\u4f53', 'SimSun', 'Microsoft YaHei', 'Noto Sans CJK SC'],
+    'FangSong': ['FangSong', '\u4eff\u5b8b', 'SimSun', 'Noto Serif CJK SC'],
+    'FangSong_GB2312': ['FangSong', '\u4eff\u5b8b', 'SimSun', 'Noto Serif CJK SC'],
+    'MS-Mincho': ['MS Mincho', 'Yu Mincho', 'Meiryo', 'Noto Serif CJK JP'],
+    'MS-Gothic': ['MS Gothic', 'Yu Gothic', 'Meiryo', 'Noto Sans CJK JP'],
+    'MS-PGothic': ['MS PGothic', 'Yu Gothic', 'Meiryo', 'Noto Sans CJK JP'],
+    'HYGoThic-Medium': ['Apple SD Gothic Neo', 'Malgun Gothic', 'Gulim', 'Noto Sans CJK KR'],
+    'HYSMyeongJo-Medium': ['AppleMyungjo', 'Batang', 'Noto Serif CJK KR'],
+    'AppleMyungjo': ['Apple SD Gothic Neo', 'Batang', 'Noto Serif CJK KR'],
+    'TimesNewRomanPSMT': ['Times New Roman', 'Times', 'Liberation Serif'],
+    'TimesNewRomanPS-BoldMT': ['Times New Roman', 'Times', 'Liberation Serif'],
+    'TimesNewRomanPS-ItalicMT': ['Times New Roman', 'Times', 'Liberation Serif'],
+    'ArialMT': ['Arial', 'Helvetica', 'Liberation Sans'],
+    'Arial-BoldMT': ['Arial', 'Helvetica', 'Liberation Sans'],
+    'CourierNewPSMT': ['Courier New', 'Consolas', 'Liberation Mono'],
+    'Helvetica': ['Arial', 'Helvetica', 'Liberation Sans'],
+    'Helvetica-Bold': ['Arial', 'Helvetica', 'Liberation Sans'],
+    'Symbol': ['Symbol', 'Segoe UI Symbol'],
+    'ZapfDingbats': ['Segoe UI Symbol', 'Symbol'],
+    'UNNAMED': ['Arial', 'Helvetica', 'Liberation Sans'],
+    'helv': ['Arial', 'Helvetica', 'Liberation Sans'],
+}
+
+CHAR_RANGE_FONT_MAP = [
+    ((0x4E00, 0x9FFF), 'SimSun'),
+    ((0x3400, 0x4DBF), 'SimSun'),
+    ((0x20000, 0x2A6DF), 'SimSun'),
+    ((0x3040, 0x309F), 'Meiryo'),
+    ((0x30A0, 0x30FF), 'Meiryo'),
+    ((0xAC00, 0xD7AF), 'Malgun Gothic'),
+    ((0x0600, 0x06FF), 'Arabic Typesetting'),
+    ((0x0590, 0x05FF), 'David'),
+    ((0x0E00, 0x0E7F), 'Leelawadee UI'),
+    ((0x0900, 0x097F), 'Mangal'),
+    ((0x0400, 0x04FF), 'Times New Roman'),
+]

pdf2docx_healer-0.1.2/src/docx_healer/converter.py

@@ -0,0 +1,123 @@
+"""Main ConverterHealer — orchestrates the 4-phase pipeline."""
+
+import os
+import json
+import tempfile
+from dataclasses import dataclass
+
+
+@dataclass
+class HealerConfig:
+    """Configuration for the pdf2docx-healer pipeline."""
+    # OCR settings
+    ocr_enabled: bool = False
+    ocr_lang: str = 'eng'
+    ocr_dpi: int = 300
+    ocr_threshold: float = 0.3
+    
+    # Feature toggles
+    fix_lists: bool = True
+    fix_hyperlinks: bool = True
+    fix_fonts: bool = True
+    
+    # List detection
+    aggressive_lists: bool = False
+    
+    # Output
+    verbose: bool = True
+
+
+def heal(pdf_path, docx_path=None, config=None):
+    """Convert PDF to DOCX preserving formatting (bullets, hyperlinks, fonts).
+
+    This is the main entry point running the 4-phase pipeline:
+    1. Pre-parse: OCR scanned PDFs if needed
+    2. Intercept: Monkey-patch pdf2docx for list detection
+    3. Convert: Run pdf2docx with patched internals
+    4. Post-process: List styles, hyperlinks, font mapping on final DOCX
+    """
+    if config is None:
+        config = HealerConfig()
+    
+    if docx_path is None:
+        docx_path = os.path.splitext(pdf_path)[0] + '.docx'
+    
+    verbose = config.verbose
+    
+    # === Phase 1: Pre-parse — OCR detection ===
+    actual_pdf = pdf_path
+    tmp_pdf = None
+    
+    if config.ocr_enabled:
+        from .ocr_pipeline import needs_ocr, ocr_pdf_file
+        import fitz
+        
+        src_doc = fitz.open(pdf_path)
+        try:
+            if needs_ocr(src_doc, threshold=config.ocr_threshold):
+                src_doc.close()
+                tmp_pdf = ocr_pdf_file(
+                    pdf_path,
+                    language=config.ocr_lang,
+                    dpi=config.ocr_dpi,
+                    verbose=verbose
+                )
+                actual_pdf = tmp_pdf
+            else:
+                src_doc.close()
+        except Exception as e:
+            if verbose:
+                print(f"[healer] OCR skipped: {e}")
+            try:
+                src_doc.close()
+            except Exception:
+                pass
+    
+    try:
+        # === Phase 2: Intercept — Apply monkey-patches ===
+        if config.fix_lists:
+            from .patches import apply_patches
+            apply_patches(verbose=verbose)
+        
+        # === Phase 3: Convert ===
+        _convert(actual_pdf, docx_path, verbose=verbose)
+        
+        # === Phase 4: Post-process ===
+        from .post_processor import post_process_docx
+        post_process_docx(
+            docx_path,
+            fix_lists=config.fix_lists,
+            fix_hyperlinks=config.fix_hyperlinks,
+            fix_fonts=config.fix_fonts,
+            aggressive_lists=config.aggressive_lists,
+            verbose=verbose,
+        )
+        
+        if verbose:
+            print(f"[healer] Done: {docx_path}")
+        
+        return docx_path
+    
+    finally:
+        if tmp_pdf and os.path.exists(tmp_pdf):
+            try:
+                os.unlink(tmp_pdf)
+            except OSError:
+                pass
+
+
+def _convert(pdf_path, docx_path, verbose=False):
+    """Run pdf2docx conversion with default settings."""
+    if verbose:
+        print("[healer] Converting...")
+
+    from pdf2docx import Converter
+    if not verbose:
+        import logging
+        logging.getLogger().setLevel(logging.WARNING)
+
+    cv = Converter(pdf_path)
+    try:
+        cv.convert(docx_path)
+    finally:
+        cv.close()

pdf2docx_healer-0.1.2/src/docx_healer/font_mapper.py

@@ -0,0 +1,88 @@
+"""Font fallback mapping for CJK and unavailable fonts."""
+
+from .constants import FONT_FALLBACK_MAP, CHAR_RANGE_FONT_MAP
+
+
+def normalize_font_name(original_name, text_sample=''):
+    """Resolve a PyMuPDF/PDF font name to one commonly available on the target system.
+    
+    Args:
+        original_name: Font name from pdf2docx span (e.g., 'SimSun', 'TimesNewRomanPSMT').
+        text_sample: Sample characters to use for character-based fallback.
+    
+    Returns:
+        A resolved font name string.
+    """
+    if not original_name:
+        return 'Arial'
+    
+    name = original_name.strip()
+    
+    # Exact match in fallback map
+    if name in FONT_FALLBACK_MAP:
+        return FONT_FALLBACK_MAP[name][0]
+    
+    # Check normalized name (strip prefix like 'BAAAAA+' from subset fonts)
+    if '+' in name:
+        base_name = name.split('+', 1)[-1]
+    else:
+        base_name = name
+    
+    if base_name in FONT_FALLBACK_MAP:
+        return FONT_FALLBACK_MAP[base_name][0]
+    
+    # Case-insensitive lookup
+    name_upper = base_name.upper()
+    for key, fallback in FONT_FALLBACK_MAP.items():
+        if key.upper() == name_upper:
+            return fallback[0]
+    
+    # Character-based fallback (check text content)
+    if text_sample:
+        for (lo, hi), fallback_font in CHAR_RANGE_FONT_MAP:
+            if any(lo <= ord(c) <= hi for c in text_sample):
+                # Look up the range-matched font in our fallback map
+                if fallback_font in FONT_FALLBACK_MAP:
+                    return FONT_FALLBACK_MAP[fallback_font][0]
+                return fallback_font
+    
+    # Ultimate fallback
+    return 'Arial'
+
+
+def fix_docx_fonts(docx_path, verbose=False):
+    """Open a DOCX and fix font names using the fallback map.
+    
+    Args:
+        docx_path: Path to the DOCX file to fix in-place.
+        verbose: Print progress information.
+    
+    Returns:
+        Number of font names fixed.
+    """
+    from docx import Document
+    
+    doc = Document(docx_path)
+    fixed = 0
+    
+    for paragraph in doc.paragraphs:
+        try:
+            for run in paragraph.runs:
+                original = run.font.name
+                if original:
+                    normalized = normalize_font_name(original, run.text)
+                    if normalized != original:
+                        run.font.name = normalized
+                        fixed += 1
+        except Exception:
+            if verbose:
+                import traceback
+                traceback.print_exc()
+            continue
+    
+    if fixed > 0:
+        doc.save(docx_path)
+        if verbose:
+            print(f"[healer] Fixed {fixed} font name(s) in {docx_path}")
+    
+    return fixed

pdf2docx_healer-0.1.2/src/docx_healer/link_injector.py

@@ -0,0 +1,165 @@
+"""Hyperlink injection via python-docx post-processing (not store/restore)."""
+
+import re
+from docx.oxml.ns import qn
+from docx.oxml import OxmlElement
+from docx.opc.constants import RELATIONSHIP_TYPE as RT
+from lxml import etree
+
+# URL pattern
+_URL_PATTERN = re.compile(
+    r'https?://[^\s<>"\')\]]+|'
+    r'ftp://[^\s<>"\')\]]+|'
+    r'www\.[^\s<>"\')\]]+\.[a-zA-Z]{2,}[^\s<>"\')\]]*|'
+    r'mailto:[^\s<>"\')\]]+',
+    re.IGNORECASE
+)
+
+
+def fix_docx_hyperlinks(docx_path, verbose=False):
+    """Post-process: find URL text in runs and wrap them in OOXML hyperlinks.
+
+    Opens the DOCX, scans all runs for URLs, and replaces plain-text URLs
+    with clickable hyperlinks in-place.
+
+    Returns number of hyperlinks added.
+    """
+    from docx import Document
+    doc = Document(docx_path)
+    count = 0
+
+    for paragraph in doc.paragraphs:
+        count += _hyperlink_urls_in_paragraph(paragraph)
+
+    if count > 0:
+        doc.save(docx_path)
+        if verbose:
+            print(f"[healer] Added {count} hyperlink(s) in {docx_path}")
+
+    return count
+
+
+def _hyperlink_urls_in_paragraph(paragraph):
+    """Find URLs in paragraph runs and convert them to hyperlinks.
+
+    Strategy: for each run containing URL(s), split the run into
+    text-before / hyperlink / text-after segments, processing ALL URLs
+    in the run (not just the first).
+
+    NOTE: This function modifies the paragraph XML tree by inserting and
+    removing elements.  python-docx's in-memory ``paragraph.runs`` view
+    is not refreshed after these changes, so the caller must not rely on
+    it being up-to-date.  Because we iterate over a snapshot (``list()``)
+    and save the document immediately afterwards, this is safe.
+    """
+    count = 0
+    runs = list(paragraph.runs)
+
+    for run in runs:
+        if not run.text:
+            continue
+        urls = _URL_PATTERN.findall(run.text)
+        if not urls:
+            continue
+
+        # Check if run is already inside a hyperlink
+        if run._element.getparent() is not None:
+            parent_tag = run._element.getparent().tag
+            if parent_tag == qn('w:hyperlink'):
+                continue
+
+        run_elem = run._element
+        parent = run_elem.getparent()
+        orig_rPr = run_elem.find(qn('w:rPr'))
+        insert_pos = parent.index(run_elem)
+        parent.remove(run_elem)
+
+        remaining_text = run.text
+
+        for url_match in urls:
+            original_url = url_match
+            target_url = url_match
+            if '://' not in target_url and not target_url.startswith('mailto:'):
+                target_url = 'https://' + target_url
+
+            idx = remaining_text.find(original_url)
+            if idx < 0:
+                continue
+
+            before = remaining_text[:idx]
+            after = remaining_text[idx + len(original_url):]
+
+            if before:
+                before_run = OxmlElement('w:r')
+                if orig_rPr is not None:
+                    before_run.append(copy_rPr(orig_rPr))
+                before_run.text = before
+                parent.insert(insert_pos, before_run)
+                insert_pos += 1
+
+            hyperlink = _build_hyperlink(paragraph, target_url, run)
+            parent.insert(insert_pos, hyperlink)
+            hyperlink[0].text = original_url
+            insert_pos += 1
+            count += 1
+
+            remaining_text = after
+
+        if remaining_text:
+            after_run = OxmlElement('w:r')
+            if orig_rPr is not None:
+                after_run.append(copy_rPr(orig_rPr))
+            after_run.text = remaining_text
+            parent.insert(insert_pos, after_run)
+
+    return count
+
+
+def _build_hyperlink(paragraph, url, source_run):
+    """Build an OOXML w:hyperlink element referencing an external URL."""
+    part = paragraph.part
+    r_id = part.relate_to(url, RT.HYPERLINK, is_external=True)
+
+    hyperlink = OxmlElement('w:hyperlink')
+    hyperlink.set(qn('r:id'), r_id)
+
+    # Build the run inside the hyperlink, copying formatting
+    hl_run = OxmlElement('w:r')
+    rPr = source_run._element.find(qn('w:rPr'))
+    if rPr is not None:
+        hl_run.append(copy_rPr(rPr))
+
+    # Add hyperlink style (blue + underline)
+    _ensure_hyperlink_style(hl_run)
+
+    hyperlink.append(hl_run)
+    return hyperlink
+
+
+def _ensure_hyperlink_style(run_elem):
+    """Ensure the run inside a hyperlink has blue color and underline."""
+    rPr = run_elem.find(qn('w:rPr'))
+    if rPr is None:
+        rPr = OxmlElement('w:rPr')
+        run_elem.insert(0, rPr)
+
+    # Add underline if not present
+    if rPr.find(qn('w:u')) is None:
+        u = OxmlElement('w:u')
+        u.set(qn('w:val'), 'single')
+        rPr.append(u)
+
+    # Add blue color if not present
+    if rPr.find(qn('w:color')) is None:
+        color = OxmlElement('w:color')
+        color.set(qn('w:val'), '0563C1')
+        rPr.append(color)
+
+
+def copy_rPr(source_rPr):
+    """Deep copy a w:rPr element, with fallback if lxml serialisation fails."""
+    try:
+        return etree.fromstring(etree.tostring(source_rPr))
+    except Exception:
+        import copy
+        return copy.deepcopy(source_rPr)