svg-ultralight 0.26.0__tar.gz → 0.28.0__tar.gz

svg_ultralight-0.28.0/.gitignore

@@ -0,0 +1,3 @@
+Update-PythonVenv.ps1
+requirements.txt
+dev_requirements.txt

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: svg-ultralight
-Version: 0.26.0
+Version: 0.28.0
 Summary: a sensible way to create svg files with Python
 Author-email: Shay Hill <shay_public@hotmail.com>
 License: MIT

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "svg-ultralight"
-version = "0.26.0"
+version = "0.28.0"
 description = "a sensible way to create svg files with Python"
 authors = [{ name = "Shay Hill", email = "shay_public@hotmail.com" }]
 license = { text = "MIT" }
@@ -20,6 +20,10 @@ build-backend = "setuptools.build_meta"
 addopts = "--doctest-modules"
 
 
+[tool.isort]
+profile = "black"
+
+
 [tool.tox]
 legacy_tox_ini = """
     [tox]
@@ -33,7 +37,7 @@ legacy_tox_ini = """
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.26.0"
+version = "0.28.0"
 tag_format = "$version"
 version_files = ["pyproject.toml:^version"]
 annotated_tag = true

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/src/svg_ultralight/__init__.py

@@ -4,6 +4,11 @@
 :created: 12/22/2019.
 """
 
+from svg_ultralight.bounding_boxes.bound_helpers import (
+    new_bbox_union,
+    new_bound_union,
+    new_element_union,
+)
 from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
 from svg_ultralight.bounding_boxes.type_bound_element import BoundElement
 from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
@@ -27,6 +32,7 @@ from svg_ultralight.nsmap import NSMAP, new_qname
 from svg_ultralight.query import pad_text
 from svg_ultralight.root_elements import new_svg_root_around_bounds
 from svg_ultralight.string_conversion import (
+    format_attr_dict,
     format_number,
     format_numbers,
     format_numbers_in_string,
@@ -39,10 +45,14 @@ __all__ = [
     "PaddedText",
     "SupportsBounds",
     "deepcopy_element",
+    "format_attr_dict",
     "format_number",
     "format_numbers",
     "format_numbers_in_string",
+    "new_bbox_union",
+    "new_bound_union",
     "new_element",
+    "new_element_union",
     "new_metadata",
     "new_qname",
     "new_sub_element",

svg_ultralight-0.28.0/src/svg_ultralight/bounding_boxes/bound_helpers.py

@@ -0,0 +1,95 @@
+"""Helper functions for dealing with BoundElements.
+
+:author: Shay Hill
+:created: 2024-05-03
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from lxml.etree import _Element as EtreeElement  # type: ignore
+
+from svg_ultralight.bounding_boxes.type_bound_element import BoundElement
+from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
+from svg_ultralight.bounding_boxes.type_padded_text import PaddedText
+from svg_ultralight.constructors import new_element
+
+if TYPE_CHECKING:
+    from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
+
+
+def new_element_union(
+    *elems: EtreeElement | SupportsBounds, **attributes: float | str
+) -> EtreeElement:
+    """Get the union of any elements found in the given arguments.
+
+    :param elems: BoundElements, PaddedTexts, or EtreeElements.
+        Other arguments will be ignored.
+    :return: a new group element containing all elements.
+
+    This does not support consolidating attributes. E.g., if all elements have the
+    same fill color, this will not be recognized and consilidated into a single
+    attribute for the group. Too many attributes change their behavior when applied
+    to a group.
+    """
+    elements_found: list[EtreeElement] = []
+    for elem in elems:
+        if isinstance(elem, (BoundElement, PaddedText)):
+            elements_found.append(elem.elem)
+        elif isinstance(elem, EtreeElement):
+            elements_found.append(elem)
+
+    if not elements_found:
+        msg = (
+            "Cannot find any elements to union. "
+            + "At least one argument must be a "
+            + "BoundElement, PaddedText, or EtreeElement."
+        )
+        raise ValueError(msg)
+    group = new_element("g", **attributes)
+    group.extend(elements_found)
+    return group
+
+
+def new_bbox_union(*blems: SupportsBounds | EtreeElement) -> BoundingBox:
+    """Get the union of the bounding boxes of the given elements.
+
+    :param blems: BoundElements, BoundingBoxes, or PaddedTexts.
+        Other arguments will be ignored.
+    :return: the union of all bounding boxes as a BoundingBox instance.
+
+    Will used the padded_box attribute of PaddedText instances.
+    """
+    bboxes: list[BoundingBox] = []
+    for blem in blems:
+        if isinstance(blem, BoundingBox):
+            bboxes.append(blem)
+        elif isinstance(blem, BoundElement):
+            bboxes.append(blem.bbox)
+        elif isinstance(blem, PaddedText):
+            bboxes.append(blem.padded_bbox)
+
+    if not bboxes:
+        msg = (
+            "Cannot find any bounding boxes to union. "
+            + "At least one argument must be a "
+            + "BoundElement, BoundingBox, or PaddedText."
+        )
+        raise ValueError(msg)
+
+    return BoundingBox.merged(*bboxes)
+
+
+def new_bound_union(*blems: SupportsBounds | EtreeElement) -> BoundElement:
+    """Get the union of the bounding boxes of the given elements.
+
+    :param blems: BoundElements or EtreeElements.
+        At least one argument must be a BoundElement, BoundingBox, or PaddedText.
+    :return: the union of all arguments as a BoundElement instance.
+
+    Will used the padded_box attribute of PaddedText instances.
+    """
+    group = new_element_union(*blems)
+    bbox = new_bbox_union(*blems)
+    return BoundElement(group, bbox)

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/src/svg_ultralight/bounding_boxes/type_bounding_box.py

