svg-ultralight 0.48.0__py3-none-any.whl → 0.50.2__py3-none-any.whl

svg_ultralight/bounding_boxes/supports_bounds.py

@@ -1,166 +1,166 @@
-"""A protocol for objects that support bounds.
-
-This module defines a protocol for objects that can have bounds. Existing and
-future types like BoundingBox, BoundElement, and PaddedText can be arranged,
-aligned, and uniformly scaled by reading and setting their bounds. This is the
-interface needed to support such alignment.
-
-Attributes:
-    x (float): The minimum x coordinate. x2 (float): The maximum x coordinate.
-    cx (float): The center x coordinate. y (float): The minimum y coordinate. y2
-    (float): The maximum y coordinate. 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.
-
-:author: Shay Hill
-:created: 2023-02-15
-"""
-
-from __future__ import annotations
-
-from typing import Protocol
-
-_Matrix = tuple[float, float, float, float, float, float]
-
-
-class SupportsBounds(Protocol):
-    """Protocol for objects that can have bounds.
-
-    Attributes:
-        transformation (_Matrix): An svg-style transformation matrix.
-        transform (method): Apply a transformation to the object.
-        x (float): The minimum x coordinate.
-        x2 (float): The maximum x coordinate.
-        cx (float): The center x coordinate.
-        y (float): The minimum y coordinate.
-        y2 (float): The maximum y coordinate.
-        cy (float): The center y coordinate.
-        width (float): The width of the object.
-        height(float): The height 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
-    scale would modify the x and y coordinates. If you want to scale an object,
-    set width and height.
-    """
-
-    def transform(
-        self,
-        transformation: _Matrix | None = None,
-        *,
-        scale: tuple[float, float] | float | None = None,
-        dx: float | None = None,
-        dy: float | None = None,
-    ):
-        """Apply a transformation to the object."""
-        ...
-
-    @property
-    def x(self) -> float:
-        """Return minimum x coordinate."""
-        ...
-
-    @x.setter
-    def x(self, value: float):
-        """Set minimum x coordinate.
-
-        :param value: The minimum x coordinate.
-        """
-
-    @property
-    def x2(self) -> float:
-        """Return maximum x coordinate."""
-        ...
-
-    @x2.setter
-    def x2(self, value: float):
-        """Set maximum x coordinate.
-
-        :param value: The maximum x coordinate.
-        """
-
-    @property
-    def cx(self) -> float:
-        """Return center x coordinate."""
-        ...
-
-    @cx.setter
-    def cx(self, value: float):
-        """Set center x coordinate.
-
-        :param value: The center x coordinate.
-        """
-
-    @property
-    def y(self) -> float:
-        """Return minimum y coordinate."""
-        ...
-
-    @y.setter
-    def y(self, value: float):
-        """Set minimum y coordinate.
-
-        :param value: The minimum y coordinate.
-        """
-
-    @property
-    def y2(self) -> float:
-        """Return maximum y coordinate."""
-        ...
-
-    @y2.setter
-    def y2(self, value: float):
-        """Set maximum y coordinate.
-
-        :param value: The maximum y coordinate.
-        """
-
-    @property
-    def cy(self) -> float:
-        """Return center y coordinate."""
-        ...
-
-    @cy.setter
-    def cy(self, value: float):
-        """Set center y coordinate.
-
-        :param value: The center y coordinate.
-        """
-
-    @property
-    def width(self) -> float:
-        """Return width of the object."""
-        ...
-
-    @width.setter
-    def width(self, value: float):
-        """Set width of the object.
-
-        :param value: The width of the object.
-        """
-
-    @property
-    def height(self) -> float:
-        """Return height of the object."""
-        ...
-
-    @height.setter
-    def height(self, value: float):
-        """Set height of the object.
-
-        :param value: The height of the object.
-        """
-
-    @property
-    def scale(self) -> tuple[float, float]:
-        """Return scale of the object."""
-        ...
-
-    @scale.setter
-    def scale(self, value: tuple[float, float]):
-        """Return scale of the object.
-
-        :param value: The scale of the object.
-        """
-        ...
+"""A protocol for objects that support bounds.
+
+This module defines a protocol for objects that can have bounds. Existing and
+future types like BoundingBox, BoundElement, and PaddedText can be arranged,
+aligned, and uniformly scaled by reading and setting their bounds. This is the
+interface needed to support such alignment.
+
+Attributes:
+    x (float): The minimum x coordinate. x2 (float): The maximum x coordinate.
+    cx (float): The center x coordinate. y (float): The minimum y coordinate. y2
+    (float): The maximum y coordinate. 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.
+
+:author: Shay Hill
+:created: 2023-02-15
+"""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+_Matrix = tuple[float, float, float, float, float, float]
+
+
+class SupportsBounds(Protocol):
+    """Protocol for objects that can have bounds.
+
+    Attributes:
+        transformation (_Matrix): An svg-style transformation matrix.
+        transform (method): Apply a transformation to the object.
+        x (float): The minimum x coordinate.
+        x2 (float): The maximum x coordinate.
+        cx (float): The center x coordinate.
+        y (float): The minimum y coordinate.
+        y2 (float): The maximum y coordinate.
+        cy (float): The center y coordinate.
+        width (float): The width of the object.
+        height(float): The height 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
+    scale would modify the x and y coordinates. If you want to scale an object,
+    set width and height.
+    """
+
+    def transform(
+        self,
+        transformation: _Matrix | None = None,
+        *,
+        scale: tuple[float, float] | float | None = None,
+        dx: float | None = None,
+        dy: float | None = None,
+    ) -> None:
+        """Apply a transformation to the object."""
+        ...
+
+    @property
+    def x(self) -> float:
+        """Return minimum x coordinate."""
+        ...
+
+    @x.setter
+    def x(self, value: float) -> None:
+        """Set minimum x coordinate.
+
+        :param value: The minimum x coordinate.
+        """
+
+    @property
+    def x2(self) -> float:
+        """Return maximum x coordinate."""
+        ...
+
+    @x2.setter
+    def x2(self, value: float) -> None:
+        """Set maximum x coordinate.
+
+        :param value: The maximum x coordinate.
+        """
+
+    @property
+    def cx(self) -> float:
+        """Return center x coordinate."""
+        ...
+
+    @cx.setter
+    def cx(self, value: float) -> None:
+        """Set center x coordinate.
+
+        :param value: The center x coordinate.
+        """
+
+    @property
+    def y(self) -> float:
+        """Return minimum y coordinate."""
+        ...
+
+    @y.setter
+    def y(self, value: float) -> None:
+        """Set minimum y coordinate.
+
+        :param value: The minimum y coordinate.
+        """
+
+    @property
+    def y2(self) -> float:
+        """Return maximum y coordinate."""
+        ...
+
+    @y2.setter
+    def y2(self, value: float) -> None:
+        """Set maximum y coordinate.
+
+        :param value: The maximum y coordinate.
+        """
+
+    @property
+    def cy(self) -> float:
+        """Return center y coordinate."""
+        ...
+
+    @cy.setter
+    def cy(self, value: float) -> None:
+        """Set center y coordinate.
+
+        :param value: The center y coordinate.
+        """
+
+    @property
+    def width(self) -> float:
+        """Return width of the object."""
+        ...
+
+    @width.setter
+    def width(self, value: float) -> None:
+        """Set width of the object.
+
+        :param value: The width of the object.
+        """
+
+    @property
+    def height(self) -> float:
+        """Return height of the object."""
+        ...
+
+    @height.setter
+    def height(self, value: float) -> None:
+        """Set height of the object.
+
+        :param value: The height of the object.
+        """
+
+    @property
+    def scale(self) -> tuple[float, float]:
+        """Return scale of the object."""
+        ...
+
+    @scale.setter
+    def scale(self, value: tuple[float, float]) -> None:
+        """Return scale of the object.
+
+        :param value: The scale of the object.
+        """
+        ...

