svg-ultralight 0.32.2__py3-none-any.whl → 0.34.0__py3-none-any.whl

svg_ultralight/__init__.py

@@ -8,6 +8,10 @@ from svg_ultralight.bounding_boxes.bound_helpers import (
     new_bbox_union,
     new_bound_union,
     new_element_union,
+    cut_bbox,
+    pad_bbox,
+    bbox_dict,
+    new_bbox_rect,
 )
 from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
 from svg_ultralight.bounding_boxes.type_bound_collection import BoundCollection
@@ -20,7 +24,6 @@ from svg_ultralight.constructors.new_element import (
     new_sub_element,
     update_element,
 )
-from svg_ultralight.import_svg import import_svg
 from svg_ultralight.inkscape import (
     write_pdf,
     write_pdf_from_svg,
@@ -31,7 +34,12 @@ from svg_ultralight.inkscape import (
 from svg_ultralight.main import new_svg_root, write_svg
 from svg_ultralight.metadata import new_metadata
 from svg_ultralight.nsmap import NSMAP, new_qname
-from svg_ultralight.query import pad_text
+from svg_ultralight.query import (
+    get_bounding_box,
+    get_bounding_boxes,
+    pad_text,
+    clear_svg_ultralight_cache,
+)
 from svg_ultralight.root_elements import new_svg_root_around_bounds
 from svg_ultralight.string_conversion import (
     format_attr_dict,
@@ -53,15 +61,20 @@ __all__ = [
     "NSMAP",
     "PaddedText",
     "SupportsBounds",
+    "bbox_dict",
+    "clear_svg_ultralight_cache",
+    "cut_bbox",
     "deepcopy_element",
     "format_attr_dict",
     "format_number",
     "format_numbers",
     "format_numbers_in_string",
-    "import_svg",
+    "get_bounding_box",
+    "get_bounding_boxes",
     "mat_apply",
     "mat_dot",
     "mat_invert",
+    "new_bbox_rect",
     "new_bbox_union",
     "new_bound_union",
     "new_element",
@@ -71,6 +84,7 @@ __all__ = [
     "new_sub_element",
     "new_svg_root",
     "new_svg_root_around_bounds",
+    "pad_bbox",
     "pad_text",
     "transform_element",
     "update_element",

svg_ultralight/animate.py

@@ -34,7 +34,7 @@ def write_gif(
     :param loop: how many times to loop gif. 0 -> forever
     :effects: write file to gif
     """
-    images = [Image.open(x) for x in pngs]  # type: ignore
-    images[0].save(  # type: ignore
+    images = [Image.open(x) for x in pngs]
+    images[0].save(
         gif, save_all=True, append_images=images[1:], duration=duration, loop=loop
     )

svg_ultralight/bounding_boxes/bound_helpers.py

@@ -95,3 +95,77 @@ def new_bound_union(*blems: SupportsBounds | EtreeElement) -> BoundElement:
     group = new_element_union(*blems)
     bbox = new_bbox_union(*blems)
     return BoundElement(group, bbox)
+
+
+def _expand_pad(pad: float | tuple[float, ...]) -> tuple[float, float, float, float]:
+    """Expand a float pad argument into a 4-tuple."""
+    if isinstance(pad, (int, float)):
+        return pad, pad, pad, pad
+    if len(pad) == 1:
+        return pad[0], pad[0], pad[0], pad[0]
+    if len(pad) == 2:
+        return pad[0], pad[1], pad[0], pad[1]
+    if len(pad) == 3:
+        return pad[0], pad[1], pad[2], pad[1]
+    return pad[0], pad[1], pad[2], pad[3]
+
+
+def cut_bbox(
+    bbox: SupportsBounds,
+    *,
+    x: float | None = None,
+    y: float | None = None,
+    x2: float | None = None,
+    y2: float | None = None,
+) -> BoundingBox:
+    """Return a new bounding box with updated limits.
+
+    :param bbox: the original bounding box or bounded element.
+    :param x: the new x-coordinate.
+    :param y: the new y-coordinate.
+    :param x2: the new x2-coordinate.
+    :param y2: the new y2-coordinate.
+    :return: a new bounding box with the updated limits.
+    """
+    x = bbox.x if x is None else x
+    y = bbox.y if y is None else y
+    x2 = bbox.x2 if x2 is None else x2
+    y2 = bbox.y2 if y2 is None else y2
+    width = x2 - x
+    height = y2 - y
+    return BoundingBox(x, y, width, height)
+
+
+def pad_bbox(bbox: SupportsBounds, pad: float | tuple[float, ...]) -> BoundingBox:
+    """Return a new bounding box with padding.
+
+    :param bbox: the original bounding box or bounded element.
+    :param pad: the padding to apply.
+        If a single number, the same padding will be applied to all sides.
+        If a tuple, will be applied per css rules.
+        len = 1 : 0, 0, 0, 0
+        len = 2 : 0, 1, 0, 1
+        len = 3 : 0, 1, 2, 1
+        len = 4 : 0, 1, 2, 3
+    :return: a new bounding box with padding applied.
+    """
+    t, r, b, l = _expand_pad(pad)
+    return cut_bbox(bbox, x=bbox.x - l, y=bbox.y - t, x2=bbox.x2 + r, y2=bbox.y2 + b)
+
+
+def bbox_dict(bbox: SupportsBounds) -> dict[str, float]:
+    """Return a dictionary representation of a bounding box.
+
+    :param bbox: the bounding box or bound element from which to extract dimensions.
+    :return: a dictionary with keys x, y, width, and height.
+    """
+    return {"x": bbox.x, "y": bbox.y, "width": bbox.width, "height": bbox.height}
+
+
+def new_bbox_rect(bbox: BoundingBox, **kwargs: float | str) -> EtreeElement:
+    """Return a new rect element with the same dimensions as the bounding box.
+
+    :param bbox: the bounding box or bound element from which to extract dimensions.
+    :param kwargs: additional attributes for the rect element.
+    """
+    return new_element("rect", **bbox_dict(bbox), **kwargs)

svg_ultralight/layout.py

@@ -43,7 +43,10 @@ def expand_pad_arg(pad: PadArg) -> tuple[float, float, float, float]:
         return expand_pad_arg([pad])
     as_ms = [m if isinstance(m, Measurement) else Measurement(m) for m in pad]
     as_units = [m.value for m in as_ms]
-    as_units = [as_units[i % len(as_units)] for i in range(4)]
+    if len(as_units) == 3:
+        as_units = [*as_units, as_units[1]]
+    else:
+        as_units = [as_units[i % len(as_units)] for i in range(4)]
     return as_units[0], as_units[1], as_units[2], as_units[3]
 
 
@@ -99,7 +102,7 @@ def _infer_scale(
     * print_h == 0 / viewbox_h > 0
 
     The print area is invalid, but there is special handling for this. Interpret
-    viewbox units as print_w.native_unit and determine print area from viewbox area 1
+    viewbox units as print_w.native_unit and determe print area from viewbox area 1
     to 1.
 
         >>> _infer_scale(Measurement("in"), Measurement("in"), 1, 2)

svg_ultralight/metadata.py

@@ -65,8 +65,8 @@ def _wrap_bag(title: str) -> EtreeElement:
     """
     items = title.split(",")
     agent = new_element(new_qname("rdf", "Bag"))
-    for title in items:
-        _ = new_sub_element(agent, new_qname("rdf", "li"), text=title)
+    for title_item in items:
+        _ = new_sub_element(agent, new_qname("rdf", "li"), text=title_item)
     return agent
 
 

svg_ultralight/query.py

@@ -11,24 +11,36 @@ business card). Getting bounding boxes from Inkscape is not exceptionally fast.
 
 from __future__ import annotations
 
+import hashlib
 import os
+import pickle
 import re
 import uuid
+from contextlib import suppress
 from copy import deepcopy
+from pathlib import Path
 from subprocess import PIPE, Popen
-from tempfile import NamedTemporaryFile
+from tempfile import NamedTemporaryFile, TemporaryFile
 from typing import TYPE_CHECKING
+from warnings import warn
+
+from lxml import etree
 
 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, write_svg
 
 if TYPE_CHECKING:
-    from pathlib import Path
 
     from lxml.etree import _Element as EtreeElement  # type: ignore
 
 
+with TemporaryFile() as f:
+    _CACHE_DIR = Path(f.name).parent / "svg_ultralight_cache"
+
+_CACHE_DIR.mkdir(exist_ok=True)
+
+
 def _fill_ids(*elem_args: EtreeElement) -> None:
     """Set the id attribute of an element and all its children. Keep existing ids.
 
@@ -66,8 +78,8 @@ def _envelop_copies(*elem_args: EtreeElement) -> EtreeElement:
     :param elem_args: one or more etree elements
     :return: an etree element enveloping copies of elem_args with all views normalized
     """
-    envelope = new_svg_root(0, 0, 1, 1, id_=f"envelope_{uuid.uuid4()}")
-    envelope.extend(deepcopy(e) for e in elem_args)
+    envelope = new_svg_root(0, 0, 1, 1)
+    envelope.extend([deepcopy(e) for e in elem_args])
     _normalize_views(envelope)
     return envelope
 
@@ -106,6 +118,8 @@ def map_ids_to_bounding_boxes(
     a (0, 0, 1, 1) root. This will put the boxes where you'd expect them to be, no
     matter what root you use.
     """
+    if not elem_args:
+        return {}
     _fill_ids(*elem_args)
     envelope = _envelop_copies(*elem_args)
 
@@ -123,40 +137,82 @@ def map_ids_to_bounding_boxes(
     return id2bbox
 
 
-def get_bounding_box(
+def _hash_elem(elem: EtreeElement) -> str:
+    """Hash an EtreeElement.
+
+    Will match identical (excepting id) elements.
+    """
+    elem_copy = deepcopy(elem)
+    with suppress(KeyError):
+        _ = elem_copy.attrib.pop("id")
+    hash_object = hashlib.sha256(etree.tostring(elem_copy))
+    return hash_object.hexdigest()
+
+
+def _try_bbox_cache(elem_hash: str) -> BoundingBox | None:
+    """Try to load a cached bounding box."""
+    cache_path = _CACHE_DIR / elem_hash
+    if not cache_path.exists():
+        return None
+    try:
+        with cache_path.open("rb") as f:
+            return pickle.load(f)
+    except (EOFError, pickle.UnpicklingError) as e:
+        msg = f"Error loading cache file {cache_path}: {e}"
+        warn(msg)
+    except Exception as e:
+        msg = f"Unexpected error loading cache file {cache_path}: {e}"
+        warn(msg)
+    return None
+
+
+def get_bounding_boxes(
     inkscape: str | Path, *elem_args: EtreeElement
-) -> BoundingBox | tuple[BoundingBox, ...]:
+) -> tuple[BoundingBox, ...]:
     r"""Get bounding box around a single element (or multiple elements).
 
     :param inkscape: path to an inkscape executable on your local file system
         IMPORTANT: path cannot end with ``.exe``.
         Use something like ``"C:\\Program Files\\Inkscape\\inkscape"``
     :param elem_args: xml elements
-    :return: a BoundingBox instance around a single elem or a tuple of BoundingBox
-        instances if multiple elem_args are passed.
+    :return: a BoundingBox instance around a each elem_arg
 
     This will work most of the time, but if you're missing an nsmap, you'll need to
     create an entire xml file with a custom nsmap (using
     `svg_ultralight.new_svg_root`) then call `map_ids_to_bounding_boxes` directly.
     """
-    id2bbox = map_ids_to_bounding_boxes(inkscape, *elem_args)
-    bboxes = [id2bbox[x.get("id", "")] for x in elem_args]
-    if len(bboxes) == 1:
-        return bboxes[0]
-    return tuple(bboxes)
+    elem2hash = {elem: _hash_elem(elem) for elem in elem_args}
+    cached = [_try_bbox_cache(h) for h in elem2hash.values()]
+    if None not in cached:
+        return tuple(filter(None, cached))
 
+    hash2bbox = {h: c for h, c in zip(elem2hash.values(), cached) if c is not None}
+    remainder = [e for e, c in zip(elem_args, cached) if c is None]
+    id2bbox = map_ids_to_bounding_boxes(inkscape, *remainder)
+    for elem in remainder:
+        hash_ = elem2hash[elem]
+        hash2bbox[hash_] = id2bbox[elem.attrib["id"]]
+        with (_CACHE_DIR / hash_).open("wb") as f:
+            pickle.dump(hash2bbox[hash_], f)
+    return tuple(hash2bbox[h] for h in elem2hash.values())
 
-def _replace_text(text_elem: EtreeElement, new_text: str) -> None:
-    """Replace the text in a text element.
 
-    :param text_elem: an etree element with a text tag
-    :param new_text: the new text to insert
+def get_bounding_box(inkscape: str | Path, elem: EtreeElement) -> BoundingBox:
+    r"""Get bounding box around a single element.
 
-    If the text element has tspans, replace each tspan.text with new_text.
+    :param inkscape: path to an inkscape executable on your local file system
+        IMPORTANT: path cannot end with ``.exe``.
+        Use something like ``"C:\\Program Files\\Inkscape\\inkscape"``
+    :param elem: xml element
+    :return: a BoundingBox instance around a single elem
     """
-    text_elem.text = new_text
-    for sub_elem in text_elem:
-        sub_elem.text = new_text
+    return get_bounding_boxes(inkscape, elem)[0]
+
+
+def clear_svg_ultralight_cache() -> None:
+    """Clear all cached bounding boxes."""
+    for cache_file in _CACHE_DIR.glob("*"):
+        cache_file.unlink()
 
 
 def pad_text(
@@ -179,12 +235,10 @@ def pad_text(
     _ = rmargin_ref.attrib.pop("id", None)
     _ = capline_ref.attrib.pop("id", None)
     rmargin_ref.attrib["text-anchor"] = "end"
-    _replace_text(capline_ref, capline_reference_char)
-    id2bbox = map_ids_to_bounding_boxes(inkscape, text_elem, rmargin_ref, capline_ref)
+    capline_ref.text = capline_reference_char
 
-    bbox = id2bbox[text_elem.attrib["id"]]
-    rmargin_bbox = id2bbox[rmargin_ref.attrib["id"]]
-    capline_bbox = id2bbox[capline_ref.attrib["id"]]
+    bboxes = get_bounding_boxes(inkscape, text_elem, rmargin_ref, capline_ref)
+    bbox, rmargin_bbox, capline_bbox = bboxes
 
     tpad = bbox.y - capline_bbox.y
     rpad = -rmargin_bbox.x2

svg_ultralight/transformations.py

@@ -63,6 +63,9 @@ def mat_invert(tmat: _Matrix) -> _Matrix:
     """Invert a 2D transformation matrix in svg format."""
     a, b, c, d, e, f = tmat
     det = a * d - b * c
+    if det == 0:
+        msg = "Matrix is not invertible"
+        raise ValueError(msg)
     return (
         d / det,
         -b / det,

{svg_ultralight-0.32.2.dist-info → svg_ultralight-0.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: svg-ultralight
-Version: 0.32.2
+Version: 0.34.0
 Summary: a sensible way to create svg files with Python
 Author-email: Shay Hill <shay_public@hotmail.com>
 License: MIT
@@ -11,10 +11,10 @@ Requires-Dist: pillow
 Requires-Dist: paragraphs
 Requires-Dist: types-lxml
 Provides-Extra: dev
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: commitizen ; extra == 'dev'
-Requires-Dist: pre-commit ; extra == 'dev'
-Requires-Dist: tox ; extra == 'dev'
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: commitizen; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: tox; extra == "dev"
 
 # svg_ultralight
 

{svg_ultralight-0.32.2.dist-info → svg_ultralight-0.34.0.dist-info}/RECORD

@@ -1,19 +1,18 @@
-svg_ultralight/__init__.py,sha256=k6oHfgxlQLUJmIhkQdBthMTvDqKFsWIp_ZaXxC1bwGM,2250
-svg_ultralight/animate.py,sha256=fE-zRU_uFrZIL9W78fcGz7qmrts8fz5UoWEy7b4xb44,1144
-svg_ultralight/import_svg.py,sha256=TVLbinch2g0RN-OlWyGXoQEO6vc2I_LsMXpOchwTJzE,1548
+svg_ultralight/__init__.py,sha256=jqT_dNNvrSJ3SUndR3e323BbdNlZIEu_iIzmr0iwWNw,2500
+svg_ultralight/animate.py,sha256=JSrBm-59BcNXDF0cGgl4-C89eBunjevZnwZxIWt48TU,1112
 svg_ultralight/inkscape.py,sha256=M8yTxXOu4NlXnhsMycvEJiIDpnDeiZ_bZakJBM38ZoU,9152
-svg_ultralight/layout.py,sha256=RBFJl6cIN6BYqXea5powEl2A4ZIxUJ0mtVoURkSZy_E,12240
+svg_ultralight/layout.py,sha256=FgR45FsHax4xDjGkk9HEVW4OcwhtM8aqw2JUdZs_m7Q,12326
 svg_ultralight/main.py,sha256=6oNkZfD27UMdP-oYqp5agS_IGcYb8NkUZwM9Zdyb3SA,7287
-svg_ultralight/metadata.py,sha256=Mxgxrxe1Ar4kp2wTT29aadxgHNFaaNLABo29jStiWDg,4201
+svg_ultralight/metadata.py,sha256=xR3ObM0QV7OQ90IKvfigR5B6e0JW6GGVGvTlL5NswWI,4211
 svg_ultralight/nsmap.py,sha256=y63upO78Rr-JJT56RWWZuyrsILh6HPoY4GhbYnK1A0g,1244
 svg_ultralight/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-svg_ultralight/query.py,sha256=nsw7L_gH-EPf5LaNu5jtVPihq-qhKs1O2psMU3sTUXU,7732
+svg_ultralight/query.py,sha256=F_yl-zbNQSOFxiuHT4qZ0LqLoYdD36BGTREJady5sBc,9430
 svg_ultralight/root_elements.py,sha256=pt9J6mPrnoTAZVF6vKTZoM_o947I8UCj6MbGcD2JUCk,2869
 svg_ultralight/string_conversion.py,sha256=WEmpf75RJmJ2lfJluagAz2wPsz6wM8XvTEwkq4U0vEc,7353
-svg_ultralight/transformations.py,sha256=64BN_UupvOZk4nbiKLKv09P3j0TPFhH6mKro_3QBqeY,3945
+svg_ultralight/transformations.py,sha256=7-6NNh6xZ45mM_933fMuQfRGpI7q9Qrt5qse9e6FUek,4036
 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=YMClhdekeYbzD_ijXDAer-H3moWKN3lUNnZs1UNFFKc,3458
+svg_ultralight/bounding_boxes/bound_helpers.py,sha256=1l0-Aw3p-9ru7Pm76Wa9K_ufSPRv54NDTG8WsMo_obQ,6125
 svg_ultralight/bounding_boxes/supports_bounds.py,sha256=fbHV6mGdeIVV3lS15vBKSrHiHKR7DMg4K5X__4LLmCE,4569
 svg_ultralight/bounding_boxes/type_bound_collection.py,sha256=b89TM2UsdaeApyjTQeMbx_FG_WcCiLAImEiHiZ6EWPI,2600
 svg_ultralight/bounding_boxes/type_bound_element.py,sha256=9RdxH8osOlAvPdWR0Ww9NsasHLPYFDs-MbydoV48x4E,2239
@@ -23,7 +22,7 @@ svg_ultralight/constructors/__init__.py,sha256=YcnO0iBQc19aL8Iemw0Y452MBMBIT2AN5
 svg_ultralight/constructors/new_element.py,sha256=VtMz9sPn9rMk6rui5Poysy3vezlOaS-tGIcGbu-SXmY,3406
 svg_ultralight/strings/__init__.py,sha256=Zalrf-ThFz7b7xKELx5lb2gOlBgV-6jk_k_EeSdVCVk,295
 svg_ultralight/strings/svg_strings.py,sha256=RYKMxOHq9abbZyGcFqsElBGLrBX-EjjNxln3s_ibi30,1296
-svg_ultralight-0.32.2.dist-info/METADATA,sha256=iXnT_qxV0Qg9tp3XAtv1b7TlxV-xkiYnAkCm700McgA,8871
-svg_ultralight-0.32.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-svg_ultralight-0.32.2.dist-info/top_level.txt,sha256=se-6yqM_0Yg5orJKvKWdjQZ4iR4G_EjhL7oRgju-fdY,15
-svg_ultralight-0.32.2.dist-info/RECORD,,
+svg_ultralight-0.34.0.dist-info/METADATA,sha256=MUbU1KYDWS-PKOOwFfkVJlvghN33UlKxW1ucx4NU3_E,8867
+svg_ultralight-0.34.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+svg_ultralight-0.34.0.dist-info/top_level.txt,sha256=se-6yqM_0Yg5orJKvKWdjQZ4iR4G_EjhL7oRgju-fdY,15
+svg_ultralight-0.34.0.dist-info/RECORD,,

{svg_ultralight-0.32.2.dist-info → svg_ultralight-0.34.0.dist-info}/WHEEL

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

svg_ultralight/import_svg.py

@@ -1,50 +0,0 @@
-"""Import an svg file as a BoundElement.
-
-:author: Shay Hill
-:created: 2024-05-28
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from lxml import etree
-
-from svg_ultralight.bounding_boxes.type_bound_element import BoundElement
-from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
-from svg_ultralight.constructors import new_element
-
-if TYPE_CHECKING:
-    import os
-
-    from lxml.etree import _Element as EtreeElement  # type: ignore
-
-
-def _get_bounds_from_viewbox(root: EtreeElement) -> BoundingBox:
-    """Get the BoundingBox from the viewbox attribute of the root element.
-
-    :param root: The root element of the svg.
-    :return: The BoundingBox of the svg.
-    """
-    viewbox = root.attrib.get("viewBox")
-    if viewbox is None:
-        msg = "SVG file has no viewBox attribute. Failed to create BoundingBox."
-        raise ValueError(msg)
-    x, y, width, height = map(float, viewbox.split())
-    return BoundingBox(x, y, width, height)
-
-
-def import_svg(svg: str | os.PathLike[str]) -> BoundElement:
-    """Import an svg file as a BoundElement.
-
-    :param svg: The path to the svg file.
-    :return: The BoundElement representation of the svg.
-
-    The viewbox of the svg is used to create the BoundingBox of the BoundElement.
-    """
-    tree = etree.parse(svg)
-    root = tree.getroot()
-    bbox = _get_bounds_from_viewbox(root)
-    root_as_elem = new_element("g")
-    root_as_elem.extend(root)
-    return BoundElement(root_as_elem, bbox)