@@ -6,13 +6,51 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+import dataclasses
 
 from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
 from svg_ultralight.string_conversion import format_number
 
+Matrix = tuple[float, float, float, float, float, float]
 
-@dataclass
+
+def mat_dot(mat1: Matrix, mat2: Matrix) -> Matrix:
+    """Matrix multiplication for svg-style matrices.
+
+    :param mat1: transformation matrix (sx, 0, 0, sy, tx, ty)
+    :param mat2: transformation matrix (sx, 0, 0, sy, tx, ty)
+
+    Svg uses an unusual matrix format. For 3x3 transformation matrix
+
+    [[00, 01, 02],
+     [10, 11, 12],
+     [20, 21, 22]]
+
+    The svg matrix is
+    (00, 10, 01, 11, 02, 12)
+
+    Values 10 and 01 are only used for skewing, which is not supported by a bounding
+    box, but they're here if this function is used in other ways.
+    """
+    aa = sum(mat1[x] * mat2[y] for x, y in ((0, 0), (2, 1)))
+    bb = sum(mat1[x] * mat2[y] for x, y in ((1, 0), (3, 1)))
+    cc = sum(mat1[x] * mat2[y] for x, y in ((0, 2), (2, 3)))
+    dd = sum(mat1[x] * mat2[y] for x, y in ((1, 2), (3, 3)))
+    ee = sum(mat1[x] * mat2[y] for x, y in ((0, 4), (2, 5))) + mat1[4]
+    ff = sum(mat1[x] * mat2[y] for x, y in ((1, 4), (3, 5))) + mat1[5]
+    return (aa, bb, cc, dd, ee, ff)
+
+
+def mat_apply(mat1: Matrix, mat2: tuple[float, float]) -> tuple[float, float]:
+    """Apply an svg-style transformation matrix to a point.
+
+    :param mat1: transformation matrix (sx, 0, 0, sy, tx, ty)
+    :param mat2: point (x, y)
+    """
+    return mat1[0] * mat2[0] + mat1[4], mat1[3] * mat2[1] + mat1[5]
+
+
+@dataclasses.dataclass
 class BoundingBox(SupportsBounds):
     """Mutable bounding box object for svg_ultralight.
 
@@ -21,14 +59,12 @@ class BoundingBox(SupportsBounds):
     :param width: width of the bounding box
     :param height: height of the bounding box
 
-    The below optional parameters, in addition to the required parameters, capture
-    the entire state of a BoundingBox instance.  They could be used to make a copy or
+    The below optional parameter, in addition to the required parameters, captures
+    the entire state of a BoundingBox instance. It could be used to make a copy or
     to initialize a transformed box with the same transform_string as another box.
-    Under most circumstances, they will not be used.
+    Under most circumstances, it will not be used.
 
-    :param scale: scale of the bounding box
-    :param translation_x: x translation of the bounding box
-    :param translation_y: y translation of the bounding box
+    :param _transform: transformation matrix
 
     Functions that return a bounding box will return a BoundingBox instance. This
     instance can be transformed (uniform scale and translate only). Transformations
@@ -37,8 +73,8 @@ class BoundingBox(SupportsBounds):
     Define the bbox with x=, y=, width=, height=
 
     Transform the BoundingBox by setting these variables. Each time you set x, cx,
-    x2, y, cy, y2, width, or height, private transformation values (_scale,
-    _transform_x, and _transform_y) will be updated.
+    x2, y, cy, y2, width, or height, private transformation value _transform will be
+    updated.
 
     The ultimate transformation can be accessed through ``.transformation_string``.
     So the workflow will look like :
@@ -78,13 +114,19 @@ class BoundingBox(SupportsBounds):
     _y: float
     _width: float
     _height: float
-    _scale: float = 1.0
-    _translation_x: float = 0.0
-    _translation_y: float = 0.0
+    _transform: Matrix = (1, 0, 0, 1, 0, 0)
+
+    @property
+    def transform(self) -> Matrix:
+        """Get read only tranformation matrix.
+
+        :return: transformation matrix of the bounding box
+        """
+        return self._transform
 
     @property
     def scale(self) -> float:
-        """Read-only scale.
+        """Get scale of the bounding box.
 
         :return: uniform scale of the bounding box
 
@@ -95,7 +137,7 @@ class BoundingBox(SupportsBounds):
         width*scale, height => height*scale, scale => scale*scale. This matches how
         scale works in almost every other context.
         """
