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

chgksuite/composer/pptx.py

@@ -3,15 +3,16 @@ import os
 import re
 
 import toml
+
+from chgksuite.common import log_wrap, replace_escaped, tryint
+from chgksuite.composer.composer_common import BaseExporter, backtick_replace, parseimg
 from pptx import Presentation
 from pptx.dml.color import RGBColor
 from pptx.enum.text import MSO_AUTO_SIZE, MSO_VERTICAL_ANCHOR, PP_ALIGN
+from pptx.enum.lang import MSO_LANGUAGE_ID
 from pptx.util import Inches as PptxInches
 from pptx.util import Pt as PptxPt
 
-from chgksuite.common import log_wrap, replace_escaped, tryint
-from chgksuite.composer.composer_common import BaseExporter, backtick_replace, parseimg
-
 
 class PptxExporter(BaseExporter):
     def __init__(self, *args, **kwargs):
@@ -48,6 +49,17 @@ class PptxExporter(BaseExporter):
         textbox = slide.shapes.add_textbox(left, top, width, height)
         return textbox
 
+    def add_run(self, para, text, color=None):
+        r = para.add_run()
+        r.text = text
+        if color is None:
+            color = self.c["textbox"].get("color")
+        if color:
+            r.font.color.rgb = RGBColor(*color)
+        if self.args.language == "ru":
+            r.font.language_id = MSO_LANGUAGE_ID.RUSSIAN
+        return r
+
     def pptx_format(self, el, para, tf, slide, replace_spaces=True):
         def r_sp(text):
             if replace_spaces:
@@ -60,15 +72,13 @@ class PptxExporter(BaseExporter):
                 licount = 0
                 for li in el[1]:
                     licount += 1
-                    r = para.add_run()
-                    r.text = "\n{}. ".format(licount)
+                    self.add_run(para, "\n{}. ".format(licount))
                     self.pptx_format(li, para, tf, slide)
             else:
                 licount = 0
                 for li in el:
                     licount += 1
-                    r = para.add_run()
-                    r.text = "\n{}. ".format(licount)
+                    self.add_run(para, "\n{}. ".format(licount))
                     self.pptx_format(li, para, tf, slide)
 
         if isinstance(el, str):
@@ -77,23 +87,20 @@ class PptxExporter(BaseExporter):
 
             for run in self.parse_4s_elem(el):
                 if run[0] == "screen":
-                    r = para.add_run()
-                    r.text = r_sp(run[1]["for_screen"])
+                    self.add_run(para, r_sp(run[1]["for_screen"]))
 
                 elif run[0] == "linebreak":
-                    r = para.add_run("\n")
+                    self.add_run(para, "\n")
 
                 elif run[0] == "strike":
-                    r = para.add_run()
-                    r.text = r_sp(run[1])
+                    r = self.add_run(para, r_sp(run[1]))
                     r.font.strike = True  # TODO: doesn't work as of 2023-12-24, cf. https://github.com/scanny/python-pptx/issues/339
 
                 elif run[0] == "img":
                     pass  # image processing is moved to other places
 
                 else:
-                    r = para.add_run()
-                    r.text = r_sp(run[1])
+                    r = self.add_run(para, r_sp(run[1]))
                     if "italic" in run[0]:
                         r.font.italic = True
                     if "bold" in run[0]:
@@ -166,25 +173,28 @@ class PptxExporter(BaseExporter):
                     txt = txt.upper()
                 self.set_question_number(slide, number=txt)
             else:
-                r = p.add_run()
-                r.text = self._replace_no_break(self.pptx_process_text(section[0][1]))
+                r = self.add_run(
+                    p, self._replace_no_break(self.pptx_process_text(section[0][1]))
+                )
                 r.font.size = PptxPt(self.c["text_size_grid"]["section"])
                 add_line_break = True
         if editor:
