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

weasyprint/stacking.py

@@ -45,7 +45,7 @@ class StackingContext:
         child_contexts = [cls.from_box(child, page) for child in page.children]
         # Children are sub-contexts, remove them from the "normal" tree.
         page = page.copy_with_children([])
-        return cls(page, child_contexts, [], [], [], page)
+        return cls(page, child_contexts, [], [], {}, page)
 
     @classmethod
     def from_box(cls, box, page, child_contexts=None):
@@ -60,7 +60,7 @@ class StackingContext:
         #    context, not this new one."
         blocks = []
         floats = []
-        blocks_and_cells = []
+        blocks_and_cells = {}
         box = _dispatch_children(
             box, page, child_contexts, blocks, floats, blocks_and_cells)
         return cls(box, children, blocks, floats, blocks_and_cells, page)
@@ -99,22 +99,21 @@ def _dispatch(box, page, child_contexts, blocks, floats, blocks_and_cells):
     else:
         if isinstance(box, boxes.BlockLevelBox):
             blocks_index = len(blocks)
-            blocks_and_cells_index = len(blocks_and_cells)
+            box_blocks_and_cells = {}
+            box = _dispatch_children(
+                box, page, child_contexts, blocks, floats, box_blocks_and_cells)
+            blocks.insert(blocks_index, box)
+            blocks_and_cells[box] = box_blocks_and_cells
         elif isinstance(box, boxes.TableCellBox):
-            blocks_index = None
-            blocks_and_cells_index = len(blocks_and_cells)
+            box_blocks_and_cells = {}
+            box = _dispatch_children(
+                box, page, child_contexts, blocks, floats, box_blocks_and_cells)
+            blocks_and_cells[box] = box_blocks_and_cells
         else:
             blocks_index = None
-            blocks_and_cells_index = None
-
-        box = _dispatch_children(
-            box, page, child_contexts, blocks, floats, blocks_and_cells)
-
-        # Insert at the positions before dispatch the children.
-        if blocks_index is not None:
-            blocks.insert(blocks_index, box)
-        if blocks_and_cells_index is not None:
-            blocks_and_cells.insert(blocks_and_cells_index, box)
+            box_blocks_and_cells = None
+            box = _dispatch_children(
+                box, page, child_contexts, blocks, floats, blocks_and_cells)
 
         return box
 

weasyprint/svg/__init__.py

@@ -92,6 +92,7 @@ class Node:
         self._wrapper = wrapper
         self._etree_node = wrapper.etree_element
         self._style = style
+        self._children = None
 
         self.attrib = wrapper.etree_element.attrib.copy()
 
@@ -175,13 +176,16 @@ class Node:
             child._wrapper.etree_children = [
                 child._etree_node for child in children]
 
-
     def __iter__(self):
         """Yield node children, handling cascade."""
-        for wrapper in self._wrapper:
-            child = Node(wrapper, self._style)
-            self.cascade(child)
-            yield child
+        if self._children is None:
+            children = []
+            for wrapper in self._wrapper:
+                child = Node(wrapper, self._style)
+                self.cascade(child)
+                children.append(child)
+            self._children = children
+        return iter(self._children)
 
     def get_viewbox(self):
         """Get node viewBox as a tuple of floats."""
@@ -210,7 +214,7 @@ class Node:
             return re.sub('[\n\r\t]', ' ', string)
         else:
             string = re.sub('[\n\r]', '', string)
-            string = re.sub('\t', ' ', string)
+            string = string.replace('\t', ' ')
             return re.sub(' +', ' ', string)
 
     def get_child(self, id_):
@@ -320,14 +324,14 @@ class Node:
         svg.inner_diagonal = hypot(svg.inner_width, svg.inner_height) / sqrt(2)
 
 
-
 class SVG:
     """An SVG document."""
 
-    def __init__(self, tree, url):
+    def __init__(self, tree, url, font_config):
         wrapper = ElementWrapper.from_xml_root(tree)
         style = parse_stylesheets(wrapper, url)
         self.tree = Node(wrapper, style)
+        self.font_config = font_config
         self.url = url
         self.filters = {}
         self.gradients = {}
