word2pdf 0.1.0__py3-none-any.whl

word2pdf/__init__.py

@@ -0,0 +1,18 @@
+"""Word2PDF - convert .docx to PDF in pure Python.
+
+No Microsoft Word, no LibreOffice, no external binaries: the package reads
+WordprocessingML directly, lays the document out itself and draws the result
+with ReportLab, so it behaves the same on Windows, macOS and Linux.
+
+    from word2pdf import convert
+
+    convert('report.docx', 'report.pdf')
+    pdf_bytes = convert('report.docx')
+    convert('invoice.docx', 'invoice.pdf', context={'customer': 'Example Ltd'})
+"""
+from .api import Converter, Result, convert, convert_many, convert_to_bytes
+from .templates import DocxTemplate, render_docx
+
+__version__ = '0.1.0'
+__all__ = ['convert', 'convert_to_bytes', 'convert_many', 'Converter', 'Result',
+           'DocxTemplate', 'render_docx', '__version__']

word2pdf/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == '__main__':
+    raise SystemExit(main())

word2pdf/api.py

@@ -0,0 +1,143 @@
+"""The public conversion API."""
+from __future__ import annotations
+
+import io
+import os
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from .document import parse_document
+from .fonts import FontManager
+from .layout import Flow, Layouter
+from .oxml import Package
+from .render import Renderer
+
+
+@dataclass
+class Result:
+    """What a conversion produced."""
+    pages: int = 0
+    warnings: List[str] = field(default_factory=list)
+    missing_fonts: List[str] = field(default_factory=list)
+    output: Optional[str] = None
+
+    def __bool__(self):
+        return self.pages > 0
+
+
+class Converter:
+    """Reusable converter; keeps the font index warm between documents."""
+
+    def __init__(self, font_dirs=None, default_font='Calibri', font_cache=True,
+                 **options):
+        self.options = dict(options)
+        self.options.setdefault('default_font', default_font)
+        self.options.setdefault('font_dirs', font_dirs)
+        self.options.setdefault('font_cache', font_cache)
+        self.fonts = FontManager(extra_dirs=font_dirs, use_cache=font_cache,
+                                 default_family=default_font)
+
+    def convert(self, source, target=None, context=None, **overrides):
+        """Convert a .docx to PDF.
+
+        *source* is a path, bytes or file-like object; *target* a path or
+        file-like object (omit it to get the PDF back as bytes).  Pass
+        *context* to fill ``{{ placeholders }}`` in the document first.
+        """
+        options = dict(self.options)
+        options.update(overrides)
+        if context is not None:
+            from .templates import render_docx
+            source = render_docx(source, context, jinja=options.get('jinja', True))
+        package = source if isinstance(source, Package) else Package(source)
+        document = parse_document(package, options)
+        self.fonts.strategy = options.get('font_fallback', self.fonts.strategy)
+        self.fonts.set_document_default(_document_font(document, options))
+        layouter = Layouter(document, fonts=self.fonts, options=options)
+        pages = Flow(layouter, options).run()
+        renderer = Renderer(pages, document, options)
+
+        result = Result(pages=len(pages))
+        if target is None:
+            buffer = io.BytesIO()
+            renderer.write(buffer)
+            data = buffer.getvalue()
+        else:
+            if hasattr(target, 'write'):
+                renderer.write(target)
+                data = None
+            else:
+                target = os.fspath(target)
+                directory = os.path.dirname(os.path.abspath(target))
+                if directory:
+                    os.makedirs(directory, exist_ok=True)
+                renderer.write(target)
+                result.output = target
+                data = None
+        result.warnings = list(document.warnings) + list(layouter.warnings) \
+            + list(renderer.warnings)
+        result.missing_fonts = sorted(self.fonts.missing_families)
+        self.last_result = result
+        if target is None:
+            return data
+        return result
+
+
+def _document_font(document, options) -> str:
+    """The font Word would fall back to for this document."""
+    override = options.get('default_font_override')
+    if override:
+        return override
+    styles = document.styles
+    if styles is not None:
+        family = styles.doc_rpr.font_ascii
+        if not family and styles.doc_rpr.theme_ascii and styles.theme is not None:
+            family = styles.theme.font(styles.doc_rpr.theme_ascii)
+        normal = styles.get(styles.default_para_style)
+        if not family and normal is not None:
+            family = normal.rpr.font_ascii
+        if not family and styles.theme is not None:
+            family = styles.theme.minor_font
+        if family:
+            return family
+    return options.get('default_font', 'Calibri')
+
+
+_default: Optional[Converter] = None
+
+
+def _converter(**options) -> Converter:
+    global _default
+    keys = ('font_dirs', 'default_font', 'font_cache')
+    if _default is None or any(options.get(k) not in (None, _default.options.get(k))
+                               for k in keys if k in options):
+        _default = Converter(font_dirs=options.get('font_dirs'),
+                             default_font=options.get('default_font', 'Calibri'),
+                             font_cache=options.get('font_cache', True))
+    return _default
+
+
+def convert(source, target=None, context=None, **options):
+    """Convert a .docx file to PDF without Word or LibreOffice.
+
+    >>> convert('report.docx', 'report.pdf')
+    >>> pdf_bytes = convert('report.docx')
+    >>> convert('invoice.docx', 'invoice.pdf', context={'total': '12.00'})
+    """
+    converter = _converter(**options)
+    return converter.convert(source, target, context=context, **options)
+
+
+def convert_to_bytes(source, context=None, **options) -> bytes:
+    return convert(source, None, context=context, **options)
+
+
+def convert_many(sources, out_dir='.', **options):
+    """Convert several documents, reusing one warm font index."""
+    converter = _converter(**options)
+    results = []
+    for source in sources:
+        name = os.path.splitext(os.path.basename(os.fspath(source)))[0] + '.pdf'
+        results.append(converter.convert(source, os.path.join(out_dir, name),
+                                         **options))
+    return results

