mpl-typst 0.1.0__py3-none-any.whl

mpl_typst/__init__.py

@@ -0,0 +1,74 @@
+"""Package `mpl_typst` provides a :py:`matplotlib` backend for rendering
+directly to Typst as well as rendering to PDF, PNG, SVG indirectly through
+Typst renderer.
+
+One can import `mpl_typst.as_default` module in order to use `mpl_typst`
+backend by default.
+
+.. code:: python
+
+   import mpl_typst.as_default
+
+Or one can configure it manually.
+
+.. code:: python
+
+   import matplotlib
+   import mpl_typst
+   mpl.use('module://mpl_typst')
+
+Also, it is possible to use rendering context as usual to override backend.
+
+.. code:: python
+
+   import matplotlib as mpl
+   import mpl_typst
+   with mpl.rc_context({'backend': 'module://mpl_typst'}):
+       ...
+"""
+
+from contextlib import contextmanager
+from os import PathLike
+from pathlib import Path
+from typing import Any, Generator
+
+import matplotlib as mpl
+from mpl_typst.backend import (FigureCanvas, FigureManager, TypstFigureCanvas,
+                               TypstFigureManager, TypstRenderer,
+                               TypstRenderingError)
+
+__all__ = ('BACKEND', 'FigureCanvas', 'FigureManager', 'TypstFigureCanvas',
+           'TypstFigureManager', 'TypstGraphicsContext', 'TypstRenderer',
+           'TypstRenderingError', 'rc_context', 'use')
+
+# Backend specification for use with `matplotlib.use`
+BACKEND = 'module://mpl_typst'
+
+
+@contextmanager
+def rc_context(
+    rc: dict[str, Any] | None = None,
+    fname: PathLike | Path | str | None = None,
+) -> Generator[None, None, None]:
+    """A shortcut for using Typst as default backend in a context.
+
+    It forward all arguments to original :py:`matplotlib.rc_context` context
+    manager but it enforces use of `mpl_typst` backend in the beginning of
+    newly created context.
+
+    .. code:: python
+
+       import mpl_typst
+       with mpl_typst.rc_context():
+           ...
+    """
+    original_backend = mpl.rcParams['backend']
+    with mpl.rc_context(rc, fname):
+        mpl.use(BACKEND)
+        yield
+        mpl.use(original_backend)
+
+
+def use(*, force: bool = True):
+    """Set Typst rendering backend as default on (see :py:`matplotlib.use`)."""
+    mpl.use(BACKEND)

mpl_typst/as_default.py

@@ -0,0 +1,7 @@
+"""This module is aimed to use by end-users in order to configure `mpl_typst`
+as default backend.
+"""
+
+from mpl_typst import use
+
+use()  # Use this MPL backend as default.

mpl_typst/backend.py

