chgksuite 0.26.0b11__py3-none-any.whl → 0.27.0__py3-none-any.whl

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)
@@ -124,6 +348,9 @@ class HandoutGenerator:
 
     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"):
@@ -138,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/handouter/utils.py

@@ -45,8 +45,29 @@ def wrap_val(key, val):
     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 = contents.split("\n---\n")
+    blocks = split_blocks(contents)
     result = []
     for block_ in blocks:
         block = block_.strip()

chgksuite/lastdir

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