svg-ultralight 0.40.1__tar.gz → 0.42.0__tar.gz

{svg_ultralight-0.40.1/src/svg_ultralight.egg-info → svg_ultralight-0.42.0}/PKG-INFO

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

svg_ultralight-0.42.0/experiments/encode_fonts3.py

@@ -0,0 +1,248 @@
+"""Deterministically encode a font into a base64 string for CSS.
+
+This works fine for a browser, but there is little point. There is no way to
+rasterize a css file with an embedded font like this. Learned some things doing it,
+but Inkscape, Gimp, and everything else I've tried *except* a browser will ignore an
+embedded or locally linked file in a `<style>` element.
+
+:author: Shay Hill
+:created: 2025-06-15
+"""
+
+# pyright: reportMissingTypeStubs = false
+# pyright: reportUnknownMemberType = false
+# pyright: reportUnknownVariableType = false
+
+from __future__ import annotations
+
+import cssutils
+import base64
+import os
+import tempfile
+from pathlib import Path
+
+from svg_ultralight.string_conversion import (
+    encode_to_css_class_name,
+    decode_from_css_class_name,
+)
+
+from fontTools.subset import Subsetter
+from fontTools.ttLib import TTFont
+from fontTools.ttLib.woff2 import compress
+import string
+import warnings
+from typing import Iterable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lxml.etree import (
+        _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
+    )
+
+
+_WESTERN_UTF8_CHAR_SETS = [
+    string.ascii_lowercase,
+    string.ascii_uppercase,
+    string.digits,
+    string.punctuation,
+    "áÁéÉíÍóÓúÚñÑäÄëËïÏöÖüÜçÇàÀèÈìÌòÒùÙâÂêÊîÎôÔûÛãÃõÕåÅæÆøØœŒßÿŸ",
+]
+
+
+def get_robust_char_subset(
+    text: str, char_sets: Iterable[Iterable[str]] = _WESTERN_UTF8_CHAR_SETS
+) -> str | None:
+    """Infer a subset of characters likely to be used from a sample text.
+
+    :param text: Sample text to infer the subset from.
+    :param char_sets: List of character sets to use for inference. Each set is a
+        string of characters. The default is a list of common western UTF-8
+        character sets. Include all characters from any set that is used in the text.
+    :return: A string of characters that are likely to be used in the text. Default
+        subsets to include are lowercase, uppercase, digits, punctuation, and a set
+        of common western diacritics. Space is always included.
+
+    This function is for selecting which characters will be encoded inside a css
+    class--which is itself inside an svg file.
+
+    Fonts can be large. The smallest solution is to only encode the characters used
+    in the text, but that can be inflexible. A robust subset allows characters that
+    are similar to the text, so there is a little room to correct spelling or alter
+    the text.
+    """
+    char_sets_ = [set(x) for x in char_sets]
+    chars_known = {" "}.union(*char_sets)
+    chars_used = set(text)
+    if chars_used - chars_known:
+        warnings.warn("Cannot create subset char sets. Returning None.")
+        return None
+
+    subset = {" "}
+    for char_set in char_sets_:
+        if chars_used & char_set:
+            subset |= char_set
+    return "".join(sorted(subset))
+
+
+def font_to_woff2(
+    font_path: str | os.PathLike[str],
+    woff2_path: str | os.PathLike[str],
+    subset: str | None = None,
+) -> None:
+    """Convert a (subset of a) font to woff2.
+
+    :param font_path: Path to the original font file. Ttf and otf both work, but otf
+        may show warnings (implemented as logging messages in fontTools. I have not
+        silenced these. It may be a better idea to avoid subsetting otf fonts.
+    :param woff2_path: Path to output.
+    :param subset: String of characters to include in the subset. If None, the entire
+        font is used.
+    """
+    font = TTFont(font_path, recalcTimestamp=False)
+    font.flavor = "woff2"
+
+    if subset is not None:
+        subsetter = Subsetter()
+        unicodes = set(map(ord, subset))
+        subsetter.populate(unicodes=unicodes)
+        subsetter.subset(font)
+
+    font.save(woff2_path)
+
+
+def encode_font_to_woff2_base64(
+    font_path: str | os.PathLike[str], subset: str | None = None
+) -> str:
+    """Encode a WOFF2 font file to a base64 string useable in CSS.
+
+    :param font_path: Path to the original font file. Ttf and otf both work, but otf
+        may show warnings (implemented as logging messages in fontTools. I have not
+        silenced these. It may be a better idea to avoid subsetting otf fonts.
+    :param subset: String of characters to include in the subset. If None, the entire
+        font is used.
+    """
+    with tempfile.NamedTemporaryFile(suffix=".woff2", delete=False) as f:
+        woff2_path = f.name
+    with tempfile.NamedTemporaryFile(suffix=".woff2", delete=False) as f:
+        woff2_compressed = f.name
+
+    try:
+        font_to_woff2(font_path, woff2_path, subset)
+        compress(woff2_path, woff2_compressed)
+        with open(woff2_compressed, "rb") as woff2_file:
+            woff2_data = woff2_file.read()
+        return base64.b64encode(woff2_data).decode("utf-8")
+    finally:
+        os.unlink(woff2_path)
+        os.unlink(woff2_compressed)
+
+
+def _find_font_file(name: str, *font_dirs: str | os.PathLike[str]) -> Path | None:
+    """Find a font file in the given directories.
+
+    :param name: The name of the font file to find.
+    :param font_dirs: Directories to search for the font file.
+    :return: The path to the font file if found, otherwise None.
+    """
+    if not font_dirs:
+        return None
+    for file in Path(font_dirs[0]).glob("*"):
+        if file.is_file() and file.name == name:
+            return Path(file)
+    return _find_font_file(name, *font_dirs[1:])
+
+
+def encode_local_fonts(root: EtreeElement, *font_dirs: str | os.PathLike[str]) -> None:
+    """Encode all local fonts in the given SVG root element.
+
+    :param root: The root element of the SVG document.
+    :param font_dirs: directories to search for local fonts.
+    """
+    font2text: dict[str, set[str]] = {}
+    for elem in root.iterdescendants("text"):
+        elem_class = elem.attrib.get("class", "")
+        if elem_class[-7:].lower() not in {"_2e_ttf", "_2e_otf"}:
+            continue
+        _ = font2text.setdefault(elem_class, set())
+        font2text[elem_class] |= set(elem.text or "")
+
+    if not font2text:
+        return
+
+    encoded: list[tuple[str, str]] = []
+    for font_class, chars in font2text.items():
+        font_name = decode_from_css_class_name(font_class)
+        font_file = _find_font_file(font_name, *font_dirs)
+        if font_file is None:
+            msg = f"Font file '{font_name}' not found in specified directories."
+            raise FileNotFoundError(msg)
+
+        base64 = encode_font_to_woff2_base64(font_file, subset="".join(chars))
+        encoded.append((font_class, base64))
+
+    style = root.find("style")
+    if style is None:
+        style = new_element("style", type="text/css")
+        root.insert(0, style)
+    css = style.text or ""
+    stylesheet = cssutils.parseString(css)
+
+    for font_class, base64 in encoded:
+        font_face_rule = cssutils.css.CSSFontFaceRule()
+        font_face_rule.style = cssutils.css.CSSStyleDeclaration()
+        font_face_rule.style["font-family"] = f'{font_class}'
+        font_face_rule.style["src"] = f"url('data:font/woff2;base64,{base64}') format('woff2')"
+        stylesheet.add(font_face_rule)
+
+        style_rule = cssutils.css.CSSStyleRule(selectorText=f".{font_class}")
+        style_rule.style = cssutils.css.CSSStyleDeclaration()
+        style_rule.style["font-family"] = f'"{font_class}"'
+        stylesheet.add(style_rule)
+
+    style.text = stylesheet.cssText.decode("utf-8")
+
+
+from svg_ultralight.main import new_svg_root
+from svg_ultralight.constructors import new_element, new_sub_element
+
+root = new_svg_root(x_=0, y_=-10, width_=100, height_=100)
+
+class_ = encode_to_css_class_name("AGENCYB.TTF")
+for i in range(6):
+    _ = new_sub_element(root, "text", text=f"Hello World {i}", class_=class_)
+
+
+FONTS_DIRS = [
+    Path(r"C:\Windows\Fonts"),
+    Path(r"C:\Users\shaya\AppData\Local\Microsoft\Windows\Fonts"),
+]
+
+encode_local_fonts(root, *FONTS_DIRS)
+
+from svg_ultralight.main import write_svg
+
+# _ = write_svg("temp.svg", root)
+
+import time
+
+# Example usage:
+from pathlib import Path
+import random
+
+# input_font = str(Path("C:/Windows/Fonts/AGENCYB.TTF"))
+# aaa = None
+# bbb = None
+# for i in range(10):
+#     if i % 3 == 0:
+#         chars = "".join(list(set(input_font)))
+#     elif i % 3 == 1:
+#         chars = get_robust_char_subset(input_font)
+#     else:
+#         chars = None
+#     print(chars)
+#     result = encode_woff2_to_base64(input_font, chars)
+#     bbb = result
+#     aaa = aaa or bbb
+#     print(aaa == bbb)
+#     print(len(bbb))
+#     aaa = bbb
+#     time.sleep(1)  # Sleep for 1 second to avoid rapid file creation