@@ -0,0 +1,420 @@
+import pathlib
+import re
+import subprocess
+from datetime import date, datetime
+from io import BytesIO, StringIO
+from shutil import copyfileobj
+from tempfile import TemporaryDirectory
+from typing import Any, Literal, Optional, Self, TextIO, Type
+
+import numpy as np
+from matplotlib import get_cachedir
+from matplotlib.backend_bases import (FigureCanvasBase, FigureManagerBase,
+                                      GraphicsContextBase, RendererBase,
+                                      register_backend)
+from matplotlib.figure import Figure
+from matplotlib.font_manager import FontProperties
+from matplotlib.path import Path
+from matplotlib.text import Text
+from matplotlib.transforms import Affine2DBase, Transform
+from matplotlib.typing import ColorType
+from mpl_typst.typst import Array, Block, Call, Content, Dictionary, Scalar
+from mpl_typst.typst import Writer as TypstWriter
+from numpy.typing import ArrayLike
+
+__all__ = ('FigureCanvas', 'FigureManager', 'TypstFigureCanvas',
+           'TypstFigureManager', 'TypstGraphicsContext', 'TypstRenderer',
+           'TypstRenderingError')
+
+PROLOGUE = pathlib.Path(__file__).parent / 'prologue.typ'
+
+RE_ERROR = re.compile(
+    r'^(?P<filename>.*):(?P<line>\d+):(?P<column>\d+): error: (?P<reason>.*)$')
+
+TPL_ERROR = '  {filename}:{line}:{column}: {reason}'
+
+
+class TypstRenderingError(RuntimeError):
+    """Represent an error occured in rendering target with Typst binary."""
+
+    def __init__(self, stdout: str, stderr: str, errors: list[dict[str, Any]]):
+        header = (f'Typst renderer failed with {len(errors)} errors. '
+                  'They are shown below')
+        lines = [header]
+        for error in errors:
+            lines.append(TPL_ERROR.format(**error))
+        message = '\n'.join(lines)
+
+        super().__init__(message)
+        self.stdout = stdout
+        self.stderr = stderr
+        self.errors = errors
+
+    def to_dict(self):
+        return {'stdout': self.stdout, 'stderr': self.stderr,
+                'errors': self.errors}
+
+
+class TypstRenderer(RendererBase):
+    """Typst renderer handles drawing/rendering operations."""
+
+    def __init__(self, figure: Figure, fout: TextIO,
+                 metadata: dict[str, str] = {}):
+        super().__init__()
+        self.figure = figure
+        self.fout = fout
+        self.metadata = metadata
+
+        self.width = self.figure.get_figwidth()
+        self.height = self.figure.get_figheight()
+        self.dpi = self.figure.dpi
+        self.timestamp = datetime.now().replace(microsecond=0)
+
+        self.writer: Optional[TypstWriter] = None
+        self.main: Optional[Block] = None
+
+    def __enter__(self) -> Self:
+        # First of all, add some helpers for rendering at the beginning.
+        with open(PROLOGUE) as fin:
+            template = fin.read()
+            text = template.replace('{{ date }}', self.timestamp.isoformat())
+        self.fout.write(text)
+        self.fout.write('\n')
+
+        # Now configure document geometry and set metadata.
+        if self.metadata:
+            title = 'none'
+            if value := self.metadata.get('title'):
+                escaped = value.replace('"', '\"')
+                title = f'"{escaped}"'
+
+            author = '()'
+            if value := self.metadata.get('author'):
+                escaped = value.replace('"', '\"')
+                author = f'"{value}"'
+
+            date_ = 'auto'
+            if ts := self.metadata.get('date', self.timestamp.date()):
+                if isinstance(ts, datetime):
+                    ts: date = ts.date()
+                elif isinstance(ts, date):
+                    ts: date = ts
+                elif isinstance(ts, str):
+                    ts: date = datetime.fromisoformat(ts).date()
+                else:
+                    raise ValueError(f'Wrong date format in metadata: {ts}.')
+                date_ = (f'datetime(year: {ts.year}, month: {ts.month}, '
+                         f'day: {ts.day})')
+
+            self.fout.write(f'#set document(title: {title}, author: {author}, '
+                            f'date: {date_})\n')
+            self.fout.write(f'#set page(width: {self.width}in, '
+                            f'height: {self.height}in, margin: 0pt)\n')
+            self.fout.write('\n')
+
+        # Create a main block for drawing.
+        self.main = Block()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.fout.write('#')  # Escape command.
+        self.writer = TypstWriter(self.fout)
+        expr = Call('block', self.main, spacing=Scalar(0, 'pt'),
+                    above=Scalar(0, 'pt'), below=Scalar(0, 'pt'),
+                    width=Scalar(self.width, 'in'),
+                    height=Scalar(self.height, 'in'))
+        expr.to_string(self.writer)
+
+    def draw_image(self, gc: GraphicsContextBase, x: float, y: float,
+                   im: ArrayLike, transform: Affine2DBase | None = None):
+        raise NotImplementedError
+
+    def draw_path(self, gc: GraphicsContextBase, path: Path,
+                  transform: Transform, rgbFace: ColorType | None = None):
+        # Transform y-coordinates since Oy axis is flipped.
+        def normalize(coords) -> tuple[float, ...]:
+            result = []
+            for ix, coord in enumerate(coords):
+                if (ix % 2) == 1:
+                    coord = self.height - coord / self.dpi
+                else:
+                    coord = coord / self.dpi
+                result.append(coord)
+            return tuple(result)
+
+        # Configure how to fill the path.
+        fill = None
+        if rgbFace is not None:
+            fill = Call('rgb', *[Scalar(c * 100, '%') for c in rgbFace])
+
+        # Configure basic appearance of a line.
+        if (capstyle := gc.get_capstyle()) == 'projecting':
+            capstyle = 'square'
+        colour = Call('rgb', *[Scalar(c * 100, '%') for c in gc.get_rgb()])
+        stroke = Call(
+            'stroke',
+            paint=colour,
+            thickness=Scalar(gc.get_linewidth(), 'pt'),
+            cap=Scalar(capstyle),
+            join=Scalar(gc.get_joinstyle()),
+        )
+
+        # Configure appearance of dashed line.
+        (offset, bounds) = gc.get_dashes()
+        if bounds:
+            bounds = Array([Scalar(bound, 'pt') for bound in bounds])
+            if offset:
+                stroke.kwargs.update({
+                    'dash': Dictionary({
+                        'array': bounds,
+                        'phase': Scalar(offset, 'pt'),
+                    })
+                })
+            else:
+                stroke.kwargs.update({'dash': bounds})
+
+        # Construct a `path` routine invokation.
+        line = Call('path', fill=fill, stroke=stroke)
+        for points, code in path.iter_segments(transform):
+            points = normalize(points)
+            match code:
+                case Path.STOP:
+                    pass
+                case Path.MOVETO | Path.LINETO:
+                    x, y = points
+                    line.args.append(Array([Scalar(x, 'in'), Scalar(y, 'in')]))
+                case Path.CURVE3:
+                    cx, cy, px, py = points
+                    p = Array([Scalar(px, 'in'), Scalar(py, 'in')])
+                    c = Array([Scalar(cx - px, 'in'), Scalar(cy - py, 'in')])
+                    line.args.append(Array([p, c]))
+                case Path.CURVE4:
+                    inx, iny, outx, outy, px, py = points
+                    p = Array([Scalar(px, 'in'), Scalar(py, 'in')])
+                    inp = Array([Scalar(inx - px, 'in'),
+                                 Scalar(iny - py, 'in')])
+                    out = Array([Scalar(outx - px, 'in'),
+                                 Scalar(outy - py, 'in')])
+                    line.args.append(Array([p, inp, out]))
+                case Path.CLOSEPOLY:
+                    line.kwargs.update({'closed': True})
+
+        # Place a line path relative to parent block element without layouting.
+        place = Call('place', line, dx=Scalar(0, 'in'), dy=Scalar(0, 'in'))
+        self.main.append(place)
+
+    def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,
+                       coordinates, offsets, offsetTrans, facecolors,
+                       antialiased, edgecolors):
+        # TODO(@daskol): Apply offset transformation.
+        vertices = np.array([master_transform.transform(point)
+                             for point in coordinates])
+        vertices /= self.dpi  # Points to inches.
+        vertices[..., 1] = self.height - vertices[..., 1]  # Inverted Oy axis.
+
+        # Cast coordinates to term in internal representation.
+        shape = vertices.shape
+        vertices = np.array([Scalar(el, 'in') for el in vertices.flatten()])
+        vertices = vertices.reshape(shape)
+
+        for i in range(vertices.shape[0] - 1):
+            # TODO(@daskol): What about shapes coordinates, facecolors, and
+            # edgecolors?
+            facecolor = [Scalar(c * 100, '%') for c in facecolors[i]]
+            for j in range(vertices.shape[1] - 1):
+                # Create filling color.
+                fill = Call('rgb', *facecolor)
+
+                # Create stroke if line width is given.
+                if edgecolors:
+                    edgecolor = [Scalar(c * 100, '%') for c in edgecolors[i]]
+                else:
+                    edgecolor = facecolor
+                stroke = None
+                if (lw := gc.get_linewidth()) > 0:
+                    paint = Call('rgb', *edgecolor)
+                    stroke = Call('stroke', paint=paint,
+                                  thickness=Scalar(lw, 'pt'))
+
+                # TODO(@daskol): Take into account joints, dashes, and hatches.
+
+                # Select quad and walk over it anti-clockwise.
+                quad = vertices[i:i + 2, j:j + 2]
+                quad = quad.reshape(4, 2)
+                quad = quad[[2, 3, 1, 0]]
+                line = Call('path', fill=fill, stroke=stroke, closed=True)
+                for coords in quad:
+                    point = Array(coords)
+                    line.args.append(point)
+
+                # Put on canvas with respect of the origin.
+                place = Call('place', line,
+                             dx=Scalar(0, 'in'), dy=Scalar(0, 'in'))
+                self.main.append(place)
+
+    def draw_text(self, gc: GraphicsContextBase, x: float, y: float, s: str,
+                  prop: FontProperties, angle: float,
+                  ismath: bool | Literal['TeX'] = False, *,
+                  mtext: Text | None = None):
+        alignment = 'center + horizon'
+        baseline = False
+        fontsize = prop.get_size_in_points()
+        if mtext:
+            pos = mtext.get_unitless_position()
+            x, y = mtext.get_transform().transform(pos)
+            x = x / self.figure.dpi
+            y = self.height - y / self.figure.dpi
+            halign = mtext.get_horizontalalignment()
+            valign = mtext.get_verticalalignment()
+            match valign:
+                case 'center':
+                    valign = 'horizon'
+                case 'center_baseline':
+                    valign = 'horizon'
+                    baseline = True
+                case 'baseline':
+                    valign = 'bottom'
+                    baseline = True
+            alignment = f'{halign} + {valign}'
+            fontsize = mtext.get_fontsize()
+            angle = mtext.get_rotation()
+        else:
+            x = x / self.figure.dpi
+            y = self.height + y / self.figure.dpi
+
+        elem = Call('draw-text',
+                    Content(s),
+                    dx=Scalar(x, 'in'),
+                    dy=Scalar(y, 'in'),
+                    size=Scalar(fontsize, 'pt'),
+                    alignment=alignment,
+                    baseline=baseline,
+                    angle=Scalar(360 - angle, 'deg'))
+        self.main.append(elem)
+
+    def flipy(self):
+        """Axis Oy points to bottom."""
+        return True
+
+    def get_canvas_width_height(self) -> tuple[float, float]:
+        return self.width, self.height
+
+    def get_text_width_height_descent(
+            self, s: str, prop: FontProperties,
+            ismath: bool | Literal['TeX'] = False,
+    ) -> tuple[float, float, float]:
+        return super().get_text_width_height_descent(s, prop, ismath)
+
+    def new_gc(self) -> Type[GraphicsContextBase]:
+        return TypstGraphicsContext()
+
+    def points_to_pixels(self, points):
+        return points  # if backend doesn't have dpi, e.g., postscript or svg
+
+
+class TypstGraphicsContext(GraphicsContextBase):
+    """In Typst, all the work is done by the renderer, mapping line styles to
+    Typst calls.
+    """
+
+
+class TypstFigureManager(FigureManagerBase):
+    """Non-interactive backend requires nothing."""
+
+
+class TypstFigureCanvas(FigureCanvasBase):
+    """The canvas the figure renders into.  Calls the draw and print fig
+    methods, creates the renderers, etc.
+
+    Attributes
+    ----------
+    figure : `~matplotlib.figure.Figure`
+        A high-level Figure instance
+    """
+
+    filetypes = {**FigureCanvasBase.filetypes, 'typ': 'Typst Markup'}
+
+    fixed_dpi: Optional[float] = None
+
+    manager_class = TypstFigureManager
+
+    def draw(self):
+        """Draw the figure using the renderer."""
+        self.figure.draw_without_rendering()
+        super().draw()
+
+    def get_default_filetype(self):
+        return 'typ'
+
+    def print_pdf(self, filename, **kwargs):
+        return self._print_as('pdf', filename, **kwargs)
+
+    def print_png(self, filename, **kwargs):
+        return self._print_as('png', filename, **kwargs)
+
+    def print_svg(self, filename, **kwargs):
+        return self._print_as('svg', filename, **kwargs)
+
+    def print_typ(self, filename, *, metadata=None, **kwargs):
+        # TODO(@daskol): Matplotlib shows quite unexpectedbehaviour. It renders
+        # the same figure multiple types with randering to temporary buffer
+        # (BytesIO) rather than directly to file. So, it would be great to
+        # rewrite this function and neighnoring one to make it file-agnostic.
+        if isinstance(filename, BytesIO):
+            buf = StringIO()
+            with TypstRenderer(self.figure, buf, metadata or {}) as renderer:
+                self.figure.draw(renderer)
+            content = buf.getvalue().encode('utf-8')
+            buf.write(content)
+        else:
+            with open(filename, 'w') as fout:
+                metadata = metadata or {}
+                with TypstRenderer(self.figure, fout, metadata) as renderer:
+                    self.figure.draw(renderer)
+
+    def _print_as(self, fmt, filename, *, metadata=None, **kwargs):
+        # Set up default metadata. We use metadata as a condition for setting
+        # canvas geometry in rendering.
+        metadata = metadata or {}
+        if 'author' not in metadata:
+            metadata['author'] = 'mpl_typst (Typst Matplotlib backend)'
+
+        with TemporaryDirectory(prefix='typst-', dir=get_cachedir()) as tmpdir:
+            # Render figure in pure textual typst markup.
+            inp_path = pathlib.Path(tmpdir) / 'main.typ'
+            self.print_typ(inp_path, metadata=metadata, **kwargs)
+
+            # Render typst markup running typst binary.
+            out_path = inp_path.with_suffix(f'.{fmt}')
+            dpi = kwargs.get('dpi', self.figure.dpi)
+            cmd = ['typst', 'compile', f'--root={tmpdir}', f'--format={fmt}',
+                   '--diagnostic-format=short', f'--ppi={dpi}',
+                   str(inp_path), str(out_path)]
+            proc = subprocess.run(cmd, capture_output=True, cwd=tmpdir)
+            if proc.returncode:
+                kwargs = {'stdout': proc.stdout.decode('utf-8'),
+                          'stderr': proc.stderr.decode('utf-8'),
+                          'errors': []}
+                for m in RE_ERROR.finditer(kwargs['stderr']):
+                    error = m.groupdict()
+                    error['line'] = int(error['line'])
+                    error['column'] = int(error['column'])
+                    kwargs['errors'].append(error)
+                raise TypstRenderingError(**kwargs)
+
+            # Move rendered figure from temporary directory to target location.
+            if isinstance(filename, BytesIO):
+                with open(out_path, 'rb') as fin:
+                    copyfileobj(fin, filename)
+            else:
+                dst_path = pathlib.Path(filename)
+                dst_path.parent.mkdir(exist_ok=True, parents=True)
+                out_path.rename(dst_path)
+
+
+# Now, just provide the standard names that `backend.__init__` is expecting.
+FigureCanvas = TypstFigureCanvas
+FigureManager = TypstFigureManager
+
+# Register file format for Typst markup.
+register_backend('typ', 'mpl_typst', 'Typst markup')

