svg-ultralight 0.43.1__tar.gz → 0.45.0__tar.gz

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 ci:
   skip: [pyright]
 
-exclude: "experiments"
+exclude: "tests|experiments"
 
 repos:
 
@@ -42,7 +42,7 @@ repos:
         # files: .pre-commit-config.yaml
 
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: v1.15.0
+  rev: v1.16.1
   hooks:
   - id: mypy
     name: mypy
@@ -89,14 +89,13 @@ repos:
   # S101 Use of `assert` detected
   # S603 `subprocess` call: check for execution of untrusted input
   # PLR2004 Magic value used in comparison
-  # S320 Using `lxml` to parse untrusted data is known to be vulnerable to XML attacks
   # S301 don't use pickle
   # B028 wants explicit stacklevel on warn
   # BLE001 Use of `except Exception:` detected
   # ANN401 Any type disallowed
   # FLY002 Consider f-string instead of string join
   # S311 Standard pseudo-random generator used
-  rev: 'v0.11.11'
+  rev: 'v0.12.2'
   hooks:
     - id: ruff
       name: "ruff-lint"
@@ -104,7 +103,7 @@ repos:
       args:
       - --target-version=py39
       - --select=ALL
-      - --ignore=ANN201,ANN202,B905,COM812,D203,D213,I001,ISC003,N802,N806,PGH003,PLR0913,PTH108,S101,S603,PLR2004,S320,S301,B028,BLE001,ANN401,FLY002,SIM108,S311
+      - --ignore=ANN201,ANN202,B905,COM812,D203,D213,I001,ISC003,N802,N806,PGH003,PLR0913,PTH108,S101,S603,PLR2004,S301,B028,BLE001,ANN401,FLY002,SIM108,S311
       - --fix
       - --fixable=RUF022
     - id: ruff
@@ -114,6 +113,6 @@ repos:
 
 # reads pyproject.toml for additional config
 - repo: https://github.com/RobertCraigie/pyright-python
-  rev: v1.1.398
+  rev: v1.1.403
   hooks:
     - id: pyright

{svg_ultralight-0.43.1/src/svg_ultralight.egg-info → svg_ultralight-0.45.0}/PKG-INFO

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

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "svg-ultralight"
-version = "0.43.1"
+version = "0.45.0"
 description = "a sensible way to create svg files with Python"
 authors = [{ name = "Shay Hill", email = "shay_public@hotmail.com" }]
 license = { text = "MIT" }
@@ -48,9 +48,12 @@ legacy_tox_ini = """
 [tool.ruff.lint.pydocstyle]
 convention = "pep257"
 
+[tool.ruff.lint.per-file-ignores]
+"tests/*.py" = ["S101", "D", "F401"]  # Ignore assertions, docstrings, unused imports in test files
+
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.43.1"
+version = "0.45.0"
 tag_format = "$version"
 version_files = ["pyproject.toml:^version"]
 annotated_tag = true

svg_ultralight-0.45.0/src/svg_ultralight/attrib_hints.py

@@ -0,0 +1,14 @@
+"""Type hints for pass-through arguments to lxml constructors.
+
+:author: Shay Hill
+:created: 2025-07-09
+"""
+
+from collections.abc import Mapping
+from typing import Union
+
+# Types svg_ultralight can format to pass through to lxml constructors.
+ElemAttrib = Union[str, float, None]
+
+# Type for an optional dictionary of element attributes.
+OptionalElemAttribMapping = Union[Mapping[str, ElemAttrib], None]

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/src/svg_ultralight/bounding_boxes/bound_helpers.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from lxml import etree
 from lxml.etree import _Element as EtreeElement  # pyright: ignore[reportPrivateUsage]
 
 from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
@@ -19,14 +20,14 @@ from svg_ultralight.constructors import new_element
 if TYPE_CHECKING:
     import os
 
+    from svg_ultralight.attrib_hints import ElemAttrib
     from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
-from lxml import etree
 
 _Matrix = tuple[float, float, float, float, float, float]
 
 
 def new_element_union(
-    *elems: EtreeElement | SupportsBounds, **attributes: float | str
+    *elems: EtreeElement | SupportsBounds, **attributes: ElemAttrib
 ) -> EtreeElement:
     """Get the union of any elements found in the given arguments.
 
@@ -186,13 +187,13 @@ def _get_view_box(elem: EtreeElement) -> tuple[float, float, float, float]:
     return x, y, width, height
 
 
-def parse_bound_element(svg_fil: str | os.PathLike[str]) -> BoundElement:
+def parse_bound_element(svg_file: str | os.PathLike[str]) -> BoundElement:
     """Import an element as a BoundElement.
 
     :param elem: the element to import.
     :return: a BoundElement instance.
     """
-    tree = etree.parse(svg_fil)
+    tree = etree.parse(svg_file)
     root = tree.getroot()
     elem = new_element("g")
     elem.extend(list(root))

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/src/svg_ultralight/bounding_boxes/padded_text_initializers.py

@@ -27,10 +27,7 @@ from svg_ultralight.font_tools.font_info import (
 )
 from svg_ultralight.font_tools.globs import DEFAULT_FONT_SIZE
 from svg_ultralight.query import get_bounding_boxes
-from svg_ultralight.string_conversion import (
-    format_attr_dict,
-    format_number,
-)
+from svg_ultralight.string_conversion import format_attr_dict, format_number
 
 if TYPE_CHECKING:
     import os
