svg-ultralight 0.64.0__py3-none-any.whl

svg_ultralight/query.py

@@ -0,0 +1,254 @@
+"""Query an SVG file for bounding boxes.
+
+:author: Shay Hill
+:created: 7/25/2020
+
+Bounding boxes are generated with a command-line call to Inkscape, so an Inkscape
+installation is required for this to work. The bounding boxes are returned as
+BoundingBox instances, which are a big help with aligning objects (e.g., text on a
+business card). Getting bounding boxes from Inkscape is not exceptionally fast.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import pickle
+import re
+import uuid
+from contextlib import suppress
+from copy import deepcopy
+from pathlib import Path
+from subprocess import PIPE, Popen
+from tempfile import NamedTemporaryFile, TemporaryFile
+from typing import TYPE_CHECKING, Literal
+from warnings import warn
+
+from lxml import etree
+from lxml.etree import _Comment as EtreeComment  # pyright: ignore[reportPrivateUsage]
+
+from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
+from svg_ultralight.main import new_svg_root, write_svg
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from lxml.etree import (
+        _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
+    )
+
+
+with TemporaryFile() as f:
+    _CACHE_DIR = Path(f.name).parent / "svg_ultralight_cache"
+
+_CACHE_DIR.mkdir(exist_ok=True)
+
+_TEMP_ID_PREFIX = "svg_ultralight-temp_query_module-"
+
+
+def _iter_elems(*elem_args: EtreeElement) -> Iterator[EtreeElement]:
+    """Yield element and sub-elements."""
+    for elem in elem_args:
+        yield from elem.iter()
+
+
+def _fill_ids(*elem_args: EtreeElement) -> None:
+    """Set the id attribute of an element and all its children. Keep existing ids.
+
+    :param elem: an etree element, accepts multiple arguments
+    """
+    for elem in _iter_elems(*elem_args):
+        if isinstance(elem, EtreeComment):
+            continue
+        if elem.get("id") is None:
+            elem.set("id", f"{_TEMP_ID_PREFIX}-{uuid.uuid4()}")
+
+
+def _normalize_views(elem: EtreeElement) -> None:
+    """Create a square viewBox for any element with an svg tag.
+
+    :param elem: an etree element
+
+    This prevents the bounding boxes from being distorted. Only do this to copies,
+    because there's no way to undo it.
+    """
+    for child in elem:
+        _normalize_views(child)
+    if str(elem.tag).endswith("svg"):
+        elem.set("viewBox", "0 0 1 1")
+        elem.set("width", "1")
+        elem.set("height", "1")
+
+
+def _envelop_copies(*elem_args: EtreeElement) -> EtreeElement:
+    """Create an svg root element enveloping all elem_args.
+
+    :param elem_args: one or more etree elements
+    :return: an etree element enveloping copies of elem_args with all views normalized
+    """
+    envelope = new_svg_root(0, 0, 1, 1)
+    envelope.extend([deepcopy(e) for e in elem_args])
+    _normalize_views(envelope)
+    return envelope
+
+
+def _split_bb_string(bb_string: str) -> tuple[str, BoundingBox]:
+    """Split a bounding box string into id and BoundingBox instance.
+
+    :param bb_string: "id,x,y,width,height"
+    :return: (id, BoundingBox(x, y, width, height))
+    """
+    id_, *bounds = bb_string.split(",")
+    x, y, width, height = (float(x) for x in bounds)
+    return id_, BoundingBox(x, y, width, height)
+
+
+def map_elems_to_bounding_boxes(
+    inkscape: str | os.PathLike[str], *elem_args: EtreeElement
+) -> dict[EtreeElement | Literal["svg"], BoundingBox]:
+    r"""Query an svg file for bounding-box dimensions.
+
+    :param inkscape: path to an inkscape executable on your local file system
+        IMPORTANT: path cannot end with ``.exe``.
+        Use something like ``"C:\\Program Files\\Inkscape\\inkscape"``
+    :param elem_args: xml element (written to a temporary file then queried)
+    :return: input svg elements and any descendents of those elements mapped
+        `BoundingBox(x, y, width, height)`
+        So return dict keys are the input elements themselves with one exception: a
+        string key, "svg", is mapped to a bounding box around all input elements.
+    :effects: temporarily adds an id attribute if any ids are missing. These are
+        removed if the function completes. Existing, non-unique ids will break this
+        function.
+
+    Bounding boxes are relative to svg viewBox. If, for instance, viewBox x == -10,
+    all bounding-box x values will be offset -10. So, everything is wrapped in a root
+    element, `envelope` with a "normalized" viewBox, `viewBox=(0, 0, 1, 1)`. That
+    way, any child root elements ("child root elements" sounds wrong, but it works)
+    viewBoxes are normalized as well. This works even with a root element around a
+    root element, so input elem_args can be root elements or "normal" elements like
+    "rect", "circle", or "text" or a mixture of both. Bounding boxes output here will
+    work as expected in any viewBox.
+
+    The ``inkscape --query-all svg`` call will return a tuple:
+
+    (b'svg1,x,y,width,height\\r\\elem1,x,y,width,height\\r\\n', None)
+    where x, y, width, and height are strings of numbers.
+
+    This calls the command and formats the output into a dictionary. There is a
+    little extra complexity to handle cases with duplicate elements. Inkscape will
+    map bounding boxes to element ids *if* those ids are unique. If Inkscape
+    encounters a duplicate ID, Inkscape will map the bounding box of that element to
+    a string like "rect1". If you pass unequal elements with the same id, I can't
+    help you, but you might pass the same element multiple times. If you do this,
+    Inkscape will find a bounding box for each occurrence, map the first occurrence
+    to the id, then map subsequent occurrences to a string like "rect1". This
+    function will handle that.
+    """
+    if not elem_args:
+        return {}
+    _fill_ids(*elem_args)
+
+    envelope = _envelop_copies(*elem_args)
+    with NamedTemporaryFile(mode="wb", delete=False, suffix=".svg") as svg_file:
+        svg = write_svg(svg_file, envelope)
+    with Popen(f'"{inkscape}" --query-all {svg}', stdout=PIPE) as bb_process:
+        bb_data = str(bb_process.communicate()[0])[2:-1]
+    os.unlink(svg_file.name)
+
+    bb_strings = re.split(r"[\\r]*\\n", bb_data)[:-1]
+    id2bbox = dict(map(_split_bb_string, bb_strings))
+
+    elem2bbox: dict[EtreeElement | Literal["svg"], BoundingBox] = {}
+    for elem in _iter_elems(*elem_args):
+        elem_id = elem.attrib.get("id")
+        if not (elem_id):  # id removed in a previous loop
+            continue
+        with suppress(KeyError):
+            # some elems like <style> don't have a bounding box
+            elem2bbox[elem] = id2bbox[elem_id]
+        if elem_id.startswith(_TEMP_ID_PREFIX):
+            del elem.attrib["id"]
+    elem2bbox["svg"] = BoundingBox.union(*id2bbox.values())
+    return elem2bbox
+
+
+def _hash_elem(elem: EtreeElement) -> str:
+    """Hash an EtreeElement.
+
+    Will match identical (excepting id) elements.
+    """
+    elem_copy = deepcopy(elem)
+    with suppress(KeyError):
+        _ = elem_copy.attrib.pop("id")
+    hash_object = hashlib.sha256(etree.tostring(elem_copy))
+    return hash_object.hexdigest()
+
+
+def _try_bbox_cache(elem_hash: str) -> BoundingBox | None:
+    """Try to load a cached bounding box."""
+    cache_path = _CACHE_DIR / elem_hash
+    if not cache_path.exists():
+        return None
+    try:
+        with cache_path.open("rb") as f:
+            return pickle.load(f)
+    except (EOFError, pickle.UnpicklingError) as e:
+        msg = f"Error loading cache file {cache_path}: {e}"
+        warn(msg, stacklevel=2)
+    except Exception as e:
+        msg = f"Unexpected error loading cache file {cache_path}: {e}"
+        warn(msg, stacklevel=2)
+    return None
+
+
+def get_bounding_boxes(
+    inkscape: str | os.PathLike[str], *elem_args: EtreeElement
+) -> tuple[BoundingBox, ...]:
+    r"""Get bounding box around a single element (or multiple elements).
+
+    :param inkscape: path to an inkscape executable on your local file system
+        IMPORTANT: path cannot end with ``.exe``.
+        Use something like ``"C:\\Program Files\\Inkscape\\inkscape"``
+    :param elem_args: xml elements
+    :return: a BoundingBox instance around a each elem_arg
+
+    This will work most of the time, but if you're missing an nsmap, you'll need to
+    create an entire xml file with a custom nsmap (using
+    `svg_ultralight.new_svg_root`) then call `map_elems_to_bounding_boxes` directly.
+    """
+    elem2hash = {elem: _hash_elem(elem) for elem in elem_args}
+    cached = [_try_bbox_cache(h) for h in elem2hash.values()]
+    if None not in cached:
+        return tuple(filter(None, cached))
+
+    hash2bbox = {
+        h: c for h, c in zip(elem2hash.values(), cached, strict=True) if c is not None
+    }
+    remainder = [e for e, c in zip(elem_args, cached, strict=True) if c is None]
+    id2bbox = map_elems_to_bounding_boxes(inkscape, *remainder)
+    for elem in remainder:
+        hash_ = elem2hash[elem]
+        hash2bbox[hash_] = id2bbox[elem]
+        with (_CACHE_DIR / hash_).open("wb") as f:
+            pickle.dump(hash2bbox[hash_], f)
+    return tuple(hash2bbox[h] for h in elem2hash.values())
+
+
+def get_bounding_box(
+    inkscape: str | os.PathLike[str], elem: EtreeElement
+) -> BoundingBox:
+    r"""Get bounding box around a single element.
+
+    :param inkscape: path to an inkscape executable on your local file system
+        IMPORTANT: path cannot end with ``.exe``.
+        Use something like ``"C:\\Program Files\\Inkscape\\inkscape"``
+    :param elem: xml element
+    :return: a BoundingBox instance around a single elem
+    """
+    return get_bounding_boxes(inkscape, elem)[0]
+
+
+def clear_svg_ultralight_cache() -> None:
+    """Clear all cached bounding boxes."""
+    for cache_file in _CACHE_DIR.glob("*"):
+        cache_file.unlink()

svg_ultralight/read_svg.py

@@ -0,0 +1,58 @@
+"""Read SVG file and extract text content.
+
+Note about svg resolution: Despite the fact that vector graphics have effectively
+infinite resolution, ePub apparently uses the actual geometry size to determine the
+resolution of the image. For images ike a business card drawn in real-world inches
+(3.5" width), an ePub will assume a size of 3.5 pixels. There may be some unit for
+the width and height variables (for InDesign, it's pnt) that addresses this, but I
+don't trust it to be consistent across ePub readers. I adjust the units to something
+large, then use CSS to scale it down to the correct size.
+
+:author: Shay Hill
+:created: 2025-07-28
+"""
+
+import os
+from pathlib import Path
+
+from lxml import etree
+from lxml.etree import _Element as EtreeElement  # pyright: ignore[reportPrivateUsage]
+
+import svg_ultralight as su
+
+
+def get_bounding_box_from_root(root: EtreeElement) -> su.BoundingBox:
+    """Extract bounding box from SVG root element.
+
+    :param root: the root element of the SVG file
+    :raise ValueError: if the viewBox attribute is not present
+
+    """
+    viewbox = root.get("viewBox", "")
+    try:
+        x, y, width, height = map(float, viewbox.split())
+    except ValueError as e:
+        msg = f"Invalid or missing viewBox attribute: '{viewbox}'"
+        raise ValueError(msg) from e
+    return su.BoundingBox(x, y, width, height)
+
+
+def parse(svg_file: str | os.PathLike[str]) -> su.BoundElement:
+    """Import an SVG file and return an SVG object.
+
+    :param svg_file: Path to the SVG file.
+    :return: A BoundElement containing the SVG content and the svg viewBox as a
+        BoundingBox.
+
+    Near equivalent to `etree.parse(file).getroot()`, but returns a BoundElement
+    instance. This will only work with SVG files that have a viewBox attribute.
+    """
+    with Path(svg_file).open("r", encoding="utf-8") as f:
+        root = etree.parse(f).getroot()
+    if len(root) == 1:
+        elem = root[0]
+    else:
+        elem = su.new_element("g")
+        elem.extend(list(root))
+    bbox = get_bounding_box_from_root(root)
+    return su.BoundElement(elem, bbox)

svg_ultralight/root_elements.py

@@ -0,0 +1,96 @@
+"""Build root elements in various ways.
+
+:author: Shay Hill
+:created: 2023-09-23
+"""
+
+from __future__ import annotations
+
+from contextlib import suppress
+from typing import TYPE_CHECKING
+
+from svg_ultralight.bounding_boxes import bound_helpers as bound
+from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
+from svg_ultralight.main import new_svg_root
+
+if TYPE_CHECKING:
+    from lxml.etree import (
+        _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
+
+
+def _viewbox_args_from_bboxes(*bboxes: BoundingBox) -> dict[str, float]:
+    """Create x_, y_, width_, height_ new_svg_root arguments from bounding boxes.
+
+    :param bbox: bounding boxes to merge
+    :return: dict of new_svg_root arguments
+    """
+    merged = BoundingBox.union(*bboxes)
+    return {
+        "x_": merged.x,
+        "y_": merged.y,
+        "width_": merged.width,
+        "height_": merged.height,
+    }
+
+
+def new_svg_root_around_bounds(
+    *bounded: SupportsBounds | EtreeElement,
+    pad_: PadArg = 0,
+    print_width_: float | str | None = None,
+    print_height_: float | str | None = None,
+    dpu_: float = 1,
+    nsmap: dict[str | None, str] | None = None,
+    attrib: OptionalElemAttribMapping = None,
+    **attributes: ElemAttrib,
+) -> EtreeElement:
+    """Create svg root around BoundElements.
+
+    :param bounded: BoundingBox istances, BoundElement instances, PaddedText
+        instances, or any other EtreeElement instances. Anything that isn't a
+        bounding box or SupportsBounds will be ignored.
+    :param pad_: optionally increase viewBox by pad in all directions. Acceps a
+        single value or a tuple of values applied to (cycled over) top, right,
+        bottom, left. pad can be floats or dimension strings*
+    :param print_width_: optionally explicitly set unpadded width in units
+        (float) or a dimension string*
+    :param print_height_: optionally explicitly set unpadded height in units
+        (float) or a dimension string*
+    :param dpu_: dots per unit. Scale the output by this factor. This is
+        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)
+    elem: EtreeElement | None = None
+    with suppress(ValueError):
+        elem = bound.new_element_union(*bounded)
+    viewbox = _viewbox_args_from_bboxes(bbox)
+    root = new_svg_root(
+        x_=viewbox["x_"],
+        y_=viewbox["y_"],
+        width_=viewbox["width_"],
+        height_=viewbox["height_"],
+        pad_=pad_,
+        print_width_=print_width_,
+        print_height_=print_height_,
+        dpu_=dpu_,
+        nsmap=nsmap,
+        attrib=attributes,
+    )
+    if elem is None:
+        return root
+    for subelem in elem:
+        root.append(subelem)
+    return root

svg_ultralight/string_conversion.py

@@ -0,0 +1,244 @@
+"""Quasi-private functions for high-level string conversion.
+
+:author: Shay Hill
+:created: 7/26/2020
+
+Rounding some numbers to ensure quality svg rendering:
+* Rounding floats to six digits after the decimal
+"""
+
+from __future__ import annotations
+
+import binascii
+import re
+from enum import Enum
+from typing import TYPE_CHECKING, cast
+
+import svg_path_data
+from lxml import etree
+
+from svg_ultralight.nsmap import NSMAP
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from lxml.etree import (
+        _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.
+
+    :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.
+    """
+    return svg_path_data.format_number(num, resolution=resolution)
+
+
+def format_numbers(
+    nums: Iterable[float] | Iterable[str] | Iterable[float | str],
+) -> list[str]:
+    """Format multiple strings to limited precision.
+
+    :param nums: iterable of floats
+    :return: list of formatted strings
+    """
+    return [format_number(num) for num in nums]
+
+
+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
+    :param val: element attribute value
+    :return: tuple of key, value
+    :raises ValueError: if key is 'd' and val is not a string
+
+    etree.Elements will only accept string
+    values. This saves having to convert input to strings.
+
+    * convert float values to formatted strings
+    * format datastring values when keyword is 'd'
+    * replace '_' with '-' in keywords
+    * remove trailing '_' from keywords
+    * will convert `namespace:tag` to a qualified name
+
+    SVG attribute names like `font-size` and `stroke-width` are not valid python
+    keywords, but can be passed as `font-size` and `stroke-width`.
+
+    Reserved Python keywords that are also valid and useful SVG attribute names (a
+    popular one will be 'class') can be passed with a trailing underscore (e.g.,
+    class_='body_text').
+    """
+    if "http:" in key or "https:" in key:
+        key_ = key
+    elif ":" in key:
+        namespace, tag = key.split(":")
+        key_ = str(etree.QName(NSMAP[namespace], tag))
+    else:
+        key_ = key.rstrip("_").replace("_", "-")
+
+    if val is None:
+        val_ = "none"
+    elif isinstance(val, (int, float)):
+        val_ = format_number(val)
+    else:
+        val_ = val
+
+    return key_, val_
+
+
+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.
+    :return: dict of attributes, each key a valid svg attribute name, each value a str
+    """
+    return dict(_fix_key_and_format_val(key, val) for key, val in attributes.items())
+
+
+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
+    :param attributes: element attribute names and values. Knows what to do with 'text'
+        keyword.V :effects: updates ``elem``
+    """
+    attr_dict = format_attr_dict(**attributes)
+
+    dots = {"text"}
+    for dot in dots & set(attr_dict):
+        setattr(elem, dot, attr_dict.pop(dot))
+
+    for key, val in attr_dict.items():
+        elem.set(key, val)
+
+
+class _TostringDefaults(Enum):
+    """Default values for an svg xml_header."""
+
+    DOCTYPE = (
+        '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"\n'
+        + '"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">'
+    )
+    ENCODING = "UTF-8"
+
+
+def svg_tostring(xml: EtreeElement, **tostring_kwargs: str | bool | None) -> bytes:
+    """Contents of svg file with optional xml declaration.
+
+    :param xml: root node of your svg geometry
+    :param tostring_kwargs: keyword arguments to etree.tostring.
+        pass xml_header=True for sensible defaults, see further documentation on xml
+        header in write_svg docstring.
+    :return: bytestring of svg file contents
+    """
+    tostring_kwargs["pretty_print"] = tostring_kwargs.get("pretty_print", True)
+    if tostring_kwargs.get("xml_declaration"):
+        for default in _TostringDefaults:
+            arg_name = default.name.lower()
+            value = tostring_kwargs.get(arg_name, default.value)
+            tostring_kwargs[arg_name] = value
+    as_bytes = etree.tostring(etree.ElementTree(xml), **tostring_kwargs)  # type: ignore
+    return cast("bytes", as_bytes)
+
+
+def get_view_box_str(
+    x: float,
+    y: float,
+    width: float,
+    height: float,
+    pad: float | tuple[float, float, float, float] = 0,
+) -> str:
+    """Create a space-delimited string.
+
+    :param x: x value in upper-left corner
+    :param y: y value in upper-left corner
+    :param width: width of viewBox
+    :param height: height of viewBox
+    :param pad: optionally increase viewBox by pad in all directions
+    :return: space-delimited string "x y width height"
+    """
+    if not isinstance(pad, tuple):
+        pad = (pad, pad, pad, pad)
+    pad_t, pad_r, pad_b, pad_l = pad
+    pad_h = pad_l + pad_r
+    pad_v = pad_t + pad_b
+    dims = [
+        format_number(x) for x in (x - pad_l, y - pad_t, width + pad_h, height + pad_v)
+    ]
+    return " ".join(dims)
+
+
+# ===================================================================================
+#   Encode and decode arbitrary strings to / from valid CSS class names.
+# ===================================================================================
+
+
+# insert his before any class name that would otherwise start with a digit
+_NAME_PREFIX = "__"
+
+_DELIMITED_HEX = re.compile(r"_[0-9a-fA-F]{2,8}_")
+
+
+def _encode_class_name_invalid_char_to_hex(char: str) -> str:
+    """Encode any invalid single char to a hex representation prefixed with '_x'.
+
+    :param char: The character to encode.
+    :return: A string in the format '_x' followed by the hex value of the character.
+
+    Return valid css-class-name characters unchanged. Encode others. Exception: This
+    function encodes `_`, which *are* valid CSS class characters, in order to reserve
+    underscores for `_` hex delimiters and `__` -name prefixes.
+    """
+    if re.match(r"[a-zA-Z0-9-]", char):
+        return char
+    hex_ = binascii.hexlify(char.encode("utf-8")).decode("ascii")
+    return f"_{hex_}_"
+
+
+def encode_to_css_class_name(text: str) -> str:
+    """Convert text to a valid CSS class name in a reversible way.
+
+    :param text: The text to convert.
+    :return: A valid CSS class name derived from the text. The intended use is to pass
+        a font filename, so the filename can be decoded from the contents of an SVG
+        file and each css class created from a font file will, if the style is not
+        altered, have a unique class name.
+
+    Non-ascii characters like `é` will be encoded as hex, even if they are, by
+    documentation, valid CSS class characters. The class name will be ascii only.
+    """
+    css_class = "".join(_encode_class_name_invalid_char_to_hex(c) for c in text)
+    # add a prefix if the name starts with a digit or is empty
+    if not css_class or not re.match(r"^[a-zA-Z_]", css_class):
+        css_class = _NAME_PREFIX + css_class
+    return css_class
+
+
+def decode_from_css_class_name(css_class: str) -> str:
+    """Reverse the conversion from `filename_to_css_class`.
+
+    :param css_class: The CSS class name to convert back to text. This will not
+        be meaningful if the class name was not created by encode_css_class_name. If
+        you use another string, there is a potential for a hex decoding error.
+    :return: The original filename passed to `filename_to_css_class`.
+    """
+    css_class = css_class.removeprefix(_NAME_PREFIX)
+
+    result = ""
+    while css_class:
+        if match := _DELIMITED_HEX.match(css_class):
+            hex_str = match.group(0)[1:-1]
+            result += binascii.unhexlify(hex_str).decode("utf-8")
+            css_class = css_class[len(match.group(0)) :]
+        else:
+            result += css_class[0]
+            css_class = css_class[1:]
+    return result

svg_ultralight/strings/__init__.py

@@ -0,0 +1,21 @@
+"""Import svg_strings into the svg_ultralight.strings namespace.
+
+:author: Shay Hill
+:created: 2021-12-09
+"""
+
+from svg_ultralight.strings.svg_strings import (
+    svg_color_tuple,
+    svg_float_tuples,
+    svg_floats,
+    svg_ints,
+    svg_matrix,
+)
+
+__all__ = [
+    "svg_color_tuple",
+    "svg_float_tuples",
+    "svg_floats",
+    "svg_ints",
+    "svg_matrix",
+]