vibego 0.2.35__tar.gz → 0.2.37__tar.gz

{vibego-0.2.35 → vibego-0.2.37}/PKG-INFO

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

{vibego-0.2.35 → vibego-0.2.37}/bot.py

@@ -482,6 +482,11 @@ _ESCAPED_CODE_BLOCK_PATTERN = re.compile(
     re.DOTALL
 )
 
+_OPTIMIZE_CHECKBOX_PATTERN = re.compile(r"\\\[\s+\\\]")
+_OPTIMIZE_DOT_PATTERN = re.compile(
+    r"(?P<prefix>[0-9A-Za-z\u4e00-\u9fff])\\\.(?=(?:\s|$|[)\]\u3002\uff0c\uff1b\uff1a\uff01\uff1f]))"
+)
+
 
 def _is_already_escaped(text: str) -> bool:
     """检测文本是否已经包含 MarkdownV2 转义字符。
@@ -534,68 +539,46 @@ def _unescape_markdown_v2(text: str) -> str:
     return re.sub(r"\\([_*\[\]()~`>#+=|{}.!:-])", r"\1", text)
 
 
-def _unescape_if_already_escaped(text: str) -> str:
-    """智能检测并清理预转义文本，特别保护代码块。
-
-    改进的分段处理策略：
-    1. 先识别已转义的代码块（\`\`\`...\`\`\` 和 \`...\`）
-    2. 对这些代码块先反转义边界反引号，变成正常代码块
-    3. 然后用正常的 CODE_SEGMENT_RE 识别代码块
-    4. 只对非代码块的普通文本进行反转义
-    5. 代码块内容保持转义状态（因为是代码本身）
-    6. 重新组合所有段落
-
-    Args:
-        text: 待处理的文本
-
-    Returns:
-        处理后的文本（如未检测到预转义，返回原文本）
-    """
+def _force_unescape_markdown(text: str) -> str:
+    """强制移除 MarkdownV2 转义，同时保护代码块语法不被破坏。"""
     if not text:
         return text
 
-    # 快速检测：如果没有任何转义字符，直接返回
-    if not _is_already_escaped(text):
-        return text
-
-    # 第一步：处理已转义的代码块，将边界反引号反转义
-    # 这样后续可以用正常的 CODE_SEGMENT_RE 识别它们
     processed = text
-
-    # 先标记所有已转义的代码块，用占位符替换
     code_blocks: list[str] = []
 
     def _preserve_code_block(match: re.Match[str]) -> str:
-        """保存代码块并返回占位符"""
+        """临时替换代码块，防止内部字符被错误反转义。"""
         block = match.group(0)
-        # 代码块边界的反引号需要反转义，但内容保持不变
-        # 例如：\`\`\`bash\npython -m vibego\_cli\`\`\`
-        #    -> ```bash\npython -m vibego\_cli```
         if block.startswith(r"\`\`\`"):
-            # 多行代码块
-            unescaped_block = block.replace(r"\`", "`", 6)  # 只替换前后各3个反引号
+            # 多行代码块保留内容，只修复边界反引号
+            unescaped_block = block.replace(r"\`", "`", 6)
         else:
-            # 单行代码块
-            unescaped_block = block.replace(r"\`", "`", 2)  # 只替换前后各1个反引号
+            # 单行代码块同理处理首尾反引号
+            unescaped_block = block.replace(r"\`", "`", 2)
 
         placeholder = f"__CODE_BLOCK_{len(code_blocks)}__"
         code_blocks.append(unescaped_block)
         return placeholder
 
     processed = _ESCAPED_CODE_BLOCK_PATTERN.sub(_preserve_code_block, processed)
+    processed = _unescape_markdown_v2(processed)
 
-    # 第二步：对非代码块部分进行反转义
-    if _is_already_escaped(processed):
-        processed = _unescape_markdown_v2(processed)
-
-    # 第三步：恢复代码块
-    for i, block in enumerate(code_blocks):
-        placeholder = f"__CODE_BLOCK_{i}__"
-        processed = processed.replace(placeholder, block)
+    for index, block in enumerate(code_blocks):
+        processed = processed.replace(f"__CODE_BLOCK_{index}__", block)
 
     return processed
 
 
