chgksuite 0.27.0__tar.gz → 0.27.0b3__tar.gz

{chgksuite-0.27.0 → chgksuite-0.27.0b3}/PKG-INFO

@@ -1,21 +1,23 @@
 Metadata-Version: 2.4
 Name: chgksuite
-Version: 0.27.0
+Version: 0.27.0b3
 Summary: A package for chgk automation
-Project-URL: Homepage, https://gitlab.com/peczony/chgksuite
 Author-email: Alexander Pecheny <ap@pecheny.me>
 License-Expression: MIT
-License-File: LICENSE
-Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://gitlab.com/peczony/chgksuite
 Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: beautifulsoup4
 Requires-Dist: chardet
+Requires-Dist: dashtable
 Requires-Dist: dateparser
 Requires-Dist: mammoth
 Requires-Dist: openpyxl
 Requires-Dist: parse
-Requires-Dist: pillow
+Requires-Dist: Pillow
 Requires-Dist: ply
 Requires-Dist: pypandoc
 Requires-Dist: pypdf
@@ -27,7 +29,7 @@ Requires-Dist: requests
 Requires-Dist: toml
 Requires-Dist: urllib3>=2.6.2
 Requires-Dist: watchdog
-Description-Content-Type: text/markdown
+Dynamic: license-file
 
 **chgksuite** is an utility that helps chgk editors.
 

{chgksuite-0.27.0 → chgksuite-0.27.0b3}/chgksuite/cli.py

@@ -596,15 +596,6 @@ class ArgparseBuilder:
             caption="Имя 4s-файла",
             filetypes=[("chgksuite markup files", "*.4s")],
         )
-        cmdcompose_markdown = cmdcompose_filetype.add_parser("markdown")
-        self.add_argument(
-            cmdcompose_markdown,
-            "filename",
-            nargs="*",
-            help="file(s) to compose from.",
-            caption="Имя 4s-файла",
-            filetypes=[("chgksuite markup files", "*.4s")],
-        )
         cmdcompose_pptx = cmdcompose_filetype.add_parser("pptx")
         self.add_argument(
             cmdcompose_pptx,

{chgksuite-0.27.0 → chgksuite-0.27.0b3}/chgksuite/common.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 import argparse
+import codecs
 import csv
 import itertools
 import json
@@ -113,7 +114,7 @@ class DefaultArgs:
 def set_lastdir(path):
     chgksuite_dir = get_chgksuite_dir()
     lastdir = os.path.join(chgksuite_dir, "lastdir")
-    with open(lastdir, "w", encoding="utf-8") as f:
+    with codecs.open(lastdir, "w", "utf8") as f:
         f.write(path)
 
 
@@ -121,7 +122,7 @@ def get_lastdir():
     chgksuite_dir = get_chgksuite_dir()
     lastdir = os.path.join(chgksuite_dir, "lastdir")
     if os.path.isfile(lastdir):
-        with open(lastdir, "r", encoding="utf-8") as f:
+        with codecs.open(lastdir, "r", "utf8") as f:
             return f.read().rstrip()
     return "."
 

{chgksuite-0.27.0 → chgksuite-0.27.0b3}/chgksuite/composer/__init__.py

@@ -1,5 +1,6 @@
 #!usr/bin/env python
 # -*- coding: utf-8 -*-
+import codecs
 import json
 import os
 import shutil
@@ -21,7 +22,7 @@ from chgksuite.composer.docx import DocxExporter
 from chgksuite.composer.latex import LatexExporter
 from chgksuite.composer.lj import LjExporter
 from chgksuite.composer.pptx import PptxExporter
-from chgksuite.composer.markdown import MarkdownExporter
+from chgksuite.composer.reddit import RedditExporter
 from chgksuite.composer.stats import StatsAdder
 from chgksuite.composer.telegram import TelegramExporter
 from chgksuite.composer.openquiz import OpenquizExporter
@@ -74,13 +75,10 @@ def process_file_wrapper(filename, sourcedir, targetdir, args):
 
 def parse_filepath(filepath, args=None):
     args = args or DefaultArgs()
-    with open(filepath, "r", encoding="utf-8") as input_file:
+    with codecs.open(filepath, "r", "utf8") as input_file:
         input_text = input_file.read()
     input_text = input_text.replace("\r", "")
-    debug_dir = os.path.dirname(os.path.abspath(filepath))
-    return parse_4s(
-        input_text, randomize=args.randomize, debug=args.debug, debug_dir=debug_dir
-    )
+    return parse_4s(input_text, randomize=args.randomize, debug=args.debug)
 
 
 def make_merged_filename(filelist):
@@ -107,7 +105,7 @@ def process_file(filename, tmp_dir, targetdir, args=None, logger=None):
             targetdir,
             make_filename(os.path.basename(filename), "dbg", args),
         )