-            r = p.add_run()
-            r.text = self._replace_no_break(
-                ("\n" if add_line_break else "")
-                + self.pptx_process_text(editor[0][1])
-                + "\n"
+            r = self.add_run(
+                p,
+                self._replace_no_break(
+                    ("\n\n" if add_line_break else "")
+                    + self.pptx_process_text(editor[0][1])
+                ),
             )
             add_line_break = True
         if meta:
             for element in meta:
-                r = p.add_run()
-                r.text = self._replace_no_break(
-                    ("\n" if add_line_break else "")
-                    + self.pptx_process_text(element[1])
-                    + "\n"
+                r = self.add_run(
+                    p,
+                    self._replace_no_break(
+                        ("\n\n" if add_line_break else "")
+                        + self.pptx_process_text(element[1])
+                    ),
                 )
                 add_line_break = True
 
@@ -211,8 +221,11 @@ class PptxExporter(BaseExporter):
             title = slide.shapes.title
             title.text = title_text[0][1]
             if date_text:
-                subtitle = slide.placeholders[1]
-                subtitle.text = date_text[0][1]
+                try:
+                    subtitle = slide.placeholders[1]
+                    subtitle.text = date_text[0][1]
+                except KeyError:
+                    pass
         for block in (editor_block, section_block):
             self._process_block(block)
 
@@ -223,11 +236,12 @@ class PptxExporter(BaseExporter):
         qtf = qntextbox.text_frame
         qtf_p = self.init_paragraph(qtf)
         if self.c["number_textbox"].get("align"):
-            qtf_p.alignment = getattr(PP_ALIGN, self.c["number_textbox"]["align"].upper())
-        qtf_r = qtf_p.add_run()
+            qtf_p.alignment = getattr(
+                PP_ALIGN, self.c["number_textbox"]["align"].upper()
+            )
         if self.c.get("question_number_format") == "caps" and tryint(number):
             number = f"ВОПРОС {number}"
-        qtf_r.text = number
+        qtf_r = self.add_run(qtf_p, number)
         if self.c["number_textbox"].get("bold"):
             qtf_r.font.bold = True
         if self.c["number_textbox"].get("color"):
@@ -278,6 +292,15 @@ class PptxExporter(BaseExporter):
             base_top = PptxInches(self.c["textbox"]["top"])
             base_width = PptxInches(self.c["textbox"]["width"])
             base_height = PptxInches(self.c["textbox"]["height"])
+            if self.c.get("disable_autolayout"):
+                slide.shapes.add_picture(
+                    image["imgfile"],
+                    left=base_left,
+                    top=base_top,
+                    width=img_base_width,
+                    height=img_base_height,
+                )
+                return self.get_textbox(slide), 1
             big_mode = (
                 image["big"] and not self.c.get("text_is_duplicated") and allowbigimage
             )
@@ -390,9 +413,13 @@ class PptxExporter(BaseExporter):
     def process_question_text(self, q):
         image = self._get_image_from_4s(q["question"])
         handout = self._get_handout_from_4s(q["question"])
-        if image:
+        add_handout_on_separate_slide = self.c.get("add_handout_on_separate_slide")
+        add_handout_on_separate_slide = (
+            add_handout_on_separate_slide is None or add_handout_on_separate_slide
+        )
+        if image and add_handout_on_separate_slide:
             self.add_slide_with_image(image, number=self.number)
-        elif handout:
+        elif handout and add_handout_on_separate_slide:
             self.add_slide_with_handout(handout, number=self.number)
         slide = self.prs.slides.add_slide(self.BLANK_SLIDE)
         text_is_duplicated = bool(self.c.get("text_is_duplicated"))
@@ -411,9 +438,11 @@ class PptxExporter(BaseExporter):
         fields = ["answer"]
         if q.get("zachet") and self.c.get("add_zachet"):
             fields.append("zachet")
+        if q.get("nezachet") and self.c.get("add_zachet"):
+            fields.append("nezachet")
         if self.c["add_comment"] and "comment" in q:
             fields.append("comment")
-        if self.c["add_source"] and "source" in q:
+        if self.c.get("add_source") and "source" in q:
             fields.append("source")
         textbox = None
         coeff = 1
@@ -435,6 +464,10 @@ class PptxExporter(BaseExporter):
             text_for_size += "\n" + self.recursive_join(
                 self.pptx_process_text(q["zachet"], strip_brackets=False)
             )
+        if q.get("nezachet") and self.c.get("add_zachet"):
+            text_for_size += "\n" + self.recursive_join(
+                self.pptx_process_text(q["nezachet"], strip_brackets=False)
+            )
         if q.get("comment") and self.c.get("add_comment"):
             text_for_size += "\n" + self.recursive_join(
                 self.pptx_process_text(q["comment"])
@@ -451,34 +484,34 @@ class PptxExporter(BaseExporter):
             p = self.init_paragraph(tf, size=self.c["force_text_size_answer"])
         else:
             p = self.init_paragraph(tf, text=text_for_size, coeff=coeff)
-        r = p.add_run()
-        r.text = f"{self.get_label(q, 'answer')}: "
+        r = self.add_run(p, f"{self.get_label(q, 'answer')}: ")
         r.font.bold = True
         self.pptx_format(
             self.pptx_process_text(q["answer"], strip_brackets=False), p, tf, slide
         )
         if q.get("zachet") and self.c.get("add_zachet"):
             zachet_text = self.pptx_process_text(q["zachet"], strip_brackets=False)
-            r = p.add_run()
-            r.text = f"\n{self.get_label(q, 'zachet')}: "
+            r = self.add_run(p, f"\n{self.get_label(q, 'zachet')}: ")
             r.font.bold = True
             self.pptx_format(zachet_text, p, tf, slide)
+        if q.get("nezachet") and self.c.get("add_zachet"):
+            nezachet_text = self.pptx_process_text(q["nezachet"], strip_brackets=False)
+            r = self.add_run(p, f"\n{self.get_label(q, 'nezachet')}: ")
+            r.font.bold = True
+            self.pptx_format(nezachet_text, p, tf, slide)
         if self.c["add_comment"] and "comment" in q:
             comment_text = self.pptx_process_text(q["comment"])
-            r = p.add_run()
-            r.text = f"\n{self.get_label(q, 'comment')}: "
+            r = self.add_run(p, f"\n{self.get_label(q, 'comment')}: ")
             r.font.bold = True
             self.pptx_format(comment_text, p, tf, slide)
-        if self.c["add_source"] and "source" in q:
+        if self.c.get("add_source") and "source" in q:
             source_text = self.pptx_process_text(q["source"])
-            r = p.add_run()
-            r.text = f"\n{self.get_label(q, 'source')}: "
+            r = self.add_run(p, f"\n{self.get_label(q, 'source')}: ")
             r.font.bold = True
             self.pptx_format(source_text, p, tf, slide)
-        if self.c["add_author"] and "author" in q:
+        if self.c.get("add_author") and "author" in q:
             author_text = self.pptx_process_text(q["author"])
-            r = p.add_run()
-            r.text = f"\n{self.get_label(q, 'author')}: "
+            r = self.add_run(p, f"\n{self.get_label(q, 'author')}: ")
             r.font.bold = True
             self.pptx_format(author_text, p, tf, slide)
 
@@ -510,7 +543,7 @@ class PptxExporter(BaseExporter):
                 return element["size"]
         return self.c["text_size_grid"]["smallest"]
 
-    def init_paragraph(self, text_frame, text=None, coeff=1, size=None):
+    def init_paragraph(self, text_frame, text=None, coeff=1, size=None, color=None):
         p = text_frame.paragraphs[0]
         p.font.name = self.c["font"]["name"]
         if size:

chgksuite/composer/telegram.py

@@ -16,6 +16,11 @@ from chgksuite.composer.composer_common import BaseExporter, parseimg
 from chgksuite.composer.telegram_bot import run_bot_in_thread
 
 
+def get_text(msg_data):
+    if "message" in msg_data and "text" in msg_data["message"]:
+        return msg_data["message"]["text"]
+
+
 class TelegramExporter(BaseExporter):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -37,6 +42,7 @@ class TelegramExporter(BaseExporter):
         self.channel_id = None  # Target channel ID
         self.chat_id = None  # Discussion group ID linked to the channel
         self.auth_uuid = uuid.uuid4().hex[:8]
+        self.chat_auth_uuid = uuid.uuid4().hex[:8]
         self.init_telegram()
 
     def check_connectivity(self):
@@ -119,6 +125,9 @@ class TelegramExporter(BaseExporter):
 
             if result:
                 msg_data = json.loads(result["raw_data"])
+                if msg_data["message"]["chat"]["type"] != "private":
+                    print("You should post to the PRIVATE chat, not to the channel/group")
+                    continue
                 self.control_chat_id = msg_data["message"]["chat"]["id"]
                 self.send_api_request(
                     "sendMessage",
@@ -852,7 +861,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)
@@ -860,6 +869,7 @@ class TelegramExporter(BaseExporter):
                     raise Exception("Failed to get channel ID from forwarded message")
         else:
             raise Exception("Channel ID is undefined")
+        
         # Handle chat resolution
         if isinstance(chat_result, int):
             chat_id = chat_result
@@ -868,14 +878,15 @@ class TelegramExporter(BaseExporter):
             if not chat_id:
                 print("\n" + "=" * 50)
                 print(
-                    "Please forward any message from the discussion group to the bot."
+                    f"Please write a message in the discussion group with text: {self.chat_auth_uuid}"
                 )
                 print("This will allow me to extract the group ID automatically.")
+                print("The bot MUST be added do the group and made admin, else it won't work!")
                 print("=" * 50 + "\n")
 
                 # 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")
@@ -883,15 +894,13 @@ class TelegramExporter(BaseExporter):
                 while chat_id == channel_id:
                     error_msg = (
                         "Chat ID and channel ID are the same. The problem may be that "
-                        "you forwarded a message from discussion group that itself was automatically forwarded "
-                        "from the channel by Telegram. Please forward a message that was sent directly in the discussion group."
+                        "you posted a message in the channel, not in the discussion group."
                     )
                     self.logger.error(error_msg)
                     chat_id = self.wait_for_forwarded_message(
                         entity_type="chat",
                         check_type=False,
                         add_msg=error_msg,
-                        string_id=chat_result,
                     )
                 if chat_id:
                     self.save_username(chat_result, chat_id)
@@ -904,7 +913,10 @@ class TelegramExporter(BaseExporter):
             raise Exception("Chat ID is undefined")
 
         self.channel_id = f"-100{channel_id}"
-        self.chat_id = f"-100{chat_id}"
+        if not str(chat_id).startswith("-100"):
+            self.chat_id = f"-100{chat_id}"
+        else:
+            self.chat_id = chat_id
 
         self.logger.info(
             f"Using channel ID {self.channel_id} and discussion group ID {self.chat_id}"
@@ -1088,7 +1100,10 @@ class TelegramExporter(BaseExporter):
             failure_message = "❌ Failed to extract channel ID."
         else:
             entity_name = "discussion group"
-            instruction_message = "🔄 Please forward any message from the discussion group\n\n⚠️ IMPORTANT: Do NOT forward messages that were automatically posted from the channel. Forward messages that were sent directly in the discussion group."
+            instruction_message = (
+                f"🔄 Please post to the discussion group a message with text: {self.chat_auth_uuid}\n\n"
+                "⚠️ IMPORTANT: Bot should be added to the discussion group and have ADMIN rights!"
+            )
             success_message = "✅ Successfully extracted discussion group ID: {}"
             failure_message = "❌ Failed to extract discussion group ID."
 
@@ -1105,6 +1120,7 @@ class TelegramExporter(BaseExporter):
         resolved = False
         retry_count = 0
         max_retries = 30  # 5 minutes (10 seconds per retry)
+        extracted_id = None
 
         # Extract channel ID for comparison if we're looking for a discussion group
         channel_numeric_id = None
@@ -1117,11 +1133,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
             """
             )
@@ -1129,58 +1149,63 @@ class TelegramExporter(BaseExporter):
             messages = cursor.fetchall()
 
             for row in messages:
+                if self.args.debug:
+                    self.logger.info(row["raw_data"])
                 if self.created_at and row["created_at"] < self.created_at:
                     break
                 msg_data = json.loads(row["raw_data"])
-                if msg_data["message"]["chat"]["id"] != self.control_chat_id:
-                    continue
-                if "message" in msg_data and "forward_from_chat" in msg_data["message"]:
-                    forward_info = msg_data["message"]["forward_from_chat"]
-
-                    # Extract chat ID from the message
-                    chat_id = forward_info.get("id")
-                    # Remove -100 prefix if present
-                    if str(chat_id).startswith("-100"):
-                        extracted_id = int(str(chat_id)[4:])
-                    else:
-                        extracted_id = chat_id
-
-                    # If we're looking for a discussion group, verify it's not the same as the channel ID
-                    if entity_type == "chat" and channel_numeric_id:
-                        if extracted_id == channel_numeric_id:
-                            self.logger.warning(
-                                "User forwarded a message from the channel, not the discussion group"
-                            )
-                            self.send_api_request(
-                                "sendMessage",
-                                {
-                                    "chat_id": self.control_chat_id,
-                                    "text": "⚠️ You forwarded a message from the channel, not from the discussion group.\n\nPlease forward a message that was originally sent IN the discussion group, not an automatic repost from the channel.",
-                                },
-                            )
-                            # Skip this message and continue waiting
-                            continue
-
-                    # For channels, check the type; for chats, accept any type except "channel" if check_type is False
-                    if (check_type and forward_info.get("type") == "channel") or (
-                        not check_type
-                    ):
-                        resolved = True
-                        self.created_at = row["created_at"]
-                        self.logger.info(
-                            f"Extracted {entity_name} ID: {extracted_id} from forwarded message"
+                if entity_type == "chat":
+                    if get_text(msg_data) != self.chat_auth_uuid:
+                        continue
+                    extracted_id = msg_data["message"]["chat"]["id"]
+                    if extracted_id == channel_numeric_id or extracted_id == self.control_chat_id:
+                        self.logger.warning(
+                            "User posted a message in the channel, not the discussion group"
                         )
-
-                        # Send confirmation message
                         self.send_api_request(
                             "sendMessage",
                             {
                                 "chat_id": self.control_chat_id,
-                                "text": success_message.format(extracted_id),
+                                "text": (
+                                    "⚠️ You posted a message in the channel, not in the discussion group."
+                                )
                             },
                         )
+                        # Skip this message and continue waiting
+                        continue
+                elif entity_type == "channel":
+                    if msg_data["message"]["chat"]["id"] != self.control_chat_id:
+                        continue
+                    if "message" in msg_data and "forward_from_chat" in msg_data["message"]:
+                        forward_info = msg_data["message"]["forward_from_chat"]
+
+                        # Extract chat ID from the message
+                        chat_id = forward_info.get("id")
+                        # Remove -100 prefix if present
+                        if str(chat_id).startswith("-100"):
+                            extracted_id = int(str(chat_id)[4:])
+                        else:
+                            extracted_id = chat_id
+                # For channels, check the type; for chats, accept any type except "channel" if check_type is False
+                if extracted_id and ((check_type and forward_info.get("type") == "channel") or (
+                    not check_type
+                )):
+                    resolved = True
+                    self.created_at = row["created_at"]
+                    self.logger.info(
+                        f"Extracted {entity_name} ID: {extracted_id} from forwarded message"
+                    )
+
+                    # Send confirmation message
+                    self.send_api_request(
+                        "sendMessage",
+                        {
+                            "chat_id": self.control_chat_id,
+                            "text": success_message.format(extracted_id),
+                        },
+                    )
 
-                        return extracted_id
+                    return extracted_id
 
             retry_count += 1
 

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)