svg_ultralight/bounding_boxes/type_bound_collection.py

@@ -1,71 +1,71 @@
-"""A class to hold a list of bound elements and transform them together.
-
-:author: Shay Hill
-:created: 2024-05-05
-"""
-
-from __future__ import annotations
-
-import dataclasses
-from typing import TYPE_CHECKING
-
-from lxml.etree import _Element as EtreeElement  # pyright: ignore[reportPrivateUsage]
-
-from svg_ultralight.bounding_boxes.bound_helpers import new_bbox_union
-from svg_ultralight.bounding_boxes.type_bounding_box import HasBoundingBox
-from svg_ultralight.transformations import new_transformation_matrix, transform_element
-
-if TYPE_CHECKING:
-    from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
-    from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
-
-_Matrix = tuple[float, float, float, float, float, float]
-
-
-@dataclasses.dataclass
-class BoundCollection(HasBoundingBox):
-    """A class to hold a list of bound elements and transform them together.
-
-    This will transform the individual elements in place.
-    """
-
-    blems: list[SupportsBounds | EtreeElement] = dataclasses.field(init=False)
-    bbox: BoundingBox = dataclasses.field(init=False)
-
-    def __init__(self, *blems: SupportsBounds | EtreeElement) -> None:
-        """Initialize the bound collection.
-
-        :param blems: bound elements to be transformed together
-        """
-        self.blems = list(blems)
-        self.bbox = new_bbox_union(*self.blems)
-
-    def transform(
-        self,
-        transformation: _Matrix | None = None,
-        *,
-        scale: tuple[float, float] | float | None = None,
-        dx: float | None = None,
-        dy: float | None = None,
-    ):
-        """Transform each bound element in self.blems.
-
-        :param transformation: 2D transformation matrix
-        :param scale: optional scale factor
-        :param dx: optional x translation
-        :param dy: optional y translation
-
-        Keep track of all compounding transformations in order to have a value for
-        self.scale (required for membersh and to provide access to cumulative
-        transforms should this be useful for any reason. This means all
-        transformations must be applied to two bounding boxes: a persistant bbox to
-        keep track of the scale property and a temporary bbox to isolate each
-        transformation.
-        """
-        tmat = new_transformation_matrix(transformation, scale=scale, dx=dx, dy=dy)
-        self.bbox.transform(tmat)
-        for blem in self.blems:
-            if isinstance(blem, EtreeElement):
-                _ = transform_element(blem, tmat)
-            else:
-                blem.transform(tmat)
+"""A class to hold a list of bound elements and transform them together.
+
+:author: Shay Hill
+:created: 2024-05-05
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import TYPE_CHECKING
+
+from lxml.etree import _Element as EtreeElement  # pyright: ignore[reportPrivateUsage]
+
+from svg_ultralight.bounding_boxes.bound_helpers import new_bbox_union
+from svg_ultralight.bounding_boxes.type_bounding_box import HasBoundingBox
+from svg_ultralight.transformations import new_transformation_matrix, transform_element
+
+if TYPE_CHECKING:
+    from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
+    from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
+
+_Matrix = tuple[float, float, float, float, float, float]
+
+
+@dataclasses.dataclass
+class BoundCollection(HasBoundingBox):
+    """A class to hold a list of bound elements and transform them together.
+
+    This will transform the individual elements in place.
+    """
+
+    blems: list[SupportsBounds | EtreeElement] = dataclasses.field(init=False)
+    bbox: BoundingBox = dataclasses.field(init=False)
+
+    def __init__(self, *blems: SupportsBounds | EtreeElement) -> None:
+        """Initialize the bound collection.
+
+        :param blems: bound elements to be transformed together
+        """
+        self.blems = list(blems)
+        self.bbox = new_bbox_union(*self.blems)
+
+    def transform(
+        self,
+        transformation: _Matrix | None = None,
+        *,
+        scale: tuple[float, float] | float | None = None,
+        dx: float | None = None,
+        dy: float | None = None,
+    ) -> None:
+        """Transform each bound element in self.blems.
+
+        :param transformation: 2D transformation matrix
+        :param scale: optional scale factor
+        :param dx: optional x translation
+        :param dy: optional y translation
+
+        Keep track of all compounding transformations in order to have a value for
+        self.scale (required for membersh and to provide access to cumulative
+        transforms should this be useful for any reason. This means all
+        transformations must be applied to two bounding boxes: a persistant bbox to
+        keep track of the scale property and a temporary bbox to isolate each
+        transformation.
+        """
+        tmat = new_transformation_matrix(transformation, scale=scale, dx=dx, dy=dy)
+        self.bbox.transform(tmat)
+        for blem in self.blems:
+            if isinstance(blem, EtreeElement):
+                _ = transform_element(blem, tmat)
+            else:
+                blem.transform(tmat)

svg_ultralight/bounding_boxes/type_bound_element.py

@@ -1,65 +1,65 @@
-"""An element tied to a BoundingBox instance.
-
-Take an element, associate it to a BoundingBox instance, transform the BoundingBox
-instance. The element will be transformed accordingly.
-
-It is critical to remember that self.elem is a reference. It is not necessary to
-access self.elem through the BoundElement instance. Earlier and later references will
-all be updated as the BoundElement instance is updated.
-
-:author: Shay Hill
-:created: 2022-12-09
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from svg_ultralight.bounding_boxes.type_bounding_box import HasBoundingBox
-from svg_ultralight.transformations import new_transformation_matrix, transform_element
-
-if TYPE_CHECKING:
-    from lxml.etree import (
-        _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
-    )
-
-    from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
-
-_Matrix = tuple[float, float, float, float, float, float]
-
-
-class BoundElement(HasBoundingBox):
-    """An element with a bounding box.
-
-    Updates the element when x, y, x2, y2, width, or height are set.
-
-    Can access these BoundingBox attributes (plus scale) as attributes of this object.
-    """
-
-    def __init__(self, element: EtreeElement, bounding_box: BoundingBox) -> None:
-        """Initialize a BoundElement instance.
-
-        :param element: the element to be bound
-        :param bounding_box: the bounding box around the element
-        """
-        self.elem = element
-        self.bbox = bounding_box
-
-    def transform(
-        self,
-        transformation: _Matrix | None = None,
-        *,
-        scale: tuple[float, float] | 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
-        """
-        tmat = new_transformation_matrix(transformation, scale=scale, dx=dx, dy=dy)
-        self.bbox.transform(tmat)
-        _ = transform_element(self.elem, tmat)
+"""An element tied to a BoundingBox instance.
+
+Take an element, associate it to a BoundingBox instance, transform the BoundingBox
+instance. The element will be transformed accordingly.
+
+It is critical to remember that self.elem is a reference. It is not necessary to
+access self.elem through the BoundElement instance. Earlier and later references will
+all be updated as the BoundElement instance is updated.
+
+:author: Shay Hill
+:created: 2022-12-09
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from svg_ultralight.bounding_boxes.type_bounding_box import HasBoundingBox
+from svg_ultralight.transformations import new_transformation_matrix, transform_element
+
+if TYPE_CHECKING:
+    from lxml.etree import (
+        _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
+    )
+
+    from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
+
+_Matrix = tuple[float, float, float, float, float, float]
+
+
+class BoundElement(HasBoundingBox):
+    """An element with a bounding box.
+
+    Updates the element when x, y, x2, y2, width, or height are set.
+
+    Can access these BoundingBox attributes (plus scale) as attributes of this object.
+    """
+
+    def __init__(self, element: EtreeElement, bounding_box: BoundingBox) -> None:
+        """Initialize a BoundElement instance.
+
+        :param element: the element to be bound
+        :param bounding_box: the bounding box around the element
+        """
+        self.elem = element
+        self.bbox = bounding_box
+
+    def transform(
+        self,
+        transformation: _Matrix | None = None,
+        *,
+        scale: tuple[float, float] | float | None = None,
+        dx: float | None = None,
+        dy: float | None = 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
+        """
+        tmat = new_transformation_matrix(transformation, scale=scale, dx=dx, dy=dy)
+        self.bbox.transform(tmat)
+        _ = transform_element(self.elem, tmat)