word2pdf/cli.py

@@ -0,0 +1,155 @@
+"""Command line interface: ``word2pdf in.docx [out.pdf]``."""
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+import sys
+import time
+
+from . import __version__
+from .api import Converter
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog='word2pdf',
+        description='Convert .docx to PDF in pure Python - no Word, no '
+                    'LibreOffice, no external binaries.')
+    parser.add_argument('inputs', nargs='+', metavar='DOCX',
+                        help='input .docx files (globs allowed)')
+    parser.add_argument('-o', '--output', metavar='PDF',
+                        help='output file (single input) or directory')
+    parser.add_argument('-d', '--out-dir', metavar='DIR',
+                        help='write the PDFs into this directory')
+    parser.add_argument('--data', metavar='JSON',
+                        help='JSON file (or inline JSON) of template values')
+    parser.add_argument('--set', action='append', default=[], metavar='KEY=VALUE',
+                        help='set one template value; repeatable')
+    parser.add_argument('--no-jinja', action='store_true',
+                        help='use the built-in template engine even if Jinja2 '
+                             'is installed')
+    parser.add_argument('--font-dir', action='append', default=[], metavar='DIR',
+                        help='extra directory to search for fonts; repeatable')
+    parser.add_argument('--default-font', default=None, metavar='NAME',
+                        help='fallback font family (default: the document default)')
+    parser.add_argument('--font-fallback', choices=('word', 'closest'),
+                        default='word',
+                        help="how to replace missing fonts: 'word' mimics Word "
+                             "(document default), 'closest' matches width/style")
+    parser.add_argument('--no-device-grid', action='store_true',
+                        help='lay out in exact points instead of matching '
+                             "Word's 600 dpi rounding")
+    parser.add_argument('--no-compress', action='store_true',
+                        help='write an uncompressed PDF')
+    parser.add_argument('--image-quality', type=int, metavar='1-100',
+                        help='re-encode photos as JPEG at this quality to '
+                             'shrink the PDF (default: keep them untouched)')
+    parser.add_argument('--image-max-dpi', type=int, metavar='DPI',
+                        help='downsample images above this resolution')
+    parser.add_argument('--title', help='PDF title metadata')
+    parser.add_argument('--author', help='PDF author metadata')
+    parser.add_argument('-q', '--quiet', action='store_true')
+    parser.add_argument('-v', '--verbose', action='store_true',
+                        help='report warnings and substituted fonts')
+    parser.add_argument('--version', action='version',
+                        version='Word2PDF %s' % __version__)
+    return parser
+
+
+def load_context(args) -> dict:
+    context: dict = {}
+    if args.data:
+        raw = args.data
+        if os.path.exists(raw):
+            with open(raw, 'r', encoding='utf-8') as fh:
+                context.update(json.load(fh))
+        else:
+            context.update(json.loads(raw))
+    for item in args.set:
+        key, _, value = item.partition('=')
+        if not key:
+            continue
+        try:
+            context[key.strip()] = json.loads(value)
+        except ValueError:
+            context[key.strip()] = value
+    return context
+
+
+def expand(patterns):
+    files = []
+    for pattern in patterns:
+        matches = glob.glob(pattern) if any(ch in pattern for ch in '*?[') \
+            else [pattern]
+        if not matches:
+            print('no such file: %s' % pattern, file=sys.stderr)
+        files.extend(matches)
+    return files
+
+
+def target_for(source, args, many: bool):
+    if args.out_dir:
+        base = os.path.splitext(os.path.basename(source))[0] + '.pdf'
+        return os.path.join(args.out_dir, base)
+    if args.output and not many:
+        if os.path.isdir(args.output):
+            base = os.path.splitext(os.path.basename(source))[0] + '.pdf'
+            return os.path.join(args.output, base)
+        return args.output
+    if args.output and many:
+        base = os.path.splitext(os.path.basename(source))[0] + '.pdf'
+        return os.path.join(args.output, base)
+    return os.path.splitext(source)[0] + '.pdf'
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    sources = expand(args.inputs)
+    if not sources:
+        return 1
+    context = load_context(args) or None
+
+    options = {'jinja': not args.no_jinja,
+               'font_fallback': args.font_fallback,
+               'compress': not args.no_compress}
+    if args.no_device_grid:
+        options['device_grid'] = 0
+    if args.image_quality:
+        options['image_quality'] = args.image_quality
+    if args.image_max_dpi:
+        options['image_max_dpi'] = args.image_max_dpi
+    if args.title:
+        options['title'] = args.title
+    if args.author:
+        options['author'] = args.author
+
+    converter = Converter(font_dirs=args.font_dir or None,
+                          default_font=args.default_font or 'Calibri',
+                          **options)
+    failures = 0
+    for source in sources:
+        target = target_for(source, args, len(sources) > 1)
+        started = time.time()
+        try:
+            result = converter.convert(source, target, context=context)
+        except Exception as exc:                       # pragma: no cover
+            failures += 1
+            print('%s: %s' % (source, exc), file=sys.stderr)
+            continue
+        if not args.quiet:
+            print('%s -> %s (%d page%s, %.2fs)'
+                  % (source, target, result.pages, '' if result.pages == 1 else 's',
+                     time.time() - started))
+        if args.verbose:
+            for warning in result.warnings:
+                print('  warning: %s' % warning, file=sys.stderr)
+            if result.missing_fonts:
+                print('  substituted fonts: %s' % ', '.join(result.missing_fonts),
+                      file=sys.stderr)
+    return 1 if failures else 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

