typing 修复

src/chat/heart_flow/heartFC_chat.py

@@ -183,7 +183,7 @@ class HeartFChatting:
         self.talk_threshold = think_len
         logger.info(f"{self.log_prefix} 思考频率阈值: {self.talk_threshold}")
 
-    async def _loopbody(self):
+    async def _loopbody(self):  # sourcery skip: hoist-if-from-if
         recent_messages_list = message_api.get_messages_by_time_in_chat(
             chat_id=self.stream_id,
             start_time=self.last_read_time,
@@ -195,11 +195,15 @@ class HeartFChatting:
         )
 
         if len(recent_messages_list) >= self.talk_threshold:
-            
             # !处理no_reply_until_call逻辑
             if self.no_reply_until_call:
                 for message in recent_messages_list:
-                    if message.is_mentioned or message.is_at or len(recent_messages_list) >= 8 or time.time() - self.last_read_time > 600:
+                    if (
+                        message.is_mentioned
+                        or message.is_at
+                        or len(recent_messages_list) >= 8
+                        or time.time() - self.last_read_time > 600
+                    ):
                         self.no_reply_until_call = False
                         break
                 # 没有提到，继续保持沉默
@@ -208,7 +212,6 @@ class HeartFChatting:
                     await asyncio.sleep(1)
                     return True
 
-            
             self.last_read_time = time.time()
             await self._observe(
                 recent_messages_list=recent_messages_list,
@@ -271,9 +274,9 @@ class HeartFChatting:
         return loop_info, reply_text, cycle_timers
 
     async def _observe(
-        self, # interest_value: float = 0.0, 
+        self,  # interest_value: float = 0.0,
-        recent_messages_list: Optional[List["DatabaseMessages"]] = None
+        recent_messages_list: Optional[List["DatabaseMessages"]] = None,
-    ) -> bool:
+    ) -> bool:  # sourcery skip: merge-else-if-into-elif, remove-redundant-if
         if recent_messages_list is None:
             recent_messages_list = []
         reply_text = ""  # 初始化reply_text变量，避免UnboundLocalError
@@ -327,14 +330,12 @@ class HeartFChatting:
             if modified_message and modified_message._modify_flags.modify_llm_prompt:
                 prompt_info = (modified_message.llm_prompt, prompt_info[1])
 
-                
             with Timer("规划器", cycle_timers):
                 action_to_use_info, _ = await self.action_planner.plan(
                     loop_start_time=self.last_read_time,
                     available_actions=available_actions,
                 )
 
-            
             # !此处使at或者提及必定回复
             metioned_message = None
             for message in recent_messages_list:
@@ -344,7 +345,7 @@ class HeartFChatting:
             has_reply = False
             for action in action_to_use_info:
                 if action.action_type == "reply":
-                    has_reply =True
+                    has_reply = True
                     break
 
             if not has_reply and metioned_message:
@@ -358,7 +359,6 @@ class HeartFChatting:
                     )
                 )
 
