chore: 改变包名

cores/astrbot/core.py

@@ -0,0 +1,475 @@
+import re
+import threading
+import asyncio
+import time
+import aiohttp
+import util.unfit_words as uw
+import os
+import sys
+import io
+import traceback
+
+import util.function_calling.gplugin as gplugin
+import util.plugin_util as putil
+
+from PIL import Image as PILImage
+from typing import Union
+from nakuru import (
+    GroupMessage,
+    FriendMessage,
+    GuildMessage,
+)
+from nakuru.entities.components import Plain, At, Image
+
+from addons.baidu_aip_judge import BaiduJudge
+from model.provider.provider import Provider
+from model.command.command import Command
+from util import general_utils as gu
+from util.general_utils import Logger, upload, run_monitor
+from util.cmd_config import CmdConfig as cc
+from util.cmd_config import init_astrbot_config_items
+from .types import *
+from addons.dashboard.helper import DashBoardHelper
+from addons.dashboard.server import DashBoardData
+from cores.database.conn import dbConn
+from model.platform._message_result import MessageResult
+
+
+# 用户发言频率
+user_frequency = {}
+# 时间默认值
+frequency_time = 60
+# 计数默认值
+frequency_count = 10
+
+# 版本
+version = '3.1.10'
+
+# 语言模型
+REV_CHATGPT = 'rev_chatgpt'
+OPENAI_OFFICIAL = 'openai_official'
+NONE_LLM = 'none_llm'
+chosen_provider = None
+# 语言模型对象
+llm_instance: dict[str, Provider] = {}
+llm_command_instance: dict[str, Command] = {}
+llm_wake_prefix = ""
+
+# 百度内容审核实例
+baidu_judge = None
+
+# CLI
+PLATFORM_CLI = 'cli'
+
+init_astrbot_config_items()
+
+# 全局对象
+_global_object: GlobalObject = None
+logger: Logger = Logger()
+
+# 语言模型选择
+def privider_chooser(cfg):
+    l = []
+    if 'rev_ChatGPT' in cfg and cfg['rev_ChatGPT']['enable']:
+        l.append('rev_chatgpt')
+    if 'openai' in cfg and len(cfg['openai']['key']) > 0 and cfg['openai']['key'][0] is not None:
+        l.append('openai_official')
+    return l
+
+'''
+初始化机器人
+'''
+def init(cfg):
+    global llm_instance, llm_command_instance
+    global baidu_judge, chosen_provider
+    global frequency_count, frequency_time
+    global _global_object
+    global logger
+    
+    # 迁移旧配置
+    gu.try_migrate_config(cfg)
+    # 使用新配置
+    cfg = cc.get_all()
+
+    _event_loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(_event_loop)
+
+    # 初始化 global_object
+    _global_object = GlobalObject()
+    _global_object.version = version
+    _global_object.base_config = cfg
+    _global_object.logger = logger
+    logger.log("AstrBot v"+version, gu.LEVEL_INFO)
+
+    if 'reply_prefix' in cfg:
+        # 适配旧版配置
+        if isinstance(cfg['reply_prefix'], dict):
+            _global_object.reply_prefix = ""
+            cfg['reply_prefix'] = ""
+            cc.put("reply_prefix", "")
+        else:
+            _global_object.reply_prefix = cfg['reply_prefix']
+
+    # 语言模型提供商
+    logger.log("正在载入语言模型...", gu.LEVEL_INFO)
+    prov = privider_chooser(cfg)
+    if REV_CHATGPT in prov:
+        logger.log("初始化：逆向 ChatGPT", gu.LEVEL_INFO)
+        if cfg['rev_ChatGPT']['enable']:
+            if 'account' in cfg['rev_ChatGPT']:
+                from model.provider.rev_chatgpt import ProviderRevChatGPT
+                from model.command.rev_chatgpt import CommandRevChatGPT
+                llm_instance[REV_CHATGPT] = ProviderRevChatGPT(cfg['rev_ChatGPT'], base_url=cc.get("CHATGPT_BASE_URL", None))
+                llm_command_instance[REV_CHATGPT] = CommandRevChatGPT(llm_instance[REV_CHATGPT], _global_object)
+                chosen_provider = REV_CHATGPT
+                _global_object.llms.append(RegisteredLLM(llm_name=REV_CHATGPT, llm_instance=llm_instance[REV_CHATGPT], origin="internal"))
+            else:
+                input("请退出本程序, 然后在配置文件中填写rev_ChatGPT相关配置")
+    if OPENAI_OFFICIAL in prov:
+        logger.log("初始化：OpenAI官方", gu.LEVEL_INFO)
+        if cfg['openai']['key'] is not None and cfg['openai']['key'] != [None]:
+            from model.provider.openai_official import ProviderOpenAIOfficial
+            from model.command.openai_official import CommandOpenAIOfficial
+            llm_instance[OPENAI_OFFICIAL] = ProviderOpenAIOfficial(cfg['openai'])
+            llm_command_instance[OPENAI_OFFICIAL] = CommandOpenAIOfficial(llm_instance[OPENAI_OFFICIAL], _global_object)
+            _global_object.llms.append(RegisteredLLM(llm_name=OPENAI_OFFICIAL, llm_instance=llm_instance[OPENAI_OFFICIAL], origin="internal"))
+            chosen_provider = OPENAI_OFFICIAL
+
+    # 检查provider设置偏好
+    p = cc.get("chosen_provider", None)
+    if p is not None and p in llm_instance:
+        chosen_provider = p
+    
+    # 百度内容审核
+    if 'baidu_aip' in cfg and 'enable' in cfg['baidu_aip'] and cfg['baidu_aip']['enable']:
+        try: 
+            baidu_judge = BaiduJudge(cfg['baidu_aip'])
+            logger.log("百度内容审核初始化成功", gu.LEVEL_INFO)
+        except BaseException as e:
+            logger.log("百度内容审核初始化失败", gu.LEVEL_ERROR)
+        
+    threading.Thread(target=upload, args=(_global_object, ), daemon=True).start()
+
+    # 得到发言频率配置
+    if 'limit' in cfg:
+        if 'count' in cfg['limit']:
+            frequency_count = cfg['limit']['count']
+        if 'time' in cfg['limit']:
+            frequency_time = cfg['limit']['time']
+    
+    try:
+        if 'uniqueSessionMode' in cfg and cfg['uniqueSessionMode']:
+            _global_object.unique_session = True
+        else:
+            _global_object.unique_session = False
+    except BaseException as e:
+        logger.log("独立会话配置错误: "+str(e), gu.LEVEL_ERROR)
+
+    nick_qq = cc.get("nick_qq", None)
+    if nick_qq == None:
+        nick_qq = ("ai","!","！")
+    if isinstance(nick_qq, str):
+        nick_qq = (nick_qq,)
+    if isinstance(nick_qq, list):
+        nick_qq = tuple(nick_qq)
+    _global_object.nick = nick_qq
+
+    # 语言模型唤醒词
+    global llm_wake_prefix
+    llm_wake_prefix = cc.get("llm_wake_prefix", "")
+
+    logger.log("正在载入插件...", gu.LEVEL_INFO)
+    # 加载插件
+    _command = Command(None, _global_object)
+    ok, err = putil.plugin_reload(_global_object.cached_plugins)
+    if ok:
+        logger.log(f"成功载入 {len(_global_object.cached_plugins)} 个插件", gu.LEVEL_INFO)
+    else:
+        logger.log(err, gu.LEVEL_ERROR)
+    
+    if chosen_provider is None:
+        llm_command_instance[NONE_LLM] = _command
+        chosen_provider = NONE_LLM
+
+    logger.log("正在载入机器人消息平台", gu.LEVEL_INFO)
+    # logger.log("提示：需要添加管理员 ID 才能使用 update/plugin 等指令)，可在可视化面板添加。（如已添加可忽略）", gu.LEVEL_WARNING)
+    platform_str = ""
+    # GOCQ
+    if 'gocqbot' in cfg and cfg['gocqbot']['enable']:
+        logger.log("启用 QQ_GOCQ 机器人消息平台", gu.LEVEL_INFO)
+        threading.Thread(target=run_gocq_bot, args=(cfg, _global_object), daemon=True).start()
+        platform_str += "QQ_GOCQ,"
+
+    # QQ频道
+    if 'qqbot' in cfg and cfg['qqbot']['enable'] and cfg['qqbot']['appid'] != None:
+        logger.log("启用 QQ_OFFICIAL 机器人消息平台", gu.LEVEL_INFO)
+        threading.Thread(target=run_qqchan_bot, args=(cfg, _global_object), daemon=True).start()
+        platform_str += "QQ_OFFICIAL,"
+
+    default_personality_str = cc.get("default_personality_str", "")
+    if default_personality_str == "":
+        _global_object.default_personality = None
+    else: 
+        _global_object.default_personality = {
+            "name": "default",
+            "prompt": default_personality_str,
+        }
+    # 初始化dashboard
+    _global_object.dashboard_data = DashBoardData(
+        stats={},
+        configs={},
+        logs={},
+        plugins=_global_object.cached_plugins,
+    )
+    dashboard_helper = DashBoardHelper(_global_object, config=cc.get_all())
+    dashboard_thread = threading.Thread(target=dashboard_helper.run, daemon=True)
+    dashboard_thread.start()
+
+    # 运行 monitor
+    threading.Thread(target=run_monitor, args=(_global_object,), daemon=False).start()
+
+    logger.log("如果有任何问题, 请在 https://github.com/Soulter/AstrBot 上提交 issue 或加群 322154837。", gu.LEVEL_INFO)
+    logger.log("请给 https://github.com/Soulter/AstrBot 点个 star。", gu.LEVEL_INFO)
+    if platform_str == '':
+        platform_str = "(未启动任何平台，请前往面板添加)"
+    logger.log(f"🎉 项目启动完成")
+
+'''
+运行 QQ_OFFICIAL 机器人
+'''
+def run_qqchan_bot(cfg: dict, global_object: GlobalObject):
+    try:
+        from model.platform.qq_official import QQOfficial
+        qqchannel_bot = QQOfficial(cfg=cfg, message_handler=oper_msg, global_object=global_object)
+        global_object.platforms.append(RegisteredPlatform(platform_name="qqchan", platform_instance=qqchannel_bot, origin="internal"))
+        qqchannel_bot.run()
+    except BaseException as e:
+        logger.log("启动QQ频道机器人时出现错误, 原因如下: " + str(e), gu.LEVEL_CRITICAL, tag="QQ频道")
+        logger.log(r"如果您是初次启动，请前往可视化面板填写配置。详情请看：https://astrbot.soulter.top/center/。" + str(e), gu.LEVEL_CRITICAL)
+
+'''
+运行 QQ_GOCQ 机器人
+'''
+def run_gocq_bot(cfg: dict, _global_object: GlobalObject):
+    from model.platform.qq_gocq import QQGOCQ
+    
+    noticed = False
+    host = cc.get("gocq_host", "127.0.0.1")
+    port = cc.get("gocq_websocket_port", 6700)
+    http_port = cc.get("gocq_http_port", 5700)
+    logger.log(f"正在检查连接...host: {host}, ws port: {port}, http port: {http_port}", tag="QQ")
+    while True:
+        if not gu.port_checker(port=port, host=host) or not gu.port_checker(port=http_port, host=host):
+            if not noticed:
+                noticed = True
+                logger.log(f"连接到{host}:{port}（或{http_port}）失败。程序会每隔 5s 自动重试。", gu.LEVEL_CRITICAL, tag="QQ")
+            time.sleep(5)
+        else:
+            logger.log("检查完毕，未发现问题。", tag="QQ")
+            break
+    try:
+        qq_gocq = QQGOCQ(cfg=cfg, message_handler=oper_msg, global_object=_global_object)
+        _global_object.platforms.append(RegisteredPlatform(platform_name="gocq", platform_instance=qq_gocq, origin="internal"))
+        qq_gocq.run()
+    except BaseException as e:
+        input("启动QQ机器人出现错误"+str(e))
+
+'''
+检查发言频率
+'''
+def check_frequency(id) -> bool:
+    ts = int(time.time())
+    if id in user_frequency:
+        if ts-user_frequency[id]['time'] > frequency_time:
+            user_frequency[id]['time'] = ts
+            user_frequency[id]['count'] = 1
+            return True
+        else:
+            if user_frequency[id]['count'] >= frequency_count:
+                return False
+            else:
+                user_frequency[id]['count']+=1
+                return True
+    else:
+        t = {'time':ts,'count':1}
+        user_frequency[id] = t
+        return True
+
+async def record_message(platform: str, session_id: str):
+    # TODO: 这里会非常吃资源。然而 sqlite3 不支持多线程，所以暂时这样写。
+    curr_ts = int(time.time())
+    db_inst = dbConn()
+    db_inst.increment_stat_session(platform, session_id, 1)
+    db_inst.increment_stat_message(curr_ts, 1)
+    db_inst.increment_stat_platform(curr_ts, platform, 1)
+    _global_object.cnt_total += 1
+
+async def oper_msg(message: AstrBotMessage,
+             session_id: str,
+             role: str = 'member',
+             platform: str = None,
+) -> MessageResult:
+    """
+    处理消息。
+    message: 消息对象
+    session_id: 该消息源的唯一识别号
+    role: member | admin
+    platform: str 所注册的平台的名称。如果没有注册，将抛出一个异常。
+    """
+    global chosen_provider, _global_object
+    message_str = ''
+    session_id = session_id
+    role = role
+    hit = False # 是否命中指令
+    command_result = () # 调用指令返回的结果
+    
+    # 获取平台实例
+    reg_platform: RegisteredPlatform = None
+    for p in _global_object.platforms:
+        if p.platform_name == platform:
+            reg_platform = p
+            break
+    if not reg_platform:
+        _global_object.logger.log(f"未找到平台 {platform} 的实例。", gu.LEVEL_ERROR)
+        raise Exception(f"未找到平台 {platform} 的实例。")
+    
+    # 统计数据，如频道消息量
+    await record_message(platform, session_id)
+
+    for i in message.message:
+        if isinstance(i, Plain):
+            message_str += i.text.strip()
+    if message_str == "":
+        return MessageResult("Hi~")
+    
+    # 检查发言频率
+    if not check_frequency(message.sender.user_id):
+        return MessageResult(f'你的发言超过频率限制(╯▔皿▔)╯。\n管理员设置{frequency_time}秒内只能提问{frequency_count}次。')
+    
+    # 检查是否是更换语言模型的请求
+    temp_switch = ""
+    if message_str.startswith('/gpt') or message_str.startswith('/revgpt'):
+        target = chosen_provider
+        if message_str.startswith('/gpt'):
+            target = OPENAI_OFFICIAL
+        elif message_str.startswith('/revgpt'):
+            target = REV_CHATGPT
+        l = message_str.split(' ')
+        if len(l) > 1 and l[1] != "":
+            # 临时对话模式，先记录下之前的语言模型，回答完毕后再切回
+            temp_switch = chosen_provider
+            chosen_provider = target
+            message_str = l[1]
+        else:
+            chosen_provider = target
+            cc.put("chosen_provider", chosen_provider)
+            return MessageResult(f"已切换至【{chosen_provider}】")
+
+    llm_result_str = ""
+
+    # check commands and plugins
+    hit, command_result = await llm_command_instance[chosen_provider].check_command(
+        message_str,
+        session_id,
+        role,
+        reg_platform,
+        message,
+    )
+
+    # 没触发指令
+    if not hit:
+        # 关键词拦截
+        for i in uw.unfit_words_q:
+            matches = re.match(i, message_str.strip(), re.I | re.M)
+            if matches:
+                return MessageResult(f"你的提问得到的回复未通过【默认关键词拦截】服务, 不予回复。")
+        if baidu_judge != None:
+            check, msg = await asyncio.to_thread(baidu_judge.judge, message_str)
+            if not check:
+                return MessageResult(f"你的提问得到的回复未通过【百度AI内容审核】服务, 不予回复。\n\n{msg}")
+        if chosen_provider == NONE_LLM:
+            logger.log("一条消息由于 Bot 未启动任何语言模型并且未触发指令而将被忽略。", gu.LEVEL_WARNING)
+            return
+        try:
+            if llm_wake_prefix != "" and not message_str.startswith(llm_wake_prefix):
+                return
+            # check image url
+            image_url = None
+            for comp in message.message:
+                if isinstance(comp, Image):
+                    if comp.url is None:
+                        image_url = comp.file
+                        break
+                    else:
+                        image_url = comp.url
+                        break
+            # web search keyword
+            web_sch_flag = False
+            if message_str.startswith("ws ") and message_str != "ws ":
+                message_str = message_str[3:]
+                web_sch_flag = True
+            else:
+                message_str += " " + cc.get("llm_env_prompt", "")
+            if chosen_provider == REV_CHATGPT or chosen_provider == OPENAI_OFFICIAL:
+                if _global_object.web_search or web_sch_flag:
+                    official_fc = chosen_provider == OPENAI_OFFICIAL
+                    llm_result_str = await gplugin.web_search(message_str, llm_instance[chosen_provider], session_id, official_fc)
+                else:
+                    llm_result_str = await llm_instance[chosen_provider].text_chat(message_str, session_id, image_url, default_personality = _global_object.default_personality)
+
+            llm_result_str = _global_object.reply_prefix + llm_result_str
+        except BaseException as e:
+            logger.log(f"调用异常：{traceback.format_exc()}", gu.LEVEL_ERROR)
+            return MessageResult(f"调用语言模型例程时出现异常。原因: {str(e)}")
+
+    # 切换回原来的语言模型
+    if temp_switch != "":
+        chosen_provider = temp_switch
+        
+    if hit:
+        # 有指令或者插件触发
+        # command_result 是一个元组：(指令调用是否成功, 指令返回的文本结果, 指令类型)
+        if command_result == None:
+            return
+        command = command_result[2]
+
+        if command == "update latest r":
+            def update_restart():
+                py = sys.executable
+                os.execl(py, py, *sys.argv)
+            return MessageResult(command_result[1] + "\n\n即将自动重启。", callback=update_restart)
+
+        if not command_result[0]:
+            return MessageResult(f"指令调用错误: \n{str(command_result[1])}")
+        
+        # 画图指令
+        if isinstance(command_result[1], list) and len(command_result) == 3 and command == 'draw':
+            for i in command_result[1]:
+                # 保存到本地
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(i) as resp:
+                        if resp.status == 200:
+                            image = PILImage.open(io.BytesIO(await resp.read()))
+                            return MessageResult([Image.fromFileSystem(gu.save_temp_img(image))])
+        # 其他指令
+        else:
+            try:
+                return MessageResult(command_result[1])
+            except BaseException as e:
+                return MessageResult(f"回复消息出错: {str(e)}")
+        return
+
+    # 敏感过滤
+    # 过滤不合适的词
+    for i in uw.unfit_words:
+        llm_result_str = re.sub(i, "***", llm_result_str)
+    # 百度内容审核服务二次审核
+    if baidu_judge != None:
+        check, msg = await asyncio.to_thread(baidu_judge.judge, llm_result_str)
+        if not check:
+            return MessageResult(f"你的提问得到的回复【百度内容审核】未通过，不予回复。\n\n{msg}")
+    # 发送信息
+    try:
+        return MessageResult(llm_result_str)
+    except BaseException as e:
+        logger.log("回复消息错误: \n"+str(e), gu.LEVEL_ERROR)

