weasyprint 65.1__py3-none-any.whl → 66.0__py3-none-any.whl

weasyprint/pdf/__init__.py

@@ -12,6 +12,7 @@ from ..matrix import Matrix
 from . import debug, pdfa, pdfua
 from .fonts import build_fonts_dictionary
 from .stream import Stream
+from .tags import add_tags
 
 from .anchors import (  # isort:skip
     add_annotations, add_forms, add_links, add_outlines, resolve_links,
@@ -118,15 +119,15 @@ def generate_pdf(document, target, zoom, **options):
     PROGRESS_LOGGER.info('Step 6 - Creating PDF')
 
     # Set properties according to PDF variants
-    mark = False
     srgb = options['srgb']
+    pdf_tags = options['pdf_tags']
     variant = options['pdf_variant']
     if variant:
         variant_function, properties = VARIANTS[variant]
-        if 'mark' in properties:
-            mark = properties['mark']
         if 'srgb' in properties:
             srgb = properties['srgb']
+        if 'pdf_tags' in properties:
+            pdf_tags = properties['pdf_tags']
 
     pdf = pydyf.PDF()
     images = {}
@@ -159,6 +160,8 @@ def generate_pdf(document, target, zoom, **options):
     compress = not options['uncompressed_pdf']
     for page_number, (page, links_and_anchors) in enumerate(
             zip(document.pages, page_links_and_anchors)):
+        tags = {} if pdf_tags else None
+
         # Draw from the top-left corner
         matrix = Matrix(scale, 0, 0, -scale, 0, page.height * scale)
 
@@ -175,7 +178,7 @@ def generate_pdf(document, target, zoom, **options):
             left / scale, top / scale,
             (right - left) / scale, (bottom - top) / scale)
         stream = Stream(
-            document.fonts, page_rectangle, resources, images, mark, compress=compress)
+            document.fonts, page_rectangle, resources, images, tags, compress=compress)
         stream.transform(d=-1, f=(page.height * scale))
         pdf.add_object(stream)
         page_streams.append(stream)
@@ -187,13 +190,13 @@ def generate_pdf(document, target, zoom, **options):
             'Contents': stream.reference,
             'Resources': resources.reference,
         })
-        if mark:
+        if pdf_tags:
             pdf_page['Tabs'] = '/S'
             pdf_page['StructParents'] = page_number
         pdf.add_page(pdf_page)
         pdf_pages.append(pdf_page)
 
-        add_links(links_and_anchors, matrix, pdf, pdf_page, pdf_names, mark)
+        add_links(links_and_anchors, matrix, pdf, pdf_page, pdf_names, tags)
         add_annotations(
             links_and_anchors[0], matrix, document, pdf, pdf_page, annot_files,
             compress)
@@ -323,6 +326,10 @@ def generate_pdf(document, target, zoom, **options):
             }),
         ])
 
+    # Add tags
+    if pdf_tags:
+        add_tags(pdf, document, page_streams)
+
     # Apply PDF variants functions
     if variant:
         variant_function(

weasyprint/pdf/anchors.py

@@ -16,7 +16,7 @@ from ..text.fonts import get_font_description
 from ..urls import URLFetchingError
 
 
-def add_links(links_and_anchors, matrix, pdf, page, names, mark):
+def add_links(links_and_anchors, matrix, pdf, page, names, tags):
     """Include hyperlinks in given PDF page."""
     links, anchors = links_and_anchors
 
@@ -30,7 +30,7 @@ def add_links(links_and_anchors, matrix, pdf, page, names, mark):
                 'Rect': pydyf.Array([x1, y1, x2, y2]),
                 'BS': pydyf.Dictionary({'W': 0}),
             })
-            if mark:
+            if tags is not None:
                 box.link_annotation['Contents'] = pydyf.String(link_target)
             if link_type == 'internal':
                 box.link_annotation['Dest'] = pydyf.String(link_target)

weasyprint/pdf/pdfua.py

@@ -1,125 +1,17 @@
 """PDF/UA generation."""
 
-import pydyf
+from functools import partial
 
 from .metadata import add_metadata
 
 
-def pdfua(pdf, metadata, document, page_streams, attachments, compress):
+def pdfua(pdf, metadata, document, page_streams, attachments, compress, version):
     """Set metadata for PDF/UA documents."""