@@ -401,6 +405,9 @@ class SVG:
 
         original_streams = []
 
+        call_fill_stroke = fill_stroke and node.tag in (
+            'circle', 'ellipse', 'line', 'path', 'polyline', 'polygon', 'rect')
+
         if fill_stroke:
             self.stream.push_state()
 
@@ -410,16 +417,17 @@ class SVG:
             apply_filters(self, node, filter_, font_size)
 
         # Apply transform attribute
-        self.transform(node.get('transform'), font_size)
+        self.transform(node, font_size)
 
         # Create substream for opacity
         opacity = alpha_value(node.get('opacity', 1))
         if fill_stroke and 0 <= opacity < 1:
             original_streams.append(self.stream)
-            box = self.calculate_bounding_box(node, font_size)
-            if not is_valid_bounding_box(box):
-                box = (0, 0, self.inner_width, self.inner_height)
-            self.stream = self.stream.add_group(*box)
+            self.stream = self.stream.add_group(0, 0, 0, 0)  # BBox set after drawing
+
+        # Set graphical state
+        if call_fill_stroke:
+            self.set_graphical_state(node, font_size)
 
         # Clip
         clip_path = parse_url(node.get('clip-path')).fragment
@@ -515,7 +523,7 @@ class SVG:
             paint_mask(self, node, mask, opacity)
 
         # Fill and stroke
-        if fill_stroke:
+        if call_fill_stroke:
             self.fill_stroke(node, font_size)
 
         # Draw markers
@@ -523,6 +531,12 @@ class SVG:
 
         # Apply opacity stream and restore original stream
         if fill_stroke and 0 <= opacity < 1:
+            box = self.calculate_bounding_box(node, font_size)
+            if not is_valid_bounding_box(box):
+                box = (0, 0, self.inner_width, self.inner_height)
+            x, y, width, height = box
+            self.stream.extra['BBox'][:] = x, y, x + width, y + height
+
             group_id = self.stream.id
             self.stream = original_streams.pop()
             self.stream.set_alpha(opacity, stroke=True, fill=True)
@@ -665,37 +679,30 @@ class SVG:
 
         return source, color
 
-    def fill_stroke(self, node, font_size, text=False):
-        """Paint fill and stroke for a node."""
-        if node.tag in ('text', 'textPath', 'a') and not text:
-            return
-
+    def set_graphical_state(self, node, font_size, text=False):
+        """Set stroke and fill colors, and line options."""
         # Get fill data
         fill_source, fill_color = self.get_paint(node.get('fill', 'black'))
         fill_opacity = alpha_value(node.get('fill-opacity', 1))
-        fill_drawn = draw_gradient_or_pattern(
-            self, node, fill_source, font_size, fill_opacity, stroke=False)
-        if fill_color and not fill_drawn:
+        fill_in_gradient = fill_source in self.gradients
+        fill_in_pattern = fill_source in self.patterns
+        if fill_color and not (fill_in_gradient or fill_in_pattern):
             stream_color = color(fill_color)
             stream_color.alpha *= fill_opacity
             self.stream.set_color(stream_color)
-        fill = fill_color or fill_drawn
 
         # Get stroke data
         stroke_source, stroke_color = self.get_paint(node.get('stroke'))
         stroke_opacity = alpha_value(node.get('stroke-opacity', 1))
-        stroke_drawn = draw_gradient_or_pattern(
-            self, node, stroke_source, font_size, stroke_opacity, stroke=True)
-        if stroke_color and not stroke_drawn:
+        stroke_in_gradient = stroke_source in self.gradients
+        stroke_in_pattern = stroke_source in self.patterns
+        if stroke_color and not (stroke_in_gradient or stroke_in_pattern):
             stream_color = color(stroke_color)
             stream_color.alpha *= stroke_opacity
             self.stream.set_color(stream_color, stroke=True)
-        stroke = stroke_color or stroke_drawn
         stroke_width = self.length(node.get('stroke-width', '1px'), font_size)
         if stroke_width:
             self.stream.set_line_width(stroke_width)