-
             # 3. 并行执行所有动作
             action_tasks = [
                 asyncio.create_task(
@@ -521,10 +521,9 @@ class HeartFChatting:
         reply_text = ""
         first_replied = False
         for reply_content in reply_set.reply_data:
-            
             if reply_content.content_type != ReplyContentType.TEXT:
                 continue
-            data: str = reply_content.content # type: ignore
+            data: str = reply_content.content  # type: ignore
             if not first_replied:
                 await send_api.text_to_stream(
                     text=data,
@@ -576,6 +575,7 @@ class HeartFChatting:
                 return {"action_type": "no_action", "success": True, "reply_text": "", "command": ""}
 
             elif action_planner_info.action_type == "wait_time":
+                action_planner_info.action_data = action_planner_info.action_data or {}
                 logger.info(f"{self.log_prefix} 等待{action_planner_info.action_data['time']}秒后回复")
                 await asyncio.sleep(action_planner_info.action_data["time"])
                 return {"action_type": "wait_time", "success": True, "reply_text": "", "command": ""}

src/chat/heart_flow/heartflow_message_processor.py

@@ -10,7 +10,6 @@ from src.chat.message_receive.message import MessageRecv
 from src.chat.message_receive.storage import MessageStorage
 from src.chat.heart_flow.heartflow import heartflow
 from src.chat.utils.utils import is_mentioned_bot_in_message
-from src.chat.utils.timer_calculator import Timer
 from src.chat.utils.chat_message_builder import replace_user_references
 from src.common.logger import get_logger
 from src.mood.mood_manager import mood_manager
@@ -36,7 +35,7 @@ async def _calculate_interest(message: MessageRecv) -> Tuple[float, list[str]]:
         return 0.0, []
 
     is_mentioned, is_at, reply_probability_boost = is_mentioned_bot_in_message(message)
-    interested_rate = 0.0
+    # interested_rate = 0.0
     keywords = []
     # with Timer("记忆激活"):
     #     interested_rate, keywords, keywords_lite = await hippocampus_manager.get_activate_from_text(
@@ -153,10 +152,10 @@ class HeartFCMessageReceiver:
             logger.info(f"[{mes_name}]{userinfo.user_nickname}:{processed_plain_text}[{interested_rate:.2f}]")  # type: ignore
 
             _ = Person.register_person(
-                platform=message.message_info.platform,
+                platform=message.message_info.platform,  # type: ignore
-                user_id=message.message_info.user_info.user_id,
+                user_id=message.message_info.user_info.user_id,  # type: ignore
-                nickname=userinfo.user_nickname,
+                nickname=userinfo.user_nickname,  # type: ignore
-            )  # type: ignore
+            )
 
         except Exception as e:
             logger.error(f"消息处理失败: {e}")

src/chat/planner_actions/planner.py

@@ -22,12 +22,12 @@ from src.chat.utils.chat_message_builder import (
 from src.chat.utils.utils import get_chat_type_and_target_info
 from src.chat.planner_actions.action_manager import ActionManager
 from src.chat.message_receive.chat_stream import get_chat_manager
-from src.plugin_system.base.component_types import ActionInfo, ChatMode, ComponentType, ActionActivationType
+from src.plugin_system.base.component_types import ActionInfo, ComponentType, ActionActivationType
 from src.plugin_system.core.component_registry import component_registry
 
 if TYPE_CHECKING:
     from src.common.data_models.info_data_model import TargetPersonInfo
-    from src.common.data_models.database_data_model import DatabaseMessages, DatabaseActionRecords
+    from src.common.data_models.database_data_model import DatabaseMessages
 
 logger = get_logger("planner")
 
@@ -121,7 +121,6 @@ no_reply_until_call
     )
 
 
-
 class ActionPlanner:
     def __init__(self, chat_id: str, action_manager: ActionManager):
         self.chat_id = chat_id
@@ -180,7 +179,6 @@ class ActionPlanner:
                 target_message = message_id_list[-1][1]
                 logger.info(f"{self.log_prefix}动作'{action}'缺少target_message_id，使用最新消息作为target_message")
 
-
             # 验证action是否可用
             available_action_names = [action_name for action_name, _ in current_available_actions]
             internal_action_names = ["no_reply", "reply", "wait_time", "no_reply_until_call"]
@@ -223,18 +221,17 @@ class ActionPlanner:
 
         return action_planner_infos
 
-
     async def plan(
         self,
         available_actions: Dict[str, ActionInfo],
         loop_start_time: float = 0.0,
     ) -> Tuple[List[ActionPlannerInfo], Optional["DatabaseMessages"]]:
+        # sourcery skip: use-named-expression
         """
         规划器 (Planner): 使用LLM根据上下文决定做出什么动作。
         """
         target_message: Optional["DatabaseMessages"] = None
 
-        
         # 获取聊天上下文
         message_list_before_now = get_raw_msg_before_timestamp_with_chat(
             chat_id=self.chat_id,
@@ -264,9 +261,7 @@ class ActionPlanner:
         is_group_chat, chat_target_info, current_available_actions = self.get_necessary_info()
 
         # 应用激活类型过滤
-        filtered_actions = self._filter_actions_by_activation_type(
+        filtered_actions = self._filter_actions_by_activation_type(available_actions, chat_content_block_short)
-            available_actions, chat_content_block_short
-        )
 
         logger.info(f"{self.log_prefix}过滤后有{len(filtered_actions)}个可用动作")
 
@@ -286,7 +281,7 @@ class ActionPlanner:
             message_id_list=message_id_list,
             filtered_actions=filtered_actions,
             available_actions=available_actions,
-            loop_start_time=loop_start_time
+            loop_start_time=loop_start_time,
         )
 
         # 获取target_message（如果有非no_action的动作）
@@ -333,7 +328,9 @@ class ActionPlanner:
             moderation_prompt_block = "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。"
             time_block = f"当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
             bot_name = global_config.bot.nickname
-            bot_nickname = f",也有人叫你{','.join(global_config.bot.alias_names)}" if global_config.bot.alias_names else ""
+            bot_nickname = (
+                f",也有人叫你{','.join(global_config.bot.alias_names)}" if global_config.bot.alias_names else ""
+            )
             name_block = f"你的名字是{bot_name}{bot_nickname}，请注意哪些是你自己的发言。"
 
             # 获取主规划器模板并填充
@@ -379,11 +376,8 @@ class ActionPlanner:
 
         return is_group_chat, chat_target_info, current_available_actions
 
-    
     def _filter_actions_by_activation_type(
-        self, 
+        self, available_actions: Dict[str, ActionInfo], chat_content_block: str
-        available_actions: Dict[str, ActionInfo], 
-        chat_content_block: str
     ) -> Dict[str, ActionInfo]:
         """根据激活类型过滤动作"""
         filtered_actions = {}
@@ -409,6 +403,7 @@ class ActionPlanner:
         return filtered_actions
 
     async def _build_action_options_block(self, current_available_actions: Dict[str, ActionInfo]) -> str:
+        # sourcery skip: use-join
         """构建动作选项块"""
         if not current_available_actions:
             return ""
@@ -448,7 +443,7 @@ class ActionPlanner:
         message_id_list: List[Tuple[str, "DatabaseMessages"]],
         filtered_actions: Dict[str, ActionInfo],
         available_actions: Dict[str, ActionInfo],
-        loop_start_time: float
+        loop_start_time: float,
     ) -> List[ActionPlannerInfo]:
         """执行主规划器"""
         llm_content = None
@@ -487,16 +482,11 @@ class ActionPlanner:
         # 解析LLM响应
         if llm_content:
             try:
-                # 处理新的格式：多个```json包裹的JSON对象
+                if json_objects := self._extract_json_from_markdown(llm_content):
-                json_objects = self._extract_json_from_markdown(llm_content)
-                
-                if json_objects:
                     logger.info(f"{self.log_prefix}从响应中提取到{len(json_objects)}个JSON对象")
                     filtered_actions_list = list(filtered_actions.items())
                     for json_obj in json_objects:
-                        actions.extend(
+                        actions.extend(self._parse_single_action(json_obj, message_id_list, filtered_actions_list))
-                            self._parse_single_action(json_obj, message_id_list, filtered_actions_list)
-                        )
                 else:
                     # 尝试解析为直接的JSON
                     logger.warning(f"{self.log_prefix}LLM没有返回可用动作: {llm_content}")
@@ -509,12 +499,14 @@ class ActionPlanner:
         else:
             actions = self._create_no_reply("规划器没有获得LLM响应", available_actions)
 
-        
         # 添加循环开始时间到所有非no_action动作
         for action in actions:
+            action.action_data = action.action_data or {}
             action.action_data["loop_start_time"] = loop_start_time
 
-        logger.info(f"{self.log_prefix}规划器决定执行{len(actions)}个动作: {' '.join([a.action_type for a in actions])}")
+        logger.info(
+            f"{self.log_prefix}规划器决定执行{len(actions)}个动作: {' '.join([a.action_type for a in actions])}"
+        )
 
         return actions
 
@@ -531,21 +523,20 @@ class ActionPlanner:
         ]
 
     def _extract_json_from_markdown(self, content: str) -> List[dict]:
