PyPI - weasyprint - Versions diffs - 67.0__py3-none-any.whl → 68.1__py3-none-any.whl - Mend

weasyprint 67.0py3-none-any.whl → 68.1py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (36) hide show

weasyprint/__init__.py +35 -103
weasyprint/__main__.py +107 -80
weasyprint/css/__init__.py +7 -14
weasyprint/css/functions.py +5 -0
weasyprint/css/html5_ua.css +1 -1
weasyprint/css/tokens.py +4 -1
weasyprint/css/validation/properties.py +4 -4
weasyprint/document.py +4 -64
weasyprint/draw/text.py +12 -10
weasyprint/formatting_structure/boxes.py +4 -1
weasyprint/formatting_structure/build.py +111 -37
weasyprint/images.py +27 -32
weasyprint/layout/__init__.py +2 -1
weasyprint/layout/block.py +22 -16
weasyprint/layout/grid.py +25 -14
weasyprint/layout/page.py +4 -4
weasyprint/layout/preferred.py +63 -24
weasyprint/pdf/__init__.py +12 -1
weasyprint/pdf/anchors.py +10 -16
weasyprint/pdf/fonts.py +12 -3
weasyprint/pdf/metadata.py +153 -98
weasyprint/pdf/pdfa.py +1 -3
weasyprint/pdf/pdfua.py +1 -3
weasyprint/pdf/pdfx.py +1 -3
weasyprint/svg/__init__.py +52 -32
weasyprint/svg/css.py +21 -4
weasyprint/svg/defs.py +5 -9
weasyprint/svg/text.py +4 -3
weasyprint/text/fonts.py +2 -3
weasyprint/text/line_break.py +4 -5
weasyprint/urls.py +290 -97
{weasyprint-67.0.dist-info → weasyprint-68.1.dist-info}/METADATA +2 -1
{weasyprint-67.0.dist-info → weasyprint-68.1.dist-info}/RECORD +36 -36
{weasyprint-67.0.dist-info → weasyprint-68.1.dist-info}/WHEEL +0 -0
{weasyprint-67.0.dist-info → weasyprint-68.1.dist-info}/entry_points.txt +0 -0
{weasyprint-67.0.dist-info → weasyprint-68.1.dist-info}/licenses/LICENSE +0 -0

weasyprint/pdf/metadata.py CHANGED Viewed

