smartpi 0.1.40__py3-none-any.whl → 0.1.41__py3-none-any.whl

smartpi/mcp_intent_recognizer.py

@@ -0,0 +1,408 @@
+# -*- coding: utf-8 -*-
+"""使用MCP优化的意图识别器"""
+import asyncio
+import json
+import re
+from typing import List, Dict, Any
+from .mcp_client import MCPClient
+import logging
+
+# 配置日志
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+class MCPIntentRecognizer:
+    """基于MCP的意图识别器"""
+    
+    def __init__(self, global_intents=None):
+        self.mcp_client = None
+        self.is_connected = False
+        self.server_url = "http://127.0.0.1:8000/mcp"
+        self.intent_tool_name = "recognize_intent"
+        self.initialize_task = None
+        # 初始化标志，避免重复初始化
+        self._initializing = False
+        # 存储全局意图映射
+        self.global_intents = global_intents if global_intents is not None else {}
+        
+        # 构建英文代码到数字代码的映射
+        self.en_code_to_intent_code = {}
+        for intent_code, intent_info in self.global_intents.items():
+            if "en_code" in intent_info:
+                en_code = intent_info["en_code"]
+                # 支持单个英文代码或英文代码列表
+                if isinstance(en_code, list):
+                    for code in en_code:
+                        self.en_code_to_intent_code[code.lower()] = intent_code
+                else:
+                    self.en_code_to_intent_code[en_code.lower()] = intent_code
+        
+        logger.info(f"MCPIntentRecognizer初始化，全局意图数量: {len(self.global_intents)}, 英文代码映射数量: {len(self.en_code_to_intent_code)}")
+    
+    def _get_intent_code_from_en_code(self, en_code):
+        """
+        将英文意图代码转换为数字代码
+        
+        Args:
+            en_code: 英文意图代码
+            
+        Returns:
+            int: 对应的数字代码，如果未找到则返回None
+        """
+        if not en_code or not isinstance(en_code, str):
+            return None
+        
+        # 转换为小写后查找
+        return self.en_code_to_intent_code.get(en_code.lower())
+    
+    def update_en_code_mapping(self):
+        """
+        更新英文代码到数字代码的映射
+        当全局意图被更新时，需要调用此方法来更新映射
+        """
+        # 清空旧的映射
+        self.en_code_to_intent_code.clear()
+        
+        # 重新构建映射
+        for intent_code, intent_info in self.global_intents.items():
+            if "en_code" in intent_info:
+                en_code = intent_info["en_code"]
+                # 支持单个英文代码或英文代码列表
+                if isinstance(en_code, list):
+                    for code in en_code:
+                        self.en_code_to_intent_code[code.lower()] = intent_code
+                else:
+                    self.en_code_to_intent_code[en_code.lower()] = intent_code
+        
+        logger.info(f"英文代码映射已更新，当前映射数量: {len(self.en_code_to_intent_code)}")
+    
+    async def initialize(self):
+        """初始化MCP客户端并连接到服务器"""
+        # 避免重复初始化
+        if self.is_connected or self._initializing:
+            return self.is_connected
+        
+        self._initializing = True
+        
+        try:
+            self.mcp_client = MCPClient()
+            result = await self.mcp_client.connect(self.server_url)
+            if result:
+                logger.info("成功连接到MCP服务器")
+                self.is_connected = True
+                return True
+            else:
+                logger.warning("连接MCP服务器未成功返回")
+                self.is_connected = False
+                return False
+        except Exception as e:
+            logger.error(f"连接MCP服务器失败: {str(e)}")
+            self.is_connected = False
+            return False
+        finally:
+            self._initializing = False
+    
+    async def recognize_intent_async(self, user_input: str) -> List[Dict[str, Any]]:
+        """异步识别用户输入中的意图"""
+        # 确保已连接
+        if not self.is_connected:
+            await self.initialize()
+            if not self.is_connected:
+                logger.error("无法连接到MCP服务器")
+                return []
+        
+        try:
+            # 构建工具调用请求
+            tool_call = {
+                "id": "1",
+                "type": "function",
+                "function": {
+                    "name": self.intent_tool_name,
+                    "arguments": json.dumps({"user_input": user_input})
+                }
+            }
+            
+            # 调用MCP工具
+            results = await self.mcp_client.call_tool([tool_call])
+            
+            # 解析结果
+            if results:
+                # 遍历所有结果，找到tool类型的响应
+                for tool_result in results:
+                    if tool_result.get("role") == "tool":
+                        intent_result = tool_result.get("content", "[]")
+                        logger.info(f"从MCP接收到的意图结果: {intent_result}")
+                        parsed_result = self._parse_intent_result(intent_result)
+                        
+                        # 增强带参数意图识别，无论MCP是否返回结果，都尝试提取参数
+                        enhanced_result = []
+                        
+                        # 1. 如果MCP返回了意图，为每个意图添加参数和名称
+                        if parsed_result:
+                            for intent_data in parsed_result:
+                                # 如果没有参数，尝试提取，但仅对需要参数的意图进行提取
+                                if 'arg' not in intent_data or not intent_data['arg']:
+                                    intent_code = intent_data['intent']
+                                    # 只有特定的意图类型才需要参数（如音量调节、速度调节等）
+                                    # 根据意图配置判断是否需要参数，或者直接检查意图代码
+                                    # 这里我们假设只有部分意图需要参数，大部分不需要
+                                    # 音量调节(2)、速度调节(7)等需要参数的意图列表
+                                    parameter_intents = ['2', '7']  # 可以根据实际情况扩展
+                                    if intent_code in parameter_intents:
+                                        intent_data['arg'] = self._extract_parameters(user_input, intent_code)
+                                    else:
+                                        # 不需要参数的意图，保持空列表
+                                        intent_data['arg'] = []
+                                
+                                enhanced_result.append(intent_data)
+                        else:
+                            # 2. 如果MCP没有返回意图，尝试直接从文本中识别音量调节等常见意图
+                            enhanced_result = self._direct_extract_intents(user_input)
+                        
+                        logger.info(f"增强后的意图识别结果: {enhanced_result}")
+                        return enhanced_result
+        except Exception as e:
+            logger.error(f"通过MCP识别意图失败: {str(e)}")
+        
+        # 如果发生异常，尝试直接从文本中识别意图
+        return self._direct_extract_intents(user_input)
+    
+    def _extract_parameters(self, text, intent):
+        """从文本中提取参数"""
+        text_lower = text.lower()
+        
+        # 尝试提取数字参数，支持百分比形式
+        numbers = re.findall(r'\d+(?:\.\d+)?', text_lower)
+        if numbers:
+            return [numbers[0]]  # 返回第一个匹配的数字
+        
+        return []
+    
+    def _direct_extract_intents(self, user_input):
+        """直接从文本中提取常见意图，特别是带参数的意图"""
+        text_lower = user_input.lower()
+        result = []
+        
+        
+        
+        # 直接使用从ai_llm.py传入的全局意图配置，实现集中管理
+        for intent_code, intent_info in self.global_intents.items():
+            # 检查意图是否已被识别（避免重复）
+            intent_already_identified = any(item["intent"] == intent_code for item in result)
+            if intent_already_identified:
+                continue
+                
+            # 检查关键词
+            for keyword in intent_info["keywords"]:
+                if keyword in text_lower:
+                    # 提取参数
+                    args = self._extract_parameters(text_lower, intent_code)
+                    result.append({
+                        "intent": intent_code,
+                        "arg": args
+                    })
+                    break
+        
+        return result
+    
+    def recognize_intent(self, user_input: str) -> List[Dict[str, Any]]:
+        """同步识别用户输入中的意图（供非异步代码调用）- 仅使用MCP，不包含回退机制"""
+        try:
+            # 增强日志记录
+            logger.info(f"开始意图识别: {user_input}")
+            
+            # 如果事件循环已存在，使用现有的
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_closed():
+                    raise RuntimeError("Event loop is closed")
+            except (RuntimeError, AssertionError):
+                # 创建新的事件循环
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+            
+            # 尝试通过MCP识别
+            result = loop.run_until_complete(self.recognize_intent_async(user_input))
+            logger.info(f"意图识别完成，结果: {result}")
+            return result
+        except Exception as e:
+            logger.error(f"同步调用MCP意图识别失败: {str(e)}")
+            return []
+    
+
+    
+    def _parse_intent_result(self, intent_text: str) -> List[Dict[str, Any]]:
+        """解析意图识别结果，与FastIntentRecognizer保持一致"""
+        try:
+            # 处理可能的格式问题
+            if not intent_text or intent_text.strip() == "[]":
+                return []
+                
+            # 第一步：确保所有双花括号都被替换为单花括号
+            intent_text = intent_text.replace("{{", "{").replace("}}", "}")
+            
+            # 第二步：尝试多种解析策略
+            # 策略1：尝试作为单个JSON对象解析
+            try:
+                if intent_text.strip().startswith("{"):
+                    intent_data = json.loads(intent_text)
+                    # 确保返回的格式与FastIntentRecognizer一致
+                    if "intent" in intent_data:
+                        return [intent_data]
+                    # 如果字段名为intent_code，则转换为intent
+                    elif "intent_code" in intent_data:
+                        converted = {"intent": intent_data["intent_code"]}
+                        if "arg" in intent_data:
+                            converted["arg"] = intent_data["arg"]
+                        return [converted]
+            except Exception as e1:
+                logger.warning(f"策略1解析失败: {str(e1)}")
+                
+            # 策略2：尝试作为JSON数组解析
+            try:
+                if not intent_text.strip().startswith("["):
+                    formatted_text = "[" + intent_text + "]"
+                    intents = json.loads(formatted_text)
+                else:
+                    intents = json.loads(intent_text)
+                
+                # 确保返回的格式与FastIntentRecognizer一致
+                if isinstance(intents, list):
+                    result = []
+                    for intent in intents:
+                        if isinstance(intent, dict):
+                            if "intent" in intent:
+                                result.append(intent)
+                            elif "intent_code" in intent:
+                                converted = {"intent": intent["intent_code"]}
+                                if "arg" in intent:
+                                    converted["arg"] = intent["arg"]
+                                result.append(converted)
+                    return result if result else intents
+                elif isinstance(intents, dict):
+                    if "intent" in intents:
+                        return [intents]
+                    elif "intent_code" in intents:
+                        converted = {"intent": intents["intent_code"]}
+                        if "arg" in intents:
+                            converted["arg"] = intents["arg"]
+                        return [converted]
+                    return [intents]
+            except Exception as e2:
+                logger.warning(f"策略2解析失败: {str(e2)}")
+                
+            # 策略3：处理可能包含多个意图的情况
+            try:
+                # 去除所有空白字符
+                clean_text = ''.join(intent_text.split())
+                
+                if ",{" in clean_text:
+                    # 分割多个意图
+                    intent_parts = clean_text.split(",")
+                    intents = []
+                    for i, part in enumerate(intent_parts):
+                        try:
+                            # 确保每个部分都是有效的JSON对象
+                            if not part.startswith("{"):
+                                part = "{" + part
+                            if not part.endswith("}"):
+                                part = part + "}"
+                            intent_data = json.loads(part)
+                            # 转换格式
+                            if "intent" in intent_data:
+                                intents.append(intent_data)
+                            elif "intent_code" in intent_data:
+                                converted = {"intent": intent_data["intent_code"]}
+                                if "arg" in intent_data:
+                                    converted["arg"] = intent_data["arg"]
+                                intents.append(converted)
+                        except Exception as e_inner:
+                            logger.warning(f"解析第{i+1}个意图失败: {str(e_inner)}")
+                            pass
+                    if intents:
+                        return intents
+            except Exception as e3:
+                logger.warning(f"策略3解析失败: {str(e3)}")
+                
+            # 策略4：尝试修复格式后再解析
+            try:
+                # 去除所有空白字符
+                clean_text = ''.join(intent_text.split())
+                
+                # 确保是对象或数组格式
+                if not clean_text.startswith("{") and not clean_text.startswith("["):
+                    # 尝试添加对象括号
+                    if clean_text.startswith("intent") or ":" in clean_text:
+                        clean_text = "{" + clean_text + "}"
+                        intent_data = json.loads(clean_text)
+                        # 转换格式
+                        if "intent" in intent_data:
+                            return [intent_data]
+                        elif "intent_code" in intent_data:
+                            intent_code_value = intent_data["intent_code"]
+                            if isinstance(intent_code_value, str) and intent_code_value.isalpha():
+                                numeric_code = self._get_intent_code_from_en_code(intent_code_value)
+                                if numeric_code:
+                                    intent_code_value = numeric_code
+                            converted = {"intent": intent_code_value}
+                            if "arg" in intent_data:
+                                converted["arg"] = intent_data["arg"]
+                            return [converted]
+                else:
+                    # 再次尝试解析
+                    intent_data = json.loads(clean_text)
+                    if isinstance(intent_data, list):
+                        # 检查列表中的每个意图
+                        for item in intent_data:
+                            if isinstance(item, dict) and "intent" in item:
+                                intent_value = item["intent"]
+                                if isinstance(intent_value, str) and intent_value.isalpha():
+                                    numeric_code = self._get_intent_code_from_en_code(intent_value)
+                                    if numeric_code:
+                                        item["intent"] = numeric_code
+                        return intent_data
+                    else:
+                        if isinstance(intent_data, dict) and "intent" in intent_data:
+                            # 检查intent是否为英文代码，如果是则转换为数字代码
+                            intent_value = intent_data["intent"]
+                            if isinstance(intent_value, str) and intent_value.isalpha():
+                                numeric_code = self._get_intent_code_from_en_code(intent_value)
+                                if numeric_code:
+                                    intent_data["intent"] = numeric_code
+                        return [intent_data]
+            except Exception as e4:
+                logger.warning(f"策略4解析失败: {str(e4)}")
+                
+            # 所有策略都失败
+            logger.error("所有解析尝试都失败了，返回空列表")
+            return []
+        except Exception as e:
+            logger.error(f"解析意图结果时发生严重错误: {str(e)}")
+            return []
+    
+    async def close(self):
+        """关闭MCP连接"""
+        if self.mcp_client:
+            try:
+                # 优先尝试使用exit_stack关闭
+                if hasattr(self.mcp_client, 'exit_stack'):
+                    await self.mcp_client.exit_stack.aclose()
+                # 如果有close方法，也调用它
+                elif hasattr(self.mcp_client, 'close'):
+                    await self.mcp_client.close()
+                self.is_connected = False
+                logger.info("MCP连接已关闭")
+            except Exception as e:
+                logger.error(f"关闭MCP连接时出错: {str(e)}")
+
+
+# 全局实例，在需要时才初始化
+global_mcp_intent_recognizer = None
+
+
+def get_mcp_intent_recognizer():
+    global global_mcp_intent_recognizer
+    if global_mcp_intent_recognizer is None:
+        global_mcp_intent_recognizer = MCPIntentRecognizer()
+    return global_mcp_intent_recognizer