+        # sourcery skip: for-append-to-extend
         """从Markdown格式的内容中提取JSON对象"""
         json_objects = []
 
         # 使用正则表达式查找```json包裹的JSON内容
-        json_pattern = r'```json\s*(.*?)\s*```'
+        json_pattern = r"```json\s*(.*?)\s*```"
         matches = re.findall(json_pattern, content, re.DOTALL)
 
         for match in matches:
             try:
                 # 清理可能的注释和格式问题
-                json_str = re.sub(r'//.*?\n', '\n', match)  # 移除单行注释
+                json_str = re.sub(r"//.*?\n", "\n", match)  # 移除单行注释
-                json_str = re.sub(r'/\*.*?\*/', '', json_str, flags=re.DOTALL)  # 移除多行注释
+                json_str = re.sub(r"/\*.*?\*/", "", json_str, flags=re.DOTALL)  # 移除多行注释
-                json_str = json_str.strip()
+                if json_str := json_str.strip():
-                
-                if json_str:
                     json_obj = json.loads(repair_json(json_str))
                     if isinstance(json_obj, dict):
                         json_objects.append(json_obj)

src/common/data_models/info_data_model.py

@@ -23,3 +23,4 @@ class ActionPlannerInfo(BaseDataModel):
     action_data: Optional[Dict] = None
     action_message: Optional["DatabaseMessages"] = None
     available_actions: Optional[Dict[str, "ActionInfo"]] = None