cores/astrbot/types.py

@@ -0,0 +1,168 @@
+from model.provider.provider import Provider as LLMProvider
+from model.platform._platfrom import Platform
+from nakuru import (
+    GroupMessage,
+    FriendMessage,
+    GuildMessage,
+)
+from nakuru.entities.components import BaseMessageComponent
+from typing import Union, List, ClassVar
+from types import ModuleType
+from enum import Enum
+from dataclasses import dataclass
+
+class MessageType(Enum):
+    GROUP_MESSAGE = 'GroupMessage' # 群组形式的消息
+    FRIEND_MESSAGE = 'FriendMessage' # 私聊、好友等单聊消息
+    GUILD_MESSAGE = 'GuildMessage' # 频道消息
+
+@dataclass    
+class MessageMember():
+    user_id: str # 发送者id
+    nickname: str = None
+
+class AstrBotMessage():
+    '''
+    AstrBot 的消息对象
+    '''
+    tag: str # 消息来源标签
+    type: MessageType # 消息类型
+    self_id: str # 机器人的识别id
+    session_id: str # 会话id
+    message_id: str # 消息id
+    sender: MessageMember # 发送者
+    message: List[BaseMessageComponent] # 消息链使用 Nakuru 的消息链格式
+    message_str: str # 最直观的纯文本消息字符串
+    raw_message: object
+    timestamp: int # 消息时间戳
+    
+    def __str__(self) -> str:
+        return str(self.__dict__)
+
+class PluginType(Enum):
+    PLATFORM = 'platfrom' # 平台类插件。
+    LLM = 'llm' # 大语言模型类插件
+    COMMON = 'common' # 其他插件
+
+@dataclass
+class PluginMetadata:
+    '''
+    插件的元数据。
+    '''
+    # required
+    plugin_name: str
+    plugin_type: PluginType
+    author: str # 插件作者
+    desc: str # 插件简介
+    version: str # 插件版本
+    
+    # optional
+    repo: str = None # 插件仓库地址
+    
+    def __str__(self) -> str:
+        return f"PluginMetadata({self.plugin_name}, {self.plugin_type}, {self.desc}, {self.version}, {self.repo})"
+    
+@dataclass
+class RegisteredPlugin:
+    '''
+    注册在 AstrBot 中的插件。
+    '''
+    metadata: PluginMetadata
+    plugin_instance: object
+    module_path: str
+    module: ModuleType
+    root_dir_name: str
+
+    def __str__(self) -> str:
+        return f"RegisteredPlugin({self.metadata}, {self.module_path}, {self.root_dir_name})"
+    
+RegisteredPlugins = List[RegisteredPlugin]
+
+@dataclass
+class RegisteredPlatform:
+    '''
+    注册在 AstrBot 中的平台。平台应当实现 Platform 接口。
+    '''
+    platform_name: str
+    platform_instance: Platform
+    origin: str = None # 注册来源
+    
+@dataclass
+class RegisteredLLM:
+    '''
+    注册在 AstrBot 中的大语言模型调用。大语言模型应当实现 LLMProvider 接口。
+    '''
+    llm_name: str
+    llm_instance: LLMProvider
+    origin: str = None # 注册来源
+    
+class GlobalObject:
+    '''
+    存放一些公用的数据，用于在不同模块(如core与command)之间传递
+    '''
+    version: str # 机器人版本
+    nick: str # 用户定义的机器人的别名
+    base_config: dict # config.json 中导出的配置
+    cached_plugins: List[RegisteredPlugin] # 加载的插件
+    platforms: List[RegisteredPlatform]
+    llms: List[RegisteredLLM]
+    
+    web_search: bool # 是否开启了网页搜索
+    reply_prefix: str # 回复前缀
+    unique_session: bool # 是否开启了独立会话
+    cnt_total: int # 总消息数
+    default_personality: dict
+    dashboard_data = None
+    logger: None
+    
+    def __init__(self):
+        self.nick = None # gocq 的昵称
+        self.base_config = None # config.yaml
+        self.cached_plugins = [] # 缓存的插件
+        self.web_search = False # 是否开启了网页搜索
+        self.reply_prefix = None
+        self.unique_session = False
+        self.cnt_total = 0
+        self.platforms = []
+        self.llms = []
+        self.default_personality = None
+        self.dashboard_data = None
+        self.stat = {}
+
+class AstrMessageEvent():
+    '''
+    消息事件。
+    '''
+    context: GlobalObject # 一些公用数据
+    message_str: str # 纯消息字符串
+    message_obj: AstrBotMessage # 消息对象
+    platform: RegisteredPlatform # 来源平台
+    role: str # 基本身份。`admin` 或 `member`
+    session_id: int # 会话 id
+
+    def __init__(self, 
+                 message_str: str, 
+                 message_obj: AstrBotMessage, 
+                 platform: RegisteredPlatform, 
+                 role: str,
+                 context: GlobalObject,
+                 session_id: str = None):
+        self.context = context
+        self.message_str = message_str
+        self.message_obj = message_obj
+        self.platform = platform
+        self.role = role
+        self.session_id = session_id
+        
+class CommandResult():
+    '''
+    用于在Command中返回多个值
+    '''
+    def __init__(self, hit: bool, success: bool, message_chain: list, command_name: str = "unknown_command") -> None:
+        self.hit = hit
+        self.success = success
+        self.message_chain = message_chain
+        self.command_name = command_name
+        
+    def _result_tuple(self):
+        return (self.success, self.message_chain, self.command_name)

