svg-ultralight 0.42.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

svg_ultralight/__init__.py

@@ -51,7 +51,6 @@ from svg_ultralight.string_conversion import (
     format_attr_dict,
     format_number,
     format_numbers,
-    format_numbers_in_string,
 )
 from svg_ultralight.transformations import (
     mat_apply,
@@ -75,7 +74,6 @@ __all__ = [
     "format_attr_dict",
     "format_number",
     "format_numbers",
-    "format_numbers_in_string",
     "get_bounding_box",
     "get_bounding_boxes",
     "mat_apply",

svg_ultralight/bounding_boxes/padded_text_initializers.py

@@ -122,12 +122,17 @@ def pad_text_ft(
     """
     attributes_ = format_attr_dict(**attributes)
     attributes_.update(get_svg_font_attributes(font))
-    attributes_["font-size"] = attributes_.get("font-size", format_number(font_size))
 
-    elem = new_element("text", text=text, **attributes_)
+    _ = attributes_.pop("font-size", None)
+    _ = attributes_.pop("font-family", None)
+    _ = attributes_.pop("font-style", None)
+    _ = attributes_.pop("font-weight", None)
+    _ = attributes_.pop("font-stretch", None)
+
     info = get_padded_text_info(
         font, text, font_size, ascent, descent, y_bounds_reference=y_bounds_reference
     )
+    elem = info.new_element(**attributes_)
     return PaddedText(elem, info.bbox, *info.padding, info.line_gap)
 
 

svg_ultralight/font_tools/font_info.py

@@ -102,19 +102,101 @@ from contextlib import suppress
 from pathlib import Path
 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 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
+from svg_ultralight.constructors.new_element import new_element
 from svg_ultralight.font_tools.globs import DEFAULT_FONT_SIZE
+from svg_ultralight.string_conversion import format_numbers
 
 if TYPE_CHECKING:
     import os
+    from collections.abc import Iterator
 
+    from lxml.etree import _Element as EtreeElement
 
 logging.getLogger("fontTools").setLevel(logging.ERROR)
 
 
+def _split_into_quadratic(
+    *pts: tuple[float, float],
+) -> Iterator[tuple[tuple[float, float], tuple[float, float]]]:
+    """Connect a series of points with quadratic bezier segments.
+
+    :param points: a series of at least two (x, y) coordinates.
+    :return: an iterator of ((x, y), (x, y)) quadatic bezier control points (the
+        second and third points)
+
+    This is part of connecting a (not provided) current point to the last input
+    point. The other input points will be control points of a series of quadratic
+    Bezier curves. New Bezier curve endpoints will be created between these points.
+
+    given (B, C, D, E) (with A as the not-provided current point):
+    - [A,  B, bc][1:]
+    - [bc, C, cd][1:]
+    - [cd, D,  E][1:]
+    """
+    if len(pts) < 2:
+        msg = "At least two points are required."
+        raise ValueError(msg)
+    for prev_cp, next_cp in it.pairwise(pts[:-1]):
+        xs, ys = zip(prev_cp, next_cp)
+        midpnt = sum(xs) / 2, sum(ys) / 2
+        yield prev_cp, midpnt
+    yield pts[-2], pts[-1]
+
+
+class PathPen(BasePen):
+    """A pen to collect svg path data commands from a glyph."""
+
+    def __init__(self, glyph_set: Any) -> None:
+        """Initialize the PathPen with a glyph set.
+
+        :param glyph_set: TTFont(path).getGlyphSet()
+        """
+        super().__init__(glyph_set)
+        self._cmds: list[str] = []
+
+    @property
+    def svgd(self) -> str:
+        """Return an svg path data string for the glyph."""
+        if not self._cmds:
+            return ""
+        svgd = format_svgd_shortest(" ".join(self._cmds))
+        return "M" + svgd[1:]
+
+    @property
+    def cpts(self) -> list[list[tuple[float, float]]]:
+        """Return as a list of lists of Bezier control points."""
+        return get_cpts_from_svgd(" ".join(self._cmds))
+
+    def moveTo(self, pt: tuple[float, float]) -> None:
+        """Move the current point to a new location."""
+        self._cmds.extend(("M", *map(str, pt)))
+
+    def lineTo(self, pt: tuple[float, float]) -> None:
+        """Add a line segment to the path."""
+        self._cmds.extend(("L", *map(str, pt)))
+
+    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))))
+
+    def qCurveTo(self, *pts: tuple[float, float]) -> None:
+        """Add a series of quadratic bezier segments to the path."""
+        for q_pts in _split_into_quadratic(*pts):
+            self._cmds.extend(("Q", *map(str, it.chain(*q_pts))))
+
+    def closePath(self):
+        """Close the current path."""
+        self._cmds.append("Z")
+
+
 class FTFontInfo:
     """Hide all the type kludging necessary to use fontTools."""
 
@@ -205,6 +287,26 @@ class FTFontInfo:
         msg = f"Character '{char}' not found in font '{self.path}'."
         raise ValueError(msg)
 
+    def get_char_svgd(self, char: str, dx: float = 0) -> str:
+        """Return the svg path data for a glyph.
+
+        :param char: The character to get the svg path data for.
+        :param dx: An optional x translation to apply to the glyph.
+        :return: The svg path data for the character.
+        """
+        glyph_set = self.font.getGlyphSet()
+        glyph_name = self.font.getBestCmap().get(ord(char))
+        path_pen = PathPen(glyph_set)
+        _ = glyph_set[glyph_name].draw(path_pen)
+        svgd = path_pen.svgd
+        if not dx or not svgd:
+            return svgd
+        cpts = path_pen.cpts
+        for i, curve in enumerate(cpts):
+            cpts[i][:] = [(x + dx, y) for x, y in curve]
+        svgd = format_svgd_shortest(get_svgd_from_cpts(cpts))
+        return "M" + svgd[1:]
+
     def get_char_bounds(self, char: str) -> tuple[int, int, int, int]:
         """Return the min and max x and y coordinates of a glyph.
 
@@ -217,7 +319,6 @@ class FTFontInfo:
         glyph_name = self.font.getBestCmap().get(ord(char))
         bounds_pen = BoundsPen(glyph_set)
         _ = glyph_set[glyph_name].draw(bounds_pen)
-
         pen_bounds = cast("None | tuple[int, int, int, int]", bounds_pen.bounds)
         if pen_bounds is None:
             return 0, 0, 0, 0
@@ -264,6 +365,25 @@ class FTFontInfo:
         max_y = max(max_ys)
         return min_x, min_y, max_x, max_y
 
+    def get_text_svgd(self, text: str, dx: float = 0) -> str:
+        """Return the svg path data for a string.
+
+        :param text: The text to get the svg path data for.
+        :param dx: An optional x translation to apply to the entire text.
+        :return: The svg path data for the text.
+        """
+        hmtx = cast("dict[str, tuple[int, int]]", self.font["hmtx"])
+        svgd = ""
+        char_dx = dx
+        for c_this, c_next in it.pairwise(text):
+            this_name = self.get_glyph_name(c_this)
+            next_name = self.get_glyph_name(c_next)
+            svgd += self.get_char_svgd(c_this, char_dx)
+            char_dx += hmtx[this_name][0]
+            char_dx += self.kern_table.get((this_name, next_name), 0)
+        svgd += self.get_char_svgd(text[-1], char_dx)
+        return svgd
+
     def get_text_bbox(self, text: str) -> BoundingBox:
         """Return the BoundingBox of a string svg coordinates.
 
@@ -333,6 +453,16 @@ class FTTextInfo:
         """
         return self.font_size / self.font.units_per_em
 
+    def new_element(self, **attributes: str | float) -> 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))})"
+        attributes["transform"] = matrix
+        stroke_width = attributes.get("stroke-width")
+        if stroke_width:
+            attributes["stroke-width"] = float(stroke_width) / self.scale
+        return new_element("path", d=self.font.get_text_svgd(self.text), **attributes)
+
     @property
     def bbox(self) -> BoundingBox:
         """Return the bounding box of the text.

svg_ultralight/string_conversion.py

@@ -11,10 +11,10 @@ from __future__ import annotations
 
 import binascii
 import re
-from contextlib import suppress
 from enum import Enum
 from typing import TYPE_CHECKING, cast
 
+import svg_path_data
 from lxml import etree
 
 from svg_ultralight.nsmap import NSMAP
@@ -27,109 +27,16 @@ if TYPE_CHECKING:
     )
 
 
-_MAYBE_NEG = r"(?:(?P<negative>-?))"
-_MAYBE_INT = r"(?:(?P<integer>\d+?))"
-_MAYBE_FRACTION = r"(?:\.(?P<fraction>\d+))?"
-_MAYBE_EXP = r"(?:[eE](?P<exponent>[+-]?\d+))?"
+def format_number(num: float | str, resolution: int | None = 6) -> str:
+    """Format a number into an svg-readable float string with resolution = 6.
 
