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

weasyprint/__init__.py

@@ -15,7 +15,7 @@ import cssselect2
 import tinycss2
 import tinyhtml5
 
-VERSION = __version__ = '65.1'
+VERSION = __version__ = '66.0'
 
 #: Default values for command-line and Python API options. See
 #: :func:`__main__.main` to learn more about specific options for
@@ -39,6 +39,8 @@ VERSION = __version__ = '65.1'
 #:     A PDF version number.
 #: :param bool pdf_forms:
 #:     Whether PDF forms have to be included.
+#: :param bool pdf_tags:
+#:     Whether PDF should be tagged for accessibility.
 #: :param bool uncompressed_pdf:
 #:     Whether PDF content should be compressed.
 #: :param bool custom_metadata:
@@ -71,6 +73,7 @@ DEFAULT_OPTIONS = {
     'pdf_variant': None,
     'pdf_version': None,
     'pdf_forms': None,
+    'pdf_tags': False,
     'uncompressed_pdf': False,
     'custom_metadata': False,
     'presentational_hints': False,

weasyprint/__main__.py

@@ -89,6 +89,8 @@ PARSER.add_argument(
 PARSER.add_argument('--pdf-version', help='PDF version number')
 PARSER.add_argument(
     '--pdf-forms', action='store_true', help='include PDF forms')
+PARSER.add_argument(
+    '--pdf-tags', action='store_true', help='tag PDF for accessibility')
 PARSER.add_argument(
     '--uncompressed-pdf', action='store_true',
     help='do not compress PDF content, mainly for debugging purpose')

weasyprint/css/__init__.py

@@ -573,28 +573,36 @@ def declaration_precedence(origin, importance):
         return 5
 
 
-def resolve_var(computed, token, parent_style):
+def resolve_var(computed, token, parent_style, known_variables=None):
     """Return token with resolved CSS variables."""
     if not check_var_function(token):
         return
 
+    if known_variables is None:
+        known_variables = set()
+
     if token.lower_name != 'var':
         arguments = []
         for i, argument in enumerate(token.arguments):
             if argument.type == 'function':
-                arguments.extend(resolve_var(computed, argument, parent_style))
+                arguments.extend(resolve_var(
+                    computed, argument, parent_style, known_variables))
             else:
                 arguments.append(argument)
         token = tinycss2.ast.FunctionBlock(
             token.source_line, token.source_column, token.name, arguments)
-        return resolve_var(computed, token, parent_style) or (token,)
+        return resolve_var(computed, token, parent_style, known_variables) or (token,)
 
     args = parse_function(token)[1]
     variable_name = args.pop(0).value.replace('-', '_')  # first arg is name
+    if variable_name in known_variables:
+        return []  # endless recursion, returned value is nothing
+    else:
+        known_variables.add(variable_name)
     default = args  # next args are default value
     computed_value = []
     for value in (computed[variable_name] or default):
-        resolved = resolve_var(computed, value, parent_style)
+        resolved = resolve_var(computed, value, parent_style, known_variables)
         computed_value.extend((value,) if resolved is None else resolved)
     return computed_value
 

weasyprint/css/computed_values.py

@@ -282,7 +282,7 @@ def length(style, name, value, font_size=None, pixels_only=False):
     elif unit in LENGTHS_TO_PIXELS:
         # Convert absolute lengths to pixels
         result = value.value * LENGTHS_TO_PIXELS[unit]
-    elif unit in ('em', 'ex', 'ch', 'rem'):
+    elif unit in ('em', 'ex', 'ch', 'rem', 'lh', 'rlh'):
         if font_size is None:
             font_size = style['font_size']
         if unit == 'ex':
@@ -296,6 +296,12 @@ def length(style, name, value, font_size=None, pixels_only=False):
             result = value.value * font_size
         elif unit == 'rem':
             result = value.value * style.root_style['font_size']
+        elif unit == 'lh':
+            line_height, _ = strut_layout(style)
+            result = value.value * line_height
+        elif unit == 'rlh':
+            line_height, _ = strut_layout(style.root_style)
+            result = value.value * line_height
     else:
         # A percentage or 'auto': no conversion needed.
         return value
@@ -478,7 +484,7 @@ def _content_list(style, values):
                 if attr is None:
                     computed_value = None
                 else:
-                    computed_value = (value[0], ((attr,) + value[1][1:]))
+                    computed_value = (value[0], (attr, *value[1][1:]))
             else:
                 computed_value = value
         if computed_value is None:

weasyprint/css/html5_ua.css

@@ -47,11 +47,6 @@ h3 { margin-top: 1em; margin-bottom: 1em }
 h4 { margin-top: 1.33em; margin-bottom: 1.33em }
 h5 { margin-top: 1.67em; margin-bottom: 1.67em }
 h6 { margin-top: 2.33em; margin-bottom: 2.33em }
-:is(article, aside, nav, section) h1 { font-size: 1.5em; margin-bottom: .83em; margin-top: .83em }
-:is(article, aside, nav, section) :is(article, aside, nav, section) h1 { font-size: 1.17em; margin-bottom: 1em; margin-top: 1em }
-:is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) h1 { font-size: 1em; margin-bottom: 1.33em; margin-top: 1.33em }
-:is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) h1 { font-size: .83em; margin-bottom: 1.67em; margin-top: 1.67em }
-:is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) h1 { font-size: .67em; margin-bottom: 2.33em; margin-top: 2.33em }
 
 blockquote, figure { margin-left: 40px; margin-right: 40px }
 
