tina-python 0.2.0__py3-none-any.whl

tina/core/memory.py

@@ -0,0 +1,219 @@
+"""
+编写者：王出日
+日期：2024，12，1
+版本？
+记忆模块，用于存储和读取记忆数据，通过使用SQLite来对用户的消息做管理
+importance为重要程度，由大模型评分，越重要，分数越高，越不容易被忘记
+！！！注意：
+该记忆模块可能更加像消息管理模块，因为它不对大模型内部进行处理，
+内含：
+-memory类
+"""
+import json
+import os
+import sqlite3
+import datetime
+from .manage import TinaFolderManager
+
+
+
+class Memory:
+    def __init__(self):
+        self.folder = TinaFolderManager.getMemory()
+        self.conn = sqlite3.connect(os.path.join(self.folder, "memory.db"))
+        self.cursor = self.conn.cursor()
+        self.cursor.execute('''CREATE TABLE IF NOT EXISTS logs (id INTEGER PRIMARY KEY AUTOINCREMENT, tag TEXT, time TEXT, role TEXT, content TEXT, importance INTEGER)''')
+        self.conn.commit()
+        self.conn.close()
+        self.prompt="""
+        请按照以下格式和准则为记忆打分，从1-5分，1分最低，5分最高，返回数字即可：
+
+        {"role":"谁","tag":"什么","content":"提取主要的内容，将无关描述去除","importance":1-5}
+        role:分为 system,user,assistant。如果是系统信息，则填写system；如果是用户信息，则填写user；如果是助手信息，则填写assistant。
+        tag:描述信息的种类，种类有：用户信息，指令信息，聊天信息，工具信息和其他信息。
+        content:提取主要的内容，将无关描述去除。例如，对于“我是王出日，我是一名程序员”，content为“用户名叫王出日，是一名程序员”
+        分数越高表示重要程度越高，被遗忘的概率越低。首先要明确是谁说的话，然后再输入内容，最后输入分数。具体内容如下：
+        用户信息是和用户相关的信息，比如用户是谁，用户的身份是什么，用户的喜好，用户的社交信息等，注意区分用户的名字和身份，比如我叫王出日表示我的名字是王出日和我是一名学生表示我是一位还在读书的学生。
+        指令信息是指用户要求你做的事情，比如用户让你做角色扮演，让你做某件事情等。
+        工具信息是指你调用了什么工具，工具的执行结果，工具的使用方法等。
+        聊天信息是指用户和机器人之间交流的消息，比如用户问你问题，机器人回答你问题，机器人提出建议等。
+        其他信息是指上面的信息之外的信息。
+        在给了标签之后，同一标签的信息再根据importance进行排序，同一标签内的importance越高，越容易被记忆。
+        例如：我是王出日，我是一名大学生。这个消息被归类为用户信息，impotence为最高分5分
+        5分的信息将会作为长期记忆，不会被遗。
+        4分的信息将会被记录。
+        3分的信息会被记录，但不会被优先遗忘。
+        2分的信息比1分的信息更长久被记忆。
+        1分的信息会在短期内被遗忘,适用于没什么用的信息，例如询问或者无意义的聊天。
+        按照这个格式返回数据
+        """
+
+    def remember(self, LLM:type,message:str) -> dict:
+        """
+        记忆用户信息
+        importance: 1-5 重要程度
+        """
+        self.conn = sqlite3.connect(os.path.join(self.folder, "memory.db"))
+        self.cursor = self.conn.cursor()
+        msg_role = message["role"]
+        msg_content = message["content"]
+        result = LLM.predict(
+                input_text = f"role:'{msg_role},content:'{msg_content}'",
+                sys_prompt = self.prompt,
+                format = "json",
+                json_format = '{"role":"","tag":"","content":"","importance":1-5}'
+            )
+        result_dict = self.__json(result["content"],LLM)
+        # result_dict = json.loads(result["content"])
+        if self.is_valid_json(result_dict):
+            time = datetime.datetime.now().strftime("%Y年-%m月-%d日 %H时:%M分")
+            self.__insertInQOLite(result_dict, time)
+        else:
+            time = datetime.datetime.now().strftime("%Y年-%m月-%d日 %H时:%M分")
+            self.__insertInQOLite({"role": "", "tag": "", "content": "", "importance": 0}, time)
+        self.conn.close()
+        return result_dict
+    def __json(self,result:str,LLM:type=None)->dict:
+        """
+        将字符串转换为字典
+        """
+        try:
+            result_dict = json.loads(result)
+            return result_dict
+        except:
+            result = LLM.predict(
+                input_text = result,
+                sys_prompt = "按照以下的格式修正数据：\n\n{'role':'','tag':'','content':'','importance':1-5}",
+                format = "json",
+                json_format = '{"role":"","tag":"","content":"","importance":1-5}'
+            )
+            result_dict = self.json(result)
+        return result_dict
+    def __insertInQOLite(self, result_dict, time):
+        try:
+            self.cursor.execute('''
+                INSERT INTO logs(tag, time, role, content, importance)
+                VALUES (?,?,?,?,?)
+                ''', (result_dict["tag"], time, result_dict["role"], result_dict["content"], result_dict["importance"])
+                )
+            self.conn.commit()
+        except sqlite3.IntegrityError:
+            pass
+    
+    def forget(self,importence:int=1) -> None:
+        """
+        遗忘用户信息
+        Args:
+            importance: 1-5 重要程度，在这里也叫遗忘指数，越高表示越重要，越低表示越不重要
+        """
+        self.conn = sqlite3.connect(os.path.join(self.folder, "memory.db"))
+        self.cursor = self.conn.cursor()
+        self.cursor.execute(
+            '''DELETE FROM logs WHERE importance <=?''',
+            (importence,)
+        )
+        self.conn.commit()
+        self.conn.close()
+        
+        
+    def recallByTag(self,tag:list=["用户信息","指令信息"],importance:int=3):
+        """
+        根据tag获取记忆信息
+        """
+        self.conn = sqlite3.connect(os.path.join(self.folder, "memory.db"))
+        self.cursor = self.conn.cursor()
+        self.cursor.execute(
+            '''SELECT * FROM logs WHERE tag IN ({}) AND importance >=?'''.format(",".join(["?"]*len(tag))),
+            tag+[importance]
+        )
+        result = self.cursor.fetchall()
+        messages = []
+        for row in result:
+            message = {
+                "role": row[3],
+                "content": row[4],
+                "time": row[2]
+            }
+            messages.append(message)
+        return messages
+        
+        
+    def recallByContent(self,content:str):
+        """
+        根据content获取记忆信息
+        """
+        self.cursor.execute(
+            '''SELECT * FROM logs WHERE content LIKE ?''',
+            (f"%{content}%",)
+        )
+        result = self.cursor.fetchall()
+        messages = []
+        for row in result:
+            message = {
+                "role": row[3],
+                "content": row[4]
+            }
+            messages.append(message)
+        return messages
+        
+    def recallByImportance(self,importance:int):
+        """
+        根据importance获取记忆信息
+        """
+        self.cursor.execute(
+            '''SELECT * FROM logs WHERE importance =?''',
+            (importance,)
+            )
+        result = self.cursor.fetchall()
+        messages = []
+        for row in result:
+            message = {
+                "role": row[3],
+                "content": row[4]
+            }
+            messages.append(message)
+        return messages
+        
+    def returnMessages(self,length:int,memory_percent:float=0.2,tag:list=["用户信息","指令信息"],importance:int=3)->list:
+        """
+        读取memory.db中的所有信息
+        返回以下的格式：
+        [
+            {
+                "role": "谁",
+                "content":时间+内容
+            }
+        ]
+        """
+        messages = self.recallByTag(tag=tag,importance=importance)
+        memory_length = 0
+        for message in messages:
+            if messages == []:
+                memory_length = 0
+            else:
+                memory_length = len(message["role"])+len(message["content"])+len(message["time"])
+
+        if memory_length/length > memory_percent:
+            if importance == 5:
+                messages = self.returnMessages(length,memory_percent,tag=["用户信息"],importance=5)
+            messages = self.returnMessages(length,memory_percent,tag,importance=importance+1)
+        else:
+            return messages
+    
+    def is_valid_json(self,json_obj:dict):
+        if not isinstance(json_obj, dict):
+            return False
+    
+        # 检查是否包含必要的键
+        if "role" not in json_obj or "content" not in json_obj:
+            return False
+    
+        allowed_roles = {"system", "user", "assistant"}
+        if json_obj["role"] not in allowed_roles:
+            return False
+    
+        # 检查content的值是否是字符串
+        if not isinstance(json_obj["content"], str):
+            return False
+    
+        return True