word2pdf/document/__init__.py

@@ -0,0 +1,24 @@
+"""The document: WordprocessingML in, a style-resolved model out.
+
+`props` holds the typed property bags and their merge rules, `styles` and
+`numbering` the two cascades that feed them, `model` the shapes the rest of the
+engine works with, and `parser` does the reading.  Nothing here knows about
+pages or fonts: a Paragraph carries resolved properties, not positions.
+"""
+from .model import (Block, BreakRun, Cell, Document, FieldRun, FloatingObject,
+                    HeaderFooter, ImageRun, Inline, Link, NoteRun, NumberLabel,
+                    Paragraph, Row, Section, ShapeRun, TabRun, Table, TextRun)
+from .numbering import SYMBOL_BULLETS, Numbering, format_number
+from .parser import parse_document, parse_field
+from .props import (Border, CellProps, ParaProps, RowProps, RunProps, Shading,
+                    TabStop, TableProps, merge_tabs)
+from .styles import Style, StyleSheet, Theme, apply_tint_shade
+
+__all__ = ['parse_document', 'parse_field', 'Document', 'Section', 'Block',
+           'Paragraph', 'Table', 'Row', 'Cell', 'HeaderFooter',
+           'FloatingObject', 'Inline', 'TextRun', 'ImageRun', 'BreakRun',
+           'FieldRun', 'NoteRun', 'ShapeRun', 'TabRun', 'Link', 'NumberLabel',
+           'RunProps', 'ParaProps', 'CellProps', 'RowProps', 'TableProps',
+           'Border', 'Shading', 'TabStop', 'merge_tabs', 'StyleSheet', 'Style',
+           'Theme', 'apply_tint_shade', 'Numbering', 'format_number',
+           'SYMBOL_BULLETS']