-        return self._scale
+        return self._transform[0]
 
     @scale.setter
     def scale(self, value: float) -> None:
@@ -110,7 +152,7 @@ class BoundingBox(SupportsBounds):
         `scale = 2` -> ignore whatever scale was previously defined and set scale to 2
         `scale *= 2` -> make it twice as big as it was.
         """
-        self._scale = value
+        self._add_transform(value / self.scale, 0, 0)
 
     @property
     def x(self) -> float:
@@ -118,7 +160,7 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _x value transformed by scale and translation
         """
-        return (self._translation_x + self._x) * self._scale
+        return mat_apply(self._transform, (self._x, 0))[0]
 
     @x.setter
     def x(self, value: float) -> None:
@@ -142,7 +184,7 @@ class BoundingBox(SupportsBounds):
 
         :param value: new center x value after transformation
         """
-        self._add_transform(1, value - self.cx, 0)
+        self.x += value - self.cx
 
     @property
     def x2(self) -> float:
@@ -158,7 +200,7 @@ class BoundingBox(SupportsBounds):
 
         :param value: new x2 value after transformation
         """
-        self._add_transform(1, value - self.x2, 0)
+        self.x += value - self.x2
 
     @property
     def y(self) -> float:
@@ -166,7 +208,7 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _y value transformed by scale and translation
         """
-        return (self._translation_y + self._y) * self._scale
+        return mat_apply(self._transform, (0, self._y))[1]
 
     @y.setter
     def y(self, value: float) -> None:
@@ -190,7 +232,7 @@ class BoundingBox(SupportsBounds):
 
         :param value: new center y value after transformation
         """
-        self._add_transform(1, 0, value - self.cy)
+        self.y += value - self.cy
 
     @property
     def y2(self) -> float:
@@ -206,7 +248,7 @@ class BoundingBox(SupportsBounds):
 
         :param value: new y2 value after transformation
         """
-        self.y = value - self.height
+        self.y += value - self.y2
 
     @property
     def width(self) -> float:
@@ -214,7 +256,7 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _width value transformed by scale
         """
-        return self._width * self._scale
+        return self._width * self.scale
 
     @width.setter
     def width(self, value: float) -> None:
@@ -227,7 +269,7 @@ class BoundingBox(SupportsBounds):
         """
         current_x = self.x
         current_y = self.y
-        self._scale *= value / self.width
+        self.scale *= value / self.width
         self.x = current_x
         self.y = current_y
 
@@ -237,7 +279,7 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _height value transformed by scale
         """
-        return self._height * self._scale
+        return self._height * self.scale
 
     @height.setter
     def height(self, value: float) -> None:
@@ -250,18 +292,15 @@ class BoundingBox(SupportsBounds):
         """
         self.width = value * self.width / self.height
 
-    def _add_transform(self, scale: float, translation_x: float, translation_y: float):
+    def _add_transform(self, scale: float, dx: float, dy: float):
         """Transform the bounding box by updating the transformation attributes.
 
         :param scale: scale factor
-        :param translation_x: x translation
-        :param translation_y: y translation
-
-        Transformation attributes are _translation_x, _translation_y, and _scale
+        :param dx: x translation
+        :param dy: y translation
         """
-        self._translation_x += translation_x / self._scale
-        self._translation_y += translation_y / self._scale
-        self._scale *= scale
+        tmat = (scale, 0, 0, scale, dx, dy)
+        self._transform = mat_dot(tmat, self._transform)
 
     @property
     def transform_string(self) -> str:
@@ -272,11 +311,7 @@ class BoundingBox(SupportsBounds):
         Use with
         ``update_element(elem, transform=bbox.transform_string)``
         """
-        scale, trans_x, trans_y = (
-            format_number(x)
-            for x in (self._scale, self._translation_x, self._translation_y)
-        )
-        return f"scale({scale}) translate({trans_x} {trans_y})"
+        return f"matrix({' '.join(map(format_number, self._transform))})"
 
     def merge(self, *others: BoundingBox) -> BoundingBox:
         """Create a bounding box around all other bounding boxes.

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/src/svg_ultralight/query.py

@@ -118,7 +118,8 @@ def map_ids_to_bounding_boxes(
 
     id2bbox: dict[str, BoundingBox] = {}
     for id_, *bounds in (x.split(",") for x in bb_strings):
-        id2bbox[id_] = BoundingBox(*(float(x) for x in bounds))
+        x, y, width, height = (float(x) for x in bounds)
+        id2bbox[id_] = BoundingBox(x, y, width, height)
     return id2bbox
 
 

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/src/svg_ultralight/root_elements.py

@@ -8,9 +8,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from svg_ultralight.bounding_boxes.type_bound_element import BoundElement
+from svg_ultralight.bounding_boxes import bound_helpers as bound
 from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
-from svg_ultralight.bounding_boxes.type_padded_text import PaddedText
 from svg_ultralight.main import new_svg_root
 
 if TYPE_CHECKING:
@@ -64,15 +63,8 @@ def new_svg_root_around_bounds(
     :return: root svg element
     :raise ValueError: if no bounding boxes are found in bounded
     """