-        with open(debug_fn, "w", encoding="utf-8") as output_file:
+        with codecs.open(debug_fn, "w", "utf8") as output_file:
             output_file.write(json.dumps(structure, indent=2, ensure_ascii=False))
 
     if not args.filetype:
@@ -148,8 +146,8 @@ def process_file(filename, tmp_dir, targetdir, args=None, logger=None):
         outfilename = os.path.join(targetdir, make_filename(filename, "txt", args))
         exporter.export(outfilename)
 
-    if args.filetype in ("redditmd", "markdown"):
-        exporter = MarkdownExporter(structure, args, dir_kwargs)
+    if args.filetype == "redditmd":
+        exporter = RedditExporter(structure, args, dir_kwargs)
         outfilename = os.path.join(targetdir, make_filename(filename, "md", args))
         exporter.export(outfilename)
 

{chgksuite-0.27.0 → chgksuite-0.27.0b3}/chgksuite/composer/chgksuite_parser.py

@@ -1,15 +1,9 @@
-import os
+import codecs
 import random
 import re
 from collections import defaultdict
 
-from chgksuite.common import (
-    QUESTION_LABELS,
-    check_question,
-    get_chgksuite_dir,
-    init_logger,
-    log_wrap,
-)
+from chgksuite.common import QUESTION_LABELS, check_question, init_logger, log_wrap
 from chgksuite.typotools import remove_excessive_whitespace as rew
 
 REQUIRED_LABELS = set(["question", "answer"])
@@ -95,7 +89,7 @@ def replace_counters(string_):
     return string_
 
 