smartpi/models/snakers4_silero-vad/hubconf.py

@@ -0,0 +1,56 @@
+dependencies = ['torch', 'torchaudio']
+import torch
+import os
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+from silero_vad.utils_vad import (init_jit_model,
+                                  get_speech_timestamps,
+                                  save_audio,
+                                  read_audio,
+                                  VADIterator,
+                                  collect_chunks,
+                                  OnnxWrapper)
+
+
+def versiontuple(v):
+    splitted = v.split('+')[0].split(".")
+    version_list = []
+    for i in splitted:
+        try:
+            version_list.append(int(i))
+        except:
+            version_list.append(0)
+    return tuple(version_list)
+
+
+def silero_vad(onnx=False, force_onnx_cpu=False, opset_version=16):
+    """Silero Voice Activity Detector
+    Returns a model with a set of utils
+    Please see https://github.com/snakers4/silero-vad for usage examples
+    """
+    available_ops = [15, 16]
+    if onnx and opset_version not in available_ops:
+        raise Exception(f'Available ONNX opset_version: {available_ops}')
+
+    if not onnx:
+        installed_version = torch.__version__
+        supported_version = '1.12.0'
+        if versiontuple(installed_version) < versiontuple(supported_version):
+            raise Exception(f'Please install torch {supported_version} or greater ({installed_version} installed)')
+
+    model_dir = os.path.join(os.path.dirname(__file__), 'src', 'silero_vad', 'data')
+    if onnx:
+        if opset_version == 16:
+            model_name = 'silero_vad.onnx'
+        else:
+            model_name = f'silero_vad_16k_op{opset_version}.onnx'
+        model = OnnxWrapper(os.path.join(model_dir, model_name), force_onnx_cpu)
+    else:
+        model = init_jit_model(os.path.join(model_dir, 'silero_vad.jit'))
+    utils = (get_speech_timestamps,
+             save_audio,
+             read_audio,
+             VADIterator,
+             collect_chunks)
+
+    return model, utils

