endstation 0.2.0__py3-none-any.whl

endstation/__init__.py

@@ -0,0 +1,60 @@
+"""Shared scaffolding for desktop scientific applications.
+
+Not a science library. Everything here is the apparatus that surrounds an
+analysis: guarding optional dependencies, reporting and cancelling slow work,
+collecting form errors, locating research data that is deliberately not in the
+checkout, running work off the UI thread, embedding a figure, rendering a
+documentation page, and building a macOS bundle.
+
+**The core imports nothing.** ``endstation``, ``endstation.optional``,
+``endstation.progress``, ``endstation.forms`` and ``endstation.paths`` have no
+third-party dependencies at all, so a package that declares
+``dependencies = []`` can adopt them without giving that up. numpy, matplotlib
+and a Qt binding live behind extras and are imported inside the functions that
+need them:
+
+========================  ===========  ====================================
+Subpackage                Extra        Needs
+========================  ===========  ====================================
+``endstation.qt``         ``qt``       PySide6, matplotlib
+``endstation.docs``       ``docs``     matplotlib, for math only
+``endstation.testing``    ``testing``  pytest
+``endstation.tools``      --           macOS ``sips``/``iconutil`` at runtime
+========================  ===========  ====================================
+
+Importing this module must therefore stay cheap and toolkit-free; the names
+re-exported below are from the dependency-free core only. Reach into the
+subpackages explicitly for anything else.
+"""
+
+from __future__ import annotations
+
+from .forms import ErrorCollector, FieldError, FormErrors
+from .optional import MissingExtra, optional_module, require_extra
+from .paths import MissingData, data_root, find_data, find_project_root, require_dir
+from .progress import Cancelled, cancelling, report, throttled
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "__version__",
+    # optional dependencies
+    "MissingExtra",
+    "optional_module",
+    "require_extra",
+    # progress and cancellation
+    "Cancelled",
+    "cancelling",
+    "report",
+    "throttled",
+    # form validation
+    "ErrorCollector",
+    "FieldError",
+    "FormErrors",
+    # paths
+    "MissingData",
+    "data_root",
+    "find_data",
+    "find_project_root",
+    "require_dir",
+]

endstation/docs/__init__.py

@@ -0,0 +1,34 @@
+"""Documentation pages: an ordered index, and markdown rendered for a Qt viewer.
+
+Four projects had a version of this and each had a capability the others
+lacked -- one rendered LaTeX, one prerendered HTML for an older Qt, one shipped
+its pages as package data, one published them to a GitHub wiki. This is the
+union.
+
+Toolkit-free: nothing here imports Qt. :mod:`endstation.docs.markdown` produces
+HTML plus a dictionary of PNG bytes, and the widget layer registers those with
+``QTextDocument.addResource``. That keeps the whole pipeline testable down to
+the bytes, with no display.
+
+Needs matplotlib for math rendering, which is the ``mpl`` extra. Structure
+conversion alone works without it -- pass ``render_math=False``.
+"""
+
+from __future__ import annotations
+
+from .index import Page, PageIndex, load_pages, title_of
+from .markdown import MATH_URL_PREFIX, RenderedPage, to_html
+from .mathtext import Segment, split_segments, strip_boxed
+
+__all__ = [
+    "MATH_URL_PREFIX",
+    "Page",
+    "PageIndex",
+    "RenderedPage",
+    "Segment",
+    "load_pages",
+    "split_segments",
+    "strip_boxed",
+    "title_of",
+    "to_html",
+]

endstation/docs/index.py

