chgksuite 0.25.1__py3-none-any.whl → 0.26.0__py3-none-any.whl

chgksuite/handouter/pack.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import math
+import os
+import subprocess
+
+from pypdf import PdfWriter
+
+from chgksuite.handouter.utils import parse_handouts
+
+
+def run_hndt(fullpath, args):
+    spargs = ["hndt"]
+    if args.font:
+        spargs.extend(["--font", args.font])
+    spargs.append(fullpath)
+    proc = subprocess.run(spargs, cwd=args.folder, check=True, capture_output=True)
+    ns = globals()
+    ns.update(locals())
+    lines = [line for line in proc.stdout.decode("utf8").split("\n") if line]
+    return lines[-1].split("Output file:")[1].strip()
+
+
+def pdf_output(pages, filename):
+    print(f"merging to {filename}, total pages {len(pages)}...")
+    merger = PdfWriter()
+
+    for pdf in pages:
+        merger.append(pdf)
+
+    merger.write(filename)
+    merger.close()
+
+
+def pack_handouts(args):
+    if not args.folder:
+        args.folder = os.getcwd()
+    args.folder = os.path.abspath(args.folder)
+
+    color_pages = []
+    bw_pages = []
+
+    for fn in sorted(os.listdir(args.folder)):
+        if not fn.endswith(".txt"):
+            continue
+        fullpath = os.path.join(args.folder, fn)
+        with open(fullpath, encoding="utf8") as f:
+            contents = f.read()
+        parsed = parse_handouts(contents)
+        if len(parsed) > 1:
+            print(f"skipping {fn}: more than one handout per txt is not supported")
+            continue
+        color = parsed[0].get("color") or 0
+        handouts_per_team = parsed[0].get("handouts_per_team") or 3
+        total_handouts_per_page = parsed[0]["columns"] * parsed[0]["rows"]
+        teams_per_page = total_handouts_per_page / handouts_per_team
+        pages = math.ceil((args.n_teams + 1) / teams_per_page)
+        print(f"processing {fn}")
+        print(f"color = {color}")
+        print(f"handouts_per_team = {handouts_per_team}")
+        print(f"total_handouts_per_page = {total_handouts_per_page}")
+        print(f"teams_per_page = {round(teams_per_page, 1)}")
+        print(f"pages = {pages}")
+        print("running hndt...")
+        output_file = run_hndt(fullpath, args)
+        if color:
+            color_pages += [output_file] * pages
+        else:
+            bw_pages += [output_file] * pages
+    if color_pages:
+        pdf_output(
+            color_pages,
+            os.path.join(args.folder, args.output_filename_prefix + "_color.pdf"),
+        )
+    if bw_pages:
+        pdf_output(
+            bw_pages,
+            os.path.join(args.folder, args.output_filename_prefix + "_bw.pdf"),
+        )

