chgksuite 0.26.1__py3-none-any.whl → 0.27.0__py3-none-any.whl

chgksuite/composer/{reddit.py → markdown.py}

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

chgksuite/composer/openquiz.py

@@ -1,4 +1,3 @@
-import codecs
 import copy
 import re
 import json
@@ -71,7 +70,7 @@ class OpenquizExporter(BaseExporter):
                 )
         while res.endswith("\n"):
             res = res[:-1]
-        hs = self.labels["question_labels"]["handout_short"]
+        hs = self.regexes["handout_short"]
         if images:
             res = re.sub("\\[" + hs + "(.+?)\\]", "", s, flags=re.DOTALL)
             res = res.strip()
@@ -175,5 +174,5 @@ class OpenquizExporter(BaseExporter):
         result = []
         for q in questions:
             result.append(self.oq_format_question(q))
-        with codecs.open(outfilename, "w", "utf8") as f:
+        with open(outfilename, "w", encoding="utf-8") as f:
             f.write(json.dumps(result, indent=2, ensure_ascii=False))

chgksuite/composer/pptx.py

@@ -121,13 +121,13 @@ class PptxExporter(BaseExporter):
         replace_spaces=True,
         do_not_remove_accents=False,
     ):
-        hs = self.labels["question_labels"]["handout_short"]
+        hs = self.regexes["handout_short"]
         if isinstance(s, list):
             for i in range(len(s)):
                 s[i] = self.pptx_process_text(s[i], image=image)
             return s
         if not (self.args.do_not_remove_accents or do_not_remove_accents):
-            s = remove_accents_standalone(s, self.labels)
+            s = remove_accents_standalone(s, self.regexes)
         if strip_brackets:
             s = self.remove_square_brackets(s)
             s = s.replace("]\n", "]\n\n")

chgksuite/composer/telegram.py

@@ -6,6 +6,7 @@ import sqlite3
 import tempfile
 import time
 import uuid
+from typing import Optional, Union
 
 import requests
 import toml
@@ -247,7 +248,7 @@ class TelegramExporter(BaseExporter):
                 channel_id_str = channel_id_str[4:]
             return f"https://t.me/c/{channel_id_str}/{message_id}"
 