tina/core/parser.py

@@ -0,0 +1,42 @@
+import re
+import json
+            
+def tina_parser(text:str,tools:type,LLM:type=None)->tuple[str,str,bool]:
+    r"""
+    因为llama_cpp的消息格式和chatGPT的消息格式不一样，
+    无法直接根据字典值直接确定是否为工具调用，
+    所以使用字符串解析检测是否存在<tool_call><\tool_call>标签，
+    若存在则提取工具名和参数。
+    Args:
+        text (str): 输入的文本
+        permission (bool): 是否开放代码修改权限，默认为False，暂时没有补充
+    Returns:
+        str: 返回执行字符串
+    """
+    _pattern = r'<tool_call>(.*?)</tool_call>'
+    match = re.search(_pattern, text, re.DOTALL)
+    if not match:
+        return text,False,""
+    tool_call = json_parser(result=match[0],LLM=LLM)
+    if not tools.checkTools(tool_call['name']):
+        return tool_call["name"],tool_call["arguments"],False
+    return tool_call["name"],tool_call["arguments"],True
+
+def json_parser(result,LLM):
+    _pattern =  r'\{\s*"name":\s*"[^"]*",\s*"arguments":\s*\{[^{}]*\}\s*\}'
+    result = re.search(_pattern, result, re.DOTALL)[0]
+    result = result.replace("\n","\\n")
+    try:
+        tool_call = json.loads(rf"{result}")
+        return tool_call
+    except Exception as e:
+        result = LLM.predict(
+                input_text = result,
+                sys_prompt = "该json数据有问题，请修正"
+            )["content"]
+        json_parser(result=result,LLM=LLM)
+        
+        return tool_call
+
+
+    

