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

weasyprint/layout/grid.py

@@ -1123,6 +1123,7 @@ def grid_layout(context, box, bottom_space, skip_stack, containing_block,
     # Find resume_at row.
     this_page_children = []
     resume_row = None
+    extra_skip_height = 0
     if skip_stack:
         from .block import block_level_layout
         first_skip_row = min(skip_stack)
@@ -1130,7 +1131,6 @@ def grid_layout(context, box, bottom_space, skip_stack, containing_block,
         skip_height = (
             sum(size for size, _ in rows_sizes[:last_skip_row]) +
             (len(rows_sizes[:last_skip_row]) - 1) * row_gap)
-        extra_skip_height = 0
         for child, (x, y, width, height) in children_positions.items():
             if (advancement := box.advancements.get((x, y))) is None:
                 continue
@@ -1271,13 +1271,16 @@ def grid_layout(context, box, bottom_space, skip_stack, containing_block,
         if child.margin_left == 'auto':
             child.margin_left = 0
 
-        child_width = width - (
-            child.margin_left + child.border_left_width + child.padding_left +
-            child.margin_right + child.border_right_width + child.padding_right)
-        child_height = height - (
-            child.margin_bottom + child.border_bottom_width + child.padding_bottom)
+        child_border_width = width - (child.margin_left + child.margin_right)
+        child_content_width = child_border_width - (
+                child.border_left_width + child.padding_left +
+                child.border_right_width + child.padding_right)
+        child_border_height = height - child.margin_bottom
+        child_content_height = child_border_height - (
+            child.border_bottom_width + child.padding_bottom)
         if not child_skip_stack or child.style['box_decoration_break'] == 'clone':
-            child_height -= (
+            child_border_height -= child.margin_top
+            child_content_height -= (
                 child.margin_top + child.border_top_width + child.padding_top)
 
         justify_self = set(child.style['justify_self'])
@@ -1286,6 +1289,9 @@ def grid_layout(context, box, bottom_space, skip_stack, containing_block,
         if justify_self & {'normal', 'stretch'}:
             if child.style['width'] == 'auto':
                 child.style = child.style.copy()
+                child_width = (
+                    child_content_width if child.style['box_sizing'] == 'content-box'
+                    else child_border_width)
                 child.style['width'] = Dimension(child_width, 'px')
         align_self = set(child.style['align_self'])
         if align_self & {'auto'}:
@@ -1293,6 +1299,9 @@ def grid_layout(context, box, bottom_space, skip_stack, containing_block,
         if align_self & {'normal', 'stretch'}:
             if child.style['height'] == 'auto':
                 child.style = child.style.copy()
+                child_height = (
+                    child_content_height if child.style['box_sizing'] == 'content-box'
+                    else child_border_height)
                 child.style['height'] = Dimension(child_height, 'px')
 
         # TODO: Find a better solution for the layout.
@@ -1338,11 +1347,11 @@ def grid_layout(context, box, bottom_space, skip_stack, containing_block,
             continue
 
         if justify_self & {'normal', 'stretch'}:
-            new_child.width = max(child_width, new_child.width)
+            new_child.width = max(child_content_width, new_child.width)
         else:
             if new_child.style['width'] == 'auto':
                 new_child.width = max_content_width(context, new_child, outer=False)
-            diff = child_width - new_child.width
+            diff = child_content_width - new_child.width
             if justify_self & {'center'}:
                 new_child.translate(diff / 2, 0)
             elif justify_self & {'right', 'end', 'flex-end', 'self-end'}:
@@ -1350,9 +1359,9 @@ def grid_layout(context, box, bottom_space, skip_stack, containing_block,
 
         # TODO: Apply auto margins.
         if align_self & {'normal', 'stretch'}:
-            new_child.height = max(child_height, new_child.height)
+            new_child.height = max(child_content_height, new_child.height)
         else:
-            diff = child_height - new_child.height
+            diff = child_content_height - new_child.height
             if align_self & {'center'}:
                 new_child.translate(0, diff / 2)
             elif align_self & {'end', 'flex-end', 'self-end'}:
@@ -1368,8 +1377,9 @@ def grid_layout(context, box, bottom_space, skip_stack, containing_block,
         context.finish_block_formatting_context(box)
         return None, None, {'break': 'any', 'page': None}, [], False
 
-    old_advancements = box.advancements or {}
-    advancements = box.advancements = {}
+    old_advancements = box.advancements.copy()
+    advancements = box.advancements
+    advancements.clear()
     box = box.copy_with_children(new_children)
     if isinstance(box, boxes.InlineGridBox):
         # TODO: Synthetize a real baseline value.
@@ -1420,7 +1430,8 @@ def grid_layout(context, box, bottom_space, skip_stack, containing_block,
             else:
                 # Child fully drawn, save the extra height added to reach the bottom of
                 # the page to substract it from the advancements.
-                extra_advancement = max(extra_advancement, child.height - child_height)
+                extra_advancement = max(
+                    extra_advancement, child.height - child_content_height)
 
     # Substract the extra height added to reach the bottom of the page from all the
     # advancements.

weasyprint/layout/page.py

@@ -389,7 +389,7 @@ def make_margin_boxes(context, page, state):
         if box.is_generated:
             # @margins mustn't manipulate page-context counters
             margin_state = copy.deepcopy(state)
-            quote_depth, counter_values, counter_scopes = margin_state
+            quote_depth, counter_values, counter_scopes, _page_groups = margin_state
             # TODO: check this, probably useless
             counter_scopes.append(set())
             build.update_counters(margin_state, box.style)
@@ -901,7 +901,7 @@ def _update_page_groups(page_groups, resume_at, next_page, root_box, blank):
             return next_page['page']
 
 
-def remake_page(index, page_groups, context, root_box, html):
+def remake_page(index, context, root_box, html):
     """Return one laid out page without margin boxes.
 
     Start with the initial values from ``context.page_maker[index]``.
@@ -932,6 +932,7 @@ def remake_page(index, page_groups, context, root_box, html):
         (next_page_side == 'right' and not right_page) or
         (context.reported_footnotes and resume_at is None))
     side = 'right' if right_page else 'left'
+    page_groups = page_state[3]
     name = _update_page_groups(page_groups, resume_at, next_page, root_box, blank)
     groups = tuple((name, index) for name, index, _ in page_groups)
     page_type = PageType(side, blank, name, index, groups)
@@ -990,7 +991,6 @@ def make_all_pages(context, root_box, html, pages):
     """
     i = 0
     reported_footnotes = None
-    page_groups = []
     while True:
         remake_state = context.page_maker[i][-1]
         if (len(pages) == 0 or
@@ -1002,7 +1002,7 @@ def make_all_pages(context, root_box, html, pages):
             remake_state['pages_wanted'] = False
             remake_state['anchors'] = []
             remake_state['content_lookups'] = []
-            page, resume_at = remake_page(i, page_groups, context, root_box, html)
+            page, resume_at = remake_page(i, context, root_box, html)
             reported_footnotes = context.reported_footnotes
             yield page
         else:

weasyprint/layout/preferred.py

@@ -101,9 +101,32 @@ def _block_content_width(context, box, function, outer):
             function(context, child, outer=True) for child in box.children
             if not child.is_absolutely_positioned()]
         width = max(children_widths) if children_widths else 0
+    elif box.style['box_sizing'] == 'content-box':
+        width = width.value
     else:
-        assert width.unit.lower() == 'px'
         width = width.value
+        percentages = 0
+
+        for value in ('padding_left', 'padding_right'):
+            style_value = box.style[value]
+            if style_value != 'auto':
+                if style_value.unit.lower() == 'px':
+                    width -= style_value.value
+                else:
+                    assert style_value.unit == '%'
+                    percentages += style_value.value
+
+        # Same as margin_width().
+        collapse = box.style['border_collapse'] == 'collapse'
+        if collapse and hasattr(box, 'border_left_width'):
+            width -= box.border_left_width
+        else:
+            width -= box.style['border_left_width']
+        if collapse and hasattr(box, 'border_right_width'):
+            width -= box.border_right_width
+        else:
+            width -= box.style['border_right_width']
+        width = (100 - min(100, percentages)) * max(0, width) / 100
 
     return adjust(box, outer, width)
 
@@ -362,7 +385,17 @@ def inline_line_widths(context, box, outer, is_line_start, minimum, skip_stack=N
             # "By default, there is a break opportunity
             #  both before and after any inline object."
             if minimum:
-                lines = [None, min_content_width(context, child), None]
+                # "For soft wrap opportunities defined by the boundary between two
+                # characters or atomic inlines, the white-space property on the nearest
+                # common ancestor of the two characters controls breaking; which
+                # elements’ line-break, word-break, and overflow-wrap properties control
+                # the determination of soft wrap opportunities at such boundaries is
+                # undefined in this level." We choose to always follow the parent’s
+                # value here, other parts of the line-breaking algorithm do the same.
+                if box.style['white_space'] in ('normal', 'pre-wrap', 'pre-line'):
+                    lines = [None, min_content_width(context, child), None]
+                else:
+                    lines = [min_content_width(context, child)]
             else:
                 lines = [max_content_width(context, child)]
         # The first text line goes on the current line.

weasyprint/pdf/__init__.py

@@ -9,6 +9,7 @@ from .. import VERSION, Attachment
 from ..html import W3C_DATE_RE
 from ..logger import LOGGER, PROGRESS_LOGGER
 from ..matrix import Matrix
+from ..urls import select_source
 from . import debug, pdfa, pdfua, pdfx
 from .fonts import build_fonts_dictionary
 from .stream import Stream
@@ -273,14 +274,24 @@ def generate_pdf(document, target, zoom, **options):
             key = key.encode('ascii', errors='ignore').decode()
             if key:
                 pdf.info[key] = pydyf.String(value)
+    if options['xmp_metadata']:
+        for url in options['xmp_metadata']:
+            result = select_source(url)
+            with result as (file_obj, base_url, charset, _):
+                xmp_metadata = file_obj.read()
+                if charset:
+                    xmp_metadata = xmp_metadata.decode(charset).encode()
+                metadata.xmp_metadata.append(xmp_metadata)
 
     # Embedded files
     attachments = metadata.attachments.copy()
     if options['attachments']:
+        relationships = iter(options['attachment_relationships'] or [])
         for attachment in options['attachments']:
             if not isinstance(attachment, Attachment):
                 attachment = Attachment(
-                    attachment, url_fetcher=document.url_fetcher)
+                    attachment, url_fetcher=document.url_fetcher,
+                    relationship=next(relationships, 'Unspecified'))
             attachments.append(attachment)
     pdf_attachments = []
     for attachment in attachments:

weasyprint/pdf/anchors.py

@@ -1,7 +1,6 @@
 """Insert anchors, links, bookmarks and inputs in PDFs."""
 
 import collections
-import io
 import mimetypes
 from hashlib import md5
 from os.path import basename
@@ -330,18 +329,12 @@ def write_pdf_attachment(pdf, attachment, compress):
     """Write an attachment to the PDF stream."""
     # Attachments from document links like <link> or <a> can only be URLs.
     # They're passed in as tuples
-    url = None
-    uncompressed_length = 0
-    stream = b''
+    url = mime_type = None
     try:
-        with attachment.source as (_, source, url, _):
-            if isinstance(source, str):
-                source = source.encode()
-            if isinstance(source, bytes):
-                source = io.BytesIO(source)
-            for data in iter(lambda: source.read(4096), b''):
-                uncompressed_length += len(data)
-                stream += data
+        with attachment.source as (file_obj, url, _, mime_type):
+            stream = file_obj.read()
+            if isinstance(stream, str):
+                stream = stream.encode()
     except URLFetchingError as exception:
         LOGGER.error('Failed to load attachment: %s', exception)
         LOGGER.debug('Error while loading attachment:', exc_info=exception)
@@ -356,9 +349,10 @@ def write_pdf_attachment(pdf, attachment, compress):
         filename = basename(unquote(urlsplit(url).path))
     else:
         filename = 'attachment.bin'
-    mime_type = mimetypes.guess_type(filename, strict=False)[0]
-    if not mime_type:
-        mime_type = 'application/octet-stream'
+    mime_type = (
+        mime_type or
+        mimetypes.guess_type(filename, strict=False)[0] or
+        'application/octet-stream')
 
     creation = pydyf.String(attachment.created.strftime('D:%Y%m%d%H%M%SZ'))
     mod = pydyf.String(attachment.modified.strftime('D:%Y%m%d%H%M%SZ'))
@@ -367,7 +361,7 @@ def write_pdf_attachment(pdf, attachment, compress):
         'Subtype': f'/{mime_type.replace("/", "#2f")}',
         'Params': pydyf.Dictionary({
             'CheckSum': f'<{attachment.md5}>',
-            'Size': uncompressed_length,
+            'Size': len(stream),
             'CreationDate': creation,
             'ModDate': mod,
         })

weasyprint/pdf/fonts.py

@@ -618,14 +618,23 @@ def _build_vector_font_dictionary(font_dictionary, pdf, font, widths, compress,
     if font.missing:
         # Add CMap that doesn’t include missing glyphs, so that they can be replaced by
         # .notdef.
+        cmap_extra = pydyf.Dictionary({
+            'Type': '/CMap',
+            'CMapName': '/WP-Encod-0',
+            'CIDSystemInfo': pydyf.Dictionary({
+                'Registry': pydyf.String('Adobe'),
+                'Ordering': pydyf.String('Identity'),
+                'Supplement': 0,
+            }),
+        })
         encoding = pydyf.Stream([
             b'/CIDInit /ProcSet findresource begin',
             b'12 dict begin',
             b'begincmap',
             b'/CIDSystemInfo',
             b'3 dict dup begin',
-            b'/Registry (WP) def',
-            b'/Ordering (Encod) def',
+            b'/Registry (Adobe) def',
+            b'/Ordering (Identity) def',
             b'/Supplement 0 def',
             b'end def',
             b'/CMapName /WP-Encod-0 def',
@@ -633,7 +642,7 @@ def _build_vector_font_dictionary(font_dictionary, pdf, font, widths, compress,
             b'1 begincodespacerange',
             b'<0000> <ffff>',
             b'endcodespacerange',
-        ], compress=compress)
+        ], cmap_extra, compress=compress)
         available = tuple(font.to_unicode)
         available_length = len(available)
         for i in range(ceil(available_length / 100)):

weasyprint/pdf/metadata.py

@@ -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

@@ -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

@@ -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

@@ -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 = {