xhtml2pdf 0.2.25__tar.gz → 0.2.26__tar.gz

{xhtml2pdf-0.2.25/xhtml2pdf.egg-info → xhtml2pdf-0.2.26}/PKG-INFO

@@ -1,218 +1,15 @@
 Metadata-Version: 2.4
 Name: xhtml2pdf
-Version: 0.2.25
+Version: 0.2.26
 Summary: PDF generator using HTML and CSS
 Author-email: Dirk Holtwick <dirk.holtwick@gmail.com>
 Maintainer-email: Luis Zarate <luisza14@gmail.com>, Timo Brembeck <opensource@timo.brembeck.email>
-License: 
-                                         Apache License
-                                   Version 2.0, January 2004
-                                http://www.apache.org/licenses/
-        
-           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-        
-           1. Definitions.
-        
-              "License" shall mean the terms and conditions for use, reproduction,
-              and distribution as defined by Sections 1 through 9 of this document.
-        
-              "Licensor" shall mean the copyright owner or entity authorized by
-              the copyright owner that is granting the License.
-        
-              "Legal Entity" shall mean the union of the acting entity and all
-              other entities that control, are controlled by, or are under common
-              control with that entity. For the purposes of this definition,
-              "control" means (i) the power, direct or indirect, to cause the
-              direction or management of such entity, whether by contract or
-              otherwise, or (ii) ownership of fifty percent (50%) or more of the
-              outstanding shares, or (iii) beneficial ownership of such entity.
-        
-              "You" (or "Your") shall mean an individual or Legal Entity
-              exercising permissions granted by this License.
-        
-              "Source" form shall mean the preferred form for making modifications,
-              including but not limited to software source code, documentation
-              source, and configuration files.
-        
-              "Object" form shall mean any form resulting from mechanical
-              transformation or translation of a Source form, including but
-              not limited to compiled object code, generated documentation,
-              and conversions to other media types.
-        
-              "Work" shall mean the work of authorship, whether in Source or
-              Object form, made available under the License, as indicated by a
-              copyright notice that is included in or attached to the work
-              (an example is provided in the Appendix below).
-        
-              "Derivative Works" shall mean any work, whether in Source or Object
-              form, that is based on (or derived from) the Work and for which the
-              editorial revisions, annotations, elaborations, or other modifications
-              represent, as a whole, an original work of authorship. For the purposes
-              of this License, Derivative Works shall not include works that remain
-              separable from, or merely link (or bind by name) to the interfaces of,
-              the Work and Derivative Works thereof.
-        
-              "Contribution" shall mean any work of authorship, including
-              the original version of the Work and any modifications or additions
-              to that Work or Derivative Works thereof, that is intentionally
-              submitted to Licensor for inclusion in the Work by the copyright owner
-              or by an individual or Legal Entity authorized to submit on behalf of
-              the copyright owner. For the purposes of this definition, "submitted"
-              means any form of electronic, verbal, or written communication sent
-              to the Licensor or its representatives, including but not limited to
-              communication on electronic mailing lists, source code control systems,
-              and issue tracking systems that are managed by, or on behalf of, the
-              Licensor for the purpose of discussing and improving the Work, but
-              excluding communication that is conspicuously marked or otherwise
-              designated in writing by the copyright owner as "Not a Contribution."
-        
-              "Contributor" shall mean Licensor and any individual or Legal Entity
-              on behalf of whom a Contribution has been received by Licensor and
-              subsequently incorporated within the Work.
-        
-           2. Grant of Copyright License. Subject to the terms and conditions of
-              this License, each Contributor hereby grants to You a perpetual,
-              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-              copyright license to reproduce, prepare Derivative Works of,
-              publicly display, publicly perform, sublicense, and distribute the
-              Work and such Derivative Works in Source or Object form.
-        
-           3. Grant of Patent License. Subject to the terms and conditions of
-              this License, each Contributor hereby grants to You a perpetual,
-              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-              (except as stated in this section) patent license to make, have made,
-              use, offer to sell, sell, import, and otherwise transfer the Work,
-              where such license applies only to those patent claims licensable
-              by such Contributor that are necessarily infringed by their
-              Contribution(s) alone or by combination of their Contribution(s)
-              with the Work to which such Contribution(s) was submitted. If You
-              institute patent litigation against any entity (including a
-              cross-claim or counterclaim in a lawsuit) alleging that the Work
-              or a Contribution incorporated within the Work constitutes direct
-              or contributory patent infringement, then any patent licenses
-              granted to You under this License for that Work shall terminate
-              as of the date such litigation is filed.
-        
-           4. Redistribution. You may reproduce and distribute copies of the
-              Work or Derivative Works thereof in any medium, with or without
-              modifications, and in Source or Object form, provided that You
-              meet the following conditions:
-        
-              (a) You must give any other recipients of the Work or
-                  Derivative Works a copy of this License; and
-        
-              (b) You must cause any modified files to carry prominent notices
-                  stating that You changed the files; and
-        
-              (c) You must retain, in the Source form of any Derivative Works
-                  that You distribute, all copyright, patent, trademark, and
-                  attribution notices from the Source form of the Work,
-                  excluding those notices that do not pertain to any part of
-                  the Derivative Works; and
-        
-              (d) If the Work includes a "NOTICE" text file as part of its
-                  distribution, then any Derivative Works that You distribute must
-                  include a readable copy of the attribution notices contained
-                  within such NOTICE file, excluding those notices that do not
-                  pertain to any part of the Derivative Works, in at least one
-                  of the following places: within a NOTICE text file distributed
-                  as part of the Derivative Works; within the Source form or
-                  documentation, if provided along with the Derivative Works; or,
-                  within a display generated by the Derivative Works, if and
-                  wherever such third-party notices normally appear. The contents
-                  of the NOTICE file are for informational purposes only and
-                  do not modify the License. You may add Your own attribution
-                  notices within Derivative Works that You distribute, alongside
-                  or as an addendum to the NOTICE text from the Work, provided
-                  that such additional attribution notices cannot be construed
-                  as modifying the License.
-        
-              You may add Your own copyright statement to Your modifications and
-              may provide additional or different license terms and conditions
-              for use, reproduction, or distribution of Your modifications, or
-              for any such Derivative Works as a whole, provided Your use,
-              reproduction, and distribution of the Work otherwise complies with
-              the conditions stated in this License.
-        
-           5. Submission of Contributions. Unless You explicitly state otherwise,
-              any Contribution intentionally submitted for inclusion in the Work
-              by You to the Licensor shall be under the terms and conditions of
-              this License, without any additional terms or conditions.
-              Notwithstanding the above, nothing herein shall supersede or modify
-              the terms of any separate license agreement you may have executed
-              with Licensor regarding such Contributions.
-        
-           6. Trademarks. This License does not grant permission to use the trade
-              names, trademarks, service marks, or product names of the Licensor,
-              except as required for reasonable and customary use in describing the
-              origin of the Work and reproducing the content of the NOTICE file.
-        
-           7. Disclaimer of Warranty. Unless required by applicable law or
-              agreed to in writing, Licensor provides the Work (and each
-              Contributor provides its Contributions) on an "AS IS" BASIS,
-              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-              implied, including, without limitation, any warranties or conditions
-              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-              PARTICULAR PURPOSE. You are solely responsible for determining the
-              appropriateness of using or redistributing the Work and assume any
-              risks associated with Your exercise of permissions under this License.
-        
-           8. Limitation of Liability. In no event and under no legal theory,
-              whether in tort (including negligence), contract, or otherwise,
-              unless required by applicable law (such as deliberate and grossly
-              negligent acts) or agreed to in writing, shall any Contributor be
-              liable to You for damages, including any direct, indirect, special,
-              incidental, or consequential damages of any character arising as a
-              result of this License or out of the use or inability to use the
-              Work (including but not limited to damages for loss of goodwill,
-              work stoppage, computer failure or malfunction, or any and all
-              other commercial damages or losses), even if such Contributor
-              has been advised of the possibility of such damages.
-        
-           9. Accepting Warranty or Additional Liability. While redistributing
-              the Work or Derivative Works thereof, You may choose to offer,
-              and charge a fee for, acceptance of support, warranty, indemnity,
-              or other liability obligations and/or rights consistent with this
-              License. However, in accepting such obligations, You may act only
-              on Your own behalf and on Your sole responsibility, not on behalf
-              of any other Contributor, and only if You agree to indemnify,
-              defend, and hold each Contributor harmless for any liability
-              incurred by, or claims asserted against, such Contributor by reason
-              of your accepting any such warranty or additional liability.
-        
-           END OF TERMS AND CONDITIONS
-        
-           APPENDIX: How to apply the Apache License to your work.
-        
-              To apply the Apache License to your work, attach the following
-              boilerplate notice, with the fields enclosed by brackets "[]"
-              replaced with your own identifying information. (Don't include
-              the brackets!)  The text should be enclosed in the appropriate
-              comment syntax for the file format. We also recommend that a
-              file or class name and description of purpose be included on the
-              same "printed page" as the copyright notice for easier
-              identification within third-party archives.
-        
-           Copyright [yyyy] [name of copyright owner]
-        
-           Licensed under the Apache License, Version 2.0 (the "License");
-           you may not use this file except in compliance with the License.
-           You may obtain a copy of the License at
-        
-               http://www.apache.org/licenses/LICENSE-2.0
-        
-           Unless required by applicable law or agreed to in writing, software
-           distributed under the License is distributed on an "AS IS" BASIS,
-           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-           See the License for the specific language governing permissions and
-           limitations under the License.
-        
+License-Expression: Apache-2.0
 Project-URL: Repository, https://github.com/xhtml2pdf/xhtml2pdf
 Project-URL: Bug tracker, https://github.com/xhtml2pdf/xhtml2pdf/issues
 Project-URL: Documentation, https://xhtml2pdf.readthedocs.io/
 Project-URL: Changelog, https://xhtml2pdf.readthedocs.io/en/latest/release-notes.html
 Keywords: PDF,HTML,HTML,XML,CSS
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Environment :: Other Environment
@@ -242,7 +39,6 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-License-File: AUTHORS.rst
 Requires-Dist: arabic-reshaper>=3.0.0
 Requires-Dist: html5lib>=1.1
 Requires-Dist: Pillow>=8.1.1