@@ -0,0 +1,138 @@
+"""Which documentation pages exist, and what order they read in.
+
+Toolkit-free on purpose, like the rest of the pure layer: a build script needs
+to know what to generate, a test needs to check the set is current, and a CLI
+``--explain`` should be able to print the same prose the window shows. None of
+those should need a GUI installed.
+
+**Ordering is explicit, not alphabetical.** A reader should meet the overview
+before the correction it motivates, and alphabetical ordering puts
+``facet-fitting`` before ``overview`` for no reason anyone can defend. A page
+listed in the order but missing from disk is skipped rather than raising -- a
+half-written set should not stop a window opening -- and a page found on disk
+but absent from the order is appended, so adding a file does not also require
+registering it in a second place.
+
+**A missing directory degrades to an explanatory entry.** Pages that live at
+the repository root ship in a checkout and not in a wheel; pages shipped as
+package data ship in both. Either is a legitimate arrangement, but a Help menu
+that silently loses half its items when installed is not -- so an unavailable
+page still appears and says why.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+__all__ = ["Page", "PageIndex", "load_pages"]
+
+_TITLE = re.compile(r"^#\s+(.+)$", re.MULTILINE)
+
+
+@dataclass(frozen=True)
+class Page:
+    """One documentation page, available or not."""
+
+    slug: str
+    title: str
+    path: Path | None = None
+    #: Why this page cannot be shown. Empty when it can.
+    unavailable: str = ""
+
+    @property
+    def available(self) -> bool:
+        return self.path is not None and not self.unavailable
+
+    def read(self) -> str:
+        """The markdown source, or the explanation if there is none."""
+        if not self.available:
+            return f"# {self.title}\n\n{self.unavailable}\n"
+        return self.path.read_text(encoding="utf-8")
+
+
+def title_of(path: Path, fallback: str) -> str:
+    """The page's first ``# heading``, or a title made from its filename.
+
+    Reading the title from the content rather than a registry means renaming a
+    heading cannot leave a menu entry saying something the page does not.
+    """
+    try:
+        match = _TITLE.search(path.read_text(encoding="utf-8"))
+    except OSError:  # pragma: no cover - unreadable file
+        return fallback
+    return match.group(1).strip() if match else fallback
+
+
+def _pretty(slug: str) -> str:
+    return slug.replace("-", " ").replace("_", " ").strip().capitalize()
+
+
+class PageIndex:
+    """An ordered collection of :class:`Page`, addressable by slug."""
+
+    def __init__(self, pages: list[Page]) -> None:
+        self._pages = list(pages)
+        self._by_slug = {p.slug: p for p in self._pages}
+
+    def __iter__(self):
+        return iter(self._pages)
+
+    def __len__(self) -> int:
+        return len(self._pages)
+
+    def __contains__(self, slug: object) -> bool:
+        return slug in self._by_slug
+
+    def __getitem__(self, slug: str) -> Page:
+        return self._by_slug[slug]
+
+    @property
+    def slugs(self) -> tuple[str, ...]:
+        return tuple(p.slug for p in self._pages)
+
+    def available(self) -> tuple[Page, ...]:
+        return tuple(p for p in self._pages if p.available)
+
+
+def load_pages(
+    directory: Path | str,
+    order: tuple[str, ...] = (),
+    *,
+    missing_message: str | None = None,
+) -> PageIndex:
+    """Build an index from ``directory``.
+
+    ``order`` lists slugs -- filenames without ``.md`` -- in reading order.
+    Slugs in ``order`` but not on disk are skipped; files on disk but not in
+    ``order`` are appended in sorted order.
+
+    If ``directory`` does not exist and ``missing_message`` is given, every slug
+    in ``order`` still appears, marked unavailable and carrying that message.
+    Without a message, an absent directory yields an empty index.
+    """
+    directory = Path(directory)
+
+    if not directory.is_dir():
+        if missing_message is None:
+            return PageIndex([])
+        return PageIndex([
+            Page(slug=slug, title=_pretty(slug), unavailable=missing_message)
+            for slug in order
+        ])
+
+    on_disk = {p.stem: p for p in sorted(directory.glob("*.md"))}
+
+    pages: list[Page] = []
+    for slug in order:
+        path = on_disk.pop(slug, None)
+        if path is not None:
+            pages.append(Page(slug, title_of(path, _pretty(slug)), path))
+
+    # Whatever the order did not mention, so a new file shows up without also
+    # having to be registered.
+    for slug, path in on_disk.items():
+        pages.append(Page(slug, title_of(path, _pretty(slug)), path))
+
+    return PageIndex(pages)

endstation/docs/markdown.py

@@ -0,0 +1,289 @@
+r"""Documentation pages as rich text: markdown structure *and* typeset math.
+
+Qt's rich-text engine parses a small HTML subset, which makes this cheap: this
+module converts a page to that subset, and the widget layer only displays it.
+
+Getting equations rendering and stopping there is a tempting place to stop, and
+it goes bad: tables and bullet lists stay as literal pipes and dashes. Real
+documentation puts the evidence *in* the tables -- an angle-convention
+reconciliation, an errata list, a three-way comparison -- and those are the
+content, in the one place a reader goes to understand what the software does.
+
+**No markdown dependency.** The subset Qt renders is small enough that a full
+CommonMark implementation would mostly be output this cannot use, and the
+conversion has to interleave with math extraction anyway (see below). This
+handles headings, paragraphs, bullet and numbered lists, tables, fenced and
+inline code, bold, italic, links, block quotes and rules -- which is what the
+pages actually contain.
+
+Three things worth knowing before editing:
+
+**Math is split out before anything is escaped.** Math spans in real pages
+contain ``<`` and ``>``. Escaping first would hand mathtext ``t &lt; w``, which
+it renders literally. So :func:`~endstation.docs.mathtext.split_segments` runs
+on the raw source and only the *text* spans are escaped.
+
+**Images are referenced by key, not embedded.** ``QTextDocument.loadResource``
+does not handle ``data:`` URLs, so each rendered equation gets an
+``endstation-math:N`` src and the viewer registers the bytes with
+``addResource``. That also keeps this module free of base64 padding it would
+only have to undo.
+
+**A render failure degrades rather than crashing.** The raw ``$...$`` source
+appears in a distinct colour, so a future edit using an unsupported macro is
+diagnosable at a glance instead of taking down the page.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+from dataclasses import dataclass, field
+
+from .mathtext import render_math_png, split_segments
+
+__all__ = ["MATH_URL_PREFIX", "RenderedPage", "UNRENDERED_COLOR", "to_html"]
+
+#: Scheme the viewer registers rendered equations under. Not `data:`.
+MATH_URL_PREFIX = "endstation-math:"
+
+#: Colour for a math span mathtext could not parse. Visible, not alarming.
+UNRENDERED_COLOR = "#b3541e"
+
+
+@dataclass
+class RenderedPage:
+    """HTML for a ``QTextDocument``, plus the images it refers to."""
+
+    html: str
+    images: dict[str, bytes] = field(default_factory=dict)
+    #: Math spans that failed to render, as raw LaTeX. Empty is the normal case.
+    unrendered: list[str] = field(default_factory=list)
+
+
+# -- inline formatting ------------------------------------------------------
+
+_INLINE_CODE = re.compile(r"`([^`]+)`")
+_BOLD = re.compile(r"\*\*([^*]+)\*\*")
+_ITALIC = re.compile(r"(?<![*\w])\*([^*\n]+)\*(?!\*)")
+_LINK = re.compile(r"\[([^\]]+)\]\(([^)\s]+)\)")
+
+
+def _inline(text: str) -> str:
+    """Escape, then apply inline markup. Order matters: escaping is first."""
+    out = html.escape(text)
+    # Code first, so `**` inside a code span is not turned into bold.
+    out = _INLINE_CODE.sub(
+        lambda m: f'<code style="background-color:#f0f0f0;">{m.group(1)}</code>',
+        out,
+    )
+    out = _BOLD.sub(r"<b>\1</b>", out)
+    out = _ITALIC.sub(r"<i>\1</i>", out)
+    out = _LINK.sub(r'<a href="\2">\1</a>', out)
+    return out
+
+
+# -- block structure --------------------------------------------------------
+
+_HEADING = re.compile(r"^(#{1,6})\s+(.*)$")
+_BULLET = re.compile(r"^\s*[-*+]\s+(.*)$")
+_NUMBERED = re.compile(r"^\s*\d+[.)]\s+(.*)$")
+_RULE = re.compile(r"^\s*([-*_])\s*(\1\s*){2,}$")
+_QUOTE = re.compile(r"^>\s?(.*)$")
+_TABLE_DIVIDER = re.compile(r"^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$")
+
+
+def _split_row(line: str) -> list[str]:
+    return [cell.strip() for cell in line.strip().strip("|").split("|")]
+
+
+def _blocks_to_html(lines: list[str]) -> str:
+    """Convert already-math-substituted lines into Qt's HTML subset."""
+    out: list[str] = []
+    index = 0
+    total = len(lines)
+
+    while index < total:
+        line = lines[index]
+
+        if not line.strip():
+            index += 1
+            continue
+
+        # Fenced code
+        if line.lstrip().startswith("```"):
+            body: list[str] = []
+            index += 1
+            while index < total and not lines[index].lstrip().startswith("```"):
+                body.append(html.escape(lines[index]))
+                index += 1
+            index += 1  # closing fence
+            out.append(
+                '<pre style="background-color:#f0f0f0;">'
+                + "\n".join(body)
+                + "</pre>"
+            )
+            continue
+
+        if _RULE.match(line):
+            out.append("<hr />")
+            index += 1
+            continue
+
+        heading = _HEADING.match(line)
+        if heading:
+            level = len(heading.group(1))
+            out.append(f"<h{level}>{_inline(heading.group(2))}</h{level}>")
+            index += 1
+            continue
+
+        # Table: a header row followed by a divider row.
+        if (
+            "|" in line
+            and index + 1 < total
+            and _TABLE_DIVIDER.match(lines[index + 1])
+        ):
+            header = _split_row(line)
+            index += 2
+            rows = []
+            while index < total and "|" in lines[index] and lines[index].strip():
+                rows.append(_split_row(lines[index]))
+                index += 1
+            out.append(_table_html(header, rows))
+            continue
+
+        if _QUOTE.match(line):
+            body = []
+            while index < total and _QUOTE.match(lines[index]):
+                body.append(_QUOTE.match(lines[index]).group(1))
+                index += 1
+            out.append(
+                '<blockquote style="color:#555;">'
+                f"{_inline(' '.join(body))}</blockquote>"
+            )
+            continue
+
+        if _BULLET.match(line) or _NUMBERED.match(line):
+            numbered = bool(_NUMBERED.match(line))
+            tag = "ol" if numbered else "ul"
+            items = []
+            while index < total:
+                match = (_NUMBERED if numbered else _BULLET).match(lines[index])
+                if not match:
+                    break
+                items.append(f"<li>{_inline(match.group(1))}</li>")
+                index += 1
+            out.append(f"<{tag}>{''.join(items)}</{tag}>")
+            continue
+
+        # Paragraph: consecutive non-blank lines that start nothing else.
+        body = []
+        while index < total and lines[index].strip():
+            candidate = lines[index]
+            if (
+                _HEADING.match(candidate)
+                or _BULLET.match(candidate)
+                or _NUMBERED.match(candidate)
+                or _RULE.match(candidate)
+                or _QUOTE.match(candidate)
+                or candidate.lstrip().startswith("```")
+            ):
+                break
+            body.append(candidate)
+            index += 1
+        if body:
+            out.append(f"<p>{_inline(' '.join(body))}</p>")
+
+    return "\n".join(out)
+
+
+def _table_html(header: list[str], rows: list[list[str]]) -> str:
+    """A bordered table. Qt honours the `border` attribute, not CSS borders."""
+    head = "".join(
+        f'<th style="padding:4px 8px;background-color:#ececec;">{_inline(c)}</th>'
+        for c in header
+    )
+    body = []
+    for row in rows:
+        # Pad or trim to the header width; a ragged row is a typo, not a reason
+        # to drop the table.
+        cells = (row + [""] * len(header))[: len(header)]
+        body.append(
+            "<tr>"
+            + "".join(
+                f'<td style="padding:4px 8px;">{_inline(c)}</td>' for c in cells
+            )
+            + "</tr>"
+        )
+    return (
+        '<table border="1" cellspacing="0" cellpadding="0" '
+        'style="margin:8px 0;">'
+        f"<tr>{head}</tr>{''.join(body)}</table>"
+    )
+
+
+# -- the public entry point -------------------------------------------------
+
+#: A paragraph containing nothing but a centred paragraph. See `to_html`.
+_UNWRAP_NESTED_P = re.compile(r"<p>\s*(<p align=\"center\">.*?</p>)\s*</p>",
+                              re.DOTALL)
+
+#: Placeholder inserted where a math span was, before block parsing runs, so an
+#: equation cannot be mistaken for a table pipe or a list bullet.
+_TOKEN = "\x00MATH{}\x00"
+
+
+def to_html(source: str, *, render_math: bool = True) -> RenderedPage:
+    """Convert a markdown page to the HTML subset ``QTextDocument`` renders.
+
+    ``render_math=False`` skips rasterisation entirely -- for a test that cares
+    about structure, or an environment with no matplotlib.
+    """
+    segments = split_segments(source)
+
+    images: dict[str, bytes] = {}
+    unrendered: list[str] = []
+    replacements: dict[str, str] = {}
+    text_parts: list[str] = []
+
+    for i, segment in enumerate(segments):
+        if not segment.is_math:
+            text_parts.append(segment.text)
+            continue
+
+        token = _TOKEN.format(i)
+        png = render_math_png(segment.text) if render_math else None
+
+        if png is None:
+            unrendered.append(segment.text)
+            raw = html.escape(f"${segment.text}$")
+            replacements[token] = (
+                f'<span style="color:{UNRENDERED_COLOR};">{raw}</span>'
+            )
+        else:
+            key = f"{MATH_URL_PREFIX}{len(images)}"
+            images[key] = png
+            tag = f'<img src="{key}" />'
+            # Display math gets its own centred line; inline sits in the run.
+            replacements[token] = (
+                f'<p align="center">{tag}</p>' if segment.kind == "display" else tag
+            )
+
+        text_parts.append(token)
+
+    html_body = _blocks_to_html("".join(text_parts).splitlines())
+
+    # Substituted after block parsing, so the `<img>` markup cannot be escaped
+    # by `_inline` on its way through.
+    for token, markup in replacements.items():
+        html_body = html_body.replace(html.escape(token), markup)
+        html_body = html_body.replace(token, markup)
+
+    # A display equation on its own line arrives here as a paragraph whose only
+    # content is a centred paragraph. Qt tolerates the nesting but lays it out
+    # with the outer paragraph's spacing *and* the inner one's, which reads as
+    # an accidental gap; unwrapping keeps display math spaced like every other
+    # block.
+    html_body = _UNWRAP_NESTED_P.sub(r"\1", html_body)
+
+    return RenderedPage(html=html_body, images=images, unrendered=unrendered)