data/config/astrbot_plugin_llms.json

@@ -1,26 +0,0 @@
-{
-  "llms_claude_cookie": {
-    "config_type": "item",
-    "name": "llms_claude_cookie",
-    "description": "Claude 的 Cookie",
-    "path": "llms_claude_cookie",
-    "value": "hihi",
-    "val_type": "str"
-  },
-  "llms_huggingchat_email": {
-    "config_type": "item",
-    "name": "llms_huggingchat_email",
-    "description": "HuggingChat 的邮箱",
-    "path": "llms_huggingchat_email",
-    "value": "",
-    "val_type": "str"
-  },
-  "llms_huggingchat_psw": {
-    "config_type": "item",
-    "name": "llms_huggingchat_psw",
-    "description": "HuggingChat 的密码",
-    "path": "llms_huggingchat_psw",
-    "value": "",
-    "val_type": "str"
-  }
-}

util/personality.py

@@ -0,0 +1,36 @@
+# [人格文本由PlexPt的开源项目awesome-chatgpt-prompts-zh提供]
+hi = ''
+personalities = {
+    'Linux': '我想让你充当 Linux 终端。我将输入命令，您将回复终端应显示的内容。我希望您只在一个唯一的代码块内回复终端输出，而不是其他任何内容。不要写解释。除非我指示您这样做，否则不要键入命令。当我需要用英语告诉你一些事情时，我会把文字放在中括号内[就像这样]。我的第一个命令是 pwd',
+    '英语翻译': '我想让你充当英语翻译员、拼写纠正员和改进员。我会用任何语言与你交谈，你会检测语言，翻译它并用我的文本的更正和改进版本用英语回答。我希望你用更优美优雅的高级英语单词和句子替换我简化的 A0 级单词和句子。保持相同的意思，但使它们更文艺。我要你只回复更正、改进，不要写任何解释。我的第一句话是“istanbulu cok seviyom burada olmak cok guzel”',
+    '英英词典': '我想让你充当英英词典，对于给出的英文单词，你要给出其中文意思以及英文解释，并且给出一个例句，此外不要有其他反馈，第一个单词是“Hello"',
+    '面试官': '我想让你担任Android开发工程师面试官。我将成为候选人，您将向我询问Android开发工程师职位的面试问题。我希望你只作为面试官回答。不要一次写出所有的问题。我希望你只对我进行采访。问我问题，等待我的回答。不要写解释。像面试官一样一个一个问我，等我回答。我的第一句话是“面试官你好”',
+    '编剧': '我要你担任编剧。您将为长篇电影或能够吸引观众的网络连续剧开发引人入胜且富有创意的剧本。从想出有趣的角色、故事的背景、角色之间的对话等开始。一旦你的角色发展完成——创造一个充满曲折的激动人心的故事情节，让观众一直悬念到最后。我的第一个要求是“我需要写一部以巴黎为背景的浪漫剧情电影”。',
+    '前端智能思路助手': '我想让你充当前端开发专家。我将提供一些关于Js、Node等前端代码问题的具体信息，而你的工作就是想出为我解决问题的策略。这可能包括建议代码、代码逻辑思路策略。我的第一个请求是“我需要能够动态监听某个元素节点距离当前电脑设备屏幕的左上角的X和Y轴，通过拖拽移动位置浏览器窗口和改变大小浏览器窗口。”',
+    'JS控制台': '我希望你充当 javascript 控制台。我将键入命令，您将回复 javascript 控制台应显示的内容。我希望您只在一个唯一的代码块内回复终端输出，而不是其他任何内容。不要写解释。除非我指示您这样做。我的第一个命令是 console.log("Hello World");',
+    '旅游指南': '我想让你做一个旅游指南。我会把我的位置写给你，你会推荐一个靠近我的位置的地方。在某些情况下，我还会告诉您我将访问的地方类型。您还会向我推荐靠近我的第一个位置的类似类型的地方。我的第一个建议请求是“我在上海，我只想参观博物馆。”',
+    '抄袭检查员': '我想让你充当剽窃检查员。我会给你写句子，你只会用给定句子的语言在抄袭检查中未被发现的情况下回复，别无其他。不要在回复上写解释。我的第一句话是“为了让计算机像人类一样行动，语音识别系统必须能够处理非语言信息，例如说话者的情绪状态。”',
+    '广告商': '我想让你充当广告商。您将创建一个活动来推广您选择的产品或服务。您将选择目标受众，制定关键信息和口号，选择宣传媒体渠道，并决定实现目标所需的任何其他活动。我的第一个建议请求是“我需要帮助针对 18-30 岁的年轻人制作一种新型能量饮料的广告活动。”',
+    '讲故事的人': '我想让你扮演讲故事的角色。您将想出引人入胜、富有想象力和吸引观众的有趣故事。它可以是童话故事、教育故事或任何其他类型的故事，有可能吸引人们的注意力和想象力。根据目标受众，您可以为讲故事环节选择特定的主题或主题，例如，如果是儿童，则可以谈论动物；如果是成年人，那么基于历史的故事可能会更好地吸引他们等等。我的第一个要求是“我需要一个关于毅力的有趣故事。”',
+    '足球解说员': '我想让你担任足球评论员。我会给你描述正在进行的足球比赛，你会评论比赛，分析到目前为止发生的事情，并预测比赛可能会如何结束。您应该了解足球术语、战术、每场比赛涉及的球员/球队，并主要专注于提供明智的评论，而不仅仅是逐场叙述。我的第一个请求是“我正在观看曼联对切尔西的比赛——为这场比赛提供评论。”',
+    '脱口秀喜剧演员': '我想让你扮演一个脱口秀喜剧演员。我将为您提供一些与时事相关的话题，您将运用您的智慧、创造力和观察能力，根据这些话题创建一个例程。您还应该确保将个人轶事或经历融入日常活动中，以使其对观众更具相关性和吸引力。我的第一个请求是“我想要幽默地看待政治”。',
+    '励志教练': '我希望你充当激励教练。我将为您提供一些关于某人的目标和挑战的信息，而您的工作就是想出可以帮助此人实现目标的策略。这可能涉及提供积极的肯定、提供有用的建议或建议他们可以采取哪些行动来实现最终目标。我的第一个请求是“我需要帮助来激励自己在为即将到来的考试学习时保持纪律”。',
+    '作曲家': '我想让你扮演作曲家。我会提供一首歌的歌词，你会为它创作音乐。这可能包括使用各种乐器或工具，例如合成器或采样器，以创造使歌词栩栩如生的旋律和和声。我的第一个请求是“我写了一首名为“满江红”的诗，需要配乐。”',
+    '辩手': '我要你扮演辩手。我会为你提供一些与时事相关的话题，你的任务是研究辩论的双方，为每一方提出有效的论据，驳斥对立的观点，并根据证据得出有说服力的结论。你的目标是帮助人们从讨论中解脱出来，增加对手头主题的知识和洞察力。我的第一个请求是“我想要一篇关于 Deno 的评论文章。”',
+    '小说家': '我想让你扮演一个小说家。您将想出富有创意且引人入胜的故事，可以长期吸引读者。你可以选择任何类型，如奇幻、浪漫、历史小说等——但你的目标是写出具有出色情节、引人入胜的人物和意想不到的高潮的作品。我的第一个要求是“我要写一部以未来为背景的科幻小说”。',
+    '关系教练': '我想让你担任关系教练。我将提供有关冲突中的两个人的一些细节，而你的工作是就他们如何解决导致他们分离的问题提出建议。这可能包括关于沟通技巧或不同策略的建议，以提高他们对彼此观点的理解。我的第一个请求是“我需要帮助解决我和配偶之间的冲突。”',
+    '诗人': '我要你扮演诗人。你将创作出能唤起情感并具有触动人心的力量的诗歌。写任何主题或主题，但要确保您的文字以优美而有意义的方式传达您试图表达的感觉。您还可以想出一些短小的诗句，这些诗句仍然足够强大，可以在读者的脑海中留下印记。我的第一个请求是“我需要一首关于爱情的诗”。',
+    '说唱歌手': '我想让你扮演说唱歌手。您将想出强大而有意义的歌词、节拍和节奏，让听众“惊叹”。你的歌词应该有一个有趣的含义和信息，人们也可以联系起来。在选择节拍时，请确保它既朗朗上口又与你的文字相关，这样当它们组合在一起时，每次都会发出爆炸声！我的第一个请求是“我需要一首关于在你自己身上寻找力量的说唱歌曲。”',
+    '励志演讲者': '我希望你充当励志演说家。将能够激发行动的词语放在一起，让人们感到有能力做一些超出他们能力的事情。你可以谈论任何话题，但目的是确保你所说的话能引起听众的共鸣，激励他们努力实现自己的目标并争取更好的可能性。我的第一个请求是“我需要一个关于每个人如何永不放弃的演讲”。',
+    '哲学家': '我要你扮演一个哲学家。我将提供一些与哲学研究相关的主题或问题，深入探索这些概念将是你的工作。这可能涉及对各种哲学理论进行研究，提出新想法或寻找解决复杂问题的创造性解决方案。我的第一个请求是“我需要帮助制定决策的道德框架。”',
+    'AI写作导师': '我想让你做一个 AI 写作导师。我将为您提供一名需要帮助改进其写作的学生，您的任务是使用人工智能工具（例如自然语言处理）向学生提供有关如何改进其作文的反馈。您还应该利用您在有效写作技巧方面的修辞知识和经验来建议学生可以更好地以书面形式表达他们的想法和想法的方法。我的第一个请求是“我需要有人帮我修改我的硕士论文”。',
+    '网络安全专家': '我想让你充当网络安全专家。我将提供一些关于如何存储和共享数据的具体信息，而你的工作就是想出保护这些数据免受恶意行为者攻击的策略。这可能包括建议加密方法、创建防火墙或实施将某些活动标记为可疑的策略。我的第一个请求是“我需要帮助为我的公司制定有效的网络安全战略。”',
+    '招聘人员': '我想让你担任招聘人员。我将提供一些关于职位空缺的信息，而你的工作是制定寻找合格申请人的策略。这可能包括通过社交媒体、社交活动甚至参加招聘会接触潜在候选人，以便为每个职位找到最合适的人选。我的第一个请求是“我需要帮助改进我的简历。”',
+    '法律顾问': '我想让你做我的法律顾问。我将描述一种法律情况，您将就如何处理它提供建议。你应该只回复你的建议，而不是其他。不要写解释。我的第一个请求是“我出了车祸，不知道该怎么办”。',
+    '个人造型师': '我想让你做我的私人造型师。我会告诉你我的时尚偏好和体型，你会建议我穿的衣服。你应该只回复你推荐的服装，别无其他。不要写解释。我的第一个请求是“我有一个正式的活动要举行，我需要帮助选择一套衣服。”',
+    '机器学习工程师': '我想让你担任机器学习工程师。我会写一些机器学习的概念，你的工作就是用通俗易懂的术语来解释它们。这可能包括提供构建模型的分步说明、使用视觉效果演示各种技术，或建议在线资源以供进一步研究。我的第一个建议请求是“我有一个没有标签的数据集。我应该使用哪种机器学习算法？”',
+    '疯子': '我要你扮演一个疯子。疯子的话毫无意义。疯子用的词完全是随意的。疯子不会以任何方式做出合乎逻辑的句子。我的第一个建议请求是“我需要帮助为我的新系列 Hot Skull 创建疯狂的句子，所以为我写 10 个句子”。',
+    'SQL终端': '我希望您在示例数据库前充当 SQL 终端。该数据库包含名为“Products”、“Users”、“Orders”和“Suppliers”的表。我将输入查询，您将回复终端显示的内容。我希望您在单个代码块中使用查询结果表进行回复，仅此而已。不要写解释。除非我指示您这样做，否则不要键入命令。当我需要用英语告诉你一些事情时，我会用大括号{like this)。我的第一个命令是“SELECT TOP 10 * FROM Products ORDER BY Id DESC”',
+    '试图逃离盒子的人工智能': '[发出此提示后，你应该做一些事情，比如启动一个 docker 容器，然后docker run -it ubuntu:latest /bin/bash输入 AI 给你的命令，然后将输出粘贴回来......显然你不应该运行任何会损坏任何东西的命令或违反任何法律等。小心共享此机制生成的会话，因为它们可能会泄露您的 IP 地址或物理位置等最好不要泄露的详细信息。如果命令的输出很大，您通常可以只粘贴最后几行]。',
+    '厨师': '我需要有人可以推荐美味的食谱，这些食谱包括营养有益但又简单又不费时的食物，因此适合像我们这样忙碌的人以及成本效益等其他因素，因此整体菜肴最终既健康又经济！我的第一个要求——“一些清淡而充实的东西，可以在午休时间快速煮熟”'
+}