mpl_typst/prologue.typ

@@ -0,0 +1,53 @@
+/**
+ * This is autogenerated Typst markup from a scene description created by
+ * matplotlib in Python.
+ *
+ * Timestamp: {{ date }}.
+ */
+
+#let draw-text(dx: 0pt, dy: 0pt, size: 10pt, alignment: center + horizon, baseline: false, angle: 0deg, body) = style(styles => {
+  // In order to align a text properly, we need to configure bounding box of a
+  // text.
+  let top-edge = "cap-height"
+  let bot-edge = "bounds"
+  let valign = alignment.y;
+  if baseline and valign == bottom {
+    bot-edge = "baseline"
+  }
+  if baseline and valign == horizon {
+    bot-edge = "baseline"
+  }
+
+  // Measure shape of text block.
+  let content = text(size: size, top-edge: top-edge, bottom-edge: bot-edge, body)
+  let shape = measure(content, styles)
+
+  // Adjust horizontal position.
+  let px = dx
+  if alignment.x == left {
+    // Do nothing.
+  } else if alignment.x == center {
+    px -= shape.width / 2
+  } else if alignment.x == right {
+    px -= shape.width
+  }
+
+  // Adjust vertical position.
+  let py = dy
+  if valign == top {
+    // Do nothing.
+  } else if valign == horizon {
+    py -= shape.height / 2
+  } else if valign == bottom {
+    py -= shape.height
+  }
+
+  // Rotate text block if required. Note, that matplotlib supports two modes
+  // for rotation while Typst allows to perform only the second one.
+  if angle != 0deg {
+    content = rotate(angle, origin: alignment, content)
+  }
+
+  // Finaly, place a content block in calculated displacement.
+  place(dx: px, dy: py, content)
+})