@@ -174,9 +169,9 @@ input:is([type=button i], [type=reset i], [type=submit i])[value], button[value]
 input[type=submit i]:not([value])::before { content: "Submit" }
 input[type=reset i]:not([value])::before { content: "Reset" }
 input:is([type=checkbox i], [type=radio i]) { height: .7em; vertical-align: -.2em; width: .7em }
-input:is([type=checkbox i], [type=radio i])[checked]::before { background: black; content: ""; height: 100% }
+input:is([type=checkbox i], [type=radio i])[checked]::before { background: black; content: ""; display: block; height: 100% }
 input[type=radio i], input[type=radio][checked]:before { border-radius: 50% }
-input[value]::before { content: attr(value); display: block; overflow: hidden }
+input[value]:not([type=checkbox i], [type=radio i])::before { content: attr(value); display: block; overflow: hidden }
 :is(input, input[value=""], input[type=checkbox i], input[type=radio i]) { content: ""; display: block }
 select { background: lightgrey; border-radius: .25em .25em; position: relative; white-space: normal }
 select[multiple] { height: 3.6em }

weasyprint/css/html5_ua_form.css

@@ -1,5 +1,5 @@
 /* Default stylesheet for PDF forms */
 
 button, input, select, textarea { appearance: auto }
-select option, select:not([multiple])::before, input:not([type="submit"])::before {visibility: hidden }
+select option, select:not([multiple])::before, input:not([type="submit"])::before { visibility: hidden }
 textarea { text-indent: 10000% } /* Hide text but don’t change color used by PDF form */

weasyprint/css/utils.py

@@ -40,7 +40,7 @@ RESOLUTION_TO_DPPX = {
 }
 
 # Sets of possible length units
-LENGTH_UNITS = set(LENGTHS_TO_PIXELS) | set(['ex', 'em', 'ch', 'rem'])
+LENGTH_UNITS = set(LENGTHS_TO_PIXELS) | set(['ex', 'em', 'ch', 'rem', 'lh', 'rlh'])
 
 # Constants about background positions
 ZERO_PERCENT = Dimension(0, '%')

weasyprint/document.py

@@ -10,7 +10,7 @@ from .anchors import gather_anchors, make_page_bookmark_tree
 from .css import get_all_computed_styles
 from .css.counters import CounterStyle
 from .css.targets import TargetCollector
-from .draw import draw_page, stacked
+from .draw import draw_page
 from .formatting_structure.build import build_formatting_structure
 from .html import get_html_metadata
 from .images import get_image_from_uri as original_get_image_from_uri
@@ -82,7 +82,7 @@ class Page:
 
     def paint(self, stream, scale=1):
         """Paint the page into the PDF file."""
-        with stacked(stream):
+        with stream.stacked():
             stream.transform(a=scale, d=scale)
             draw_page(self._page_box, stream)
 
@@ -276,14 +276,6 @@ class Document:
         # fonts that may be used when rendering
         self.font_config = font_config
 
