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

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)
 
@@ -92,7 +92,7 @@ class DocumentMetadata:
 
     New attributes may be added in future versions of WeasyPrint.
     """
-    def __init__(self, title=None, authors= None, description=None, keywords=None,
+    def __init__(self, title=None, authors=None, description=None, keywords=None,
                  generator=None, created=None, modified=None, attachments=None,
                  lang=None, custom=None, generate_rdf_metadata=generate_rdf_metadata):
         #: The title of the document, as a string or :obj:`None`.
@@ -204,9 +204,11 @@ class Document:
     """
 
     @classmethod
-    def _build_layout_context(cls, html, font_config, counter_style, options):
+    def _build_layout_context(cls, html, font_config, counter_style, color_profiles,
+                              options):
         target_collector = TargetCollector()
         page_rules = []
+        layers = []
         user_stylesheets = []
         cache = options['cache']
         if cache is None:
@@ -217,11 +219,12 @@ class Document:
             if not hasattr(css, 'matcher'):
                 css = CSS(
                     guess=css, media_type=html.media_type,
-                    font_config=font_config, counter_style=counter_style)
+                    font_config=font_config, counter_style=counter_style,
+                    color_profiles=color_profiles)
             user_stylesheets.append(css)
         style_for = get_all_computed_styles(
-            html, user_stylesheets, options['presentational_hints'],
-            font_config, counter_style, page_rules, target_collector,
+            html, user_stylesheets, options['presentational_hints'], font_config,
+            counter_style, color_profiles, page_rules, layers, target_collector,
             options['pdf_forms'])
         get_image_from_uri = functools.partial(
             original_get_image_from_uri, cache=cache,
@@ -233,15 +236,18 @@ class Document:
         return context
 
     @classmethod
-    def _render(cls, html, font_config, counter_style, options):
+    def _render(cls, html, font_config, counter_style, color_profiles, options):
         if font_config is None:
             font_config = FontConfiguration()
 
         if counter_style is None:
             counter_style = CounterStyle()
 
+        if color_profiles is None:
+            color_profiles = {}
+
         context = cls._build_layout_context(
-            html, font_config, counter_style, options)
+            html, font_config, counter_style, color_profiles, options)
 
         root_box = build_formatting_structure(
             html.etree_element, context.style_for, context.get_image_from_uri,
@@ -252,11 +258,11 @@ class Document:
         rendering = cls(
             [Page(page_box) for page_box in page_boxes],
             DocumentMetadata(**get_html_metadata(html)),
-            html.url_fetcher, font_config)
+            html.url_fetcher, font_config, color_profiles)
         rendering._html = html
         return rendering
 
-    def __init__(self, pages, metadata, url_fetcher, font_config):
+    def __init__(self, pages, metadata, url_fetcher, font_config, color_profiles):
         #: A list of :class:`Page` objects.
         self.pages = pages
         #: A :class:`DocumentMetadata` object.
@@ -276,13 +282,7 @@ 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)
+        self.color_profiles = color_profiles
 
     def copy(self, pages='all'):
         """Take a subset of the pages.
@@ -314,7 +314,8 @@ class Document:
         elif not isinstance(pages, list):
             pages = list(pages)
         return type(self)(
-            pages, self.metadata, self.url_fetcher, self.font_config)
+            pages, self.metadata, self.url_fetcher, self.font_config,
+            self.color_profiles)
 
     def make_bookmark_tree(self, scale=1, transform_pages=False):
         """Make a tree of all bookmarks in the document.

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)
@@ -232,7 +217,7 @@ def draw_background(stream, bg, clip_box=True, bleed=None, marks=()):
                 '''
             svg += '</svg>'
             tree = ElementTree.fromstring(svg)
-            image = SVGImage(tree, None, None, stream)
+            image = SVGImage(tree, None, None, None)
             # Painting area is the PDF media box
             size = (width, height)
             position = (x, y)
@@ -247,10 +232,10 @@ def draw_background(stream, bg, clip_box=True, bleed=None, marks=()):
             bg.layers.insert(0, layer)
         # Paint in reversed order: first layer is "closest" to the viewer.
         for layer in reversed(bg.layers):
-            draw_background_image(stream, layer, bg.image_rendering)
+            draw_background_image(stream, layer, bg.style)
 
 
-def draw_background_image(stream, layer, image_rendering):
+def draw_background_image(stream, layer, style):
     if layer.image is None or 0 in layer.size:
         return
 
@@ -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, style)
+            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):
-        layer.image.draw(group, image_width, image_height, image_rendering)
-        pattern.draw_x_object(group.id)
+    with stream.artifact(), stream.stacked():
+        layer.image.draw(group, image_width, image_height, style)
+        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,14 +477,13 @@ 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(
-                stream, draw_width, draw_height, box.style['image_rendering'])
+            box.replacement.draw(stream, draw_width, draw_height, box.style)
 
 
 def draw_inline_level(stream, page, box, offset_x=0, text_overflow='clip',
@@ -513,15 +498,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 +511,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)