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

{svg_ultralight-0.42.0 → svg_ultralight-0.43.0}/.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 ci:
   skip: [pyright]
 
-exclude: "tests"
+exclude: "experiments"
 
 repos:
 
@@ -84,6 +84,7 @@ repos:
   # PGH003 Use specific rule codes when ignoring type issues
   # PLR0913 Too many arguments to function call
   # PTH108 os.unlink should be replaced by .unlink()
+  # SIM108 insists on ternary operator
   #
   # S101 Use of `assert` detected
   # S603 `subprocess` call: check for execution of untrusted input
@@ -94,15 +95,16 @@ repos:
   # 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'
   hooks:
     - id: ruff
       name: "ruff-lint"
-      exclude: "tests"
+      # exclude: "tests"
       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
+      - --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
       - --fix
       - --fixable=RUF022
     - id: ruff

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

@@ -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 → svg_ultralight-0.43.0}/dev-requirements.txt

@@ -8,7 +8,7 @@ argcomplete==3.6.2
     # via commitizen
 beautifulsoup4==4.13.4
     # via types-lxml
-cachetools==6.0.0
+cachetools==6.1.0
     # via tox
 cfgv==3.4.0
     # via pre-commit
@@ -21,7 +21,7 @@ colorama==0.4.6
     #   commitizen
     #   pytest
     #   tox
-commitizen==4.8.2
+commitizen==4.8.3
     # via svg-ultralight (pyproject.toml)
 cssselect==1.3.0
     # via types-lxml
@@ -35,15 +35,17 @@ filelock==3.18.0
     # via
     #   tox
     #   virtualenv
-fonttools==4.58.1
+fonttools==4.58.5
     # via svg-ultralight (pyproject.toml)
 identify==2.6.12
     # via pre-commit
+importlib-metadata==8.7.0
+    # via commitizen
 iniconfig==2.1.0
     # via pytest
 jinja2==3.1.6
     # via commitizen
-lxml==5.4.0
+lxml==6.0.0
     # via svg-ultralight (pyproject.toml)
 markupsafe==3.0.2
     # via jinja2
@@ -58,8 +60,10 @@ packaging==25.0
     #   pytest
     #   tox
 paragraphs==1.0.1
-    # via svg-ultralight (pyproject.toml)
-pillow==11.2.1
+    # via
+    #   svg-path-data
+    #   svg-ultralight (pyproject.toml)
+pillow==11.3.0
     # via svg-ultralight (pyproject.toml)
 platformdirs==4.3.8
     # via
@@ -73,11 +77,11 @@ pre-commit==4.2.0
     # via svg-ultralight (pyproject.toml)
 prompt-toolkit==3.0.51
     # via questionary
-pygments==2.19.1
+pygments==2.19.2
     # via pytest
 pyproject-api==1.9.1
     # via tox
-pytest==8.4.0
+pytest==8.4.1
     # via svg-ultralight (pyproject.toml)
 pyyaml==6.0.2
     # via
@@ -87,17 +91,19 @@ questionary==2.1.0
     # via commitizen
 soupsieve==2.7
     # via beautifulsoup4
-termcolor==2.5.0
+svg-path-data==0.3.0
+    # via svg-ultralight (pyproject.toml)
+termcolor==3.1.0
     # via commitizen
-tomlkit==0.13.2
+tomlkit==0.13.3
     # via commitizen
-tox==4.26.0
+tox==4.27.0
     # via svg-ultralight (pyproject.toml)
 types-html5lib==1.1.11.20250516
     # via types-lxml
 types-lxml==2025.3.30
     # via svg-ultralight (pyproject.toml)
-typing-extensions==4.14.0
+typing-extensions==4.14.1
     # via
     #   beautifulsoup4
     #   svg-ultralight (pyproject.toml)
@@ -108,3 +114,5 @@ virtualenv==20.31.2
     #   tox
 wcwidth==0.2.13
     # via prompt-toolkit
+zipp==3.23.0
+    # via importlib-metadata

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

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

{svg_ultralight-0.42.0 → svg_ultralight-0.43.0}/src/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-0.42.0 → svg_ultralight-0.43.0}/src/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-0.42.0 → svg_ultralight-0.43.0}/src/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-0.42.0 → svg_ultralight-0.43.0}/src/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 → svg_ultralight-0.43.0/src/svg_ultralight.egg-info}/PKG-INFO

@@ -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 → svg_ultralight-0.43.0}/src/svg_ultralight.egg-info/requires.txt

@@ -3,6 +3,7 @@ fonttools
 lxml
 paragraphs
 pillow
+svg-path-data
 types-lxml
 typing-extensions
 

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