{svg_ultralight-0.40.1 → svg_ultralight-0.42.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "svg-ultralight"
-version = "0.40.1"
+version = "0.42.0"
 description = "a sensible way to create svg files with Python"
 authors = [{ name = "Shay Hill", email = "shay_public@hotmail.com" }]
 license = { text = "MIT" }
@@ -49,7 +49,7 @@ convention = "pep257"
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.40.1"
+version = "0.42.0"
 tag_format = "$version"
 version_files = ["pyproject.toml:^version"]
 annotated_tag = true

{svg_ultralight-0.40.1 → svg_ultralight-0.42.0}/src/svg_ultralight/font_tools/font_info.py

@@ -383,7 +383,7 @@ class FTTextInfo:
     @property
     def bpad(self) -> float:
         """Return the bottom padding for the text."""
-        return self.descent - self.bbox.y2
+        return -self.descent - self.bbox.y2
 
     @property
     def lpad(self) -> float:
@@ -433,8 +433,8 @@ def get_padded_text_info(
     :param font_size: the font size to use.
     :param ascent: the ascent of the font. If not provided, it will be calculated
         from the font file.
-    :param descent: the descent of the font. If not provided, it will be calculated
-        from the font file.
+    :param descent: the descent of the font, usually a negative number. If not
+        provided, it will be calculated from the font file.
     :param y_bounds_reference: optional character or string to use as a reference
         for the ascent and descent. If provided, the ascent and descent will be the y
         extents of the capline reference. This argument is provided to mimic the
@@ -447,7 +447,7 @@ def get_padded_text_info(
     if y_bounds_reference:
         capline_info = FTTextInfo(font_info, y_bounds_reference, font_size)
         ascent = -capline_info.bbox.y
-        descent = capline_info.bbox.y2
+        descent = -capline_info.bbox.y2
 
     return FTTextInfo(font_info, text, font_size, ascent, descent)
 

{svg_ultralight-0.40.1 → svg_ultralight-0.42.0}/src/svg_ultralight/string_conversion.py

@@ -27,10 +27,88 @@ if TYPE_CHECKING:
     )
 
 
-def format_number(num: float | str) -> str:
+_MAYBE_NEG = r"(?:(?P<negative>-?))"
+_MAYBE_INT = r"(?:(?P<integer>\d+?))"
+_MAYBE_FRACTION = r"(?:\.(?P<fraction>\d+))?"
+_MAYBE_EXP = r"(?:[eE](?P<exponent>[+-]?\d+))?"
+
+# 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.
+    """
+    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
@@ -38,15 +116,20 @@ def format_number(num: float | str) -> str:
     giving six. Mostly to eliminate exponential notation, but I'm "rstripping" the
     strings to reduce filesize and increase readability
 
-    * reduce fp precision to 6 digits
+    * 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
     """
-    as_str = f"{float(num):0.6f}".rstrip("0").rstrip(".")
-    if as_str == "-0":
-        as_str = "0"
-    return as_str
+    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
 
 
 def format_numbers(

{svg_ultralight-0.40.1 → svg_ultralight-0.42.0/src/svg_ultralight.egg-info}/PKG-INFO

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

{svg_ultralight-0.40.1 → svg_ultralight-0.42.0}/src/svg_ultralight.egg-info/SOURCES.txt

@@ -4,6 +4,8 @@ README.md
 dev-requirements.txt
 pyproject.toml
 tox.ini
+experiments/encode_fonts3.py
+experiments/font_css.py
 src/svg_ultralight/__init__.py
 src/svg_ultralight/animate.py
 src/svg_ultralight/image_ops.py
@@ -35,7 +37,6 @@ src/svg_ultralight/constructors/__init__.py
 src/svg_ultralight/constructors/new_element.py
 src/svg_ultralight/font_tools/__init__.py
 src/svg_ultralight/font_tools/comp_results.py
-src/svg_ultralight/font_tools/font_css.py
 src/svg_ultralight/font_tools/font_info.py
 src/svg_ultralight/font_tools/globs.py
 src/svg_ultralight/strings/__init__.py

{svg_ultralight-0.40.1 → svg_ultralight-0.42.0}/tests/test_layout.py

@@ -175,14 +175,14 @@ class TestLayout:
         viewbox = (0, 0, 96, 0)
         padded, width_attribs = layout.pad_and_scale(viewbox, "0.25in", "2in")
         assert padded == (-12, -12, 120, 24)
-        assert width_attribs == {"width": "2.5in", "height": "0.5in"}
+        assert width_attribs == {"width": "2.5in", "height": ".5in"}
 
     def test_0_height(self):
         """Test that print width is used to calculate pad"""
         viewbox = (0, 0, 0, 96)
         padded, width_attribs = layout.pad_and_scale(viewbox, "0.25in", None, "2in")
         assert padded == (-12, -12, 24, 120)
-        assert width_attribs == {"width": "0.5in", "height": "2.5in"}
+        assert width_attribs == {"width": ".5in", "height": "2.5in"}
 
     def test_string_padding(self):
         """Test that string padding is converted to float"""
@@ -229,7 +229,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] == ['-0.1', '-0.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):

{svg_ultralight-0.40.1 → svg_ultralight-0.42.0}/tests/test_new_element.py

@@ -41,7 +41,7 @@ class TestNewElement:
     def test_float(self) -> None:
         """Floats at 0.6f precision."""
         elem = constructors.new_element("text", x=1 / 3)
-        assert etree.tostring(elem) == b'<text x="0.333333"/>'
+        assert etree.tostring(elem) == b'<text x=".333333"/>'
 
 
 class TestNewSubElement:

{svg_ultralight-0.40.1 → svg_ultralight-0.42.0}/tests/test_string_conversion.py

@@ -6,12 +6,54 @@
 
 # pyright: reportPrivateUsage=false
 import random
+import itertools as it
 import string
+from collections.abc import Iterator
+from decimal import Decimal
+
 import pytest
 
 import svg_ultralight.string_conversion as mod
 
 
+_FLOAT_ITERATIONS = 100
+
+def random_floats() -> Iterator[float]:
+    """Yield random float values within(-ish) precision limits.
+
+    Value may exceed the precision limits of the system.
+    """
+    for _ in range(_FLOAT_ITERATIONS):
+        yield random.uniform(1e-20, 1e20)
+
+def low_numbers() -> Iterator[float]:
+    """Yield random float values below precision limits.
+
+    Value may exceed the precision limits of the system.
+    """
+    for _ in range(_FLOAT_ITERATIONS):
+        yield random.uniform(1e-25, 1e-24)
+
+def high_numbers() -> Iterator[float]:
+    """Yield random float values above precision limits.
+
+    Value may exceed the precision limits of the system.
+    """
+    for _ in range(_FLOAT_ITERATIONS):
+        yield random.uniform(1e+24, 1e+25)
+
+
+def random_ints() -> Iterator[int]:
+    """Yield random integer values."""
+    big_int = 2**63 - 1
+    for _ in range(_FLOAT_ITERATIONS):
+        yield random.randint(-big_int, big_int)
+
+def random_numbers() -> Iterator[float]:
+    """Yield random numbers values."""
+    return it.chain(random_floats(), low_numbers(), high_numbers(), random_ints())
+
+
 class TestFormatNuber:
     def test_negative_zero(self):
         """Remove "-" from "-0"."""
@@ -22,6 +64,8 @@ class TestFormatNuber:
         assert mod.format_number(1.0000000001) == "1"
 
 
+
+
 class TestFormatNumbers:
     def test_empty(self):
         """Return empty list."""
@@ -31,10 +75,31 @@ class TestFormatNumbers:
         """Return list of formatted strings."""
         assert mod.format_numbers([1, 2, 3]) == ["1", "2", "3"]
 
+    @pytest.mark.parametrize("num", random_numbers())
+    def test_exp_vs_fp_notation(self, num: float):
+        """Exponential and fp notation have the same value.
+
+        The first assertion is a sanity check.
+        """
+        expect = float(str(num))
+        assert expect == float(Decimal(num))
+        assert expect == float(mod._format_as_fixed_point(str(num)))
+        assert expect == float(mod._format_as_exponential(str(num)))
+
+    @pytest.mark.parametrize("num", random_numbers())
+    def test_exponent_integer_part_is_len_1_or_stripped(self, num: float):
+        """Integer part is one digit."""
+        exponential = mod._format_as_exponential(num)
+        # Result is exactly one digit
+        if "." not in exponential:
+            assert exponential.lstrip("-").isdigit()
+        # Result is nothing before decimal or one non-zero digit before decimal.
+        integer = exponential.split(".")[0].lstrip("-")
+        assert not integer or integer in "123456789"
 
 class TestFormatNumbersInString:
     def test_empty(self):
-        """Return empty string."""
+        """Return empty string.."""
         assert mod.format_numbers_in_string("") == ""
 
     def test_no_numbers(self):
@@ -81,14 +146,14 @@ class TestFormatAttrDict:
 
     def test_datastring(self):
         """Find and format floats in a datastring."""
-        assert mod.format_attr_dict(d="M1.0,0 Q -0,.33333333 1,2z") == {
-            "d": "M1,0 Q 0,0.333333 1,2z"
+        assert mod.format_attr_dict(d="M1.0,0 Q -0,.33333333333 1,2z") == {
+            "d": "M1,0 Q 0,.333333 1,2z"
         }
 
     def test_datastring_with_exponential_number(self):
         """Find and format floats in a datastring."""
         assert mod.format_attr_dict(d="M1.0,1.0e-10 Q -0,.33333333 1,2z") == {
-            "d": "M1,0 Q 0,0.333333 1,2z"
+            "d": "M1,0 Q 0,.333333 1,2z"
         }
 
     def test_format_string(self):