-        else:
-            stroke = None
 
         # Apply dash array
         dash_array = tuple(
@@ -738,6 +745,23 @@ class SVG:
             miter_limit = 4
         self.stream.set_miter_limit(miter_limit)
 
+    def fill_stroke(self, node, font_size, text=False):
+        """Paint fill and stroke for a node."""
+        # Get fill data
+        fill_source, fill_color = self.get_paint(node.get('fill', 'black'))
+        fill_opacity = alpha_value(node.get('fill-opacity', 1))
+        fill_drawn = draw_gradient_or_pattern(
+            self, node, fill_source, font_size, fill_opacity, stroke=False)
+        fill = fill_color or fill_drawn
+
+        # Get stroke data
+        stroke_source, stroke_color = self.get_paint(node.get('stroke'))
+        stroke_opacity = alpha_value(node.get('stroke-opacity', 1))
+        stroke_drawn = draw_gradient_or_pattern(
+            self, node, stroke_source, font_size, stroke_opacity, stroke=True)
+        stroke_width = self.length(node.get('stroke-width', '1px'), font_size)
+        stroke = (stroke_color or stroke_drawn) and stroke_width
+
         # Fill and stroke
         even_odd = node.get('fill-rule') == 'evenodd'
         if text:
@@ -760,12 +784,15 @@ class SVG:
             else:
                 self.stream.end()
 
-    def transform(self, transform_string, font_size):
+    def transform(self, node, font_size):
         """Apply a transformation string to the node."""
+        transform_origin = node.get('transform-origin')
+        transform_string = node.get('transform')
         if not transform_string:
             return
 
-        matrix = transform(transform_string, font_size, self.inner_diagonal)
+        matrix = transform(
+            transform_string, transform_origin, font_size, self.inner_diagonal)
         if matrix.determinant:
             self.stream.transform(*matrix.values)
 
@@ -813,7 +840,7 @@ class SVG:
 class Pattern(SVG):
     """SVG node applied as a pattern."""
     def __init__(self, tree, svg):
-        super().__init__(tree._etree_node, svg.url)
+        super().__init__(tree._etree_node, svg.url, svg.font_config)
         self.svg = svg
         self.tree = tree
 

weasyprint/svg/bounding_box.py

@@ -206,7 +206,7 @@ def bounding_box_path(svg, node, font_size):
 
 def bounding_box_text(svg, node, font_size):
     """Bounding box for text node."""
-    return node.get('text_bounding_box')
+    return getattr(node, 'text_bounding_box', None)
 
 
 def bounding_box_g(svg, node, font_size):
@@ -229,7 +229,9 @@ def bounding_box_use(svg, node, font_size):
     if (tree := get_use_tree(svg, node, font_size)) is None:
         return EMPTY_BOUNDING_BOX
     else:
-        return bounding_box(svg, tree, font_size, True)
+        x, y = svg.point(node.get('x'), node.get('y'), font_size)
+        box = bounding_box(svg, tree, font_size, True)
+        return box[0] + x, box[1] + y, box[2], box[3]
 
 
 def _bounding_box_elliptical_arc(x1, y1, rx, ry, phi, large, sweep, x, y):

weasyprint/svg/defs.py

@@ -44,12 +44,6 @@ def get_use_tree(svg, node, font_size):
 
 def use(svg, node, font_size):
     """Draw use tags."""
-    x, y = svg.point(node.get('x'), node.get('y'), font_size)
-
-    for attribute in ('x', 'y', 'viewBox', 'mask'):
-        if attribute in node.attrib:
-            del node.attrib[attribute]
-
     if (tree := get_use_tree(svg, node, font_size)) is None:
         return
 
@@ -69,6 +63,7 @@ def use(svg, node, font_size):
 
     node.cascade(tree)
     node.override_iter(iter((tree,)))
+    x, y = svg.point(node.get('x'), node.get('y'), font_size)
     svg.stream.transform(e=x, f=y)
 
 
@@ -137,7 +132,7 @@ def draw_gradient(svg, node, gradient, font_size, opacity, stroke):
 
     if 'gradientTransform' in gradient.attrib:
         transform_matrix = transform(
-            gradient.get('gradientTransform'), font_size,
+            gradient.get('gradientTransform'), '0 0', font_size,
             svg.normalized_diagonal)
         matrix = transform_matrix @ matrix
 
@@ -407,7 +402,7 @@ def spread_radial_gradient(spread, positions, colors, fx, fy, fr, cx, cy, r,
                 average_positions = [position, ratio, ratio, next_position]
                 zero_color = gradient_average_color(
                     average_colors, average_positions)
-                colors = [zero_color] + original_colors[-(i - 1):] + colors
+                colors = [zero_color, *original_colors[-(i - 1):], *colors]
                 new_positions = [
                     position - 1 - full_repeat for position
                     in original_positions[-(i - 1):]]
@@ -450,7 +445,7 @@ def draw_pattern(svg, node, pattern, font_size, opacity, stroke):
 
     if 'patternTransform' in pattern.attrib:
         transform_matrix = transform(
-            pattern.get('patternTransform'), font_size, svg.inner_diagonal)
+            pattern.get('patternTransform'), '0 0', font_size, svg.inner_diagonal)
         matrix = transform_matrix @ matrix
 
     matrix = matrix @ svg.stream.ctm

weasyprint/svg/images.py

@@ -58,8 +58,15 @@ def image(svg, node, font_size):
         intrinsic_width = intrinsic_ratio * intrinsic_height
     elif intrinsic_height is None:
         intrinsic_height = intrinsic_width / intrinsic_ratio
-    width = width or intrinsic_width
-    height = height or intrinsic_height
+
+    # Calculate final dimensions while preserving aspect ratio
+    if width and not height:
+        height = width / intrinsic_ratio
+    elif height and not width:
+        width = height * intrinsic_ratio
+    else:
+        width = width or intrinsic_width
+        height = height or intrinsic_height
 
     scale_x, scale_y, translate_x, translate_y = preserve_ratio(
         svg, node, font_size, width, height,
@@ -69,8 +76,9 @@ def image(svg, node, font_size):
     svg.stream.end()
     svg.stream.push_state()
     svg.stream.transform(a=scale_x, d=scale_y, e=translate_x, f=translate_y)
+    # TODO: pass real style instead of dict.
     image.draw(
         svg.stream, intrinsic_width, intrinsic_height,
-        image_rendering=node.attrib.get('image-rendering', 'auto'),
+        {'image_rendering': node.attrib.get('image-rendering', 'auto')},
     )
     svg.stream.pop_state()

weasyprint/svg/text.py

@@ -18,6 +18,10 @@ class TextBox:
         return self.pango_layout.text
 
 
+class Style(dict):
+    """Dummy class to store dict."""
+
+
 def text(svg, node, font_size):
     """Draw text node."""
     from ..css.properties import INITIAL_VALUES
@@ -25,7 +29,9 @@ def text(svg, node, font_size):
     from ..text.line_break import split_first_line
 
     # TODO: use real computed values
-    style = INITIAL_VALUES.copy()
+    style = Style()
+    style.update(INITIAL_VALUES)
+    style.font_config = svg.font_config
     style['font_family'] = [
         font.strip('"\'') for font in
         node.get('font-family', 'sans-serif').split(',')]
@@ -123,6 +129,7 @@ def text(svg, node, font_size):
         return
 
     svg.stream.push_state()
+    svg.set_graphical_state(node, font_size, text=True)
     svg.stream.begin_text()
     emoji_lines = []
 
@@ -166,4 +173,6 @@ def text(svg, node, font_size):
     svg.stream.pop_state()
 
     for font_size, x, y, emojis in emoji_lines:
-        draw_emojis(svg.stream, font_size, x, y, emojis)
+        # TODO: pass real style instead of dict.
+        style = {'font_size': font_size}
+        draw_emojis(svg.stream, style, x, y, emojis)

weasyprint/svg/utils.py

@@ -5,7 +5,7 @@ from contextlib import suppress
 from math import cos, radians, sin, tan
 from urllib.parse import urlparse
 
-from tinycss2.color4 import parse_color
+from tinycss2.color5 import parse_color
 
 from ..matrix import Matrix
 
@@ -25,7 +25,7 @@ def normalize(string):
 
 def size(string, font_size=None, percentage_reference=None):
     """Compute size from string, resolving units and percentages."""
-    from ..css.utils import LENGTHS_TO_PIXELS
+    from ..css.units import LENGTHS_TO_PIXELS
 
     if not string:
         return 0
@@ -94,7 +94,10 @@ def preserve_ratio(svg, node, font_size, width, height, viewbox=None):
     scale_x = width / viewbox_width if viewbox_width else 1
     scale_y = height / viewbox_height if viewbox_height else 1
 
-    aspect_ratio = node.get('preserveAspectRatio', 'xMidYMid').split()
+    if viewbox:
+        aspect_ratio = node.get('preserveAspectRatio', 'xMidYMid').split()
+    else:
+        aspect_ratio = ('none',)
     align = aspect_ratio[0]
     if align == 'none':
         x_position = 'min'
@@ -149,13 +152,17 @@ def color(string):
     return parse_color(string or '') or parse_color('black')
 
 
-def transform(transform_string, font_size, normalized_diagonal):
+def transform(transform_string, transform_origin, font_size, normalized_diagonal):
     """Get a matrix corresponding to the transform string."""
     # TODO: merge with gather_anchors and css.validation.properties.transform
-    transformations = re.findall(
-        r'(\w+) ?\( ?(.*?) ?\)', normalize(transform_string))
-    matrix = Matrix()
 
+    origin_x, origin_y = 0, 0
+    size_strings = normalize(transform_origin).split()
+    if len(size_strings) == 2:
+        origin_x, origin_y = size(size_strings[0]), size(size_strings[1])
+    matrix = Matrix(e=origin_x, f=origin_y)
+
+    transformations = re.findall(r'(\w+) ?\( ?(.*?) ?\)', normalize(transform_string))
     for transformation_type, transformation in transformations:
         values = [
             size(value, font_size, normalized_diagonal)
@@ -196,4 +203,4 @@ def transform(transform_string, font_size, normalized_diagonal):
             if transformation_type in ('scaleY', 'scale'):
                 matrix = Matrix(d=values.pop(0)) @ matrix
 
-    return matrix
+    return Matrix(e=-origin_x, f=-origin_y) @ matrix

weasyprint/text/constants.py

@@ -462,7 +462,7 @@ LANG_QUOTES = {
 }
 
 
-@lru_cache()
+@lru_cache
 def get_lang_quotes(lang):
     if lang in LANG_QUOTES:
         return LANG_QUOTES[lang]

weasyprint/text/ffi.py

@@ -22,6 +22,7 @@ ffi.cdef('''
     hb_blob_t * hb_face_reference_blob (hb_face_t *face);
     unsigned int hb_face_get_index (const hb_face_t *face);
     unsigned int hb_face_get_upem (const hb_face_t *face);
+    unsigned int hb_face_get_glyph_count (const hb_face_t *face);
     hb_blob_t * hb_face_reference_table (const hb_face_t *face, hb_tag_t tag);
     const char * hb_blob_get_data (hb_blob_t *blob, unsigned int *length);
     unsigned int hb_blob_get_length (hb_blob_t *blob);
@@ -450,8 +451,8 @@ def _dlopen(ffi, *names, allow_fail=False):
             return ffi.dlopen(name, flags)
     if allow_fail:
         return
-    # Re-raise the exception.
-    print(
+    # Print error message and re-raise the exception.
+    print(  # noqa: T201, logger is not configured yet
         '\n-----\n\n'
         'WeasyPrint could not import some external libraries. Please '
         'carefully follow the installation steps before reporting an issue:\n'
@@ -474,7 +475,7 @@ if hasattr(os, 'add_dll_directory') and not hasattr(sys, 'frozen'):  # pragma: n
 
 gobject = _dlopen(
     ffi, 'libgobject-2.0-0', 'gobject-2.0-0', 'gobject-2.0',
-    'libgobject-2.0.so.0', 'libgobject-2.0.dylib', 'libgobject-2.0-0.dll')
+    'libgobject-2.0.so.0', 'libgobject-2.0.0.dylib', 'libgobject-2.0-0.dll')
 pango = _dlopen(
     ffi, 'libpango-1.0-0', 'pango-1.0-0', 'pango-1.0', 'libpango-1.0.so.0',
     'libpango-1.0.dylib', 'libpango-1.0-0.dll')

weasyprint/text/fonts.py

@@ -2,6 +2,7 @@
 
 from hashlib import md5
 from io import BytesIO
+from locale import getpreferredencoding
 from pathlib import Path
 from shutil import rmtree
 from tempfile import mkdtemp
@@ -11,7 +12,7 @@ from xml.etree.ElementTree import Element, SubElement, tostring
 from fontTools.ttLib import TTFont, woff2
 
 from ..logger import LOGGER
-from ..urls import FILESYSTEM_ENCODING, fetch
+from ..urls import fetch
 
 from .constants import (  # isort:skip
     CAPS_KEYS, EAST_ASIAN_KEYS, FONTCONFIG_STRETCH, FONTCONFIG_STYLE, FONTCONFIG_WEIGHT,
@@ -20,6 +21,8 @@ from .ffi import (  # isort:skip
     FROM_UNITS, TO_UNITS, ffi, fontconfig, gobject, harfbuzz, pango, pangoft2,
     unicode_to_char_p)
 
+PREFERRED_ENCODING = getpreferredencoding(False)
+
 
 def _check_font_configuration(font_config):  # pragma: no cover
     """Check whether the given font_config has fonts.
@@ -105,6 +108,10 @@ class FontConfiguration:
         # Temporary folder storing fonts.
         self._folder = None
 
+        # Cache.
+        self.strut_layouts = {}
+        self.font_features = {}
+
     def add_font_face(self, rule_descriptors, url_fetcher):
         """Add a font face to the Fontconfig configuration."""
 
@@ -150,7 +157,7 @@ class FontConfiguration:
                     if font_name.lower() == name.lower():
                         fontconfig.FcPatternGetString(
                             matching_pattern, b'file', 0, string)
-                        path = ffi.string(string[0]).decode(FILESYSTEM_ENCODING)
+                        path = ffi.string(string[0]).decode(PREFERRED_ENCODING)
                         url = Path(path).as_uri()
                         break
                 else:
@@ -191,7 +198,8 @@ class FontConfiguration:
             match = SubElement(root, 'match', target='scan')
             test = SubElement(match, 'test', name='file', compare='eq')
             SubElement(test, 'string').text = str(font_path)
-            edit = SubElement(match, 'edit', name='family', mode=mode)
+            # Prepend, as replacing the font family breaks Pango, see #2510.
+            edit = SubElement(match, 'edit', name='family', mode='prepend')
             SubElement(edit, 'string').text = rule_descriptors['font_family']
             if 'font_style' in rule_descriptors:
                 edit = SubElement(match, 'edit', name='slant', mode=mode)
@@ -235,7 +243,7 @@ class FontConfiguration:
             # too as explained in Behdad's blog entry.
             fontconfig.FcConfigParseAndLoadFromMemory(self._config, xml, True)
             font_added = fontconfig.FcConfigAppFontAddFile(
-                self._config, str(font_path).encode(FILESYSTEM_ENCODING))
+                self._config, str(font_path).encode(PREFERRED_ENCODING))
             if font_added:
                 return pangoft2.pango_fc_font_map_config_changed(
                     ffi.cast('PangoFcFontMap *', self.font_map))
@@ -374,7 +382,7 @@ def get_pango_font_key(pango_font):
     # TODO: This value is stable for a given Pango font in a given Pango map, but can’t
     # be cached with just the Pango font as a key because two Pango fonts could point to
     # the same address for two different Pango maps. We should cache it in the
-    # FontConfiguration object. See https://github.com/Kozea/WeasyPrint/issues/2144
+    # FontConfiguration object. See issue #2144.
     description = ffi.gc(
         pango.pango_font_describe(pango_font), pango.pango_font_description_free)
     font_size = pango.pango_font_description_get_size(description) * FROM_UNITS