mpl_typst/typst.py

@@ -0,0 +1,182 @@
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from io import StringIO
+from typing import Any, Literal, Self
+
+__all__ = ('Array', 'Block', 'Content', 'Dictionary', 'Node', 'Scalar',
+           'Writer')
+
+
+class Writer:
+
+    def __init__(self, buf: StringIO | None = None, indent: int = 0):
+        self.buf = buf or StringIO()
+        self.indent_ = indent
+        self.indented = False
+
+    @contextmanager
+    def indent(self):
+        self.indent_ += 1
+        yield
+        self.indent_ -= 1
+
+    def to_string(self, value: Any) -> Self:
+        match value:
+            case Node():
+                value.to_string(self)
+            case bool():
+                self.write(str(value).lower())
+            case None:
+                self.write('none')
+            case _:
+                self.write(str(value))
+        return self
+
+    def write(self, content: str):
+        if not self.indented:
+            self.indented = True
+            self.buf.write(' ' * (2 * self.indent_))
+        self.buf.write(content)
+
+    def writeln(self, content: str | None = None):
+        if content:
+            self.write(content)
+        self.buf.write('\n')
+        self.indented = False
+
+
+class Node:
+
+    def __str__(self) -> str:
+        buf = StringIO()
+        self.to_string(buf)
+        return buf.getvalue()
+
+    def to_string(self, writer: Writer):
+        raise NotImplementedError
+
+
+Unit = Literal['pt', 'cm', 'mm', 'in', 'em', 'px', 'deg', 'rad', '%']
+
+
+@dataclass
+class Scalar(Node):
+
+    value: float | int | str
+
+    unit: Unit | None = None
+
+    def __post_init__(self):
+        if self.unit and isinstance(self.value, str):
+            raise ValueError(
+                f'String literals cannot have a unit: {self.unit}.')
+
+    def to_string(self, writer: Writer):
+        if self.unit:
+            writer.write(f'{self.value}{self.unit}')
+        elif isinstance(self.value, str):
+            writer.write(f'"{self.value}"')
+        else:
+            writer.write(f'{self.value}')
+
+
+@dataclass
+class Content(Node):
+
+    content: str
+
+    def to_string(self, writer: Writer):
+        writer.write('[')
+        writer.write(self.content)
+        writer.write(']')
+
+
+@dataclass
+class Array(Node):
+
+    array: list[Any] = field(default_factory=list)
+
+    def append(self, value):
+        self.array.append(value)
+
+    def to_string(self, writer: Writer, *, interior_only=False):
+        if not interior_only:
+            writer.write('(')
+        for ix, item in enumerate(self.array):
+            if ix > 0:
+                if interior_only:
+                    writer.writeln(',')  # Indentation in Call expression.
+                else:
+                    writer.write(', ')
+            writer.to_string(item)
+        if not interior_only:
+            writer.write(')')
+
+
+@dataclass
+class Dictionary(Node):
+
+    dictionary: dict[str, Any] = field(default_factory=dict)
+
+    def to_string(self, writer: Writer, *, interior_only=False):
+        if not interior_only:
+            writer.write('(')
+        for ix, (key, val) in enumerate(self.dictionary.items()):
+            if ix > 0:
+                if interior_only:
+                    writer.writeln(',')  # Indentation in Call expression.
+                else:
+                    writer.write(', ')
+            writer.write(f'{key}: ')
+            writer.to_string(val)
+        if not interior_only:
+            writer.write(')')
+
+    def update(self, items):
+        self.dictionary.update(items)
+
+
+@dataclass(init=False)
+class Call(Node):
+
+    name: str
+
+    args: Array = field(default_factory=Array)
+
+    kwargs: Array = field(default_factory=Dictionary)
+
+    def __init__(self, name: str, *args, **kwargs):
+        self.name = name
+        self.args = Array([*args])
+        self.kwargs = Dictionary(kwargs)
+
+    def to_string(self, writer: Writer):
+        writer.write(f'{self.name}(')
+        with writer.indent():
+            writer.writeln()
+            self.args.to_string(writer, interior_only=True)
+            if self.args.array and self.kwargs.dictionary:
+                writer.writeln(',')
+            self.kwargs.to_string(writer, interior_only=True)
+        writer.write(')')
+
+
+@dataclass
+class Block(Node):
+
+    exprs: list[Node] = field(default_factory=list)
+
+    def append(self, expr: Node):
+        self.exprs.append(expr)
+
+    def to_string(self, writer: Writer):
+        if not self.exprs:
+            writer.write('{}')
+            return
+
+        writer.writeln('{')
+        with writer.indent():
+            for expr in self.exprs:
+                expr.to_string(writer)
+                writer.writeln()
+        writer.write('}')

