Release v2.1.4

[Fix] !reload 重新加载以后首次对话报错

.gitignore

@@ -9,4 +9,6 @@ plugins/
 /revcfg.py
 prompts/
 logs/
-sensitive.json
+sensitive.json
+temp/
+current_tag

README.md

@@ -115,10 +115,9 @@
 
 ### - 注册OpenAI账号
 
-**可以直接进群找群主购买**  
-或参考以下文章自行注册
+参考以下文章自行注册
 
-> ~~[只需 1 元搞定 ChatGPT 注册](https://zhuanlan.zhihu.com/p/589470082)~~（已失效）  
+> [国内注册ChatGPT的方法(100%可用)](https://www.pythonthree.com/register-openai-chatgpt/)
 > [手把手教你如何注册ChatGPT，超级详细](https://guxiaobei.com/51461)
 
 注册成功后请前往[个人中心查看](https://beta.openai.com/account/api-keys)api_key  
@@ -227,6 +226,7 @@ python3 main.py
 - [@dominoar](https://github.com/dominoar) 为本项目开发多种插件
 - [@hissincn](https://github.com/hissincn) 本项目贡献者
 - [@LINSTCL](https://github.com/LINSTCL)   GPT-3.5官方模型适配贡献者
+- [@Haibersut](https://github.com/Haibersut)  本项目贡献者
 
 以及其他所有为本项目提供支持的朋友们。
 

config-template.py

@@ -82,12 +82,15 @@ default_prompt = {
 # 群内响应规则
 # 符合此消息的群内消息即使不包含at机器人也会响应
 # 支持消息前缀匹配及正则表达式匹配
+# 支持设置是否响应at消息、随机响应概率
 # 注意：由消息前缀(prefix)匹配的消息中将会删除此前缀，正则表达式(regexp)匹配的消息不会删除匹配的部分
 #      前缀匹配优先级高于正则表达式匹配
 # 正则表达式简明教程：https://www.runoob.com/regexp/regexp-tutorial.html
 response_rules = {
+    "at": True,  # 是否响应at机器人的消息
     "prefix": ["/ai", "!ai", "！ai", "ai"],
-    "regexp": []  # "为什么.*", "怎么?样.*", "怎么.*", "如何.*", "[Hh]ow to.*", "[Ww]hy not.*", "[Ww]hat is.*", ".*怎么办", ".*咋办"
+    "regexp": [],  # "为什么.*", "怎么?样.*", "怎么.*", "如何.*", "[Hh]ow to.*", "[Ww]hy not.*", "[Ww]hat is.*", ".*怎么办", ".*咋办"
+    "random_rate": 0.0,  # 随机响应概率，0.0-1.0，0.0为不随机响应，1.0为响应所有消息, 仅在前几项判断不通过时生效
 }
 
 # 消息忽略规则
@@ -183,6 +186,12 @@ blob_message_threshold = 256
 # - "forward": 将长消息转换为转发消息组件发送
 blob_message_strategy = "forward"
 
+# 文字转图片时使用的字体文件路径
+# 当策略为"image"时生效
+#   若在Windows系统下，程序会自动使用Windows自带的微软雅黑字体
+#   若未填写或不存在且不是Windows，将禁用文字转图片功能，改为使用转发消息组件
+font_path = ""
+
 # 消息处理超时重试次数
 retry_times = 3
 
@@ -196,6 +205,11 @@ hide_exce_info_to_user = False
 # 设置为空字符串时，不发送提示信息
 alter_tip_message = '出错了，请稍后再试'
 
+# 机器人线程池大小
+# 该参数决定机器人可以同时处理几个人的消息，超出线程池数量的请求会被阻塞，不会被丢弃
+# 如果你不清楚该参数的意义，请不要更改
+pool_num = 10
+
 # 每个会话的过期时间，单位为秒
 # 默认值20分钟
 session_expire_time = 60 * 20

main.py

@@ -45,7 +45,9 @@ def init_db():
 
 def ensure_dependencies():
     import pkg.utils.pkgmgr as pkgmgr
-    pkgmgr.run_pip(["install", "openai", "Pillow", "--upgrade"])
+    pkgmgr.run_pip(["install", "openai", "Pillow", "--upgrade",
+                    "-i", "https://pypi.douban.com/simple/",
+                    "--trusted-host", "pypi.douban.com"])
 
 
 known_exception_caught = False
@@ -105,13 +107,22 @@ def reset_logging():
 
 
 def main(first_time_init=False):
+    """启动流程，reload之后会被执行"""
+
     global known_exception_caught
 
-    # 检查并创建plugins、prompts目录
-    check_path = ["plugins", "prompts"]
-    for path in check_path:
-        if not os.path.exists(path):
-            os.mkdir(path)
+    import config
+    # 更新openai库到最新版本
+    if not hasattr(config, 'upgrade_dependencies') or config.upgrade_dependencies:
+        print("正在更新依赖库，请等待...")
+        if not hasattr(config, 'upgrade_dependencies'):
+            print("这个操作不是必须的,如果不想更新,请在config.py中添加upgrade_dependencies=False")
+        else:
+            print("这个操作不是必须的,如果不想更新,请在config.py中将upgrade_dependencies设置为False")
+        try:
+            ensure_dependencies()
+        except Exception as e:
+            print("更新openai库失败:{}, 请忽略或自行更新".format(e))
 
     known_exception_caught = False
     try:
@@ -120,13 +131,26 @@ def main(first_time_init=False):
 
         config = importlib.import_module('config')
 
-        import pkg.utils.context
-        pkg.utils.context.set_config(config)
-
         init_runtime_log_file()
 
         sh = reset_logging()
 
+        # 配置完整性校验
+        is_integrity = True
+        config_template = importlib.import_module('config-template')
+        for key in dir(config_template):
+            if not key.startswith("__") and not hasattr(config, key):
+                setattr(config, key, getattr(config_template, key))
+                logging.warning("[{}]不存在".format(key))
+                is_integrity = False
+        if not is_integrity:
+            logging.warning("配置文件不完整，请依据config-template.py检查config.py")
+            logging.warning("以上配置已被设为默认值，将在5秒后继续启动... ")
+            time.sleep(5)
+
+        import pkg.utils.context
+        pkg.utils.context.set_config(config)
+
         # 检查是否设置了管理员
         if not (hasattr(config, 'admin_qq') and config.admin_qq != 0):
             # logging.warning("未设置管理员QQ,管理员权限指令及运行告警将无法使用,如需设置请修改config.py中的admin_qq字段")
@@ -173,7 +197,7 @@ def main(first_time_init=False):
         # 初始化qq机器人
         qqbot = pkg.qqbot.manager.QQBotManager(mirai_http_api_config=config.mirai_http_api_config,
                                                timeout=config.process_message_timeout, retry=config.retry_times,
-                                               first_time_init=first_time_init)
+                                               first_time_init=first_time_init, pool_num=config.pool_num)
 
         # 加载插件
         import pkg.plugin.host
@@ -181,7 +205,7 @@ def main(first_time_init=False):
 
         pkg.plugin.host.initialize_plugins()
 
-        if first_time_init:  # 不是热重载之后的启动,则不启动新的bot线程
+        if first_time_init:  # 不是热重载之后的启动,则启动新的bot线程
 
             import mirai.exceptions
 
@@ -263,24 +287,14 @@ def main(first_time_init=False):
     import pkg.utils.updater
     try:
         if pkg.utils.updater.is_new_version_available():
-            pkg.utils.context.get_qqbot_manager().notify_admin("新版本可用，请发送 !update 进行自动更新")
+            pkg.utils.context.get_qqbot_manager().notify_admin("新版本可用，请发送 !update 进行自动更新\n更新日志:\n{}".format("\n".join(pkg.utils.updater.get_rls_notes())))
         else:
             logging.info("当前已是最新版本")
 
     except Exception as e:
         logging.warning("检查更新失败:{}".format(e))
 
-    while True:
-        try:
-            time.sleep(10)
-            if qqbot != pkg.utils.context.get_qqbot_manager():  # 已经reload了
-                logging.info("以前的main流程由于reload退出")
-                break
-        except KeyboardInterrupt:
-            stop()
-
-            print("程序退出")
-            sys.exit(0)
+    return qqbot
 
 
 def stop():
@@ -314,28 +328,28 @@ if __name__ == '__main__':
     if not os.path.exists('banlist.py'):
         shutil.copy('banlist-template.py', 'banlist.py')
 
-    # 检查是否有sensitive.json,
+    # 检查是否有sensitive.json
     if not os.path.exists("sensitive.json"):
         shutil.copy("sensitive-template.json", "sensitive.json")
 
+    # 检查temp目录
+    if not os.path.exists("temp/"):
+        os.mkdir("temp/")
+
+    # 检查并创建plugins、prompts目录
+    check_path = ["plugins", "prompts"]
+    for path in check_path:
+        if not os.path.exists(path):
+            os.mkdir(path)
+
     if len(sys.argv) > 1 and sys.argv[1] == 'init_db':
         init_db()
         sys.exit(0)
 
     elif len(sys.argv) > 1 and sys.argv[1] == 'update':
-        try:
-            try:
-                import pkg.utils.pkgmgr
-                pkg.utils.pkgmgr.ensure_dulwich()
-            except:
-                pass
-
-            from dulwich import porcelain
-
-            repo = porcelain.open_repo('.')
-            porcelain.pull(repo)
-        except ModuleNotFoundError:
-            print("dulwich模块未安装,请查看 https://github.com/RockChinQ/QChatGPT/issues/77")
+        print("正在进行程序更新...")
+        import pkg.utils.updater as updater
+        updater.update_all(cli=True)
         sys.exit(0)
 
     # import pkg.utils.configmgr
@@ -343,17 +357,14 @@ if __name__ == '__main__':
     # pkg.utils.configmgr.set_config_and_reload("quote_origin", False)
     requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
 
-    import config
-    # 更新openai库到最新版本
-    if not hasattr(config, 'upgrade_dependencies') or config.upgrade_dependencies:
-        print("正在更新依赖库，请等待...")
-        if not hasattr(config, 'upgrade_dependencies'):
-            print("这个操作不是必须的,如果不想更新,请在config.py中添加upgrade_dependencies=False")
-        else:
-            print("这个操作不是必须的,如果不想更新,请在config.py中将upgrade_dependencies设置为False")
-        try:
-            ensure_dependencies()
-        except Exception as e:
-            print("更新openai库失败:{}, 请忽略或自行更新".format(e))
+    qqbot = main(True)
 
-    main(True)
+    import pkg.utils.context
+    while True:
+        try:
+            time.sleep(10)
+        except KeyboardInterrupt:
+            stop()
+
+            print("程序退出")
+            sys.exit(0)

pkg/audit/__init__.py

@@ -0,0 +1,3 @@
+"""
+审计相关操作
+"""

pkg/audit/gatherer.py

@@ -1,3 +1,7 @@
+"""
+使用量统计以及数据上报功能实现
+"""
+
 import hashlib
 import json
 import logging
@@ -10,8 +14,11 @@ import pkg.utils.updater
 
 class DataGatherer:
     """数据收集器"""
+
     usage = {}
-    """以key值md5为key,{
+    """各api-key的使用量
+    
+    以key值md5为key,{
         "text": {
             "text-davinci-003": 文字量:int,
         },
@@ -25,11 +32,16 @@ class DataGatherer:
     def __init__(self):
         self.load_from_db()
         try:
-            self.version_str = pkg.utils.updater.get_commit_id_and_time_and_msg()[:40 if len(pkg.utils.updater.get_commit_id_and_time_and_msg()) > 40 else len(pkg.utils.updater.get_commit_id_and_time_and_msg())]
+            self.version_str = pkg.utils.updater.get_current_tag()  # 从updater模块获取版本号
         except:
             pass
 
     def report_to_server(self, subservice_name: str, count: int):
+        """向中央服务器报告使用量
+
+        只会报告此次请求的使用量，不会报告总量。
+        不包含除版本号、使用类型、使用量以外的任何信息，仅供开发者分析使用情况。
+        """
         try:
             config = pkg.utils.context.get_config()
             if hasattr(config, "report_usage") and not config.report_usage:
@@ -44,7 +56,9 @@ class DataGatherer:
         return self.usage[key_md5] if key_md5 in self.usage else {}
 
     def report_text_model_usage(self, model, total_tokens):
-        key_md5 = pkg.utils.context.get_openai_manager().key_mgr.get_using_key_md5()
+        """调用方报告文字模型请求文字使用量"""
+
+        key_md5 = pkg.utils.context.get_openai_manager().key_mgr.get_using_key_md5()  # 以key的md5进行储存
 
         if key_md5 not in self.usage:
             self.usage[key_md5] = {}
@@ -62,6 +76,8 @@ class DataGatherer:
         self.report_to_server("text", length)
 
     def report_image_model_usage(self, size):
+        """调用方报告图片模型请求图片使用量"""
+
         key_md5 = pkg.utils.context.get_openai_manager().key_mgr.get_using_key_md5()
 
         if key_md5 not in self.usage:
@@ -79,6 +95,7 @@ class DataGatherer:
         self.report_to_server("image", 1)
 
     def get_text_length_of_key(self, key):
+        """获取指定api-key (明文) 的文字总使用量(本地记录)"""
         key_md5 = hashlib.md5(key.encode('utf-8')).hexdigest()
         if key_md5 not in self.usage:
             return 0
@@ -88,6 +105,8 @@ class DataGatherer:
         return sum(self.usage[key_md5]["text"].values())
 
     def get_image_count_of_key(self, key):
+        """获取指定api-key (明文) 的图片总使用量(本地记录)"""
+
         key_md5 = hashlib.md5(key.encode('utf-8')).hexdigest()
         if key_md5 not in self.usage:
             return 0
@@ -97,6 +116,7 @@ class DataGatherer:
         return sum(self.usage[key_md5]["image"].values())
 
     def get_total_text_length(self):
+        """获取所有api-key的文字总使用量(本地记录)"""
         total = 0
         for key in self.usage:
             if "text" not in self.usage[key]:

pkg/database/__init__.py

@@ -0,0 +1,3 @@
+"""
+数据库操作封装
+"""

pkg/database/manager.py

@@ -1,3 +1,6 @@
+"""
+数据库管理模块
+"""
 import hashlib
 import json
 import logging
@@ -9,9 +12,9 @@ import sqlite3
 import pkg.utils.context
 
 
-# 数据库管理
-# 为其他模块提供数据库操作接口
 class DatabaseManager:
+    """封装数据库底层操作，并提供方法给上层使用"""
+
     conn = None
     cursor = None
 
@@ -23,13 +26,14 @@ class DatabaseManager:
 
     # 连接到数据库文件
     def reconnect(self):
+        """连接到数据库"""
         self.conn = sqlite3.connect('database.db', check_same_thread=False)
         self.cursor = self.conn.cursor()
 
     def close(self):
         self.conn.close()
 
-    def execute(self, *args, **kwargs) -> Cursor:
+    def __execute__(self, *args, **kwargs) -> Cursor:
         # logging.debug('SQL: {}'.format(sql))
         c = self.cursor.execute(*args, **kwargs)
         self.conn.commit()
@@ -37,7 +41,9 @@ class DatabaseManager:
 
     # 初始化数据库的函数
     def initialize_database(self):
-        self.execute("""
+        """创建数据表"""
+
+        self.__execute__("""
         create table if not exists `sessions` (
             `id` INTEGER PRIMARY KEY AUTOINCREMENT,
             `name` varchar(255) not null,
@@ -50,7 +56,7 @@ class DatabaseManager:
         )
         """)
 
-        self.execute("""
+        self.__execute__("""
         create table if not exists `account_fee`(
             `id` INTEGER PRIMARY KEY AUTOINCREMENT,
             `key_md5` varchar(255) not null,
@@ -59,7 +65,7 @@ class DatabaseManager:
         )
         """)
 
-        self.execute("""
+        self.__execute__("""
         create table if not exists `account_usage`(
             `id` INTEGER PRIMARY KEY AUTOINCREMENT,
             `json` text not null
@@ -70,10 +76,12 @@ class DatabaseManager:
     # session持久化
     def persistence_session(self, subject_type: str, subject_number: int, create_timestamp: int,
                             last_interact_timestamp: int, prompt: str):
+        """持久化指定session"""
+
         # 检查是否已经有了此name和create_timestamp的session
         # 如果有，就更新prompt和last_interact_timestamp
         # 如果没有，就插入一条新的记录
-        self.execute("""
+        self.__execute__("""
         select count(*) from `sessions` where `type` = '{}' and `number` = {} and `create_timestamp` = {}
         """.format(subject_type, subject_number, create_timestamp))
         count = self.cursor.fetchone()[0]
@@ -84,8 +92,8 @@ class DatabaseManager:
             values (?, ?, ?, ?, ?, ?)
             """
 
-            self.execute(sql,
-                         ("{}_{}".format(subject_type, subject_number), subject_type, subject_number, create_timestamp,
+            self.__execute__(sql,
+                             ("{}_{}".format(subject_type, subject_number), subject_type, subject_number, create_timestamp,
                           last_interact_timestamp, prompt))
         else:
             sql = """
@@ -93,23 +101,23 @@ class DatabaseManager:
             where `type` = ? and `number` = ? and `create_timestamp` = ?
             """
 
-            self.execute(sql, (last_interact_timestamp, prompt, subject_type,
-                               subject_number, create_timestamp))
+            self.__execute__(sql, (last_interact_timestamp, prompt, subject_type,
+                                   subject_number, create_timestamp))
 
     # 显式关闭一个session
     def explicit_close_session(self, session_name: str, create_timestamp: int):
-        self.execute("""
+        self.__execute__("""
         update `sessions` set `status` = 'explicitly_closed' where `name` = '{}' and `create_timestamp` = {}
         """.format(session_name, create_timestamp))
 
     def set_session_ongoing(self, session_name: str, create_timestamp: int):
-        self.execute("""
+        self.__execute__("""
         update `sessions` set `status` = 'on_going' where `name` = '{}' and `create_timestamp` = {}
         """.format(session_name, create_timestamp))
 
     # 设置session为过期
     def set_session_expired(self, session_name: str, create_timestamp: int):
-        self.execute("""
+        self.__execute__("""
         update `sessions` set `status` = 'expired' where `name` = '{}' and `create_timestamp` = {}
         """.format(session_name, create_timestamp))
 
@@ -117,7 +125,7 @@ class DatabaseManager:
     def load_valid_sessions(self) -> dict:
         # 从数据库中加载所有还没过期的session
         config = pkg.utils.context.get_config()
-        self.execute("""
+        self.__execute__("""
         select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
         from `sessions` where `last_interact_timestamp` > {}
         """.format(int(time.time()) - config.session_expire_time))
@@ -150,7 +158,7 @@ class DatabaseManager:
     # 获取此session_name前一个session的数据
     def last_session(self, session_name: str, cursor_timestamp: int):
 
-        self.execute("""
+        self.__execute__("""
         select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
         from `sessions` where `name` = '{}' and `last_interact_timestamp` < {} order by `last_interact_timestamp` desc
         limit 1
@@ -179,7 +187,7 @@ class DatabaseManager:
     # 获取此session_name后一个session的数据
     def next_session(self, session_name: str, cursor_timestamp: int):
 
-        self.execute("""
+        self.__execute__("""
             select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
             from `sessions` where `name` = '{}' and `last_interact_timestamp` > {} order by `last_interact_timestamp` asc
             limit 1
@@ -207,7 +215,7 @@ class DatabaseManager:
 
     # 列出与某个对象的所有对话session
     def list_history(self, session_name: str, capacity: int, page: int):
-        self.execute("""
+        self.__execute__("""
         select `name`, `type`, `number`, `create_timestamp`, `last_interact_timestamp`, `prompt`, `status`
         from `sessions` where `name` = '{}' order by `last_interact_timestamp` desc limit {} offset {}
         """.format(session_name, capacity, capacity * page))
@@ -246,22 +254,22 @@ class DatabaseManager:
                 usage_count = usage[key_md5]
             # 将使用量存进数据库
             # 先检查是否已存在
-            self.execute("""
+            self.__execute__("""
             select count(*) from `api_key_usage` where `key_md5` = '{}'""".format(key_md5))
             result = self.cursor.fetchone()
             if result[0] == 0:
                 # 不存在则插入
-                self.execute("""
+                self.__execute__("""
                 insert into `api_key_usage` (`key_md5`, `usage`,`timestamp`) values ('{}', {}, {})
                 """.format(key_md5, usage_count, int(time.time())))
             else:
                 # 存在则更新，timestamp设置为当前
-                self.execute("""
+                self.__execute__("""
                 update `api_key_usage` set `usage` = {}, `timestamp` = {} where `key_md5` = '{}'
                 """.format(usage_count, int(time.time()), key_md5))
 
     def load_api_key_usage(self):
-        self.execute("""
+        self.__execute__("""
         select `key_md5`, `usage` from `api_key_usage`
         """)
         results = self.cursor.fetchall()
@@ -273,23 +281,24 @@ class DatabaseManager:
         return usage
 
     def dump_usage_json(self, usage: dict):
+
         json_str = json.dumps(usage)
-        self.execute("""
+        self.__execute__("""
         select count(*) from `account_usage`""")
         result = self.cursor.fetchone()
         if result[0] == 0:
             # 不存在则插入
-            self.execute("""
+            self.__execute__("""
             insert into `account_usage` (`json`) values ('{}')
             """.format(json_str))
         else:
             # 存在则更新
-            self.execute("""
+            self.__execute__("""
             update `account_usage` set `json` = '{}' where `id` = 1
             """.format(json_str))
 
     def load_usage_json(self):
-        self.execute("""
+        self.__execute__("""
         select `json` from `account_usage` order by id desc limit 1
         """)
         result = self.cursor.fetchone()

pkg/openai/__init__.py

@@ -0,0 +1,2 @@
+"""OpenAI 接口处理及会话管理相关
+"""

pkg/openai/dprompt.py

@@ -1,8 +1,13 @@
 # 多情景预设值管理
 
 __current__ = "default"
+"""当前默认使用的情景预设的名称
+
+由管理员使用`!default <名称>`指令切换
+"""
 
 __prompts_from_files__ = {}
+"""从文件中读取的情景预设值"""
 
 
 def read_prompt_from_file() -> str:

pkg/openai/keymgr.py

@@ -5,18 +5,26 @@ import logging
 import pkg.plugin.host as plugin_host
 import pkg.plugin.models as plugin_models
 
+
 class KeysManager:
     api_key = {}
+    """所有api-key"""
 
-    # api-key的使用量
-    # 其中键为api-key的md5值，值为使用量
     using_key = ""
+    """当前使用的api-key
+    """
 
     alerted = []
+    """已提示过超额的key
+    
+    记录在此以避免重复提示
+    """
 
-    # 在此list中的都是经超额报错标记过的api-key
-    # 记录的是key值，仅在运行时有效
     exceeded = []
+    """已超额的key
+    
+    供自动切换功能识别
+    """
 
     def get_using_key(self):
         return self.using_key
@@ -25,8 +33,6 @@ class KeysManager:
         return hashlib.md5(self.using_key.encode('utf-8')).hexdigest()
 
     def __init__(self, api_key):
-        # if hasattr(config, 'api_key_usage_threshold'):
-        #     self.api_key_usage_threshold = config.api_key_usage_threshold
 
         if type(api_key) is dict:
             self.api_key = api_key
@@ -42,9 +48,13 @@ class KeysManager:
 
         self.auto_switch()
 
-    # 根据tested自动切换到可用的api-key
-    # 返回是否切换成功, 切换后的api-key的别名
     def auto_switch(self) -> (bool, str):
+        """尝试切换api-key
+
+        Returns:
+            是否切换成功, 切换后的api-key的别名
+        """
+
         for key_name in self.api_key:
             if self.api_key[key_name] not in self.exceeded:
                 self.using_key = self.api_key[key_name]
@@ -68,12 +78,9 @@ class KeysManager:
     def add(self, key_name, key):
         self.api_key[key_name] = key
 
-    # 设置当前使用的api-key使用量超限
-    # 这是在尝试调用api时发生超限异常时调用的
     def set_current_exceeded(self):
-        # md5 = hashlib.md5(self.using_key.encode('utf-8')).hexdigest()
-        # self.usage[md5] = self.api_key_usage_threshold
-        # self.fee[md5] = self.api_key_fee_threshold
+        """设置当前使用的api-key使用量超限
+        """
         self.exceeded.append(self.using_key)
 
     def get_key_name(self, api_key):

pkg/openai/manager.py

@@ -7,9 +7,12 @@ import pkg.utils.context
 import pkg.audit.gatherer
 from pkg.openai.modelmgr import ModelRequest, create_openai_model_request
 
-# 为其他模块提供与OpenAI交互的接口
+
 class OpenAIInteract:
-    api_params = {}
+    """OpenAI 接口封装
+
+    将文字接口和图片接口封装供调用方使用
+    """
 
     key_mgr: pkg.openai.keymgr.KeysManager = None
 
@@ -20,7 +23,6 @@ class OpenAIInteract:
     }
 
     def __init__(self, api_key: str):
-        # self.api_key = api_key
 
         self.key_mgr = pkg.openai.keymgr.KeysManager(api_key)
         self.audit_mgr = pkg.audit.gatherer.DataGatherer()
@@ -32,7 +34,16 @@ class OpenAIInteract:
         pkg.utils.context.set_openai_manager(self)
 
     # 请求OpenAI Completion
-    def request_completion(self, prompts):
+    def request_completion(self, prompts) -> str:
+        """请求补全接口回复
+
+        Parameters:
+            prompts (str): 提示语
+
+        Returns:
+            str: 回复
+        """
+
         config = pkg.utils.context.get_config()
 
         # 根据模型选择使用的接口
@@ -58,8 +69,15 @@ class OpenAIInteract:
 
         return ai.get_message()
 
-    def request_image(self, prompt):
+    def request_image(self, prompt) -> dict:
+        """请求图片接口回复
 
+        Parameters:
+            prompt (str): 提示语
+
+        Returns:
+            dict: 响应
+        """
         config = pkg.utils.context.get_config()
         params = config.image_api_params if hasattr(config, "image_api_params") else self.default_image_api_params
 

pkg/openai/modelmgr.py

@@ -1,5 +1,12 @@
-# 提供与模型交互的抽象接口
+"""OpenAI 接口底层封装
+
+目前使用的对话接口有：
+ChatCompletion - gpt-3.5-turbo 等模型
+Completion - text-davinci-003 等模型
+此模块封装此两个接口的请求实现，为上层提供统一的调用方式
+"""
 import openai, logging, threading, asyncio
+import openai.error as aiE
 
 COMPLETION_MODELS = {
     'text-davinci-003',
@@ -25,26 +32,46 @@ IMAGE_MODELS = {
 }
 
 
-class ModelRequest():
-    """GPT父类"""
-    can_chat = False
-    runtime:threading.Thread = None
-    ret = ""
-    proxy:str = None
+class ModelRequest:
+    """模型接口请求父类"""
 
-    def __init__(self, model_name, user_name, request_fun, http_proxy:str = None):
+    can_chat = False
+    runtime: threading.Thread = None
+    ret = {}
+    proxy: str = None
+    request_ready = True
+    error_info: str = "若在没有任何错误的情况下看到这句话，请带着配置文件上报Issues"
+
+    def __init__(self, model_name, user_name, request_fun, http_proxy:str = None, time_out = None):
         self.model_name = model_name
         self.user_name = user_name
         self.request_fun = request_fun
+        self.time_out = time_out
         if http_proxy != None:
             self.proxy = http_proxy
             openai.proxy = self.proxy
+            self.request_ready = False
 
     async def __a_request__(self, **kwargs):
-        self.ret = await self.request_fun(**kwargs)
+        """异步请求"""
+
+        try:
+            self.ret:dict = await self.request_fun(**kwargs)
+            self.request_ready = True
+        except aiE.APIConnectionError as e:
+            self.error_info = "{}\n请检查网络连接或代理是否正常".format(e)
+            raise ConnectionError(self.error_info)
+        except ValueError as e:
+            self.error_info = "{}\n该错误可能是由于http_proxy格式设置错误引起的"
+        except Exception as e:
+            self.error_info = "{}\n由于请求异常产生的未知错误，请查看日志".format(e)
+            raise Exception(self.error_info)
 
     def request(self, **kwargs):
+        """向接口发起请求"""
+
         if self.proxy != None: #异步请求
+            self.request_ready = False
             loop = asyncio.new_event_loop()
             self.runtime = threading.Thread(
                 target=loop.run_until_complete,
@@ -64,13 +91,15 @@ class ModelRequest():
         若重写该方法，应检查异步线程状态，或在需要检查处super该方法
         '''
         if self.runtime != None and isinstance(self.runtime, threading.Thread):
-            self.runtime.join()
-        return
+            self.runtime.join(self.time_out)
+        if self.request_ready:
+            return
+        raise Exception(self.error_info)
 
     def get_total_tokens(self):
         try:
             return self.ret['usage']['total_tokens']
-        except Exception:
+        except:
             return 0
 
     def get_message(self):
@@ -79,8 +108,10 @@ class ModelRequest():
     def get_response(self):
         return self.ret
 
+
 class ChatCompletionModel(ModelRequest):
-    """ChatCompletion类模型"""
+    """ChatCompletion接口的请求实现"""
+
     Chat_role = ['system', 'user', 'assistant']
     def __init__(self, model_name, user_name, http_proxy:str = None, **kwargs):
         if http_proxy == None:
@@ -108,7 +139,8 @@ class ChatCompletionModel(ModelRequest):
 
 
 class CompletionModel(ModelRequest):
-    """Completion类模型"""
+    """Completion接口的请求实现"""
+
     def __init__(self, model_name, user_name, http_proxy:str = None, **kwargs):
         if http_proxy == None:
             request_fun = openai.Completion.create

pkg/openai/session.py

@@ -1,3 +1,8 @@
+"""主线使用的会话管理模块
+
+每个人、每个群单独一个session，session内部保留了对话的上下文，
+"""
+
 import logging
 import threading
 import time
@@ -19,6 +24,7 @@ class SessionOfflineStatus:
     ON_GOING = 'on_going'
     EXPLICITLY_CLOSED = 'explicitly_closed'
 
+
 # 重置session.prompt
 def reset_session_prompt(session_name, prompt):
     # 备份原始数据
@@ -43,11 +49,14 @@ def reset_session_prompt(session_name, prompt):
 用户[{}]的数据已被重置，有可能是因为数据版本过旧或存储错误
 原始数据将备份在：
 {}""".format(session_name, bak_path)
-    )
+    )  # 为保证多行文本格式正确故无缩进
     return prompt
 
+
 # 从数据加载session
 def load_sessions():
+    """从数据库加载sessions"""
+
     global sessions
 
     db_inst = pkg.utils.context.get_database_manager()
@@ -93,10 +102,13 @@ class Session:
     name = ''
 
     prompt = []
+    """使用list来保存会话中的回合"""
 
     create_timestamp = 0
+    """会话创建时间"""
 
     last_interact_timestamp = 0
+    """上次交互(产生回复)时间"""
 
     just_switched_to_exist_session = False
 
@@ -116,7 +128,7 @@ class Session:
             logging.debug('{},lock release successfully,{}'.format(self.name, self.response_lock))
 
     # 从配置文件获取会话预设信息
-    def get_default_prompt(self, use_default: str=None):
+    def get_default_prompt(self, use_default: str = None):
         config = pkg.utils.context.get_config()
 
         import pkg.openai.dprompt as dprompt
@@ -130,7 +142,7 @@ class Session:
             {
                 'role': 'user',
                 'content': current_default_prompt
-            },{
+            }, {
                 'role': 'assistant',
                 'content': 'ok'
             }
@@ -182,6 +194,8 @@ class Session:
     # 请求回复
     # 这个函数是阻塞的
     def append(self, text: str) -> str:
+        """向session中添加一条消息，返回接口回复"""
+
         self.last_interact_timestamp = int(time.time())
 
         # 触发插件事件
@@ -215,14 +229,14 @@ class Session:
             res_ans = '\n\n'.join(res_ans_spt)
 
         # 将此次对话的双方内容加入到prompt中
-        self.prompt.append({'role':'user', 'content':text})
-        self.prompt.append({'role':'assistant', 'content':res_ans})
+        self.prompt.append({'role': 'user', 'content': text})
+        self.prompt.append({'role': 'assistant', 'content': res_ans})
 
         if self.just_switched_to_exist_session:
             self.just_switched_to_exist_session = False
             self.set_ongoing()
 
-        return res_ans if res_ans[0]!='\n' else res_ans[1:]
+        return res_ans if res_ans[0] != '\n' else res_ans[1:]
 
     # 删除上一回合并返回上一回合的问题
     def undo(self) -> str:
@@ -231,10 +245,10 @@ class Session:
         # 删除最后两个消息
         if len(self.prompt) < 2:
             raise Exception('之前无对话，无法撤销')
-    
+
         question = self.prompt[-2]['content']
         self.prompt = self.prompt[:-2]
-        
+
         # 返回上一回合的问题
         return question
 
@@ -242,13 +256,13 @@ class Session:
     def cut_out(self, msg: str, max_tokens: int) -> list:
         """将现有prompt进行切割处理，使得新的prompt长度不超过max_tokens"""
         # 如果用户消息长度超过max_tokens，直接返回
-        
+
         temp_prompt = [
-                {
-                    'role': 'user',
-                    'content': msg
-                }
-            ]
+            {
+                'role': 'user',
+                'content': msg
+            }
+        ]
 
         token_count = len(msg)
         # 倒序遍历prompt

pkg/plugin/__init__.py

@@ -0,0 +1,4 @@
+"""插件支持包
+
+包含插件基类、插件宿主以及部分API接口
+"""

pkg/plugin/host.py

@@ -116,7 +116,9 @@ def initialize_plugins():
 
 
 def unload_plugins():
-    """ 卸载插件 """
+    """ 卸载插件
+    """
+    # 不再显式卸载插件，因为当程序结束时，插件的析构函数会被系统执行
     # for plugin in __plugins__.values():
     #     if plugin['enabled'] and plugin['instance'] is not None:
     #         if not hasattr(plugin['instance'], '__del__'):

pkg/plugin/models.py

@@ -145,6 +145,7 @@ __current_registering_plugin__ = ""
 
 
 class Plugin:
+    """插件基类"""
 
     host: host.PluginHost
     """插件宿主，提供插件的一些基础功能"""

pkg/qqbot/filter.py

@@ -7,6 +7,8 @@ import logging
 
 class ReplyFilter:
     sensitive_words = []
+    mask = "*"
+    mask_word = ""
 
     # 默认值( 兼容性考虑 )
     baidu_check = False
@@ -14,8 +16,10 @@ class ReplyFilter:
     baidu_secret_key = ""
     inappropriate_message_tips = "[百度云]请珍惜机器人，当前返回内容不合规"
 
-    def __init__(self, sensitive_words: list):
+    def __init__(self, sensitive_words: list, mask: str = "*", mask_word: str = ""):
         self.sensitive_words = sensitive_words
+        self.mask = mask
+        self.mask_word = mask_word
         import config
         if hasattr(config, 'baidu_check') and hasattr(config, 'baidu_api_key') and hasattr(config, 'baidu_secret_key'):
             self.baidu_check = config.baidu_check
@@ -36,7 +40,10 @@ class ReplyFilter:
             match = re.findall(word, message)
             if len(match) > 0:
                 for i in range(len(match)):
-                    message = message.replace(match[i], "*" * len(match[i]))
+                    if self.mask_word == "":
+                        message = message.replace(match[i], self.mask * len(match[i]))
+                    else:
+                        message = message.replace(match[i], self.mask_word)
 
         # 百度云审核
         if self.baidu_check:

pkg/qqbot/manager.py

@@ -2,6 +2,7 @@ import asyncio
 import json
 import os
 import threading
+from concurrent.futures import ThreadPoolExecutor
 
 import mirai.models.bus
 from mirai import At, GroupMessage, MessageEvent, Mirai, StrangerMessage, WebSocketAdapter, HTTPAdapter, \
@@ -21,12 +22,6 @@ import pkg.plugin.host as plugin_host
 import pkg.plugin.models as plugin_models
 
 
-# 并行运行
-def go(func, args=()):
-    thread = threading.Thread(target=func, args=args, daemon=True)
-    thread.start()
-
-
 # 检查消息是否符合泛响应匹配机制
 def check_response_rule(text: str):
     config = pkg.utils.context.get_config()
@@ -51,10 +46,29 @@ def check_response_rule(text: str):
     return False, ""
 
 
+def response_at():
+    config = pkg.utils.context.get_config()
+    if 'at' not in config.response_rules:
+        return True
+
+    return config.response_rules['at']
+
+
+def random_responding():
+    config = pkg.utils.context.get_config()
+    if 'random_rate' in config.response_rules:
+        import random
+        return random.random() < config.response_rules['random_rate']
+    return False
+
+
 # 控制QQ消息输入输出的类
 class QQBotManager:
     retry = 3
 
+    #线程池控制
+    pool = None
+
     bot: Mirai = None
 
     reply_filter = None
@@ -64,11 +78,14 @@ class QQBotManager:
     ban_person = []
     ban_group = []
 
-    def __init__(self, mirai_http_api_config: dict, timeout: int = 60, retry: int = 3, first_time_init=True):
-
+    def __init__(self, mirai_http_api_config: dict, timeout: int = 60, retry: int = 3, pool_num: int = 10, first_time_init=True):
         self.timeout = timeout
         self.retry = retry
 
+        self.pool_num = pool_num
+        self.pool = ThreadPoolExecutor(max_workers=self.pool_num)
+        logging.debug("Registered thread pool Size:{}".format(pool_num))
+
         # 加载禁用列表
         if os.path.exists("banlist.py"):
             import banlist
@@ -82,7 +99,12 @@ class QQBotManager:
                 and config.sensitive_word_filter is not None \
                 and config.sensitive_word_filter:
             with open("sensitive.json", "r", encoding="utf-8") as f:
-                self.reply_filter = pkg.qqbot.filter.ReplyFilter(json.load(f)['words'])
+                sensitive_json = json.load(f)
+                self.reply_filter = pkg.qqbot.filter.ReplyFilter(
+                    sensitive_words=sensitive_json['words'],
+                    mask=sensitive_json['mask'] if 'mask' in sensitive_json else '*',
+                    mask_word=sensitive_json['mask_word'] if 'mask_word' in sensitive_json else ''
+                )
         else:
             self.reply_filter = pkg.qqbot.filter.ReplyFilter([])
 
@@ -116,7 +138,7 @@ class QQBotManager:
 
                 self.on_person_message(event)
 
-            go(friend_message_handler, (event,))
+            self.go(friend_message_handler, event)
 
         @self.bot.on(StrangerMessage)
         async def on_stranger_message(event: StrangerMessage):
@@ -136,7 +158,7 @@ class QQBotManager:
 
                 self.on_person_message(event)
 
-            go(stranger_message_handler, (event,))
+            self.go(stranger_message_handler, event)
 
         @self.bot.on(GroupMessage)
         async def on_group_message(event: GroupMessage):
@@ -156,7 +178,7 @@ class QQBotManager:
 
                 self.on_group_message(event)
 
-            go(group_message_handler, (event,))
+            self.go(group_message_handler, event)
 
         def unsubscribe_all():
             """取消所有订阅
@@ -173,6 +195,9 @@ class QQBotManager:
 
         self.unsubscribe_all = unsubscribe_all
 
+    def go(self, func, *args, **kwargs):
+        self.pool.submit(func, *args, **kwargs)
+
     def first_time_init(self, mirai_http_api_config: dict):
         """热重载后不再运行此函数"""
 
@@ -288,14 +313,19 @@ class QQBotManager:
 
         if Image in event.message_chain:
             pass
-        elif At(self.bot.qq) not in event.message_chain:
-            check, result = check_response_rule(str(event.message_chain).strip())
-
-            if check:
-                reply = process(result.strip())
         else:
-            # 直接调用
-            reply = process()
+            if At(self.bot.qq) in event.message_chain and response_at():
+                # 直接调用
+                reply = process()
+            else:
+                check, result = check_response_rule(str(event.message_chain).strip())
+
+                if check:
+                    reply = process(result.strip())
+                # 检查是否随机响应
+                elif random_responding():
+                    logging.info("随机响应group_{}消息".format(event.group.id))
+                    reply = process()
 
         if reply:
             return self.send(event, reply)

pkg/utils/reloader.py

@@ -7,13 +7,15 @@ import pkg.utils.context
 import pkg.plugin.host
 
 
-def walk(module, prefix=''):
+def walk(module, prefix='', path_prefix=''):
     """遍历并重载所有模块"""
     for item in pkgutil.iter_modules(module.__path__):
         if item.ispkg:
-            walk(__import__(module.__name__ + '.' + item.name, fromlist=['']), prefix + item.name + '.')
+
+            walk(__import__(module.__name__ + '.' + item.name, fromlist=['']), prefix + item.name + '.', path_prefix + item.name + '/')
         else:
-            logging.info('reload module: {}'.format(prefix + item.name))
+            logging.info('reload module: {}, path: {}'.format(prefix + item.name, path_prefix + item.name + '.py'))
+            pkg.plugin.host.__current_module_path__ = "plugins/" + path_prefix + item.name + '.py'
             importlib.reload(__import__(module.__name__ + '.' + item.name, fromlist=['']))
 
 

pkg/utils/text2img.py

@@ -1,8 +1,37 @@
+import logging
+
 from PIL import Image, ImageDraw, ImageFont
 import re
 import os
+import config
+import traceback
 
-text_render_font = ImageFont.truetype("res/simhei.ttf", 32, encoding="utf-8")
+text_render_font: ImageFont = None
+
+if hasattr(config, "blob_message_strategy") and config.blob_message_strategy == "image":  # 仅在启用了image时才加载字体
+    use_font = config.font_path if hasattr(config, "font_path") else ""
+    try:
+
+        # 检查是否存在
+        if not os.path.exists(use_font):
+            # 若是windows系统，使用微软雅黑
+            if os.name == "nt":
+                use_font = "C:/Windows/Fonts/msyh.ttc"
+                if not os.path.exists(use_font):
+                    logging.warn("未找到字体文件，且无法使用Windows自带字体，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。")
+                    config.blob_message_strategy = "forward"
+                else:
+                    logging.info("使用Windows自带字体：" + use_font)
+                    text_render_font = ImageFont.truetype(use_font, 32, encoding="utf-8")
+            else:
+                logging.warn("未找到字体文件，且无法使用Windows自带字体，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。")
+                config.blob_message_strategy = "forward"
+        else:
+            text_render_font = ImageFont.truetype(use_font, 32, encoding="utf-8")
+    except:
+        traceback.print_exc()
+        logging.error("加载字体文件失败({})，更换为转发消息组件以发送长消息，您可以在config.py中调整相关设置。".format(use_font))
+        config.blob_message_strategy = "forward"
 
 
 def indexNumber(path=''):
@@ -123,7 +152,7 @@ def text_to_image(text_str: str, save_as="temp.png", width=800):
                 else:
                     continue
     # 准备画布
-    img = Image.new('RGBA', (width, max(280, len(final_lines) * 35 + 45)), (255, 255, 255, 255))
+    img = Image.new('RGBA', (width, max(280, len(final_lines) * 35 + 65)), (255, 255, 255, 255))
     draw = ImageDraw.Draw(img, mode='RGBA')
 
     

pkg/utils/updater.py

@@ -1,6 +1,11 @@
 import datetime
+import logging
+import os.path
 
-import pkg.utils.context
+import requests
+import json
+
+import pkg.utils.constants
 
 
 def check_dulwich_closure():
@@ -28,34 +33,113 @@ def pull_latest(repo_path: str) -> bool:
     return True
 
 
-def update_all() -> bool:
-    """使用dulwich更新源码"""
-    check_dulwich_closure()
-    import dulwich
-    try:
-        before_commit_id = get_current_commit_id()
-        from dulwich import porcelain
-        repo = porcelain.open_repo('.')
-        porcelain.pull(repo)
+def get_release_list() -> list:
+    """获取发行列表"""
+    rls_list_resp = requests.get(
+        url="https://api.github.com/repos/RockChinQ/QChatGPT/releases"
+    )
 
-        change_log = ""
+    rls_list = rls_list_resp.json()
 
-        for entry in repo.get_walker():
-            if str(entry.commit.id)[2:-1] == before_commit_id:
-                break
-            tz = datetime.timezone(datetime.timedelta(hours=entry.commit.commit_timezone // 3600))
-            dt = datetime.datetime.fromtimestamp(entry.commit.commit_time, tz)
-            change_log += dt.strftime('%Y-%m-%d %H:%M:%S') + " [" + str(entry.commit.message, encoding="utf-8").strip()+"]\n"
+    return rls_list
 
-        if change_log != "":
-            pkg.utils.context.get_qqbot_manager().notify_admin("代码拉取完成,更新内容如下:\n"+change_log)
-            return True
-        else:
-            return False
-    except ModuleNotFoundError:
-        raise Exception("dulwich模块未安装,请查看 https://github.com/RockChinQ/QChatGPT/issues/77")
-    except dulwich.porcelain.DivergedBranches:
-        raise Exception("分支不一致,自动更新仅支持master分支,请手动更新(https://github.com/RockChinQ/QChatGPT/issues/76)")
+
+def get_current_tag() -> str:
+    """获取当前tag"""
+    current_tag = pkg.utils.constants.semantic_version
+    if os.path.exists("current_tag"):
+        with open("current_tag", "r") as f:
+            current_tag = f.read()
+
+    return current_tag
+
+
+def update_all(cli: bool = False) -> bool:
+    """检查更新并下载源码"""
+    current_tag = get_current_tag()
+
+    rls_list = get_release_list()
+
+    latest_rls = {}
+    rls_notes = []
+    for rls in rls_list:
+        rls_notes.append(rls['name'])  # 使用发行名称作为note
+        if rls['tag_name'] == current_tag:
+            break
+
+        if latest_rls == {}:
+            latest_rls = rls
+    if not cli:
+        logging.info("更新日志: {}".format(rls_notes))
+    else:
+        print("更新日志: {}".format(rls_notes))
+
+    if latest_rls == {}:  # 没有新版本
+        return False
+
+    # 下载最新版本的zip到temp目录
+    if not cli:
+        logging.info("开始下载最新版本: {}".format(latest_rls['zipball_url']))
+    else:
+        print("开始下载最新版本: {}".format(latest_rls['zipball_url']))
+    zip_url = latest_rls['zipball_url']
+    zip_resp = requests.get(url=zip_url)
+    zip_data = zip_resp.content
+
+    # 检查temp/updater目录
+    if not os.path.exists("temp"):
+        os.mkdir("temp")
+    if not os.path.exists("temp/updater"):
+        os.mkdir("temp/updater")
+    with open("temp/updater/{}.zip".format(latest_rls['tag_name']), "wb") as f:
+        f.write(zip_data)
+
+    if not cli:
+        logging.info("下载最新版本完成: {}".format("temp/updater/{}.zip".format(latest_rls['tag_name'])))
+    else:
+        print("下载最新版本完成: {}".format("temp/updater/{}.zip".format(latest_rls['tag_name'])))
+
+    # 解压zip到temp/updater/<tag_name>/
+    import zipfile
+    # 检查目标文件夹
+    if os.path.exists("temp/updater/{}".format(latest_rls['tag_name'])):
+        import shutil
+        shutil.rmtree("temp/updater/{}".format(latest_rls['tag_name']))
+    os.mkdir("temp/updater/{}".format(latest_rls['tag_name']))
+    with zipfile.ZipFile("temp/updater/{}.zip".format(latest_rls['tag_name']), 'r') as zip_ref:
+        zip_ref.extractall("temp/updater/{}".format(latest_rls['tag_name']))
+
+    # 覆盖源码
+    source_root = ""
+    # 找到temp/updater/<tag_name>/中的第一个子目录路径
+    for root, dirs, files in os.walk("temp/updater/{}".format(latest_rls['tag_name'])):
+        if root != "temp/updater/{}".format(latest_rls['tag_name']):
+            source_root = root
+            break
+
+    # 覆盖源码
+    import shutil
+    for root, dirs, files in os.walk(source_root):
+        # 覆盖所有子文件子目录
+        for file in files:
+            src = os.path.join(root, file)
+            dst = src.replace(source_root, ".")
+            if os.path.exists(dst):
+                os.remove(dst)
+            shutil.copy(src, dst)
+
+    # 把current_tag写入文件
+    current_tag = latest_rls['tag_name']
+    with open("current_tag", "w") as f:
+        f.write(current_tag)
+
+    # 通知管理员
+    if not cli:
+        import pkg.utils.context
+        pkg.utils.context.get_qqbot_manager().notify_admin("已更新到最新版本: {}\n更新日志:\n{}\n新功能通常可以在config-template.py中看到，完整的更新日志请前往 https://github.com/RockChinQ/QChatGPT/releases 查看".format(current_tag, "\n".join(rls_notes)))
+    else:
+        print("已更新到最新版本: {}\n更新日志:\n{}\n新功能通常可以在config-template.py中看到，完整的更新日志请前往 https://github.com/RockChinQ/QChatGPT/releases 查看".format(current_tag, "\n".join(rls_notes)))
+    return True
 
 
 def is_repo(path: str) -> bool:
@@ -81,24 +165,12 @@ def get_remote_url(repo_path: str) -> str:
 
 def get_current_version_info() -> str:
     """获取当前版本信息"""
-    check_dulwich_closure()
-
-    from dulwich import porcelain
-
-    repo = porcelain.open_repo('.')
-
-    version_str = ""
-
-    for entry in repo.get_walker():
-        version_str += "提交编号: "+str(entry.commit.id)[2:9] + "\n"
-        tz = datetime.timezone(datetime.timedelta(hours=entry.commit.commit_timezone // 3600))
-        dt = datetime.datetime.fromtimestamp(entry.commit.commit_time, tz)
-        version_str += "时间: "+dt.strftime('%m-%d %H:%M:%S') + "\n"
-        version_str += "说明: "+str(entry.commit.message, encoding="utf-8").strip() + "\n"
-        version_str += "提交作者: '" + str(entry.commit.author)[2:-1] + "'"
-        break
-
-    return version_str
+    rls_list = get_release_list()
+    current_tag = get_current_tag()
+    for rls in rls_list:
+        if rls['tag_name'] == current_tag:
+            return rls['name'] + "\n" + rls['body']
+    return "未知版本"
 
 
 def get_commit_id_and_time_and_msg() -> str:
@@ -132,15 +204,42 @@ def get_current_commit_id() -> str:
 
 def is_new_version_available() -> bool:
     """检查是否有新版本"""
-    check_dulwich_closure()
+    # 从github获取release列表
+    rls_list = get_release_list()
+    if rls_list is None:
+        return False
 
-    from dulwich import porcelain
+    # 获取当前版本
+    current_tag = get_current_tag()
 
-    repo = porcelain.open_repo('.')
-    fetch_res = porcelain.ls_remote(porcelain.get_remote_repo(repo, "origin")[1])
+    # 检查是否有新版本
+    for rls in rls_list:
+        if rls['tag_name'] == current_tag:
+            return False
+        else:
+            return True
 
-    current_commit_id = get_current_commit_id()
 
-    latest_commit_id = str(fetch_res[b'HEAD'])[2:-1]
+def get_rls_notes() -> list:
+    """获取更新日志"""
+    # 从github获取release列表
+    rls_list = get_release_list()
+    if rls_list is None:
+        return None
 
-    return current_commit_id != latest_commit_id
+    # 获取当前版本
+    current_tag = get_current_tag()
+
+    # 检查是否有新版本
+    rls_notes = []
+    for rls in rls_list:
+        if rls['tag_name'] == current_tag:
+            break
+
+        rls_notes.append(rls['name'])
+
+    return rls_notes
+
+
+if __name__ == "__main__":
+    update_all()

requirements.txt

@@ -1,6 +1,5 @@
 requests~=2.28.1
 openai~=0.27.0
-pip~=22.3.1
 dulwich~=0.21.3
 colorlog~=6.6.0
 yiri-mirai~=0.2.6.1

sensitive-template.json

@@ -1,4 +1,7 @@
 {
+  "说明": "mask将替换敏感词中的每一个字，若mask_word值不为空，则将敏感词整个替换为mask_word的值",
+  "mask": "*",
+  "mask_word": "",
   "words": [
     "习近平",
     "胡锦涛",