-def parse_4s(s, randomize=False, debug=False, logger=None, debug_dir=None):
+def parse_4s(s, randomize=False, debug=False, logger=None):
     logger = logger or init_logger("composer")
     mapping = {
         "#": "meta",
@@ -121,11 +115,8 @@ def parse_4s(s, randomize=False, debug=False, logger=None, debug_dir=None):
     if s[0] == "\ufeff" and len(s) > 1:
         s = s[1:]
 
-    if debug:
-        debug_dir = debug_dir or get_chgksuite_dir()
-        debug_path = os.path.join(debug_dir, "raw.debug")
-        with open(debug_path, "w", encoding="utf-8") as debugf:
-            debugf.write(log_wrap(s.split("\n")))
+    with codecs.open("raw.debug", "w", "utf8") as debugf:
+        debugf.write(log_wrap(s.split("\n")))
 
     s = replace_counters(s)
 
@@ -146,7 +137,7 @@ def parse_4s(s, randomize=False, debug=False, logger=None, debug_dir=None):
     counter = 1
 
     if debug:
-        with open("debug1st.debug", "w", encoding="utf-8") as debugf:
+        with codecs.open("debug1st.debug", "w", "utf8") as debugf:
             debugf.write(log_wrap(structure))
 
     for element in structure:
@@ -239,7 +230,7 @@ def parse_4s(s, randomize=False, debug=False, logger=None, debug_dir=None):
                 i += 1
 
     if debug:
-        with open("debug.debug", "w", encoding="utf-8") as debugf:
+        with codecs.open("debug.debug", "w", "utf8") as debugf:
             debugf.write(log_wrap(final_structure))
 
     for element in final_structure:

{chgksuite-0.27.0 → chgksuite-0.27.0b3}/chgksuite/composer/db.py

@@ -1,3 +1,4 @@
+import codecs
 import datetime
 import os
 import re
@@ -210,7 +211,7 @@ class DbExporter(BaseExporter):
             if res:
                 result.append(res)
         text = "".join(result)
-        with open(outfilename, "w", encoding="utf-8") as f:
+        with codecs.open(outfilename, "w", "utf8") as f:
             f.write(text)
         self.logger.info("Output: {}".format(outfilename))
         if self.args.clipboard:

{chgksuite-0.27.0 → chgksuite-0.27.0b3}/chgksuite/composer/docx.py

@@ -102,7 +102,7 @@ def remove_square_brackets_standalone(s, regexes):
     s = s.replace("\\[", "LEFTSQUAREBRACKET")
     s = s.replace("\\]", "RIGHTSQUAREBRACKET")
     # Use placeholder to preserve handout brackets during removal
-    s = re.sub(f"\\[({hs}.+?)\\]", "{HANDOUT_PLACEHOLDER\\1}", s, flags=re.DOTALL)
+    s = re.sub(f"\\[{hs}(.+?)\\]", "{HANDOUT_PLACEHOLDER\\1}", s, flags=re.DOTALL)
     i = 0
     while "[" in s and "]" in s and i < 10:
         s = re.sub(" *\\[.+?\\]", "", s, flags=re.DOTALL)

{chgksuite-0.27.0 → chgksuite-0.27.0b3}/chgksuite/composer/latex.py

@@ -1,3 +1,4 @@
+import codecs
 import hashlib
 import os
 import re
@@ -220,7 +221,7 @@ class LatexExporter(BaseExporter):
 
         tex += "\\end{document}"
 
-        with open(outfilename, "w", encoding="utf-8") as outfile:
+        with codecs.open(outfilename, "w", "utf8") as outfile:
             outfile.write(tex)
         cwd = os.getcwd()
         os.chdir(self.dir_kwargs["tmp_dir"])

{chgksuite-0.27.0 → chgksuite-0.27.0b3}/chgksuite/composer/lj.py

@@ -1,3 +1,4 @@
+import codecs
 import datetime
 import os
 import random
@@ -239,7 +240,7 @@ class LjExporter(BaseExporter):
                 "general_impressions_text"
             ]
         if self.args.debug:
-            with open("lj.debug", "w", encoding="utf-8") as f:
+            with codecs.open("lj.debug", "w", "utf8") as f:
                 f.write(log_wrap(final_structure))
         return final_structure
 

{chgksuite-0.27.0 → chgksuite-0.27.0b3}/chgksuite/composer/openquiz.py

@@ -1,3 +1,4 @@
+import codecs
 import copy
 import re
 import json
@@ -174,5 +175,5 @@ class OpenquizExporter(BaseExporter):
         result = []
         for q in questions:
             result.append(self.oq_format_question(q))
-        with open(outfilename, "w", encoding="utf-8") as f:
+        with codecs.open(outfilename, "w", "utf8") as f:
             f.write(json.dumps(result, indent=2, ensure_ascii=False))

chgksuite-0.27.0/chgksuite/composer/markdown.py → chgksuite-0.27.0b3/chgksuite/composer/reddit.py