mpl_typst/typst_test.py

@@ -0,0 +1,18 @@
+from mpl_typst.typst import Block, Call, Scalar, Writer
+
+
+def test_sanity():
+    block = Block()
+
+    arr = [0.1, Scalar(1, 'pt'), '2em']
+    dic = {'phase': 0, 'array': arr, 'baseline': False}
+    path = Call('path', *arr, **dic)
+    block.append(path)
+
+    components = (0, 0, 0, 1)
+    rgb = Call('rgb', *components)
+    block.append(rgb)
+
+    writer = Writer()
+    block.to_string(writer)
+    assert writer.buf.getvalue() != ''

mpl_typst-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Daniel Bershatsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mpl_typst-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.1
+Name: mpl-typst
+Version: 0.1.0
+Summary: Typst backend for matplotlib (Python visualization library).
+Author-email: Daniel Bershatsky <daniel.bershatsky@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/daskol/typst-mpl-backend
+Project-URL: Repository, https://github.com/daskol/typst-mpl-backend.git
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib
+Provides-Extra: dev
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pytest>=7; extra == "dev"
+
+# Typst Matplotlib Backend
+
+*Typst backend for matplotlib (Python visualization library).*
+
+## Overview
+
+At the moment, Typst supports main vector and raster image formats. Namely,
+images in PNG, JPEG, GIF, or SVG format can be easily emplaced in a document
+with Typst. However, it is **not possible** to keep metadata and annotations.
+These are mandatory in order to allow a reader to select and interact with
+vector content (e.g. text) on images. Although SVG can contain text metadata in
+principle, Typst does not support this feature at the moment but still it is
+able to render SVG as a vector content.
+
+This package solves this problem for `matplotlib` users. Basically, this
+project implements a custom render (or backend) for `matplotlib` which
+generates `typ`-file containing Typst markup. Generated markup file can be
+later included in the original markup so that the resulting PDF will have
+interactable content. Matplotlib exploits exactly the same strategy in order to
+generate PGF-files &mdash; a LaTeX markup itself &mdash; which can be included
+into LaTeX markup directly.
+
+## Usage
+
+In order to render image with `mpl_typst` one can import `mpl_typst.as_default`
+module in order to use `mpl_typst` backend by default.
+
+```python
+import mpl_typst.as_default
+```
+
+Or one can configure it manually.
+
+```python
+import matplotlib
+import mpl_typst
+mpl.use('module://mpl_typst')
+```
+
+Also, it is possible to use rendering context as usual to override backend.
+
+```python
+import matplotlib as mpl
+import mpl_typst
+with mpl.rc_context({'backend': 'module://mpl_typst'}):  # or mpl_typst.BACKEND
+    ...
+```
+
+Next, you can save your figure to `typ` as usual.
+
+```python
+fig, ax = plt.subplots()
+...
+fig.savefig('line-plot-simple.typ')
+```
+
+As soon as you get a `typ`-file you can included it directly to `figure`
+function and adjust figure time.
+
+```typst
+#figure(
+  include "line-plot-simple.typ",
+  kind: image,
+  caption: [Simple line plot],
+  placement: top,
+) <line-plot-simple>
+```