-# Split a float (fp or exponential) into its components. All components are optional.
-FLOAT_PATTERN = re.compile(rf"{_MAYBE_NEG}{_MAYBE_INT}{_MAYBE_FRACTION}{_MAYBE_EXP}")
-
-
-def _split_float_str(num: str | float) -> tuple[str, str, str, int]:
-    """Split a float string into its sign, integer part, fractional part, and exponent.
-
-    :param num_str: A string representing the number (e.g., '1.23e+03').
-    :return: A tuple containing the integer part, fractional part, and exponent.
-    """
-    if float(num) == 0:
-        return "", "", "", 0
-    num_str = str(num)
-    groups = FLOAT_PATTERN.fullmatch(num_str)
-    if not groups:
-        msg = "Invalid number string: {num_str}."
-        raise ValueError(msg.format(num_str=num_str))
-
-    sign = groups["negative"] or ""
-    integer = (groups["integer"] or "").lstrip("0")
-    fraction = (groups["fraction"] or "").rstrip("0")
-    exponent = int(groups["exponent"] or 0)
-    return sign, integer, fraction, exponent
-
-
-def _format_as_fixed_point(num: str | float) -> str:
-    """Format a number in fixed-point notation.
-
-    :param exp_str: A string representing the number in exponential notation
-        (e.g., '1.23e+03') or just a number.
-    :return: A string representing the number in fixed-point notation.
-    """
-    sign, integer, fraction, exponent = _split_float_str(num)
-    if exponent > 0:
-        fraction = fraction.ljust(exponent, "0")
-        integer += fraction[:exponent]
-        fraction = fraction[exponent:]
-    elif exponent < 0:
-        integer = integer.rjust(-exponent, "0")
-        fraction = integer[exponent:] + fraction
-        integer = integer[:exponent]
-
-    fraction = "." + fraction if fraction else ""
-    return f"{sign}{integer}{fraction}" or "0"
-
-
-def _format_as_exponential(num: str | float) -> str:
-    """Convert a number in fixed-point notation (as a string) to exponential notation.
-
-    :param num_str: A string representing the number in fixed-point notation
-        (e.g., '123000') or just a number.
-    :return: A string representing the number in exponential notation.
+    :param num: number to format (string or float)
+    :param resolution: number of digits after the decimal point, defaults to 6. None
+        to match behavior of `str(num)`.
+    :return: string representation of the number with six digits after the decimal
+        (if in fixed-point notation). Will return exponential notation when shorter.
     """
