chgksuite 0.26.0b3__tar.gz → 0.26.0b4__tar.gz

{chgksuite-0.26.0b3/chgksuite.egg-info → chgksuite-0.26.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chgksuite
-Version: 0.26.0b3
+Version: 0.26.0b4
 Summary: A package for chgk automation
 Home-page: https://gitlab.com/peczony/chgksuite
 Author: Alexander Pecheny

chgksuite-0.26.0b4/chgksuite/handouter/gen.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import itertools
+import os
+import re
+from collections import defaultdict
+
+import toml
+
+from chgksuite.common import get_source_dirs
+from chgksuite.composer.chgksuite_parser import parse_4s
+from chgksuite.composer.composer_common import _parse_4s_elem, parseimg
+from chgksuite.handouter.utils import read_file, write_file
+
+
+def postprocess(s):
+    return s.replace("\\_", "_")
+
+
+def generate_handouts_list(handouts, output_dir, base_name, parsed):
+    """Generate a human-readable file with question numbers that have handouts."""
+    question_numbers = sorted([int(h["for_question"]) for h in handouts])
+
+    content = "ВОПРОСЫ С РАЗДАТОЧНЫМ МАТЕРИАЛОМ:\n\n"
+    content += f"Сквозная нумерация:\n{', '.join(map(str, question_numbers))}\n\n"
+
+    content += "По турам:\n"
+    tour = 0
+    by_tour = {}
+    for tup in parsed:
+        if tup[0] == "section":
+            tour += 1
+            by_tour[tour] = []
+        if tup[0] == "Question":
+            if tour == 0:
+                tour = 1
+                by_tour[tour] = []
+            if tup[1]["number"] in question_numbers:
+                by_tour[tour].append(tup[1]["number"])
+
+    for tour in sorted(by_tour):
+        tour_handouts = by_tour[tour]
+        if tour_handouts:
+            content += f"Тур {tour}: {', '.join(map(str, tour_handouts))}\n"
+        else:
+            content += f"Тур {tour}: нет раздаток\n"
+
+    output_fn = os.path.join(output_dir, base_name + "_handouts_list.txt")
+    write_file(output_fn, content)
+    print(f"File with list of handouts: {output_fn}")
+    print(content)
+
+
+def generate_handouts(args):
+    _, resourcedir = get_source_dirs()
+    labels = toml.loads(
+        read_file(os.path.join(resourcedir, f"labels_{args.lang}.toml"))
+    )
+    handout_re = re.compile(
+        "\\["
+        + labels["question_labels"]["handout_short"]
+        + ".+?:( |\n)(?P<handout_text>.+?)\\]",
+        flags=re.DOTALL,
+    )
+
+    cnt = read_file(args.filename)
+    parsed = parse_4s(cnt)
+
+    questions = [q[1] for q in parsed if q[0] == "Question"]
+    handouts = []
+    for q in questions:
+        if isinstance(q["question"], list):
+            question_text = "\n".join(itertools.chain.from_iterable(q["question"]))
+        else:
+            question_text = q["question"]
+        question_text_lower = question_text.lower()
+        srch = handout_re.search(question_text)
+        if srch:
+            text = postprocess(srch.group("handout_text"))
+            elems = _parse_4s_elem(text)
+            img = [el for el in elems if el[0] == "img"]
+            if img:
+                try:
+                    parsed_img = parseimg(img[0][1])
+                except:
+                    print(
+                        f"Image file for question {q['number']} not found, add it by hand"
+                    )
+                    continue
+            else:
+                parsed_img = None
+            res = {"for_question": q["number"]}
+            if parsed_img:
+                res["image"] = parsed_img["imgfile"]
+            else:
+                res["text"] = text
+            handouts.append(res)
+        elif (
+            "раздат" in question_text_lower
+            or "роздан" in question_text_lower
+            or "(img" in question_text_lower
+        ):
+            print(f"probably badly formatted handout for question {q['number']}")
+            res = {"for_question": q["number"], "text": postprocess(question_text)}
+            handouts.append(res)
+    result = []
+    result_by_question = defaultdict(list)
+    for handout in handouts:
+        if "image" in handout:
+            key = "image"
+            prefix = "image: "
+        else:
+            key = "text"
+            prefix = ""
+        value = handout[key]
+        formatted = (
+            f"for_question: {handout['for_question']}\n" if not args.separate else ""
+        ) + f"columns: 3\n\n{prefix}{value}"
+        result.append(formatted)
+        result_by_question[handout["for_question"]].append(formatted)
+    output_dir = os.path.dirname(os.path.abspath(args.filename))
+    bn, _ = os.path.splitext(os.path.basename(args.filename))
+
+    if args.separate:
+        for k, v in result_by_question.items():
+            if len(v) > 1:
+                for i, cnt in enumerate(v):
+                    output_fn = os.path.join(
+                        output_dir, f"{bn}_q{k.zfill(2)}_{i + 1}.txt"
+                    )
+                    print(output_fn)
+                    write_file(output_fn, cnt)
+            else:
+                output_fn = os.path.join(output_dir, f"{bn}_q{str(k).zfill(2)}.txt")
+                print(output_fn)
+                write_file(output_fn, v[0])
+    else:
+        output_fn = os.path.join(output_dir, bn + "_handouts.txt")
+        print(f"output filename: {output_fn}")
+        write_file(output_fn, "\n---\n".join(result))
+
+    if args.list_handouts:
+        generate_handouts_list(handouts, output_dir, bn, parsed)

chgksuite-0.26.0b4/chgksuite/handouter/installer.py

@@ -0,0 +1,245 @@
+import functools
+import os
+import platform
+import re
+import shutil
+import subprocess
+import tarfile
+import zipfile
+
+import requests
+
+
+def get_utils_dir():
+    path = os.path.join(os.path.expanduser("~"), ".pecheny_utils")
+    if not os.path.exists(path):
+        os.mkdir(path)
+    return path
+
+
+def escape_latex(text):
+    text = text.replace("\\", "\\textbackslash")
+    text = text.replace("~", "\\textasciitilde")
+    text = text.replace("^", "\\textasciicircum")
+    for char in ("%", "&", "$", "#", "{", "}", "_"):
+        text = text.replace(char, "\\" + char)
+    text = text.replace("\n", "\\linebreak\n")
+    return text
+
+
+def check_tectonic_path(tectonic_path):
+    proc = subprocess.run([tectonic_path, "--help"], capture_output=True, check=True)
+    return proc.returncode == 0
+
+
+def get_tectonic_path():
+    errors = []
+    system = platform.system()
+
+    cpdir = get_utils_dir()
+    if system == "Windows":
+        binary_name = "tectonic.exe"
+        tectonic_path = os.path.join(cpdir, binary_name)
+    else:
+        binary_name = "tectonic"
+        tectonic_path = os.path.join(cpdir, binary_name)
+
+    tectonic_ok = False
+    try:
+        tectonic_ok = check_tectonic_path(binary_name)
+    except FileNotFoundError:
+        pass  # tectonic not found in PATH
+    except subprocess.CalledProcessError as e:
+        errors.append(f"tectonic --version failed: {type(e)} {e}")
+    if tectonic_ok:
+        return binary_name
+    if os.path.isfile(tectonic_path):
+        try:
+            tectonic_ok = check_tectonic_path(tectonic_path)
+        except subprocess.CalledProcessError as e:
+            errors.append(f"tectonic --version failed: {type(e)} {e}")
+    if tectonic_ok:
+        return tectonic_path
+
+
+def github_get_latest_release(repo):
+    url = f"https://api.github.com/repos/{repo}/releases/latest"
+    req = requests.get(url)
+    assets_url = req.json()["assets_url"]
+    assets_req = requests.get(assets_url)
+    return {asset["name"]: asset["browser_download_url"] for asset in assets_req.json()}
+
+
+def darwin_is_emulated():
+    try:
+        sub = subprocess.run(
+            ["sysctl", "-n", "sysctl.proc_translated"], capture_output=True, check=True
+        )
+        out = sub.stdout.decode("utf8").strip()
+        return int(out)
+    except subprocess.CalledProcessError:
+        print("couldn't tell if emulated, returning 0")
+        return 0
+
+
+def parse_tectonic_archive_name(archive_name):
+    if archive_name.endswith(".tar.gz"):
+        archive_name = archive_name[: -len(".tar.gz")]
+    elif archive_name.endswith(".zip"):
+        archive_name = archive_name[: -len(".zip")]
+    else:
+        return
+    sp = archive_name.split("-")
+    result = {
+        "version": sp[1],
+        "arch": sp[2],
+        "manufacturer": sp[3],
+        "system": sp[4],
+    }
+    if len(sp) > 5:
+        result["toolchain"] = sp[5]
+    return result
+
+
+# download_file function taken from https://stackoverflow.com/a/39217788
+def download_file(url):
+    print(f"downloading from {url}...")
+    local_filename = url.split("/")[-1]
+    with requests.get(url, stream=True) as resp:
+        resp.raw.read = functools.partial(resp.raw.read, decode_content=True)
+        with open(local_filename, "wb") as f:
+            shutil.copyfileobj(resp.raw, f, length=16 * 1024 * 1024)
+    return local_filename
+
+
+def extract_zip(zip_file, dirname=None):
+    if dirname is None:
+        dirname = zip_file[:-4]
+    with zipfile.ZipFile(zip_file, "r") as zip_ref:
+        zip_ref.extractall(dirname)
+    os.remove(zip_file)
+
+
+def extract_tar(tar_file, dirname=None):
+    if dirname is None:
+        dirname = tar_file[: tar_file.lower().index(".tar")]
+    tf = tarfile.open(tar_file)
+    tf.extractall(dirname)
+    os.remove(tar_file)
+
+
+def extract_archive(filename, dirname=None):
+    if filename.lower().endswith((".tar", ".tar.gz")):
+        extract_tar(filename, dirname=dirname)
+    elif filename.lower().endswith(".zip"):
+        extract_zip(filename, dirname=dirname)
+
+
+def guess_archive_url(assets):
+    system = platform.system()
+    proc = platform.processor()
+    if system == "Darwin":
+        if proc == "arm" or (proc == "i386" and darwin_is_emulated()):
+            arch = "aarch64"
+        else:
+            arch = "x86_64"
+        for k, v in assets.items():
+            parsed = parse_tectonic_archive_name(k)
+            if not parsed:
+                continue
+            if parsed["arch"] == arch and parsed["system"] == "darwin":
+                return v
+    elif system == "Windows":
+        for k, v in assets.items():
+            parsed = parse_tectonic_archive_name(k)
+            if not parsed:
+                continue
+            if (
+                parsed["arch"] == "x86_64"
+                and parsed["system"] == "windows"
+                and parsed["toolchain"] == "msvc"
+            ):
+                return v
+    elif system == "Linux":
+        for k, v in assets.items():
+            parsed = parse_tectonic_archive_name(k)
+            if not parsed:
+                continue
+            if (
+                (not proc or (proc and parsed["arch"] == proc))
+                and parsed["system"] == "linux"
+                and parsed["toolchain"] == "musl"
+            ):
+                return v
+    raise Exception(f"Archive for system {system} proc {proc} not found")
+
+
+def archive_url_from_regex(assets, regex):
+    for k, v in assets.items():
+        if re.match(regex, k):
+            return v
+    raise Exception(f"Archive for regex {regex} not found")
+
+
+def install_tectonic(args):
+    system = platform.system()
+    assets = github_get_latest_release("tectonic-typesetting/tectonic")
+    if args.tectonic_package_regex:
+        archive_url = archive_url_from_regex(assets, args.tectonic_package_regex)
+    else:
+        archive_url = guess_archive_url(assets)
+    downloaded = download_file(archive_url)
+    dirname = "tectonic_folder"
+    extract_archive(downloaded, dirname=dirname)
+    if system == "Windows":
+        filename = "tectonic.exe"
+    else:
+        filename = "tectonic"
+    target_path = os.path.join(get_utils_dir(), filename)
+    shutil.move(os.path.join(dirname, filename), target_path)
+    shutil.rmtree(dirname)
+    return target_path
+
+
+def install_font(url):
+    fn = url.split("/")[-1].split("?")[0]
+    bn, ext = os.path.splitext(fn)
+    if "." in bn:
+        new_fn = bn.replace(".", "_") + ext
+    else:
+        new_fn = fn
+    dir_name = new_fn[:-4]
+    dir_name_base = dir_name.split(os.pathsep)[-1]
+    fonts_dir = os.path.join(get_utils_dir(), "fonts")
+    if not os.path.exists(fonts_dir):
+        os.makedirs(fonts_dir)
+    target_dir = os.path.join(fonts_dir, dir_name_base)
+    if os.path.isdir(target_dir):
+        print(f"{target_dir} already exists")
+        return
+    download_file(url)
+    if fn != new_fn:
+        os.rename(fn, new_fn)
+    extract_archive(new_fn, dirname=dir_name)
+    if not os.path.isdir(target_dir):
+        shutil.copytree(dir_name, target_dir)
+    shutil.rmtree(dir_name)
+
+
+def find_font(file_name, root_dir=None):
+    root_dir = root_dir or os.path.join(get_utils_dir(), "fonts")
+    if not os.path.isdir(root_dir):
+        os.makedirs(root_dir, exist_ok=True)
+    for dir_, _, files in os.walk(root_dir):
+        for fn in files:
+            if fn == file_name:
+                return os.path.join(dir_, fn)
+    raise Exception(f"{file_name} not found")
+
+
+def install_font_from_github_wrapper(repo):
+    latest = github_get_latest_release(repo)
+    for k, v in latest.items():
+        if k.endswith(".zip"):
+            install_font(v)
+            break

chgksuite-0.26.0b4/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-0.26.0b4/chgksuite/handouter/runner.py

@@ -0,0 +1,234 @@
+#!/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 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()
+        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-0.26.0b4/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-0.26.0b4/chgksuite/handouter/utils.py

@@ -0,0 +1,67 @@
+import os
+
+from pecheny_utils 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 parse_handouts(contents):
+    blocks = contents.split("\n---\n")
+    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

chgksuite-0.26.0b4/chgksuite/version.py

@@ -0,0 +1 @@
+__version__ = "0.26.0b4"

{chgksuite-0.26.0b3 → chgksuite-0.26.0b4/chgksuite.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chgksuite
-Version: 0.26.0b3
+Version: 0.26.0b4
 Summary: A package for chgk automation
 Home-page: https://gitlab.com/peczony/chgksuite
 Author: Alexander Pecheny

{chgksuite-0.26.0b3 → chgksuite-0.26.0b4}/chgksuite.egg-info/SOURCES.txt

@@ -33,6 +33,13 @@ chgksuite/composer/stats.py
 chgksuite/composer/telegram.py
 chgksuite/composer/telegram_bot.py
 chgksuite/composer/telegram_parser.py
+chgksuite/handouter/__init__.py
+chgksuite/handouter/gen.py
+chgksuite/handouter/installer.py
+chgksuite/handouter/pack.py
+chgksuite/handouter/runner.py
+chgksuite/handouter/tex_internals.py
+chgksuite/handouter/utils.py
 chgksuite/resources/cheader.tex
 chgksuite/resources/fix-unnumbered-sections.sty
 chgksuite/resources/labels_by.toml

{chgksuite-0.26.0b3 → chgksuite-0.26.0b4}/setup.py

@@ -31,7 +31,7 @@ setup(
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
     ],
-    packages=["chgksuite", "chgksuite.composer"],
+    packages=["chgksuite", "chgksuite.composer", "chgksuite.handouter"],
     package_data={
         "chgksuite": [
             "resources/*.json",

chgksuite-0.26.0b3/chgksuite/version.py

@@ -1 +0,0 @@
-__version__ = "0.26.0b3"