render

#!/usr/bin/env python3

import argparse
import math
import logging
import os
from pathlib import Path
import re
import shlex
import shutil
import subprocess
import sys
from tempfile import TemporaryDirectory
import yaml
import zipfile

# non standard libraries
from jinja2 import Environment, FileSystemLoader

options = {
    "block_start_string": "<+++",
    "block_end_string": "+++>",
    "variable_start_string": "<++",
    "variable_end_string": "++>",
    "comment_start_string": "{=",
    "comment_end_string": "=}",
}

section_re = re.compile("\\\section\{")
infile_re = re.compile(r"(\\input)|(\\include)")
extract_re = re.compile(r"(?<=\{).+?(?=\})")

PATH = os.path.split(os.path.realpath(__file__))[0]

jinja_env = Environment(loader=FileSystemLoader(PATH), **options)


def edition_from_tag():
    """
    sets the edition from the latests tag
    this assumes that the tag is the set per release
    """
    cmd = "git tag -l | tail -1"
    return subprocess.getoutput(cmd)


def screen_master(masterdoc, tempdir):
    prefix = os.path.join(tempdir, "slides")
    fnames = list()
    with open(os.path.join(prefix, masterdoc)) as infile:
        for line in infile:
            if infile_re.match(line):
                fnames.extend(extract_re.findall(line))
    return fnames


def count_matching_lines(fp):
    count = 0
    for line in fp:
        if section_re.match(line):
            count += 1
    return count


def count_sections(file_list, tempdir):
    """
    counting '\section(*)' lines by calling
    `count_matching_lines` - the function will
    operate in the temporary directory, to ensure
    sections introduced after parsing the configuration
    are counted.

    input:
        - `file_list` - the list of files need to typeset
          the master TeX document
        - `tempdir` - the temporary directory
    ouput:
        - the total number of sections.
    """
    prefix = os.path.join(tempdir, "slides")

    count = 0
    for fname in file_list:
        to_count = os.path.join(prefix, fname) + ".tex"
        try:
            with open(to_count) as fp:
                count += count_matching_lines(fp)
        except:
            print(f"Error treating counting sections in: '{fname}'")
    return count


def define_boundaries(section_count):
    fhe = math.floor(section_count / 2)
    return {
        "lower": 1,
        "upper": section_count,
        "first_half_end": fhe,
        "second_half_start": fhe + 1,
    }


def render_tex(env, template):
    template = template
    tpl = jinja_env.get_template(template)
    x = tpl.render(env)
    return x


def to_file(tex, fname, tempdir, path=""):
    with open(os.path.join(tempdir, path, fname), "w") as f:
        f.write(tex)


def get_pdf_name(filename):
    path_object = Path(filename)
    new_filename = path_object.with_suffix("." + "pdf")
    return new_filename


def run_pdflatex(fname="out.tex", path=".", handout=False):
    outdir = os.path.realpath(os.path.join(os.getcwd(), "slides"))
    cmd = "pdflatex -synctex=1 -interaction=nonstopmode"
    if handout:
        cmd += r' "\def\ishandout{1} \input{' + fname + r'}"'
    else:
        cmd += f" {fname}"
    cmd = shlex.split(cmd)
    retcode = subprocess.call(cmd, cwd=path)
    pdfname = get_pdf_name(fname)
    shutil.copy(os.path.join(path, pdfname), os.path.join(outdir, pdfname))
    return retcode


def parse_config(fname):
    """
    will parse the configuration file in YAML format
    an invalid yaml file, will cause the script to crash
    """
    with open(fname) as configfile:
        data = yaml.safe_load(configfile)
    return data


