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

chgksuite/composer/latex.py

@@ -1,4 +1,3 @@
-import codecs
 import hashlib
 import os
 import re
@@ -199,11 +198,11 @@ class LatexExporter(BaseExporter):
         firsttour = True
         for element in self.structure:
             if element[0] == "heading":
-                tex += "\n{{\\huge {}}}\n" "\\vspace{{0.8em}}\n".format(
+                tex += "\n{{\\huge {}}}\n\\vspace{{0.8em}}\n".format(
                     self.tex_element_layout(element[1])
                 )
             if element[0] == "date":
-                tex += "\n{{\\large {}}}\n" "\\vspace{{0.8em}}\n".format(
+                tex += "\n{{\\large {}}}\n\\vspace{{0.8em}}\n".format(
                     self.tex_element_layout(element[1])
                 )
             if element[0] in {"meta", "editor"}:
@@ -221,7 +220,7 @@ class LatexExporter(BaseExporter):
 
         tex += "\\end{document}"
 
-        with codecs.open(outfilename, "w", "utf8") as outfile:
+        with open(outfilename, "w", encoding="utf-8") as outfile:
             outfile.write(tex)
         cwd = os.getcwd()
         os.chdir(self.dir_kwargs["tmp_dir"])

chgksuite/composer/lj.py

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

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

@@ -5,7 +5,12 @@ import re
 import toml
 
 from chgksuite.common import log_wrap, replace_escaped, tryint
-from chgksuite.composer.composer_common import BaseExporter, backtick_replace, parseimg
+from chgksuite.composer.composer_common import (
+    BaseExporter,
+    backtick_replace,
+    parseimg,
+    remove_accents_standalone,
+)
 from pptx import Presentation
 from pptx.dml.color import RGBColor
 from pptx.enum.text import MSO_AUTO_SIZE, MSO_VERTICAL_ANCHOR, PP_ALIGN
@@ -109,15 +114,20 @@ class PptxExporter(BaseExporter):
                         r.font.underline = True
 
     def pptx_process_text(
-        self, s, image=None, strip_brackets=True, replace_spaces=True
+        self,
+        s,
+        image=None,
+        strip_brackets=True,
+        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:
-            s = s.replace("\u0301", "")
+        if not (self.args.do_not_remove_accents or do_not_remove_accents):
+            s = remove_accents_standalone(s, self.regexes)
         if strip_brackets:
             s = self.remove_square_brackets(s)
             s = s.replace("]\n", "]\n\n")
@@ -408,7 +418,9 @@ class PptxExporter(BaseExporter):
         if number is not None:
             self.set_question_number(slide, number)
         p = self.init_paragraph(tf, text=handout)
-        self.pptx_format(self.pptx_process_text(handout), p, tf, slide)
+        self.pptx_format(
+            self.pptx_process_text(handout, do_not_remove_accents=True), p, tf, slide
+        )
 
     def process_question_text(self, q):
         image = self._get_image_from_4s(q["question"])

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
@@ -126,7 +127,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")
+                    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(
@@ -245,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:
@@ -869,7 +872,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
@@ -881,7 +884,9 @@ class TelegramExporter(BaseExporter):
                     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(
+                    "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
@@ -1158,7 +1163,10 @@ class TelegramExporter(BaseExporter):
                     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:
+                    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"
                         )
@@ -1168,7 +1176,7 @@ class TelegramExporter(BaseExporter):
                                 "chat_id": self.control_chat_id,
                                 "text": (
                                     "⚠️ You posted a message in the channel, not in the discussion group."
-                                )
+                                ),
                             },
                         )
                         # Skip this message and continue waiting
@@ -1176,7 +1184,10 @@ class TelegramExporter(BaseExporter):
                 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"]:
+                    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
@@ -1187,9 +1198,10 @@ class TelegramExporter(BaseExporter):
                         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
-                )):
+                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(

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: