vibego 0.2.38__py3-none-any.whl → 0.2.40__py3-none-any.whl

bot.py

@@ -69,8 +69,6 @@ from tasks.fsm import (
     TaskNoteStates,
     TaskPushStates,
 )
-from telegram_markdown import render_markdown_to_telegram
-
 # --- 简单 .env 加载 ---
 def load_env(p: str = ".env"):
     """从指定路径加载 dotenv 格式的键值对到进程环境变量。"""
@@ -128,7 +126,7 @@ TEST_PHASE_PROMPT = f"进入测试阶段{AGENTS_PHASE_SUFFIX}"
 # 报告缺陷时的专用前缀，插入在统一提示语之前
 BUG_REPORT_PREFIX = "报告一个缺陷，详见底部最新的缺陷描述。"
 
-_parse_mode_env = (os.environ.get("TELEGRAM_PARSE_MODE") or "MarkdownV2").strip()
+_parse_mode_env = (os.environ.get("TELEGRAM_PARSE_MODE") or "Markdown").strip()
 _parse_mode_key = _parse_mode_env.replace("-", "").replace("_", "").lower()
 MODEL_OUTPUT_PARSE_MODE: Optional[ParseMode]
 if _parse_mode_key in _PARSE_MODE_CANDIDATES:
@@ -136,7 +134,12 @@ if _parse_mode_key in _PARSE_MODE_CANDIDATES:
     if MODEL_OUTPUT_PARSE_MODE is None:
         worker_log.info("模型输出将按纯文本发送")
     else:
