vibego 0.2.35__tar.gz → 0.2.42__tar.gz

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

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

{vibego-0.2.35 → vibego-0.2.42}/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(
@@ -482,7 +485,6 @@ _ESCAPED_CODE_BLOCK_PATTERN = re.compile(
     re.DOTALL
 )
 
-
 def _is_already_escaped(text: str) -> bool:
     """检测文本是否已经包含 MarkdownV2 转义字符。
 
@@ -504,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%）
@@ -534,77 +536,62 @@ 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)
-        return render_markdown_to_telegram(cleaned)
+        return _escape_markdown_v2(cleaned)
     if _IS_MARKDOWN:
         return _normalize_legacy_markdown(text)
     return text
 
 
+def _prepare_model_payload_variants(text: str) -> tuple[str, Optional[str]]:
+    """返回首选与备用内容，默认为单一格式。"""
+
+    payload = _prepare_model_payload(text)
+    return payload, None
+
+
 def _extract_bad_request_message(exc: TelegramBadRequest) -> str:
     message = getattr(exc, "message", None)
     if not message:
@@ -658,6 +645,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 +654,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)
@@ -694,20 +695,12 @@ async def _send_with_markdown_guard(
         if raw_sender is None:
             raise
 
-        # Markdown 彻底失败时退回纯文本发送，需要先清理 MarkdownV2 转义符号
-        fallback_payload = _unescape_if_already_escaped(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:
@@ -762,7 +755,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 +776,7 @@ async def reply_large_text(
             prepared,
             _send_formatted_message,
             raw_sender=_send_raw_message,
+            fallback_payload=fallback_payload,
         )
 
         worker_log.info(
@@ -797,10 +795,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 +1514,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 +1537,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})
@@ -2620,7 +2621,7 @@ def _build_status_buttons(task_id: str, current_status: str) -> list[list[Inline
     for status in STATUS_DISPLAY_ORDER:
         text = _format_status(status)
         if status == current_status:
-            text = f"👉 {text} (当前)"
+            text = f"{text} (当前)"
         row.append(
             InlineKeyboardButton(
                 text=text,
@@ -2794,13 +2795,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 +2828,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 +2837,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 +2869,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(
@@ -4197,6 +4249,7 @@ async def _deliver_pending_messages(
                     "chat": chat_id,
                 },
             )
+            return False
         else:
             worker_log.info(
                 "模型输出已发送且计划完成",
@@ -4523,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:
@@ -4616,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={
@@ -4637,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={
@@ -4652,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(
@@ -4688,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.35 → vibego-0.2.42}/pyproject.toml

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

{vibego-0.2.35 → vibego-0.2.42}/tests/test_long_poll_mechanism.py

@@ -50,11 +50,13 @@ def reset_global_state():
     bot.SESSION_OFFSETS.clear()
     bot.CHAT_DELIVERED_HASHES.clear()
     bot.CHAT_DELIVERED_OFFSETS.clear()
+    bot.CHAT_LONG_POLL_LOCK = None
     yield
     bot.CHAT_LONG_POLL_STATE.clear()
     bot.SESSION_OFFSETS.clear()
     bot.CHAT_DELIVERED_HASHES.clear()
     bot.CHAT_DELIVERED_OFFSETS.clear()
+    bot.CHAT_LONG_POLL_LOCK = None
 
 
 # ============================================================================
@@ -72,7 +74,7 @@ def test_interrupt_long_poll_sets_flag():
         "interrupted": False,
     }
 
-    bot._interrupt_long_poll(chat_id)
+    asyncio.run(bot._interrupt_long_poll(chat_id))
 
     assert bot.CHAT_LONG_POLL_STATE[chat_id]["interrupted"] is True
 
@@ -84,7 +86,7 @@ def test_interrupt_long_poll_no_state():
     bot.CHAT_LONG_POLL_STATE.pop(chat_id, None)
 
     # 不应抛出异常
-    bot._interrupt_long_poll(chat_id)
+    asyncio.run(bot._interrupt_long_poll(chat_id))
 
 
 # ============================================================================
@@ -126,7 +128,7 @@ async def test_watch_and_notify_enters_long_poll_after_first_delivery(mock_sessi
     chat_id = 12345
     delivery_count = 0
 
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         nonlocal delivery_count
         delivery_count += 1
         # 第一次返回 True（首次发送成功）
@@ -151,10 +153,10 @@ async def test_watch_and_notify_enters_long_poll_after_first_delivery(mock_sessi
         assert chat_id in bot.CHAT_LONG_POLL_STATE
         assert bot.CHAT_LONG_POLL_STATE[chat_id]["active"] is True
         assert bot.CHAT_LONG_POLL_STATE[chat_id]["round"] == 0
-        assert bot.CHAT_LONG_POLL_STATE[chat_id]["max_rounds"] == 10
+        assert bot.CHAT_LONG_POLL_STATE[chat_id]["max_rounds"] == 600
 
         # 中断任务（避免等待 3 分钟）
-        bot._interrupt_long_poll(chat_id)
+        await bot._interrupt_long_poll(chat_id)
         await asyncio.sleep(0.1)
 
         # 取消任务
@@ -173,7 +175,7 @@ async def test_watch_and_notify_long_poll_increments_round(mock_session_path):
     chat_id = 12345
     delivery_count = 0
 
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         nonlocal delivery_count
         delivery_count += 1
         # 第一次返回 True，之后返回 False
@@ -204,7 +206,7 @@ async def test_watch_and_notify_long_poll_increments_round(mock_session_path):
         await asyncio.sleep(0.3)
 
         # 中断并清理
-        bot._interrupt_long_poll(chat_id)
+        await bot._interrupt_long_poll(chat_id)
         await asyncio.sleep(0.1)
         task.cancel()
         try:
@@ -221,7 +223,7 @@ async def test_watch_and_notify_interrupted_by_new_message(mock_session_path):
     chat_id = 12345
     delivery_count = 0
 
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         nonlocal delivery_count
         delivery_count += 1
         return delivery_count == 1  # 只第一次返回 True
@@ -241,7 +243,7 @@ async def test_watch_and_notify_interrupted_by_new_message(mock_session_path):
         assert chat_id in bot.CHAT_LONG_POLL_STATE
 
         # 模拟新消息到达，中断轮询
-        bot._interrupt_long_poll(chat_id)
+        await bot._interrupt_long_poll(chat_id)
 
         # 等待任务检测到中断标志并退出
         await asyncio.sleep(0.2)
@@ -267,7 +269,7 @@ async def test_watch_and_notify_long_poll_resets_on_new_delivery(mock_session_pa
     delivery_sequence = [True, False, False, True, False]  # 第 1 和第 4 次有消息
     delivery_index = 0
 
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         nonlocal delivery_index
         result = delivery_sequence[delivery_index] if delivery_index < len(delivery_sequence) else False
         delivery_index += 1
@@ -291,7 +293,7 @@ async def test_watch_and_notify_long_poll_resets_on_new_delivery(mock_session_pa
         await asyncio.sleep(0.25)
 
         # 中断并清理
-        bot._interrupt_long_poll(chat_id)
+        await bot._interrupt_long_poll(chat_id)
         await asyncio.sleep(0.1)
         task.cancel()
         try:
@@ -316,11 +318,11 @@ def test_interrupt_long_poll_idempotent():
     }
 
     # 第一次调用
-    bot._interrupt_long_poll(chat_id)
+    asyncio.run(bot._interrupt_long_poll(chat_id))
     assert bot.CHAT_LONG_POLL_STATE[chat_id]["interrupted"] is True
 
     # 第二次调用（应该仍然是 True，不报错）
-    bot._interrupt_long_poll(chat_id)
+    asyncio.run(bot._interrupt_long_poll(chat_id))
     assert bot.CHAT_LONG_POLL_STATE[chat_id]["interrupted"] is True
 
 
@@ -335,7 +337,7 @@ async def test_watch_and_notify_max_rounds_limit(mock_session_path):
     chat_id = 12345
 
     # 修改最大轮询次数为 2（便于测试）
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         # 只在第一次返回 True，进入延迟轮询
         # 后续返回 False，让轮询计数递增
         if not hasattr(mock_deliver, "called"):
@@ -362,7 +364,7 @@ async def test_watch_and_notify_does_not_block_event_loop(mock_session_path):
     """
     chat_id = 12345
 
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         return False
 
     with patch.object(bot, "_deliver_pending_messages", side_effect=mock_deliver):
@@ -397,3 +399,4 @@ async def test_watch_and_notify_does_not_block_event_loop(mock_session_path):
             await task
         except asyncio.CancelledError:
             pass
+import asyncio