word2pdf/document/model.py

@@ -0,0 +1,235 @@
+"""The intermediate document model produced by the parser.
+
+Everything here is already style-resolved: the layout engine never has to look
+at a style sheet again.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from .props import CellProps, ParaProps, RowProps, RunProps, TableProps
+
+
+@dataclass
+class Link:
+    url: Optional[str] = None
+    anchor: Optional[str] = None
+    tooltip: Optional[str] = None
+
+
+@dataclass
+class Inline:
+    props: RunProps = field(default_factory=RunProps)
+    link: Optional[Link] = None
+
+
+@dataclass
+class TextRun(Inline):
+    text: str = ''
+
+
+@dataclass
+class TabRun(Inline):
+    pass
+
+
+@dataclass
+class BreakRun(Inline):
+    kind: str = 'line'          # line | page | column
+    clear: Optional[str] = None
+
+
+@dataclass
+class ImageRun(Inline):
+    data: Optional[bytes] = None
+    width: float = 0.0          # points
+    height: float = 0.0
+    alt: str = ''
+    rotation: float = 0.0
+    fmt: str = ''
+    crop: Optional[tuple] = None   # (left, top, right, bottom) fractions
+
+
+@dataclass
+class ShapeRun(Inline):
+    """A drawing we cannot render faithfully; kept so its text is not lost."""
+    width: float = 0.0
+    height: float = 0.0
+    fill: Optional[str] = None
+    stroke: Optional[str] = None
+    blocks: list = field(default_factory=list)
+
+
+@dataclass
+class FieldRun(Inline):
+    kind: str = ''              # PAGE | NUMPAGES | DATE | TIME | REF | ...
+    text: str = ''              # cached result from the document
+    argument: str = ''
+    fmt: str = ''
+
+
+@dataclass
+class NoteRun(Inline):
+    """A footnote or endnote reference."""
+    note_id: str = ''
+    kind: str = 'footnote'
+    mark: str = ''
+
+
+@dataclass
+class NumberLabel:
+    text: str = ''
+    props: RunProps = field(default_factory=RunProps)
+    suffix: str = 'tab'
+    align: str = 'left'
+    font_family: Optional[str] = None
+
+
+@dataclass
+class FloatingObject:
+    """An anchored drawing: positioned absolutely, outside the text flow."""
+    image: Optional[ImageRun] = None
+    blocks: list = field(default_factory=list)
+    width: float = 0.0
+    height: float = 0.0
+    h_relative: str = 'column'
+    v_relative: str = 'paragraph'
+    h_offset: float = 0.0
+    v_offset: float = 0.0
+    h_align: Optional[str] = None
+    v_align: Optional[str] = None
+    behind: bool = False
+    wrap: str = 'none'
+    z_index: int = 0
+    fill: Optional[str] = None
+    stroke: Optional[str] = None
+    stroke_width: float = 0.0
+    rotation: float = 0.0
+    alt: str = ''
+
+
+@dataclass
+class Block:
+    pass
+
+
+@dataclass
+class Paragraph(Block):
+    props: ParaProps = field(default_factory=ParaProps)
+    items: List[Inline] = field(default_factory=list)
+    mark_props: RunProps = field(default_factory=RunProps)
+    number: Optional[NumberLabel] = None
+    style_id: Optional[str] = None
+    bookmarks: List[str] = field(default_factory=list)
+    in_table: bool = False
+    floats: List[FloatingObject] = field(default_factory=list)
+
+    @property
+    def text(self) -> str:
+        return ''.join(i.text for i in self.items if isinstance(i, TextRun))
+
+
+@dataclass
+class Cell:
+    blocks: List[Block] = field(default_factory=list)
+    props: CellProps = field(default_factory=CellProps)
+    grid_span: int = 1
+    v_merge: Optional[str] = None
+    width: Optional[float] = None
+    column: int = 0
+
+
+@dataclass
+class Row:
+    cells: List[Cell] = field(default_factory=list)
+    props: RowProps = field(default_factory=RowProps)
+    header: bool = False
+
+
+@dataclass
+class Table(Block):
+    rows: List[Row] = field(default_factory=list)
+    grid: List[float] = field(default_factory=list)
+    props: TableProps = field(default_factory=TableProps)
+    style_id: Optional[str] = None
+    look: dict = field(default_factory=dict)
+    nesting: int = 0
+
+
+@dataclass
+class HeaderFooter:
+    blocks: List[Block] = field(default_factory=list)
+    part: str = ''
+
+
+@dataclass
+class Section:
+    width: float = 612.0
+    height: float = 792.0
+    margin_top: float = 72.0
+    margin_right: float = 72.0
+    margin_bottom: float = 72.0
+    margin_left: float = 72.0
+    header_distance: float = 36.0
+    footer_distance: float = 36.0
+    gutter: float = 0.0
+    landscape: bool = False
+    columns: int = 1
+    column_space: float = 36.0
+    column_widths: Optional[list] = None
+    column_separator: bool = False
+    page_num_start: Optional[int] = None
+    page_num_format: Optional[str] = None
+    title_page: bool = False
+    vertical_align: str = 'top'
+    break_type: str = 'nextPage'
+    blocks: List[Block] = field(default_factory=list)
+    headers: dict = field(default_factory=dict)   # default|first|even -> HeaderFooter
+    footers: dict = field(default_factory=dict)
+    borders: Optional[dict] = None
+
+    @property
+    def content_width(self) -> float:
+        return max(1.0, self.width - self.margin_left - self.margin_right - self.gutter)
+
+    @property
+    def content_height(self) -> float:
+        return max(1.0, self.height - self.margin_top - self.margin_bottom)
+
+    def column_layout(self):
+        """(x_offset, width) for each column, relative to the text area."""
+        if self.column_widths:
+            out = []
+            x = 0.0
+            for width, space in self.column_widths:
+                out.append((x, width))
+                x += width + space
+            return out
+        count = max(1, self.columns)
+        total = self.content_width
+        width = (total - self.column_space * (count - 1)) / count
+        return [(i * (width + self.column_space), width) for i in range(count)]
+
+
+@dataclass
+class Document:
+    sections: List[Section] = field(default_factory=list)
+    styles: object = None
+    numbering: object = None
+    theme: object = None
+    package: object = None
+    settings: dict = field(default_factory=dict)
+    footnotes: dict = field(default_factory=dict)
+    endnotes: dict = field(default_factory=dict)
+    properties: dict = field(default_factory=dict)
+    warnings: List[str] = field(default_factory=list)
+
+    @property
+    def default_tab(self) -> float:
+        return self.settings.get('default_tab', 36.0)
+
+    def iter_blocks(self):
+        for section in self.sections:
+            for block in section.blocks:
+                yield section, block