@@ -5,19 +5,18 @@
 """
 
 # pyright: reportPrivateUsage=false
-import random
 import itertools as it
+import random
 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.
 
@@ -26,6 +25,7 @@ def random_floats() -> Iterator[float]:
     for _ in range(_FLOAT_ITERATIONS):
         yield random.uniform(1e-20, 1e20)
 
+
 def low_numbers() -> Iterator[float]:
     """Yield random float values below precision limits.
 
@@ -34,13 +34,14 @@ def low_numbers() -> Iterator[float]:
     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)
+        yield random.uniform(1e24, 1e25)
 
 
 def random_ints() -> Iterator[int]:
@@ -49,12 +50,15 @@ def random_ints() -> Iterator[int]:
     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:
+    """Test format_number function."""
+
     def test_negative_zero(self):
         """Remove "-" from "-0"."""
         assert mod.format_number(-0.0000000001) == "0"
@@ -64,9 +68,9 @@ class TestFormatNuber:
         assert mod.format_number(1.0000000001) == "1"
 
 
-
-
 class TestFormatNumbers:
+    """Test format_numbers function."""
+
     def test_empty(self):
         """Return empty list."""
         assert mod.format_numbers([]) == []
@@ -75,93 +79,18 @@ 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.."""
-        assert mod.format_numbers_in_string("") == ""
-
-    def test_no_numbers(self):
-        """Return string with no changes."""
-        assert mod.format_numbers_in_string("hello") == "hello"
-
-    def test_numbers(self):
-        """Return string with numbers formatted."""
-        assert mod.format_numbers_in_string("1.0000000001") == "1"
-
-    def test_skip_text(self):
-        """Skip text."""
-        key = "text"
-        val = "1.000000000000000000"
-        assert mod._fix_key_and_format_val(key, val) == (key, val)
-
-    def test_skip_id(self):
-        """Skip text."""
-        key = "id"
-        val = "1.000000000000000000"
-        assert mod._fix_key_and_format_val(key, val) == (key, val)
-
-    def test_skip_hex_colors(self):
-        """Skip hex colors."""
-        assert mod.format_numbers_in_string("#000000") == "#000000"
-
 
 class TestFormatAttrDict:
+    """Test format_attr_dict function."""
+
     def test_float(self):
         """Return string of float."""
         assert mod.format_attr_dict(x=1.0) == {"x": "1"}
 
-    def test_float_string(self):
-        """Return string of float."""
-        assert mod.format_attr_dict(x="1.0") == {"x": "1"}
-
     def test_exponential_float(self):
-        """Return string of float."""
-        assert mod.format_attr_dict(x="1.0e-10") == {"x": "0"}
-
-    def test_exponential_float_string(self):
         """Return string of float."""
         assert mod.format_attr_dict(x=1.0e-10) == {"x": "0"}
 
-    def test_datastring(self):
-        """Find and format floats in a datastring."""
-        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,.333333 1,2z"
-        }
-
-    def test_format_string(self):
-        """Format floats in a format SVG attribute string."""
-        assert mod.format_attr_dict(transform="translate(1.0, -0) scale(1.0, 1.0)") == {
-            "transform": "translate(1, 0) scale(1, 1)"
-        }
-
     def test_trailing_underscore(self):
         """Remove trailing underscore from key."""
         assert mod.format_attr_dict(x_=1) == {"x": "1"}
@@ -181,16 +110,19 @@ def _generate_random_utf8_string():
         + string.whitespace
         + additional_chars
     )
-    random_string = "".join(random.choice(characters) for _ in range(length))
-    return random_string
+    return "".join(random.choice(characters) for _ in range(length))
+
 
 @pytest.fixture(params=range(100))
 def random_utf8_string(request: pytest.FixtureRequest) -> str:
+    """Generate a random UTF-8 string for testing."""
     _ = request.param
     return _generate_random_utf8_string()
 
 
 class TestEncodeCssClassName:
+    """Test encode_to_css_class_name and decode_from_css_class_name functions."""
+
     def test_encode_decode(self, random_utf8_string: str):
         """Encode - decode will return the original string."""
         encoded = mod.encode_to_css_class_name(random_utf8_string)
@@ -202,4 +134,4 @@ class TestEncodeCssClassName:
     def test_encode_valid(self, random_utf8_string: str):
         """All encoded strings will be ascii, _, and -."""
         encoded = mod.encode_to_css_class_name(random_utf8_string)
-        assert all(c.isascii() or c in {'_', '-'} for c in encoded)
+        assert all(c.isascii() or c in {"_", "-"} for c in encoded)