-    bboxes = [x for x in bounded if isinstance(x, BoundingBox)]
-    bboxes += [x.bbox for x in bounded if isinstance(x, BoundElement)]
-    bboxes += [x.padded_bbox for x in bounded if isinstance(x, PaddedText)]
-
-    if not bboxes:
-        msg = "no bounding boxes found"
-        raise ValueError(msg)
-
-    viewbox = _viewbox_args_from_bboxes(*bboxes)
+    bbox = bound.new_bbox_union(*bounded)
+    viewbox = _viewbox_args_from_bboxes(bbox)
     return new_svg_root(
         x_=viewbox["x_"],
         y_=viewbox["y_"],

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/src/svg_ultralight.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: svg-ultralight
-Version: 0.26.0
+Version: 0.28.0
 Summary: a sensible way to create svg files with Python
 Author-email: Shay Hill <shay_public@hotmail.com>
 License: MIT

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/src/svg_ultralight.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+.gitignore
 .pre-commit-config.yaml
 README.md
 pyproject.toml
@@ -20,6 +21,7 @@ src/svg_ultralight.egg-info/dependency_links.txt
 src/svg_ultralight.egg-info/requires.txt
 src/svg_ultralight.egg-info/top_level.txt
 src/svg_ultralight/bounding_boxes/__init__.py
+src/svg_ultralight/bounding_boxes/bound_helpers.py
 src/svg_ultralight/bounding_boxes/supports_bounds.py
 src/svg_ultralight/bounding_boxes/type_bound_element.py
 src/svg_ultralight/bounding_boxes/type_bounding_box.py

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/tests/test_inkscape.py

@@ -17,10 +17,7 @@ from svg_ultralight.inkscape import convert_text_to_path
 from svg_ultralight.main import new_svg_root
 from svg_ultralight.nsmap import NSMAP
 
-INKSCAPE = Path(
-    r"C:\\Program Files\\WindowsApps\\25415Inkscape.Inkscape_1.3.2.0"
-    + "_x64__9waqn51p1ttv2\\VFS\\ProgramFilesX64\\Inkscape\\bin\\inkscape.exe"
-)
+INKSCAPE = Path(r"C:\Program Files\Inkscape\bin\inkscape")
 
 if not INKSCAPE.with_suffix(".exe").exists():
     msg = "Inkscape not found. Please install Inkscape or update the INKSCAPE path var."

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/tests/test_queries.py

@@ -7,20 +7,16 @@ A quick test. Won't be able to run it till you change INKSCAPE to the correct pa
 your system.
 """
 
-import math
 from dataclasses import dataclass
 from pathlib import Path
 
 import pytest
 
-from svg_ultralight import new_svg_root
+from svg_ultralight import BoundingBox, new_svg_root
 from svg_ultralight.constructors import new_sub_element
-from svg_ultralight.query import BoundingBox, map_ids_to_bounding_boxes
+from svg_ultralight.query import map_ids_to_bounding_boxes
 
-INKSCAPE = Path(
-    r"C:\\Program Files\\WindowsApps\\25415Inkscape.Inkscape_1.3.2.0"
-    + "_x64__9waqn51p1ttv2\\VFS\\ProgramFilesX64\\Inkscape\\bin\\inkscape.exe"
-)
+INKSCAPE = Path(r"C:\Program Files\Inkscape\bin\inkscape")
 
 if not INKSCAPE.with_suffix(".exe").exists():
     msg = "Inkscape not found. Please install Inkscape or update the INKSCAPE path var."
@@ -28,7 +24,6 @@ if not INKSCAPE.with_suffix(".exe").exists():
 
 
 class TestMergeBoundingBoxes:
-
     def test_new_merged_bbox(self):
         bbox_a = BoundingBox(-2, -4, 10, 20)
         bbox_b = BoundingBox(0, 0, 10, 10)
@@ -75,45 +70,45 @@ class TestBoundingBox:
         assert bbox.width == 9000.0
         assert bbox.height == 12000.0
 
-    def test_x(self, bounding_box):
+    def test_x(self, bounding_box: BoundingBox):
         assert bounding_box.x == 0.0
         bounding_box.x = 50.0
         assert bounding_box.x == 50.0
         assert bounding_box.cx == 100.0
 
-    def test_x2(self, bounding_box):
+    def test_x2(self, bounding_box: BoundingBox):
         assert bounding_box.x2 == 100.0
         bounding_box.x2 = 150.0
         assert bounding_box.x2 == 150.0
         assert bounding_box.cx == 100.0
 
-    def test_y(self, bounding_box):
+    def test_y(self, bounding_box: BoundingBox):
         assert bounding_box.y == 0.0
         bounding_box.y = 50.0
         assert bounding_box.y == 50.0
         assert bounding_box.cy == 150.0
 
-    def test_y2(self, bounding_box):
+    def test_y2(self, bounding_box: BoundingBox):
         assert bounding_box.y2 == 200.0
         bounding_box.y2 = 250.0
         assert bounding_box.y2 == 250.0
         assert bounding_box.cy == 150.0
 
-    def test_width(self, bounding_box):
+    def test_width(self, bounding_box: BoundingBox):
         assert bounding_box.width == 100.0
         bounding_box.width = 150.0
         assert bounding_box.width == 150.0
         assert bounding_box.x2 == 150.0
 
-    def test_height(self, bounding_box):
+    def test_height(self, bounding_box: BoundingBox):
         assert bounding_box.height == 200.0
         bounding_box.height = 250.0
         assert bounding_box.height == 250.0
         assert bounding_box.y2 == 250.0
 
-    def test_transform_string(self, bounding_box):
+    def test_transform_string(self, bounding_box: BoundingBox):
         transform_string = bounding_box.transform_string
-        assert transform_string == "scale(1) translate(0 0)"
+        assert transform_string == "matrix(1 0 0 1 0 0)"
 
     def test_merge(self):
         bbox1 = MockSupportsBounds(0, 0, 100, 200)
@@ -185,6 +180,4 @@ class TestAlterBoundingBox:
         bbox.y = 200
         bbox.height = 200
         bbox.height = 40
-        assert math.isclose(bbox.scale, 1)
-        assert math.isclose(bbox._translation_x, 90)  # type: ignore
-        assert math.isclose(bbox._translation_y, 180)  # type: ignore
+        assert bbox.transform == (1, 0, 0, 1, 90, 180)

{svg_ultralight-0.26.0 → svg_ultralight-0.28.0}/tests/test_root_elements.py

@@ -6,15 +6,13 @@
 
 import pytest
 
-from svg_ultralight.main import new_svg_root
-from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
 from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
 from svg_ultralight.bounding_boxes.type_bound_element import BoundElement
 from svg_ultralight.bounding_boxes.type_padded_text import PaddedText
 from svg_ultralight.constructors import new_element
 from svg_ultralight.root_elements import new_svg_root_around_bounds
+from svg_ultralight.bounding_boxes.bound_helpers import new_bound_union
 from lxml.etree import _Element as EtreeElement  # type: ignore
-from typing import Union
 
 
 class TestNewSvgRootAroundBounds:
@@ -23,13 +21,13 @@ class TestNewSvgRootAroundBounds:
         """Raise ValueError if no bounding boxes found."""
         with pytest.raises(ValueError) as excinfo:
             _ = new_svg_root_around_bounds()
-        assert "no bounding boxes found" in str(excinfo.value)
+        assert "At least one argument" in str(excinfo.value)
 
     def test_no_bound_elements(self):
         """Raise ValueError if no BoundElements found."""
         with pytest.raises(ValueError) as excinfo:
             _ = new_svg_root_around_bounds(new_element("g"))
-        assert "no bounding boxes found" in str(excinfo.value)
+        assert "At least one argument" in str(excinfo.value)
 
     def test_bounding_boxes(self):
         """Create svg root element from bounding boxes."""
@@ -53,3 +51,33 @@ class TestNewSvgRootAroundBounds:
         result = new_svg_root_around_bounds(*args)
         assert isinstance(result, EtreeElement)
         assert result.attrib["viewBox"] == "0 0 201 201"
+
+class TestNewBoundUnion:
+
+    def test_bounding_boxes_only(self):
+        """Raise an error if no elements found."""
+        bboxes = [BoundingBox(0, 0, 100, 100), BoundingBox(50, 50, 150, 150)]
+        with pytest.raises(ValueError) as excinfo:
+            _ = new_bound_union(*bboxes)
+        assert "must be a BoundElement, PaddedText, or Etree" in str(excinfo.value)
+
+    def test_elements_only(self):
+        """Raise an error if no elements found."""
+        elems = [new_element("g"), new_element("g")]
+        with pytest.raises(ValueError) as excinfo:
+            _ = new_bound_union(*elems)
+        assert "must be a BoundElement, BoundingBox, or Padded" in str(excinfo.value)
+
+    def test_bound_elements(self):
+        """Create svg root element from BoundElements."""
+        bboxes = [BoundingBox(0, 0, 100, 100), BoundingBox(50, 50, 150, 150)]
+        args = bboxes[0], BoundElement(new_element("g"), bboxes[1])
+        result = new_bound_union(*args)
+        assert isinstance(result, BoundElement)
+
+    def test_padded_text(self):
+        """Create svg root element from BoundElements."""
+        bboxes = [BoundingBox(0, 0, 100, 100), BoundingBox(50, 50, 150, 150)]
+        args = bboxes[0], PaddedText(new_element("g"), bboxes[1], 1, 1, 1, 1)
+        result = new_bound_union(*args)
+        assert isinstance(result, BoundElement)