fix(platform):address-dedup-review-feedback-for-qqofficial

Author: 001VIsir

astrbot/core/event_bus.py

@@ -11,12 +11,14 @@
 """
 
 import asyncio
-import hashlib
 from asyncio import Queue
 
 from astrbot.core import logger
 from astrbot.core.astrbot_config_mgr import AstrBotConfigManager
-from astrbot.core.message.utils import build_component_dedup_signature
+from astrbot.core.message.utils import (
+    build_event_content_dedup_key,
+    build_event_message_id_dedup_key,
+)
 from astrbot.core.pipeline.scheduler import PipelineScheduler
 from astrbot.core.utils.number_utils import safe_positive_float
 from astrbot.core.utils.ttl_registry import TTLKeyRegistry
@@ -31,53 +33,9 @@ class EventDeduplicator:
     and message ID, with configurable TTL window.
     """
 
-    _MAX_RAW_TEXT_FINGERPRINT_LEN = 256
-
     def __init__(self, ttl_seconds: float = 0.5) -> None:
         self._registry = TTLKeyRegistry(ttl_seconds)
 
-    def _build_attachment_signature(self, event: AstrMessageEvent) -> str:
-        """Build attachment signature for deduplication."""
-        return build_component_dedup_signature(event.get_messages())
-
-    def _build_content_key(self, event: AstrMessageEvent) -> str:
-        """Build content-based deduplication key."""
-        msg_text = (event.get_message_str() or "").strip()
-        if len(msg_text) <= self._MAX_RAW_TEXT_FINGERPRINT_LEN:
-            msg_sig = msg_text
-        else:
-            msg_hash = hashlib.sha1(msg_text.encode("utf-8")).hexdigest()[:16]
-            msg_sig = f"h:{len(msg_text)}:{msg_hash}"
-
-        attach_sig = self._build_attachment_signature(event)
-        return "|".join([
-            "content",
-            event.get_platform_id() or "",
-            event.unified_msg_origin or "",
-            event.get_sender_id() or "",
-            msg_sig,
-            attach_sig,
-        ])
-
-    def _build_message_id_key(self, event: AstrMessageEvent) -> str | None:
-        """Build message ID-based deduplication key.
-
-        Falls back to message_obj.id if message_id is not available.
-        """
-        # Try message_id first
-        message_id = str(getattr(event.message_obj, "message_id", "") or "")
-        # Fallback to id if message_id is not available
-        if not message_id:
-            message_id = str(getattr(event.message_obj, "id", "") or "")
-        if not message_id:
-            return None
-        return "|".join([
-            "message_id",
-            event.get_platform_id() or "",
-            event.unified_msg_origin or "",
-            message_id,
-        ])
-
     def is_duplicate(self, event: AstrMessageEvent) -> bool:
         """Check if the event is a duplicate.
 
@@ -89,7 +47,7 @@ def is_duplicate(self, event: AstrMessageEvent) -> bool:
             return False
 
         # Short-circuit: check message_id first (cheap) before computing full content key (expensive)
-        message_id_key = self._build_message_id_key(event)
+        message_id_key = build_event_message_id_dedup_key(event)
         if message_id_key is not None:
             if self._registry.contains(message_id_key):
                 logger.debug(
@@ -102,7 +60,7 @@ def is_duplicate(self, event: AstrMessageEvent) -> bool:
             self._registry.add(message_id_key)
 
         # Only compute full content key if we get past message_id check
-        content_key = self._build_content_key(event)
+        content_key = build_event_content_dedup_key(event)
         if self._registry.contains(content_key):
             logger.debug(
                 "Skip duplicate event in event_bus (by content): umo=%s, sender=%s",

astrbot/core/message/utils.py

@@ -1,10 +1,17 @@
 """Message utilities for deduplication and component handling."""
 
 import hashlib
-from typing import Iterable
+from collections.abc import Iterable
+from typing import TYPE_CHECKING
 
 from astrbot.core.message.components import BaseMessageComponent, File, Image
 
+if TYPE_CHECKING:
+    from astrbot.core.platform import AstrMessageEvent
+
+
+_MAX_RAW_TEXT_FINGERPRINT_LEN = 256
+
 
 def build_component_dedup_signature(
     components: Iterable[BaseMessageComponent],
@@ -40,3 +47,56 @@ def build_component_dedup_signature(
 
     payload = "|".join(parts)
     return hashlib.sha1(payload.encode("utf-8")).hexdigest()[:16]
+
+
+def build_sender_content_dedup_key(content: str, sender_id: str) -> str | None:
+    """Build a sender+content hash key for short-window deduplication."""
+    if not (content and sender_id):
+        return None
+    content_hash = hashlib.sha1(content.encode("utf-8")).hexdigest()[:16]
+    return f"{sender_id}:{content_hash}"
+
+
+def build_event_content_dedup_key(event: "AstrMessageEvent") -> str:
+    """Build a content fingerprint key for EventBus deduplication."""
+    msg_text = str(event.get_message_str() or "").strip()
+    if len(msg_text) <= _MAX_RAW_TEXT_FINGERPRINT_LEN:
+        msg_sig = msg_text
+    else:
+        msg_hash = hashlib.sha1(msg_text.encode("utf-8")).hexdigest()[:16]
+        msg_sig = f"h:{len(msg_text)}:{msg_hash}"
+
+    attach_sig = build_component_dedup_signature(event.get_messages())
+    platform_id = str(event.get_platform_id() or "")
+    unified_msg_origin = str(event.unified_msg_origin or "")
+    sender_id = str(event.get_sender_id() or "")
+    return "|".join(
+        [
+            "content",
+            platform_id,
+            unified_msg_origin,
+            sender_id,
+            msg_sig,
+            attach_sig,
+        ]
+    )
+
+
+def build_event_message_id_dedup_key(event: "AstrMessageEvent") -> str | None:
+    """Build a message_id fingerprint key for EventBus deduplication."""
+    message_id = str(getattr(event.message_obj, "message_id", "") or "")
+    if not message_id:
+        message_id = str(getattr(event.message_obj, "id", "") or "")
+    if not message_id:
+        return None
+
+    platform_id = str(event.get_platform_id() or "")
+    unified_msg_origin = str(event.unified_msg_origin or "")
+    return "|".join(
+        [
+            "message_id",
+            platform_id,
+            unified_msg_origin,
+            message_id,
+        ]
+    )

astrbot/core/platform/sources/qqofficial/qqofficial_platform_adapter.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import hashlib
 import logging
 import os
 import random
@@ -23,6 +22,7 @@
     PlatformMetadata,
 )
 from astrbot.core.message.components import BaseMessageComponent
+from astrbot.core.message.utils import build_sender_content_dedup_key
 from astrbot.core.platform.astr_message_event import MessageSesion
 from astrbot.core.utils.number_utils import safe_positive_float
 from astrbot.core.utils.ttl_registry import TTLKeyRegistry
@@ -55,13 +55,22 @@ def _extract_sender_id(message) -> str:
     Returns:
         The sender ID as a string, or empty string if not found.
     """