-    def build_element_structure(self, structure, etree_element=None):
-        if etree_element is None:
-            etree_element = self._html.etree_element
-            structure[etree_element] = {'parent': None}
-        for child in etree_element:
-            structure[child] = {'parent': etree_element}
-            self.build_element_structure(structure, child)
-
     def copy(self, pages='all'):
         """Take a subset of the pages.
 

weasyprint/draw/__init__.py

@@ -12,7 +12,6 @@ from ..matrix import Matrix
 from ..stacking import StackingContext
 from .border import draw_border, draw_line, draw_outline, rounded_box, set_mask_border
 from .color import styled_color
-from .stack import stacked
 from .text import draw_text
 
 
@@ -32,11 +31,9 @@ def draw_page(page, stream):
 def draw_stacking_context(stream, stacking_context):
     """Draw a ``stacking_context`` on ``stream``."""
     # See https://www.w3.org/TR/CSS2/zindex.html.
-    with stacked(stream):
+    with stream.stacked():
         box = stacking_context.box
 
-        stream.begin_marked_content(box, mcid=True)
-
         # Apply the viewport_overflow to the html box, see #35.
         if box.is_for_root_element and (
                 stacking_context.page.style['overflow'] != 'visible'):
@@ -68,21 +65,20 @@ def draw_stacking_context(stream, stacking_context):
             if box.transformation_matrix.determinant:
                 stream.transform(*box.transformation_matrix.values)
             else:
-                stream.end_marked_content()
                 return
 
         # Point 1 is done in draw_page.
 
         # Point 2.
-        if isinstance(box, (boxes.BlockBox, boxes.MarginBox,
-                            boxes.InlineBlockBox, boxes.TableCellBox,
-                            boxes.FlexContainerBox, boxes.ReplacedBox)):
+        if isinstance(box, (boxes.BlockBox, boxes.MarginBox, boxes.InlineBlockBox,
+                            boxes.TableCellBox, boxes.FlexContainerBox,
+                            boxes.GridContainerBox, boxes.ReplacedBox)):
             set_mask_border(stream, box)
-            # The canvas background was removed by layout_backgrounds
+            # The canvas background was removed by layout_backgrounds.
             draw_background(stream, box.background)
             draw_border(stream, box)
 
-        with stacked(stream):
+        with stream.stacked():
             # Dont clip the page box, see #35.
             clip = (
                 box.style['overflow'] != 'visible' and
@@ -118,17 +114,8 @@ def draw_stacking_context(stream, stacking_context):
                 draw_inline_level(stream, stacking_context.page, box)
 
             # Point 7.
-            for block in (box, *stacking_context.blocks_and_cells):
-                if isinstance(block, boxes.ReplacedBox):
-                    draw_replacedbox(stream, block)
-                elif block.children:
-                    if block != box:
-                        stream.begin_marked_content(block, mcid=True)
-                    if isinstance(block.children[-1], boxes.LineBox):
-                        for child in block.children:
-                            draw_inline_level(stream, stacking_context.page, child)
-                    if block != box:
-                        stream.end_marked_content()
+            draw_block_level(
+                stacking_context.page, stream, {box: stacking_context.blocks_and_cells})
 
             # Point 8.
             for child_context in stacking_context.zero_z_contexts:
@@ -144,12 +131,10 @@ def draw_stacking_context(stream, stacking_context):
         if box.style['opacity'] < 1:
             group_id = stream.id
             stream = original_stream
-            with stacked(stream):
+            with stream.stacked():
                 stream.set_alpha(box.style['opacity'], stroke=True, fill=True)
                 stream.draw_x_object(group_id)
 
-        stream.end_marked_content()
-
 
 def draw_background(stream, bg, clip_box=True, bleed=None, marks=()):
     """Draw the background color and image to a ``pdf.stream.Stream``.
@@ -161,7 +146,7 @@ def draw_background(stream, bg, clip_box=True, bleed=None, marks=()):
     if bg is None:
         return
 
-    with stacked(stream):
+    with stream.stacked():
         if clip_box:
             for box in bg.layers[-1].clipped_boxes:
                 rounded_box(stream, box)
@@ -170,7 +155,7 @@ def draw_background(stream, bg, clip_box=True, bleed=None, marks=()):
 
         # Draw background color.
         if bg.color.alpha > 0:
-            with stacked(stream):
+            with stream.artifact(), stream.stacked():
                 stream.set_color(bg.color)
                 painting_area = bg.layers[-1].painting_area
                 stream.rectangle(*painting_area)
@@ -262,21 +247,21 @@ def draw_background_image(stream, layer, image_rendering):
     image_width, image_height = layer.size
 
     if repeat_x == 'no-repeat' and repeat_y == 'no-repeat':