@@ -39,6 +36,8 @@ if TYPE_CHECKING:
         _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
     )
 
+    from svg_ultralight.attrib_hints import ElemAttrib, OptionalElemAttribMapping
+
 DEFAULT_Y_BOUNDS_REFERENCE = "{[|gjpqyf"
 
 
@@ -99,7 +98,8 @@ def pad_text_ft(
     descent: float | None = None,
     *,
     y_bounds_reference: str | None = None,
-    **attributes: str | float,
+    attrib: OptionalElemAttribMapping = None,
+    **attributes: ElemAttrib,
 ) -> PaddedText:
     """Create a new PaddedText instance using fontTools.
 
@@ -115,11 +115,15 @@ def pad_text_ft(
         extents of the capline reference. This argument is provided to mimic the
         behavior of the query module's `pad_text` function. `pad_text` does no
         inspect font files and relies on Inkscape to measure reference characters.
+    :param attrib: optionally pass additional attributes as a mapping instead of as
+        anonymous kwargs. This is useful for pleasing the linter when unpacking a
+        dictionary into a function call.
     :param attributes: additional attributes to set on the text element. There is a
         chance these will cause the font element to exceed the BoundingBox of the
         PaddedText instance.
     :return: a PaddedText instance with a line_gap defined.
     """
+    attributes.update(attrib or {})
     attributes_ = format_attr_dict(**attributes)
     attributes_.update(get_svg_font_attributes(font))
 
@@ -145,7 +149,8 @@ def pad_text_mix(
     descent: float | None = None,
     *,
     y_bounds_reference: str | None = None,
-    **attributes: str | float,
+    attrib: OptionalElemAttribMapping = None,
+    **attributes: ElemAttrib,
 ) -> PaddedText:
     """Use Inkscape text bounds and fill missing with fontTools.
 
@@ -161,11 +166,15 @@ def pad_text_mix(
         extents of the capline reference. This argument is provided to mimic the
         behavior of the query module's `pad_text` function. `pad_text` does no
         inspect font files and relies on Inkscape to measure reference characters.
+    :param attrib: optionally pass additional attributes as a mapping instead of as
+        anonymous kwargs. This is useful for pleasing the linter when unpacking a
+        dictionary into a function call.
     :param attributes: additional attributes to set on the text element. There is a
         chance these will cause the font element to exceed the BoundingBox of the
         PaddedText instance.
     :return: a PaddedText instance with a line_gap defined.
     """
+    attributes.update(attrib or {})
     elem = new_element("text", text=text, **attributes)
     padded_inkscape = pad_text(inkscape, elem, y_bounds_reference, font=font)
     padded_fonttools = pad_text_ft(
@@ -175,7 +184,7 @@ def pad_text_mix(
         ascent,
         descent,
         y_bounds_reference=y_bounds_reference,
-        **attributes,
+        attrib=attributes,
     )
     bbox = padded_inkscape.unpadded_bbox
     rpad = padded_inkscape.rpad

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/src/svg_ultralight/constructors/new_element.py

@@ -25,8 +25,10 @@ if TYPE_CHECKING:
         _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
     )
 
+    from svg_ultralight.attrib_hints import ElemAttrib
 
-def new_element(tag: str | QName, **attributes: str | float) -> EtreeElement:
+
+def new_element(tag: str | QName, **attributes: ElemAttrib) -> EtreeElement:
     """Create an etree.Element, make every kwarg value a string.
 
     :param tag: element tag
@@ -62,7 +64,7 @@ def new_element(tag: str | QName, **attributes: str | float) -> EtreeElement:
 
 
 def new_sub_element(
-    parent: EtreeElement, tag: str | QName, **attributes: str | float
+    parent: EtreeElement, tag: str | QName, **attributes: ElemAttrib
 ) -> EtreeElement:
     """Create an etree.SubElement, make every kwarg value a string.
 
