""" 命令处理器模块 负责处理语音命令并执行相应操作 """ import time import re from typing import Dict, Any, List, Optional, Callable import threading class CommandProcessor: """ 命令处理器 负责处理语音命令并执行相应操作 """ def __init__(self, plugin): """ 初始化命令处理器 Args: plugin: 语音控制插件实例 """ self.plugin = plugin self.enabled = False self.initialized = False # 命令映射 self.command_mappings = {} # 命令组 self.command_groups = {} # 命令历史 self.command_history = [] self.max_history_size = 1000 # 命令配置 self.command_config = { 'enable_fuzzy_matching': True, 'fuzzy_threshold': 0.7, 'enable_context_commands': True, 'context_timeout': 30.0, 'enable_chained_commands': True, 'max_chain_length': 5, 'enable_confirmation': True, 'confirmation_threshold': 0.9 } # 上下文管理 self.command_context = { 'current_context': 'default', 'context_stack': [], 'context_start_time': 0.0, 'context_variables': {} } # 命令链 self.command_chain = { 'is_active': False, 'commands': [], 'chain_start_time': 0.0 } # 统计信息 self.stats = { 'commands_processed': 0, 'commands_executed': 0, 'commands_failed': 0, 'fuzzy_matches': 0, 'exact_matches': 0, 'context_commands': 0, 'chained_commands': 0 } # 回调函数 self.command_callbacks = { 'command_received': [], 'command_processed': [], 'command_executed': [], 'command_failed': [], 'context_changed': [], 'chain_started': [], 'chain_completed': [] } # 时间戳记录 self.last_command_time = 0.0 self.last_context_change = 0.0 print("✓ 命令处理器已创建") def initialize(self) -> bool: """ 初始化命令处理器 Returns: 是否初始化成功 """ try: # 初始化默认命令映射 self._initialize_default_commands() # 初始化命令组 self._initialize_command_groups() self.initialized = True print("✓ 命令处理器初始化完成") return True except Exception as e: print(f"✗ 命令处理器初始化失败: {e}") import traceback traceback.print_exc() return False def enable(self) -> bool: """ 启用命令处理器 Returns: 是否启用成功 """ try: if not self.initialized: print("✗ 命令处理器未初始化") return False self.enabled = True print("✓ 命令处理器已启用") return True except Exception as e: print(f"✗ 命令处理器启用失败: {e}") import traceback traceback.print_exc() return False def disable(self): """禁用命令处理器""" try: self.enabled = False print("✓ 命令处理器已禁用") except Exception as e: print(f"✗ 命令处理器禁用失败: {e}") import traceback traceback.print_exc() def finalize(self): """清理命令处理器资源""" try: self.disable() self.command_mappings.clear() self.command_groups.clear() self.command_history.clear() self.command_callbacks.clear() self.initialized = False print("✓ 命令处理器资源已清理") except Exception as e: print(f"✗ 命令处理器资源清理失败: {e}") import traceback traceback.print_exc() def update(self, dt: float): """ 更新命令处理器状态 Args: dt: 时间增量 """ try: if not self.enabled: return current_time = time.time() self.last_command_time = current_time # 检查上下文超时 self._check_context_timeout(current_time) # 检查命令链超时 self._check_chain_timeout(current_time) except Exception as e: print(f"✗ 命令处理器更新失败: {e}") import traceback traceback.print_exc() def _initialize_default_commands(self): """初始化默认命令映射""" try: # 基础移动命令 self.register_command('前进', self._move_forward, 'movement', '向前移动') self.register_command('后退', self._move_backward, 'movement', '向后移动') self.register_command('左转', self._turn_left, 'movement', '向左转') self.register_command('右转', self._turn_right, 'movement', '向右转') self.register_command('停止', self._stop_movement, 'movement', '停止移动') # 系统控制命令 self.register_command('打开灯光', self._toggle_lights, 'system', '切换灯光状态') self.register_command('关闭灯光', self._toggle_lights, 'system', '切换灯光状态') self.register_command('增加音量', self._increase_volume, 'system', '增加系统音量') self.register_command('减少音量', self._decrease_volume, 'system', '减少系统音量') self.register_command('播放音乐', self._play_music, 'entertainment', '播放音乐') self.register_command('暂停播放', self._pause_music, 'entertainment', '暂停音乐播放') self.register_command('下一首', self._next_track, 'entertainment', '播放下一首') self.register_command('上一首', self._previous_track, 'entertainment', '播放上一首') # 交互命令 self.register_command('你好', self._greet_user, 'interaction', '打招呼') self.register_command('谢谢', self._acknowledge_thanks, 'interaction', '回应感谢') self.register_command('再见', self._say_goodbye, 'interaction', '道别') self.register_command('帮助', self._provide_help, 'interaction', '提供帮助信息') self.register_command('关于', self._show_about, 'interaction', '显示系统信息') print("✓ 默认命令映射初始化完成") except Exception as e: print(f"✗ 默认命令映射初始化失败: {e}") def _initialize_command_groups(self): """初始化命令组""" try: self.command_groups = { 'movement': { 'name': '移动控制', 'description': '控制物体移动的命令', 'commands': ['前进', '后退', '左转', '右转', '停止'] }, 'system': { 'name': '系统控制', 'description': '控制系统功能的命令', 'commands': ['打开灯光', '关闭灯光', '增加音量', '减少音量'] }, 'entertainment': { 'name': '娱乐控制', 'description': '控制娱乐功能的命令', 'commands': ['播放音乐', '暂停播放', '下一首', '上一首'] }, 'interaction': { 'name': '交互命令', 'description': '日常交互的命令', 'commands': ['你好', '谢谢', '再见', '帮助', '关于'] } } print("✓ 命令组初始化完成") except Exception as e: print(f"✗ 命令组初始化失败: {e}") def register_command(self, command_text: str, handler: Callable, group: str = 'default', description: str = '') -> bool: """ 注册命令 Args: command_text: 命令文本 handler: 命令处理函数 group: 命令组 description: 命令描述 Returns: 是否注册成功 """ try: self.command_mappings[command_text] = { 'handler': handler, 'group': group, 'description': description, 'registered_time': time.time() } # 添加到命令组 if group in self.command_groups: if command_text not in self.command_groups[group]['commands']: self.command_groups[group]['commands'].append(command_text) else: self.command_groups[group] = { 'name': group, 'description': f'命令组: {group}', 'commands': [command_text] } print(f"✓ 命令已注册: {command_text}") return True except Exception as e: print(f"✗ 命令注册失败: {e}") return False def unregister_command(self, command_text: str) -> bool: """ 注销命令 Args: command_text: 命令文本 Returns: 是否注销成功 """ try: if command_text in self.command_mappings: command_info = self.command_mappings[command_text] group = command_info['group'] # 从命令组中移除 if group in self.command_groups: if command_text in self.command_groups[group]['commands']: self.command_groups[group]['commands'].remove(command_text) del self.command_mappings[command_text] print(f"✓ 命令已注销: {command_text}") return True else: print(f"✗ 命令不存在: {command_text}") return False except Exception as e: print(f"✗ 命令注销失败: {e}") return False def process_command(self, text: str, confidence: float = 1.0) -> bool: """ 处理语音命令 Args: text: 命令文本 confidence: 置信度(0.0-1.0) Returns: 是否处理成功 """ try: if not self.enabled: print("✗ 命令处理器未启用") return False # 记录命令历史 command_entry = { 'text': text, 'confidence': confidence, 'timestamp': time.time(), 'context': self.command_context['current_context'] } self.command_history.append(command_entry) # 保持历史记录大小 if len(self.command_history) > self.max_history_size: self.command_history.pop(0) # 触发命令接收回调 self._trigger_command_callback('command_received', { 'text': text, 'confidence': confidence, 'command_entry': command_entry }) # 检查是否在命令链中 if self.command_chain['is_active']: return self._process_chained_command(text, confidence) # 查找匹配的命令 matched_command = self._find_matching_command(text, confidence) if matched_command: command_text = matched_command['command'] command_info = self.command_mappings[command_text] handler = command_info['handler'] # 更新统计信息 if matched_command['type'] == 'exact': self.stats['exact_matches'] += 1 else: self.stats['fuzzy_matches'] += 1 # 检查是否需要确认 if (self.command_config['enable_confirmation'] and confidence < self.command_config['confirmation_threshold']): return self._request_confirmation(text, command_text, handler, confidence) # 执行命令 return self._execute_command(command_text, handler, text, confidence, matched_command) else: # 未找到匹配命令 print(f"✗ 未找到匹配命令: {text}") self.stats['commands_failed'] += 1 # 触发命令失败回调 self._trigger_command_callback('command_failed', { 'text': text, 'confidence': confidence, 'reason': 'no_match' }) # 请求帮助 if self._is_help_request(text): self._provide_help() return False except Exception as e: print(f"✗ 命令处理失败: {e}") import traceback traceback.print_exc() self.stats['commands_failed'] += 1 return False def _find_matching_command(self, text: str, confidence: float) -> Optional[Dict[str, Any]]: """ 查找匹配的命令 Args: text: 命令文本 confidence: 置信度 Returns: 匹配的命令信息或None """ try: # 首先尝试精确匹配 if text in self.command_mappings: return { 'command': text, 'type': 'exact', 'confidence': confidence } # 尝试上下文命令 if (self.command_config['enable_context_commands'] and self.command_context['current_context'] != 'default'): context_commands = self.command_context['context_variables'].get('commands', []) for command in context_commands: if command in self.command_mappings and text in command: return { 'command': command, 'type': 'context', 'confidence': confidence * 0.9 } self.stats['context_commands'] += 1 # 尝试模糊匹配 if self.command_config['enable_fuzzy_matching']: best_match = self._fuzzy_match_command(text) if best_match: return best_match return None except Exception as e: print(f"✗ 命令匹配失败: {e}") return None def _fuzzy_match_command(self, text: str) -> Optional[Dict[str, Any]]: """ 模糊匹配命令 Args: text: 命令文本 Returns: 匹配的命令信息或None """ try: best_match = None best_score = 0.0 for command_text in self.command_mappings: score = self._calculate_similarity(text, command_text) if score > best_score and score >= self.command_config['fuzzy_threshold']: best_score = score best_match = { 'command': command_text, 'type': 'fuzzy', 'confidence': score } return best_match except Exception as e: print(f"✗ 模糊匹配失败: {e}") return None def _calculate_similarity(self, text1: str, text2: str) -> float: """ 计算文本相似度 Args: text1: 文本1 text2: 文本2 Returns: 相似度(0.0-1.0) """ try: # 简单的相似度计算（实际应用中可以使用更复杂的算法） set1 = set(text1) set2 = set(text2) intersection = len(set1.intersection(set2)) union = len(set1.union(set2)) if union == 0: return 0.0 return intersection / union except Exception as e: print(f"✗ 相似度计算失败: {e}") return 0.0 def _process_chained_command(self, text: str, confidence: float) -> bool: """ 处理命令链中的命令 Args: text: 命令文本 confidence: 置信度 Returns: 是否处理成功 """ try: # 添加到命令链 self.command_chain['commands'].append({ 'text': text, 'confidence': confidence, 'timestamp': time.time() }) # 检查是否完成命令链 if self._is_chain_completion(text): return self._execute_command_chain() return True except Exception as e: print(f"✗ 命令链处理失败: {e}") return False def _is_chain_completion(self, text: str) -> bool: """ 检查是否完成命令链 Args: text: 命令文本 Returns: 是否完成命令链 """ try: completion_keywords = ['完成', '结束', '执行', '确定', '确认'] return any(keyword in text for keyword in completion_keywords) except Exception as e: print(f"✗ 命令链完成检查失败: {e}") return False def _execute_command_chain(self) -> bool: """ 执行命令链 Returns: 是否执行成功 """ try: # 触发命令链完成回调 self._trigger_command_callback('chain_completed', { 'commands': self.command_chain['commands'] }) # 重置命令链 self.command_chain['is_active'] = False self.command_chain['commands'] = [] self.command_chain['chain_start_time'] = 0.0 self.stats['chained_commands'] += 1 return True except Exception as e: print(f"✗ 命令链执行失败: {e}") return False def _request_confirmation(self, original_text: str, command_text: str, handler: Callable, confidence: float) -> bool: """ 请求命令确认 Args: original_text: 原始文本 command_text: 命令文本 handler: 处理函数 confidence: 置信度 Returns: 是否请求成功 """ try: confirmation_text = f"您是想执行 {command_text} 吗？请确认。" # 通过语音合成器播放确认请求 if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech(confirmation_text) # 存储待确认的命令 self.pending_confirmation = { 'original_text': original_text, 'command_text': command_text, 'handler': handler, 'confidence': confidence, 'timestamp': time.time() } return True except Exception as e: print(f"✗ 确认请求失败: {e}") return False def _execute_command(self, command_text: str, handler: Callable, original_text: str, confidence: float, match_info: Dict[str, Any]) -> bool: """ 执行命令 Args: command_text: 命令文本 handler: 处理函数 original_text: 原始文本 confidence: 置信度 match_info: 匹配信息 Returns: 是否执行成功 """ try: # 触发命令处理回调 self._trigger_command_callback('command_processed', { 'command_text': command_text, 'original_text': original_text, 'confidence': confidence, 'match_type': match_info['type'] }) # 执行命令处理函数 result = handler(original_text, confidence) if result: self.stats['commands_executed'] += 1 # 触发命令执行回调 self._trigger_command_callback('command_executed', { 'command_text': command_text, 'original_text': original_text, 'confidence': confidence }) # 检查是否需要进入特定上下文 self._check_context_transition(command_text) print(f"✓ 命令执行成功: {command_text}") return True else: self.stats['commands_failed'] += 1 # 触发命令失败回调 self._trigger_command_callback('command_failed', { 'command_text': command_text, 'original_text': original_text, 'confidence': confidence, 'reason': 'execution_failed' }) print(f"✗ 命令执行失败: {command_text}") return False except Exception as e: print(f"✗ 命令执行异常: {e}") import traceback traceback.print_exc() self.stats['commands_failed'] += 1 # 触发命令失败回调 self._trigger_command_callback('command_failed', { 'command_text': command_text, 'original_text': original_text, 'confidence': confidence, 'reason': 'exception', 'exception': str(e) }) return False def _check_context_transition(self, command_text: str): """ 检查上下文转换 Args: command_text: 命令文本 """ try: # 根据命令类型设置上下文 context_transitions = { '播放音乐': 'music', '暂停播放': 'music', '下一首': 'music', '上一首': 'music' } if command_text in context_transitions: self.set_context(context_transitions[command_text]) except Exception as e: print(f"✗ 上下文转换检查失败: {e}") def _check_context_timeout(self, current_time: float): """ 检查上下文超时 Args: current_time: 当前时间 """ try: if (self.command_context['current_context'] != 'default' and current_time - self.command_context['context_start_time'] > self.command_config['context_timeout']): self.reset_context() except Exception as e: print(f"✗ 上下文超时检查失败: {e}") def _check_chain_timeout(self, current_time: float): """ 检查命令链超时 Args: current_time: 当前时间 """ try: if (self.command_chain['is_active'] and current_time - self.command_chain['chain_start_time'] > 10.0): # 10秒超时 self.command_chain['is_active'] = False self.command_chain['commands'] = [] self.command_chain['chain_start_time'] = 0.0 except Exception as e: print(f"✗ 命令链超时检查失败: {e}") def set_context(self, context_name: str, variables: Dict[str, Any] = None) -> bool: """ 设置命令上下文 Args: context_name: 上下文名称 variables: 上下文变量 Returns: 是否设置成功 """ try: # 保存当前上下文到栈中 self.command_context['context_stack'].append({ 'context': self.command_context['current_context'], 'variables': self.command_context['context_variables'].copy(), 'timestamp': self.command_context['context_start_time'] }) # 设置新上下文 self.command_context['current_context'] = context_name self.command_context['context_start_time'] = time.time() if variables: self.command_context['context_variables'] = variables else: self.command_context['context_variables'] = {} # 触发上下文变更回调 self._trigger_command_callback('context_changed', { 'old_context': self.command_context['context_stack'][-1]['context'] if self.command_context['context_stack'] else 'default', 'new_context': context_name, 'variables': variables }) self.last_context_change = time.time() print(f"✓ 上下文已设置为: {context_name}") return True except Exception as e: print(f"✗ 上下文设置失败: {e}") return False def reset_context(self) -> bool: """ 重置命令上下文 Returns: 是否重置成功 """ try: if self.command_context['context_stack']: # 恢复上一个上下文 previous_context = self.command_context['context_stack'].pop() self.command_context['current_context'] = previous_context['context'] self.command_context['context_variables'] = previous_context['variables'] self.command_context['context_start_time'] = previous_context['timestamp'] else: # 重置为默认上下文 self.command_context['current_context'] = 'default' self.command_context['context_variables'] = {} self.command_context['context_start_time'] = time.time() # 触发上下文变更回调 self._trigger_command_callback('context_changed', { 'old_context': 'previous', 'new_context': self.command_context['current_context'], 'variables': self.command_context['context_variables'] }) print("✓ 上下文已重置") return True except Exception as e: print(f"✗ 上下文重置失败: {e}") return False def start_command_chain(self) -> bool: """ 开始命令链 Returns: 是否开始成功 """ try: self.command_chain['is_active'] = True self.command_chain['commands'] = [] self.command_chain['chain_start_time'] = time.time() # 触发命令链开始回调 self._trigger_command_callback('chain_started', {}) print("✓ 命令链已开始") return True except Exception as e: print(f"✗ 命令链开始失败: {e}") return False def _is_help_request(self, text: str) -> bool: """ 检查是否为帮助请求 Args: text: 文本 Returns: 是否为帮助请求 """ try: help_keywords = ['帮助', 'help', '怎么用', '使用方法', '功能'] return any(keyword in text for keyword in help_keywords) except Exception as e: print(f"✗ 帮助请求检查失败: {e}") return False # 默认命令处理函数 def _move_forward(self, text: str, confidence: float) -> bool: """向前移动""" try: print("→ 执行向前移动命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("正在向前移动") return True except Exception as e: print(f"✗ 向前移动命令执行失败: {e}") return False def _move_backward(self, text: str, confidence: float) -> bool: """向后移动""" try: print("← 执行向后移动命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("正在向后移动") return True except Exception as e: print(f"✗ 向后移动命令执行失败: {e}") return False def _turn_left(self, text: str, confidence: float) -> bool: """向左转""" try: print("↺ 执行向左转命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("正在向左转") return True except Exception as e: print(f"✗ 向左转命令执行失败: {e}") return False def _turn_right(self, text: str, confidence: float) -> bool: """向右转""" try: print("↻ 执行向右转命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("正在向右转") return True except Exception as e: print(f"✗ 向右转命令执行失败: {e}") return False def _stop_movement(self, text: str, confidence: float) -> bool: """停止移动""" try: print("⏹ 执行停止移动命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("已停止移动") return True except Exception as e: print(f"✗ 停止移动命令执行失败: {e}") return False def _toggle_lights(self, text: str, confidence: float) -> bool: """切换灯光""" try: action = "打开" if "打开" in text else "关闭" print(f"💡 执行{action}灯光命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech(f"已{action}灯光") return True except Exception as e: print(f"✗ 灯光控制命令执行失败: {e}") return False def _increase_volume(self, text: str, confidence: float) -> bool: """增加音量""" try: print("🔊 执行增加音量命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("音量已增加") return True except Exception as e: print(f"✗ 增加音量命令执行失败: {e}") return False def _decrease_volume(self, text: str, confidence: float) -> bool: """减少音量""" try: print("🔉 执行减少音量命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("音量已减少") return True except Exception as e: print(f"✗ 减少音量命令执行失败: {e}") return False def _play_music(self, text: str, confidence: float) -> bool: """播放音乐""" try: print("🎵 执行播放音乐命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("正在播放音乐") return True except Exception as e: print(f"✗ 播放音乐命令执行失败: {e}") return False def _pause_music(self, text: str, confidence: float) -> bool: """暂停音乐""" try: print("⏸ 执行暂停音乐命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("音乐已暂停") return True except Exception as e: print(f"✗ 暂停音乐命令执行失败: {e}") return False def _next_track(self, text: str, confidence: float) -> bool: """下一首""" try: print("⏭ 执行播放下一首命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("正在播放下一首") return True except Exception as e: print(f"✗ 播放下一首命令执行失败: {e}") return False def _previous_track(self, text: str, confidence: float) -> bool: """上一首""" try: print("⏮ 执行播放上一首命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("正在播放上一首") return True except Exception as e: print(f"✗ 播放上一首命令执行失败: {e}") return False def _greet_user(self, text: str, confidence: float) -> bool: """打招呼""" try: print("👋 执行打招呼命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("您好！有什么可以帮助您的吗？") return True except Exception as e: print(f"✗ 打招呼命令执行失败: {e}") return False def _acknowledge_thanks(self, text: str, confidence: float) -> bool: """回应感谢""" try: print("🙏 执行回应感谢命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("不客气！") return True except Exception as e: print(f"✗ 回应感谢命令执行失败: {e}") return False def _say_goodbye(self, text: str, confidence: float) -> bool: """道别""" try: print("👋 执行道别命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech("再见！") return True except Exception as e: print(f"✗ 道别命令执行失败: {e}") return False def _provide_help(self, text: str = None, confidence: float = 1.0) -> bool: """提供帮助""" try: help_text = "我可以帮您控制移动、灯光、音量和音乐播放。请说'前进'、'后退'、'左转'、'右转'、'停止'来控制移动；说'打开灯光'或'关闭灯光'来控制灯光；说'增加音量'或'减少音量'来调节音量；说'播放音乐'、'暂停播放'、'下一首'、'上一首'来控制音乐。" print("ℹ️ 执行提供帮助命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech(help_text) return True except Exception as e: print(f"✗ 提供帮助命令执行失败: {e}") return False def _show_about(self, text: str, confidence: float) -> bool: """显示关于信息""" try: about_text = "语音控制系统版本1.0.0，基于EG引擎开发。" print("ℹ️ 执行显示关于信息命令") if self.plugin.speech_synthesizer: self.plugin.speech_synthesizer.synthesize_speech(about_text) return True except Exception as e: print(f"✗ 显示关于信息命令执行失败: {e}") return False def get_command_mappings(self) -> Dict[str, Dict[str, Any]]: """ 获取命令映射 Returns: 命令映射字典 """ return self.command_mappings.copy() def get_command_groups(self) -> Dict[str, Dict[str, Any]]: """ 获取命令组 Returns: 命令组字典 """ return self.command_groups.copy() def get_command_history(self) -> List[Dict[str, Any]]: """ 获取命令历史 Returns: 命令历史列表 """ return self.command_history.copy() def clear_command_history(self): """清空命令历史""" try: self.command_history.clear() print("✓ 命令历史已清空") except Exception as e: print(f"✗ 命令历史清空失败: {e}") def set_command_config(self, config: Dict[str, Any]) -> bool: """ 设置命令配置 Args: config: 配置字典 Returns: 是否设置成功 """ try: self.command_config.update(config) print(f"✓ 命令配置已更新: {self.command_config}") return True except Exception as e: print(f"✗ 命令配置设置失败: {e}") return False def get_command_config(self) -> Dict[str, Any]: """ 获取命令配置 Returns: 配置字典 """ return self.command_config.copy() def get_context(self) -> Dict[str, Any]: """ 获取当前上下文 Returns: 上下文字典 """ return self.command_context.copy() def _trigger_command_callback(self, callback_type: str, data: Dict[str, Any]): """ 触发命令回调 Args: callback_type: 回调类型 data: 回调数据 """ try: if callback_type in self.command_callbacks: for callback in self.command_callbacks[callback_type]: try: callback(data) except Exception as e: print(f"✗ 命令回调执行失败: {e}") except Exception as e: print(f"✗ 命令回调触发失败: {e}") def register_command_callback(self, callback_type: str, callback: Callable): """ 注册命令回调 Args: callback_type: 回调类型 callback: 回调函数 """ try: if callback_type in self.command_callbacks: self.command_callbacks[callback_type].append(callback) print(f"✓ 命令回调已注册: {callback_type}") else: print(f"✗ 无效的回调类型: {callback_type}") except Exception as e: print(f"✗ 命令回调注册失败: {e}") def unregister_command_callback(self, callback_type: str, callback: Callable): """ 注销命令回调 Args: callback_type: 回调类型 callback: 回调函数 """ try: if callback_type in self.command_callbacks: if callback in self.command_callbacks[callback_type]: self.command_callbacks[callback_type].remove(callback) print(f"✓ 命令回调已注销: {callback_type}") except Exception as e: print(f"✗ 命令回调注销失败: {e}") def get_stats(self) -> Dict[str, Any]: """ 获取统计信息 Returns: 统计信息字典 """ return self.stats.copy() def reset_stats(self): """重置统计信息""" try: self.stats = { 'commands_processed': 0, 'commands_executed': 0, 'commands_failed': 0, 'fuzzy_matches': 0, 'exact_matches': 0, 'context_commands': 0, 'chained_commands': 0 } print("✓ 命令处理器统计信息已重置") except Exception as e: print(f"✗ 命令处理器统计信息重置失败: {e}")