-    sign, integer, fraction, exponent = _split_float_str(num)
-    if len(integer) > 1:
-        exponent += len(integer) - 1
-        fraction = (integer[1:] + fraction).rstrip("0")
-        integer = integer[0]
-    elif not integer and fraction:
-        leading_zeroes = len(fraction) - len(fraction.lstrip("0"))
-        exponent -= leading_zeroes + 1
-        integer = fraction[leading_zeroes]
-        fraction = fraction[leading_zeroes + 1 :]
-
-    fraction = "." + fraction if fraction else ""
-    exp_str = f"e{exponent}" if exponent else ""
-    return f"{sign}{integer}{fraction}{exp_str}" or "0"
-
-
-def format_number(num: float | str, precision: float | None = 6) -> str:
-    """Format strings at limited precision.
-
-    :param num: anything that can print as a float.
-    :param precision: number of digits after the decimal point, default 6. You can
-        also pass None for no precision limit. This may produce some long strings,
-        but will retain as much information as possible when converting between
-        floats and strings.
-    :return: str
-
-    I've read articles that recommend no more than four digits before and two digits
-    after the decimal point to ensure good svg rendering. I'm being generous and
-    giving six. Mostly to eliminate exponential notation, but I'm "rstripping" the
-    strings to reduce filesize and increase readability
-
-    * reduce fp precision to (default) 6 digits
-    * remove trailing zeros
-    * remove trailing decimal point
-    * remove leading 0 in "0.123"
-    * convert "-0" to "0"
-    * use shorter of exponential or fixed-point notation
-    """
-    if precision is not None:
-        num = f"{float(num):.{precision}f}"
-    exponential_str = _format_as_exponential(num)
-    fixed_point_str = _format_as_fixed_point(num)
-    if len(exponential_str) < len(fixed_point_str):
-        return exponential_str
-    return fixed_point_str
+    return svg_path_data.format_number(num, resolution=resolution)
 
 
 def format_numbers(
@@ -143,44 +50,6 @@ def format_numbers(
     return [format_number(num) for num in nums]
 
 
-def _is_float_or_float_str(data: float | str) -> bool:
-    """Check if a string is a float.
-
-    :param data: string to check
-    :return: bool
-    """
-    try:
-        _ = float(data)
-    except ValueError:
-        return False
-    else:
-        return True
-
-
-def format_numbers_in_string(data: float | str) -> str:
-    """Find and format floats in a string.
-
-    :param data: string with floats or a float value
-    :return: string with floats formatted to limited precision
-
-    Works as a more robust version of format_number. Will correctly handle input
-    floats in exponential notation. This should work for any parameter value in an
-    svg except 'text', 'id' and for any other value except hex color codes. The
-    function will fail with input strings like 'ice3.14bucket', because 'e3.14' will
-    be identified as a float. SVG param values will not have such strings, but the
-    'text' attribute could. This function will not handle that case. Do not attempt
-    to reformat 'text' attribute values.
-    """
-    with suppress(ValueError):
-        # try as a regular number to strip spaces from simple float strings
-        return format_number(data)
-    if str(data).startswith("#"):
-        return str(data)
-    words = re.split(r"([^\d.eE-]+)", str(data))
-    words = [format_number(w) if _is_float_or_float_str(w) else w for w in words]
-    return "".join(words)
-
-
 def _fix_key_and_format_val(key: str, val: str | float) -> tuple[str, str]:
     """Format one key, value pair for an svg element.
 
@@ -213,10 +82,12 @@ def _fix_key_and_format_val(key: str, val: str | float) -> tuple[str, str]:
     else:
         key_ = key.rstrip("_").replace("_", "-")
 
-    if key_ in {"id", "text"}:
-        return key_, str(val)
+    if isinstance(val, (int, float)):
+        val_ = format_number(val)
+    else:
+        val_ = val
 
-    return key_, format_numbers_in_string(val)
+    return key_, val_
 
 
 def format_attr_dict(**attributes: str | float) -> dict[str, str]:

{svg_ultralight-0.42.0.dist-info → svg_ultralight-0.43.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: svg-ultralight
-Version: 0.42.0
+Version: 0.43.0
 Summary: a sensible way to create svg files with Python
 Author-email: Shay Hill <shay_public@hotmail.com>
 License: MIT
@@ -11,6 +11,7 @@ Requires-Dist: fonttools
 Requires-Dist: lxml
 Requires-Dist: paragraphs
 Requires-Dist: pillow
+Requires-Dist: svg-path-data
 Requires-Dist: types-lxml
 Requires-Dist: typing-extensions
 Provides-Extra: dev

{svg_ultralight-0.42.0.dist-info → svg_ultralight-0.43.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-svg_ultralight/__init__.py,sha256=A398qxoBmywPj3WR2sLgxhctsQZGgk_Dwd8jUIB87dU,2819
+svg_ultralight/__init__.py,sha256=3YdTZfa0xUDrPCbOVyx39D9ENks-JEtsi9DFZzvaTf0,2755
 svg_ultralight/animate.py,sha256=SMcQkeWAP9dD08Iyzy9qGG8Qk1p-14WfrB7WSN8Pj_4,1133
 svg_ultralight/image_ops.py,sha256=6V9YkxnhZCBw_hbVyY0uxDj0pZgiEWBSGRuPuOYKY4w,4694
 svg_ultralight/inkscape.py,sha256=ySCxWnQwEt1sosa1b4mEkR-ugpfoAeg9gs1OLPS69iI,9597
@@ -9,12 +9,12 @@ svg_ultralight/nsmap.py,sha256=y63upO78Rr-JJT56RWWZuyrsILh6HPoY4GhbYnK1A0g,1244
 svg_ultralight/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 svg_ultralight/query.py,sha256=iFFsK78TuUT6h3iv_V8_fwCggIAdYa97K7oOPhhoPuY,9711
 svg_ultralight/root_elements.py,sha256=E_H7HXk0M5F3IyFVOxO8PQmhww1-sHTzJhx8hBJPZvg,2911
-svg_ultralight/string_conversion.py,sha256=U5IBhG05DtfSkJlbQ7BKHHbob78CHG6cF_Yr1EdB20U,13829
+svg_ultralight/string_conversion.py,sha256=omCmiwyu5AIDHltPiXIEYQG3KiII1twlUJN2oven0mM,8749
 svg_ultralight/transformations.py,sha256=T3vSxcTWOwWnwu3OF610LHMbKScUIVWICUAvru5zLnU,4488
 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=LFkVsdYFKYCnEL6vLvEa_5cfu8D44ZGYeEEb7_0MnC0,7146
-svg_ultralight/bounding_boxes/padded_text_initializers.py,sha256=fce6gLBAX7Q0L5t8ECwyfvnelTqZRVCPex8TnV7mIv8,7539
+svg_ultralight/bounding_boxes/padded_text_initializers.py,sha256=tPQ5ilZnSm83HH852euoe0V77Nf-78BG7wlE7K8FqnM,7668
 svg_ultralight/bounding_boxes/supports_bounds.py,sha256=T7LGse58fDBgmlzupSC63C1ZMXjFbyzBTsTUaqD_4Sw,4513
 svg_ultralight/bounding_boxes/type_bound_collection.py,sha256=NAEpqo9H9ewhuLcOmBnMWUE0zQ1t4bvckovgvWy6hIo,2645
 svg_ultralight/bounding_boxes/type_bound_element.py,sha256=Sc-R0uXkb0aS8-OcyM5pDukKhFUka0G6KCp6LcYDcIU,2204
@@ -24,11 +24,11 @@ svg_ultralight/constructors/__init__.py,sha256=XLOInLhzMERWNnFAs-itMs-OZrBOpvQth
 svg_ultralight/constructors/new_element.py,sha256=hRUW2hR_BTkthEqPClYV7-IeFe9iv2zwb6ehp1k1xDk,3475
 svg_ultralight/font_tools/__init__.py,sha256=NX3C0vvoB-G4S-h1f0NLWePjYAMMR37D1cl_G4WBjHc,83
 svg_ultralight/font_tools/comp_results.py,sha256=iEDbExO3D7ffo0NZxrqf-WjtzUCJZbdHmqwjjac4laY,10444
-svg_ultralight/font_tools/font_info.py,sha256=00iNrJwWH2-de9CbaG1TqulRFmp_3aOyjRAlqOpT0II,20878
+svg_ultralight/font_tools/font_info.py,sha256=DE8VvGQqsgg1qZyL98OYs7hTC4wEzMF3ynEtdqhyR5Y,26290
 svg_ultralight/font_tools/globs.py,sha256=JdrrGMqDtD4WcY7YGUWV43DUW63RVev-x9vWqsQUhxU,119
 svg_ultralight/strings/__init__.py,sha256=BMGhF1pulscIgkiYvZLr6kPRR0L4lW0jUNFxkul4_EM,295
 svg_ultralight/strings/svg_strings.py,sha256=FQNxNmMkR2M-gCFo_woQKXLgCHi3ncUlRMiaRR_a9nQ,1978
-svg_ultralight-0.42.0.dist-info/METADATA,sha256=Ey-v7B_Us35-JyL8y1p52yjkIZgqNT405c54lDcpGpU,9022
-svg_ultralight-0.42.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-svg_ultralight-0.42.0.dist-info/top_level.txt,sha256=se-6yqM_0Yg5orJKvKWdjQZ4iR4G_EjhL7oRgju-fdY,15
-svg_ultralight-0.42.0.dist-info/RECORD,,
+svg_ultralight-0.43.0.dist-info/METADATA,sha256=_ZAM898pdWypT_-vZDTm_5ERfSDYc8SwN-uu0E4irb0,9052
+svg_ultralight-0.43.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+svg_ultralight-0.43.0.dist-info/top_level.txt,sha256=se-6yqM_0Yg5orJKvKWdjQZ4iR4G_EjhL7oRgju-fdY,15
+svg_ultralight-0.43.0.dist-info/RECORD,,