+    loop_start_time: Optional[float] = None

src/config/official_configs.py

@@ -72,9 +72,6 @@ class ChatConfig(ConfigBase):
     interest_rate_mode: Literal["fast", "accurate"] = "fast"
     """兴趣值计算模式，fast为快速计算，accurate为精确计算"""
 
-    mentioned_bot_reply: float = 1
-    """提及 bot 必然回复，1为100%回复，0为不额外增幅"""
-
     planner_size: float = 1.5
     """副规划器大小，越小，麦麦的动作执行能力越精细，但是消耗更多token，调大可以缓解429类错误"""
 

src/main.py

@@ -142,13 +142,13 @@ class MainSystem:
 
             await asyncio.gather(*tasks)
 
-    async def forget_memory_task(self):
+    # async def forget_memory_task(self):
-        """记忆遗忘任务"""
+    #     """记忆遗忘任务"""
-        while True:
+    #     while True:
-            await asyncio.sleep(global_config.memory.forget_memory_interval)
+    #         await asyncio.sleep(global_config.memory.forget_memory_interval)
-            logger.info("[记忆遗忘] 开始遗忘记忆...")
+    #         logger.info("[记忆遗忘] 开始遗忘记忆...")
-            await self.hippocampus_manager.forget_memory(percentage=global_config.memory.memory_forget_percentage)  # type: ignore
+    #         await self.hippocampus_manager.forget_memory(percentage=global_config.memory.memory_forget_percentage)  # type: ignore
-            logger.info("[记忆遗忘] 记忆遗忘完成")
+    #         logger.info("[记忆遗忘] 记忆遗忘完成")
 
 
 async def main():

src/plugins/built_in/relation/relation.py

@@ -179,7 +179,7 @@ class BuildRelationAction(BaseAction):
             chat_model_config = models.get("utils")
             success, update_memory, _, _ = await llm_api.generate_with_model(
                 prompt,
-                model_config=chat_model_config,
+                model_config=chat_model_config,  # type: ignore
                 request_type="relation.category.update",  # type: ignore
             )