-    # Structure for PDF tagging
-    content_mapping = pydyf.Dictionary({})
-    pdf.add_object(content_mapping)
-    structure_root = pydyf.Dictionary({
-        'Type': '/StructTreeRoot',
-        'ParentTree': content_mapping.reference,
-    })
-    pdf.add_object(structure_root)
-    structure_document = pydyf.Dictionary({
-        'Type': '/StructElem',
-        'S': '/Document',
-        'P': structure_root.reference,
-    })
-    pdf.add_object(structure_document)
-    structure_root['K'] = pydyf.Array([structure_document.reference])
-    pdf.catalog['StructTreeRoot'] = structure_root.reference
-
-    document_children = []
-    content_mapping['Nums'] = pydyf.Array()
-    links = []
-    for page_number, page_stream in enumerate(page_streams):
-        structure = {}
-        document.build_element_structure(structure)
-        parents = [None] * len(page_stream.marked)
-        for mcid, (key, box) in enumerate(page_stream.marked):
-            # Build structure elements
-            kids = [mcid]
-            if key == 'Link':
-                object_reference = pydyf.Dictionary({
-                    'Type': '/OBJR',
-                    'Obj': box.link_annotation.reference,
-                    'Pg': pdf.page_references[page_number],
-                })
-                pdf.add_object(object_reference)
-                links.append((object_reference.reference, box.link_annotation))
-            etree_element = box.element
-            child_structure_data_element = None
-            while True:
-                if etree_element is None:
-                    structure_data = structure.setdefault(
-                        box, {'parent': None})
-                else:
-                    structure_data = structure[etree_element]
-                new_element = 'element' not in structure_data
-                if new_element:
-                    child = structure_data['element'] = pydyf.Dictionary({
-                        'Type': '/StructElem',
-                        'S': f'/{key}',
-                        'K': pydyf.Array(kids),
-                        'Pg': pdf.page_references[page_number],
-                    })
-                    pdf.add_object(child)
-                    if key == 'LI':
-                        if etree_element.tag == 'dt':
-                            sub_key = 'Lbl'
-                        else:
-                            sub_key = 'LBody'
-                        real_child = pydyf.Dictionary({
-                            'Type': '/StructElem',
-                            'S': f'/{sub_key}',
-                            'K': pydyf.Array(kids),
-                            'Pg': pdf.page_references[page_number],
-                            'P': child.reference,
-                        })
-                        pdf.add_object(real_child)
-                        for kid in kids:
-                            if isinstance(kid, int):
-                                parents[kid] = real_child.reference
-                        child['K'] = pydyf.Array([real_child.reference])
-                        structure_data['element'] = real_child
-                    else:
-                        for kid in kids:
-                            if isinstance(kid, int):
-                                parents[kid] = child.reference
-                else:
-                    child = structure_data['element']
-                    child['K'].extend(kids)
-                    for kid in kids:
-                        if isinstance(kid, int):
-                            parents[kid] = child.reference
-                kid = child.reference
-                if child_structure_data_element is not None:
-                    child_structure_data_element['P'] = kid
-                if not new_element:
-                    break
-                kids = [kid]
-                child_structure_data_element = child
-                if structure_data['parent'] is None:
-                    child['P'] = structure_document.reference
-                    document_children.append(child.reference)
-                    break
-                else:
-                    etree_element = structure_data['parent']
-                key = page_stream.get_marked_content_tag(etree_element.tag)
-        content_mapping['Nums'].append(page_number)
-        content_mapping['Nums'].append(pydyf.Array(parents))
-    structure_document['K'] = pydyf.Array(document_children)
-    for i, (link, annotation) in enumerate(links, start=page_number + 1):
-        content_mapping['Nums'].append(i)
-        content_mapping['Nums'].append(link)
-        annotation['StructParent'] = i
-        annotation['F'] = 2 ** (2 - 1)
-
     # Common PDF metadata stream
