chore: release v2.6.4

Feat: 通过 GitHub API 进行插件安装和更新

.github/workflows/update-cmdpriv-template.yml

@@ -21,12 +21,12 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v2
       with:
-        python-version: 3.x
+        python-version: 3.10.13
 
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
-        python -m pip install --upgrade  yiri-mirai openai colorlog func_timeout dulwich Pillow CallingGPT tiktoken
+        python -m pip install --upgrade  yiri-mirai openai>=1.0.0 colorlog func_timeout dulwich Pillow CallingGPT tiktoken
+        python -m pip install -U openai>=1.0.0
 
     - name: Copy Scripts
       run: |

.github/workflows/update-override-all.yml

@@ -29,7 +29,6 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          # 在此处添加您的项目所需的其他依赖
 
       - name: Copy Scripts
         run: |

Dockerfile

@@ -1,12 +1,13 @@
-FROM python:3.10.13-alpine3.18
+FROM python:3.10.13-bullseye
 WORKDIR /QChatGPT
 
 COPY . /QChatGPT/
 
 RUN ls
 
-RUN pip install -r requirements.txt
-RUN pip install -U websockets==10.0
+RUN python -m pip install -r requirements.txt && \
+    python -m pip install -U websockets==10.0 && \
+    python -m pip install -U httpcore httpx openai
 
 # 生成配置文件
 RUN python main.py

README.md

@@ -8,7 +8,7 @@
 # QChatGPT
 
 <!-- 高稳定性/持续迭代/架构清晰/支持插件/高可自定义的 ChatGPT QQ机器人框架 -->