@@ -81,7 +83,7 @@ def new_sub_element(
     return elem
 
 
-def update_element(elem: EtreeElement, **attributes: str | float) -> EtreeElement:
+def update_element(elem: EtreeElement, **attributes: ElemAttrib) -> EtreeElement:
     """Update an existing etree.Element with additional params.
 
     :param elem: at etree element
@@ -94,7 +96,7 @@ def update_element(elem: EtreeElement, **attributes: str | float) -> EtreeElemen
     return elem
 
 
-def deepcopy_element(elem: EtreeElement, **attributes: str | float) -> EtreeElement:
+def deepcopy_element(elem: EtreeElement, **attributes: ElemAttrib) -> EtreeElement:
     """Create a deepcopy of an element. Optionally pass additional params.
 
     :param elem: at etree element or list of elements

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/src/svg_ultralight/font_tools/comp_results.py

@@ -31,8 +31,8 @@ from svg_ultralight.bounding_boxes.padded_text_initializers import (
     pad_text_ft,
 )
 from svg_ultralight.constructors import new_element
-from svg_ultralight.font_tools.font_info import get_svg_font_attributes
-from svg_ultralight.main import write_svg
+from svg_ultralight.font_tools.font_info import FTFontInfo, get_svg_font_attributes
+from svg_ultralight.inkscape import write_root
 from svg_ultralight.root_elements import new_svg_root_around_bounds
 
 if TYPE_CHECKING:
@@ -201,7 +201,15 @@ def draw_comparison(
         text = Path(font).stem
     font_size = 12
     font_attributes = get_svg_font_attributes(font)
-    text_elem = new_element("text", text=text, **font_attributes, font_size=font_size)
+    text_elem = new_element(
+        "text",
+        text=text,
+        **font_attributes,
+        font_size=font_size,
+        fill="none",
+        stroke="green",
+        stroke_width=0.1,
+    )
     padded_pt = pad_text(inkscape, text_elem)
     padded_ft = pad_text_ft(
         font,
@@ -210,10 +218,10 @@ def draw_comparison(
         y_bounds_reference=DEFAULT_Y_BOUNDS_REFERENCE,
         fill="none",
         stroke="orange",
-        stroke_width=0.05,
+        stroke_width=0.1,
     )
 
-    root = new_svg_root_around_bounds(pad_bbox(padded_pt.bbox, 10))
+    root = new_svg_root_around_bounds(pad_bbox(padded_pt.bbox, 1))
     root.append(
         new_bbox_rect(
             padded_pt.unpadded_bbox, fill="none", stroke_width=0.07, stroke="red"
@@ -227,7 +235,7 @@ def draw_comparison(
     root.append(padded_pt.elem)
     root.append(padded_ft.elem)
     _ = sys.stdout.write(f"{Path(font).stem} comparison drawn at {output}.\n")
-    _ = write_svg(Path(output), root)
+    _ = write_root(inkscape, Path(output), root)
 
 
 def _iter_fonts(*fonts_dirs: Path) -> Iterator[Path]:
@@ -280,4 +288,6 @@ if __name__ == "__main__":
     _test_every_font_on_my_system(_INKSCAPE, _FONT_DIRS)
 
     font = Path(r"C:\Windows\Fonts\arial.ttf")
-    draw_comparison(_INKSCAPE, "temp.svg", font)
+    font = Path("C:/Windows/Fonts/Aptos-Display-Bold.ttf")
+    info = FTFontInfo(font)
+    draw_comparison(_INKSCAPE, "temp.svg", font, "AApple")

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/src/svg_ultralight/font_tools/font_info.py

@@ -105,6 +105,7 @@ from typing import TYPE_CHECKING, Any, cast
 from fontTools.pens.basePen import BasePen
 from fontTools.pens.boundsPen import BoundsPen
 from fontTools.ttLib import TTFont
+from paragraphs import par
 from svg_path_data import format_svgd_shortest, get_cpts_from_svgd, get_svgd_from_cpts
 
 from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
@@ -118,12 +119,68 @@ if TYPE_CHECKING:
 
     from lxml.etree import _Element as EtreeElement
 
+    from svg_ultralight.attrib_hints import ElemAttrib
+
 logging.getLogger("fontTools").setLevel(logging.ERROR)
 
 
-def _split_into_quadratic(
-    *pts: tuple[float, float],
-) -> Iterator[tuple[tuple[float, float], tuple[float, float]]]:
+# extract_gpos_kerning is an unfinished attempt to extract kerning from the GPOS
+# table.
+def get_gpos_kerning(font: TTFont) -> dict[tuple[str, str], int]:
+    """Extract kerning pairs from the GPOS table of a font.
+
+    :param font: A fontTools TTFont object.
+    :return: A dictionary mapping glyph pairs to their kerning values.
+    :raises ValueError: If the font does not have a GPOS table.
+
+    This is the more elaborate kerning that is used in OTF fonts and some TTF fonts.
+    It has several flavors, I'm only implementing glyph-pair kerning (Format 1),
+    because I don't have fonts to test anything else.
+    """
+    if "GPOS" not in font:
+        msg = "Font does not have a GPOS table."
+        raise ValueError(msg)
+
+    gpos = font["GPOS"].table
+    kern_table: dict[tuple[str, str], int] = {}
+
+    type2_lookups = (x for x in gpos.LookupList.Lookup if x.LookupType == 2)
+    subtables = list(it.chain(*(x.SubTable for x in type2_lookups)))
+    for subtable in (x for x in subtables if x.Format == 1):  # glyph-pair kerning
+        for pair_set, glyph1 in zip(subtable.PairSet, subtable.Coverage.glyphs):
+            for pair_value in pair_set.PairValueRecord:
+                glyph2 = pair_value.SecondGlyph
+                value1 = pair_value.Value1
+                xadv = getattr(value1, "XAdvance", None)
+                xpla = getattr(value1, "XPlacement", None)
+                value = xadv or xpla or 0
+                if value != 0:  # only record non-zero kerning values
+                    kern_table[(glyph1, glyph2)] = value
+
+    for subtable in (x for x in subtables if x.Format == 2):  # class-based kerning
+        defs1 = subtable.ClassDef1.classDefs
+        defs2 = subtable.ClassDef2.classDefs
+        record1 = subtable.Class1Record
+        defs1 = {k: v for k, v in defs1.items() if v < len(record1)}
+        for (glyph1, class1), (glyph2, class2) in it.product(
+            defs1.items(), defs2.items()
+        ):
+            class1_record = record1[class1]
+            if class2 < len(class1_record.Class2Record):
+                value1 = class1_record.Class2Record[class2].Value1
+                xadv = getattr(value1, "XAdvance", None)
+                xpla = getattr(value1, "XPlacement", None)
+                value = xadv or xpla or 0
+                if value != 0:
+                    kern_table[(glyph1, glyph2)] = value
+
+    return kern_table
+
+
+_XYTuple = tuple[float, float]
+
+
+def _split_into_quadratic(*pts: _XYTuple) -> Iterator[tuple[_XYTuple, _XYTuple]]:
     """Connect a series of points with quadratic bezier segments.
 
     :param points: a series of at least two (x, y) coordinates.
@@ -183,9 +240,16 @@ class PathPen(BasePen):
 
     def curveTo(self, *pts: tuple[float, float]) -> None:
         """Add a series of cubic bezier segments to the path."""
-        msg = "Cubic Bezier curves not implemented for getting svg path data."
-        raise NotImplementedError(msg)
-        self._cmds.extend(("Q", *map(str, it.chain(*pts))))
+        if len(pts) > 3:
+            msg = par(
+                """I'm uncertain how to decompose these points into cubics (if the
+                goal is to match font rendering in Inkscape and elsewhere. There is
+                function, decomposeSuperBezierSegment, in fontTools, but I cannot
+                find a reference for the algorithm. I'm hoping to run into one in a
+                font file so I have a test case."""
+            )
+            raise NotImplementedError(msg)
+        self._cmds.extend(("C", *map(str, it.chain(*pts))))
 
     def qCurveTo(self, *pts: tuple[float, float]) -> None:
         """Add a series of quadratic bezier segments to the path."""
@@ -252,13 +316,18 @@ class FTFontInfo:
         method would give precedence to the first occurrence. That behavior is copied
         from examples found online.
         """
-        with suppress(KeyError, AttributeError):
+        try:
             kern_tables = cast(
                 "list[dict[tuple[str, str], int]]",
                 [x.kernTable for x in self.font["kern"].kernTables],
             )
-            return dict(x for d in reversed(kern_tables) for x in d.items())
-        return {}
+            kern = dict(x for d in reversed(kern_tables) for x in d.items())
+        except (KeyError, AttributeError):
+            kern = {}
+        with suppress(Exception):
+            kern.update(get_gpos_kerning(self.font))
+
+        return kern
 
     @ft.cached_property
     def hhea(self) -> Any:
@@ -453,7 +522,7 @@ class FTTextInfo:
         """
         return self.font_size / self.font.units_per_em
 
-    def new_element(self, **attributes: str | float) -> EtreeElement:
+    def new_element(self, **attributes: ElemAttrib) -> EtreeElement:
         """Return an svg text element with the appropriate font attributes."""
         matrix_vals = (self.scale, 0, 0, -self.scale, 0, 0)
         matrix = f"matrix({' '.join(format_numbers(matrix_vals))})"

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/src/svg_ultralight/main.py

@@ -36,6 +36,7 @@ if TYPE_CHECKING:
         _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
     )
 
+    from svg_ultralight.attrib_hints import ElemAttrib, OptionalElemAttribMapping
     from svg_ultralight.layout import PadArg
 
 
@@ -68,7 +69,8 @@ def new_svg_root(
     print_height_: float | str | None = None,
     dpu_: float = 1,
     nsmap: dict[str | None, str] | None = None,
-    **attributes: float | str,
+    attrib: OptionalElemAttribMapping | None = None,
+    **attributes: ElemAttrib,
 ) -> EtreeElement:
     """Create an svg root element from viewBox style parameters.
 
@@ -87,6 +89,9 @@ def new_svg_root(
         different from print_width_ and print_height_ in that dpu_ scales the
         *padded* output.
     :param nsmap: optionally pass a namespace map of your choosing
+    :param attrib: optionally pass additional attributes as a mapping instead of as
+        anonymous kwargs. This is useful for pleasing the linter when unpacking a
+        dictionary into a function call.
     :param attributes: element attribute names and values
     :return: root svg element
 
@@ -97,10 +102,11 @@ def new_svg_root(
     will be passed to ``etree.Element`` as element parameters. These will
     supercede any parameters inferred from the trailing underscore parameters.
     """
+    attributes.update(attrib or {})
     if nsmap is None:
         nsmap = NSMAP
 
-    inferred_attribs: dict[str, float | str] = {}
+    inferred_attribs: dict[str, ElemAttrib] = {}
     view_box_args = (x_, y_, width_, height_)
     if _is_four_floats(view_box_args):
         assert isinstance(x_, (float, int))

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/src/svg_ultralight/root_elements.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
         _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
     )
 
+    from svg_ultralight.attrib_hints import ElemAttrib, OptionalElemAttribMapping
     from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
     from svg_ultralight.layout import PadArg
 
@@ -43,7 +44,8 @@ def new_svg_root_around_bounds(
     print_height_: float | str | None = None,
     dpu_: float = 1,
     nsmap: dict[str | None, str] | None = None,
-    **attributes: float | str,
+    attrib: OptionalElemAttribMapping = None,
+    **attributes: ElemAttrib,
 ) -> EtreeElement:
     """Create svg root around BoundElements.
 
@@ -61,10 +63,14 @@ def new_svg_root_around_bounds(
         different from print_width_ and print_height_ in that dpu_ scales the
         *padded* output.
     :param nsmap: optionally pass a namespace map of your choosing
+    :param attrib: optionally pass additional attributes as a mapping instead of as
+        anonymous kwargs. This is useful for pleasing the linter when unpacking a
+        dictionary into a function call.
     :param attributes: element attribute names and values
     :return: root svg element
     :raise ValueError: if no bounding boxes are found in bounded
     """
+    attributes.update(attrib or {})
     bbox = bound.new_bbox_union(*bounded)
     viewbox = _viewbox_args_from_bboxes(bbox)
     return new_svg_root(
@@ -77,5 +83,5 @@ def new_svg_root_around_bounds(
         print_height_=print_height_,
         dpu_=dpu_,
         nsmap=nsmap,
-        **attributes,
+        attrib=attributes,
     )

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/src/svg_ultralight/string_conversion.py

@@ -26,6 +26,8 @@ if TYPE_CHECKING:
         _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
     )
 
+    from svg_ultralight.attrib_hints import ElemAttrib
+
 
 def format_number(num: float | str, resolution: int | None = 6) -> str:
     """Format a number into an svg-readable float string with resolution = 6.
@@ -50,7 +52,7 @@ def format_numbers(
     return [format_number(num) for num in nums]
 
 
-def _fix_key_and_format_val(key: str, val: str | float) -> tuple[str, str]:
+def _fix_key_and_format_val(key: str, val: ElemAttrib) -> tuple[str, str]:
     """Format one key, value pair for an svg element.
 
     :param key: element attribute name
@@ -82,7 +84,9 @@ def _fix_key_and_format_val(key: str, val: str | float) -> tuple[str, str]:
     else:
         key_ = key.rstrip("_").replace("_", "-")
 
-    if isinstance(val, (int, float)):
+    if val is None:
+        val_ = "none"
+    elif isinstance(val, (int, float)):
         val_ = format_number(val)
     else:
         val_ = val
@@ -90,7 +94,7 @@ def _fix_key_and_format_val(key: str, val: str | float) -> tuple[str, str]:
     return key_, val_
 
 
-def format_attr_dict(**attributes: str | float) -> dict[str, str]:
+def format_attr_dict(**attributes: ElemAttrib) -> dict[str, str]:
     """Use svg_ultralight key / value fixer to create a dict of attributes.
 
     :param attributes: element attribute names and values.
@@ -99,7 +103,7 @@ def format_attr_dict(**attributes: str | float) -> dict[str, str]:
     return dict(_fix_key_and_format_val(key, val) for key, val in attributes.items())
 
 
-def set_attributes(elem: EtreeElement, **attributes: str | float) -> None:
+def set_attributes(elem: EtreeElement, **attributes: ElemAttrib) -> None:
     """Set name: value items as element attributes. Make every value a string.
 
     :param elem: element to receive element.set(keyword, str(value)) calls

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0/src/svg_ultralight.egg-info}/PKG-INFO

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

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/src/svg_ultralight.egg-info/SOURCES.txt

@@ -4,10 +4,11 @@ README.md
 dev-requirements.txt
 pyproject.toml
 tox.ini
-experiments/encode_fonts3.py
+experiments/encode_fonts3.txt
 experiments/font_css.py
 src/svg_ultralight/__init__.py
 src/svg_ultralight/animate.py
+src/svg_ultralight/attrib_hints.py
 src/svg_ultralight/image_ops.py
 src/svg_ultralight/inkscape.py
 src/svg_ultralight/layout.py

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/tests/conftest.py

@@ -13,16 +13,21 @@ if TYPE_CHECKING:
     import os
 
 
-def pytest_assertrepr_compare(config: Any, op: str, left: str, right: str):
+def pytest_assertrepr_compare(
+    config: Any, op: str, left: str, right: str
+) -> list[str] | None:
     """See full error diffs"""
+    del config
     if op in ("==", "!="):
-        return ["{0} {1} {2}".format(left, op, right)]
+        return [f"{left} {op} {right}"]
+    return None
 
 
 TEST_RESOURCES = Path(__file__).parent / "resources"
 
 INKSCAPE = Path(r"C:\Program Files\Inkscape\bin\inkscape")
 
+
 def has_inkscape(inkscape: str | os.PathLike[str]) -> bool:
     """Check if Inkscape is available at a path.
 

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/tests/test_bounding.py

@@ -4,22 +4,24 @@
 :created: 2024-05-05
 """
 
-import pytest
+import copy
 import math
+
+import pytest
 from conftest import TEST_RESOURCES
-from svg_ultralight.bounding_boxes.type_bound_element import BoundElement
-from svg_ultralight.bounding_boxes.type_padded_text import PaddedText
 from lxml import etree
-from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
-from svg_ultralight.bounding_boxes.type_bound_collection import BoundCollection
+
 from svg_ultralight.bounding_boxes.bound_helpers import (
-    pad_bbox,
-    cut_bbox,
-    parse_bound_element,
     bbox_dict,
+    cut_bbox,
     new_bbox_rect,
+    pad_bbox,
+    parse_bound_element,
 )
-import copy
+from svg_ultralight.bounding_boxes.type_bound_collection import BoundCollection
+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
 
 
@@ -126,7 +128,7 @@ class TestPaddedText:
         assert bound_element.cy == 148.0
 
     def test_cx(self, bound_element: PaddedText):
-        bbox_x = bound_element.x  
+        bbox_x = bound_element.x
         bbox_x2 = bound_element.x2
         bbox_cx = bound_element.cx
         bound_element.cx += 100.0
@@ -135,13 +137,13 @@ class TestPaddedText:
         assert bound_element.cx == bbox_cx + 100.0
 
     def test_cy(self, bound_element: PaddedText):
-        bbox_y = bound_element.y  
+        bbox_y = bound_element.y
         bbox_y2 = bound_element.y2
         bbox_cy = bound_element.cy
         bound_element.cy += 100.0
         assert bound_element.y == bbox_y + 100.0
         assert bound_element.y2 == bbox_y2 + 100.0
-        assert bound_element.cy == bbox_cy + 100.0 
+        assert bound_element.cy == bbox_cy + 100.0
 
     def test_width(self, bound_element: PaddedText):
         assert bound_element.width == 106.0
@@ -188,7 +190,6 @@ class TestPaddedText:
 
 
 class TestBoundCollection:
-
     @pytest.fixture
     def bound_collection(self) -> BoundCollection:
         elem = new_element("rect", x=0, y=0, width=100, height=200)

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/tests/test_layout.py

@@ -11,7 +11,6 @@
 # pyright: reportMissingParameterType = false
 # pyright: reportPrivateUsage = false
 
-
 import itertools as it
 import math
 from collections.abc import Iterator
@@ -39,13 +38,13 @@ INKSCAPE_SCALARS = {
 }
 
 
-@pytest.fixture(scope="function", params=Unit)
-def unit(request) -> Unit:
+@pytest.fixture(params=Unit)
+def unit(request: pytest.FixtureRequest) -> Unit:
     return request.param
 
 
-@pytest.fixture(scope="function", params=it.product(Unit, Unit))
-def unit_pair(request) -> Iterator[Unit]:
+@pytest.fixture(params=it.product(Unit, Unit))
+def unit_pair(request: pytest.FixtureRequest) -> Iterator[Unit]:
     return request.param
 
 
@@ -80,17 +79,17 @@ class TestParseUnit:
 
 
 class TestMeasurement:
-    def test_unit_identified(self, unit):
+    def test_unit_identified(self, unit: Unit):
         """Test that unit is identified correctly."""
         assert Measurement(f"1{unit.value[0]}").native_unit == unit
 
-    def test_value_scaled(self, unit):
+    def test_value_scaled(self, unit: Unit):
         """Value is scaled per Inkscape conversion values."""
         assert math.isclose(
             Measurement(f"1{unit.value[0]}").value, INKSCAPE_SCALARS[unit.value[0]]
         )
 
-    def test_conversion(self, unit_pair):
+    def test_conversion(self, unit_pair: tuple[Unit, Unit]):
         """Test that value is converted to other units."""
         unit_a, unit_b = unit_pair
         a_unit = Measurement(f"1{unit_a.value[0]}")
@@ -98,27 +97,27 @@ class TestMeasurement:
         b_unit = Measurement(f"{a_as_b}{unit_b.value[0]}")
         assert math.isclose(b_unit.value, a_unit.value)
 
-    def test_add(self, unit):
+    def test_add(self, unit: Unit):
         """Test that values are added."""
         a_unit = Measurement(f"1{unit.value[0]}")
         b_unit = Measurement(f"2{unit.value[0]}")
         assert (a_unit + b_unit).value == Measurement(f"3{unit.value[0]}").value
 
-    def test_subtract(self, unit):
+    def test_subtract(self, unit: Unit):
         """Test that values are subtracted."""
         a_unit = Measurement(f"1{unit.value[0]}")
         b_unit = Measurement(f"2{unit.value[0]}")
         assert (a_unit - b_unit).value == Measurement(f"-1{unit.value[0]}").value
 
-    def test_multiply(self, unit):
+    def test_multiply(self, unit: Unit):
         """Test that values are multiplied."""
         assert (Measurement((1, unit)) * 4).value == Measurement((4, unit)).value
 
-    def test_rmultiply(self, unit):
+    def test_rmultiply(self, unit: Unit):
         """Test that values are multiplied."""
         assert (4 * Measurement((1, unit))).value == Measurement((4, unit)).value
 
-    def test_divide(self, unit):
+    def test_divide(self, unit: Unit):
         """Test that values are multiplied."""
         assert (Measurement((1, unit)) / 4).value == Measurement((1 / 4, unit)).value
 
@@ -144,6 +143,7 @@ class TestExpandPadArg:
         """Test that a single value is expanded to a 4-tuple per css rules."""
         assert layout.expand_pad_arg((1, 2, 3, 4)) == (1, 2, 3, 4)
 
+
 class TestLayout:
     def test_standard(self):
         """No print dimensions give expanded pad argument
@@ -194,9 +194,8 @@ class TestLayout:
     def test_infinite_width(self):
         """Raise ValueError if no non-infinite scale can be inferred."""
         viewbox = (0, 0, 0, 0)
-        with pytest.raises(ValueError) as excinfo:
+        with pytest.raises(ValueError, match="infinite"):
             _ = layout.pad_and_scale(viewbox, "0.25in", "2in")
-        assert "infinite" in str(excinfo.value)
 
     def test_pad_print_at_input_scale(self):
         """Test that padding is applied at the input scale.
@@ -229,7 +228,7 @@ class TestLayout:
         assert width_attribs == {"width": "12in", "height": "22in"}
 
         padded, width_attribs = layout.pad_and_scale(viewbox, "1in", "100in")
-        assert [format_number(x) for x in padded] == ['-.1', '-.1', '10.2', '20.2']
+        assert [format_number(x) for x in padded] == ["-.1", "-.1", "10.2", "20.2"]
         assert width_attribs == {"width": "102in", "height": "202in"}
 
     def test_dpu_(self):
@@ -248,6 +247,4 @@ class TestLayout:
         viewbox = (0, 0, 1, 1)
         padded, width_attribs = layout.pad_and_scale(viewbox, 1, dpu=2)
         assert padded == (-1, -1, 3, 3)
-        assert width_attribs == {'width': '6', 'height': '6'}
-        
-
+        assert width_attribs == {"width": "6", "height": "6"}

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/tests/test_matrices.py

@@ -4,11 +4,12 @@
 :created: 2024-05-05
 """
 
-from svg_ultralight.transformations import mat_dot, mat_apply, mat_invert
-import random
 import math
+import random
 from contextlib import suppress
 
+from svg_ultralight.transformations import mat_apply, mat_dot, mat_invert
+
 
 class TestMat:
     def test_explicit(self):

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/tests/test_metadata.py

@@ -4,10 +4,11 @@
 :created: 2024-01-30
 """
 
-from svg_ultralight.metadata import new_metadata
-from svg_ultralight.main import new_svg_root
 from lxml import etree
 
+from svg_ultralight.main import new_svg_root
+from svg_ultralight.metadata import new_metadata
+
 _inkscape_output = """
 <metadata id="metadata1">
     <rdf:RDF>
@@ -53,6 +54,7 @@ _inkscape_output = """
 
 _inkscape_output = "".join([x.strip() for x in _inkscape_output.splitlines()])
 
+
 class TestMetedata:
     def test_inkscape_explicit(self):
         """Output matches Inkscape output.

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/tests/test_padded_text_initializers.py

@@ -3,14 +3,14 @@
 :author: Shay Hill
 :created: 2025-06-09
 """
+
 from pathlib import Path
 
 import pytest
+from conftest import INKSCAPE, has_inkscape
 
 from svg_ultralight.bounding_boxes.padded_text_initializers import pad_text, pad_text_ft
 from svg_ultralight.constructors import new_element
-from conftest import has_inkscape, INKSCAPE
-
 
 
 class TestPadText:
@@ -57,6 +57,7 @@ class TestPadText:
         padded.line_gap = 5
         assert padded.leading == padded.height + 5
 
+
 class TestPadTextFt:
     def test_has_line_gap(self) -> None:
         """Test pad_text_ft with a font file."""

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/tests/test_queries.py

@@ -8,11 +8,10 @@ your system.
 """
 
 from dataclasses import dataclass
-from pathlib import Path
 
 import pytest
-
 from conftest import INKSCAPE, has_inkscape
+
 from svg_ultralight import BoundingBox, new_svg_root
 from svg_ultralight.constructors import new_sub_element
 from svg_ultralight.query import (
@@ -22,7 +21,6 @@ from svg_ultralight.query import (
 )
 
 
-
 class TestMergeBoundingBoxes:
     def test_new_merged_bbox(self):
         bbox_a = BoundingBox(-2, -4, 10, 20)
@@ -223,6 +221,7 @@ class TestMapElemsToBoundingBoxes:
         result = get_bounding_boxes(INKSCAPE, *elems)
         assert result == tuple(get_bounding_box(INKSCAPE, e) for e in elems)
 
+
 class TestAlterBoundingBox:
     def test_reverse_width(self) -> None:
         """adjust width one way then the other returns to original box."""
@@ -232,7 +231,3 @@ class TestAlterBoundingBox:
         bbox.height = 200
         bbox.height = 40
         assert bbox.transformation == (1, 0, 0, 1, 90, 180)
-
-
-
-

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/tests/test_root_elements.py

@@ -5,29 +5,26 @@
 """
 
 import pytest
+from lxml.etree import _Element as EtreeElement  # pyright: ignore[reportPrivateUsage]
 
-from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
+from svg_ultralight.bounding_boxes.bound_helpers import new_bound_union
 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
 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  # pyright: ignore[reportPrivateUsage]
 
 
 class TestNewSvgRootAroundBounds:
-    
     def test_empty(self):
         """Raise ValueError if no bounding boxes found."""
-        with pytest.raises(ValueError) as excinfo:
+        with pytest.raises(ValueError, match="At least one argument"):
             _ = new_svg_root_around_bounds()
-        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:
+        with pytest.raises(ValueError, match="At least one argument"):
             _ = new_svg_root_around_bounds(new_element("g"))
-        assert "At least one argument" in str(excinfo.value)
 
     def test_bounding_boxes(self):
         """Create svg root element from bounding boxes."""
@@ -52,21 +49,19 @@ class TestNewSvgRootAroundBounds:
         assert isinstance(result, EtreeElement)
         assert result.attrib["viewBox"] == "0 0 201 201"
 
-class TestNewBoundUnion:
 
+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:
+        with pytest.raises(ValueError, match="must be a BoundElement, PaddedText"):
             _ = 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:
+        with pytest.raises(ValueError, match="must be a BoundElement, BoundingBox"):
             _ = 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."""

{svg_ultralight-0.43.1 → svg_ultralight-0.45.0}/tests/test_svg_ultralight.py

@@ -8,13 +8,14 @@ No tests for png writing.
 """
 
 from __future__ import annotations
+
 import os
 import tempfile
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import pytest
 from lxml import etree
-from lxml.etree import _Element as EtreeElement  # pyright: ignore[reportPrivateUsage]
 
 from svg_ultralight import NSMAP
 
@@ -22,8 +23,13 @@ from svg_ultralight import NSMAP
 from svg_ultralight.main import new_svg_root, write_svg
 from svg_ultralight.string_conversion import svg_tostring
 
+if TYPE_CHECKING:
+    from lxml.etree import (
+        _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
+    )
+
 
-@pytest.fixture()
+@pytest.fixture
 def css_source():
     """Temporary css file object with meaningless contents."""
     with tempfile.NamedTemporaryFile(mode="w", delete=False) as css_source:
@@ -32,24 +38,29 @@ def css_source():
     os.unlink(css_source.name)
 
 
-@pytest.fixture()
+@pytest.fixture
 def temp_filename(mode: str = "w"):
     """Temporary file object to capture test output."""
-    svg_output = tempfile.NamedTemporaryFile(mode=mode, delete=False)
-    svg_output.close()
-    yield svg_output.name
+    with tempfile.NamedTemporaryFile(mode=mode, delete=False) as svg_output:
+        yield svg_output.name
     os.unlink(svg_output.name)
 
 
 class TestWriteSvg:
-    def test_linked(self, css_source, temp_filename) -> None:
+    def test_linked(
+        self, css_source: str | os.PathLike[str], temp_filename: str | os.PathLike[str]
+    ) -> None:
         """Insert stylesheet reference."""
         blank = etree.Element("blank")
-        write_svg(
-            temp_filename, blank, css_source, do_link_css=True, xml_declaration=True
+        _ = write_svg(
+            Path(temp_filename),
+            blank,
+            css_source,
+            do_link_css=True,
+            xml_declaration=True,
         )
-        with open(temp_filename, "rb") as svg_binary:
-            svg_lines = [x.decode() for x in svg_binary.readlines()]
+        with Path(temp_filename).open("rb") as svg_binary:
+            svg_lines = [x.decode() for x in svg_binary]
 
         relative_css_path = Path(css_source).relative_to(Path(temp_filename).parent)
         assert svg_lines == [
@@ -60,12 +71,14 @@ class TestWriteSvg:
             "<blank/>\n",
         ]
 
-    def test_not_linked(self, css_source, temp_filename) -> None:
+    def test_not_linked(
+        self, css_source: str | os.PathLike[str], temp_filename: str | os.PathLike[str]
+    ) -> None:
         """Copy css_source contents into svg file."""
         blank = etree.Element("blank")
-        write_svg(temp_filename, blank, css_source)
-        with open(temp_filename, "rb") as svg_binary:
-            svg_lines = [x.decode() for x in svg_binary.readlines()]
+        _ = write_svg(Path(temp_filename), blank, css_source)
+        with Path(temp_filename).open("rb") as svg_binary:
+            svg_lines = [x.decode() for x in svg_binary]
 
         assert svg_lines == [
             "<blank>\n",
@@ -75,19 +88,19 @@ class TestWriteSvg:
             "</blank>\n",
         ]
 
-    def test_css_none(self, temp_filename) -> None:
+    def test_css_none(self, temp_filename: str | os.PathLike[str]) -> None:
         """Do not link or copy in css if no css_source is passed."""
         blank = etree.Element("blank")
-        write_svg(temp_filename, blank, do_link_css=True)
-        with open(temp_filename, "rb") as svg_binary:
-            svg_lines = [x.decode() for x in svg_binary.readlines()]
+        _ = write_svg(Path(temp_filename), blank, do_link_css=True)
+        with Path(temp_filename).open("rb") as svg_binary:
+            svg_lines = [x.decode() for x in svg_binary]
 
         assert svg_lines == ["<blank/>\n"]
 
         # test with do_link_css = False
-        write_svg(temp_filename, blank)
-        with open(temp_filename, "rb") as svg_binary:
-            svg_lines_false = [x.decode() for x in svg_binary.readlines()]
+        _ = write_svg(Path(temp_filename), blank)
+        with Path(temp_filename).open("rb") as svg_binary:
+            svg_lines_false = [x.decode() for x in svg_binary]
         assert svg_lines_false == svg_lines
 
 
@@ -106,7 +119,7 @@ def svg_root(**kwargs: str | float) -> EtreeElement:
     xmlns = [f'xmlns="{namespace[0][1]}"']
     xmlns += [f'xmlns:{k}="{v}"' for k, v in namespace[1:]]
     attributes = " ".join([f'{k}="{v}"' for k, v in kwargs.items()])
-    return etree.fromstring(f'<svg {" ".join(xmlns)} {attributes}/>'.encode())
+    return etree.fromstring(f"<svg {' '.join(xmlns)} {attributes}/>".encode())
 
 
 class TestNewSvgRoot:
@@ -120,19 +133,19 @@ class TestNewSvgRoot:
 
         Build the svg element namespace from NSMAP and compare to output
         """
-        expect = svg_root(**{"viewBox": "0 1 2 3"})
+        expect = svg_root(viewBox="0 1 2 3")
         result = new_svg_root(0, 1, 2, 3)
         assert result.attrib == expect.attrib
 
     def test_additional_params(self) -> None:
         """Pass additional params."""
-        expect = svg_root(**{"attr": "value", "viewBox": "0 1 2 3"})
+        expect = svg_root(attr="value", viewBox="0 1 2 3")
         result = new_svg_root(0, 1, 2, 3, attr="value")
         assert result.attrib == expect.attrib
 
     def test_conflicting_params(self) -> None:
         """Explicit params overwrite trailing-underscore-inferred params."""
-        expect = svg_root(**{"viewBox": "0 1 2 3", "height": "30"})
+        expect = svg_root(viewBox="0 1 2 3", height="30")
         result = new_svg_root(0, 1, 2, 3, height=30)
         assert result.attrib == expect.attrib