chgksuite/handouter/runner.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import os
+import shutil
+import subprocess
+import time
+
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+from chgksuite.handouter.gen import generate_handouts
+from chgksuite.handouter.pack import pack_handouts
+from chgksuite.handouter.installer import get_tectonic_path, install_tectonic
+from chgksuite.handouter.tex_internals import (
+    GREYTEXT,
+    GREYTEXT_LANGS,
+    HEADER,
+    IMG,
+    IMGWIDTH,
+    TIKZBOX_END,
+    TIKZBOX_INNER,
+    TIKZBOX_START,
+)
+from chgksuite.handouter.utils import parse_handouts, read_file, replace_ext, write_file
+
+
+class HandoutGenerator:
+    SPACE = 1.5  # mm
+
+    def __init__(self, args):
+        self.args = args
+        self.blocks = [self.get_header()]
+
+    def get_header(self):
+        header = HEADER
+        header = (
+            header.replace("<PAPERWIDTH>", str(self.args.paperwidth))
+            .replace("<PAPERHEIGHT>", str(self.args.paperheight))
+            .replace("<MARGIN_LEFT>", str(self.args.margin_left))
+            .replace("<MARGIN_RIGHT>", str(self.args.margin_right))
+            .replace("<MARGIN_TOP>", str(self.args.margin_top))
+            .replace("<MARGIN_BOTTOM>", str(self.args.margin_bottom))
+            .replace("<TIKZ_MM>", str(self.args.tikz_mm))
+        )
+        if self.args.font:
+            header = header.replace("Arial", self.args.font)
+        return header
+
+    def parse_input(self, filepath):
+        contents = read_file(filepath)
+        return parse_handouts(contents)
+
+    def generate_for_question(self, question_num):
+        return GREYTEXT.replace(
+            "<GREYTEXT>", GREYTEXT_LANGS[self.args.lang].format(question_num)
+        )
+
+    def make_tikzbox(self, block):
+        if block.get("no_center"):
+            align = ""
+        else:
+            align = ", align=center"
+        textwidth = ", text width=\\boxwidthinner"
+        fs = block.get("font_size") or self.args.font_size
+        fontsize = "\\fontsize{FSpt}{LHpt}\\selectfont ".replace("FS", str(fs)).replace(
+            "LH", str(round(fs * 1.2, 1))
+        )
+        contents = block["contents"]
+        if block.get("font_family"):
+            contents = "\\fontspec{" + block["font_family"] + "}" + contents
+        return (
+            TIKZBOX_INNER.replace("<CONTENTS>", contents)
+            .replace("<ALIGN>", align)
+            .replace("<TEXTWIDTH>", textwidth)
+            .replace("<FONTSIZE>", fontsize)
+        )
+
+    def get_page_width(self):
+        return self.args.paperwidth - self.args.margin_left - self.args.margin_right - 2
+
+    def generate_regular_block(self, block_):
+        block = block_.copy()
+        if not (block.get("image") or block.get("text")):
+            return
+        columns = block["columns"]
+        spaces = block["columns"] - 1
+        boxwidth = self.args.boxwidth or round(
+            (self.get_page_width() - spaces * self.SPACE) / block["columns"],
+            3,
+        )
+        total_width = boxwidth * columns + spaces * self.SPACE
+        if self.args.debug:
+            print(
+                f"columns: {columns}, boxwidth: {boxwidth}, total width: {total_width}"
+            )
+        boxwidthinner = self.args.boxwidthinner or (boxwidth - 2 * self.args.tikz_mm)
+        header = [
+            r"\setlength{\boxwidth}{<Q>mm}%".replace("<Q>", str(boxwidth)),
+            r"\setlength{\boxwidthinner}{<Q>mm}%".replace("<Q>", str(boxwidthinner)),
+        ]
+        rows = []
+        contents = []
+        if block.get("image"):
+            img_qwidth = block.get("resize_image") or 1.0
+            imgwidth = IMGWIDTH.replace("<QWIDTH>", str(img_qwidth))
+            contents.append(
+                IMG.replace("<IMGPATH>", block["image"]).replace("<IMGWIDTH>", imgwidth)
+            )
+        if block.get("text"):
+            contents.append(block["text"])
+        block["contents"] = "\\linebreak\n".join(contents)
+        if block.get("no_center"):
+            block["centering"] = ""
+        else:
+            block["centering"] = "\\centering"
+        for _ in range(block.get("rows") or 1):
+            row = (
+                TIKZBOX_START.replace("<CENTERING>", block["centering"])
+                + "\n".join([self.make_tikzbox(block)] * block["columns"])
+                + TIKZBOX_END
+            )
+            rows.append(row)
+        return "\n".join(header) + "\n" + "\n\n\\vspace{1mm}\n\n".join(rows)
+
+    def generate(self):
+        for block in self.parse_input(self.args.filename):
+            if not block:
+                self.blocks.append("\n\\clearpage\n")
+                continue
+            if self.args.debug:
+                print(block)
+            if block.get("for_question"):
+                self.blocks.append(self.generate_for_question(block["for_question"]))
+            if block.get("columns"):
+                block = self.generate_regular_block(block)
+                if block:
+                    self.blocks.append(block)
+        self.blocks.append("\\end{document}")
+        return "\n\n".join(self.blocks)
+
+
+def process_file(args, file_dir, bn):
+    tex_contents = HandoutGenerator(args).generate()
+    tex_path = os.path.join(file_dir, f"{bn}_{args.lang}.tex")
+    write_file(tex_path, tex_contents)
+
+    tectonic_path = get_tectonic_path()
+    if not tectonic_path:
+        print("tectonic is not present, installing it...")
+        install_tectonic(args)
+        tectonic_path = get_tectonic_path()
+    if not tectonic_path:
+        raise Exception("tectonic couldn't be installed successfully :(")
+    if args.debug:
+        print(f"tectonic found at `{tectonic_path}`")
+
+    subprocess.run(
+        [tectonic_path, os.path.basename(tex_path)], check=True, cwd=file_dir
+    )
+
+    output_file = replace_ext(tex_path, "pdf")
+
+    if args.compress:
+        print(f"compressing {output_file}")
+        size_before = round(os.stat(output_file).st_size / 1024)
+        output_file_compressed = output_file[:-4] + ".compressed.pdf"
+        subprocess.run(
+            [
+                "gs",
+                "-sDEVICE=pdfwrite",
+                "-dCompatibilityLevel=1.5",
+                f"-dPDFSETTINGS=/{args.pdfsettings}",
+                "-dNOPAUSE",
+                "-dQUIET",
+                "-dBATCH",
+                f"-sOutputFile={output_file_compressed}",
+                output_file,
+            ],
+            check=True,
+        )
+        shutil.move(output_file_compressed, output_file)
+        size_after = round(os.stat(output_file).st_size / 1024)
+        q = round(size_after / size_before, 1)
+        print(f"before: {size_before}kb, after: {size_after}kb, compression: {q}")
+
+    print(f"Output file: {output_file}")
+
+    if not args.debug:
+        os.remove(tex_path)
+
+
+class FileChangeHandler(FileSystemEventHandler):
+    def __init__(self, args, file_dir, bn):
+        self.args = args
+        self.file_dir = file_dir
+        self.bn = bn
+        self.last_processed = 0
+
+    def on_modified(self, event):
+        if event.src_path == os.path.abspath(self.args.filename):
+            # Debounce to avoid processing the same change multiple times
+            current_time = time.time()
+            if current_time - self.last_processed > 1:
+                print(f"File {self.args.filename} changed, regenerating PDF...")
+                process_file(self.args, self.file_dir, self.bn)
+                self.last_processed = current_time
+
+
+def run_handouter(args):
+    file_dir = os.path.dirname(os.path.abspath(args.filename))
+    bn, _ = os.path.splitext(os.path.basename(args.filename))
+
+    process_file(args, file_dir, bn)
+
+    if args.watch:
+        print(f"Watching {args.filename} for changes. Press Ctrl+C to stop.")
+        event_handler = FileChangeHandler(args, file_dir, bn)
+        observer = Observer()
+        observer.schedule(event_handler, path=file_dir, recursive=False)
+        observer.start()
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            observer.stop()
+        observer.join()
+
+
+def gui_handouter(args):
+    if args.handoutssubcommand == "run":
+        run_handouter(args)
+    elif args.handoutssubcommand == "generate":
+        generate_handouts(args)
+    elif args.handoutssubcommand == "pack":
+        pack_handouts(args)
+    elif args.handoutssubcommand == "install":
+        install_tectonic(args)