+def _unescape_if_already_escaped(text: str) -> str:
+    """智能检测并清理预转义文本，必要时触发强制反转义。"""
+    if not text:
+        return text
+    if not _is_already_escaped(text):
+        return text
+    return _force_unescape_markdown(text)
+
+
 def _prepare_model_payload(text: str) -> str:
     if _IS_MARKDOWN_V2:
         cleaned = _unescape_if_already_escaped(text)
@@ -605,6 +588,47 @@ def _prepare_model_payload(text: str) -> str:
     return text
 
 
+def _optimize_markdown_v2_payload(payload: str) -> str:
+    """在保留 MarkdownV2 合法性的前提下，移除常见的冗余反斜杠。"""
+
+    if not payload or "\\" not in payload:
+        return payload
+
+    preserved_segments: list[str] = []
+
+    def _preserve(segment: re.Match[str]) -> str:
+        placeholder = f"__OPT_CODE_BLOCK_{len(preserved_segments)}__"
+        preserved_segments.append(segment.group(0))
+        return placeholder
+
+    stripped = CODE_SEGMENT_RE.sub(_preserve, payload)
+    stripped = _OPTIMIZE_CHECKBOX_PATTERN.sub("[ ]", stripped)
+
+    def _dot_replacer(match: re.Match[str]) -> str:
+        prefix = match.group("prefix")
+        return f"{prefix}."
+
+    stripped = _OPTIMIZE_DOT_PATTERN.sub(_dot_replacer, stripped)
+
+    for index, segment in enumerate(preserved_segments):
+        stripped = stripped.replace(f"__OPT_CODE_BLOCK_{index}__", segment)
+
+    return stripped
+
+
+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
+
+
 def _extract_bad_request_message(exc: TelegramBadRequest) -> str:
     message = getattr(exc, "message", None)
     if not message:
@@ -658,6 +682,7 @@ async def _send_with_markdown_guard(
     sender: Callable[[str], Awaitable[None]],
     *,
     raw_sender: Optional[Callable[[str], Awaitable[None]]] = None,
+    fallback_payload: Optional[str] = None,
 ) -> str:
     try:
         await sender(text)