-        worker_log.info("模型输出 parse_mode：%s", MODEL_OUTPUT_PARSE_MODE.value)
+        mode_value = (
+            MODEL_OUTPUT_PARSE_MODE.value
+            if isinstance(MODEL_OUTPUT_PARSE_MODE, ParseMode)
+            else str(MODEL_OUTPUT_PARSE_MODE)
+        )
+        worker_log.info("模型输出 parse_mode：%s", mode_value)
 else:
     MODEL_OUTPUT_PARSE_MODE = ParseMode.MARKDOWN_V2
     worker_log.warning(
@@ -503,8 +506,8 @@ def _is_already_escaped(text: str) -> bool:
 
     # 对于短文本，放宽检测条件
     if len(text) < 20:
-        # 短文本只要有 2 个以上转义字符就认为已被转义
-        if len(matches) >= 2:
+        # 短文本出现任意转义字符即可认定为已转义，防止重复转义
+        if len(matches) >= 1:
             return True
     else:
         # 检查转义字符密度（降低到 3%）
@@ -576,29 +579,17 @@ def _unescape_if_already_escaped(text: str) -> str:
 def _prepare_model_payload(text: str) -> str:
     if _IS_MARKDOWN_V2:
         cleaned = _unescape_if_already_escaped(text)
-        return render_markdown_to_telegram(cleaned)
+        return _escape_markdown_v2(cleaned)
     if _IS_MARKDOWN:
         return _normalize_legacy_markdown(text)
     return text
 
 
-def _optimize_markdown_v2_payload(payload: str) -> str:
-    """占位函数：保留严格转义版本，确保 MarkdownV2 合规。"""
-
-    return payload
-
-
 def _prepare_model_payload_variants(text: str) -> tuple[str, Optional[str]]:
-    """返回首选与备用的 MarkdownV2 内容，首选尽量减少转义。"""
-
-    strict_payload = _prepare_model_payload(text)
-    if not _IS_MARKDOWN_V2:
-        return strict_payload, None
+    """返回首选与备用内容，默认为单一格式。"""
 
-    optimized_payload = _optimize_markdown_v2_payload(strict_payload)
-    if optimized_payload != strict_payload:
-        return optimized_payload, strict_payload
-    return strict_payload, None
+    payload = _prepare_model_payload(text)
+    return payload, None
 
 
 def _extract_bad_request_message(exc: TelegramBadRequest) -> str:
@@ -704,20 +695,12 @@ async def _send_with_markdown_guard(
         if raw_sender is None:
             raise
 
-        # Markdown 彻底失败时退回纯文本发送，需要先清理 MarkdownV2 转义符号
-        fallback_payload = _force_unescape_markdown(text)
-        if fallback_payload != text:
-            worker_log.debug(
-                "Markdown 降级为纯文本发送，已移除转义符号",
-                extra={"original_length": len(text), "fallback_length": len(fallback_payload)},
-            )
-
         worker_log.warning(
             "Markdown 解析仍失败，将以纯文本发送",
             extra={"length": len(text)},
         )
-        await raw_sender(fallback_payload)
-        return fallback_payload
+        await raw_sender(text)
+        return text
 
 
 async def _notify_send_failure_message(chat_id: int) -> None:
@@ -4266,6 +4249,7 @@ async def _deliver_pending_messages(
                     "chat": chat_id,
                 },
             )
+            return False
         else:
             worker_log.info(
                 "模型输出已发送且计划完成",
@@ -4592,7 +4576,13 @@ async def _interrupt_long_poll(chat_id: int) -> None:
     线程安全：使用 asyncio.Lock 保护状态访问。
     """
     if CHAT_LONG_POLL_LOCK is None:
-        # 锁未初始化（测试环境或启动早期）
+        state = CHAT_LONG_POLL_STATE.get(chat_id)
+        if state is not None:
+            state["interrupted"] = True
+            worker_log.info(
+                "标记延迟轮询为待中断",
+                extra={"chat": chat_id},
+            )
         return
 
     async with CHAT_LONG_POLL_LOCK:
@@ -4685,6 +4675,13 @@ async def _watch_and_notify(chat_id: int, session_path: Path,
                             "max_rounds": long_poll_max_rounds,
                             "interrupted": False,
                         }
+                else:
+                    CHAT_LONG_POLL_STATE[chat_id] = {
+                        "active": True,
+                        "round": 0,
+                        "max_rounds": long_poll_max_rounds,
+                        "interrupted": False,
+                    }
                 worker_log.info(
                     "首次发送成功，启动延迟轮询模式",
                     extra={
@@ -4706,6 +4703,10 @@ async def _watch_and_notify(chat_id: int, session_path: Path,
                             state = CHAT_LONG_POLL_STATE.get(chat_id)
                             if state is not None:
                                 state["round"] = 0
+                    else:
+                        state = CHAT_LONG_POLL_STATE.get(chat_id)
+                        if state is not None:
+                            state["round"] = 0
                     worker_log.info(
                         "延迟轮询中收到新消息，重置计数",
                         extra={
@@ -4721,6 +4722,10 @@ async def _watch_and_notify(chat_id: int, session_path: Path,
                             state = CHAT_LONG_POLL_STATE.get(chat_id)
                             if state is not None:
                                 state["round"] = long_poll_rounds
+                    else:
+                        state = CHAT_LONG_POLL_STATE.get(chat_id)
+                        if state is not None:
+                            state["round"] = long_poll_rounds
 
                     if long_poll_rounds >= long_poll_max_rounds:
                         worker_log.info(
@@ -4757,6 +4762,13 @@ async def _watch_and_notify(chat_id: int, session_path: Path,
                         "监听任务退出，已清理延迟轮询状态",
                         extra={"chat": chat_id},
                     )
+        else:
+            if chat_id in CHAT_LONG_POLL_STATE:
+                CHAT_LONG_POLL_STATE.pop(chat_id, None)
+                worker_log.debug(
+                    "监听任务退出，已清理延迟轮询状态",
+                    extra={"chat": chat_id},
+                )
 
 
 def _read_pointer_path(pointer: Path) -> Optional[Path]:

{vibego-0.2.38.dist-info → vibego-0.2.40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibego
-Version: 0.2.38
+Version: 0.2.40
 Summary: vibego CLI：用于初始化与管理 Telegram Master Bot 的工具
 Author: Hypha
 License-Expression: LicenseRef-Proprietary

{vibego-0.2.38.dist-info → vibego-0.2.40.dist-info}/RECORD

@@ -1,4 +1,4 @@
-bot.py,sha256=YDLAFxvh0YfCDScoADirJlzlGlc_-8BdnOIzLNVPrRc,273403
+bot.py,sha256=TthqY_Rvndzd3pgLH6lvPcsDXQbwkuMfB4W9qt_Li8I,273832
 logging_setup.py,sha256=gvxHi8mUwK3IhXJrsGNTDo-DR6ngkyav1X-tvlBF_IE,4613
 master.py,sha256=ZW4A3Gh0MUKFnfZX-VJ7OCNnBzlEcOWkPKYH92OfyKA,112967
 project_repository.py,sha256=UcthtSGOJK0cTE5bQCneo3xkomRG-kyc1N1QVqxeHIs,17577
@@ -426,15 +426,14 @@ tasks/constants.py,sha256=tS1kZxBIUm3JJUMHm25XI-KHNUZl5NhbbuzjzL_rF-c,299
 tasks/fsm.py,sha256=rKXXLEieQQU4r2z_CZUvn1_70FXiZXBBugF40gpe_tQ,1476
 tasks/models.py,sha256=N_qqRBo9xMSV0vbn4k6bLBXT8C_dp_oTFUxvdx16ZQM,2459
 tasks/service.py,sha256=w_S_aWiVqRXzXEpimLDsuCCCX2lB5uDkff9aKThBw9c,41916
-telegram_markdown/__init__.py,sha256=bG3H9fWn5GfTqC6xvd49xbVdYWfSFeaX2nefweOYcWY,9757
-vibego_cli/__init__.py,sha256=TIfBvbASwv0PjEHa0uOiVJkU2YO8pvPm9O9aRMy5kDE,311
+vibego_cli/__init__.py,sha256=mkajWsGOmqjBWy1uSiLsUbptT642DZPYn7LoFD0LU7o,311
 vibego_cli/__main__.py,sha256=qqTrYmRRLe4361fMzbI3-CqpZ7AhTofIHmfp4ykrrBY,158
 vibego_cli/config.py,sha256=VxkPJMq01tA3h3cOkH-z_tiP7pMgfSGGicRvUnCWkhI,3054
 vibego_cli/deps.py,sha256=1nRXI7Dd-S1hYE8DligzK5fIluQWETRUj4_OKL0DikQ,1419
 vibego_cli/main.py,sha256=X__NXwZnIDIFbdKSTbNyZgZHKcPlN0DQz9sqTI1aQ9E,12158
 vibego_cli/data/worker_requirements.txt,sha256=QSt30DSSSHtfucTFPpc7twk9kLS5rVLNTcvDiagxrZg,62
-vibego-0.2.38.dist-info/METADATA,sha256=IPvXXUHPNJdwkvrsJi4Tuau4VmgFCxMWShPYspWpWVE,10519
-vibego-0.2.38.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vibego-0.2.38.dist-info/entry_points.txt,sha256=Lsy_zm-dlyxt8-9DL9blBReIwU2k22c8-kifr46ND1M,48
-vibego-0.2.38.dist-info/top_level.txt,sha256=rWDj9KERtbJL6Lar9Xa0O6dthaFSY_jc1WNpQgUrXCM,87
-vibego-0.2.38.dist-info/RECORD,,
+vibego-0.2.40.dist-info/METADATA,sha256=XiZcCoOO5eGJ6nG9Xt92Bt9R-zViJfjf3In31pzE78M,10519
+vibego-0.2.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vibego-0.2.40.dist-info/entry_points.txt,sha256=Lsy_zm-dlyxt8-9DL9blBReIwU2k22c8-kifr46ND1M,48
+vibego-0.2.40.dist-info/top_level.txt,sha256=R56CT3nW5H5v3ce0l3QDN4-C4qxTrNWzRTwrxnkDX4U,69
+vibego-0.2.40.dist-info/RECORD,,

{vibego-0.2.38.dist-info → vibego-0.2.40.dist-info}/top_level.txt

@@ -4,5 +4,4 @@ master
 project_repository
 scripts
 tasks
-telegram_markdown
 vibego_cli

vibego_cli/__init__.py

@@ -7,6 +7,6 @@ from __future__ import annotations
 
 __all__ = ["main", "__version__"]
 
-__version__ = "0.2.38"
+__version__ = "0.2.40"
 
 from .main import main  # noqa: E402

telegram_markdown/__init__.py

@@ -1,269 +0,0 @@
-"""
-自定义 Markdown → Telegram MarkdownV2 渲染器。
-
-依赖 markdown-it-py 提供的 CommonMark 解析能力，将常见 Markdown
-语法（段落、标题、列表、引用、加粗、斜体、代码块、行内代码、链接等）
-转换为符合 Telegram MarkdownV2 语法的文本。
-
-Telegram 对 MarkdownV2 的语法要求非常严格，特殊字符必须转义，否则会直接
-返回 “can't parse entities” 错误。借助解析树，我们可以准确地区分格式化标记
-与普通文本，做到“格式保留 + 无额外反斜杠”。
-"""
-from __future__ import annotations
-
-import re
-from typing import Iterable, List, Optional, Tuple
-
-from markdown_it import MarkdownIt
-from markdown_it.token import Token
-
-_TELEGRAM_SPECIAL_CHARS = re.compile(r"([_*\[\]()~`>#+\-=|{}.!\\])")
-
-
-def _escape_plain_text(value: str) -> str:
-    """转义 Telegram MarkdownV2 的特殊字符。"""
-    if not value:
-        return ""
-    return _TELEGRAM_SPECIAL_CHARS.sub(r"\\\1", value)
-
-
-def _escape_url(value: str) -> str:
-    """URL 中统一转义括号、空格等特殊字符。"""
-    if not value:
-        return ""
-    escaped = value.replace("\\", "\\\\")
-    escaped = escaped.replace(")", r"\)").replace("(", r"\(")
-    return escaped
-
-
-def _escape_inline_code(value: str) -> str:
-    """行内代码仅需要处理反斜杠与反引号。"""
-    if not value:
-        return "``"
-    escaped = value.replace("\\", "\\\\").replace("`", r"\`")
-    return f"`{escaped}`"
-
-
-def _escape_code_block(value: str, language: str = "") -> str:
-    """多行代码块同样保留原样，只需保护反引号。"""
-    content = (value or "").rstrip("\n")
-    content = content.replace("```", r"\`\`\`")
-    header = f"```{language.strip()}\n" if language else "```\n"
-    return f"{header}{content}\n```"
-
-
-class _TelegramMarkdownRenderer:
-    """对 markdown-it 解析出的 Token 序列进行 Telegram MarkdownV2 序列化。"""
-
-    def __init__(self) -> None:
-        self._parser = MarkdownIt("commonmark", {"linkify": True})
-
-    # ---- 外部接口 ---------------------------------------------------------
-    def render(self, markdown_text: str) -> str:
-        tokens = self._parser.parse(markdown_text or "")
-        return self._render_block_tokens(tokens, 0, len(tokens)).strip()
-
-    # ---- Block 级渲染 -----------------------------------------------------
-    def _render_block_tokens(self, tokens: List[Token], start: int, end: int) -> str:
-        blocks: List[str] = []
-        index = start
-        while index < end:
-            token = tokens[index]
-            token_type = token.type
-
-            if token_type == "paragraph_open":
-                inline = tokens[index + 1]
-                blocks.append(self._render_inline(inline.children or []))
-                index += 3  # 跳过 inline + paragraph_close
-                continue
-
-            if token_type == "heading_open":
-                inline = tokens[index + 1]
-                content = self._render_inline(inline.children or [])
-                blocks.append(f"*{content}*")
-                index += 3
-                continue
-
-            if token_type == "bullet_list_open":
-                close_idx = self._find_matching(tokens, index, "bullet_list_close")
-                blocks.append(self._render_list(tokens, index + 1, close_idx, ordered=False))
-                index = close_idx + 1
-                continue
-
-            if token_type == "ordered_list_open":
-                close_idx = self._find_matching(tokens, index, "ordered_list_close")
-                start_number = int(token.attrGet("start") or "1")
-                blocks.append(
-                    self._render_list(tokens, index + 1, close_idx, ordered=True, start_number=start_number)
-                )
-                index = close_idx + 1
-                continue
-
-            if token_type == "blockquote_open":
-                close_idx = self._find_matching(tokens, index, "blockquote_close")
-                quoted = self._render_block_tokens(tokens, index + 1, close_idx)
-                lines = quoted.splitlines()
-                blocks.append("\n".join(f"> {line}" if line else ">" for line in lines))
-                index = close_idx + 1
-                continue
-
-            if token_type in {"fence", "code_block"}:
-                language = token.info or "" if token_type == "fence" else ""
-                blocks.append(_escape_code_block(token.content, language))
-                index += 1
-                continue
-
-            if token_type == "inline":
-                blocks.append(self._render_inline(token.children or []))
-                index += 1
-                continue
-
-            if token_type == "hr":
-                blocks.append("―" * 3)
-                index += 1
-                continue
-
-            # 其他 Block token（如 html_block）直接忽略或转换为原始文本
-            if token_type == "html_block":
-                blocks.append(_escape_plain_text(token.content))
-                index += 1
-                continue
-
-            index += 1
-
-        return "\n\n".join(part for part in blocks if part)
-
-    def _render_list(
-        self,
-        tokens: List[Token],
-        start: int,
-        end: int,
-        *,
-        ordered: bool,
-        start_number: int = 1,
-    ) -> str:
-        parts: List[str] = []
-        index = start
-        counter = start_number
-        while index < end:
-            token = tokens[index]
-            if token.type != "list_item_open":
-                index += 1
-                continue
-
-            close_idx = self._find_matching(tokens, index, "list_item_close")
-            body = self._render_block_tokens(tokens, index + 1, close_idx)
-            lines = body.splitlines()
-            prefix = f"{counter}. " if ordered else "- "
-            if lines:
-                rendered = [prefix + lines[0]]
-                rendered.extend(("  " if ordered else "  ") + line for line in lines[1:])
-                parts.append("\n".join(rendered))
-            else:
-                parts.append(prefix.rstrip())
-
-            if ordered:
-                counter += 1
-            index = close_idx + 1
-
-        return "\n".join(parts)
-
-    # ---- Inline 渲染 ------------------------------------------------------
-    def _render_inline(self, tokens: Iterable[Token]) -> str:
-        rendered, _ = self._render_inline_segment(list(tokens), 0, None)
-        return rendered
-
-    def _render_inline_segment(
-        self,
-        tokens: List[Token],
-        start: int,
-        closing_type: Optional[str],
-    ) -> Tuple[str, int]:
-        parts: List[str] = []
-        index = start
-
-        while index < len(tokens):
-            token = tokens[index]
-            token_type = token.type
-
-            if closing_type and token_type == closing_type:
-                return "".join(parts), index + 1
-
-            if token_type == "text":
-                parts.append(_escape_plain_text(token.content))
-                index += 1
-                continue
-
-            if token_type in {"softbreak", "hardbreak"}:
-                parts.append("\n")
-                index += 1
-                continue
-
-            if token_type == "code_inline":
-                parts.append(_escape_inline_code(token.content))
-                index += 1
-                continue
-
-            if token_type == "strong_open":
-                inner, next_index = self._render_inline_segment(tokens, index + 1, "strong_close")
-                parts.append(f"*{inner}*")
-                index = next_index
-                continue
-
-            if token_type == "em_open":
-                inner, next_index = self._render_inline_segment(tokens, index + 1, "em_close")
-                parts.append(f"_{inner}_")
-                index = next_index
-                continue
-
-            if token_type == "link_open":
-                href = token.attrGet("href") or ""
-                inner, next_index = self._render_inline_segment(tokens, index + 1, "link_close")
-                parts.append(f"[{inner}]({_escape_url(href)})")
-                index = next_index
-                continue
-
-            if token_type == "image":
-                alt_text = self._render_inline(token.children or [])
-                parts.append(f"[{alt_text}]")
-                index += 1
-                continue
-
-            if token_type == "html_inline":
-                parts.append(_escape_plain_text(token.content))
-                index += 1
-                continue
-
-            if token_type == "strikethrough_open":
-                inner, next_index = self._render_inline_segment(tokens, index + 1, "strikethrough_close")
-                parts.append(f"~{inner}~")
-                index = next_index
-                continue
-
-            index += 1
-
-        return "".join(parts), len(tokens)
-
-    # ---- 工具方法 ---------------------------------------------------------
-    @staticmethod
-    def _find_matching(tokens: List[Token], start_idx: int, closing_type: str) -> int:
-        """使用 nesting 深度寻找匹配的关闭 token。"""
-        open_type = tokens[start_idx].type
-        depth = 0
-        for idx in range(start_idx, len(tokens)):
-            token = tokens[idx]
-            if token.type == open_type and token.nesting == 1:
-                depth += 1
-            elif token.type == closing_type and token.nesting == -1:
-                depth -= 1
-                if depth == 0:
-                    return idx
-        raise ValueError(f"未找到匹配的 {closing_type}")
-
-
-_RENDERER = _TelegramMarkdownRenderer()
-
-
-def render_markdown_to_telegram(markdown_text: str) -> str:
-    """将 Markdown 文本转换为 Telegram MarkdownV2。"""
-    return _RENDERER.render(markdown_text)