chgksuite/handouter/tex_internals.py

@@ -0,0 +1,47 @@
+HEADER = r"""
+\documentclass{minimal}
+\usepackage[paperwidth=<PAPERWIDTH>mm,paperheight=<PAPERHEIGHT>mm,top=<MARGIN_TOP>mm,bottom=<MARGIN_BOTTOM>mm,left=<MARGIN_LEFT>mm,right=<MARGIN_RIGHT>mm]{geometry}
+\frenchspacing
+\usepackage{fontspec}
+\usepackage{xcolor}
+\usepackage{tikz}
+\usepackage{calc}
+\usepackage[document]{ragged2e}
+\setmainfont{Arial}
+\newlength{\boxwidth}
+\newlength{\boxwidthinner}
+\begin{document}
+\fontsize{14pt}{16pt}\selectfont
+\setlength\parindent{0pt}
+\tikzstyle{box}=[draw, dashed, rectangle, inner sep=<TIKZ_MM>mm]
+\raggedright
+\raggedbottom
+""".strip()
+
+GREYTEXT = r"""{\fontsize{9pt}{11pt}\selectfont \textcolor{gray}{<GREYTEXT>}}"""
+
+GREYTEXT_LANGS = {
+    "by": "Да пытаньня {}",
+    "en": "Handout for question {}",
+    "kz": "{}-сұрақтың үлестіру материалы",
+    "ro": "Material care urmează a fi distribuit pentru întrebarea {}",
+    "ru": "К вопросу {}",
+    "sr": "Materijal za deljenje uz pitanje {}",
+    "ua": "До запитання {}",
+    "uz": "{} саволга тарқатма материал",
+}
+
+TIKZBOX_START = r"""{<CENTERING>
+"""
+
+TIKZBOX_INNER = r"""
+\begin{tikzpicture}
+\node[box, minimum width=\boxwidth<TEXTWIDTH><ALIGN>] {<FONTSIZE><CONTENTS>\par};
+\end{tikzpicture}
+""".strip()
+
+TIKZBOX_END = "\n}"
+
+IMG = r"""\includegraphics<IMGWIDTH>{<IMGPATH>}"""
+
+IMGWIDTH = r"[width=<QWIDTH>\textwidth]"

