chgksuite 0.25.1__py3-none-any.whl → 0.26.0__py3-none-any.whl

chgksuite/composer/pptx.py

@@ -9,6 +9,7 @@ from chgksuite.composer.composer_common import BaseExporter, backtick_replace, p
 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
 
@@ -55,6 +56,8 @@ class PptxExporter(BaseExporter):
             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):
@@ -179,9 +182,8 @@ class PptxExporter(BaseExporter):
             r = self.add_run(
                 p,
                 self._replace_no_break(
-                    ("\n" if add_line_break else "")
+                    ("\n\n" if add_line_break else "")
                     + self.pptx_process_text(editor[0][1])
-                    + "\n"
                 ),
             )
             add_line_break = True
@@ -190,9 +192,8 @@ class PptxExporter(BaseExporter):
                 r = self.add_run(
                     p,
                     self._replace_no_break(
-                        ("\n" if add_line_break else "")
+                        ("\n\n" if add_line_break else "")
                         + self.pptx_process_text(element[1])
-                        + "\n"
                     ),
                 )
                 add_line_break = True
@@ -437,6 +438,8 @@ 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.get("add_source") and "source" in q:
@@ -461,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"])
@@ -487,6 +494,11 @@ class PptxExporter(BaseExporter):
             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 = self.add_run(p, f"\n{self.get_label(q, 'comment')}: ")

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",
@@ -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,9 +878,10 @@ 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
@@ -883,8 +894,7 @@ 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(
@@ -903,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}"
@@ -1087,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."
 
@@ -1104,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
@@ -1132,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)

chgksuite/handouter/installer.py

