batoolset-gui 0.2.0__py3-none-any.whl

batoolset/drawings/svg_clip_renderer.py

@@ -0,0 +1,247 @@
+"""Clip paths for ordinary SVG files drawn with Qt (Qt 6.4-6.11 ignore them).
+
+``ClippingSvgRenderer`` is a QSvgRenderer for SVG files that use
+``clip-path`` (Inkscape, Illustrator and plotting libraries write them often):
+it draws the document element by element in document order, with Qt's own
+renderer for each element (``render(painter, id, bounds)`` keeps the parents'
+styles and transforms), and sets the clip itself around every element that
+references a ``<clipPath>``. Elements without clipping inside are drawn whole.
+
+Output: PDF / raster painters clip natively, so everything stays vector.
+Figure SVG exports do not draw panels through this renderer: they embed the
+panel's SVG source as is (batoolset.drawings.svg_embed). Only when some other
+code draws it to an SVG painter (Qt's SVG writer drops clipping) is each
+clipped element drawn as an image (600 dpi at the drawn size), clipped;
+everything else stays vector.
+
+``make_svg_renderer(path_or_bytes)`` returns a plain QSvgRenderer for SVGs
+without clip paths.
+"""
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ET
+
+from qtpy.QtCore import QByteArray, QPointF, QRectF, Qt
+from qtpy.QtGui import QColor, QImage, QPaintEngine, QPainter, QPainterPath, QPolygonF, QTransform
+from qtpy.QtSvg import QSvgRenderer
+
+from batoolset.drawings.pdf_svg_renderer import parse_path, parse_transform
+
+_SVG_NS = "http://www.w3.org/2000/svg"
+_NOT_DRAWN = {"defs", "clipPath", "mask", "title", "desc", "metadata", "style", "script",
+              "linearGradient", "radialGradient", "pattern", "marker", "symbol", "filter",
+              "font", "font-face", "namedview", "sodipodi:namedview"}
+_URL = re.compile(r"url\(\s*#([^)\s]+)\s*\)")
+_NUM = re.compile(r"[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?")
+SVG_OUTPUT_DPI = 600     # more than any journal asks for
+SVG_OUTPUT_MAX_PIXELS = 40_000_000      # per clipped element (an A4 page at 600 dpi is 35 MP)
+
+
+def _tag(el):
+    return el.tag.split("}", 1)[-1]
+
+
+def _clip_ref(el):
+    ref = el.get("clip-path")
+    if ref is None:
+        m = re.search(r"clip-path\s*:\s*([^;]+)", el.get("style") or "")
+        ref = m.group(1) if m else None
+    m = _URL.search(ref or "")
+    return m.group(1) if m else None
+
+
+def _f(v, d=0.0):
+    try:
+        return float(_NUM.match(str(v).strip()).group(0))
+    except (AttributeError, TypeError, ValueError):
+        return d
+
+
+def _shape_path(el):
+    """QPainterPath of a basic shape / path element, in its own user space."""
+    tag = _tag(el)
+    p = QPainterPath()
+    if tag == "path":
+        p = parse_path(el.get("d"))
+    elif tag == "rect":
+        rx, ry = _f(el.get("rx")), _f(el.get("ry"))
+        r = QRectF(_f(el.get("x")), _f(el.get("y")), _f(el.get("width")), _f(el.get("height")))
+        if rx or ry:
+            p.addRoundedRect(r, rx or ry, ry or rx)
+        else:
+            p.addRect(r)
+    elif tag == "circle":
+        r = _f(el.get("r"))
+        p.addEllipse(QPointF(_f(el.get("cx")), _f(el.get("cy"))), r, r)
+    elif tag == "ellipse":
+        p.addEllipse(QPointF(_f(el.get("cx")), _f(el.get("cy"))), _f(el.get("rx")), _f(el.get("ry")))
+    elif tag in ("polygon", "polyline"):
+        v = [float(x) for x in _NUM.findall(el.get("points") or "")]
+        if len(v) >= 4:
+            p.addPolygon(QPolygonF([QPointF(v[i], v[i + 1]) for i in range(0, len(v) - 1, 2)]))
+            if tag == "polygon":
+                p.closeSubpath()
+    if (el.get("clip-rule") or el.get("fill-rule")) == "evenodd":
+        p.setFillRule(Qt.FillRule.OddEvenFill)
+    return p
+
+
+class ClippingSvgRenderer(QSvgRenderer):
+    """QSvgRenderer that honours clip-path (see the module docstring)."""
+
+    def __init__(self, svg_bytes):
+        root = ET.fromstring(svg_bytes)
+        n = 0
+        for el in root.iter():                    # every element needs an id to be drawn alone
+            if el.get("id") is None and isinstance(el.tag, str):
+                el.set("id", f"__pyf_el_{n}")
+                n += 1
+        ET.register_namespace("", _SVG_NS)
+        ET.register_namespace("xlink", "http://www.w3.org/1999/xlink")
+        data = ET.tostring(root)
+        super().__init__(QByteArray(data))
+        self._root = root
+        self._ids = {el.get("id"): el for el in root.iter() if el.get("id")}
+        self._clipped_below = {}
+        self._mark(root)
+
+    def _mark(self, el):
+        """True if *el* or a descendant references a clip path. Memoised per
+        element: whether a *descendant* (not *el* itself) does."""
+        below = False
+        for child in el:
+            below = self._mark(child) or below
+        self._clipped_below[el.get("id")] = below
+        return below or _clip_ref(el) is not None
+
+    @staticmethod
+    def needed(svg_bytes) -> bool:
+        return b"clip-path" in svg_bytes
+
+    # -- geometry --------------------------------------------------------------
+    def _doc_rect(self, el_id):
+        """The element's bounds in document (viewBox) coordinates."""
+        return self.transformForElement(el_id).mapRect(self.boundsOnElement(el_id))
+
+    def _clip_in_doc(self, el):
+        """The clip path *el* references, in document coordinates, or None."""
+        cp = self._ids.get(_clip_ref(el))
+        if cp is None:
+            return None
+        # userSpaceOnUse: the referencing element's user space = parents x own transform
+        user = parse_transform(el.get("transform")) * self.transformForElement(el.get("id"))
+        units_box = cp.get("clipPathUnits") == "objectBoundingBox"
+        box = self.boundsOnElement(el.get("id")) if units_box else None
+        out = QPainterPath()
+        for child in cp:
+            p = _shape_path(child)
+            if p.isEmpty():
+                continue
+            t = parse_transform(child.get("transform"))
+            if box is not None:
+                t = t * QTransform(box.width(), 0, 0, box.height(), box.left(), box.top())
+            out = out.united((t * user).map(p)) if not out.isEmpty() else (t * user).map(p)
+        nested = self._ids.get(_clip_ref(cp)) if _clip_ref(cp) else None
+        if nested is not None and not out.isEmpty():
+            inner = self._clip_in_doc(cp)
+            if inner is not None:
+                out = out.intersected(inner)
+        return out
+
+    # -- drawing ----------------------------------------------------------------
+    def render(self, painter, *args):
+        if len(args) == 1 and isinstance(args[0], str):
+            return super().render(painter, *args)
+        if len(args) >= 2:
+            return super().render(painter, *args)
+        vb = self.viewBoxF()
+        if vb.isEmpty():
+            vb = QRectF(QPointF(0, 0), QPointF(self.defaultSize().width(), self.defaultSize().height()))
+        bounds = QRectF(args[0]) if args else QRectF(0, 0, vb.width(), vb.height())
+        sx = bounds.width() / vb.width()
+        sy = bounds.height() / vb.height()
+        dx, dy = bounds.left(), bounds.top()
+        if self.aspectRatioMode() == Qt.AspectRatioMode.KeepAspectRatio:
+            s = min(sx, sy)
+            dx += (bounds.width() - vb.width() * s) / 2.0
+            dy += (bounds.height() - vb.height() * s) / 2.0
+            sx = sy = s
+        self._to_target = QTransform(sx, 0, 0, sy, dx - vb.left() * sx, dy - vb.top() * sy)
+        engine = painter.paintEngine()
+        self._svg_output = engine is not None and engine.type() == QPaintEngine.Type.SVG
+        painter.save()
+        try:
+            for child in self._root:
+                self._draw(painter, child, None)
+        finally:
+            painter.restore()
+
+    def _draw(self, painter, el, clip):
+        if not isinstance(el.tag, str) or _tag(el) in _NOT_DRAWN:
+            return
+        el_id = el.get("id")
+        if _clip_ref(el) is not None:
+            own = self._clip_in_doc(el)
+            if own is not None:
+                clip = own if clip is None else clip.intersected(own)
+        if self._clipped_below.get(el_id) and len(el):
+            # a clipped element deeper inside: draw the children one by one,
+            # each inside this element's own clip (if any) and theirs
+            for child in el:
+                self._draw(painter, child, clip)
+            return
+        if not self.elementExists(el_id):
+            return
+        rect = self._doc_rect(el_id)
+        if rect.isEmpty() and rect.width() == 0 and rect.height() == 0:
+            return
+        target = self._to_target.mapRect(rect)
+        if clip is not None and clip.contains(rect):
+            # the clip cuts nothing (Matplotlib clips every artist to its axes):
+            # draw it plainly, so an SVG output keeps it as a vector shape
+            clip = None
+        if clip is None:
+            super().render(painter, el_id, target)
+        elif not self._svg_output:
+            painter.save()
+            painter.setClipPath(self._to_target.map(clip), Qt.ClipOperation.IntersectClip)
+            super().render(painter, el_id, target)
+            painter.restore()
+        else:
+            self._draw_as_image(painter, el_id, target, self._to_target.map(clip))
+
+    def _draw_as_image(self, painter, el_id, target, clip):
+        """SVG output: the clipped element as an image of its visible part."""
+        visible = target.intersected(clip.boundingRect())
+        if visible.isEmpty():
+            return
+        scale = SVG_OUTPUT_DPI / 72.0
+        if visible.width() * visible.height() * scale * scale > SVG_OUTPUT_MAX_PIXELS:
+            scale = (SVG_OUTPUT_MAX_PIXELS / (visible.width() * visible.height())) ** 0.5
+        img = QImage(max(1, int(round(visible.width() * scale))), max(1, int(round(visible.height() * scale))),
+                     QImage.Format.Format_ARGB32_Premultiplied)
+        img.fill(QColor(0, 0, 0, 0))
+        p = QPainter(img)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+        p.scale(img.width() / visible.width(), img.height() / visible.height())
+        p.translate(-visible.left(), -visible.top())
+        p.setClipPath(clip)
+        super().render(p, el_id, target)
+        p.end()
+        painter.drawImage(visible, img, QRectF(img.rect()))
+
+
+def make_svg_renderer(source):
+    """ClippingSvgRenderer for an SVG with clip paths, else QSvgRenderer.
+    *source*: a file path or the SVG bytes."""
+    data = source
+    if isinstance(source, str):
+        with open(source, "rb") as f:
+            data = f.read()
+    if isinstance(data, (bytes, bytearray)) and ClippingSvgRenderer.needed(bytes(data)):
+        try:
+            return ClippingSvgRenderer(bytes(data))
+        except ET.ParseError:
+            pass
+    return QSvgRenderer(QByteArray(bytes(data)) if isinstance(data, (bytes, bytearray)) else source)

batoolset/drawings/svg_embed.py

@@ -0,0 +1,165 @@
+"""SVG export of vector panels without Qt's SVG writer losing anything.
+
+Qt draws an SVG panel (an SVG file, a PDF page, a Matplotlib plot) into an SVG
+export through QSvgRenderer -> QSvgGenerator: text becomes outlines and clip
+paths are lost (clipped elements had to be rasterised). Instead, while a
+figure is exported to SVG inside ``collecting()``, each vector panel draws a
+placeholder rectangle in a unique colour (``place``); once Qt has written the
+file, ``embed(svg_text)`` replaces every placeholder by the panel's own SVG
+source: its elements, clip paths and <text> unchanged, under the placeholder's
+transform, fitted like QSvgRenderer fits it, clipped to the panel by an SVG
+clipPath, with ids prefixed so nothing clashes.
+"""
+from __future__ import annotations
+
+import contextlib
+import re
+import xml.etree.ElementTree as ET
+
+from qtpy.QtCore import QRectF
+from qtpy.QtGui import QColor, QPaintEngine, QPolygonF
+
+SVG_NS = "http://www.w3.org/2000/svg"
+XLINK_NS = "http://www.w3.org/1999/xlink"
+_ACTIVE = []
+_SKIP = {"title", "desc", "metadata", "script"}
+_ROOT_ONLY = {"width", "height", "viewBox", "x", "y", "id", "version", "baseProfile",
+              "preserveAspectRatio", "zoomAndPan", "contentScriptType", "contentStyleType"}
+
+
+def active():
+    """The collector of the SVG export in progress, or None."""
+    return _ACTIVE[-1] if _ACTIVE else None
+
+
+def wants(painter):
+    """True if *painter* writes SVG for an export that embeds vector panels."""
+    try:
+        return active() is not None and painter.paintEngine().type() == QPaintEngine.Type.SVG
+    except Exception:
+        return False
+
+
+@contextlib.contextmanager
+def collecting():
+    """While active, vector panels drawn to an SVG painter become placeholders
+    (see module docstring). Yields the collector; call collector.embed(text)."""
+    collector = SvgEmbedCollector()
+    _ACTIVE.append(collector)
+    try:
+        yield collector
+    finally:
+        _ACTIVE.remove(collector)
+
+
+def _xml_attr(value):
+    return (str(value).replace("&", "&amp;").replace('"', "&quot;")
+            .replace("<", "&lt;").replace(">", "&gt;"))
+
+
+def _tag(el):
+    return el.tag.rsplit("}", 1)[-1]
+
+
+def _prefixed_svg(svg_bytes, prefix):
+    """(view box (x, y, w, h), serialized children of the root) with every id
+    and reference to it prefixed."""
+    ET.register_namespace("", SVG_NS)
+    ET.register_namespace("xlink", XLINK_NS)
+    root = ET.fromstring(svg_bytes)
+    vb = root.get("viewBox")
+    if vb:
+        x, y, w, h = (float(v) for v in vb.replace(",", " ").split())
+    else:
+        def num(v, default):
+            m = re.match(r"\s*([-+]?[\d.]+(?:[eE][-+]?\d+)?)", v or "")
+            return float(m.group(1)) if m else default
+        x, y, w, h = 0.0, 0.0, num(root.get("width"), 100.0), num(root.get("height"), 100.0)
+    ids = {el.get("id") for el in root.iter() if el.get("id")}
+
+    def fix_refs(value):
+        value = re.sub(r"url\(\s*#([^)\s]+)\s*\)",
+                       lambda m: f"url(#{prefix}{m.group(1)})" if m.group(1) in ids else m.group(0), value)
+        return value
+
+    for el in root.iter():
+        for k, v in list(el.attrib.items()):
+            if k == "id":
+                el.set(k, prefix + v)
+            elif k in ("href", f"{{{XLINK_NS}}}href") and v.startswith("#") and v[1:] in ids:
+                el.set(k, "#" + prefix + v[1:])
+            elif "url(" in v:
+                el.set(k, fix_refs(v))
+        if _tag(el) == "style" and el.text:
+            if re.search(r"(^|[}\s])\*\s*\{", el.text):
+                el.text = ""                   # a universal rule would restyle the whole document
+            else:
+                el.text = fix_refs(el.text)
+    parts = [ET.tostring(child, encoding="unicode") for child in root if _tag(child) not in _SKIP]
+    # the root's own presentation attributes (fill, font, style...) still apply
+    root_attrs = {k: v for k, v in root.attrib.items()
+                  if "}" not in k and k not in _ROOT_ONLY}
+    return (x, y, w, h), "".join(parts), root_attrs
+
+
+class SvgEmbedCollector:
+    def __init__(self):
+        self.items = []              # (marker, svg bytes, placements)
+        self._by_source = {}
+
+    def place(self, painter, target, svg_bytes, clip=None, keep_aspect=True):
+        """Draw a placeholder for *svg_bytes* fitted into *target* (current
+        painter coordinates), visible inside *clip* (a QRectF or QPolygonF,
+        same coordinates; default *target*)."""
+        key = id(svg_bytes), len(svg_bytes)
+        if key not in self._by_source:
+            index = len(self.items)
+            marker = "#fd%02x%02x" % (1 + index // 250, 1 + index % 250)
+            self._by_source[key] = index
+            self.items.append((marker, bytes(svg_bytes), []))
+        marker, _, placements = self.items[self._by_source[key]]
+        poly = QPolygonF(QRectF(clip if isinstance(clip, QRectF) else target)) \
+            if not isinstance(clip, QPolygonF) else QPolygonF(clip)
+        placements.append((QRectF(target), poly, keep_aspect, painter.opacity()))
+        painter.save()
+        painter.setOpacity(1.0)
+        painter.fillRect(QRectF(target), QColor(marker))
+        painter.restore()
+
+    def embed(self, svg_text):
+        """Replace the placeholders in the written SVG *svg_text*."""
+        n = 0
+        for k, (marker, source, placements) in enumerate(self.items):
+            if not placements:
+                continue
+            (vx, vy, vw, vh), inner, root_attrs = _prefixed_svg(source, f"pyfp{k}_")
+            attrs = {"fill": "#000000", "stroke": "none", **root_attrs}
+            attr_text = "".join(f' {a}="{_xml_attr(v)}"' for a, v in attrs.items())
+            pattern = re.compile(r'(<g fill="' + re.escape(marker) + r'"[^>]*>\s*)<rect [^>]*/>', re.I)
+
+            def swap(m):
+                nonlocal n
+                if not placements:
+                    return m.group(0)
+                target, poly, keep_aspect, opacity = placements.pop(0)
+                n += 1
+                sx = target.width() / vw
+                sy = target.height() / vh
+                dx, dy = target.x(), target.y()
+                if keep_aspect:
+                    s = min(sx, sy)
+                    dx += (target.width() - vw * s) / 2.0
+                    dy += (target.height() - vh * s) / 2.0
+                    sx = sy = s
+                pts = " ".join(f"{p.x():g},{p.y():g}" for p in poly)
+                cid = f"pyfpclip{n}"
+                group = re.sub(r'fill="' + re.escape(marker) + '"', 'fill="none"', m.group(1), flags=re.I)
+                op = f' opacity="{opacity:g}"' if opacity < 1 else ""
+                return (group
+                        + f'<defs><clipPath id="{cid}"><polygon points="{pts}"/></clipPath></defs>'
+                        + f'<g clip-path="url(#{cid})"{op}><g{attr_text} '
+                          f'transform="matrix({sx:g},0,0,{sy:g},{dx - vx * sx:g},{dy - vy * sy:g})">'
+                        + inner + "</g></g>")
+
+            svg_text = pattern.sub(swap, svg_text)
+        return svg_text

batoolset/drawings/svg_text_renderer.py

@@ -0,0 +1,183 @@
+"""Draw an SVG's ``<text>`` elements as real text, the rest with Qt's renderer.
+
+Qt's SVG renderer draws SVG text as glyph outlines when the target is another
+SVG (QSvgGenerator), so the text of a Matplotlib plot exported with
+``svg.fonttype = 'none'`` still arrived as shapes in the editable PowerPoint /
+Illustrator exports: tick labels and axis titles could not be edited.
+``TextAsTextRenderer`` renders the SVG without its text, then draws each text
+run with ``QPainter.drawText`` at the same place, size, colour and rotation,
+which an SVG painter records as a ``<text>`` element.
+
+Single-glyph runs on one baseline (Matplotlib writes mathtext one glyph per
+``<tspan>``) are joined into one run, so a label stays one editable string.
+"""
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ET
+
+from qtpy.QtCore import QByteArray, QPointF, QRectF, Qt
+from qtpy.QtGui import QColor, QFont, QFontMetricsF, QTransform
+from qtpy.QtSvg import QSvgRenderer
+
+from batoolset.drawings.pdf_svg_renderer import parse_transform
+
+_SVG_NS = "http://www.w3.org/2000/svg"
+_NUM = re.compile(r"[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?")
+
+
+def _tag(el):
+    return el.tag.split("}", 1)[-1] if isinstance(el.tag, str) else ""
+
+
+def _f(v, d=0.0):
+    try:
+        return float(_NUM.match(str(v).strip()).group(0))
+    except (AttributeError, TypeError, ValueError):
+        return d
+
+
+def _style(el, inherited):
+    st = dict(inherited)
+    for part in (el.get("style") or "").split(";"):
+        if ":" in part:
+            k, v = part.split(":", 1)
+            st[k.strip()] = v.strip()
+    for k in ("font-size", "font-family", "font-weight", "font-style", "fill", "text-anchor", "opacity",
+              "fill-opacity"):
+        if el.get(k) is not None:
+            st[k] = el.get(k)
+    return st
+
+
+def _family(value):
+    """First family of a CSS font-family list, without quotes."""
+    first = (value or "").split(",")[0].strip().strip("'\"")
+    return first or "Arial"
+
+
+def _color(value, opacity):
+    c = QColor(0, 0, 0)
+    if value and value != "none":
+        m = re.match(r"rgb\(\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*\)", value)
+        if m:
+            c = QColor(int(float(m.group(1))), int(float(m.group(2))), int(float(m.group(3))))
+        else:
+            c = QColor(value)
+            if not c.isValid():
+                c = QColor(0, 0, 0)
+    c.setAlphaF(max(0.0, min(1.0, opacity)))
+    return c
+
+
+def _runs_of(text_el, style, transform):
+    """[(text, x, y, style, transform)] for a <text> element and its tspans."""
+    runs = []
+    own_x = _f(text_el.get("x"))
+    own_y = _f(text_el.get("y"))
+    if text_el.text and text_el.text.strip():
+        runs.append([text_el.text, own_x, own_y, style, transform])
+    for span in text_el:
+        if _tag(span) != "tspan":
+            continue
+        st = _style(span, style)
+        x = _f(span.get("x"), own_x)
+        y = _f(span.get("y"), own_y)
+        if span.text:
+            runs.append([span.text.replace("\xa0", " "), x, y, st, transform])
+    # mathtext writes its glyphs in drawing order, not reading order
+    runs.sort(key=lambda r: (round(r[2], 3), r[1]))
+    merged = []
+    for run in runs:
+        prev = merged[-1] if merged else None
+        if (prev is not None and abs(prev[2] - run[2]) < 1e-6 and prev[4] == run[4]
+                and prev[3].get("font-size") == run[3].get("font-size")
+                and prev[3].get("text-anchor", "start") == "start"):
+            prev[0] += run[0]
+        else:
+            merged.append(run)
+    return merged
+
+
+class TextAsTextRenderer(QSvgRenderer):
+    """QSvgRenderer for an SVG whose text should stay text (see module doc)."""
+
+    def __init__(self, svg_bytes, make_renderer=None):
+        root = ET.fromstring(svg_bytes)
+        self._texts = []
+        self._collect(root, QTransform(), {}, None)
+        ET.register_namespace("", _SVG_NS)
+        ET.register_namespace("xlink", "http://www.w3.org/1999/xlink")
+        stripped = ET.tostring(root)
+        super().__init__(QByteArray(stripped))
+        # the drawing without its text, by the usual renderer (clip paths...)
+        self._inner = make_renderer(stripped) if make_renderer is not None else QSvgRenderer(QByteArray(stripped))
+        self._pyf_svg_source = bytes(svg_bytes)
+
+    def _collect(self, el, parent_t, parent_style, parent):
+        t = parse_transform(el.get("transform")) * parent_t
+        style = _style(el, parent_style)
+        for child in list(el):
+            if _tag(child) == "text":
+                child_t = parse_transform(child.get("transform")) * t
+                self._texts.extend(_runs_of(child, _style(child, style), child_t))
+                el.remove(child)
+            elif _tag(child) not in ("defs", "clipPath", "style", "metadata"):
+                self._collect(child, t, style, el)
+
+    def text_runs(self):
+        return [(r[0], r[1], r[2]) for r in self._texts]
+
+    def setAspectRatioMode(self, mode):
+        super().setAspectRatioMode(mode)
+        self._inner.setAspectRatioMode(mode)
+
+    def render(self, painter, *args):
+        if len(args) == 1 and isinstance(args[0], str) or len(args) >= 2:
+            return self._inner.render(painter, *args)
+        self._inner.render(painter, *args)
+        vb = self.viewBoxF()
+        if vb.isEmpty():
+            vb = QRectF(QPointF(0, 0), QPointF(self.defaultSize().width(), self.defaultSize().height()))
+        bounds = QRectF(args[0]) if args else QRectF(0, 0, vb.width(), vb.height())
+        sx = bounds.width() / vb.width()
+        sy = bounds.height() / vb.height()
+        dx, dy = bounds.left(), bounds.top()
+        if self.aspectRatioMode() == Qt.AspectRatioMode.KeepAspectRatio:
+            s = min(sx, sy)
+            dx += (bounds.width() - vb.width() * s) / 2.0
+            dy += (bounds.height() - vb.height() * s) / 2.0
+            sx = sy = s
+        to_target = QTransform(sx, 0, 0, sy, dx - vb.left() * sx, dy - vb.top() * sy)
+        device = painter.device()
+        dpi = device.logicalDpiY() if device is not None and device.logicalDpiY() > 0 else 72
+        world = painter.worldTransform()
+        for text, x, y, st, t in self._texts:
+            size = _f(st.get("font-size"), 10.0)
+            if size <= 0:
+                continue
+            font = QFont(_family(st.get("font-family")))
+            font.setPointSizeF(size * 72.0 / dpi)        # 1 SVG unit = 1 device pixel here
+            weight = (st.get("font-weight") or "").lower()
+            font.setBold(weight in ("bold", "bolder") or _f(weight, 400) >= 600)
+            font.setItalic((st.get("font-style") or "").lower() in ("italic", "oblique"))
+            opacity = _f(st.get("opacity"), 1.0) * _f(st.get("fill-opacity"), 1.0)
+            anchor = st.get("text-anchor", "start")
+            width = QFontMetricsF(font, device).horizontalAdvance(text) if anchor != "start" else 0.0
+            shift = width / 2.0 if anchor == "middle" else width if anchor == "end" else 0.0
+            painter.save()
+            painter.setWorldTransform(t * to_target * world)
+            painter.setFont(font)
+            painter.setPen(_color(st.get("fill"), opacity))
+            painter.drawText(QPointF(x - shift, y), text)
+            painter.restore()
+
+
+def make_text_renderer(svg_bytes, make_renderer=None):
+    """A TextAsTextRenderer for *svg_bytes*, or None when it has no text."""
+    if b"<text" not in bytes(svg_bytes):
+        return None
+    try:
+        return TextAsTextRenderer(bytes(svg_bytes), make_renderer=make_renderer)
+    except ET.ParseError:
+        return None