-        # We don't use a pattern when we don't need to because some viewers
-        # (e.g., Preview on Mac) introduce unnecessary pixelation when vector
-        # images are used in patterns.
-        if not layer.unbounded:
-            stream.rectangle(painting_x, painting_y, painting_width,
-                             painting_height)
-            stream.clip()
-            stream.end()
-        # Put the image in a group so that masking outside the image and
-        # masking within the image don't conflict.
-        group = stream.add_group(*stream.page_rectangle)
-        group.transform(e=position_x + positioning_x,
-                         f=position_y + positioning_y)
-        layer.image.draw(group, image_width, image_height, image_rendering)
-        stream.draw_x_object(group.id)
+        with stream.artifact():
+            # We don't use a pattern when we don't need to because some viewers
+            # (e.g., Preview on Mac) introduce unnecessary pixelation when vector
+            # images are used in patterns.
+            if not layer.unbounded:
+                stream.rectangle(
+                    painting_x, painting_y, painting_width, painting_height)
+                stream.clip()
+                stream.end()
+            # Put the image in a group so that masking outside the image and
+            # masking within the image don't conflict.
+            group = stream.add_group(*stream.page_rectangle)
+            group.transform(e=position_x + positioning_x, f=position_y + positioning_y)
+            layer.image.draw(group, image_width, image_height, image_rendering)
+            stream.draw_x_object(group.id)
         return
 
     if repeat_x == 'no-repeat':
@@ -322,9 +307,10 @@ def draw_background_image(stream, layer, image_rendering):
         0, 0, image_width, image_height, repeat_width, repeat_height, matrix)
     group = pattern.add_group(0, 0, repeat_width, repeat_height)
 
-    with stacked(stream):
+    with stream.artifact(), stream.stacked():
         layer.image.draw(group, image_width, image_height, image_rendering)
-        pattern.draw_x_object(group.id)
+        with pattern.artifact():
+            pattern.draw_x_object(group.id)
         stream.set_color_space('Pattern')
         stream.set_color_special(pattern.id)
         if layer.unbounded:
@@ -476,9 +462,9 @@ def draw_collapsed_borders(stream, table):
 
     for segment in segments:
         _, style, width, color, side, border_box = segment
-        with stacked(stream):
-            bx, by, bw, bh = border_box
-            color = styled_color(style, color, side)
+        bx, by, bw, bh = border_box
+        color = styled_color(style, color, side)
+        with stream.artifact(), stream.stacked():
             draw_line(stream, bx, by, bx + bw, by + bh, width, style, color)
 
 
@@ -491,10 +477,10 @@ def draw_replacedbox(stream, box):
     if draw_width <= 0 or draw_height <= 0:
         return
 
-    with stacked(stream):
+    with stream.stacked():
         stream.set_alpha(1)
         stream.transform(e=draw_x, f=draw_y)
-        with stacked(stream):
+        with stream.stacked():
             # TODO: Use the real intrinsic size here, not affected by
             # 'image-resolution'?
             box.replacement.draw(
@@ -513,15 +499,10 @@ def draw_inline_level(stream, page, box, offset_x=0, text_overflow='clip',
         draw_background(stream, box.background)
         draw_border(stream, box)
         if isinstance(box, (boxes.InlineBox, boxes.LineBox)):
-            link_annotation = None
             if isinstance(box, boxes.LineBox):
                 text_overflow = box.text_overflow
                 block_ellipsis = box.block_ellipsis
-            else:
-                link_annotation = box.link_annotation
             ellipsis = 'none'
-            if link_annotation:
-                stream.begin_marked_content(box, mcid=True, tag='Link')
             for i, child in enumerate(box.children):
                 if i == len(box.children) - 1:
                     # Last child
@@ -531,15 +512,28 @@ def draw_inline_level(stream, page, box, offset_x=0, text_overflow='clip',
                 else:
                     child_offset_x = offset_x + child.position_x - box.position_x
                 if isinstance(child, boxes.TextBox):
-                    draw_text(stream, child, child_offset_x, text_overflow, ellipsis)
+                    with stream.marked(child, 'Span'):
+                        draw_text(
+                            stream, child, child_offset_x, text_overflow, ellipsis)
                 else:
                     draw_inline_level(
                         stream, page, child, child_offset_x, text_overflow, ellipsis)
-            if link_annotation:
-                stream.end_marked_content()
         elif isinstance(box, boxes.InlineReplacedBox):
-            draw_replacedbox(stream, box)
+            with stream.marked(box, 'Figure'):
+                draw_replacedbox(stream, box)
         else:
             assert isinstance(box, boxes.TextBox)
             # Should only happen for list markers.
             draw_text(stream, box, offset_x, text_overflow)
+
+
+def draw_block_level(page, stream, blocks_and_cells):
+    for block, blocks_and_cells in blocks_and_cells.items():
+        if isinstance(block, boxes.ReplacedBox):
+            with stream.marked(block, 'Figure'):
+                draw_replacedbox(stream, block)
+        elif block.children:
+            if isinstance(block.children[-1], boxes.LineBox):
+                for child in block.children:
+                    draw_inline_level(stream, page, child)
+        draw_block_level(page, stream, blocks_and_cells)