teqn: Quickly typeset a single LaTeX expression to .png, .svg, .pdf

teqn

#!/usr/bin/env python3
r"""teqn

Quickly turn your math mode expression into cropped png, svg, or pdf.
Then you can drag and drop it into slack or illustrator or whatever.
This is basically just a wrapper around the standalone document class.

Pass your math expression (in quotes) on the command line. It will be
typeset in the align* environment by default, unless you pass --nomath,
in which case you can put the environment in the expression too.

Put me in a directory in your PATH and `chmod +x`. Requires xelatex,
but modify the script if you like a different tex better. -c and -d
flags require imagemagick, -k flag is mac only.

examples:
    $ teqn "\sum_{i=0}^n f(i)"
    # writes to the file teqn_sumi0n_fi.pdf

    $ teqn -ck "\dot{\mathbf{M}}=\mathbf{y}_t\mathbf{y}_t^\top - M"
    # writes the file teqn_dotmathbfMmathbfytmathbfyttop__M.png
    # More importantly, the -k here copied that file to clipboard!

    # writes to the file teqn_pxfrac1Z_exp__leftbeta_Hxright.png
    # note we had to escape the \ before the ! because bash.
    $ teqn --convert "p(x)=\frac{1}{Z} \exp\\!\left(-\beta H(x)\right)"

    $ teqn "\left(xyz"
    # Crashes with shortened error message (unless -v is set):
    pdflatex crashed with error:
    ! Missing \right. inserted.
    <inserted text>
                    \right .
    l.7 \[ \left( \]
"""
import argparse
import os
import subprocess
import sys
import tempfile

# -------------------------- be argumentative -------------------------
ap = argparse.ArgumentParser(
    epilog=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
)
ap.add_argument(
    "tex", nargs="+", help="Your tex math expression. No $ or \\[ necessary."
)
ap.add_argument(
    "-c",
    "--convert",
    action="store_true",
    help="Make a .png instead of a .pdf.",
)
ap.add_argument(
    "-d",
    "--donvert",
    action="store_true",
    help="Make a transparent .png instead of a .pdf.",
)
ap.add_argument(
    "-f",
    "--helvet",
    action="store_true",
    help="Use Helvetica.",
)
ap.add_argument(
    "--svg",
    action="store_true",
    help="Make a .svg instead of a .pdf.",
)
ap.add_argument(
    "-k",
    "--copy",
    action="store_true",
    help="Put output file into clipboard (mac only).",
)
ap.add_argument(
    "-v",
    "--verbose",
    action="store_true",
    help="Print the tex document and pdflatex output.",
)
ap.add_argument(
    "--color",
    default="black",
    help="Text color. Useful in combination with -d / --donvert.",
)
ap.add_argument(
    "--dpi",
    default="600",
    help="For png modes. Anyone say Google Slides?",
)
ap.add_argument(
    "--nomath",
    action="store_true",
    help="Usually, teqn uses align* environment, but with this flag "
    "you can pick your own environment and do a table or whatever.",
)
args = ap.parse_args(None if sys.argv[1:] else ["-h"])

# -------- constants which i did not see fit to put into args ---------
# choose your own tex->pdf
pdftex = "xelatex"

# Put your preamble stuff here.
preamble = r"""
\usepackage{mathtools}
\usepackage{amssymb}
\usepackage{xcolor}
\usepackage{physics}
\usepackage{booktabs}
"""
if args.helvet:
    preamble += (
        r"\renewcommand{\familydefault}{\sfdefault}" "\n"
        r"\usepackage[scaled=1]{helvet}" "\n"
        r"\usepackage[helvet]{sfmath}" "\n"
    )

# This is what we run when we see the flag -c,--convert
# The -flatten makes the background white instead of transparent.
convert = args.convert or args.donvert
if convert:
    assert not (args.convert and args.donvert)
convert_cmd = [
    "convert",
    "-density",
    args.dpi,
    "-colorspace",
    "RGB",
    "-trim",
    "+repage",
]
if args.convert:
    convert_cmd[1:1] = "-flatten"

# ----------------------------- build tex -----------------------------
expr = " ".join(args.tex)
if not args.nomath:
    expr = f"\\begin{{align*}} {expr} \\end{{align*}}"
teqn = f"""
\\documentclass[preview,varwidth,border=1pt]{{standalone}}{preamble}
\\begin{{document}}
\\color{{{args.color}}}
{expr}
\\end{{document}}
""".lstrip()

if args.verbose:
    print(teqn)

# ---------------------------- make output ----------------------------
# Name the document based on the formula.
name = "".join(c for c in expr if c not in "\n\\{([]})]^_=-+*&#@!.|~?/:;,<>")
name = f"teqn_{name.strip().replace(' ', '_')}"[:60]
outname = pdfname = f"{name}.pdf"

# Run latex in a temp dir so that we don't leave aux files everywhere.
with tempfile.TemporaryDirectory(prefix="teqn") as td:
    # Write teqn to tex file
    teqn_tex = os.path.join(td, f"{name}.tex")
    with open(teqn_tex, "w") as teqn_tex_f:
        teqn_tex_f.write(teqn)

    # Compile and only show output on error.
    tex_command = [pdftex, "--halt-on-error", teqn_tex]
    if args.svg:
        tex_command = [pdftex, "--no-pdf", "--halt-on-error", teqn_tex]
    res = subprocess.run(tex_command, cwd=td, capture_output=True)
    if res.returncode:
        # Show the error that killed us and exit.
        errmsg = res.stdout.decode()
        if args.verbose:
            sys.exit(errmsg)
        else:
            start_i, end_i = errmsg.find("!"), errmsg.find("!  ==>")
            errmsg = errmsg[start_i:end_i].strip()
            sys.exit("\n".join(("latex crashed with error:", errmsg)))
    elif args.verbose:
        print(res.stdout.decode())

    # Put output file in cwd
    if convert:
        outname = f"{name}.png"
        subprocess.run(
            [*convert_cmd, os.path.join(td, pdfname), outname],
        )
    elif args.svg:
        outname = f"{name}.svg"
        res = subprocess.run(["dvisvgm", f"{name}.xdv"], cwd=td)
        os.rename(os.path.join(td, outname), outname)
    else:
        os.rename(os.path.join(td, pdfname), outname)


# Copy the file to clipboard if requested (mac only.)
if args.copy:
    subprocess.run(
        [
            "osascript",
            "-e",
            "set the clipboard to POSIX file "
            f'"{os.path.join(os.getcwd(), outname)}"',
        ]
    )