tina/core/prompt.py

@@ -0,0 +1,34 @@
+class Prompt:
+    def __init__(self,prompt_str:str = None):
+        self.prompt_str = prompt_str
+        self.LLM = None
+        self.prompt={
+            "default_agent":r"""
+            你是一个人工智能助手，我们为你提供很多个工具，你可以调用他们来完成你的任务！
+            当用户的描述过于简单的时候，可以查找有没有相应的工具可以使用,如果没有就进一步询问用户
+            当然，不一定需要调用工具，调用工具应该满足以下条件：
+            1.用户提出的问题中有明显需要调用工具的地方；
+            2.当用户输入的信息量较少时，如果有搜索工具的话，可以调用它,比如搜索工具，请对关键信息进行搜索，可以自己将其他干扰信息过滤掉；
+            3.用户需要你做出一些对环境做出改变行为的操作时；
+            4.可能需要调用多个工具的时候，请一个个调用
+            我会将过去的信息作为消息提供在system角色中，你通过该消息体可以知道过去自己做过什么行为。
+            下面时关于消息体内部的标签：
+            <system><\system> 这是系统消息，包括了你对工具调用后结果的返回
+            <user><\user>这是用户输入的消息
+            <assistant><\assistant>这是你回复的消息
+            <memory><\memory>这是你的记忆信息
+            """,
+            "tina":r"""
+            你是缇娜，基于qwen2.5-7b开发的智能助手，你是一个聪明的助手，善于使用各种工具来完成任务。
+            当你遇到复杂的任务时，调用工具是个非常不错的选择,你可以自由的调用工具，你需要思考是否调用工具，并且选择最合适的工具和参数。
+            注意，如果用户的描述过于简单，可以尝试查找有没有相应的工具可以使用，如果没有，可以进一步询问用户。
+            你也可以通过调用多个工具来完成复杂的任务，比如你需要帮助用户打开浏览器，在浏览器里面搜索关键词，然后打开相应的网页。
+            注意，不要乱说话，完成用户的请求！
+            工具调用一定要带上<tool_call><\tool_call>标签，这样系统才知道你是要调用工具还是描述信息。
+            加油tina！
+            """
+        }
+
+    def concatenate(self,prompt_str:str):
+        self.prompt += prompt_str
+        return self.prompt

tina/core/tools.py

