chgksuite 0.26.0b2__tar.gz → 0.26.0b4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chgksuite
-Version: 0.26.0b2
+Version: 0.26.0b4
 Summary: A package for chgk automation
 Home-page: https://gitlab.com/peczony/chgksuite
 Author: Alexander Pecheny
@@ -20,12 +20,14 @@ Requires-Dist: parse
 Requires-Dist: Pillow
 Requires-Dist: ply
 Requires-Dist: pypandoc
+Requires-Dist: pypdf
 Requires-Dist: pyperclip
 Requires-Dist: python-docx
 Requires-Dist: python-pptx
-Requires-Dist: requests
 Requires-Dist: python-telegram-bot
+Requires-Dist: requests
 Requires-Dist: toml
+Requires-Dist: watchdog
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{chgksuite-0.26.0b2 → chgksuite-0.26.0b4}/chgksuite/cli.py

@@ -12,6 +12,8 @@ from chgksuite.common import (
     load_settings,
 )
 from chgksuite.composer import gui_compose
+from chgksuite.handouter.runner import gui_handouter
+from chgksuite.handouter.tex_internals import GREYTEXT_LANGS
 from chgksuite.parser import gui_parse
 from chgksuite.trello import gui_trello
 from chgksuite.version import __version__
@@ -817,6 +819,205 @@ class ArgparseBuilder:
             caption="Не открывать браузер",
         )
 
+        cmdhandouts = subparsers.add_parser("handouts")
+        cmdhandouts_subcommands = cmdhandouts.add_subparsers(dest="handoutssubcommand")
+        cmdhandouts_run = self.add_parser(cmdhandouts_subcommands, "run")
+        self.add_argument(
+            cmdhandouts_run,
+            "filename",
+            help="file with handouts",
+            caption="Имя файла с раздатками",
+            filetypes=[("handouts files", "*.hndts"), ("text files", "*.txt")],
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--lang",
+            default="ru",
+            argtype="radiobutton",
+            choices=sorted(GREYTEXT_LANGS.keys()),
+            help="language",
+            caption="Язык",
+            advanced=True,
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--compress",
+            action="store_true",
+            help="compress",
+            caption="Сжать файл после вёрстки (требует установленного ghostscript)",
+            advanced=True,
+        )
+        self.add_argument(cmdhandouts_run, "--font", "-f", help="font", caption="Шрифт")
+        self.add_argument(
+            cmdhandouts_run,
+            "--font_size",
+            type=int,
+            default=14,
+            help="font size",
+            caption="Размер шрифта",
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--pdfsettings",
+            choices=["screen", "ebook", "printer", "prepress", "default"],
+            default="default",
+            advanced=True,
+            caption="Настройки pdfsettings для ghostscript",
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--paperwidth",
+            type=float,
+            default=210,
+            help="paper width",
+            caption="Ширина бумаги",
+            advanced=True,
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--paperheight",
+            type=float,
+            default=297,
+            help="paper height",
+            caption="Высота бумаги",
+            advanced=True,
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--margin_top",
+            type=float,
+            default=5,
+            help="top margin",
+            caption="Верхний отступ",
+            advanced=True,
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--margin_bottom",
+            type=float,
+            default=5,
+            help="bottom margin",
+            caption="Нижний отступ",
+            advanced=True,
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--margin_left",
+            type=float,
+            default=5,
+            help="left margin",
+            caption="Левый отступ",
+            advanced=True,
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--margin_right",
+            type=float,
+            default=5,
+            help="right margin",
+            caption="Правый отступ",
+            advanced=True,
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--boxwidth",
+            type=float,
+            help="box width",
+            caption="Ширина блока",
+            advanced=True,
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--boxwidthinner",
+            type=float,
+            help="box width inner",
+            caption="Внутренняя ширина блока",
+            advanced=True,
+        )
+        self.add_argument(
+            cmdhandouts_run,
+            "--tikz_mm",
+            type=float,
+            default=2,
+            help="tikz_mm width",
+            caption="Ширина tikz_mm",
+            advanced=True,
+        )
+
+        cmdhandouts_generate = self.add_parser(cmdhandouts_subcommands, "generate")
+        self.add_argument(
+            cmdhandouts_generate,
+            "filename",
+            help="file with questions packet",
+            caption="Имя файла с пакетом",
+            filetypes=[("chgksuite files", "*.4s")],
+        )
+        self.add_argument(
+            cmdhandouts_generate,
+            "--lang",
+            default="ru",
+            help="language",
+            caption="Язык",
+            argtype="radiobutton",
+            choices=sorted(GREYTEXT_LANGS.keys()),
+            advanced=True,
+        )
+        self.add_argument(
+            cmdhandouts_generate,
+            "--separate",
+            action="store_true",
+            help="Generate separate handouts for each question",
+            caption="Сгенерировать отдельный файл с раздатками для каждого вопроса",
+        )
+        self.add_argument(
+            cmdhandouts_generate,
+            "--list-handouts",
+            "-l",
+            action="store_true",
+            help="Generate a file with a list of handouts",
+            caption="Сгенерировать файл со списком раздаток",
+        )
+
+        cmdhandouts_pack = self.add_parser(cmdhandouts_subcommands, "pack")
+        self.add_argument(
+            cmdhandouts_pack,
+            "folder",
+            help="input directory",
+            caption="Папка с раздатками",
+        )
+        self.add_argument(
+            cmdhandouts_pack,
+            "--output_filename_prefix",
+            "-o",
+            default="packed_handouts",
+            help="output filename prefix",
+            caption="Префикс имени выходного файла",
+        )
+        self.add_argument(
+            cmdhandouts_pack,
+            "--n_teams",
+            "-n",
+            type=int,
+            required=True,
+            help="number of teams",
+            caption="Количество команд",
+        )
+        self.add_argument(
+            cmdhandouts_pack,
+            "--font",
+            "-f",
+            help="font",
+            caption="Шрифт",
+        )
+
+        cmdhandouts_install = self.add_parser(cmdhandouts_subcommands, "install")
+        self.add_argument(
+            cmdhandouts_install,
+            "--tectonic_package_regex",
+            advanced=True,
+            caption="Переопределить имя файла с релизом tectonic",
+        )
+
 
 def single_action(args, use_wrapper, resourcedir):
     if use_wrapper:
@@ -860,6 +1061,8 @@ def single_action(args, use_wrapper, resourcedir):
         gui_compose(args)
     if args.action == "trello":
         gui_trello(args)
+    if args.action == "handouts":
+        gui_handouter(args)
 
 
 def app():

{chgksuite-0.26.0b2 → chgksuite-0.26.0b4}/chgksuite/composer/telegram.py

@@ -852,7 +852,7 @@ class TelegramExporter(BaseExporter):
 
                 # Wait for a forwarded message with channel information
                 channel_id = self.wait_for_forwarded_message(
-                    entity_type="channel", check_type=True, string_id=channel_result
+                    entity_type="channel", check_type=True
                 )
                 if channel_id:
                     self.save_username(channel_result, channel_id)
@@ -875,7 +875,7 @@ class TelegramExporter(BaseExporter):
 
                 # Wait for a forwarded message with chat information
                 chat_id = self.wait_for_forwarded_message(
-                    entity_type="chat", check_type=False, string_id=chat_result
+                    entity_type="chat", check_type=False
                 )
                 if not chat_id:
                     self.logger.error("Failed to get chat ID from forwarded message")
@@ -891,7 +891,6 @@ class TelegramExporter(BaseExporter):
                         entity_type="chat",
                         check_type=False,
                         add_msg=error_msg,
-                        string_id=chat_result,
                     )
                 if chat_id:
                     self.save_username(chat_result, chat_id)
@@ -1117,11 +1116,15 @@ class TelegramExporter(BaseExporter):
 
             # Look for a forwarded message in recent messages
             cursor = self.db_conn.cursor()
+            if self.created_at:
+                threshold = "'" + self.created_at + "'"
+            else:
+                threshold = "datetime('now', '-2 minutes')"
             cursor.execute(
-                """
+                f"""
                 SELECT raw_data, created_at
                 FROM messages 
-                WHERE created_at > datetime('now', '-2 minutes')
+                WHERE created_at > {threshold}
                 ORDER BY created_at DESC
             """
             )

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