@@ -11,6 +11,7 @@ from .. import __version__
 NS = {
     'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
     'dc': 'http://purl.org/dc/elements/1.1/',
+    '': '',
     'xmp': 'http://ns.adobe.com/xap/1.0/',
     'xmpMM': 'http://ns.adobe.com/xap/1.0/mm/',
     'pdf': 'http://ns.adobe.com/pdf/1.3/',
@@ -23,110 +24,164 @@ for key, value in NS.items():
     register_namespace(key, value)
-def add_metadata(pdf, metadata, variant, version, conformance, compress):
-    """Add PDF stream of metadata.
-    Described in ISO-32000-1:2008, 14.3.2.
+class DocumentMetadata:
+    """Meta-information belonging to a whole :class:`Document`.
+    New attributes may be added in future versions of WeasyPrint.
     """
-    header = b'<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>'
-    footer = b'<?xpacket end="r"?>'
-    xml_data = metadata.generate_rdf_metadata(metadata, variant, version, conformance)
-    stream_content = b'\n'.join((header, xml_data, footer))
-    extra = {'Type': '/Metadata', 'Subtype': '/XML'}
-    metadata = pydyf.Stream([stream_content], extra, compress)
-    pdf.add_object(metadata)
-    pdf.catalog['Metadata'] = metadata.reference
+    def __init__(self, title=None, authors=None, description=None, keywords=None,
+                 generator=None, created=None, modified=None, attachments=None,
+                 lang=None, custom=None, xmp_metadata=None):
+        #: The title of the document, as a string or :obj:`None`.
+        #: Extracted from the ``<title>`` element in HTML
+        #: and written to the ``/Title`` info field in PDF.
+        self.title = title
+        #: The authors of the document, as a list of strings.
+        #: (Defaults to the empty list.)
+        #: Extracted from the ``<meta name=author>`` elements in HTML
+        #: and written to the ``/Author`` info field in PDF.
+        self.authors = authors or []
+        #: The description of the document, as a string or :obj:`None`.
+        #: Extracted from the ``<meta name=description>`` element in HTML
+        #: and written to the ``/Subject`` info field in PDF.
+        self.description = description
+        #: Keywords associated with the document, as a list of strings.
+        #: (Defaults to the empty list.)
+        #: Extracted from ``<meta name=keywords>`` elements in HTML
+        #: and written to the ``/Keywords`` info field in PDF.
+        self.keywords = keywords or []
+        #: The name of one of the software packages
+        #: used to generate the document, as a string or :obj:`None`.
+        #: Extracted from the ``<meta name=generator>`` element in HTML
+        #: and written to the ``/Creator`` info field in PDF.
+        self.generator = generator
+        #: The creation date of the document, as a string or :obj:`None`.
+        #: Dates are in one of the six formats specified in
+        #: `W3C’s profile of ISO 8601 <https://www.w3.org/TR/NOTE-datetime>`_.
+        #: Extracted from the ``<meta name=dcterms.created>`` element in HTML
+        #: and written to the ``/CreationDate`` info field in PDF.
+        self.created = created
+        #: The modification date of the document, as a string or :obj:`None`.
+        #: Dates are in one of the six formats specified in
+        #: `W3C’s profile of ISO 8601 <https://www.w3.org/TR/NOTE-datetime>`_.
+        #: Extracted from the ``<meta name=dcterms.modified>`` element in HTML
+        #: and written to the ``/ModDate`` info field in PDF.
+        self.modified = modified
+        #: A list of :class:`attachments <weasyprint.Attachment>`, empty by default.
+        #: Extracted from the ``<link rel=attachment>`` elements in HTML
+        #: and written to the ``/EmbeddedFiles`` dictionary in PDF.
+        self.attachments = attachments or []
+        #: Document language as BCP 47 language tags.
+        #: Extracted from ``<html lang=lang>`` in HTML.
+        self.lang = lang
+        #: Custom metadata, as a dict whose keys are the metadata names and
+        #: values are the metadata values.
+        self.custom = custom or {}
+        #: A list of XML bytestrings to add into the XMP metadata.
+        self.xmp_metadata = xmp_metadata or []
-def generate_rdf_metadata(metadata, variant, version, conformance):
-    """Generate RDF metadata as a bytestring.
+    def include_in_pdf(self, pdf, variant, version, conformance, compress):
+        """Add PDF stream of metadata.
-    Might be replaced by DocumentMetadata.rdf_metadata_generator().
+        Described in ISO-32000-1:2008, 14.3.2.
-    """
-    namespace = f'pdf{variant}id'
-    rdf = Element(f'{{{NS["rdf"]}}}RDF')
+        """
+        header = b'<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>\n'
+        header += b'<x:xmpmeta xmlns:x="adobe:ns:meta/">'
+        footer = b'</x:xmpmeta>\n<?xpacket end="r"?>'
+        xml_data = self.generate_rdf_metadata(variant, version, conformance)
+        stream_content = b'\n'.join((header, xml_data, *self.xmp_metadata, footer))
+        extra = {'Type': '/Metadata', 'Subtype': '/XML'}
+        metadata = pydyf.Stream([stream_content], extra, compress)
+        pdf.add_object(metadata)
+        pdf.catalog['Metadata'] = metadata.reference
+    def generate_rdf_metadata(self, variant, version, conformance):
+        """Generate RDF metadata as a bytestring."""
+        namespace = f'pdf{variant}id'
+        rdf = Element(f'{{{NS["rdf"]}}}RDF')
+        if version:
+            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
+            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
+            element.attrib[f'{{{NS[namespace]}}}part'] = str(version)
+        if conformance:
+            assert version
+            if variant == 'x':
+                for key in (
+                    f'{{{NS["pdfxid"]}}}GTS_PDFXVersion',
+                    f'{{{NS["pdfx"]}}}GTS_PDFXVersion',
+                    f'{{{NS["pdfx"]}}}GTS_PDFXConformance',
+                ):
+                    subelement = SubElement(element, key)
+                    subelement.text = conformance
+                subelement = SubElement(element, f'{{{NS["pdf"]}}}Trapped')
+                subelement.text = 'False'
+                if version >= 4:
+                    # TODO: these values could be useful instead of using random values.
+                    assert self.modified
+                    subelement = SubElement(element, f'{{{NS["xmp"]}}}MetadataDate')
+                    subelement.text = self.modified
+                    subelement = SubElement(element, f'{{{NS["xmpMM"]}}}DocumentID')
+                    subelement.text = f'xmp.did:{uuid4()}'
+                    subelement = SubElement(element, f'{{{NS["xmpMM"]}}}RenditionClass')
+                    subelement.text = 'proof:pdf'
+                    subelement = SubElement(element, f'{{{NS["xmpMM"]}}}VersionID')
+                    subelement.text = '1'
+            else:
+                element.attrib[f'{{{NS[namespace]}}}conformance'] = conformance
+                if variant == 'a' and version == 4:
+                    subelement = SubElement(element, f'{{{NS["pdfaid"]}}}rev')
+                    subelement.text = '2020'
-    if version:
-        element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
-        element.attrib[f'{{{NS["rdf"]}}}about'] = ''
-        element.attrib[f'{{{NS[namespace]}}}part'] = str(version)
-    if conformance:
-        assert version
-        if variant == 'x':
-            for key in (
-                f'{{{NS["pdfxid"]}}}GTS_PDFXVersion',
-                f'{{{NS["pdfx"]}}}GTS_PDFXVersion',
-                f'{{{NS["pdfx"]}}}GTS_PDFXConformance',
-            ):
-                subelement = SubElement(element, key)
-                subelement.text = conformance
-            subelement = SubElement(element, f'{{{NS["pdf"]}}}Trapped')
-            subelement.text = 'False'
-            if version >= 4:
-                # TODO: these values could be useful instead of using random values.
-                assert metadata.modified
-                subelement = SubElement(element, f'{{{NS["xmp"]}}}MetadataDate')
-                subelement.text = metadata.modified
-                subelement = SubElement(element, f'{{{NS["xmpMM"]}}}DocumentID')
-                subelement.text = f'xmp.did:{uuid4()}'
-                subelement = SubElement(element, f'{{{NS["xmpMM"]}}}RenditionClass')
-                subelement.text = 'proof:pdf'
-                subelement = SubElement(element, f'{{{NS["xmpMM"]}}}VersionID')
-                subelement.text = '1'
-        else:
-            element.attrib[f'{{{NS[namespace]}}}conformance'] = conformance
-            if variant == 'a' and version == 4:
-                subelement = SubElement(element, f'{{{NS["pdfaid"]}}}rev')
-                subelement.text = '2020'
-    element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
-    element.attrib[f'{{{NS["rdf"]}}}about'] = ''
-    element.attrib[f'{{{NS["pdf"]}}}Producer'] = f'WeasyPrint {__version__}'
-    if metadata.title:
-        element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
-        element.attrib[f'{{{NS["rdf"]}}}about'] = ''
-        element = SubElement(element, f'{{{NS["dc"]}}}title')
-        element = SubElement(element, f'{{{NS["rdf"]}}}Alt')
-        element = SubElement(element, f'{{{NS["rdf"]}}}li')
-        element.attrib['xml:lang'] = 'x-default'
-        element.text = metadata.title
-    if metadata.authors:
-        element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
-        element.attrib[f'{{{NS["rdf"]}}}about'] = ''
-        element = SubElement(element, f'{{{NS["dc"]}}}creator')
-        element = SubElement(element, f'{{{NS["rdf"]}}}Seq')
-        for author in metadata.authors:
-            author_element = SubElement(element, f'{{{NS["rdf"]}}}li')
-            author_element.text = author
-    if metadata.description:
-        element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
-        element.attrib[f'{{{NS["rdf"]}}}about'] = ''
-        element = SubElement(element, f'{{{NS["dc"]}}}subject')
-        element = SubElement(element, f'{{{NS["rdf"]}}}Bag')
-        element = SubElement(element, f'{{{NS["rdf"]}}}li')
-        element.attrib['xml:lang'] = 'x-default'
-        element.text = metadata.description
-    if metadata.keywords:
-        element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
-        element.attrib[f'{{{NS["rdf"]}}}about'] = ''
-        element = SubElement(element, f'{{{NS["pdf"]}}}Keywords')
-        element.text = ', '.join(metadata.keywords)
-    if metadata.generator:
-        element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
-        element.attrib[f'{{{NS["rdf"]}}}about'] = ''
-        element = SubElement(element, f'{{{NS["xmp"]}}}CreatorTool')
-        element.text = metadata.generator
-    if metadata.created:
-        element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
-        element.attrib[f'{{{NS["rdf"]}}}about'] = ''
-        element = SubElement(element, f'{{{NS["xmp"]}}}CreateDate')
-        element.text = metadata.created
-    if metadata.modified:
         element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
         element.attrib[f'{{{NS["rdf"]}}}about'] = ''
-        element = SubElement(element, f'{{{NS["xmp"]}}}ModifyDate')
-        element.text = metadata.modified
-    return tostring(rdf, encoding='utf-8')
+        element.attrib[f'{{{NS["pdf"]}}}Producer'] = f'WeasyPrint {__version__}'
+        if self.title:
+            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
+            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
+            element = SubElement(element, f'{{{NS["dc"]}}}title')
+            element = SubElement(element, f'{{{NS["rdf"]}}}Alt')
+            element = SubElement(element, f'{{{NS["rdf"]}}}li')
+            element.attrib['xml:lang'] = 'x-default'
+            element.text = self.title
+        if self.authors:
+            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
+            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
+            element = SubElement(element, f'{{{NS["dc"]}}}creator')
+            element = SubElement(element, f'{{{NS["rdf"]}}}Seq')
+            for author in self.authors:
+                author_element = SubElement(element, f'{{{NS["rdf"]}}}li')
+                author_element.text = author
+        if self.description:
+            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
+            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
+            element = SubElement(element, f'{{{NS["dc"]}}}subject')
+            element = SubElement(element, f'{{{NS["rdf"]}}}Bag')
+            element = SubElement(element, f'{{{NS["rdf"]}}}li')
+            element.attrib['xml:lang'] = 'x-default'
+            element.text = self.description
+        if self.keywords:
+            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
+            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
+            element = SubElement(element, f'{{{NS["pdf"]}}}Keywords')
+            element.text = ', '.join(self.keywords)
+        if self.generator:
+            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
+            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
+            element = SubElement(element, f'{{{NS["xmp"]}}}CreatorTool')
+            element.text = self.generator
+        if self.created:
+            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
+            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
+            element = SubElement(element, f'{{{NS["xmp"]}}}CreateDate')
+            element.text = self.created
+        if self.modified:
+            element = SubElement(rdf, f'{{{NS["rdf"]}}}Description')
+            element.attrib[f'{{{NS["rdf"]}}}about'] = ''
+            element = SubElement(element, f'{{{NS["xmp"]}}}ModifyDate')
+            element.text = self.modified
+        return tostring(rdf, encoding='utf-8')

weasyprint/pdf/pdfa.py CHANGED Viewed

@@ -4,8 +4,6 @@ from functools import partial
 import pydyf
-from .metadata import add_metadata
 def pdfa(pdf, metadata, document, page_streams, attachments, compress,
          version, variant):
@@ -65,7 +63,7 @@ def pdfa(pdf, metadata, document, page_streams, attachments, compress,
     if version == 1:
         # Metadata compression is forbidden for version 1.
         compress = False
-    add_metadata(pdf, metadata, 'a', version, variant, compress)
+    metadata.include_in_pdf(pdf, 'a', version, variant, compress)
     # Remove document information.
     if version >= 4:

weasyprint/pdf/pdfua.py CHANGED Viewed

@@ -2,13 +2,11 @@
 from functools import partial
-from .metadata import add_metadata
 def pdfua(pdf, metadata, document, page_streams, attachments, compress, version):
     """Set metadata for PDF/UA documents."""
     # Common PDF metadata stream
-    add_metadata(pdf, metadata, 'ua', version, conformance=None, compress=compress)
+    metadata.include_in_pdf(pdf, 'ua', version, conformance=None, compress=compress)
 VARIANTS = {

weasyprint/pdf/pdfx.py CHANGED Viewed

@@ -5,8 +5,6 @@ from time import localtime
 import pydyf
-from .metadata import add_metadata
 def pdfx(pdf, metadata, document, page_streams, attachments, compress, version,
          variant):
@@ -47,7 +45,7 @@ def pdfx(pdf, metadata, document, page_streams, attachments, compress, version,
         ])
     # Common PDF metadata stream.
-    add_metadata(pdf, metadata, 'x', version, conformance, compress=compress)
+    metadata.include_in_pdf(pdf, 'x', version, conformance, compress=compress)
 VARIANTS = {

weasyprint/svg/__init__.py CHANGED Viewed

@@ -9,7 +9,7 @@ from cssselect2 import ElementWrapper
 from ..urls import get_url_attribute
 from .css import parse_declarations, parse_stylesheets
-from .defs import apply_filters, clip_path, draw_gradient_or_pattern, paint_mask, use
+from .defs import apply_filters, draw_gradient_or_pattern, paint_mask, use
 from .images import image, svg
 from .path import path
 from .shapes import circle, ellipse, line, polygon, polyline, rect
@@ -24,7 +24,6 @@ from .utils import (  # isort:skip
 TAGS = {
     'a': text,
     'circle': circle,
-    'clipPath': clip_path,
     'ellipse': ellipse,
     'image': image,
     'line': line,
@@ -155,6 +154,14 @@ class Node:
                 for name, value in declarations:
                     child.attrib[name] = value.strip()
+        # Expand
+        # TODO: simplified expanders, use CSS expander code instead.
+        if font := child.attrib.pop('font', None):
+            parts = font.strip().split(maxsplit=1)
+            if len(parts) == 2:
+                child.attrib['font-size'] = parts[0]
+                child.attrib['font-family'] = parts[1]
         # Replace 'currentColor' value
         for key in COLOR_ATTRIBUTES:
             if child.get(key) == 'currentColor':
@@ -219,6 +226,8 @@ class Node:
     def get_child(self, id_):
         """Get a child with given id in the whole child tree."""
+        if self._etree_node.find(f'.//*[@id="{id_}"]') is None:
+            return
         for child in self:
             if child.get('id') == id_:
                 return child
@@ -324,23 +333,52 @@ class Node:
         svg.inner_diagonal = hypot(svg.inner_width, svg.inner_height) / sqrt(2)
+class LazyDefs:
+    def __init__(self, name, svg):
+        self._name = name
+        self._svg = svg
+        self._data = {}
+    def __getitem__(self, name):
+        return self.get(name)
+    def get(self, name):
+        if not name:
+            return
+        if name in self._data:
+            return self._data[name]
+        node = self._svg.tree.get_child(name)
+        if node is not None and self._name in node.tag.lower():
+            self._data[name] = node
+            if self._name in ('gradient', 'pattern'):
+                self._svg.inherit_element(node, self)
+        else:
+            self._data[name] = None
+        return self._data[name]
+    def __contains__(self, name):
+        return self.get(name)
 class SVG:
     """An SVG document."""
-    def __init__(self, tree, url, font_config):
+    def __init__(self, tree, url, font_config, url_fetcher=None):
         wrapper = ElementWrapper.from_xml_root(tree)
-        style = parse_stylesheets(wrapper, url)
+        style = parse_stylesheets(wrapper, url, font_config, url_fetcher)
         self.tree = Node(wrapper, style)
         self.font_config = font_config
+        self.url_fetcher = url_fetcher
         self.url = url
-        self.filters = {}
-        self.gradients = {}
-        self.images = {}
-        self.markers = {}
-        self.masks = {}
-        self.patterns = {}
-        self.paths = {}
-        self.symbols = {}
+        self.filters = LazyDefs('filter', self)
+        self.gradients = LazyDefs('gradient', self)
+        self.images = LazyDefs('image', self)
+        self.markers = LazyDefs('marker', self)
+        self.masks = LazyDefs('mask', self)
+        self.patterns = LazyDefs('pattern', self)
+        self.paths = LazyDefs('path', self)
+        self.symbols = LazyDefs('symbol', self)
         self.use_cache = {}
@@ -349,8 +387,6 @@ class SVG:
         self.text_path_width = 0
         self.tree.cascade(self.tree)
-        self.parse_defs(self.tree)
-        self.inherit_defs()
     def get_intrinsic_size(self, font_size):
         """Get intrinsic size of the image."""
@@ -382,15 +418,13 @@ class SVG:
         """Compute size of an arbirtary attribute."""
         return size(length, font_size, self.inner_diagonal)
-    def draw(self, stream, concrete_width, concrete_height, base_url,
-             url_fetcher, context):
+    def draw(self, stream, concrete_width, concrete_height, base_url, context):
         """Draw image on a stream."""
         self.stream = stream
         self.tree.set_svg_size(self, concrete_width, concrete_height)
         self.base_url = base_url
-        self.url_fetcher = url_fetcher
         self.context = context
         self.draw_node(self.tree, size('12pt'))
@@ -796,20 +830,6 @@ class SVG:
         if matrix.determinant:
             self.stream.transform(*matrix.values)
-    def parse_defs(self, node):
-        """Parse defs included in a tree."""
-        for def_type in DEF_TYPES:
-            if def_type in node.tag.lower() and 'id' in node.attrib:
-                getattr(self, f'{def_type}s')[node.attrib['id']] = node
-        for child in node:
-            self.parse_defs(child)
-    def inherit_defs(self):
-        """Handle inheritance of different defined elements lists."""
-        for defs in (self.gradients, self.patterns):
-            for element in defs.values():
-                self.inherit_element(element, defs)
     def inherit_element(self, element, defs):
         """Recursively handle inheritance of defined element."""
         href = element.get_href(self.url)
@@ -840,7 +860,7 @@ class SVG:
 class Pattern(SVG):
     """SVG node applied as a pattern."""
     def __init__(self, tree, svg):
-        super().__init__(tree._etree_node, svg.url, svg.font_config)
+        super().__init__(tree._etree_node, svg.url, svg.font_config, svg.url_fetcher)
         self.svg = svg
         self.tree = tree

weasyprint/svg/css.py CHANGED Viewed

@@ -5,11 +5,12 @@ from urllib.parse import urljoin
 import cssselect2
 import tinycss2
+from ..css.validation.descriptors import preprocess_descriptors
 from ..logger import LOGGER
 from .utils import parse_url
-def find_stylesheets_rules(tree, stylesheet_rules, url):
+def find_stylesheets_rules(tree, stylesheet_rules, url, font_config, url_fetcher):
     """Find rules among stylesheet rules and imports."""
     for rule in stylesheet_rules:
         if rule.type == 'at-rule':
@@ -22,7 +23,22 @@ def find_stylesheets_rules(tree, stylesheet_rules, url):
                 stylesheet = tinycss2.parse_stylesheet(
                     tree.fetch_url(css_url, 'text/css').decode())
                 url = css_url.geturl()
-                yield from find_stylesheets_rules(tree, stylesheet, url)
+                yield from find_stylesheets_rules(
+                    tree, stylesheet, url, font_config, url_fetcher)
+            elif rule.lower_at_keyword == 'font-face':
+                if font_config is not None and url_fetcher is not None:
+                    content = tinycss2.parse_blocks_contents(rule.content)
+                    rule_descriptors = dict(
+                        preprocess_descriptors('font-face', url, content))
+                    for key in ('src', 'font_family'):
+                        if key not in rule_descriptors:
+                            LOGGER.warning(
+                                "Missing %s descriptor in '@font-face' rule at "
+                                "%d:%d", key.replace('_', '-'),
+                                rule.source_line, rule.source_column)
+                            break
+                    else:
+                        font_config.add_font_face(rule_descriptors, url_fetcher)
             # TODO: support media types
             # if rule.lower_at_keyword == 'media':
         elif rule.type == 'qualified-rule':
@@ -49,7 +65,7 @@ def parse_declarations(input):
     return normal_declarations, important_declarations
-def parse_stylesheets(tree, url):
+def parse_stylesheets(tree, url, font_config, url_fetcher):
     """Find stylesheets and return rule matchers in given tree."""
     normal_matcher = cssselect2.Matcher()
     important_matcher = cssselect2.Matcher()
@@ -70,7 +86,8 @@ def parse_stylesheets(tree, url):
     # Parse rules and fill matchers
     for stylesheet in stylesheets:
-        for rule in find_stylesheets_rules(tree, stylesheet, url):
+        for rule in find_stylesheets_rules(
+                tree, stylesheet, url, font_config, url_fetcher):
             normal_declarations, important_declarations = parse_declarations(
                 rule.content)
             try:

weasyprint/svg/defs.py CHANGED Viewed

@@ -102,10 +102,12 @@ def draw_gradient(svg, node, gradient, font_size, opacity, stroke):
         return False
     if gradient.get('gradientUnits') == 'userSpaceOnUse':
         width, height = svg.inner_width, svg.inner_height
+        bx1, by1 = bounding_box[:2]
         matrix = Matrix()
     else:
         width, height = 1, 1
         e, f, a, d = bounding_box
+        bx1, by1 = 0, 0
         matrix = Matrix(a=a, d=d, e=e, f=f)
     spread = gradient.get('spreadMethod', 'pad')
@@ -180,10 +182,10 @@ def draw_gradient(svg, node, gradient, font_size, opacity, stroke):
         if 0 not in (a0, a1) and (a0, a1) != (1, 1):
             color_couples[i][2] = a0 / a1
-    bx1, by1 = 0, 0
     if 'gradientTransform' in gradient.attrib:
+        bx2, by2 = bx1 + width, by1 + height
         bx1, by1 = transform_matrix.invert.transform_point(bx1, by1)
-        bx2, by2 = transform_matrix.invert.transform_point(width, height)
+        bx2, by2 = transform_matrix.invert.transform_point(bx2, by2)
         width, height = bx2 - bx1, by2 - by1
         # Ensure that width and height are positive to please some PDF readers
@@ -457,7 +459,7 @@ def draw_pattern(svg, node, pattern, font_size, opacity, stroke):
     group = stream_pattern.add_group(0, 0, pattern_width, pattern_height)
     Pattern(pattern, svg).draw(
         group, pattern_width, pattern_height, svg.base_url,
-        svg.url_fetcher, svg.context)
+        svg.context)
     stream_pattern.draw_x_object(group.id)
     svg.stream.set_color_space('Pattern', stroke=stroke)
     svg.stream.set_color_special(stream_pattern.id, stroke=stroke)
@@ -515,9 +517,3 @@ def paint_mask(svg, node, mask, font_size):
     svg.stream = svg.stream.set_alpha_state(x, y, width, height)
     svg.draw_node(mask, font_size)
     svg.stream = svg_stream
-def clip_path(svg, node, font_size):
-    """Store a clip path definition."""
-    if 'id' in node.attrib:
-        svg.paths[node.attrib['id']] = node

weasyprint/svg/text.py CHANGED Viewed

@@ -141,7 +141,7 @@ def text(svg, node, font_size):
             svg.cursor_d_position[1] = 0
         svg.cursor_d_position[0] += dx or 0
         svg.cursor_d_position[1] += dy or 0
-        layout, _, _, width, height, _ = split_first_line(
+        layout, _, _, width, height, baseline = split_first_line(
             letter, style, svg.context, inf, 0)
         x = svg.cursor_position[0] if x is None else x
         y = svg.cursor_position[1] if y is None else y
@@ -154,8 +154,9 @@ def text(svg, node, font_size):
         y_position = y + svg.cursor_d_position[1] + y_align
         angle = last_r if r is None else r
         points = (
-            (x_position, y_position),
-            (x_position + width, y_position - height))
+            (x_position, y_position - baseline),
+            (x_position + width, y_position - baseline + height))
+        # TODO: Use ink extents instead of logical from line_break.line_size().
         node.text_bounding_box = extend_bounding_box(
             node.text_bounding_box, points)

weasyprint/text/fonts.py CHANGED Viewed

@@ -167,9 +167,8 @@ class FontConfiguration:
             # Get font content.
             try:
-                with fetch(url_fetcher, url) as result:
-                    string = 'string' in result
-                    font = result['string'] if string else result['file_obj'].read()
+                with fetch(url_fetcher, url) as response:
+                    font = response.read()
             except Exception as exception:
                 LOGGER.debug('Failed to load font at %r (%s)', url, exception)
                 continue

weasyprint/text/line_break.py CHANGED Viewed

@@ -256,6 +256,8 @@ def split_first_line(text, style, context, max_width, justification_spacing,
     ``baseline``: baseline in pixels of the first line
     """
+    from ..layout.percent import percentage
     # See https://www.w3.org/TR/css-text-3/#white-space-property
     text_wrap = style['white_space'] in ('normal', 'pre-wrap', 'pre-line')
     space_collapse = style['white_space'] in ('normal', 'nowrap', 'pre-line')
@@ -392,11 +394,8 @@ def split_first_line(text, style, context, max_width, justification_spacing,
                     # This word is long enough.
                     first_line_width, _ = line_size(first_line, style)
                     space = max_width - first_line_width
-                    if style['hyphenate_limit_zone'].unit == '%':
-                        limit_zone = (
-                            max_width * style['hyphenate_limit_zone'].value / 100)
-                    else:
-                        limit_zone = style['hyphenate_limit_zone'].value
+                    limit_zone = percentage(
+                        style['hyphenate_limit_zone'], style, max_width)
                     if space > limit_zone or space < 0:
                         # Available space is worth the try, or the line is even too long
                         # to fit: try to hyphenate.

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

weasyprint 67.0py3-none-any.whl → 68.1py3-none-any.whl