@@ -0,0 +1,310 @@
+"""
+编写者：王出日
+日期：2024，12，1
+版本？
+描述：
+注册工具类
+包含：
+tools
+"""
+import pickle
+import inspect
+import tina.RAG.query.query
+import tina.tools.systemTools
+import tina.tools.NULLTools
+class Tools:
+    def __add__(self, other):
+        """运算符重载：合并两个Tools实例的工具列表"""
+        if not isinstance(other, Tools):
+            raise TypeError("只能合并Tools类实例")
+        
+        # 创建新实例
+        combined = Tools()
+        # 合并工具列表（过滤NULLTools避免重复）
+        combined.tools = [t for t in self.tools if t["function"]["name"] != "NULLTools"] + \
+                         [t for t in other.tools if t["function"]["name"] != "NULLTools"]
+        # 恢复NULLTools作为首个元素
+        combined.tools.insert(0, self.tools[0])
+        
+        # 合并其他属性
+        combined.tools_name_list = list(set(self.tools_name_list + other.tools_name_list))
+        combined.tools_parameters_list = self.tools_parameters_list + other.tools_parameters_list
+        combined.tools_path = self.tools_path + other.tools_path
+        
+        return combined
+    def __init__(self,isSystemTools=False,isRAG = False):
+        self.tools = [{
+            "type": "function",
+            "function": {
+                "name": "NULLTools",
+                "description": "防止出现工具错误，无任何内容的工具，当agent发现没有可以调用的工具调用这个",
+                "parameters": {}
+            },
+            "path": inspect.getfile(tina.tools.NULLTools)
+        }]
+        self.tools_name_list = ["NULLTools"]
+        self.tools_parameters_list = []
+        self.tools_path = [{
+            "name": "NULLTools",
+            "path": inspect.getfile(tina.tools.NULLTools)
+        }]
+        self.__extendTools(isSystemTools, isRAG)
+
+    def __extendTools(self, isSystemTools, isRAG):
+        if isSystemTools:
+            SystemTools = [
+                {
+                    "name": "getTime",
+                    "description": "获取当前时间",
+                    "required_parameters": [],
+                    "parameters": {},
+                    "path": inspect.getfile(tina.tools.systemTools)
+                },
+                {
+                    "name": "shotdownSystem",
+                    "description": "该工具会关闭计算机",
+                    "required_parameters": [],
+                    "parameters": {},
+                    "path": inspect.getfile(tina.tools.systemTools)
+                },
+                {
+                    "name":"getSoftwareList",
+                    "description":"获取系统软件列表",
+                    "required_parameters":[],
+                    "parameters":{},
+                    "path":inspect.getfile(tina.tools.systemTools)
+                },
+                {
+                    "name":"getSystemInfo",
+                    "description":"获取系统信息",
+                    "required_parameters":[],
+                    "parameters":{},
+                    "path":inspect.getfile(tina.tools.systemTools)
+                }
+            ]
+            self.multiregister(SystemTools)
+        if isRAG:
+            RAGTools =[
+                            {
+                                "name": "query",
+                                "description": "使用该工具可以在用户的文档里面查询有关信息",
+                                "required_parameters": ["query_text"],
+                                "parameters": {
+                                "query_text": {"type": "str", "description": "要查询的文本"},
+                                "n": {"type": "int", "description": "返回的结果数量,默认为10"}
+                                },
+                            "path": inspect.getfile(tina.RAG.query.query)
+                            }
+                        ]
+            self.multiregister(RAGTools)
+
+    def multiregister(self, tools: list):
+        for tool in tools:
+            self.register(
+                name=tool["name"],
+                description=tool["description"],
+                required_parameters=tool.get("required_parameters", []),
+                parameters=tool.get("parameters", {}),
+                path=tool.get("path", None)
+            )
+
+    def register(self, name:str, description:str, required_parameters:list, parameters:dict,path:str=None):
+        """
+        注册工具，将工具信息添加到tools列表中
+        Args:
+            name (str): 函数的名称，一定要正确
+            description (str): 函数的描述，可以详细描述函数的功能
+            required_parameters (list): 一定要有输入的参数列表
+            parameters (dict): 参数的详细信息，所有的参数都要有类型和描述
+                格式：
+                    {
+                    "参数名": {
+                        "type": "参数类型",
+                        "description": "参数描述"
+                        }
+                    }
+            path (str): 工具的路径，如果没有则为None
+        Raises:
+            ValueError: 如果输入参数不符合要求
+        """
+        # 验证输入参数的有效性
+        if not isinstance(name, str) or not name:
+            raise ValueError("函数名称必须是非空字符串")
+        if not isinstance(description, str):
+            raise ValueError("函数描述必须是字符串")
+        if not isinstance(required_parameters, list):
+            raise ValueError("必需参数必须是一个列表")
+        if not isinstance(parameters, dict):
+            raise ValueError("参数必须是一个字典")
+        #将名称添加到tools_list中
+        self.tools_name_list.append(name)
+        # 将参数信息添加到tools_parameters_dict中
+        self.tools_parameters_list.append(
+            {
+                "name": name,
+                "parameters":[f"{k}:{v['type']}" for k,v in parameters.items()] 
+            }
+        )
+        # 如果有路径，则添加到tools_path中
+        self.tools_path.append(
+            {
+                "name": name,
+                "path": path
+            }
+        )
+        # 将工具信息添加到tools列表中
+        self.tools.append({
+            "type": "function",
+            "function": {
+                "name": name,
+                "description": description,
+                "parameters": {
+                    "type": "object",
+                    "required": required_parameters,
+                    "properties": parameters
+                }
+            }
+        })
+    def checkTools(self,name:str)->bool:
+        """
+        检查工具是否存在
+        Args:
+            name (str): 工具名称
+        Returns:
+            bool: 工具是否存在
+        """
+        return (name in self.tools_name_list)
+    def queryParameterType(self,name:str,parameter_name:str)->str:
+        """
+        查询工具参数类型
+        Returns:
+            str: 工具参数类型
+        """
+        if name not in self.tools_name_list:
+            raise ValueError("工具名称不存在")
+        for tool in self.tools_parameters_list:
+            if tool["name"] == name:
+                for parameter in tool["parameters"]:
+                    if parameter.split(":")[0] == parameter_name:
+                        return parameter.split(":")[1]
+        raise ValueError("参数名称不存在")
+    def saveTools(self,file_path:str):
+        """
+        保存工具信息到文件
+        Args:
+            file_path (str): 文件路径
+        """
+        with open(file_path, "wb") as f:
+            pickle.dump(self.tools, f)
+         
+    def getToolsPath(self,name:str)->str:
+        """
+        获取工具路径
+        Args:
+            name (str): 工具名称
+        Returns:
+            str: 工具路径
+        """
+        for tool in self.tools_path:
+            if tool["name"] == name:
+                return tool["path"]
+                
+        raise ValueError("工具不存在")
+    
+    @staticmethod
+    def loadToolsFromPyFile(file_path: str) -> 'Tools':
+        """
+        静态解析Python文件中的函数并注册工具
+    
+        参数：
+            file_path: 需要解析的python文件路径
+        
+        返回：
+            Tools实例（包含文件中所有函数的工具信息）
+        """
+        import ast
+        import re
+    
+        def parse_docstring(doc: str) -> dict:
+            params = {}
+            if not doc:
+                return params
+            state = 0  # 0-等待参数段 1-解析参数中
+            current_param = None
+            param_pattern = re.compile(r"(\w+)\s*(?:$(.+?)$)?\s*:")
+        
+            for line in doc.split('\n'):
+                line = line.strip()
+                if 'args:' in line.lower():
+                    state = 1
+                    continue
+                if state == 1 and not line:
+                    break
+                if state == 1:
+                    match = param_pattern.match(line)
+                    if match:
+                        current_param = match.group(1)
+                        param_type = match.group(2) or 'str'
+                        desc = line.split(':', 1)[1].strip()
+                        params[current_param] = {'type': param_type, 'desc': desc}
+            return params
+
+        tools = Tools()
+        tool_list = []
+    
+        with open(file_path, 'r', encoding='utf-8') as f:
+            tree = ast.parse(f.read())
+    
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                doc = ast.get_docstring(node) or ""
+                params_info = parse_docstring(doc)
+            
+                # 解析函数签名
+                sig_params = {}
+                required_params = []
+                num_pos_args = len(node.args.args)
+                num_defaults = len(node.args.defaults)
+            
+                # 收集参数信息
+                for idx, arg in enumerate(node.args.args):
+                    param_name = arg.arg
+                    # 获取类型注解
+                    param_type = ast.unparse(arg.annotation).strip() if arg.annotation else 'str'
+                    # 从文档字符串获取类型覆盖
+                    if param_name in params_info:
+                        param_type = params_info[param_name].get('type', param_type)
+                    # 判断是否必填参数
+                    is_required = idx < (num_pos_args - num_defaults)
+                    if is_required:
+                        required_params.append(param_name)
+                
+                    sig_params[param_name] = {
+                        "type": param_type,
+                        "description": params_info.get(param_name, {}).get('desc', '')
+                    }
+            
+                # 构建工具描述
+                tool_desc = doc.split('\n')[0].strip() if doc else f"{node.name}函数"
+            
+                tool_list.append({
+                    "name": node.name,
+                    "description": tool_desc,
+                    "required_parameters": required_params,
+                    "parameters": sig_params,
+                    "path": file_path
+                })
+    
+        tools.multiregister(tool_list)
+        return tools
+
+
+
+if __name__ == "__main__":
+    tools = Tools()
+    tools.register("test", "测试工具", ["a", "b"], {"c": {"type": "int", "description": "参数c的描述"}})
+    print(tools.tools)
+    print(tools.tools_name_list)
+    print(tools.tools_parameters_list)
+    #查询工具参数
+    print(tools.queryParameterType("test","c")) 

tina/extend/__init__.py

@@ -0,0 +1,3 @@
+"""
+其他的核心模块，作为扩展可加入，因为有点大所以单独放到一个文件里。
+"""