-    add_metadata(pdf, metadata, 'ua', 1, conformance=None, compress=compress)
-
-    # PDF document extra metadata
-    if 'Lang' not in pdf.catalog:
-        pdf.catalog['Lang'] = pydyf.String()
-    pdf.catalog['ViewerPreferences'] = pydyf.Dictionary({
-        'DisplayDocTitle': 'true',
-    })
-    pdf.catalog['MarkInfo'] = pydyf.Dictionary({'Marked': 'true'})
+    add_metadata(pdf, metadata, 'ua', version, conformance=None, compress=compress)
 
 
-VARIANTS = {'pdf/ua-1': (pdfua, {'mark': True})}
+VARIANTS = {
+    'pdf/ua-1': (partial(pdfua, version=1), {'version': '1.7', 'pdf_tags': True}),
+    'pdf/ua-2': (partial(pdfua, version=2), {'version': '2.0', 'pdf_tags': True}),
+}

weasyprint/pdf/stream.py

@@ -1,5 +1,7 @@
 """PDF stream."""
 
+from contextlib import contextmanager
+
 import pydyf
 
 from ..logger import LOGGER
@@ -11,14 +13,13 @@ from .fonts import Font
 
 class Stream(pydyf.Stream):
     """PDF stream object with extra features."""
-    def __init__(self, fonts, page_rectangle, resources, images, mark, *args, **kwargs):
+    def __init__(self, fonts, page_rectangle, resources, images, tags, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.page_rectangle = page_rectangle
-        self.marked = []
         self._fonts = fonts
         self._resources = resources
         self._images = images
-        self._mark = mark
+        self._tags = tags
         self._current_color = self._current_color_stroke = None
         self._current_alpha = self._current_alpha_stroke = None
         self._current_font = self._current_font_size = None
@@ -39,8 +40,8 @@ class Stream(pydyf.Stream):
             kwargs['resources'] = self._resources
         if 'images' not in kwargs:
             kwargs['images'] = self._images
-        if 'mark' not in kwargs:
-            kwargs['mark'] = self._mark
+        if 'tags' not in kwargs:
+            kwargs['tags'] = self._tags
         if 'compress' not in kwargs:
             kwargs['compress'] = self.compress
         return Stream(**kwargs)
@@ -105,7 +106,7 @@ class Stream(pydyf.Stream):
             lightness, a, b = color.to('lab').coordinates
             self.set_color_special(None, stroke, lightness, a, b)
         else:
-            LOGGER.warn('Unsupported color space %s, use sRGB instead', color.space)
+            LOGGER.warning('Unsupported color space %s, use sRGB instead', color.space)
             self.set_color_rgb(*channels, stroke)
 
     def set_font_size(self, font, size):
@@ -248,21 +249,39 @@ class Stream(pydyf.Stream):
         self._resources['Shading'][shading.id] = shading
         return shading
 
-    def begin_marked_content(self, box, mcid=False, tag=None):
-        if not self._mark:
-            return
-        property_list = None
-        if tag is None:
-            tag = self.get_marked_content_tag(box.element_tag)
-        if mcid:
-            property_list = pydyf.Dictionary({'MCID': len(self.marked)})
-            self.marked.append((tag, box))
-        super().begin_marked_content(tag, property_list)
-
-    def end_marked_content(self):
-        if not self._mark:
-            return
-        super().end_marked_content()
+    @contextmanager
+    def stacked(self):
+        """Save and restore stream context when used with the ``with`` keyword."""
+        self.push_state()
+        try:
+            yield
+        finally:
+            self.pop_state()
+
+    @contextmanager
+    def marked(self, box, tag):
+        if self._tags is not None:
+            property_list = None
+            mcid = len(self._tags)
+            assert box not in self._tags
+            self._tags[box] = {'tag': tag, 'mcid': mcid}
+            property_list = pydyf.Dictionary({'MCID': mcid})
+            super().begin_marked_content(tag, property_list)
+        try:
+            yield
+        finally:
+            if self._tags is not None:
+                super().end_marked_content()
+
+    @contextmanager
+    def artifact(self):
+        if self._tags is not None:
+            super().begin_marked_content('Artifact')
+        try:
+            yield
+        finally:
+            if self._tags is not None:
+                super().end_marked_content()
 
     @staticmethod
     def create_interpolation_function(domain, c0, c1, n):
@@ -283,31 +302,3 @@ class Stream(pydyf.Stream):
             'Bounds': pydyf.Array(bounds),
             'Functions': pydyf.Array(sub_functions),
         })