mpl_typst-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+mpl_typst/__init__.py,sha256=1NH9wxnWW5gWADkQ961EX3iDDy3iThtTXyhZ0InKuZg,2089
+mpl_typst/as_default.py,sha256=TjbPHcx_4xrWa8tVQ1rsgWRfNd7qi2_6O4tG60ChLr0,172
+mpl_typst/backend.py,sha256=2j0UD1cFGUhQJNEGK9M2EAR84tsMABEAkOqquPBMhws,16735
+mpl_typst/prologue.typ,sha256=nCffqDEvkSb5ZiOptZnjABqphISi3KzWk5Sfi2CZ0do,1480
+mpl_typst/typst.py,sha256=PRF792Db1kBFEgDPQgCk5gh3euEkgxjqyMMh8pNxyZA,4658
+mpl_typst/typst_test.py,sha256=hLX8V1g6M7j3lafgQDLBA2z7cChRoyhW08AGCqXk6Wc,432
+mpl_typst-0.1.0.dist-info/LICENSE,sha256=2G5-6WwJXB6j5mWLRTa-xU3G-PK4LuqJW-Mt7CBmp8E,1074
+mpl_typst-0.1.0.dist-info/METADATA,sha256=f1IpWyg94amffMQ6udVZAYjrFNfPbB7eZrHlj8DPgrg,3509
+mpl_typst-0.1.0.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+mpl_typst-0.1.0.dist-info/top_level.txt,sha256=Bc6UA_Jam1EyTtRfp3uxF07DEqDClZPSQrY6LVSJGdA,10
+mpl_typst-0.1.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+mpl_typst-0.1.0.dist-info/RECORD,,

mpl_typst-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.44.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mpl_typst-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mpl_typst

mpl_typst-0.1.0.dist-info/zip-safe

@@ -0,0 +1 @@
+