{xhtml2pdf-0.2.25 → xhtml2pdf-0.2.26}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools"]
+requires = ["setuptools>=77"]
 build-backend = "setuptools.build_meta"
 
 
@@ -15,9 +15,9 @@ maintainers = [
 description = "PDF generator using HTML and CSS"
 keywords = ["PDF", "HTML", "HTML", "XML", "CSS"]
 readme = "README.rst"
-license = {file = "LICENSE.txt"}
+license = "Apache-2.0"
+license-files = ["LICENSE.txt"]
 classifiers = [
-    "License :: OSI Approved :: Apache Software License",
     "Development Status :: 4 - Beta",
     "Environment :: Console",
     "Environment :: Other Environment",

{xhtml2pdf-0.2.25 → xhtml2pdf-0.2.26}/tests/test_page_numbering.py

@@ -8,6 +8,7 @@ number of pages in the document.
 """
 
 from io import BytesIO
+from typing import ClassVar
 from unittest import TestCase
 
 from pypdf import PdfReader
@@ -78,3 +79,35 @@ class PageCountInTheFlowTest(TestCase):
         texts = page_texts("<p>count <pdf:pagecount/></p>" + FILLER)
         self.assertGreater(len(texts), 1)
         self.assertIn(f"count {len(texts)}", texts[0])
+
+
+class PageFieldsInsideABoxTest(TestCase):
+    """A box or a cell lays its lines out before it draws what is in it."""
+
+    CONTAINERS: ClassVar[dict[str, str]] = {
+        "a bordered block": (
+            "<div style='border: 1pt solid red; padding: 4pt'><p>{}</p></div>"
+        ),
+        "a block with a width": "<div style='width: 50%'>{}</div>",
+        "a table cell": "<table><tr><td>{}</td></tr></table>",
+        "a flex item": "<div style='display: flex'><div>{}</div></div>",
+    }
+
+    def test_the_number_and_the_count_are_there(self) -> None:
+        for name, container in self.CONTAINERS.items():
+            with self.subTest(name):
+                texts = page_texts(
+                    container.format("page <pdf:pagenumber/> of <pdf:pagecount/>")
+                    + "<pdf:nextpage/>"
+                    + container.format("then <pdf:pagenumber/> of <pdf:pagecount/>")
+                )
+                self.assertIn("page 1 of 2", texts[0])
+                self.assertIn("then 2 of 2", texts[1])
+
+    def test_a_renumbered_page_in_a_box(self) -> None:
+        box = self.CONTAINERS["a bordered block"]
+        texts = page_texts(
+            "<p>cover</p><pdf:nextpage/><pdf:resetpagenumber value='1'/>"
+            + box.format("numbered <pdf:pagenumber/>")
+        )
+        self.assertIn("numbered 1", texts[1])

{xhtml2pdf-0.2.25 → xhtml2pdf-0.2.26}/tests/test_tags.py

@@ -1,6 +1,7 @@
 import base64
 import hashlib
 import io
+import logging
 import re
 from pathlib import Path
 from typing import NamedTuple
@@ -13,6 +14,7 @@ from pypdf.generic import ArrayObject
 from reportlab.pdfbase.pdfmetrics import stringWidth
 
 from xhtml2pdf import pisa, tags
+from xhtml2pdf.charts import HorizontalLine
 from xhtml2pdf.context import pisaContext
 from xhtml2pdf.document import pisaStory
 from xhtml2pdf.parser import AttrContainer, pisaGetAttributes
@@ -144,7 +146,7 @@ class BadInputKeepsTheDocumentTestCase(TestCase):
         with self.assertNoLogs("xhtml2pdf", level="WARNING"):
             result = self.convert(
                 '<canvas type="graph" width="200" height="100">'
-                '{"type": "pie", "data": [[1, 2]], "labels": ["a", "b"]}</canvas>'
+                '{"type": "pie", "data": [1, 2], "labels": ["a", "b"]}</canvas>'
             )
         self.assertEqual(0, result.err)
 
@@ -386,6 +388,91 @@ class ChartParametersTestCase(TestCase):
         self.assertEqual(["a", "1", "b", "2", "c", "3"], labels[:6])
 
 
+class ChartWarningsTestCase(TestCase):
+    """A chart property that does nothing says so."""
+
+    @staticmethod
+    def render(chart: str) -> None:
+        pisa.pisaDocument(
+            io.StringIO(
+                f'<html><body><canvas type="graph" width="300" height="150">{chart}'
+                "</canvas></body></html>"
+            ),
+            io.BytesIO(),
+        )
+
+    def json_warnings(self, chart: str) -> list[str]:
+        """What is said about the chart's JSON, and only that."""
+        found: list[str] = []
+        handler = logging.Handler(logging.WARNING)
+        handler.emit = lambda record: found.append(record.getMessage())
+        logger = logging.getLogger("xhtml2pdf")
+        level = logger.level
+        logger.addHandler(handler)
+        logger.setLevel(logging.WARNING)
+        try:
+            self.render(chart)
+        finally:
+            logger.removeHandler(handler)
+            logger.setLevel(level)
+        return [line for line in found if "in the JSON of" in line]
+
+    def warnings(self, chart: str) -> list[str]:
+        found = self.json_warnings(chart)
+        self.assertTrue(found)
+        return found
+
+    def test_a_key_the_chart_does_not_read(self) -> None:
+        (line,) = self.warnings(
+            '{"type": "verticalbar", "data": [[1, 2]], "labels": ["a", "b"],'
+            ' "barThickness": 5, "legend": {"x": 1, "colour": "red"}}'
+        )
+        self.assertIn("'barThickness'", line)
+        self.assertIn("'legend.colour'", line)
+
+    def test_a_value_the_property_does_not_take(self) -> None:
+        (line,) = self.warnings(
+            '{"type": "verticalbar", "data": [[1, 2]], "labels": ["a", "b"],'
+            ' "barWidth": "wide"}'
+        )
+        self.assertIn("'barWidth'", line)
+        self.assertIn("'wide'", line)
+
+    def test_a_line_chart_takes_its_category_axis(self) -> None:
+        chart = HorizontalLine()
+        chart.set_properties(
+            {
+                "data": [[1, 2, 3]],
+                "labels": ["a", "b", "c"],
+                "categoryAxis": {"strokeColor": "red", "labels": {"angle": 30}},
+            }
+        )
+        self.assertEqual(30, chart.categoryAxis.labels.angle)
+        self.assertEqual(
+            [],
+            self.json_warnings(
+                '{"type": "horizontalline", "data": [[1, 2, 3]],'
+                ' "labels": ["a", "b", "c"], "categoryAxis": {"labels": {"angle": 30}}}'
+            ),
+        )
+
+    def test_a_chart_that_uses_every_key_says_nothing(self) -> None:
+        for chart in (
+            (
+                '{"type": "verticalbar", "data": [[1, 2]], "labels": ["a", "b"],'
+                ' "barWidth": 5, "valueAxis": {"valueMin": 0},'
+                ' "categoryAxis": {"labels": {"angle": 30}}}'
+            ),
+            (
+                '{"type": "pie", "data": [3, 1], "labels": ["x", "y"],'
+                ' "title": {"_text": "T", "x": 10, "y": 10},'
+                ' "legend": {"x": 10, "y": 10}, "slices": {"strokeColor": "white"}}'
+            ),
+        ):
+            with self.subTest(chart):
+                self.assertEqual([], self.json_warnings(chart))
+
+
 class SelfClosingTocTestCase(TestCase):
     """
     <pdf:toc /> puts the table of contents where it is written.
@@ -579,6 +666,13 @@ class CanvasPlacementTestCase(TestCase):
         self.assertAlmostEqual(plain["a"][0] + 31, padded["a"][0], places=1)
         self.assertAlmostEqual(plain["a"][1] - 31, padded["a"][1], places=1)
 
+    def test_the_text_around_it_in_its_block_is_kept(self) -> None:
+        with self.assertNoLogs("xhtml2pdf", level="WARNING"):
+            found = self.runs(f"<div>lead {self.CHART} tail</div>")
+        # y grows up the page: the lead above the chart, the tail below it.
+        self.assertGreater(found["lead"][1], found["a"][1])
+        self.assertGreater(found["a"][1], found["tail"][1])
+
     def test_text_align_center_centres_it(self) -> None:
         plain = self.runs(self.CHART)
         centred = self.runs(f"<div style='text-align: center'>{self.CHART}</div>")

{xhtml2pdf-0.2.25 → xhtml2pdf-0.2.26}/xhtml2pdf/__init__.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.2.25"
+__version__ = "0.2.26"

{xhtml2pdf-0.2.25 → xhtml2pdf-0.2.26}/xhtml2pdf/builders/block.py

@@ -35,7 +35,12 @@ from xhtml2pdf.builders.flex import (
 )
 from xhtml2pdf.builders.position import PositionAnchor
 from xhtml2pdf.util import drawBoxBackground, drawBoxBorders, getSize, toList
-from xhtml2pdf.xhtml2pdf_reportlab import PmlKeepInFrame, PmlMaxHeightMixIn, opened_up
+from xhtml2pdf.xhtml2pdf_reportlab import (
+    PmlKeepInFrame,
+    PmlMaxHeightMixIn,
+    layout_moment,
+    opened_up,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -162,7 +167,7 @@ class BlockBox(Flowable, PmlMaxHeightMixIn):
         #: next page whole when it does not fit, if a page can hold it.
         self.keep_together = keep_together
         self.keepWithNext = False
-        self._key: float | None = None
+        self._key: tuple[float, int, int] | None = None
         self._entries: list[StackEntry] = []
         self._inner = 0.0
         self._stacked = 0.0
@@ -196,7 +201,7 @@ class BlockBox(Flowable, PmlMaxHeightMixIn):
     def wrap(self, availWidth: float, availHeight: float) -> tuple[float, float]:
         availHeight = self.setMaxHeight(availHeight)
         style = self.style
-        key = round(availWidth, 2)
+        key = (round(availWidth, 2), *layout_moment(getattr(self, "canv", None)))
         if self._key != key:
             # Laid out once per width and never at a trial one: a table
             # turns its percentage columns into points as it is wrapped.

{xhtml2pdf-0.2.25 → xhtml2pdf-0.2.26}/xhtml2pdf/builders/flex.py

@@ -60,6 +60,7 @@ from xhtml2pdf.xhtml2pdf_reportlab import (
     PmlKeepInFrame,
     PmlMaxHeightMixIn,
     PmlParagraph,
+    layout_moment,
 )
 
 if TYPE_CHECKING:
@@ -680,7 +681,7 @@ class FlexContainer(Flowable, PmlMaxHeightMixIn):
         self.layout = FlexLayout()
         #: Per item, the stacked content at the width it was last measured.
         self._stacks: dict[int, tuple[float, list[StackEntry], float]] = {}
-        self._cache_key: tuple[float, float] | None = None
+        self._cache_key: tuple[float, float, int, int] | None = None
         self._box: ABag | None = None
 
     # ~ Platypus protocol ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -851,7 +852,11 @@ class FlexContainer(Flowable, PmlMaxHeightMixIn):
 
     def wrap(self, availWidth: float, availHeight: float) -> tuple[float, float]:
         availHeight = self.setMaxHeight(availHeight)
-        key = (round(availWidth, 2), round(availHeight, 2))
+        key = (
+            round(availWidth, 2),
+            round(availHeight, 2),
+            *layout_moment(getattr(self, "canv", None)),
+        )
         if self._cache_key == key and self._box is not None:
             return self.width, self.height
         canv = getattr(self, "canv", None)
@@ -1539,13 +1544,13 @@ class InlineBox(Flowable):
         self._box_width = 0.0
         self._box_height = 0.0
         self.last_baseline: float | None = None
-        self._cache_key: float | None = None
+        self._cache_key: tuple[float, int, int] | None = None
 
     def identity(self, maxLen=None) -> str:
         return f"<InlineBox with {len(self.content)} flowables>"
 
     def wrap(self, availWidth: float, availHeight: float) -> tuple[float, float]:
-        key = round(availWidth, 2)
+        key = (round(availWidth, 2), *layout_moment(getattr(self, "canv", None)))
         if self._cache_key == key:
             return self.width, self.height
         canv = getattr(self, "canv", None)