@@ -666,6 +691,19 @@ async def _send_with_markdown_guard(
         if not _is_markdown_parse_error(exc):
             raise
 
+        if fallback_payload and fallback_payload != text:
+            try:
+                await sender(fallback_payload)
+                worker_log.debug(
+                    "Markdown 优化回退为严格转义版本",
+                    extra={"length": len(fallback_payload)},
+                )
+                return fallback_payload
+            except TelegramBadRequest as fallback_exc:
+                if not _is_markdown_parse_error(fallback_exc):
+                    raise
+                exc = fallback_exc
+
         sanitized: Optional[str]
         if _IS_MARKDOWN_V2:
             sanitized = _escape_markdown_v2(text)
@@ -695,7 +733,7 @@ async def _send_with_markdown_guard(
             raise
 
         # Markdown 彻底失败时退回纯文本发送，需要先清理 MarkdownV2 转义符号
-        fallback_payload = _unescape_if_already_escaped(text)
+        fallback_payload = _force_unescape_markdown(text)
         if fallback_payload != text:
             worker_log.debug(
                 "Markdown 降级为纯文本发送，已移除转义符号",
@@ -762,7 +800,11 @@ async def reply_large_text(
     """
     bot = current_bot()
     parse_mode_value = parse_mode if parse_mode is not None else _parse_mode_value()
-    prepared = text if preformatted else _prepare_model_payload(text)
+    if preformatted:
+        prepared = text
+        fallback_payload = None
+    else:
+        prepared, fallback_payload = _prepare_model_payload_variants(text)
 
     async def _send_formatted_message(payload: str) -> None:
         await bot.send_message(
@@ -779,6 +821,7 @@ async def reply_large_text(
             prepared,
             _send_formatted_message,
             raw_sender=_send_raw_message,
+            fallback_payload=fallback_payload,
         )
 
         worker_log.info(
@@ -797,10 +840,12 @@ async def reply_large_text(
         f"内容较长，已生成附件 `{attachment_name}`，请下载查看全文。"
     )
 
+    summary_prepared, summary_fallback = _prepare_model_payload_variants(summary_text)
     delivered_summary = await _send_with_markdown_guard(
-        summary_text,
+        summary_prepared,
         _send_formatted_message,
         raw_sender=_send_raw_message,
+        fallback_payload=summary_fallback,
     )
 
     document = BufferedInputFile(text.encode("utf-8"), filename=attachment_name)
@@ -1514,7 +1559,7 @@ async def _broadcast_worker_keyboard(bot: Bot) -> None:
             continue
 
         parse_mode = _parse_mode_value()
-        prepared = _prepare_model_payload(text)
+        prepared, fallback_payload = _prepare_model_payload_variants(text)
 
         async def _send_formatted(payload: str) -> None:
             await bot.send_message(
@@ -1537,6 +1582,7 @@ async def _broadcast_worker_keyboard(bot: Bot) -> None:
                 prepared,
                 _send_formatted,
                 raw_sender=_send_raw,
+                fallback_payload=fallback_payload,
             )
         except TelegramForbiddenError as exc:
             worker_log.warning("推送任务列表被拒绝：%s", exc, extra={**_session_extra(), "chat": chat_id})
@@ -2794,13 +2840,32 @@ async def _answer_with_markdown(
     *,
     reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | None = None,
 ) -> Optional[Message]:
-    prepared = _prepare_model_payload(text)
-    try:
-        sent = await message.answer(
-            prepared,
+    prepared, fallback_payload = _prepare_model_payload_variants(text)
+    sent_message: Optional[Message] = None
+
+    async def _send(payload: str) -> None:
+        nonlocal sent_message
+        sent_message = await message.answer(
+            payload,
             parse_mode=_parse_mode_value(),
             reply_markup=reply_markup,
         )
+
+    async def _send_raw(payload: str) -> None:
+        nonlocal sent_message
+        sent_message = await message.answer(
+            payload,
+            parse_mode=None,
+            reply_markup=reply_markup,
+        )
+
+    try:
+        await _send_with_markdown_guard(
+            prepared,
+            _send,
+            raw_sender=_send_raw,
+            fallback_payload=fallback_payload,
+        )
     except TelegramBadRequest as exc:
         worker_log.warning(
             "发送消息失败：%s",
@@ -2808,7 +2873,7 @@ async def _answer_with_markdown(
             extra={"chat": getattr(message.chat, "id", None)},
         )
         return None
-    return sent
+    return sent_message
 
 
 async def _edit_message_with_markdown(
@@ -2817,11 +2882,27 @@ async def _edit_message_with_markdown(
     *,
     reply_markup: InlineKeyboardMarkup | None = None,
 ) -> None:
-    prepared = _prepare_model_payload(text)
-    await callback.message.edit_text(
+    prepared, fallback_payload = _prepare_model_payload_variants(text)
+
+    async def _send(payload: str) -> None:
+        await callback.message.edit_text(
+            payload,
+            parse_mode=_parse_mode_value(),
+            reply_markup=reply_markup,
+        )
+
+    async def _send_raw(payload: str) -> None:
+        await callback.message.edit_text(
+            payload,
+            parse_mode=None,
+            reply_markup=reply_markup,
+        )
+
+    await _send_with_markdown_guard(
         prepared,
-        parse_mode=_parse_mode_value(),
-        reply_markup=reply_markup,
+        _send,
+        raw_sender=_send_raw,
+        fallback_payload=fallback_payload,
     )
 
 
@@ -2833,13 +2914,29 @@ async def _try_edit_message(
 ) -> bool:
     if message is None:
         return False
-    prepared = _prepare_model_payload(text)
-    try:
+    prepared, fallback_payload = _prepare_model_payload_variants(text)
+
+    async def _send(payload: str) -> None:
         await message.edit_text(
-            prepared,
+            payload,
             parse_mode=_parse_mode_value(),
             reply_markup=reply_markup,
         )
+
+    async def _send_raw(payload: str) -> None:
+        await message.edit_text(
+            payload,
+            parse_mode=None,
+            reply_markup=reply_markup,
+        )
+
+    try:
+        await _send_with_markdown_guard(
+            prepared,
+            _send,
+            raw_sender=_send_raw,
+            fallback_payload=fallback_payload,
+        )
         return True
     except TelegramBadRequest as exc:
         worker_log.info(

{vibego-0.2.35 → vibego-0.2.37}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vibego"
-version = "0.2.35"
+version = "0.2.37"
 description = "vibego CLI：用于初始化与管理 Telegram Master Bot 的工具"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -42,7 +42,7 @@ include = ["vibego_cli", "tasks", "scripts", "telegram_markdown"]
 "scripts" = ["*.sh", "models/*.sh"]
 
 [tool.bumpversion]
-current_version = "0.2.35"
+current_version = "0.2.37"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

vibego-0.2.37/tests/test_markdown_guard.py

@@ -0,0 +1,92 @@
+"""验证 Markdown 降级为纯文本时的反转义逻辑。"""
+
+from __future__ import annotations
+
+import pytest
+from aiogram.exceptions import TelegramBadRequest
+from aiogram.methods.base import TelegramMethod
+
+import bot
+
+
+@pytest.mark.asyncio()
+async def test_markdown_guard_plain_fallback_removes_escapes() -> None:
+    """确保回退纯文本时不会残留 MarkdownV2 转义反斜杠。"""
+
+    delivered: list[str] = []
+
+    class _DummyMethod(TelegramMethod):
+        """构造最小化的 TelegramMethod 以便创建异常对象。"""
+
+        __returning__ = bool
+
+        @property
+        def __api_method__(self) -> str:
+            return "testMethod"
+
+        def build_response(self, data, bot):  # pragma: no cover - 测试不会触发
+            return True
+
+        def build_request(self, bot):  # pragma: no cover - 测试不会触发
+            return "testMethod", {}
+
+    async def _failing_sender(_: str) -> None:
+        raise TelegramBadRequest(_DummyMethod(), "Bad Request: can't parse entities")
+
+    async def _raw_sender(payload: str) -> None:
+        delivered.append(payload)
+
+    original = "测试 \\_Markdown\\_ 转义"
+    result = await bot._send_with_markdown_guard(original, _failing_sender, raw_sender=_raw_sender)
+
+    assert delivered and delivered[0] == "测试 _Markdown_ 转义"
+    assert result == "测试 _Markdown_ 转义"
+
+
+@pytest.mark.asyncio()
+@pytest.mark.parametrize(
+    ("original", "expected"),
+    [
+        ("条目 A\\)", "条目 A)"),
+        ("任务编码：/TASK\\_0022", "任务编码：/TASK_0022"),
+        ("配置文件 config\\.json", "配置文件 config.json"),
+        ("版本号 3\\.11\\.4", "版本号 3.11.4"),
+        ("保留连字符 use\\-case", "保留连字符 use-case"),
+        ("强调 \\*重要\\*", "强调 *重要*"),
+        ("变量 \\_value\\_", "变量 _value_"),
+        ("选项 A\\|B", "选项 A|B"),
+        ("集合 \\{a, b\\}", "集合 {a, b}"),
+        ("说明 test\\.", "说明 test."),
+    ],
+)
+async def test_markdown_guard_plain_fallback_force_unescape(
+    original: str,
+    expected: str,
+) -> None:
+    """验证强制反转义可处理只有单个转义符的场景。"""
+
+    delivered: list[str] = []
+
+    class _DummyMethod(TelegramMethod):
+        __returning__ = bool
+
+        @property
+        def __api_method__(self) -> str:
+            return "testMethod"
+
+        def build_response(self, data, bot):  # pragma: no cover - 测试不会触发
+            return True
+
+        def build_request(self, bot):  # pragma: no cover - 测试不会触发
+            return "testMethod", {}
+
+    async def _failing_sender(_: str) -> None:
+        raise TelegramBadRequest(_DummyMethod(), "Bad Request: can't parse entities")
+
+    async def _raw_sender(payload: str) -> None:
+        delivered.append(payload)
+
+    result = await bot._send_with_markdown_guard(original, _failing_sender, raw_sender=_raw_sender)
+
+    assert delivered and delivered[0] == expected
+    assert result == expected

{vibego-0.2.35 → vibego-0.2.37}/tests/test_telegram_markdown_renderer.py

@@ -1,5 +1,6 @@
-from pathlib import Path
 import sys
+import os
+from pathlib import Path
 
 sys.path.append(str(Path(__file__).resolve().parents[1]))
 
@@ -7,6 +8,10 @@ import pytest
 
 from telegram_markdown import render_markdown_to_telegram
 
+os.environ.setdefault("BOT_TOKEN", "dummy")
+
+from bot import _prepare_model_payload, _prepare_model_payload_variants  # noqa: E402
+
 
 @pytest.mark.parametrize(
     "source, expected",
@@ -56,3 +61,36 @@ def test_render_blockquote() -> None:
 def test_render_link() -> None:
     markdown = "[link](https://example.com/path?a=1&b=2)"
     assert render_markdown_to_telegram(markdown) == "[link](https://example.com/path?a=1&b=2)"
+
+
+@pytest.mark.parametrize(
+    "text, expect_primary, expect_change",
+    [
+        ("A. 采用方案", "A. 采用方案", True),
+        ("示例.\n第二行", "示例.\n第二行", True),
+        ("- [ ] 待办事项", "- [ ] 待办事项", True),
+        ("- [ ] 待办事项\n- [ ] 第二条", "- [ ] 待办事项\n- [ ] 第二条", True),
+        ("任务编码：/TASK_0023", None, False),
+        ("纯文本，无需转义", None, False),
+        ("带内联代码 `A.` 示例", None, False),
+        ("```\nA. print\n```", None, False),
+        ("段落结束. 继续下一句", "段落结束. 继续下一句", True),
+        ("- [ ] 包含句点. 并继续", "- [ ] 包含句点. 并继续", True),
+    ],
+)
+def test_prepare_model_payload_variants(text: str, expect_primary: str | None, expect_change: bool) -> None:
+    primary, fallback = _prepare_model_payload_variants(text)
+    strict = _prepare_model_payload(text)
+    if expect_primary is not None:
+        assert primary == expect_primary
+    else:
+        assert primary == strict
+    if expect_change:
+        assert fallback is not None
+        assert fallback != primary
+        assert fallback == strict
+    else:
+        if fallback is None:
+            assert primary == strict
+        else:
+            assert fallback == primary == strict

{vibego-0.2.35 → vibego-0.2.37}/vibego.egg-info/PKG-INFO

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

{vibego-0.2.35 → vibego-0.2.37}/vibego_cli/__init__.py

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

vibego-0.2.35/tests/test_markdown_guard.py

@@ -1,43 +0,0 @@
-"""验证 Markdown 降级为纯文本时的反转义逻辑。"""
-
-from __future__ import annotations
-
-import pytest
-from aiogram.exceptions import TelegramBadRequest
-from aiogram.methods.base import TelegramMethod
-
-import bot
-
-
-@pytest.mark.asyncio()
-async def test_markdown_guard_plain_fallback_removes_escapes() -> None:
-    """确保回退纯文本时不会残留 MarkdownV2 转义反斜杠。"""
-
-    delivered: list[str] = []
-
-    class _DummyMethod(TelegramMethod):
-        """构造最小化的 TelegramMethod 以便创建异常对象。"""
-
-        __returning__ = bool
-
-        @property
-        def __api_method__(self) -> str:
-            return "testMethod"
-
-        def build_response(self, data, bot):  # pragma: no cover - 测试不会触发
-            return True
-
-        def build_request(self, bot):  # pragma: no cover - 测试不会触发
-            return "testMethod", {}
-
-    async def _failing_sender(_: str) -> None:
-        raise TelegramBadRequest(_DummyMethod(), "Bad Request: can't parse entities")
-
-    async def _raw_sender(payload: str) -> None:
-        delivered.append(payload)
-
-    original = "测试 \\_Markdown\\_ 转义"
-    result = await bot._send_with_markdown_guard(original, _failing_sender, raw_sender=_raw_sender)
-
-    assert delivered and delivered[0] == "测试 _Markdown_ 转义"
-    assert result == "测试 _Markdown_ 转义"