@@ -1,3 +1,4 @@
+import codecs
 import os
 
 from chgksuite.composer.composer_common import (
@@ -8,20 +9,20 @@ from chgksuite.composer.composer_common import (
 )
 
 
-class MarkdownExporter(BaseExporter):
+class RedditExporter(BaseExporter):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.im = Imgur(self.args.imgur_client_id or IMGUR_CLIENT_ID)
         self.qcount = 1
 
-    def markdownyapper(self, e):
+    def reddityapper(self, e):
         if isinstance(e, str):
-            return self.markdown_element_layout(e)
+            return self.reddit_element_layout(e)
         elif isinstance(e, list):
             if not any(isinstance(x, list) for x in e):
-                return self.markdown_element_layout(e)
+                return self.reddit_element_layout(e)
             else:
-                return "  \n".join([self.markdown_element_layout(x) for x in e])
+                return "  \n".join([self.reddit_element_layout(x) for x in e])
 
     def parse_and_upload_image(self, path):
         parsed_image = parseimg(
@@ -36,13 +37,11 @@ class MarkdownExporter(BaseExporter):
             imglink = uploaded_image["data"]["link"]
             return imglink
 
-    def markdownformat(self, s):
+    def redditformat(self, s):
         res = ""
         for run in self.parse_4s_elem(s):
-            if run[0] == "":
+            if run[0] in ("", "hyperlink"):
                 res += run[1]
-            if run[0] == "hyperlink":
-                res += "<{}>".format(run[1])
             if run[0] == "screen":
                 res += run[1]["for_screen"]
             if run[0] == "italic":
@@ -52,70 +51,61 @@ class MarkdownExporter(BaseExporter):
                     imglink = run[1]
                 else:
                     imglink = self.parse_and_upload_image(run[1])
-                if self.args.filetype == "redditmd":
-                    res += "[картинка]({})".format(imglink)
-                else:
-                    res += "![]({})".format(imglink)
+                res += "[картинка]({})".format(imglink)
         while res.endswith("\n"):
             res = res[:-1]
         res = res.replace("\n", "  \n")
         return res
 
-    def markdown_element_layout(self, e):
+    def reddit_element_layout(self, e):
         res = ""
         if isinstance(e, str):
-            res = self.markdownformat(e)
+            res = self.redditformat(e)
             return res
         if isinstance(e, list):
             res = "  \n".join(
                 [
-                    "{}\\. {}".format(i + 1, self.markdown_element_layout(x))
+                    "{}\\. {}".format(i + 1, self.reddit_element_layout(x))
                     for i, x in enumerate(e)
                 ]
             )
         return res
 
-    def markdown_format_element(self, pair):
+    def reddit_format_element(self, pair):
         if pair[0] == "Question":
-            return self.markdown_format_question(pair[1])
+            return self.reddit_format_question(pair[1])
 
-    def markdown_format_question(self, q):
+    def reddit_format_question(self, q):
         if "setcounter" in q:
             self.qcount = int(q["setcounter"])
         res = "__Вопрос {}__: {}  \n".format(
             self.qcount if "number" not in q else q["number"],
-            self.markdownyapper(q["question"]),
+            self.reddityapper(q["question"]),
         )
         if "number" not in q:
             self.qcount += 1
-        spoiler_start = ">!" if self.args.filetype == "redditmd" else ""
-        spoiler_end = "!<" if self.args.filetype == "redditmd" else ""
-        res += "__Ответ:__ {}{}  \n".format(
-            spoiler_start, self.markdownyapper(q["answer"])
-        )
+        res += "__Ответ:__ >!{}  \n".format(self.reddityapper(q["answer"]))
         if "zachet" in q:
-            res += "__Зачёт:__ {}  \n".format(self.markdownyapper(q["zachet"]))
+            res += "__Зачёт:__ {}  \n".format(self.reddityapper(q["zachet"]))
         if "nezachet" in q:
-            res += "__Незачёт:__ {}  \n".format(self.markdownyapper(q["nezachet"]))
+            res += "__Незачёт:__ {}  \n".format(self.reddityapper(q["nezachet"]))
         if "comment" in q:
-            res += "__Комментарий:__ {}  \n".format(self.markdownyapper(q["comment"]))
+            res += "__Комментарий:__ {}  \n".format(self.reddityapper(q["comment"]))
         if "source" in q:
-            res += "__Источник:__ {}  \n".format(self.markdownyapper(q["source"]))
+            res += "__Источник:__ {}  \n".format(self.reddityapper(q["source"]))
         if "author" in q:
-            res += "{}\n__Автор:__ {}  \n".format(
-                spoiler_end, self.markdownyapper(q["author"])
-            )
+            res += "!<\n__Автор:__ {}  \n".format(self.reddityapper(q["author"]))
         else:
-            res += spoiler_end + "\n"
+            res += "!<\n"
         return res
 
     def export(self, outfile):
         result = []
         for pair in self.structure:
-            res = self.markdown_format_element(pair)
+            res = self.reddit_format_element(pair)
             if res:
                 result.append(res)
         text = "\n\n".join(result)
-        with open(outfile, "w", encoding="utf-8") as f:
+        with codecs.open(outfile, "w", "utf8") as f:
             f.write(text)
         self.logger.info("Output: {}".format(outfile))

chgksuite-0.27.0b3/chgksuite/handouter/runner.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import os
+import shutil
+import subprocess
+import time
+
+import toml
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+from chgksuite.common import get_source_dirs
+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,
+    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
+        _, resourcedir = get_source_dirs()
+        self.labels = toml.loads(
+            read_file(os.path.join(resourcedir, f"labels_{args.language}.toml"))
+        )
+        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):
+        handout_text = self.labels["general"]["handout_for_question"].format(
+            question_num
+        )
+        return GREYTEXT.replace("<GREYTEXT>", handout_text)
+
+    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.language}.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-0.27.0 → chgksuite-0.27.0b3}/chgksuite/handouter/tex_internals.py