-
-    def get_marked_content_tag(self, element_tag):
-        if element_tag == 'div':
-            return 'Div'
-        elif element_tag == 'span':
-            return 'Span'
-        elif element_tag == 'article':
-            return 'Art'
-        elif element_tag == 'section':
-            return 'Sect'
-        elif element_tag == 'blockquote':
-            return 'BlockQuote'
-        elif element_tag == 'p':
-            return 'P'
-        elif element_tag in ('h1', 'h2', 'h3', 'h4', 'h5', 'h6'):
-            return element_tag.upper()
-        elif element_tag in ('dl', 'ul', 'ol'):
-            return 'L'
-        elif element_tag in ('li', 'dt', 'dd'):
-            return 'LI'
-        elif element_tag == 'table':
-            return 'Table'
-        elif element_tag in ('tr', 'th', 'td'):
-            return element_tag.upper()
-        elif element_tag in ('thead', 'tbody', 'tfoot'):
-            return element_tag[:2].upper() + element_tag[2:]
-        else:
-            return 'NonStruct'

weasyprint/pdf/tags.py

@@ -0,0 +1,305 @@
+"""PDF tagging."""
+
+from collections import defaultdict
+
+import pydyf
+
+from ..formatting_structure import boxes
+from ..layout.absolute import AbsolutePlaceholder
+from ..logger import LOGGER
+
+
+def add_tags(pdf, document, page_streams):
+    """Add tag tree to the document."""
+
+    # Add root structure.
+    content_mapping = pydyf.Dictionary({})
+    pdf.add_object(content_mapping)
+    structure_root = pydyf.Dictionary({
+        'Type': '/StructTreeRoot',
+        'ParentTree': content_mapping.reference,
+    })
+    pdf.add_object(structure_root)
+    structure_document = pydyf.Dictionary({
+        'Type': '/StructElem',
+        'S': '/Document',
+        'K': pydyf.Array(),
+        'P': structure_root.reference,
+    })
+    pdf.add_object(structure_document)
+    structure_root['K'] = pydyf.Array([structure_document.reference])
+    pdf.catalog['StructTreeRoot'] = structure_root.reference
+
+    # Map content.
+    content_mapping['Nums'] = pydyf.Array()
+    links = []
+    for page_number, (page, stream) in enumerate(zip(document.pages, page_streams)):
+        tags = stream._tags
+        page_box = page._page_box
+
+        # Prepare array for this page’s MCID-to-StructElem mapping.
+        content_mapping['Nums'].append(page_number)
+        content_mapping['Nums'].append(pydyf.Array())
+        page_nums = {}
+
+        # Map page box content.
+        elements = _build_box_tree(
+            page_box, structure_document, pdf, page_number, page_nums, links, tags)
+        for element in elements:
+            structure_document['K'].append(element.reference)
+        assert not tags
+
+        # Flatten page-local nums into global mapping.
+        sorted_refs = [ref for _, ref in sorted(page_nums.items())]
+        content_mapping['Nums'][-1].extend(sorted_refs)
+
+    # Add annotations for links.
+    for i, (link_reference, annotation) in enumerate(links, start=len(document.pages)):
+        content_mapping['Nums'].append(i)
+        content_mapping['Nums'].append(link_reference)
+        annotation['StructParent'] = i
+
+    # Add required metadata.
+    pdf.catalog['ViewerPreferences'] = pydyf.Dictionary({'DisplayDocTitle': 'true'})
+    pdf.catalog['MarkInfo'] = pydyf.Dictionary({'Marked': 'true'})
+    if 'Lang' not in pdf.catalog:
+        LOGGER.error('Missing required "lang" attribute at the root of the document')
+        pdf.catalog['Lang'] = pydyf.String()
+
+
+def _get_pdf_tag(tag):
+    """Get PDF tag corresponding to HTML tag."""
+    if tag is None:
+        return 'NonStruct'
+    elif tag == 'div':
+        return 'Div'
+    elif tag.split(':')[0] == 'a':
+        # Links and link pseudo elements create link annotations.
+        return 'Link'
+    elif tag == 'span':
+        return 'Span'
+    elif tag == 'main':
+        return 'Part'
+    elif tag == 'article':
+        return 'Art'
+    elif tag == 'section':
+        return 'Sect'
+    elif tag == 'blockquote':
+        return 'BlockQuote'
+    elif tag == 'p':
+        return 'P'
+    elif tag in ('h1', 'h2', 'h3', 'h4', 'h5', 'h6'):
+        return tag.upper()
+    elif tag in ('dl', 'ul', 'ol'):
+        return 'L'
+    elif tag in ('li', 'dt', 'dd'):
+        # TODO: dt should be different.
+        return 'LI'
+    elif tag == 'li::marker':
+        return 'Lbl'
+    elif tag == 'table':
+        return 'Table'
+    elif tag in ('tr', 'th', 'td'):
+        return tag.upper()
+    elif tag in ('thead', 'tbody', 'tfoot'):
+        return tag[:2].upper() + tag[2:]
+    elif tag == 'img':
+        return 'Figure'
+    elif tag in ('caption', 'figcaption'):
+        return 'Caption'
+    else:
+        return 'NonStruct'
+
+
+def _build_box_tree(box, parent, pdf, page_number, nums, links, tags):
+    """Recursively build tag tree for given box and yield children."""
+
+    # Special case for absolute elements.
+    if isinstance(box, AbsolutePlaceholder):
+        box = box._box
+
+    element_tag = None if box.element is None else box.element_tag
+    tag = _get_pdf_tag(element_tag)
+
+    # Special case for html, body, page boxes and margin boxes.
+    if element_tag in ('html', 'body') or isinstance(box, boxes.PageBox):
+        # Avoid generate page, html and body boxes as a semantic node, yield children.
+        if isinstance(box, boxes.ParentBox) and not isinstance(box, boxes.LineBox):
+            for child in box.children:
+                yield from _build_box_tree(
+                    child, parent, pdf, page_number, nums, links, tags)
+            return
+    elif isinstance(box, boxes.MarginBox):
+        # Build tree for margin boxes but don’t link it to main tree. It ensures that
+        # marked content is mapped in document and removed from list. It could be
+        # included in tree as Artifact, but that’s only allowed in PDF 2.0.
+        for child in box.children:
+            tuple(_build_box_tree(child, parent, pdf, page_number, nums, links, tags))
+        return
+
+    # Create box element.
+    if tag == 'LI':
+        anonymous_list_element = parent['S'] == '/LI'
+        anonymous_li_child = parent['S'] == '/LBody'
+        dl_item = box.element_tag in ('dt', 'dd')
+        no_bullet_li = box.element_tag == 'li' and (
+            'list-item' not in box.style['display'] or
+            box.style['list_style_type'] == 'none')
+        if anonymous_list_element:
+            # Store as list item body.
+            tag = 'LBody'
+        elif anonymous_li_child:
+            # Store as non struct list item body child.
+            tag = 'NonStruct'
+        elif dl_item or no_bullet_li:
+            # Wrap in list item.
+            tag = 'LBody'
+            parent = pydyf.Dictionary({
+                'Type': '/StructElem',
+                'S': '/LI',
+                'K': pydyf.Array([]),
+                'Pg': pdf.page_references[page_number],
+                'P': parent.reference,
+            })
+            pdf.add_object(parent)
+            children = _build_box_tree(box, parent, pdf, page_number, nums, links, tags)
+            for child in children:
+                parent['K'].append(child.reference)
+            yield parent
+            return
+
+    element = pydyf.Dictionary({
+        'Type': '/StructElem',
+        'S': f'/{tag}',
+        'K': pydyf.Array([]),
+        'Pg': pdf.page_references[page_number],
+        'P': parent.reference,
+    })
+    pdf.add_object(element)
+
+    # Handle special cases.
+    if tag == 'Figure':
+        # Add extra data for images.
+        x1, y1 = box.content_box_x(), box.content_box_y()
+        x2, y2 = x1 + box.width, y1 + box.height
+        element['A'] = pydyf.Dictionary({
+            'O': '/Layout',
+            'BBox': pydyf.Array((x1, y1, x2, y2)),
+        })
+        if alt := box.element.attrib.get('alt'):
+            element['Alt'] = pydyf.String(alt)
+        else:
+            source = box.element.attrib.get('src', 'unknown')
+            LOGGER.error(f'Image "{source}" has no required alt description')
+    elif tag == 'Table':
+        # Use wrapped table as tagged box, and put captions in it.
+        wrapper, table = box, box.get_wrapped_table()
+        box = table.copy_with_children([])
+        for child in wrapper.children:
+            box.children.extend(child.children if child is table else [child])
+    elif tag == 'TH':
+        # Set identifier for table headers to reference them in cells.
+        element['ID'] = pydyf.String(id(box))
+    elif tag == 'TD':
+        # Store table cell element to map it to headers later.
+        # TODO: don’t use the box to store this.
+        box.mark = element
+
+    # Include link annotations.
+    if box.link_annotation:
+        annotation = box.link_annotation
+        object_reference = pydyf.Dictionary({
+            'Type': '/OBJR',
+            'Obj': annotation.reference,
+            'Pg': pdf.page_references[page_number],
+        })
+        pdf.add_object(object_reference)
+        links.append((element.reference, annotation))
+        element['K'].append(object_reference.reference)
+
+    if isinstance(box, boxes.ParentBox):
+        # Build tree for box children.
+        for child in box.children:
+            children = child.children if isinstance(child, boxes.LineBox) else [child]
+            for child in children:
+                if isinstance(child, boxes.TextBox):
+                    # Add marked element from the stream.
+                    kid = tags.pop(child)
+                    assert kid['mcid'] not in nums
+                    if tag == 'Link':
+                        # Associate MCID directly with link reference.
+                        element['K'].append(kid['mcid'])
+                        nums[kid['mcid']] = element.reference
+                    else:
+                        kid_element = pydyf.Dictionary({
+                            'Type': '/StructElem',
+                            'S': f'/{kid["tag"]}',
+                            'K': pydyf.Array([kid['mcid']]),
+                            'Pg': pdf.page_references[page_number],
+                            'P': element.reference,
+                        })
+                        pdf.add_object(kid_element)
+                        element['K'].append(kid_element.reference)
+                        nums[kid['mcid']] = kid_element.reference
+                else:
+                    # Recursively build tree for child.
+                    if child.element_tag in ('ul', 'ol') and element['S'] == '/LI':
+                        # In PDFs, nested lists are linked to the parent list, but in
+                        # HTML, nested lists are linked to a parent’s list item.
+                        child_parent = parent
+                    else:
+                        child_parent = element
+                    child_elements = _build_box_tree(
+                        child, child_parent, pdf, page_number, nums, links, tags)
+
+                    # Check if it is already been referenced before.
+                    for child_element in child_elements:
+                        child_parent['K'].append(child_element.reference)
+
+    else:
+        # Add replaced box.
+        assert isinstance(box, boxes.ReplacedBox)
+        kid = tags.pop(box)
+        element['K'].append(kid['mcid'])
+        assert kid['mcid'] not in nums
+        nums[kid['mcid']] = element.reference
+
+    # Link table cells to related headers.
+    if tag == 'Table':
+        def _get_rows(table_box):
+            for child in table_box.children:
+                if child.element_tag == 'tr':
+                    yield child
+                else:
+                    yield from _get_rows(child)
+
+        # Get headers and rows.
+        column_headers = defaultdict(list)
+        row_headers = defaultdict(list)
+        rows = tuple(_get_rows(box))
+
+        # Find column and row headers.
+        # TODO: handle rowspan and colspan values.
+        for i, row in enumerate(rows):
+            for j, cell in enumerate(row.children):
+                if cell.element is None:
+                    continue
+                if cell.element_tag == 'th':
+                    # TODO: handle rowgroup and colgroup values.
+                    if cell.element.attrib.get('scope') == 'row':
+                        row_headers[i].append(pydyf.String(id(cell)))
+                    else:
+                        column_headers[j].append(pydyf.String(id(cell)))
+
+        # Map headers to cells.
+        for i, row in enumerate(rows):
+            for j, cell in enumerate(row.children):
+                if cell.element is None:
+                    continue
+                if cell.element_tag == 'td':
+                    cell.mark['A'] = pydyf.Dictionary({
+                        'O': '/Table',
+                        'Headers': pydyf.Array(row_headers[i] + column_headers[j]),
+                    })
+
+    yield element