chgksuite/handouter/utils.py

@@ -0,0 +1,88 @@
+import os
+
+from chgksuite.handouter.installer import escape_latex
+
+RESERVED_WORDS = [
+    "image",
+    "for_question",
+    "columns",
+    "rows",
+    "resize_image",
+    "font_size",
+    "font_family",
+    "no_center",
+    "raw_tex",
+    "color",
+    "handouts_per_team",
+]
+
+
+def read_file(filepath):
+    with open(filepath, "r", encoding="utf8") as f:
+        contents = f.read()
+    return contents
+
+
+def write_file(filepath, contents):
+    with open(filepath, "w", encoding="utf8") as f:
+        f.write(contents)
+
+
+def replace_ext(filepath, new_ext):
+    if not new_ext.startswith("."):
+        new_ext = "." + new_ext
+    dirname = os.path.dirname(filepath)
+    basename = os.path.basename(filepath)
+    base, _ = os.path.splitext(basename)
+    return os.path.join(dirname, base + new_ext)
+
+
+def wrap_val(key, val):
+    if key in ("columns", "rows", "no_center", "color", "handouts_per_team"):
+        return int(val.strip())
+    if key in ("resize_image", "font_size"):
+        return float(val.strip())
+    return val.strip()
+
+
+def split_array_by_value(arr, delimiter):
+    result = []
+    current_subarray = []
+    for item in arr:
+        if item == delimiter:
+            result.append(current_subarray)
+            current_subarray = []
+        else:
+            current_subarray.append(item)
+    result.append(current_subarray)
+    return result
+
+
+def split_blocks(contents):
+    lines = contents.split("\n")
+    sp = ["\n".join(x) for x in split_array_by_value(lines, "---")]
+    if not sp[0].strip():
+        sp = sp[1:]
+    return sp
+
+
+def parse_handouts(contents):
+    blocks = split_blocks(contents)
+    result = []
+    for block_ in blocks:
+        block = block_.strip()
+        block_dict = {}
+        text = []
+        lines = block.split("\n")
+        for line in lines:
+            sp = line.split(":", 1)
+            if sp[0] in RESERVED_WORDS:
+                block_dict[sp[0]] = wrap_val(sp[0], sp[1])
+            elif line.strip():
+                text.append(line.strip())
+        if text:
+            block_dict["text"] = "\n".join(text).strip()
+            if not block_dict.get("raw_tex"):
+                block_dict["text"] = escape_latex(block_dict["text"])
+        result.append(block_dict)
+    return result