endstation/docs/mathtext.py

@@ -0,0 +1,173 @@
+r"""Rendering LaTeX math from a documentation page, without a LaTeX install.
+
+A theory page's ``$$\Phi_m(x) = ...$$`` should not reach a reader as literal
+source, backslashes and all. This is the pure half of the fix: splitting a
+markdown string into text and math spans, and rasterizing the math spans to PNG
+bytes via :func:`matplotlib.mathtext.math_to_image` -- which is already a
+dependency wherever there are plots, and needs no live display, so the whole
+pipeline down to PNG bytes is headlessly testable. Only the final step of
+turning those bytes into an embeddable image needs a real document.
+
+Three things worth knowing before touching this file.
+
+**Splitting happens before any escaping.** Real documentation contains math
+spans holding ``<`` and ``>`` -- ``$t < w$``, ``$\zeta < \theta_c$``,
+``$k > 0$``. Escaping first would hand mathtext the string ``t &lt; w``, which
+it renders literally. So :func:`split_segments` runs on the raw source and only
+the *text* spans are escaped afterwards; the LaTeX never is.
+
+**``\boxed{...}`` is not supported by mathtext.** It raises ``ValueError``
+wrapping a ``ParseFatalException``. :func:`strip_boxed` removes the wrapper by
+counting braces rather than by regex, because the boxed content itself contains
+nested braces -- ``\boxed{\;G_m = \int_0^1 e^{i\Phi_m(t)}\,dt\;}`` -- and a
+naive ``\\boxed\{(.*)\}`` pattern would either stop at the first inner ``}`` or,
+greedy, swallow past the intended end. The visual rectangle is not reproduced;
+the equation still renders correctly and reads as its own centred line, which is
+the part that matters.
+
+**A render failure degrades, it does not crash the viewer.**
+:func:`render_math_png` returns ``None`` rather than propagating the parser's
+exception, so one unsupported macro in a future edit shows as visible raw source
+for that one span -- diagnosable at a glance -- rather than taking down the
+whole page.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+__all__ = [
+    "Segment",
+    "split_segments",
+    "strip_boxed",
+    "render_math_png",
+]
+
+#: `$$...$$` first so display math is not mistaken for two inline spans.
+#: A backslash-escaped `\$` is not a delimiter -- it is a dollar sign, which
+#: appears in prose about cost and in any page quoting a shell prompt.
+_MATH = re.compile(
+    r"(?<!\\)\$\$(?P<display>.+?)(?<!\\)\$\$"
+    r"|(?<!\\)\$(?P<inline>[^\n$]+?)(?<!\\)\$",
+    re.DOTALL,
+)
+
+#: Fenced blocks and inline code, which must be left entirely alone: `$PATH` in
+#: a shell example is not the start of an equation.
+_CODE = re.compile(r"```.*?```|``.+?``|`[^`\n]+?`", re.DOTALL)
+
+
+@dataclass(frozen=True)
+class Segment:
+    """One run of the source: prose, inline math, or display math."""
+
+    text: str
+    kind: str = "text"  # "text" | "inline" | "display"
+
+    @property
+    def is_math(self) -> bool:
+        return self.kind in ("inline", "display")
+
+
+def split_segments(source: str) -> list[Segment]:
+    """Split ``source`` into text and math spans, leaving code untouched.
+
+    Runs on raw markdown, before escaping. See the module docstring.
+    """
+    segments: list[Segment] = []
+    cursor = 0
+
+    # Walk code spans first and only look for math in the gaps between them.
+    for code in _CODE.finditer(source):
+        _split_prose(source[cursor:code.start()], segments)
+        segments.append(Segment(code.group(0), "text"))
+        cursor = code.end()
+    _split_prose(source[cursor:], segments)
+
+    return [s for s in segments if s.text]
+
+
+def _split_prose(text: str, out: list[Segment]) -> None:
+    """Find math spans in a stretch known to contain no code."""
+    cursor = 0
+    for match in _MATH.finditer(text):
+        if match.start() > cursor:
+            out.append(Segment(text[cursor:match.start()], "text"))
+        if match.group("display") is not None:
+            out.append(Segment(match.group("display").strip(), "display"))
+        else:
+            out.append(Segment(match.group("inline").strip(), "inline"))
+        cursor = match.end()
+    if cursor < len(text):
+        out.append(Segment(text[cursor:], "text"))
+
+
+def strip_boxed(latex: str) -> str:
+    r"""Remove ``\boxed{...}`` wrappers, counting braces rather than matching.
+
+    mathtext has no boxed macro and raises on one. The content is kept; only
+    the wrapper goes. Nested ``\boxed`` is handled by repeating until none is
+    left, which costs nothing and avoids a second surprise later.
+    """
+    marker = r"\boxed{"
+    while (start := latex.find(marker)) != -1:
+        depth = 0
+        for i in range(start + len(marker) - 1, len(latex)):
+            if latex[i] == "{":
+                depth += 1
+            elif latex[i] == "}":
+                depth -= 1
+                if depth == 0:
+                    inner = latex[start + len(marker):i]
+                    latex = latex[:start] + inner + latex[i + 1:]
+                    break
+        else:
+            # Unbalanced: drop the marker and keep the rest rather than looping
+            # forever on malformed input.
+            latex = latex[:start] + latex[start + len(marker):]
+    return latex
+
+
+def render_math_png(
+    latex: str,
+    *,
+    fontsize: int = 12,
+    dpi: int = 200,
+    color: str = "black",
+) -> bytes | None:
+    """Rasterize one math span. ``None`` if mathtext cannot parse it.
+
+    Returning ``None`` rather than raising is deliberate: an unsupported macro
+    should show as raw source for that one equation, not take down the page.
+
+    ``dpi`` is well above screen resolution because the result is displayed at
+    its natural size on a Retina display, where a 100-dpi raster looks soft.
+    """
+    import io
+
+    from matplotlib import mathtext
+
+    expression = strip_boxed(latex).strip()
+    if not expression:
+        return None
+
+    buffer = io.BytesIO()
+    try:
+        mathtext.math_to_image(
+            f"${expression}$",
+            buffer,
+            prop=_font_properties(fontsize),
+            dpi=dpi,
+            format="png",
+            color=color,
+        )
+    except Exception:  # noqa: BLE001 - any parse failure degrades to raw source
+        return None
+    return buffer.getvalue()
+
+
+def _font_properties(fontsize: int):
+    from matplotlib.font_manager import FontProperties
+
+    return FontProperties(size=fontsize)