-    if hasattr(message, "author") and hasattr(message.author, "user_openid"):
-        return str(message.author.user_openid)
-    if hasattr(message, "author") and hasattr(message.author, "member_openid"):
-        return str(message.author.member_openid)
-    if hasattr(message, "author") and hasattr(message.author, "id"):
-        return str(message.author.id)
-    return ""
+    author = getattr(message, "author", None)
+    if not author:
+        return ""
+
+    sender_id = (
+        getattr(author, "user_openid", None)
+        or getattr(author, "member_openid", None)
+        or getattr(author, "id", None)
+    )
+    if sender_id is None:
+        return ""
+
+    sender_id_str = str(sender_id).strip()
+    if not sender_id_str:
+        return ""
+    return sender_id_str
 
 
 class MessageDeduplicator:
@@ -82,10 +91,7 @@ def __init__(
         self._lock = asyncio.Lock()
 
     def _build_content_key(self, content: str, sender_id: str) -> str | None:
-        if not (content and sender_id):
-            return None
-        content_hash = hashlib.sha1(content.encode("utf-8")).hexdigest()[:16]
-        return f"{sender_id}:{content_hash}"
+        return build_sender_content_dedup_key(content, sender_id)
 
     async def is_duplicate(
         self,
@@ -94,24 +100,35 @@ async def is_duplicate(
         sender_id: str = "",
     ) -> bool:
         async with self._lock:
-            # Bypass deduplication if TTL is 0 (disabled)
-            if self._message_ids.ttl_seconds == 0:
+            id_dedup_enabled = self._message_ids.ttl_seconds > 0 and bool(message_id)
+            content_dedup_enabled = self._content_keys.ttl_seconds > 0
+
+            if not id_dedup_enabled and not content_dedup_enabled:
                 return False
 
             # 1) ID-based dedup
-            if self._message_ids.contains(message_id):
-                logger.debug(
-                    "[QQOfficial] Duplicate message detected (by ID): %s...",
-                    message_id[:50],
-                )
-                return True
+            if id_dedup_enabled:
+                if self._message_ids.contains(message_id):
+                    logger.debug(
+                        "[QQOfficial] Duplicate message detected (by ID): %s...",
+                        message_id[:50],
+                    )
+                    return True
 
-            self._message_ids.add(message_id)
+                self._message_ids.add(message_id)
 
             # 2) Content-based dedup
+            if not content_dedup_enabled:
+                logger.debug(
+                    "[QQOfficial] New message registered: %s...", message_id[:50]
+                )
+                return False
+
             content_key = self._build_content_key(content, sender_id)
             if content_key is None:
-                logger.debug("[QQOfficial] New message registered: %s...", message_id[:50])
+                logger.debug(
+                    "[QQOfficial] New message registered: %s...", message_id[:50]
+                )
                 return False
 
             if self._content_keys.contains(content_key):
@@ -120,7 +137,8 @@ async def is_duplicate(
                     content_key,
                 )
                 # Preserve existing behavior: do not keep message_id on content duplicates
-                self._message_ids.discard(message_id)
+                if id_dedup_enabled:
+                    self._message_ids.discard(message_id)
                 return True
 
             self._content_keys.add(content_key)
@@ -132,21 +150,9 @@ class botClient(Client):
     def set_platform(self, platform: QQOfficialPlatformAdapter) -> None:
         self.platform = platform
 
-    def _get_sender_id(self, message) -> str:
-        """Extract sender ID from different message types.
-
-        Delegates to the centralized _extract_sender_id function to avoid
-        precedence drift.
-        """
-        return _extract_sender_id(message)
-
-    def _extract_dedup_key(self, message) -> tuple[str, str]:
-        sender_id = self._get_sender_id(message)
-        content = getattr(message, "content", "") or ""
-        return sender_id, content
-
     async def _should_drop_message(self, message) -> bool:
-        sender_id, content = self._extract_dedup_key(message)
+        sender_id = _extract_sender_id(message)
+        content = getattr(message, "content", "") or ""
         return await self.platform._is_duplicate_message(message.id, content, sender_id)
 
     # 收到群消息
@@ -596,11 +602,12 @@ def _parse_from_qqofficial(
             message,
             botpy.message.C2CMessage,
         ):
+            sender_user_id = _extract_sender_id(message)
             if isinstance(message, botpy.message.GroupMessage):
-                abm.sender = MessageMember(message.author.member_openid, "")
+                abm.sender = MessageMember(sender_user_id, "")
                 abm.group_id = message.group_openid
             else:
-                abm.sender = MessageMember(message.author.user_openid, "")
+                abm.sender = MessageMember(sender_user_id, "")
             # Parse face messages to readable text
             abm.message_str = QQOfficialPlatformAdapter._parse_face_message(
                 message.content.strip()