-    def extract_id_from_link(self, link) -> int | str | None:
+    def extract_id_from_link(self, link) -> Optional[Union[int, str]]:
         """
         Extract channel or chat ID from a Telegram link.
         Examples:

chgksuite/handouter/gen.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 import itertools
+import json
 import os
 import re
 from collections import defaultdict
@@ -53,13 +54,16 @@ def generate_handouts_list(handouts, output_dir, base_name, parsed):
 
 def generate_handouts(args):
     _, resourcedir = get_source_dirs()
-    labels = toml.loads(
-        read_file(os.path.join(resourcedir, f"labels_{args.lang}.toml"))
+    toml.loads(read_file(os.path.join(resourcedir, f"labels_{args.language}.toml")))
+    with open(
+        os.path.join(resourcedir, f"regexes_{args.language}.json"), encoding="utf8"
+    ) as f:
+        regexes = json.load(f)
+    handout_re_text = (
+        "\\[" + regexes["handout_short"] + ".+?:( |\n)(?P<handout_text>.+?)\\]"
     )
     handout_re = re.compile(
-        "\\["
-        + labels["question_labels"]["handout_short"]
-        + ".+?:( |\n)(?P<handout_text>.+?)\\]",
+        handout_re_text,
         flags=re.DOTALL,
     )
 
@@ -82,9 +86,9 @@ def generate_handouts(args):
             if img:
                 try:
                     parsed_img = parseimg(img[0][1])
-                except:
+                except Exception as e:
                     print(
-                        f"Image file for question {q['number']} not found, add it by hand"
+                        f"Image file for question {q['number']} not found, add it by hand (exception {type(e)} {e})"
                     )
                     continue
             else:

chgksuite/handouter/runner.py

@@ -5,15 +5,19 @@ 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 (
+    EDGE_DASHED,
+    EDGE_NONE,
+    EDGE_SOLID,
     GREYTEXT,
-    GREYTEXT_LANGS,
     HEADER,
     IMG,
     IMGWIDTH,
@@ -29,6 +33,10 @@ class HandoutGenerator:
 
     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):
@@ -51,11 +59,33 @@ class HandoutGenerator:
         return parse_handouts(contents)
 
     def generate_for_question(self, question_num):
-        return GREYTEXT.replace(
-            "<GREYTEXT>", GREYTEXT_LANGS[self.args.lang].format(question_num)
+        handout_text = self.labels["general"]["handout_for_question"].format(
+            question_num
         )
+        return GREYTEXT.replace("<GREYTEXT>", handout_text)
+
+    def make_tikzbox(self, block, edges=None, ext=None):
+        """
+        Create a TikZ box with configurable edge styles and extensions.
+        edges is a dict with keys 'top', 'bottom', 'left', 'right'
+        values are EDGE_DASHED or EDGE_SOLID
+        ext is a dict with edge extensions to close gaps at boundaries
+        """
+        if edges is None:
+            edges = {
+                "top": EDGE_DASHED,
+                "bottom": EDGE_DASHED,
+                "left": EDGE_DASHED,
+                "right": EDGE_DASHED,
+            }
+        if ext is None:
+            ext = {
+                "top": ("0pt", "0pt"),
+                "bottom": ("0pt", "0pt"),
+                "left": ("0pt", "0pt"),
+                "right": ("0pt", "0pt"),
+            }
 
-    def make_tikzbox(self, block):
         if block.get("no_center"):
             align = ""
         else:
@@ -73,19 +103,206 @@ class HandoutGenerator:
             .replace("<ALIGN>", align)
             .replace("<TEXTWIDTH>", textwidth)
             .replace("<FONTSIZE>", fontsize)
+            .replace("<TOP>", edges["top"])
+            .replace("<BOTTOM>", edges["bottom"])
+            .replace("<LEFT>", edges["left"])
+            .replace("<RIGHT>", edges["right"])
+            .replace("<TOP_EXT_L>", ext["top"][0])
+            .replace("<TOP_EXT_R>", ext["top"][1])
+            .replace("<BOTTOM_EXT_L>", ext["bottom"][0])
+            .replace("<BOTTOM_EXT_R>", ext["bottom"][1])
+            .replace("<LEFT_EXT_T>", ext["left"][0])
+            .replace("<LEFT_EXT_B>", ext["left"][1])
+            .replace("<RIGHT_EXT_T>", ext["right"][0])
+            .replace("<RIGHT_EXT_B>", ext["right"][1])
         )
 
     def get_page_width(self):
         return self.args.paperwidth - self.args.margin_left - self.args.margin_right - 2
 
+    def get_cut_direction(self, columns, num_rows, handouts_per_team):
+        """
+        Determine whether to cut vertically or horizontally.
+        Returns (direction, team_size) where:
+        - direction is 'vertical', 'horizontal', or None
+        - team_size is the number of columns (vertical) or rows (horizontal) per team
+
+        Falls back to None if handouts can't be evenly divided into teams.
+        """
+        total = columns * num_rows
+
+        # Check if total handouts can be evenly divided
+        if total % handouts_per_team != 0:
+            return None, None
+
+        num_teams = total // handouts_per_team
+        if num_teams < 2:
+            return None, None  # Only 1 team, no cuts needed
+
+        # Try vertical layout (teams as column groups)
+        # Each team gets team_cols columns × all rows
+        if handouts_per_team % num_rows == 0:
+            team_cols = handouts_per_team // num_rows
+            if columns % team_cols == 0:
+                return "vertical", team_cols
+
+        # Try horizontal layout (teams as row groups)
+        # Each team gets all columns × team_rows rows
+        if handouts_per_team % columns == 0:
+            team_rows = handouts_per_team // columns
+            if num_rows % team_rows == 0:
+                return "horizontal", team_rows
+
+        return None, None
+
+    def get_edge_styles(
+        self, row_idx, col_idx, num_rows, columns, cut_direction, team_size
+    ):
+        """
+        Determine edge styles and extensions for a box at position (row_idx, col_idx).
+        Outer edges of team rectangles are solid (thicker), inner edges are dashed.
+        Extensions are used to close gaps in ALL solid lines.
+        Duplicate dashed edges are skipped to avoid double lines.
+
+        team_size is the number of columns (vertical) or rows (horizontal) per team.
+        """
+        # Default: all dashed, no extension
+        edges = {
+            "top": EDGE_DASHED,
+            "bottom": EDGE_DASHED,
+            "left": EDGE_DASHED,
+            "right": EDGE_DASHED,
+        }
+        ext = {
+            "top": ("0pt", "0pt"),
+            "bottom": ("0pt", "0pt"),
+            "left": ("0pt", "0pt"),
+            "right": ("0pt", "0pt"),
+        }
+
+        # Gap sizes (half of spacing to extend into)
+        h_gap = "0.75mm"  # half of SPACE (1.5mm)
+        v_gap = "0.5mm"  # half of vspace (1mm)
+
+        # Helper functions to check if position is at a team boundary
+        def is_at_right_team_boundary():
+            """Is this box at the right edge of its team (but not at grid edge)?"""
+            if cut_direction != "vertical" or not team_size:
+                return False
+            return (col_idx + 1) % team_size == 0 and col_idx < columns - 1
+
+        def is_at_left_team_boundary():
+            """Is this box at the left edge of its team (but not at grid edge)?"""
+            if cut_direction != "vertical" or not team_size:
+                return False
+            return col_idx % team_size == 0 and col_idx > 0
+
+        def is_at_bottom_team_boundary():
+            """Is this box at the bottom edge of its team (but not at grid edge)?"""
+            if cut_direction != "horizontal" or not team_size:
+                return False
+            return (row_idx + 1) % team_size == 0 and row_idx < num_rows - 1
+
+        def is_at_top_team_boundary():
+            """Is this box at the top edge of its team (but not at grid edge)?"""
+            if cut_direction != "horizontal" or not team_size:
+                return False
+            return row_idx % team_size == 0 and row_idx > 0
+
+        # Determine which edges are solid
+        # Only apply solid edges if we have a valid cut direction
+        # Otherwise fall back to all-dashed (default)
+        if cut_direction is not None:
+            # Outer edges of the entire grid
+            if row_idx == 0:
+                edges["top"] = EDGE_SOLID
+            if row_idx == num_rows - 1:
+                edges["bottom"] = EDGE_SOLID
+            if col_idx == 0:
+                edges["left"] = EDGE_SOLID
+            if col_idx == columns - 1:
+                edges["right"] = EDGE_SOLID
+
+            # Team boundary edges
+            if is_at_right_team_boundary():
+                edges["right"] = EDGE_SOLID
+            if is_at_left_team_boundary():
+                edges["left"] = EDGE_SOLID
+            if is_at_bottom_team_boundary():
+                edges["bottom"] = EDGE_SOLID
+            if is_at_top_team_boundary():
+                edges["top"] = EDGE_SOLID
+
+        # Skip duplicate dashed edges (to avoid double lines between adjacent boxes)
+        if edges["left"] == EDGE_DASHED and col_idx > 0:
+            edges["left"] = EDGE_NONE
+
+        if edges["top"] == EDGE_DASHED and row_idx > 0:
+            edges["top"] = EDGE_NONE
+
+        # Calculate extensions for solid edges to close gaps
+        # But don't extend into team boundary gaps!
+
+        if edges["top"] == EDGE_SOLID:
+            at_left_boundary = is_at_left_team_boundary()
+            ext_left = "-" + h_gap if col_idx > 0 and not at_left_boundary else "0pt"
+            at_right_boundary = is_at_right_team_boundary()
+            ext_right = (
+                h_gap if col_idx < columns - 1 and not at_right_boundary else "0pt"
+            )
+            ext["top"] = (ext_left, ext_right)
+
+        if edges["bottom"] == EDGE_SOLID:
+            at_left_boundary = is_at_left_team_boundary()
+            ext_left = "-" + h_gap if col_idx > 0 and not at_left_boundary else "0pt"
+            at_right_boundary = is_at_right_team_boundary()
+            ext_right = (
+                h_gap if col_idx < columns - 1 and not at_right_boundary else "0pt"
+            )
+            ext["bottom"] = (ext_left, ext_right)
+
+        if edges["left"] == EDGE_SOLID:
+            at_top_boundary = is_at_top_team_boundary()
+            ext_top = v_gap if row_idx > 0 and not at_top_boundary else "0pt"
+            at_bottom_boundary = is_at_bottom_team_boundary()
+            ext_bottom = (
+                "-" + v_gap
+                if row_idx < num_rows - 1 and not at_bottom_boundary
+                else "0pt"
+            )
+            ext["left"] = (ext_top, ext_bottom)
+
+        if edges["right"] == EDGE_SOLID:
+            at_top_boundary = is_at_top_team_boundary()
+            ext_top = v_gap if row_idx > 0 and not at_top_boundary else "0pt"
+            at_bottom_boundary = is_at_bottom_team_boundary()
+            ext_bottom = (
+                "-" + v_gap
+                if row_idx < num_rows - 1 and not at_bottom_boundary
+                else "0pt"
+            )
+            ext["right"] = (ext_top, ext_bottom)
+
+        return edges, ext
+
     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
+        num_rows = block.get("rows") or 1
+        handouts_per_team = block.get("handouts_per_team") or 3
+
+        # Determine cut direction
+        cut_direction, cut_after = self.get_cut_direction(
+            columns, num_rows, handouts_per_team
+        )
+        if self.args.debug:
+            print(f"cut_direction: {cut_direction}, cut_after: {cut_after}")
+
+        spaces = columns - 1
         boxwidth = self.args.boxwidth or round(
-            (self.get_page_width() - spaces * self.SPACE) / block["columns"],
+            (self.get_page_width() - spaces * self.SPACE) / columns,
             3,
         )
         total_width = boxwidth * columns + spaces * self.SPACE
@@ -98,7 +315,6 @@ class HandoutGenerator:
             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
@@ -113,10 +329,18 @@ class HandoutGenerator:
             block["centering"] = ""
         else:
             block["centering"] = "\\centering"
-        for _ in range(block.get("rows") or 1):
+
+        rows = []
+        for row_idx in range(num_rows):
+            row_boxes = []
+            for col_idx in range(columns):
+                edges, ext = self.get_edge_styles(
+                    row_idx, col_idx, num_rows, columns, cut_direction, cut_after
+                )
+                row_boxes.append(self.make_tikzbox(block, edges, ext))
             row = (
                 TIKZBOX_START.replace("<CENTERING>", block["centering"])
-                + "\n".join([self.make_tikzbox(block)] * block["columns"])
+                + "\n".join(row_boxes)
                 + TIKZBOX_END
             )
             rows.append(row)
@@ -141,7 +365,7 @@ class HandoutGenerator:
 
 def process_file(args, file_dir, bn):
     tex_contents = HandoutGenerator(args).generate()
-    tex_path = os.path.join(file_dir, f"{bn}_{args.lang}.tex")
+    tex_path = os.path.join(file_dir, f"{bn}_{args.language}.tex")
     write_file(tex_path, tex_contents)
 
     tectonic_path = get_tectonic_path()

chgksuite/handouter/tex_internals.py

@@ -13,33 +13,32 @@ HEADER = r"""
 \begin{document}
 \fontsize{14pt}{16pt}\selectfont
 \setlength\parindent{0pt}
-\tikzstyle{box}=[draw, dashed, rectangle, inner sep=<TIKZ_MM>mm]
+\tikzstyle{box}=[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};
+\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);
 \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>}"""

chgksuite/lastdir

@@ -0,0 +1 @@
+/Users/pecheny/chgksuite1/tmpz_2mf3o8/tmptke0lqfv