def find_and_replace_sections(boundaries, section_estimate, fname):
    # tex files aren't big, read all content in memory
    try:
        with open(fname) as infile:
            lines = infile.readlines()
    except:
        print(f"Error reading: '{fname}'")
        return

    # get the matching 'currentsection' lines
    first_done, second_done, minitocline = False, False, False
    for lcount, line in enumerate(lines):
        if not first_done:
            if "currentsection" in line and not "hideothersubsections" in line:
                first_done = lcount
                break
            if "hideothersubsections" in line:
                minitocline = lcount
                break
    if not minitocline:  # we need to count the line for the 2nd toc column
        for lcount, line in enumerate(lines[first_done + 1 :]):
            if not second_done:
                if "currentsection" in line:
                    second_done = lcount + first_done + 1
                    break

    if not minitocline and not (first_done and second_done):
        logger.debug("no outline found for %s -> skipping" % fname)
        return
    # first render minitoc
    if minitocline:
        lower = max((section_estimate - 2), 1)  # lower boundary not lower than 1
        upper = min(
            (section_estimate + 3), boundaries["upper"]
        )  # upper boundary not higher then upper boundary ;-)
        sections = f"{lower}-{upper}"
        lines[minitocline] = (
            "            \\tableofcontents[currentsection, sections={"
            + sections
            + "}, hideothersubsections]"
        )
    # adapt the two lines with our new boundaries:
    elif first_done and second_done:
        lines[first_done] = (
            "            \\tableofcontents[sections={%d-%d},currentsection]\n"
            % (
                boundaries["lower"],
                boundaries["first_half_end"],
            )
        )
        lines[second_done] = (
            "            \\tableofcontents[sections={%d-%d},currentsection]\n"
            % (
                boundaries["second_half_start"],
                boundaries["upper"],
            )
        )
    else:
        logger.error(f"TOC expectations for '{fname}' not met")

    with open(fname, "w") as outfile:
        for line in lines:
            outfile.write(line)


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--master-tex", required=True, help="indicate the Master TeX document"
    )
    parser.add_argument(
        "-c",
        "--configfile",
        default="config/config.yaml",
        help="indicate the configuration YAML file - default: 'config/config.yaml'",
    )
    parser.add_argument(
        "--handout", default=False, action=argparse.BooleanOptionalAction
    )
    parser.add_argument(
        "-n", "--no-rerun", default=False, action=argparse.BooleanOptionalAction
    )
    parser.add_argument(
        "--sample-directory",
        help="needed with `--handout` - should indicate directory with script file (cloze and solution)",
    )
    args = parser.parse_args()

    if args.handout and not args.sample_directory:
        print(
            "ERROR: must indicate --sample-directory when writing handouts",
            file=sys.stderr,
        )

    # the master tex needs to be without the 'slides' path, because
    # on the tempfs, the relative path work without
    args.master_tex = os.path.basename(args.master_tex)

    logger = logging.getLogger(__name__)

    data = parse_config(args.configfile)

    # setting the edition automatically:
    data["course"]["edition"] = edition_from_tag()

    with TemporaryDirectory() as tempdir:
        shutil.copytree("images", os.path.join(tempdir, "images"))
        # creating 'slides' directory (does not exist, yet):
        Path(os.path.join(tempdir, "slides", "common")).mkdir(parents=True)
        Path(os.path.join(tempdir, "slides", "users")).mkdir()
        Path(os.path.join(tempdir, "slides", "creators")).mkdir()
        Path(os.path.join(tempdir, "slides", "admin")).mkdir()
        for root, dirs, files in os.walk("slides"):
            for fname in files:
                if not fname.endswith(".tex"):
                    continue
                logger.info(f"Attempt to render {fname}")
                tex = render_tex(data, os.path.join(root, fname))
                to_file(tex, fname, tempdir, root)
        # we might need to adapt the chapter settings.
        file_list = screen_master(args.master_tex, tempdir)
        count = count_sections(file_list, tempdir)
        logger.info("Found %d sections." % count)
        boundaries = define_boundaries(count)

        # adapting chapter section display in toc slides
        # NOTE: section estimate is the assumption, that we have
        # one section per file. This assumption will NOT always hold
        # but is good enough for our purpose of setting boundaries in minitocs.
        for section_estimate, fname in enumerate(file_list):
            to_adapt = os.path.join(tempdir, "slides", fname) + ".tex"
            find_and_replace_sections(boundaries, section_estimate, to_adapt)
        # now the typesetting needs to be triggered
        run_pdflatex(
            fname=args.master_tex,
            path=os.path.join(tempdir, "slides"),
            handout=args.handout,
        )
        # re-run might be required
        if args.no_rerun:
            print("no rerun as requested")
            sys.exit()
        run_pdflatex(fname=args.master_tex, path=os.path.join(tempdir, "slides"))

        # only to produce handouts (together with script bundles)
        if args.handout:
            handout_version = (
                os.path.join("slides", os.path.splitext(args.master_tex)[0]) + ".pdf"
            )

            final_place = os.path.basename(handout_version)

            file_list = [
                (handout_version, final_place),
                ("handout/README.txt", "README.txt"),
            ]
            opj = os.path.join

            for root, dirs, files in os.walk(args.sample_directory):
                for fname in files:
                    # restrict to sample files, no helper files
                    if "copy" in fname or "README" in fname:
                        continue
                    file_list.append(
                        (opj(root, fname), opj(*root.split("/")[1:], fname))
                    )
            buildzipfname = "snakemake_intro_%s.zip" % edition_from_tag()
            z = zipfile.ZipFile(buildzipfname, "w", compression=zipfile.ZIP_DEFLATED)
            for item in file_list:
                z.write(item[0], item[1])
            z.close()