smartpi/tencentcloud-speech-sdk-python/__init__.py

@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-

smartpi/tencentcloud-speech-sdk-python/asr/flash_recognizer.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+import requests
+import hmac
+import hashlib
+import base64
+import time
+import random
+import os
+import json
+from common import credential
+
+#录音识别极速版使用
+class FlashRecognitionRequest:
+    def __init__(self, engine_type):
+        self.engine_type = engine_type
+        self.speaker_diarization = 0
+        self.hotword_id = ""
+        self.hotword_list = ""
+        self.input_sample_rate = 0
+        self.customization_id = ""
+        self.filter_dirty = 0
+        self.filter_modal = 0
+        self.filter_punc = 0
+        self.convert_num_mode = 1
+        self.word_info = 0
+        self.voice_format = ""
+        self.first_channel_only = 1
+        self.reinforce_hotword = 0
+        self.sentence_max_length = 0
+
+    def set_first_channel_only(self, first_channel_only):
+        self.first_channel_only = first_channel_only
+
+    def set_speaker_diarization(self, speaker_diarization):
+        self.speaker_diarization = speaker_diarization
+
+    def set_filter_dirty(self, filter_dirty):
+        self.filter_dirty = filter_dirty
+
+    def set_filter_modal(self, filter_modal):
+        self.filter_modal = filter_modal
+
+    def set_filter_punc(self, filter_punc):
+        self.filter_punc = filter_punc
+
+    def set_convert_num_mode(self, convert_num_mode):
+        self.convert_num_mode = convert_num_mode
+
+    def set_word_info(self, word_info):
+        self.word_info = word_info
+
+    def set_hotword_id(self, hotword_id):
+        self.hotword_id = hotword_id
+
+    def set_hotword_list(self, hotword_list):
+        self.hotword_list = hotword_list
+
+    def set_input_sample_rate(self, input_sample_rate):
+        self.input_sample_rate = input_sample_rate
+
+    def set_customization_id(self, customization_id):
+        self.customization_id = customization_id
+
+    def set_voice_format(self, voice_format):
+        self.voice_format = voice_format
+
+    def set_sentence_max_length(self, sentence_max_length):
+        self.sentence_max_length = sentence_max_length
+
+    def set_reinforce_hotword(self, reinforce_hotword):
+        self.reinforce_hotword = reinforce_hotword
+
+
+
+class FlashRecognizer:
+    '''
+    reponse:  
+    字段名            类型
+    request_id        string
+    status            Integer    
+    message           String    
+    audio_duration    Integer
+    flash_result      Result Array
+
+    Result的结构体格式为:
+    text              String
+    channel_id        Integer
+    sentence_list     Sentence Array
+
+    Sentence的结构体格式为:
+    text              String
+    start_time        Integer    
+    end_time          Integer    
+    speaker_id        Integer    
+    word_list         Word Array
+
+    Word的类型为:
+    word              String 
+    start_time        Integer 
+    end_time          Integer 
+    stable_flag：     Integer 
+    '''
+
+    def __init__(self, appid, credential):
+        self.credential = credential
+        self.appid = appid
+
+    def _format_sign_string(self, param):
+        signstr = "POSTasr.cloud.tencent.com/asr/flash/v1/"
+        for t in param:
+            if 'appid' in t:
+                signstr += str(t[1])
+                break
+        signstr += "?"
+        for x in param:
+            tmp = x
+            if 'appid' in x:
+                continue
+            for t in tmp:
+                signstr += str(t)
+                signstr += "="
+            signstr = signstr[:-1]
+            signstr += "&"
+        signstr = signstr[:-1]
+        return signstr
+
+    def _build_header(self):
+        header = dict()
+        header["Host"] = "asr.cloud.tencent.com"
+        return header
+
+    def _sign(self, signstr, secret_key):
+        hmacstr = hmac.new(secret_key.encode('utf-8'),
+                           signstr.encode('utf-8'), hashlib.sha1).digest()
+        s = base64.b64encode(hmacstr)
+        s = s.decode('utf-8')
+        return s
+
+    def _build_req_with_signature(self, secret_key, params, header):
+        query = sorted(params.items(), key=lambda d: d[0])
+        signstr = self._format_sign_string(query)
+        signature = self._sign(signstr, secret_key)
+        header["Authorization"] = signature
+        requrl = "https://"
+        requrl += signstr[4::]
+        return requrl
+
+    def _create_query_arr(self, req):
+        query_arr = dict()
+        query_arr['appid'] = self.appid
+        query_arr['secretid'] = self.credential.secret_id
+        query_arr['timestamp'] = str(int(time.time()))
+        query_arr['engine_type'] = req.engine_type
+        query_arr['voice_format'] = req.voice_format
+        query_arr['speaker_diarization'] = req.speaker_diarization
+        if req.hotword_id != "":
+            query_arr['hotword_id'] = req.hotword_id
+        if req.hotword_list != "":
+            query_arr['hotword_list'] = req.hotword_list
+        if req.input_sample_rate != 0:
+            query_arr['input_sample_rate'] = req.input_sample_rate
+        query_arr['customization_id'] = req.customization_id
+        query_arr['filter_dirty'] = req.filter_dirty
+        query_arr['filter_modal'] = req.filter_modal
+        query_arr['filter_punc'] = req.filter_punc
+        query_arr['convert_num_mode'] = req.convert_num_mode
+        query_arr['word_info'] = req.word_info
+        query_arr['first_channel_only'] = req.first_channel_only
+        query_arr['reinforce_hotword'] = req.reinforce_hotword
+        query_arr['sentence_max_length'] = req.sentence_max_length
+        return query_arr
+
+    def recognize(self, req, data):
+        header = self._build_header()
+        query_arr = self._create_query_arr(req)
+        req_url = self._build_req_with_signature(self.credential.secret_key, query_arr, header)
+        r = requests.post(req_url, headers=header, data=data)
+        return r.text