@@ -13,7 +13,7 @@ HEADER = r"""
 \begin{document}
 \fontsize{14pt}{16pt}\selectfont
 \setlength\parindent{0pt}
-\tikzstyle{box}=[rectangle, inner sep=<TIKZ_MM>mm]
+\tikzstyle{box}=[draw, dashed, rectangle, inner sep=<TIKZ_MM>mm]
 \raggedright
 \raggedbottom
 """.strip()
@@ -25,20 +25,10 @@ TIKZBOX_START = r"""{<CENTERING>
 
 TIKZBOX_INNER = r"""
 \begin{tikzpicture}
-\node[box, minimum width=\boxwidth<TEXTWIDTH><ALIGN>] (b) {<FONTSIZE><CONTENTS>\par};
-\useasboundingbox (b.south west) rectangle (b.north east);
-\draw[<TOP>] ([xshift=<TOP_EXT_L>]b.north west) -- ([xshift=<TOP_EXT_R>]b.north east);
-\draw[<BOTTOM>] ([xshift=<BOTTOM_EXT_L>]b.south west) -- ([xshift=<BOTTOM_EXT_R>]b.south east);
-\draw[<LEFT>] ([yshift=<LEFT_EXT_T>]b.north west) -- ([yshift=<LEFT_EXT_B>]b.south west);
-\draw[<RIGHT>] ([yshift=<RIGHT_EXT_T>]b.north east) -- ([yshift=<RIGHT_EXT_B>]b.south east);
+\node[box, minimum width=\boxwidth<TEXTWIDTH><ALIGN>] {<FONTSIZE><CONTENTS>\par};
 \end{tikzpicture}
 """.strip()
 
-# Line styles for box edges
-EDGE_SOLID = "line width=0.8pt"
-EDGE_DASHED = "dashed"
-EDGE_NONE = "draw=none"  # Don't draw this edge (to avoid double dashed lines)
-
 TIKZBOX_END = "\n}"
 
 IMG = r"""\includegraphics<IMGWIDTH>{<IMGPATH>}"""