-“当然！下面是一个使用Java编写的快速排序算法的示例代码”
+<!-- “当然！下面是一个使用Java编写的快速排序算法的示例代码” -->
 
 [![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/QChatGPT)](https://github.com/RockChinQ/QChatGPT/releases/latest)
 <a href="https://hub.docker.com/repository/docker/rockchin/qchatgpt">
@@ -25,7 +25,7 @@
 <a href="http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=nC80H57wmKPwRDLFeQrDDjVl81XuC21P&authKey=2wTUTfoQ5v%2BD4C5zfpuR%2BSPMDqdXgDXA%2FS2wHI1NxTfWIG%2B%2FqK08dgyjMMOzhXa9&noverify=0&group_code=738382634">
 <img alt="Static Badge" src="https://img.shields.io/badge/%E7%A4%BE%E5%8C%BA%E7%BE%A4-738382634-purple">
 </a>
-<a href="https://lazyfree.top/2023/08/16/QChatGPT%E4%BD%BF%E7%94%A8%E6%89%8B%E5%86%8C/">
+<a href="https://qchatgpt.rockchin.top">
 <img alt="Static Badge" src="https://img.shields.io/badge/%E6%9F%A5%E7%9C%8B-%E7%A4%BE%E5%8C%BA%E7%BC%96%E5%86%99%E4%BD%BF%E7%94%A8%E6%89%8B%E5%86%8C-blue">
 </a>
 <a href="https://www.bilibili.com/video/BV14h4y1w7TC">

config-template.py

@@ -208,29 +208,52 @@ auto_reset = True
 
 # OpenAI补全API的参数
 # 请在下方填写模型，程序自动选择接口
+# 模型文档：https://platform.openai.com/docs/models
 # 现已支持的模型有：
 # 
-#    'gpt-4'
-#    'gpt-4-0613'
-#    'gpt-4-32k'
-#    'gpt-4-32k-0613'
-#    'gpt-3.5-turbo'
-#    'gpt-3.5-turbo-16k'
-#    'gpt-3.5-turbo-0613'
-#    'gpt-3.5-turbo-16k-0613'
-#    'text-davinci-003'
-#    'text-davinci-002'
-#    'code-davinci-002'
-#    'code-cushman-001'
-#    'text-curie-001'
-#    'text-babbage-001'
-#    'text-ada-001'
+# ChatCompletions 接口：
+# # GPT 4 系列
+# "gpt-4-1106-preview",
+# "gpt-4-vision-preview",
+# "gpt-4",
+# "gpt-4-32k",
+# "gpt-4-0613",
+# "gpt-4-32k-0613",
+# "gpt-4-0314", # legacy
+# "gpt-4-32k-0314", # legacy
+# # GPT 3.5 系列
+# "gpt-3.5-turbo-1106",
+# "gpt-3.5-turbo",
+# "gpt-3.5-turbo-16k",
+# "gpt-3.5-turbo-0613", # legacy
+# "gpt-3.5-turbo-16k-0613", # legacy
+# "gpt-3.5-turbo-0301", # legacy
+# 
+# Completions接口：
+# "text-davinci-003", # legacy
+# "text-davinci-002", # legacy
+# "code-davinci-002", # legacy
+# "code-cushman-001", # legacy
+# "text-curie-001", # legacy
+# "text-babbage-001", # legacy
+# "text-ada-001", # legacy
+# "gpt-3.5-turbo-instruct",
 #
 # 具体请查看OpenAI的文档: https://beta.openai.com/docs/api-reference/completions/create
 # 请将内容修改到config.py中，请勿修改config-template.py
 # 
 # 支持通过 One API 接入多种模型，请在上方的openai_config中设置One API的代理地址，
 # 并在此填写您要使用的模型名称，详细请参考：https://github.com/songquanpeng/one-api
+# 
+# 支持的 One API 模型：
+# "SparkDesk",
+# "chatglm_pro",
+# "chatglm_std",
+# "chatglm_lite",
+# "qwen-v1",
+# "qwen-plus-v1",
+# "ERNIE-Bot",
+# "ERNIE-Bot-turbo",
 completion_api_params = {
     "model": "gpt-3.5-turbo",
     "temperature": 0.9,  # 数值越低得到的回答越理性，取值范围[0, 1]
@@ -248,7 +271,7 @@ image_api_params = {
 trace_function_calls = False
 
 # 群内回复消息时是否引用原消息
-quote_origin = True
+quote_origin = False
 
 # 群内回复消息时是否at发送者
 at_sender = False
@@ -351,7 +374,7 @@ rate_limitation = {
 rate_limit_strategy = "drop"
 
 # 是否在启动时进行依赖库更新
-upgrade_dependencies = True
+upgrade_dependencies = False
 
 # 是否上报统计信息
 # 用于统计机器人的使用情况，不会收集任何用户信息

main.py

@@ -191,13 +191,16 @@ def start(first_time_init=False):
 
             # 配置OpenAI proxy
             import openai
-            openai.proxy = None  # 先重置，因为重载后可能需要清除proxy
+            openai.proxies = None  # 先重置，因为重载后可能需要清除proxy
             if "http_proxy" in config.openai_config and config.openai_config["http_proxy"] is not None:
-                openai.proxy = config.openai_config["http_proxy"]
+                openai.proxies = {
+                    "http": config.openai_config["http_proxy"],
+                    "https": config.openai_config["http_proxy"]
+                }
 
             # 配置openai api_base
             if "reverse_proxy" in config.openai_config and config.openai_config["reverse_proxy"] is not None:
-                openai.api_base = config.openai_config["reverse_proxy"]
+                openai.base_url = config.openai_config["reverse_proxy"]
 
             # 主启动流程
             database = pkg.database.manager.DatabaseManager()

override-all.json

@@ -63,7 +63,7 @@
         "size": "256x256"
     },
     "trace_function_calls": false,
-    "quote_origin": true,
+    "quote_origin": false,
     "at_sender": false,
     "include_image_description": true,
     "process_message_timeout": 120,
@@ -86,7 +86,7 @@
         "default": 60
     },
     "rate_limit_strategy": "drop",
-    "upgrade_dependencies": true,
+    "upgrade_dependencies": false,
     "report_usage": true,
     "logging_level": 20
 }

pkg/openai/api/chat_completion.py

@@ -1,4 +1,5 @@
 import openai
+from openai.types.chat import chat_completion_message
 import json
 import logging
 
@@ -13,13 +14,14 @@ class ChatCompletionRequest(RequestBase):
     此类保证每一次返回的角色为assistant的信息的finish_reason一定为stop。
     若有函数调用响应，本类的返回瀑布是：函数调用请求->函数调用结果->...->assistant的信息->stop。
     """
+
     model: str
     messages: list[dict[str, str]]
     kwargs: dict
 
     stopped: bool = False
 
-    pending_func_call: dict = None
+    pending_func_call: chat_completion_message.FunctionCall = None
 
     pending_msg: str
 
@@ -46,16 +48,18 @@ class ChatCompletionRequest(RequestBase):
 
     def __init__(
         self,
+        client: openai.Client,
         model: str,
         messages: list[dict[str, str]],
         **kwargs
     ):
+        self.client = client
         self.model = model
         self.messages = messages.copy()
 
         self.kwargs = kwargs
 
-        self.req_func = openai.ChatCompletion.acreate
+        self.req_func = self.client.chat.completions.create
 
         self.pending_func_call = None
 
@@ -84,39 +88,48 @@ class ChatCompletionRequest(RequestBase):
 
             # 拼接kwargs
             args = {**args, **self.kwargs}
+            
+            from openai.types.chat import chat_completion
 
-            resp = self._req(**args)
+            resp: chat_completion.ChatCompletion = self._req(**args)
 
-            choice0 = resp["choices"][0]
+            choice0 = resp.choices[0]
 
             # 如果不是函数调用，且finish_reason为stop，则停止迭代
-            if choice0['finish_reason'] == 'stop':  #  and choice0["finish_reason"] == "stop"
+            if choice0.finish_reason == 'stop':  #  and choice0["finish_reason"] == "stop"
                 self.stopped = True
             
-            if 'function_call' in choice0['message']:
-                self.pending_func_call = choice0['message']['function_call']
+            if hasattr(choice0.message, 'function_call') and choice0.message.function_call is not None:
+                self.pending_func_call = choice0.message.function_call
 
                 self.append_message(
                     role="assistant",
-                    content=choice0['message']['content'],
-                    function_call=choice0['message']['function_call']
+                    content=choice0.message.content,
+                    function_call=choice0.message.function_call
                 )
 
                 return {
-                    "id": resp["id"],
+                    "id": resp.id,
                     "choices": [
                         {
-                            "index": choice0["index"],
+                            "index": choice0.index,
                             "message": {
                                 "role": "assistant",
                                 "type": "function_call",
-                                "content": choice0['message']['content'],
-                                "function_call": choice0['message']['function_call']
+                                "content": choice0.message.content,
+                                "function_call": {
+                                    "name": choice0.message.function_call.name,
+                                    "arguments": choice0.message.function_call.arguments
+                                }
                             },
                             "finish_reason": "function_call"
                         }
                     ],
-                    "usage": resp["usage"]
+                    "usage": {
+                        "prompt_tokens": resp.usage.prompt_tokens,
+                        "completion_tokens": resp.usage.completion_tokens,
+                        "total_tokens": resp.usage.total_tokens
+                    }
                 }
             else:
 
@@ -124,19 +137,23 @@ class ChatCompletionRequest(RequestBase):
                 # 普通回复一定处于最后方，故不用再追加进内部messages
 
                 return {
-                    "id": resp["id"],
+                    "id": resp.id,
                     "choices": [
                         {
-                            "index": choice0["index"],
+                            "index": choice0.index,
                             "message": {
                                 "role": "assistant",
                                 "type": "text",
-                                "content": choice0['message']['content']
+                                "content": choice0.message.content
                             },
-                            "finish_reason": choice0["finish_reason"]
+                            "finish_reason": choice0.finish_reason
                         }
                     ],
-                    "usage": resp["usage"]
+                    "usage": {
+                        "prompt_tokens": resp.usage.prompt_tokens,
+                        "completion_tokens": resp.usage.completion_tokens,
+                        "total_tokens": resp.usage.total_tokens
+                    }
                 }
         else:  # 处理函数调用请求
 
@@ -144,20 +161,20 @@ class ChatCompletionRequest(RequestBase):
             
             self.pending_func_call = None
 
-            func_name = cp_pending_func_call['name']
+            func_name = cp_pending_func_call.name
             arguments = {}
 
             try:
 
                 try:
-                    arguments = json.loads(cp_pending_func_call['arguments'])
+                    arguments = json.loads(cp_pending_func_call.arguments)
                 # 若不是json格式的异常处理
                 except json.decoder.JSONDecodeError:
                     # 获取函数的参数列表
                     func_schema = get_func_schema(func_name)
 
                     arguments = {
-                        func_schema['parameters']['required'][0]: cp_pending_func_call['arguments']
+                        func_schema['parameters']['required'][0]: cp_pending_func_call.arguments
                     }
                 
                 logging.info("执行函数调用: name={}, arguments={}".format(func_name, arguments))

pkg/openai/api/completion.py

@@ -1,4 +1,5 @@
 import openai
+from openai.types import completion, completion_choice
 
 from .model import RequestBase
 
@@ -17,10 +18,12 @@ class CompletionRequest(RequestBase):
 
     def __init__(
         self,
+        client: openai.Client,
         model: str,
         messages: list[dict[str, str]],
         **kwargs
     ):
+        self.client = client
         self.model = model
         self.prompt = ""
         
@@ -31,7 +34,7 @@ class CompletionRequest(RequestBase):
 
         self.kwargs = kwargs
 
-        self.req_func = openai.Completion.acreate
+        self.req_func = self.client.completions.create
 
     def __iter__(self):
         return self
@@ -63,49 +66,35 @@ class CompletionRequest(RequestBase):
         if self.stopped:
             raise StopIteration()
 
-        resp = self._req(
+        resp: completion.Completion = self._req(
             model=self.model,
             prompt=self.prompt,
             **self.kwargs
         )
 
-        if resp["choices"][0]["finish_reason"] == "stop":
+        if resp.choices[0].finish_reason == "stop":
             self.stopped = True
 
-        choice0 = resp["choices"][0]
+        choice0: completion_choice.CompletionChoice = resp.choices[0]
 
-        self.prompt += choice0["text"]
+        self.prompt += choice0.text
 
         return {
-            "id": resp["id"],
+            "id": resp.id,
             "choices": [
                 {
-                    "index": choice0["index"],
+                    "index": choice0.index,
                     "message": {
                         "role": "assistant",
                         "type": "text",
-                        "content": choice0["text"]
+                        "content": choice0.text
                     },
-                    "finish_reason": choice0["finish_reason"]
+                    "finish_reason": choice0.finish_reason
                 }
             ],
-            "usage": resp["usage"]
-        }
-        
-if __name__ == "__main__":
-    import os
-
-    openai.api_key = os.environ["OPENAI_API_KEY"]
-
-    for resp in CompletionRequest(
-        model="text-davinci-003",
-        messages=[
-            {
-                "role": "user",
-                "content": "Hello, who are you?"
+            "usage": {
+                "prompt_tokens": resp.usage.prompt_tokens,
+                "completion_tokens": resp.usage.completion_tokens,
+                "total_tokens": resp.usage.total_tokens
             }
-        ]
-    ):
-        print(resp)
-        if resp["choices"][0]["finish_reason"] == "stop":
-            break
+        }

pkg/openai/api/model.py

@@ -8,6 +8,8 @@ import openai
 
 class RequestBase:
 
+    client: openai.Client
+
     req_func: callable
 
     def __init__(self, *args, **kwargs):
@@ -17,41 +19,17 @@ class RequestBase:
         import pkg.utils.context as context
         switched, name = context.get_openai_manager().key_mgr.auto_switch()
         logging.debug("切换api-key: switched={}, name={}".format(switched, name))
-        openai.api_key = context.get_openai_manager().key_mgr.get_using_key()
+        self.client.api_key = context.get_openai_manager().key_mgr.get_using_key()
 
     def _req(self, **kwargs):
         """处理代理问题"""
         import config
 
-        ret: dict = {}
-        exception: Exception = None
+        ret = self.req_func(**kwargs)
+        logging.debug("接口请求返回：%s", str(ret))
 
-        async def awrapper(**kwargs):
-            nonlocal ret, exception
-
-            try:
-                ret = await self.req_func(**kwargs)
-                logging.debug("接口请求返回：%s", str(ret))
-                
-                if config.switch_strategy == 'active':
-                    self._next_key()
-
-                return ret
-            except Exception as e:
-                exception = e
-            
-        loop = asyncio.new_event_loop()
-
-        thr = threading.Thread(
-            target=loop.run_until_complete,
-            args=(awrapper(**kwargs),)
-        )
-
-        thr.start()
-        thr.join()
-
-        if exception is not None:
-            raise exception
+        if config.switch_strategy == 'active':
+            self._next_key()
 
         return ret
 

pkg/openai/manager.py

@@ -24,6 +24,8 @@ class OpenAIInteract:
         "size": "256x256",
     }
 
+    client: openai.Client = None
+
     def __init__(self, api_key: str):
 
         self.key_mgr = pkg.openai.keymgr.KeysManager(api_key)
@@ -31,7 +33,9 @@ class OpenAIInteract:
 
         # logging.info("文字总使用量：%d", self.audit_mgr.get_total_text_length())
 
-        openai.api_key = self.key_mgr.get_using_key()
+        self.client = openai.Client(
+            api_key=self.key_mgr.get_using_key()
+        )
 
         pkg.utils.context.set_openai_manager(self)
 
@@ -48,7 +52,7 @@ class OpenAIInteract:
         cp_parmas = config.completion_api_params.copy()
         del cp_parmas['model']
 
-        request = select_request_cls(model, messages, cp_parmas)
+        request = select_request_cls(self.client, model, messages, cp_parmas)
 
         # 请求接口
         for resp in request:

pkg/openai/modelmgr.py

@@ -5,43 +5,50 @@ ChatCompletion - gpt-3.5-turbo 等模型
 Completion - text-davinci-003 等模型
 此模块封装此两个接口的请求实现，为上层提供统一的调用方式
 """
-import openai, logging, threading, asyncio
-import openai.error as aiE
 import tiktoken
+import openai
 
 from pkg.openai.api.model import RequestBase
 from pkg.openai.api.completion import CompletionRequest
 from pkg.openai.api.chat_completion import ChatCompletionRequest
 
 COMPLETION_MODELS = {
-    'text-davinci-003',
-    'text-davinci-002',
-    'code-davinci-002',
-    'code-cushman-001',
-    'text-curie-001',
-    'text-babbage-001',
-    'text-ada-001',
+    "text-davinci-003", # legacy
+    "text-davinci-002", # legacy
+    "code-davinci-002", # legacy
+    "code-cushman-001", # legacy
+    "text-curie-001", # legacy
+    "text-babbage-001", # legacy
+    "text-ada-001", # legacy
+    "gpt-3.5-turbo-instruct",
 }
 
 CHAT_COMPLETION_MODELS = {
-    'gpt-3.5-turbo',
-    'gpt-3.5-turbo-16k',
-    'gpt-3.5-turbo-0613',
-    'gpt-3.5-turbo-16k-0613',
-    # 'gpt-3.5-turbo-0301',
-    'gpt-4',
-    'gpt-4-0613',
-    'gpt-4-32k',
-    'gpt-4-32k-0613',
+    # GPT 4 系列
+    "gpt-4-1106-preview",
+    "gpt-4-vision-preview",
+    "gpt-4",
+    "gpt-4-32k",
+    "gpt-4-0613",
+    "gpt-4-32k-0613",
+    "gpt-4-0314", # legacy
+    "gpt-4-32k-0314", # legacy
+    # GPT 3.5 系列
+    "gpt-3.5-turbo-1106",
+    "gpt-3.5-turbo",
+    "gpt-3.5-turbo-16k",
+    "gpt-3.5-turbo-0613", # legacy
+    "gpt-3.5-turbo-16k-0613", # legacy
+    "gpt-3.5-turbo-0301", # legacy
     # One-API 接入
-    'SparkDesk',
-    'chatglm_pro',
-    'chatglm_std',
-    'chatglm_lite',
-    'qwen-v1',
-    'qwen-plus-v1',
-    'ERNIE-Bot',
-    'ERNIE-Bot-turbo',
+    "SparkDesk",
+    "chatglm_pro",
+    "chatglm_std",
+    "chatglm_lite",
+    "qwen-v1",
+    "qwen-plus-v1",
+    "ERNIE-Bot",
+    "ERNIE-Bot-turbo",
 }
 
 EDIT_MODELS = {
@@ -53,11 +60,11 @@ IMAGE_MODELS = {
 }
 
 
-def select_request_cls(model_name: str, messages: list, args: dict) -> RequestBase:
+def select_request_cls(client: openai.Client, model_name: str, messages: list, args: dict) -> RequestBase:
     if model_name in CHAT_COMPLETION_MODELS:
-        return ChatCompletionRequest(model_name, messages, **args)
+        return ChatCompletionRequest(client, model_name, messages, **args)
     elif model_name in COMPLETION_MODELS:
-        return CompletionRequest(model_name, messages, **args)
+        return CompletionRequest(client, model_name, messages, **args)
     raise ValueError("不支持模型[{}]，请检查配置文件".format(model_name))
 
 

pkg/openai/session.py

@@ -278,7 +278,7 @@ class Session:
             if resp['choices'][0]['message']['role'] == "assistant" and resp['choices'][0]['message']['content'] != None:  # 包含纯文本响应
 
                 if not trace_func_calls:
-                    res_text += resp['choices'][0]['message']['content'] + "\n"
+                    res_text += resp['choices'][0]['message']['content']
                 else:
                     res_text = resp['choices'][0]['message']['content']
                     pending_res_text = resp['choices'][0]['message']['content']

pkg/plugin/host.py

@@ -7,14 +7,19 @@ import pkgutil
 import sys
 import shutil
 import traceback
+import time
+import re
 
 import pkg.utils.updater as updater
 import pkg.utils.context as context
 import pkg.plugin.switch as switch
 import pkg.plugin.settings as settings
 import pkg.qqbot.adapter as msadapter
+import pkg.utils.network as network
+import pkg.plugin.metadata as metadata
 
 from mirai import Mirai
+import requests
 
 from CallingGPT.session.session import Session
 
@@ -65,6 +70,8 @@ def generate_plugin_order():
 def iter_plugins():
     """按照顺序迭代插件"""
     for plugin_name in __plugins_order__:
+        if plugin_name not in __plugins__:
+            continue
         yield __plugins__[plugin_name]
 
 
@@ -113,10 +120,15 @@ def load_plugins():
     # 加载插件顺序
     settings.load_settings()
 
+    logging.debug("registered plugins: {}".format(__plugins__))
+
     # 输出已注册的内容函数列表
     logging.debug("registered content functions: {}".format(__callable_functions__))
     logging.debug("function instance map: {}".format(__function_inst_map__))
 
+    # 迁移插件源地址记录
+    metadata.do_plugin_git_repo_migrate()
+
 
 def initialize_plugins():
     """初始化插件"""
@@ -155,34 +167,100 @@ def unload_plugins():
     #                 logging.error("插件{}卸载时发生错误: {}".format(plugin['name'], sys.exc_info()))
 
 
-def install_plugin(repo_url: str):
-    """安装插件，从git储存库获取并解决依赖"""
-    try:
-        import pkg.utils.pkgmgr
-        pkg.utils.pkgmgr.ensure_dulwich()
-    except:
-        pass
+def get_github_plugin_repo_label(repo_url: str) -> list[str]:
+    """获取username, repo"""
 
-    try:
-        import dulwich
-    except ModuleNotFoundError:
-        raise Exception("dulwich模块未安装,请查看 https://github.com/RockChinQ/QChatGPT/issues/77")
+    # 提取 username/repo , 正则表达式
+    repo =  re.findall(r'(?:https?://github\.com/|git@github\.com:)([^/]+/[^/]+?)(?:\.git|/|$)', repo_url)
 
-    from dulwich import porcelain
+    if len(repo) > 0: # github
+        return repo[0].split("/")
+    else:
+        return None
 
-    logging.info("克隆插件储存库: {}".format(repo_url))
-    repo = porcelain.clone(repo_url, "plugins/"+repo_url.split(".git")[0].split("/")[-1]+"/", checkout=True)
 
+def download_plugin_source_code(repo_url: str, target_path: str) -> str:
+    """下载插件源码"""
+    # 检查源类型
+    
+    # 提取 username/repo , 正则表达式
+    repo =  get_github_plugin_repo_label(repo_url)
+
+    target_path += repo[1]
+
+    if repo is not None: # github
+        logging.info("从 GitHub 下载插件源码...")
+
+        zipball_url = f"https://api.github.com/repos/{'/'.join(repo)}/zipball/HEAD"
+
+        zip_resp = requests.get(
+            url=zipball_url,
+            proxies=network.wrapper_proxies(),
+            stream=True
+        )
+
+        if zip_resp.status_code != 200:
+            raise Exception("下载源码失败: {}".format(zip_resp.text))
+        
+        if os.path.exists("temp/"+target_path):
+            shutil.rmtree("temp/"+target_path)
+
+        if os.path.exists(target_path):
+            shutil.rmtree(target_path)
+
+        os.makedirs("temp/"+target_path)
+
+        with open("temp/"+target_path+"/source.zip", "wb") as f:
+            for chunk in zip_resp.iter_content(chunk_size=1024):
+                if chunk:
+                    f.write(chunk)
+
+        logging.info("下载完成, 解压...")
+        import zipfile
+        with zipfile.ZipFile("temp/"+target_path+"/source.zip", 'r') as zip_ref:
+            zip_ref.extractall("temp/"+target_path)
+        os.remove("temp/"+target_path+"/source.zip")
+
+        # 目标是 username-repo-hash , 用正则表达式提取完整的文件夹名，复制到 plugins/repo
+        import glob
+
+        # 获取解压后的文件夹名
+        unzip_dir = glob.glob("temp/"+target_path+"/*")[0]
+
+        # 复制到 plugins/repo
+        shutil.copytree(unzip_dir, target_path+"/")
+
+        # 删除解压后的文件夹
+        shutil.rmtree(unzip_dir)
+
+        logging.info("解压完成")
+    else:
+        raise Exception("暂不支持的源类型，请使用 GitHub 仓库发行插件。")
+    
+    return repo[1]
+
+
+def check_requirements(path: str):
     # 检查此目录是否包含requirements.txt
-    if os.path.exists("plugins/"+repo_url.split(".git")[0].split("/")[-1]+"/requirements.txt"):
+    if os.path.exists(path+"/requirements.txt"):
         logging.info("检测到requirements.txt，正在安装依赖")
         import pkg.utils.pkgmgr
-        pkg.utils.pkgmgr.install_requirements("plugins/"+repo_url.split(".git")[0].split("/")[-1]+"/requirements.txt")
+        pkg.utils.pkgmgr.install_requirements(path+"/requirements.txt")
 
         import pkg.utils.log as log
         log.reset_logging()
 
 
+def install_plugin(repo_url: str):
+    """安装插件，从git储存库获取并解决依赖"""
+
+    repo_label = download_plugin_source_code(repo_url, "plugins/")
+
+    check_requirements("plugins/"+repo_label)
+
+    metadata.set_plugin_metadata(repo_label, repo_url, int(time.time()), "HEAD")
+
+
 def uninstall_plugin(plugin_name: str) -> str:
     """卸载插件"""
     if plugin_name not in __plugins__:
@@ -202,39 +280,43 @@ def uninstall_plugin(plugin_name: str) -> str:
 def update_plugin(plugin_name: str):
     """更新插件"""
     # 检查是否有远程地址记录
-    target_plugin_dir = "plugins/" + __plugins__[plugin_name]['path'].replace("\\", "/").split("plugins/")[1].split("/")[0]
+    plugin_path_name = get_plugin_path_name_by_plugin_name(plugin_name)
 
-    remote_url = updater.get_remote_url(target_plugin_dir)
+    meta = metadata.get_plugin_metadata(plugin_path_name)
+
+    if meta == {}:
+        raise Exception("没有此插件元数据信息，无法更新")
+
+    remote_url = meta['source']
     if remote_url == "https://github.com/RockChinQ/QChatGPT" or remote_url == "https://gitee.com/RockChin/QChatGPT" \
         or remote_url == "" or remote_url is None or remote_url == "http://github.com/RockChinQ/QChatGPT" or remote_url == "http://gitee.com/RockChin/QChatGPT":
         raise Exception("插件没有远程地址记录，无法更新")
     
-    # 把远程clone到temp/plugins/update/插件名
-    logging.info("克隆插件储存库: {}".format(remote_url))
+    # 重新安装插件
+    logging.info("正在重新安装插件以进行更新...")
 
-    from dulwich import porcelain
-    clone_target_dir = "temp/plugins/update/"+target_plugin_dir.split("/")[-1]+"/"
+    install_plugin(remote_url)
 
-    if os.path.exists(clone_target_dir):
-        shutil.rmtree(clone_target_dir)
 
-    if not os.path.exists(clone_target_dir):
-        os.makedirs(clone_target_dir)
-    repo = porcelain.clone(remote_url, clone_target_dir, checkout=True)
+def get_plugin_name_by_path_name(plugin_path_name: str) -> str:
+    for k, v in __plugins__.items():
+        if v['path'] == "plugins/"+plugin_path_name+"/main.py":
+            return k
+    return None
 
-    # 检查此目录是否包含requirements.txt
-    if os.path.exists(clone_target_dir+"requirements.txt"):
-        logging.info("检测到requirements.txt，正在安装依赖")
-        import pkg.utils.pkgmgr
-        pkg.utils.pkgmgr.install_requirements(clone_target_dir+"requirements.txt")
 
-        import pkg.utils.log as log
-        log.reset_logging()
+def get_plugin_path_name_by_plugin_name(plugin_name: str) -> str:
+    if plugin_name not in __plugins__:
+        return None
+    
+    plugin_main_module_path = __plugins__[plugin_name]['path']
 
-    # 将temp/plugins/update/插件名 覆盖到 plugins/插件名
-    shutil.rmtree(target_plugin_dir)
+    plugin_main_module_path = plugin_main_module_path.replace("\\", "/")
+
+    spt = plugin_main_module_path.split("/")
+
+    return spt[1]
 
-    shutil.copytree(clone_target_dir, target_plugin_dir)
 
 class EventContext:
     """事件上下文"""

pkg/plugin/metadata.py

@@ -0,0 +1,87 @@
+import os
+import shutil
+import json
+import time
+
+import dulwich.errors as dulwich_err
+
+from ..utils import updater
+
+
+def read_metadata_file() -> dict:
+    # 读取 plugins/metadata.json 文件
+    if not os.path.exists('plugins/metadata.json'):
+        return {}
+    with open('plugins/metadata.json', 'r') as f:
+        return json.load(f)
+
+
+def write_metadata_file(metadata: dict):
+    if not os.path.exists('plugins'):
+        os.mkdir('plugins')
+
+    with open('plugins/metadata.json', 'w') as f:
+        json.dump(metadata, f, indent=4, ensure_ascii=False)
+
+
+def do_plugin_git_repo_migrate():
+    # 仅在 plugins/metadata.json 不存在时执行
+    if os.path.exists('plugins/metadata.json'):
+        return
+
+    metadata = read_metadata_file()
+
+    # 遍历 plugins 下所有目录，获取目录的git远程地址
+    for plugin_name in os.listdir('plugins'):
+        plugin_path = os.path.join('plugins', plugin_name)
+        if not os.path.isdir(plugin_path):
+            continue
+        
+        remote_url = None
+        try:
+            remote_url = updater.get_remote_url(plugin_path)
+        except dulwich_err.NotGitRepository:
+            continue
+        if remote_url == "https://github.com/RockChinQ/QChatGPT" or remote_url == "https://gitee.com/RockChin/QChatGPT" \
+            or remote_url == "" or remote_url is None or remote_url == "http://github.com/RockChinQ/QChatGPT" or remote_url == "http://gitee.com/RockChin/QChatGPT":
+            continue
+
+        from . import host
+
+        if plugin_name not in metadata:
+            metadata[plugin_name] = {
+                'source': remote_url,
+                'install_timestamp': int(time.time()),
+                'ref': 'HEAD',
+            }
+
+    write_metadata_file(metadata)
+    
+
+def set_plugin_metadata(
+    plugin_name: str,
+    source: str,
+    install_timestamp: int,
+    ref: str,
+):
+    metadata = read_metadata_file()
+    metadata[plugin_name] = {
+        'source': source,
+        'install_timestamp': install_timestamp,
+        'ref': ref,
+    }
+    write_metadata_file(metadata)
+
+
+def remove_plugin_metadata(plugin_name: str):
+    metadata = read_metadata_file()
+    if plugin_name in metadata:
+        del metadata[plugin_name]
+        write_metadata_file(metadata)
+
+
+def get_plugin_metadata(plugin_name: str) -> dict:
+    metadata = read_metadata_file()
+    if plugin_name in metadata:
+        return metadata[plugin_name]
+    return {}

pkg/qqbot/cmds/plugin/plugin.py

@@ -84,7 +84,7 @@ class PluginGetCommand(AbstractCommandNode):
 @AbstractCommandNode.register(
     parent=PluginCommand,
     name="update",
-    description="更新所有插件",
+    description="更新指定插件或全部插件",
     usage="!plugin update",
     aliases=[],
     privilege=2
@@ -110,7 +110,9 @@ class PluginUpdateCommand(AbstractCommandNode):
                             plugin_host.update_plugin(key)
                             updated.append(key)
                     else:
-                        if ctx.crt_params[0] in plugin_list:
+                        plugin_path_name = plugin_host.get_plugin_path_name_by_plugin_name(ctx.crt_params[0])
+
+                        if plugin_path_name is not None:
                             plugin_host.update_plugin(ctx.crt_params[0])
                             updated.append(ctx.crt_params[0])
                         else:
@@ -119,7 +121,7 @@ class PluginUpdateCommand(AbstractCommandNode):
                     pkg.utils.context.get_qqbot_manager().notify_admin("已更新插件: {}, 请发送 !reload 重载插件".format(", ".join(updated)))
                 except Exception as e:
                     logging.error("插件更新失败:{}".format(e))
-                    pkg.utils.context.get_qqbot_manager().notify_admin("插件更新失败:{} 请尝试手动更新插件".format(e))
+                    pkg.utils.context.get_qqbot_manager().notify_admin("插件更新失败:{} 请使用 !plugin 命令确认插件名称或尝试手动更新插件".format(e))
 
             reply = ["[bot]正在更新插件，请勿重复发起..."]
             threading.Thread(target=closure).start()

pkg/qqbot/message.py

@@ -65,14 +65,14 @@ def process_normal_message(text_message: str, mgr, config, launcher_type: str,
             if not event.is_prevented_default():
                 reply = [prefix + text]
 
-        except openai.error.APIConnectionError as e:
+        except openai.APIConnectionError as e:
             err_msg = str(e)
             if err_msg.__contains__('Error communicating with OpenAI'):
                 reply = handle_exception("{}会话调用API失败:{}\n您的网络无法访问OpenAI接口或网络代理不正常".format(session_name, e),
                                          "[bot]err:调用API失败，请重试或联系管理员，或等待修复")
             else:
                 reply = handle_exception("{}会话调用API失败:{}".format(session_name, e), "[bot]err:调用API失败，请重试或联系管理员，或等待修复")
-        except openai.error.RateLimitError as e:
+        except openai.RateLimitError as e:
             logging.debug(type(e))
             logging.debug(e.error['message'])
 
@@ -116,14 +116,14 @@ def process_normal_message(text_message: str, mgr, config, launcher_type: str,
             else:
                 reply = handle_exception("{}会话调用API失败:{}".format(session_name, e),
                                          "[bot]err:RateLimitError,请重试或联系作者，或等待修复")
-        except openai.error.InvalidRequestError as e:
+        except openai.BadRequestError as e:
             if config.auto_reset and "This model's maximum context length is" in str(e):
                 session.reset(persist=True)
                 reply = [tips_custom.session_auto_reset_message]
             else:
                 reply = handle_exception("{}API调用参数错误:{}\n".format(
                                 session_name, e), "[bot]err:API调用参数错误，请联系管理员，或等待修复")
-        except openai.error.ServiceUnavailableError as e:
+        except openai.APIStatusError as e:
             reply = handle_exception("{}API调用服务不可用:{}".format(session_name, e), "[bot]err:API调用服务不可用，请重试或联系管理员，或等待修复")
         except Exception as e:
             logging.exception(e)

pkg/qqbot/sources/nakuru.py

@@ -185,7 +185,11 @@ class NakuruProjectAdapter(MessageSourceAdapter):
         if resp.status_code == 403:
             logging.error("go-cqhttp拒绝访问，请检查config.py中nakuru_config的token是否与go-cqhttp设置的access-token匹配")
             raise Exception("go-cqhttp拒绝访问，请检查config.py中nakuru_config的token是否与go-cqhttp设置的access-token匹配")
-        self.bot_account_id = int(resp.json()['data']['user_id'])
+        try:
+            self.bot_account_id = int(resp.json()['data']['user_id'])
+        except Exception as e:
+            logging.error("获取go-cqhttp账号信息失败: {}, 请检查是否已启动go-cqhttp并配置正确".format(e))
+            raise Exception("获取go-cqhttp账号信息失败: {}, 请检查是否已启动go-cqhttp并配置正确".format(e))
 
     def send_message(
         self,

requirements.txt

@@ -1,5 +1,5 @@
 requests
-openai~=0.28.0
+openai
 dulwich~=0.21.6
 colorlog~=6.6.0
 yiri-mirai
@@ -10,4 +10,4 @@ Pillow
 nakuru-project-idk
 CallingGPT
 tiktoken
-PyYaml
+PyYaml

res/announcement.json

@@ -4,5 +4,11 @@
         "time": "2023-08-01 10:49:26",
         "timestamp": 1690858166,
         "content": "现已支持GPT函数调用功能，欢迎了解：https://github.com/RockChinQ/QChatGPT/wiki/%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8-%E5%86%85%E5%AE%B9%E5%87%BD%E6%95%B0"
+    },
+    {
+        "id": 3,
+        "time": "2023-11-10 12:20:09",
+        "timestamp": 1699590009,
+        "content": "OpenAI 库1.0版本已发行，若出现 OpenAI 调用问题，请更新 QChatGPT 版本。详见项目主页：https://github.com/RockChinQ/QChatGPT"
     }
 ]

tests/proxy_test/forward_proxy_test.py

@@ -0,0 +1,24 @@
+import os
+
+import openai
+
+client = openai.Client(
+    api_key=os.environ["OPENAI_API_KEY"],
+)
+
+openai.proxies = {
+    'http': 'http://127.0.0.1:7890',
+    'https': 'http://127.0.0.1:7890',
+}
+
+resp = client.chat.completions.create(
+    model="gpt-3.5-turbo",
+    messages=[
+        {
+            "role": "user",
+            "content": "Hello, how are you?",
+        }
+    ]
+)
+
+print(resp)

tests/repo_regexp_test.py

@@ -0,0 +1,7 @@
+import re
+
+repo_url = "git@github.com:RockChinQ/WebwlkrPlugin.git"
+
+repo =  re.findall(r'(?:https?://github\.com/|git@github\.com:)([^/]+/[^/]+?)(?:\.git|/|$)', repo_url)
+
+print(repo)