chgksuite 0.25.0b4__py3-none-any.whl → 0.26.0__py3-none-any.whl

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/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