svg-ultralight 0.38.0__py3-none-any.whl → 0.39.0__py3-none-any.whl

svg_ultralight/bounding_boxes/bound_helpers.py

@@ -10,8 +10,9 @@ from typing import TYPE_CHECKING
 
 from lxml.etree import _Element as EtreeElement  # pyright: ignore[reportPrivateUsage]
 
+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
+from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox, HasBoundingBox
 from svg_ultralight.bounding_boxes.type_padded_text import PaddedText
 from svg_ultralight.constructors import new_element
 
@@ -66,15 +67,7 @@ def new_bbox_union(*blems: SupportsBounds | EtreeElement) -> BoundingBox:
 
     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)
-
+    bboxes = [x.bbox for x in blems if isinstance(x, HasBoundingBox)]
     if not bboxes:
         msg = (
             "Cannot find any bounding boxes to union. "

svg_ultralight/bounding_boxes/supports_bounds.py

@@ -37,7 +37,7 @@ class SupportsBounds(Protocol):
         cy (float): The center y coordinate.
         width (float): The width of the object.
         height(float): The height of the object.
-        scale (float): The scale of the object.
+        scale ((float, float)): The x and yx and y scale of the object.
 
     There is no setter for scale. Scale is a function of width and height.
     Setting scale would be ambiguous. because the typical implementation of
@@ -45,16 +45,11 @@ class SupportsBounds(Protocol):
     set width and height.
     """
 
-    @property
-    def transformation(self) -> _Matrix:
-        """Return an svg-style transformation matrix."""
-        ...
-
     def transform(
         self,
         transformation: _Matrix | None = None,
         *,
-        scale: float | None = None,
+        scale: tuple[float, float] | None = None,
         dx: float | None = None,
         dy: float | None = None,
     ):
@@ -158,12 +153,12 @@ class SupportsBounds(Protocol):
         """
 
     @property
-    def scale(self) -> float:
+    def scale(self) -> tuple[float, float]:
         """Return scale of the object."""
         ...
 
     @scale.setter
-    def scale(self, value: float):
+    def scale(self, value: tuple[float, float]):
         """Return scale of the object.
 
         :param value: The scale of the object.

svg_ultralight/bounding_boxes/type_bound_collection.py

@@ -44,7 +44,7 @@ class BoundCollection(HasBoundingBox):
         self,
         transformation: _Matrix | None = None,
         *,
-        scale: float | None = None,
+        scale: tuple[float, float] | None = None,
         dx: float | None = None,
         dy: float | None = None,
     ):

svg_ultralight/bounding_boxes/type_bound_element.py

@@ -45,14 +45,11 @@ class BoundElement(HasBoundingBox):
         self.elem = element
         self.bbox = bounding_box
 
-    def _update_elem(self):
-        self.elem.attrib["transform"] = self.bbox.transform_string
-
     def transform(
         self,
         transformation: _Matrix | None = None,
         *,
-        scale: float | None = None,
+        scale: tuple[float, float] | None = None,
         dx: float | None = None,
         dy: float | None = None,
     ):

svg_ultralight/bounding_boxes/type_bounding_box.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import dataclasses
+import math
 
 from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
 from svg_ultralight.string_conversion import format_number
@@ -15,85 +16,64 @@ from svg_ultralight.transformations import mat_apply, mat_dot, new_transformatio
 _Matrix = tuple[float, float, float, float, float, float]
 
 
-@dataclasses.dataclass
-class BoundingBox(SupportsBounds):
-    """Mutable bounding box object for svg_ultralight.
-
-    :param x: left x value
-    :param y: top y value
-    :param width: width of the bounding box
-    :param height: height of the bounding box
-
-    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, it will not be used.
-
-    :param _transformation: transformation matrix
-
-    Functions that return a bounding box will return a BoundingBox instance. This
-    instance can be transformed (uniform scale and translate only). Transformations
-    will be combined and scored to be passed to new_element as a transform value.
-
-    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 value _transformation
-    will be updated.
-
-    The ultimate transformation can be accessed through ``.transform_string``.
-    So the workflow will look like :
-
-        1. Get the bounding box of an svg element
-        2. Update the bounding box x, y, width, and height
-        3. Transform the original svg element with
-            update_element(elem, transform=bbox.transform_string)
-        4. The transformed element will lie in the transformed BoundingBox
-
-    In addition to x, y, width, and height, x2 and y2 can be set to establish the
-    right x value or bottom y value.
-
-    The point of all of this is to simplify stacking and aligning elements. To stack:
-
-        ```
-        elem_a = new_element(*args)
-        bbox_a = get_bounding_box(elem_a)
-
-        elem_b = new_element(*args)
-        bbox_b = get_bounding_box(elem_b)
-
-        # align at same x
-        bbox_b.x = bbox_a.x
-
-        # make the same width
-        bbox_b.width = bbox_a.width
+class HasBoundingBox(SupportsBounds):
+    """A parent class for BoundElement and others that have a bbox attribute."""
 
-        # stack a on top of b
-        bbox_a.y2 = bbox_b.y
+    def __init__(self, bbox: BoundingBox) -> None:
+        """Initialize the HasBoundingBox instance."""
+        self.bbox = bbox
 
-        update_element(elem_a, transform=bbox_a.transform_string)
-        update_element(elem_b, transform=bbox_b.transform_string)
-    """
+    def _get_input_corners(
+        self,
+    ) -> tuple[
+        tuple[float, float],
+        tuple[float, float],
+        tuple[float, float],
+        tuple[float, float],
+    ]:
+        """Get the input corners of the bounding box.
+
+        :return: four corners counter-clockwise starting at top left
+        """
+        x = self.bbox.base_x
+        y = self.bbox.base_y
+        x2 = x + self.bbox.base_width
+        y2 = y + self.bbox.base_height
+        return (x, y), (x2, y), (x2, y2), (x, y2)
+
+    def _get_transformed_corners(
+        self,
+    ) -> tuple[
+        tuple[float, float],
+        tuple[float, float],
+        tuple[float, float],
+        tuple[float, float],
+    ]:
+        """Get the transformed corners of the bounding box.
 
-    _x: float
-    _y: float
-    _width: float
-    _height: float
-    _transformation: _Matrix = (1, 0, 0, 1, 0, 0)
+        :return: four corners counter-clockwise starting at top left, transformed by
+            self.transformation
+        """
+        c0, c1, c2, c3 = (
+            mat_apply(self.bbox.transformation, c) for c in self._get_input_corners()
+        )
+        return c0, c1, c2, c3
 
-    @property
-    def transformation(self) -> _Matrix:
-        """Return transformation matrix.
+    def _scale_scale_by_uniform_scalar(self, scalar: float) -> None:
+        """Scale the bounding box uniformly by a factor.
 
-        :return: transformation matrix
+        :param scale: scale factor
+        Unlike self.scale, this does not set the scale, but scales the scale. So if
+        the current scale is (2, 6), and you call this with a scalar of 2, the new
+        scale will be (4, 12).
         """
-        return self._transformation
+        self.transform(scale=(scalar, scalar))
 
     def transform(
         self,
         transformation: _Matrix | None = None,
         *,
-        scale: float | None = None,
+        scale: tuple[float, float] | None = None,
         dx: float | None = None,
         dy: float | None = None,
     ):
@@ -112,10 +92,10 @@ class BoundingBox(SupportsBounds):
         when applying a transformation from another bounding box instance.
         """
         tmat = new_transformation_matrix(transformation, scale=scale, dx=dx, dy=dy)
-        self._transformation = mat_dot(tmat, self.transformation)
+        self.bbox.transformation = mat_dot(tmat, self.bbox.transformation)
 
     @property
-    def scale(self) -> float:
+    def scale(self) -> tuple[float, float]:
         """Get scale of the bounding box.
 
         :return: uniform scale of the bounding box
@@ -127,10 +107,11 @@ class BoundingBox(SupportsBounds):
         width*scale, height => height*scale, scale => scale*scale. This matches how
         scale works in almost every other context.
         """
-        return self.transformation[0]
+        xx, xy, yx, yy, *_ = self.bbox.transformation
+        return math.sqrt(xx * xx + xy * xy), math.sqrt(yx * yx + yy * yy)
 
     @scale.setter
-    def scale(self, value: float) -> None:
+    def scale(self, value: tuple[float, float]) -> None:
         """Scale the bounding box by a uniform factor.
 
         :param value: new scale value
@@ -142,7 +123,8 @@ 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.transform(scale=value / self.scale)
+        new_scale = value[0] / self.scale[0], value[1] / self.scale[1]
+        self.transform(scale=new_scale)
 
     @property
     def x(self) -> float:
@@ -150,13 +132,13 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _x value transformed by scale and translation
         """
-        return mat_apply(self.transformation, (self._x, 0))[0]
+        return min(x for x, _ in self._get_transformed_corners())
 
     @x.setter
-    def x(self, value: float) -> None:
-        """Update transformation values (do not alter self._x).
+    def x(self, value: float):
+        """Set the x coordinate of the left edge of the bounding box.
 
-        :param value: new x value after transformation
+        :param value: the new x coordinate of the left edge of the bounding box
         """
         self.transform(dx=value - self.x)
 
@@ -182,7 +164,7 @@ class BoundingBox(SupportsBounds):
 
         :return: transformed x + transformed width
         """
-        return self.x + self.width
+        return max(x for x, _ in self._get_transformed_corners())
 
     @x2.setter
     def x2(self, value: float) -> None:
@@ -198,7 +180,7 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _y value transformed by scale and translation
         """
-        return mat_apply(self.transformation, (0, self._y))[1]
+        return min(y for _, y in self._get_transformed_corners())
 
     @y.setter
     def y(self, value: float) -> None:
@@ -230,7 +212,7 @@ class BoundingBox(SupportsBounds):
 
         :return: transformed y + transformed height
         """
-        return self.y + self.height
+        return max(y for _, y in self._get_transformed_corners())
 
     @y2.setter
     def y2(self, value: float) -> None:
@@ -246,7 +228,7 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _width value transformed by scale
         """
-        return self._width * self.scale
+        return self.x2 - self.x
 
     @width.setter
     def width(self, value: float) -> None:
@@ -259,7 +241,7 @@ class BoundingBox(SupportsBounds):
         """
         current_x = self.x
         current_y = self.y
-        self.scale *= value / self.width
+        self._scale_scale_by_uniform_scalar(value / self.width)
         self.x = current_x
         self.y = current_y
 
@@ -269,7 +251,7 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _height value transformed by scale
         """
-        return self._height * self.scale
+        return self.y2 - self.y
 
     @height.setter
     def height(self, value: float) -> None:
@@ -291,7 +273,96 @@ class BoundingBox(SupportsBounds):
         Use with
         ``update_element(elem, transform=bbox.transform_string)``
         """
-        return f"matrix({' '.join(map(format_number, self.transformation))})"
+        return f"matrix({' '.join(map(format_number, self.bbox.transformation))})"
+
+
+@dataclasses.dataclass
+class BoundingBox(HasBoundingBox):
+    """Mutable bounding box object for svg_ultralight.
+
+    :param x: left x value
+    :param y: top y value
+    :param width: width of the bounding box
+    :param height: height of the bounding box
+
+    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, it will not be used.
+
+    :param transformation: transformation matrix
+
+    Functions that return a bounding box will return a BoundingBox instance. This
+    instance can be transformed (uniform scale and translate only). Transformations
+    will be combined and scored to be passed to new_element as a transform value.
+
+    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 value transformation
+    will be updated.
+
+    The ultimate transformation can be accessed through ``.transform_string``.
+    So the workflow will look like :
+
+        1. Get the bounding box of an svg element
+        2. Update the bounding box x, y, width, and height
+        3. Transform the original svg element with
+            update_element(elem, transform=bbox.transform_string)
+        4. The transformed element will lie in the transformed BoundingBox
+
+    In addition to x, y, width, and height, x2 and y2 can be set to establish the
+    right x value or bottom y value.
+
+    The point of all of this is to simplify stacking and aligning elements. To stack:
+
+        ```
+        elem_a = new_element(*args)
+        bbox_a = get_bounding_box(elem_a)
+
+        elem_b = new_element(*args)
+        bbox_b = get_bounding_box(elem_b)
+
+        # align at same x
+        bbox_b.x = bbox_a.x
+
+        # make the same width
+        bbox_b.width = bbox_a.width
+
+        # stack a on top of b
+        bbox_a.y2 = bbox_b.y
+
+        update_element(elem_a, transform=bbox_a.transform_string)
+        update_element(elem_b, transform=bbox_b.transform_string)
+    """
+
+    base_x: float = dataclasses.field(init=False)
+    base_y: float = dataclasses.field(init=False)
+    base_width: float = dataclasses.field(init=False)
+    base_height: float = dataclasses.field(init=False)
+    transformation: _Matrix = dataclasses.field(init=False)
+
+    def __init__(
+        self,
+        x: float,
+        y: float,
+        width: float,
+        height: float,
+        transformation: _Matrix = (1, 0, 0, 1, 0, 0),
+    ) -> None:
+        """Initialize a BoundingBox instance.
+
+        :param x: left x value
+        :param y: top y value
+        :param width: width of the bounding box
+        :param height: height of the bounding box
+        """
+        self.base_x = x
+        self.base_y = y
+        self.base_width = width
+        self.base_height = height
+        self.transformation = transformation
+        self.bbox = self
 
     def merge(self, *others: BoundingBox) -> BoundingBox:
         """Create a bounding box around all other bounding boxes.
@@ -321,181 +392,3 @@ class BoundingBox(SupportsBounds):
         min_y = min(x.y for x in bboxes)
         max_y = max(x.y + x.height for x in bboxes)
         return BoundingBox(min_x, min_y, max_x - min_x, max_y - min_y)
-
-
-class HasBoundingBox(SupportsBounds):
-    """A parent class for BoundElement and others that have a bbox attribute."""
-
-    def __init__(self, bbox: BoundingBox) -> None:
-        """Initialize the HasBoundingBox instance."""
-        self.bbox = bbox
-
-    @property
-    def transformation(self) -> _Matrix:
-        """The transformation matrix of the bounding box."""
-        return self.bbox.transformation
-
-    def transform(
-        self,
-        transformation: _Matrix | None = None,
-        *,
-        scale: float | None = None,
-        dx: float | None = None,
-        dy: float | None = None,
-    ):
-        """Transform the element and bounding box.
-
-        :param transformation: a 6-tuple transformation matrix
-        :param scale: a scaling factor
-        :param dx: the x translation
-        :param dy: the y translation
-        """
-        self.bbox.transform(transformation, scale=scale, dx=dx, dy=dy)
-
-    @property
-    def scale(self) -> float:
-        """The scale of the bounding box.
-
-        :return: the scale of the bounding box
-        """
-        return self.transformation[0]
-
-    @scale.setter
-    def scale(self, value: float):
-        """Set the scale of the bounding box.
-
-        :param value: the scale of the bounding box
-        """
-        self.transform(scale=value / self.scale)
-
-    @property
-    def x(self) -> float:
-        """The x coordinate of the left edge of the bounding box.
-
-        :return: the x coordinate of the left edge of the bounding box
-        """
-        return self.bbox.x
-
-    @x.setter
-    def x(self, value: float):
-        """Set the x coordinate of the left edge of the bounding box.
-
-        :param value: the new x coordinate of the left edge of the bounding box
-        """
-        self.transform(dx=value - self.x)
-
-    @property
-    def x2(self) -> float:
-        """The x coordinate of the right edge of the bounding box.
-
-        :return: the x coordinate of the right edge of the bounding box
-        """
-        return self.bbox.x2
-
-    @x2.setter
-    def x2(self, value: float):
-        """Set the x coordinate of the right edge of the bounding box.
-
-        :param value: the new x coordinate of the right edge of the bounding box
-        """
-        self.x += value - self.x2
-
-    @property
-    def cx(self) -> float:
-        """The x coordinate of the center of the bounding box.
-
-        :return: the x coordinate of the center of the bounding box
-        """
-        return self.bbox.cx
-
-    @cx.setter
-    def cx(self, value: float):
-        """Set the x coordinate of the center of the bounding box.
-
-        :param value: the new x coordinate of the center of the bounding box
-        """
-        self.x += value - self.cx
-
-    @property
-    def y(self) -> float:
-        """The y coordinate of the top edge of the bounding box.
-
-        :return: the y coordinate of the top edge of the bounding box
-        """
-        return self.bbox.y
-
-    @y.setter
-    def y(self, value: float):
-        """Set the y coordinate of the top edge of the bounding box.
-
-        :param value: the new y coordinate of the top edge of the bounding box
-        """
-        self.transform(dy=value - self.y)
-
-    @property
-    def y2(self) -> float:
-        """The y coordinate of the bottom edge of the bounding box.
-
-        :return: the y coordinate of the bottom edge of the bounding box
-        """
-        return self.bbox.y2
-
-    @y2.setter
-    def y2(self, value: float):
-        """Set the y coordinate of the bottom edge of the bounding box.
-
-        :param value: the new y coordinate of the bottom edge of the bounding box
-        """
-        self.y += value - self.y2
-
-    @property
-    def cy(self) -> float:
-        """The y coordinate of the center of the bounding box.
-
-        :return: the y coordinate of the center of the bounding box
-        """
-        return self.bbox.cy
-
-    @cy.setter
-    def cy(self, value: float):
-        """Set the y coordinate of the center of the bounding box.
-
-        :param value: the new y coordinate of the center of the bounding box
-        """
-        self.y += value - self.cy
-
-    @property
-    def width(self) -> float:
-        """The width of the bounding box.
-
-        :return: the width of the bounding box
-        """
-        return self.bbox.width
-
-    @width.setter
-    def width(self, value: float):
-        """Set the width of the bounding box.
-
-        :param value: the new width of the bounding box
-        """
-        current_x = self.x
-        current_y = self.y
-        self.scale *= value / self.width
-        self.x = current_x
-        self.y = current_y
-
-    @property
-    def height(self) -> float:
-        """The height of the bounding box.
-
-        :return: the height of the bounding box
-        """
-        return self.bbox.height
-
-    @height.setter
-    def height(self, value: float):
-        """Set the height of the bounding box.
-
-        :param value: the new height of the bounding box
-        """
-        self.width *= value / self.height

svg_ultralight/bounding_boxes/type_padded_text.py

@@ -12,7 +12,7 @@ There is a getter and setter for each of the four padding values. These *do not*
 the text element. For instance, if you decrease the left padding, the left margin
 will move, *not* the text element.
 
-There is a getter and setter for each of lmargin, rmargin, baseline, and capline.
+_There is a getter and setter for each of lmargin, rmargin, baseline, and capline.
 These *do* move the element, but do not scale it. For instance, if you move the
 leftmargin to the left, the right margin (and the text element with it) will move to
 the left.
@@ -66,8 +66,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-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
+from svg_ultralight.transformations import new_transformation_matrix, transform_element
 
 if TYPE_CHECKING:
     from lxml.etree import (
@@ -77,7 +78,7 @@ if TYPE_CHECKING:
 _Matrix = tuple[float, float, float, float, float, float]
 
 
-class PaddedText(SupportsBounds):
+class PaddedText(BoundElement):
     """A line of text with a bounding box and padding."""
 
     def __init__(
@@ -99,14 +100,14 @@ class PaddedText(SupportsBounds):
         :param lpad: Left padding.
         """
         self.elem = elem
-        self.bbox = bbox
+        self.unpadded_bbox = bbox
         self.base_tpad = tpad
         self.rpad = rpad
         self.base_bpad = bpad
         self.lpad = lpad
 
     @property
-    def padded_bbox(self) -> BoundingBox:
+    def bbox(self) -> BoundingBox:
         """Return a BoundingBox around the margins and cap/baseline.
 
         :return: A BoundingBox around the margins and cap/baseline.
@@ -117,22 +118,28 @@ class PaddedText(SupportsBounds):
         instance around multiple text elements (a <g> elem).
         """
         return BoundingBox(
-            self.lmargin, self.capline, self.padded_width, self.padded_height
+            self.x,
+            self.y,
+            self.width,
+            self.height,
+            self.unpadded_bbox.transformation,
         )
 
-    @property
-    def transformation(self) -> _Matrix:
-        """The transformation matrix of the bounding box."""
-        return self.bbox.transformation
+    @bbox.setter
+    def bbox(self, value: BoundingBox) -> None:
+        """Set the bounding box of this PaddedText.
 
-    def _update_elem(self):
-        self.elem.attrib["transform"] = self.bbox.transform_string
+        :param value: The new bounding box.
+        :effects: The text element is transformed to fit the new bounding box.
+        """
+        msg = "Cannot set bbox of PaddedText, use transform() instead."
+        raise NotImplementedError(msg)
 
     def transform(
         self,
         transformation: _Matrix | None = None,
         *,
-        scale: float | None = None,
+        scale: tuple[float, float] | None = None,
         dx: float | None = None,
         dy: float | None = None,
     ):
@@ -143,8 +150,9 @@ class PaddedText(SupportsBounds):
         :param dx: the x translation
         :param dy: the y translation
         """
-        self.bbox.transform(transformation, scale=scale, dx=dx, dy=dy)
-        self._update_elem()
+        tmat = new_transformation_matrix(transformation, scale=scale, dx=dx, dy=dy)
+        self.unpadded_bbox.transform(tmat)
+        _ = transform_element(self.elem, tmat)
 
     @property
     def tpad(self) -> float:
@@ -152,7 +160,7 @@ class PaddedText(SupportsBounds):
 
         :return: The scaled top padding of this line of text.
         """
-        return self.base_tpad * self.bbox.scale
+        return self.base_tpad * self.unpadded_bbox.scale[1]
 
     @tpad.setter
     def tpad(self, value: float) -> None:
@@ -160,7 +168,7 @@ class PaddedText(SupportsBounds):
 
         :param value: The new top padding.
         """
-        self.base_tpad = value / self.bbox.scale
+        self.base_tpad = value / self.unpadded_bbox.scale[1]
 
     @property
     def bpad(self) -> float:
@@ -168,7 +176,7 @@ class PaddedText(SupportsBounds):
 
         :return: The scaled bottom padding of this line of text.
         """
-        return self.base_bpad * self.bbox.scale
+        return self.base_bpad * self.unpadded_bbox.scale[1]
 
     @bpad.setter
     def bpad(self, value: float) -> None:
@@ -176,82 +184,18 @@ class PaddedText(SupportsBounds):
 
         :param value: The new bottom padding.
         """
-        self.base_bpad = value / self.bbox.scale
-
-    @property
-    def lmargin(self) -> float:
-        """The left margin of this line of text.
-
-        :return: The left margin of this line of text.
-        """
-        return self.bbox.x - self.lpad
-
-    @lmargin.setter
-    def lmargin(self, value: float) -> None:
-        """Set the left margin of this line of text.
-
-        :param value: The left margin of this line of text.
-        """
-        self.transform(dx=value + self.lpad - self.bbox.x)
-
-    @property
-    def rmargin(self) -> float:
-        """The right margin of this line of text.
-
-        :return: The right margin of this line of text.
-        """
-        return self.bbox.x2 + self.rpad
-
-    @rmargin.setter
-    def rmargin(self, value: float) -> None:
-        """Set the right margin of this line of text.
-
-        :param value: The right margin of this line of text.
-        """
-        self.transform(dx=value - self.rpad - self.bbox.x2)
-
-    @property
-    def capline(self) -> float:
-        """The top of this line of text.
-
-        :return: The top of this line of text.
-        """
-        return self.bbox.y - self.tpad
-
-    @capline.setter
-    def capline(self, value: float) -> None:
-        """Set the top of this line of text.
-
-        :param value: The top of this line of text.
-        """
-        self.transform(dy=value + self.tpad - self.bbox.y)
+        self.base_bpad = value / self.unpadded_bbox.scale[1]
 
     @property
-    def baseline(self) -> float:
-        """The bottom of this line of text.
-
-        :return: The bottom of this line of text.
-        """
-        return self.bbox.y2 + self.bpad
-
-    @baseline.setter
-    def baseline(self, value: float) -> None:
-        """Set the bottom of this line of text.
-
-        :param value: The bottom of this line of text.
-        """
-        self.transform(dy=value - self.bpad - self.bbox.y2)
-
-    @property
-    def padded_width(self) -> float:
+    def width(self) -> float:
         """The width of this line of text with padding.
 
         :return: The scaled width of this line of text with padding.
         """
-        return self.bbox.width + self.lpad + self.rpad
+        return self.unpadded_bbox.width + self.lpad + self.rpad
 
-    @padded_width.setter
-    def padded_width(self, width: float) -> None:
+    @width.setter
+    def width(self, value: float) -> None:
         """Scale to padded_width = width without scaling padding.
 
         :param width: The new width of this line of text.
@@ -263,27 +207,26 @@ class PaddedText(SupportsBounds):
         baseline is near y2 (y + height) not y. So, we preserve baseline (alter y
         *and* y2) when scaling.
         """
-        baseline = self.baseline
-        self.bbox.width = width - self.lpad - self.rpad
-        self.baseline = baseline
-        self._update_elem()
+        y2 = self.y2
+        self.unpadded_bbox.width = value - self.lpad - self.rpad
+        self.y2 = y2
 
     @property
-    def padded_height(self) -> float:
+    def height(self) -> float:
         """The height of this line of text with padding.
 
         :return: The scaled height of this line of text with padding.
         """
-        return self.bbox.height + self.tpad + self.bpad
+        return self.unpadded_bbox.height + self.tpad + self.bpad
 
-    @padded_height.setter
-    def padded_height(self, height: float) -> None:
-        """Scale to padded_height = height without scaling padding.
+    @height.setter
+    def height(self, value: float) -> None:
+        """Scale to height without scaling padding.
 
         :param height: The new height of this line of text.
         :effects: the text_element bounding box is scaled to height - tpad - bpad.
         """
-        self.padded_width *= height / self.padded_height
+        self.width *= value / self.height
 
     @property
     def x(self) -> float:
@@ -291,15 +234,15 @@ class PaddedText(SupportsBounds):
 
         :return: The left margin of this line of text.
         """
-        return self.lmargin
+        return self.unpadded_bbox.x - self.lpad
 
     @x.setter
     def x(self, value: float) -> None:
         """Set the left margin of this line of text.
 
-        :param value: The new left margin of this line of text.
+        :param value: The left margin of this line of text.
         """
-        self.lmargin = value
+        self.transform(dx=value + self.lpad - self.unpadded_bbox.x)
 
     @property
     def x2(self) -> float:
@@ -307,134 +250,49 @@ class PaddedText(SupportsBounds):
 
         :return: The right margin of this line of text.
         """
-        return self.rmargin
+        return self.unpadded_bbox.x2 + self.rpad
 
     @x2.setter
     def x2(self, value: float) -> None:
         """Set the right margin of this line of text.
 
-        :param value: The new right margin of this line of this text.
+        :param value: The right margin of this line of text.
         """
-        self.rmargin = value
+        self.transform(dx=value - self.rpad - self.unpadded_bbox.x2)
 
     @property
     def y(self) -> float:
-        """The capline of this line of text.
+        """The top of this line of text.
 
-        :return: The capline of this line of text.
+        :return: The top of this line of text.
         """
-        return self.capline
+        return self.unpadded_bbox.y - self.tpad
 
     @y.setter
     def y(self, value: float) -> None:
-        """Set the capline of this line of text.
+        """Set the top of this line of text.
 
-        :param value: The new capline of this line of text.
+        :param value: The top of this line of text.
         """
-        self.capline = value
+        self.transform(dy=value + self.tpad - self.unpadded_bbox.y)
 
     @property
     def y2(self) -> float:
-        """The baseline of this line of text.
+        """The bottom of this line of text.
 
-        :return: The baseline of this line of text.
+        :return: The bottom of this line of text.
         """
-        return self.baseline
+        return self.unpadded_bbox.y2 + self.bpad
 
     @y2.setter
     def y2(self, value: float) -> None:
-        """Set the baseline of this line of text.
-
-        :param value: The new baseline of this line of text.
-        """
-        self.baseline = value
-
-    @property
-    def width(self) -> float:
-        """The width of this line of text with padding.
-
-        :return: The scaled width of this line of text with padding.
-        """
-        return self.padded_width
-
-    @width.setter
-    def width(self, value: float) -> None:
-        """Scale to width without scaling padding.
-
-        :param value: The new width of this line of text.
-        :effects: the text_element bounding box is scaled to width - lpad - rpad.
-
-        Svg_Ultralight BoundingBoxes preserve x and y when scaling. This is
-        consistent with how rectangles, viewboxes, and anything else defined by x, y,
-        width, height behaves in SVG. This is unintuitive for text, because the
-        baseline is near y2 (y + height) not y. So, we preserve baseline (alter y
-        *and* y2) when scaling.
-        """
-        baseline = self.baseline
-        self.padded_width = value
-        self.baseline = baseline
-
-    @property
-    def height(self) -> float:
-        """The height of this line of text with padding.
-
-        :return: The scaled height of this line of text with padding.
-        """
-        return self.padded_height
-
-    @height.setter
-    def height(self, value: float) -> None:
-        """Scale to height without scaling padding.
-
-        :param value: The new height of this line of text.
-        :effects: the text_element bounding box is scaled to height - tpad - bpad.
-        """
-        self.padded_height = value
-
-    @property
-    def cx(self) -> float:
-        """The x coordinate of the center between margins.
-
-        :return: the x coordinate of the center between margins
-        """
-        return self.lmargin + self.padded_width / 2
-
-    @cx.setter
-    def cx(self, value: float):
-        """Set the x coordinate of the center between margins.
-
-        :param value: the new x coordinate of the center between margins
-        """
-        self.lmargin = value - self.padded_width / 2
-
-    @property
-    def cy(self) -> float:
-        """The y coordinate of the center between baseline and capline.
-
-        :return: the y coordinate of the center between baseline and capline
-        """
-        return self.capline + self.padded_height / 2
-
-    @cy.setter
-    def cy(self, value: float):
-        """Set the y coordinate of the center between baseline and capline.
-
-        :param value: the new y coordinate of the center between baseline and capline
-        """
-        self.capline = value - self.padded_height / 2
-
-    @property
-    def scale(self) -> float:
-        """The scale of the text element.
+        """Set the bottom of this line of text.
 
-        :return: the scale of the text element
+        :param value: The bottom of this line of text.
         """
-        return self.bbox.scale
-
-    @scale.setter
-    def scale(self, value: float):
-        """Set the scale of the text element.
+        self.transform(dy=value - self.bpad - self.unpadded_bbox.y2)
 
-        :param value: the new scale of the text element
-        """
-        self.bbox.scale = value
+    lmargin = x
+    rmargin = x2
+    capline = y
+    baseline = y2

svg_ultralight/layout.py

@@ -144,11 +144,11 @@ def pad_and_scale(
     """Expand and scale the pad argument. If necessary, scale image.
 
     :param viewbox: viewbox to pad (x, y, width height)
-    :param pad: padding to add around image, in user units or inches. if a
+    :param pad: padding to add around image, in user units or inches. If a
         sequence, it should be (top, right, bottom, left). if a single float or
-        string, it will be applied to all sides. if two floats, top and bottom
-        then left and right. if three floats, top, left and right, then bottom.
-        if four floats, top, right, bottom, left.
+        string, it will be applied to all sides. If two floats, top and bottom
+        then left and right. If three floats, top, left and right, then bottom.
+        If four floats, top, right, bottom, left.
     :param print_width: width of print area, in user units (float), a string
         with a unit specifier (e.g., "452mm"), or just a unit specifier (e.g.,
         "pt")
@@ -169,7 +169,7 @@ def pad_and_scale(
     If the width and height *are* specified, the user units become whatever they
     need to be to fit that requirement. For instance, if the viewbox width is 96
     and the width argument is "1in", then the user units are *still* pixels,
-    because there are 96 pixels in an inch. If the viewbox with is 2 and the
+    because there are 96 pixels in an inch. If the viewbox width is 2 and the
     width argument is "1in", then the user units are 1/2 of an inch (i.e., 48
     pixels) each, because there are 2 user units in an inch. If the viewbox
     width is 3 and the width argument is "1yd", the each user unit is 1 foot.
@@ -195,17 +195,26 @@ def pad_and_scale(
     the unit designators without changing the scale.
 
     Print aspect ratio is ignored. Viewbox aspect ratio is preserved. For
-    instance, If you take a 100x100 unit image then pass pad="0.25in" and
-    print_width="12in", the output image will be 12.5 inches across. Whatever
-    geometry was visible in the original viewbox will be much larger, but the
-    padding will still be 0.25 inches. If you want to use padding and need a
-    specific output image size, remember to subtract the padding width from your
-    print_width or print_height.
+    instance, if you created two images
+
+    * x_=0, y_=0, width_=1, height_=2, pad_="0.25in", print_width_="6in"
+
+    * x_=0, y_=0, width_=1, height_=2, pad_="0.25in", print_width_="12in"
+
+    ... (note that the images only vary in print_width_), the first image would be
+    rendered at 6.5x12.5 inches and the second at 12.5x24.5 inches. The visible
+    content in the viewbox would be exactly twice as wide in the larger image, but
+    the padding would remain 0.25 in both images. Despite setting `print_width_` to
+    exactly 6 or 12 inches, you would not get an image exactly 6 or 12 inches wide.
+    Despite a viewbox aspect ratio of 1:2, you would not get an output image of
+    exactly 1:2. If you want to use padding and need a specific output image size or
+    aspect ratio, remember to subtract the padding width from your print_width or
+    print_height.
 
     Scaling attributes are returned as a dictonary that can be "exploded" into
     the element constructor, e.g., {"width": "12.5in", "height": "12.5in"}.
 
-    * If neighther a print_width nor print_height is specified, no scaling
+    * If neither a print_width nor print_height is specified, no scaling
       attributes will be returned.
 
     * If either is specified, both a width and height will be returned (even if
@@ -242,7 +251,7 @@ def pad_and_scale(
     a 16" x 9" image with viwebox(0, 0, 14, 7), pad_="1in", print_width_="14in"
     ... then scale the printout with dpu_=2 to get a 32" x 18" image with the
     same viewbox. This means the padding will be 2" on all sides, but the image
-    will be identical (just twice as large) as the 16" x 9" image.
+    will be identical (just twice as wide and twice as high) as the 16" x 9" image.
     """
     pads = expand_pad_arg(pad)
 

svg_ultralight/query.py

@@ -63,7 +63,7 @@ def _fill_ids(*elem_args: EtreeElement) -> None:
 
 
 def _normalize_views(elem: EtreeElement) -> None:
-    """Create a square viewbox for any element with an svg tag.
+    """Create a square viewBox for any element with an svg tag.
 
     :param elem: an etree element
 
@@ -110,51 +110,61 @@ def map_elems_to_bounding_boxes(
         IMPORTANT: path cannot end with ``.exe``.
         Use something like ``"C:\\Program Files\\Inkscape\\inkscape"``
     :param elem_args: xml element (written to a temporary file then queried)
-    :return: svg elements (and a bounding box for the entire svg file as ``svg``)
-        mapped to BoundingBox(x, y, width, height)
-    :effects: temporarily adds an id attribute if any ids are missing. Non-unique ids
-        will break this function.
-
-    Bounding boxes are relative to svg viewbox. If viewbox x == -10,
+    :return: input svg elements and any descendents of those elements mapped
+        `BoundingBox(x, y, width, height)`
+        So return dict keys are the input elements themselves with one exception: a
+        string key, "svg", is mapped to a bounding box around all input elements.
+    :effects: temporarily adds an id attribute if any ids are missing. These are
+        removed if the function completes. Existing, non-unique ids will break this
+        function.
+
+    Bounding boxes are relative to svg viewBox. If, for instance, viewBox x == -10,
     all bounding-box x values will be offset -10. So, everything is wrapped in a root
-    element with a "normalized" viewbox, (viewbox=(0, 0, 1, 1)) then any child root
-    elements ("child root elements" sounds wrong, but it works) viewboxes are
-    normalized as well. This works even with a root element around a root element, so
-    input elem_args can be root elements or "normal" elements like "rect", "circle",
-    or "text" or a mixture of both.
+    element, `envelope` with a "normalized" viewBox, `viewBox=(0, 0, 1, 1)`. That
+    way, any child root elements ("child root elements" sounds wrong, but it works)
+    viewBoxes are normalized as well. This works even with a root element around a
+    root element, so input elem_args can be root elements or "normal" elements like
+    "rect", "circle", or "text" or a mixture of both. Bounding boxes output here will
+    work as expected in any viewBox.
 
     The ``inkscape --query-all svg`` call will return a tuple:
 
     (b'svg1,x,y,width,height\\r\\elem1,x,y,width,height\\r\\n', None)
     where x, y, width, and height are strings of numbers.
 
-    This calls the command and formats the output into a dictionary.
-
-    Scaling arguments ("width", "height") to new_svg_root transform the bounding
-    boxes in non-useful ways.  This copies all elements except the root element in to
-    a (0, 0, 1, 1) root. This will put the boxes where you'd expect them to be, no
-    matter what root you use.
+    This calls the command and formats the output into a dictionary. There is a
+    little extra complexity to handle cases with duplicate elements. Inkscape will
+    map bounding boxes to element ids *if* those ids are unique. If Inkscape
+    encounters a duplicate ID, Inkscape will map the bounding box of that element to
+    a string like "rect1". If you pass unequal elements with the same id, I can't
+    help you, but you might pass the same element multiple times. If you do this,
+    Inkscape will find a bounding box for each occurrence, map the first occurrence
+    to the id, then map subsequent occurrences to a string like "rect1". This
+    function will handle that.
     """
     if not elem_args:
         return {}
     _fill_ids(*elem_args)
-    envelope = _envelop_copies(*elem_args)
 
+    envelope = _envelop_copies(*elem_args)
     with NamedTemporaryFile(mode="wb", delete=False, suffix=".svg") as svg_file:
         svg = write_svg(svg_file, envelope)
     with Popen(f'"{inkscape}" --query-all {svg}', stdout=PIPE) as bb_process:
         bb_data = str(bb_process.communicate()[0])[2:-1]
     os.unlink(svg_file.name)
+
     bb_strings = re.split(r"[\\r]*\\n", bb_data)[:-1]
     id2bbox = dict(map(_split_bb_string, bb_strings))
 
     elem2bbox: dict[EtreeElement | Literal["svg"], BoundingBox] = {}
     for elem in _iter_elems(*elem_args):
-        elem2bbox[elem] = id2bbox.pop(elem.attrib["id"])
-        if elem.attrib["id"].startswith(_TEMP_ID_PREFIX):
+        elem_id = elem.attrib.get("id")
+        if not (elem_id):  # id removed in a previous loop
+            continue
+        elem2bbox[elem] = id2bbox[elem_id]
+        if elem_id.startswith(_TEMP_ID_PREFIX):
             del elem.attrib["id"]
-    ((_, scene_bbox),) = id2bbox.items()
-    elem2bbox["svg"] = scene_bbox
+    elem2bbox["svg"] = BoundingBox.merged(*id2bbox.values())
     return elem2bbox
 
 

svg_ultralight/transformations.py

@@ -52,13 +52,19 @@ def mat_dot(mat1: _Matrix, mat2: _Matrix) -> _Matrix:
     return (aa, bb, cc, dd, ee, ff)
 
 
-def mat_apply(mat1: _Matrix, mat2: tuple[float, float]) -> tuple[float, float]:
+def mat_apply(matrix: _Matrix, point: 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 mat1: transformation matrix (a, b, c, d, e, f) describing a 3x3 matrix
+        with an implied third row of (0, 0, 1)
+        [[a, c, e], [b, d, f], [0, 0, 1]]
     :param mat2: point (x, y)
     """
-    return mat1[0] * mat2[0] + mat1[4], mat1[3] * mat2[1] + mat1[5]
+    a, b, c, d, e, f = matrix
+    x, y = point
+    result_x = a * x + c * y + e
+    result_y = b * x + d * y + f
+    return result_x, result_y
 
 
 def mat_invert(tmat: _Matrix) -> _Matrix:
@@ -99,7 +105,7 @@ def get_transform_matrix(elem: EtreeElement) -> _Matrix:
 def new_transformation_matrix(
     transformation: _Matrix | None = None,
     *,
-    scale: float | None = None,
+    scale: tuple[float, float] | None = None,
     dx: float | None = None,
     dy: float | None = None,
 ) -> _Matrix:
@@ -109,10 +115,10 @@ def new_transformation_matrix(
     svg-style transformation matrix.
     """
     transformation = transformation or (1, 0, 0, 1, 0, 0)
-    scale = scale or 1
+    scale = scale or (1, 1)
     dx = dx or 0
     dy = dy or 0
-    return mat_dot((scale, 0, 0, scale, dx, dy), transformation)
+    return mat_dot((scale[0], 0, 0, scale[1], dx, dy), transformation)
 
 
 def transform_element(elem: EtreeElement, matrix: _Matrix) -> EtreeElement:

{svg_ultralight-0.38.0.dist-info → svg_ultralight-0.39.0.dist-info}/METADATA

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

{svg_ultralight-0.38.0.dist-info → svg_ultralight-0.39.0.dist-info}/RECORD

@@ -2,28 +2,28 @@ svg_ultralight/__init__.py,sha256=wUc79mKsG6lGZ1xaYijyJ4Sm9lG5-5XgRArVsCI0niY,25
 svg_ultralight/animate.py,sha256=JSrBm-59BcNXDF0cGgl4-C89eBunjevZnwZxIWt48TU,1112
 svg_ultralight/image_ops.py,sha256=PXN_p5GX91UTvhnwwU-bPuj6WzM9wCx1SqfzR5icNnQ,4686
 svg_ultralight/inkscape.py,sha256=tVFPtwsUcGKGODmYhC9IdGLyT7OAeNCVsDN0hPBSSgg,9194
-svg_ultralight/layout.py,sha256=FgR45FsHax4xDjGkk9HEVW4OcwhtM8aqw2JUdZs_m7Q,12326
+svg_ultralight/layout.py,sha256=7LV2I3u4EhqSc6ASvgwDtTZyV-Y1qt2wtvRtH2uKVAE,12799
 svg_ultralight/main.py,sha256=VA7tVMO7fiRI_JkEGaH7UFgzJ5YIbHKx4VHfMnT50hI,7446
 svg_ultralight/metadata.py,sha256=xaIfqhKu52Dl4JOrRlpUsWkkE7Umw8j5Z4waFTli-kI,4234
 svg_ultralight/nsmap.py,sha256=y63upO78Rr-JJT56RWWZuyrsILh6HPoY4GhbYnK1A0g,1244
 svg_ultralight/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-svg_ultralight/query.py,sha256=SC8E-7UejzbFvFaYryWVM9uups0rI1AgBY7L8-421Zw,10229
+svg_ultralight/query.py,sha256=wR8oixRYA489k03RU5apXaoami2KvYl8BKmwypQGTi0,10972
 svg_ultralight/root_elements.py,sha256=E_H7HXk0M5F3IyFVOxO8PQmhww1-sHTzJhx8hBJPZvg,2911
 svg_ultralight/string_conversion.py,sha256=7gaUWEJptAVZawlvoAJ7JoP996nALoJrAByM3o219Tc,7462
-svg_ultralight/transformations.py,sha256=tqexXWmnjS2uRdxfedYIHVAP3RPgGHhFJ62OBY1fMjk,4078
+svg_ultralight/transformations.py,sha256=h1GUD4hvo10ugnSwShDmrwzF048yfug7lCWqCzOTxWs,4296
 svg_ultralight/unit_conversion.py,sha256=g07nhzXdjPvGcJmkhLdFbeDLrSmbI8uFoVgPo7G62Bg,9258
 svg_ultralight/bounding_boxes/__init__.py,sha256=qUEn3r4s-1QNHaguhWhhaNfdP4tl_B6YEqxtiTFuzhQ,78
-svg_ultralight/bounding_boxes/bound_helpers.py,sha256=-0PrWaFVh9BElL7_FBATwAe1w4WU-ReUbNk5gmbgZfI,7296
-svg_ultralight/bounding_boxes/supports_bounds.py,sha256=fbHV6mGdeIVV3lS15vBKSrHiHKR7DMg4K5X__4LLmCE,4569
-svg_ultralight/bounding_boxes/type_bound_collection.py,sha256=nsgzLlOb_X_OX6uw6RpbTBLuFtma-GY832vJXGTFEG4,2623
-svg_ultralight/bounding_boxes/type_bound_element.py,sha256=irJlwy9Xy6OfJkyVVGq1t2Mv2JIggRyr7972KE3sfL4,2281
-svg_ultralight/bounding_boxes/type_bounding_box.py,sha256=cDrMp6uwaA--KJIQS2puG10qh8n3TBmiscg-cfk1f3w,16149
-svg_ultralight/bounding_boxes/type_padded_text.py,sha256=YEn8aV6urhXl2Pl4DA3W90cWdXiX7abDweQEohf3ve4,14890
+svg_ultralight/bounding_boxes/bound_helpers.py,sha256=LFkVsdYFKYCnEL6vLvEa_5cfu8D44ZGYeEEb7_0MnC0,7146
+svg_ultralight/bounding_boxes/supports_bounds.py,sha256=Yi696oJ393y29vql0U6kLMR3soSggLB3_wSACHppoJo,4505
+svg_ultralight/bounding_boxes/type_bound_collection.py,sha256=yW-gwehTrLhgG4Rk-wd6XWP0oLj7Yh_Njrudm8Dn1fk,2637
+svg_ultralight/bounding_boxes/type_bound_element.py,sha256=v-XwW1bxA3tT0CzLWOrRO5EHtLA3ivds8DyA5KFju6w,2196
+svg_ultralight/bounding_boxes/type_bounding_box.py,sha256=XsjM6nR5bKRLFa8z1U84GIC-YbleKoXa0s-UScz9Ewo,13621
+svg_ultralight/bounding_boxes/type_padded_text.py,sha256=fiDZoHIaQbGK8ETrPRa2wa5ykbdFBeeDHw9zGqKtD6E,10674
 svg_ultralight/constructors/__init__.py,sha256=XLOInLhzMERWNnFAs-itMs-OZrBOpvQthZJ2T5duqBE,327
 svg_ultralight/constructors/new_element.py,sha256=hRUW2hR_BTkthEqPClYV7-IeFe9iv2zwb6ehp1k1xDk,3475
 svg_ultralight/strings/__init__.py,sha256=BMGhF1pulscIgkiYvZLr6kPRR0L4lW0jUNFxkul4_EM,295
 svg_ultralight/strings/svg_strings.py,sha256=FQNxNmMkR2M-gCFo_woQKXLgCHi3ncUlRMiaRR_a9nQ,1978
-svg_ultralight-0.38.0.dist-info/METADATA,sha256=pq9i97xHJDcgb_Q4H8-bcwEmwkVtrKj8zntmBQeOHwM,8971
-svg_ultralight-0.38.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-svg_ultralight-0.38.0.dist-info/top_level.txt,sha256=se-6yqM_0Yg5orJKvKWdjQZ4iR4G_EjhL7oRgju-fdY,15
-svg_ultralight-0.38.0.dist-info/RECORD,,
+svg_ultralight-0.39.0.dist-info/METADATA,sha256=--QD3_OuduOUZx2fsCx6FsgTaDAuPAFHkkeKxCKY5Dw,8971
+svg_ultralight-0.39.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+svg_ultralight-0.39.0.dist-info/top_level.txt,sha256=se-6yqM_0Yg5orJKvKWdjQZ4iR4G_EjhL7oRgju-fdY,15
+svg_ultralight-0.39.0.dist-info/RECORD,,

{svg_ultralight-0.38.0.dist-info → svg_ultralight-0.39.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any