@@ -0,0 +1,245 @@
+import functools
+import os
+import platform
+import re
+import shutil
+import subprocess
+import tarfile
+import zipfile
+
+import requests
+
+
+def get_utils_dir():
+    path = os.path.join(os.path.expanduser("~"), ".pecheny_utils")
+    if not os.path.exists(path):
+        os.mkdir(path)
+    return path
+
+
+def escape_latex(text):
+    text = text.replace("\\", "\\textbackslash")
+    text = text.replace("~", "\\textasciitilde")
+    text = text.replace("^", "\\textasciicircum")
+    for char in ("%", "&", "$", "#", "{", "}", "_"):
+        text = text.replace(char, "\\" + char)
+    text = text.replace("\n", "\\linebreak\n")
+    return text
+
+
+def check_tectonic_path(tectonic_path):
+    proc = subprocess.run([tectonic_path, "--help"], capture_output=True, check=True)
+    return proc.returncode == 0
+
+
+def get_tectonic_path():
+    errors = []
+    system = platform.system()
+
+    cpdir = get_utils_dir()
+    if system == "Windows":
+        binary_name = "tectonic.exe"
+        tectonic_path = os.path.join(cpdir, binary_name)
+    else:
+        binary_name = "tectonic"
+        tectonic_path = os.path.join(cpdir, binary_name)
+
+    tectonic_ok = False
+    try:
+        tectonic_ok = check_tectonic_path(binary_name)
+    except FileNotFoundError:
+        pass  # tectonic not found in PATH
+    except subprocess.CalledProcessError as e:
+        errors.append(f"tectonic --version failed: {type(e)} {e}")
+    if tectonic_ok:
+        return binary_name
+    if os.path.isfile(tectonic_path):
+        try:
+            tectonic_ok = check_tectonic_path(tectonic_path)
+        except subprocess.CalledProcessError as e:
+            errors.append(f"tectonic --version failed: {type(e)} {e}")
+    if tectonic_ok:
+        return tectonic_path
+
+
+def github_get_latest_release(repo):
+    url = f"https://api.github.com/repos/{repo}/releases/latest"
+    req = requests.get(url)
+    assets_url = req.json()["assets_url"]
+    assets_req = requests.get(assets_url)
+    return {asset["name"]: asset["browser_download_url"] for asset in assets_req.json()}
+
+
+def darwin_is_emulated():
+    try:
+        sub = subprocess.run(
+            ["sysctl", "-n", "sysctl.proc_translated"], capture_output=True, check=True
+        )
+        out = sub.stdout.decode("utf8").strip()
+        return int(out)
+    except subprocess.CalledProcessError:
+        print("couldn't tell if emulated, returning 0")
+        return 0
+
+
+def parse_tectonic_archive_name(archive_name):
+    if archive_name.endswith(".tar.gz"):
+        archive_name = archive_name[: -len(".tar.gz")]
+    elif archive_name.endswith(".zip"):
+        archive_name = archive_name[: -len(".zip")]
+    else:
+        return
+    sp = archive_name.split("-")
+    result = {
+        "version": sp[1],
+        "arch": sp[2],
+        "manufacturer": sp[3],
+        "system": sp[4],
+    }
+    if len(sp) > 5:
+        result["toolchain"] = sp[5]
+    return result
+
+
+# download_file function taken from https://stackoverflow.com/a/39217788
+def download_file(url):
+    print(f"downloading from {url}...")
+    local_filename = url.split("/")[-1]
+    with requests.get(url, stream=True) as resp:
+        resp.raw.read = functools.partial(resp.raw.read, decode_content=True)
+        with open(local_filename, "wb") as f:
+            shutil.copyfileobj(resp.raw, f, length=16 * 1024 * 1024)
+    return local_filename
+
+
+def extract_zip(zip_file, dirname=None):
+    if dirname is None:
+        dirname = zip_file[:-4]
+    with zipfile.ZipFile(zip_file, "r") as zip_ref:
+        zip_ref.extractall(dirname)
+    os.remove(zip_file)
+
+
+def extract_tar(tar_file, dirname=None):
+    if dirname is None:
+        dirname = tar_file[: tar_file.lower().index(".tar")]
+    tf = tarfile.open(tar_file)
+    tf.extractall(dirname)
+    os.remove(tar_file)
+
+
+def extract_archive(filename, dirname=None):
+    if filename.lower().endswith((".tar", ".tar.gz")):
+        extract_tar(filename, dirname=dirname)
+    elif filename.lower().endswith(".zip"):
+        extract_zip(filename, dirname=dirname)
+
+
+def guess_archive_url(assets):
+    system = platform.system()
+    proc = platform.processor()
+    if system == "Darwin":
+        if proc == "arm" or (proc == "i386" and darwin_is_emulated()):
+            arch = "aarch64"
+        else:
+            arch = "x86_64"
+        for k, v in assets.items():
+            parsed = parse_tectonic_archive_name(k)
+            if not parsed:
+                continue
+            if parsed["arch"] == arch and parsed["system"] == "darwin":
+                return v
+    elif system == "Windows":
+        for k, v in assets.items():
+            parsed = parse_tectonic_archive_name(k)
+            if not parsed:
+                continue
+            if (
+                parsed["arch"] == "x86_64"
+                and parsed["system"] == "windows"
+                and parsed["toolchain"] == "msvc"
+            ):
+                return v
+    elif system == "Linux":
+        for k, v in assets.items():
+            parsed = parse_tectonic_archive_name(k)
+            if not parsed:
+                continue
+            if (
+                (not proc or (proc and parsed["arch"] == proc))
+                and parsed["system"] == "linux"
+                and parsed["toolchain"] == "musl"
+            ):
+                return v
+    raise Exception(f"Archive for system {system} proc {proc} not found")
+
+
+def archive_url_from_regex(assets, regex):
+    for k, v in assets.items():
+        if re.match(regex, k):
+            return v
+    raise Exception(f"Archive for regex {regex} not found")
+
+
+def install_tectonic(args):
+    system = platform.system()
+    assets = github_get_latest_release("tectonic-typesetting/tectonic")
+    if args.tectonic_package_regex:
+        archive_url = archive_url_from_regex(assets, args.tectonic_package_regex)
+    else:
+        archive_url = guess_archive_url(assets)
+    downloaded = download_file(archive_url)
+    dirname = "tectonic_folder"
+    extract_archive(downloaded, dirname=dirname)
+    if system == "Windows":
+        filename = "tectonic.exe"
+    else:
+        filename = "tectonic"
+    target_path = os.path.join(get_utils_dir(), filename)
+    shutil.move(os.path.join(dirname, filename), target_path)
+    shutil.rmtree(dirname)
+    return target_path
+
+
+def install_font(url):
+    fn = url.split("/")[-1].split("?")[0]
+    bn, ext = os.path.splitext(fn)
+    if "." in bn:
+        new_fn = bn.replace(".", "_") + ext
+    else:
+        new_fn = fn
+    dir_name = new_fn[:-4]
+    dir_name_base = dir_name.split(os.pathsep)[-1]
+    fonts_dir = os.path.join(get_utils_dir(), "fonts")
+    if not os.path.exists(fonts_dir):
+        os.makedirs(fonts_dir)
+    target_dir = os.path.join(fonts_dir, dir_name_base)
+    if os.path.isdir(target_dir):
+        print(f"{target_dir} already exists")
+        return
+    download_file(url)
+    if fn != new_fn:
+        os.rename(fn, new_fn)
+    extract_archive(new_fn, dirname=dir_name)
+    if not os.path.isdir(target_dir):
+        shutil.copytree(dir_name, target_dir)
+    shutil.rmtree(dir_name)
+
+
+def find_font(file_name, root_dir=None):
+    root_dir = root_dir or os.path.join(get_utils_dir(), "fonts")
+    if not os.path.isdir(root_dir):
+        os.makedirs(root_dir, exist_ok=True)
+    for dir_, _, files in os.walk(root_dir):
+        for fn in files:
+            if fn == file_name:
+                return os.path.join(dir_, fn)
+    raise Exception(f"{file_name} not found")
+
+
+def install_font_from_github_wrapper(repo):
+    latest = github_get_latest_release(repo)
+    for k, v in latest.items():
+        if k.endswith(".zip"):
+            install_font(v)
+            break