fix: azure dalle generate image

plugin(tool): 更新0.4.2

.flake8

@@ -0,0 +1,13 @@
+[flake8]
+max-line-length = 176
+select = E303,W293,W291,W292,E305,E231,E302
+exclude =
+    .tox,
+    __pycache__,
+    *.pyc,
+    .env
+    venv/*
+    .venv/*
+    reports/*
+    dist/*
+    lib/*

.github/ISSUE_TEMPLATE.md

@@ -1,31 +0,0 @@
-### 前置确认
-
-1. 网络能够访问openai接口
-2. python 已安装：版本在 3.7 ~ 3.10 之间
-3. `git pull` 拉取最新代码
-4. 执行`pip3 install -r requirements.txt`，检查依赖是否满足
-5. 拓展功能请执行`pip3 install -r requirements-optional.txt`，检查依赖是否满足
-6. 在已有 issue 中未搜索到类似问题
-7. [FAQS](https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs) 中无类似问题
-
-
-### 问题描述
-
-> 简要说明、截图、复现步骤等，也可以是需求或想法
-
-
-
-
-### 终端日志 (如有报错)
-
-```
-[在此处粘贴终端日志, 可在主目录下`run.log`文件中找到]
-```
-
-
-
-### 环境
-
- - 操作系统类型  (Mac/Windows/Linux)：
- - Python版本  ( 执行 `python3 -V` )：                      
- - pip版本  ( 依赖问题此项必填，执行 `pip3 -V`)：

.github/ISSUE_TEMPLATE/1.bug.yml

@@ -0,0 +1,133 @@
+name: Bug report 🐛
+description: 项目运行中遇到的Bug或问题。
+labels: ['status: needs check']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ### ⚠️ 前置确认
+        1. 网络能够访问openai接口
+        2. python 已安装：版本在 3.7 ~ 3.10 之间
+        3. `git pull` 拉取最新代码
+        4. 执行`pip3 install -r requirements.txt`，检查依赖是否满足
+        5. 拓展功能请执行`pip3 install -r requirements-optional.txt`，检查依赖是否满足
+        6. [FAQS](https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs) 中无类似问题
+  - type: checkboxes
+    attributes:
+      label: 前置确认
+      options:
+        - label: 我确认我运行的是最新版本的代码，并且安装了所需的依赖，在[FAQS](https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs)中也未找到类似问题。
+          required: true
+  - type: checkboxes
+    attributes:
+      label: ⚠️ 搜索issues中是否已存在类似问题
+      description: >
+        请在 [历史issue](https://github.com/zhayujie/chatgpt-on-wechat/issues) 中清空输入框，搜索你的问题
+        或相关日志的关键词来查找是否存在类似问题。
+      options:
+        - label: 我已经搜索过issues和disscussions，没有跟我遇到的问题相关的issue
+          required: true
+  - type: markdown
+    attributes:
+      value: |
+        请在上方的`title`中填写你对你所遇到问题的简略总结，这将帮助其他人更好的找到相似问题，谢谢❤️。
+  - type: dropdown
+    attributes:
+      label: 操作系统类型?
+      description: >
+        请选择你运行程序的操作系统类型。
+      options:
+        - Windows
+        - Linux
+        - MacOS
+        - Docker
+        - Railway
+        - Windows Subsystem for Linux (WSL)
+        - Other (请在问题中说明)
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: 运行的python版本是?
+      description: |
+        请选择你运行程序的`python`版本。
+        注意：在`python 3.7`中，有部分可选依赖无法安装。
+        经过长时间的观察，我们认为`python 3.8`是兼容性最好的版本。
+        `python 3.7`~`python 3.10`以外版本的issue，将视情况直接关闭。
+      options:
+        - python 3.7
+        - python 3.8
+        - python 3.9
+        - python 3.10
+        - other
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: 使用的chatgpt-on-wechat版本是?
+      description: |
+        请确保你使用的是 [releases](https://github.com/zhayujie/chatgpt-on-wechat/releases) 中的最新版本。
+        如果你使用git, 请使用`git branch`命令来查看分支。
+      options:
+        - Latest Release
+        - Master (branch)
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: 运行的`channel`类型是?
+      description: |
+        请确保你正确配置了该`channel`所需的配置项，所有可选的配置项都写在了[该文件中](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py)，请将所需配置项填写在根目录下的`config.json`文件中。
+      options:
+        - wx(个人微信, itchat)
+        - wxy(个人微信, wechaty)
+        - wechatmp(公众号, 订阅号)
+        - wechatmp_service(公众号, 服务号)
+        - terminal
+        - other
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 复现步骤 🕹
+      description: |
+        **⚠️ 不能复现将会关闭issue.**
+  - type: textarea
+    attributes:
+      label: 问题描述 😯
+      description: 详细描述出现的问题，或提供有关截图。
+  - type: textarea
+    attributes:
+      label: 终端日志 📒
+      description: |
+        在此处粘贴终端日志，可在主目录下`run.log`文件中找到，这会帮助我们更好的分析问题，注意隐去你的API key。
+        如果在配置文件中加入`"debug": true`，打印出的日志会更有帮助。
+
+        <details>
+        <summary><i>示例</i></summary>
+        ```log
+        [DEBUG][2023-04-16 00:23:22][plugin_manager.py:157] - Plugin SUMMARY triggered by event Event.ON_HANDLE_CONTEXT
+        [DEBUG][2023-04-16 00:23:22][main.py:221] - [Summary] on_handle_context. content: $总结前100条消息
+        [DEBUG][2023-04-16 00:23:24][main.py:240] - [Summary] limit: 100, duration: -1 seconds
+        [ERROR][2023-04-16 00:23:24][chat_channel.py:244] - Worker return exception: name 'start_date' is not defined
+        Traceback (most recent call last):
+          File "C:\ProgramData\Anaconda3\lib\concurrent\futures\thread.py", line 57, in run
+            result = self.fn(*self.args, **self.kwargs)
+          File "D:\project\chatgpt-on-wechat\channel\chat_channel.py", line 132, in _handle
+            reply = self._generate_reply(context)
+          File "D:\project\chatgpt-on-wechat\channel\chat_channel.py", line 142, in _generate_reply
+            e_context = PluginManager().emit_event(EventContext(Event.ON_HANDLE_CONTEXT, {
+          File "D:\project\chatgpt-on-wechat\plugins\plugin_manager.py", line 159, in emit_event
+            instance.handlers[e_context.event](e_context, *args, **kwargs)
+          File "D:\project\chatgpt-on-wechat\plugins\summary\main.py", line 255, in on_handle_context
+            records = self._get_records(session_id, start_time, limit)
+          File "D:\project\chatgpt-on-wechat\plugins\summary\main.py", line 96, in _get_records
+            c.execute("SELECT * FROM chat_records WHERE sessionid=? and timestamp>? ORDER BY timestamp DESC LIMIT ?", (session_id, start_date, limit))
+        NameError: name 'start_date' is not defined
+        [INFO][2023-04-16 00:23:36][app.py:14] - signal 2 received, exiting...
+        ```
+        </details>
+      value: |
+        ```log
+        <此处粘贴终端日志>
+        ```

.github/ISSUE_TEMPLATE/2.feature.yml

@@ -0,0 +1,28 @@
+name: Feature request 🚀
+description: 提出你对项目的新想法或建议。
+labels: ['status: needs check']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        请在上方的`title`中填写简略总结，谢谢❤️。
+  - type: checkboxes
+    attributes:
+      label: ⚠️ 搜索是否存在类似issue
+      description: >
+        请在 [历史issue](https://github.com/zhayujie/chatgpt-on-wechat/issues) 中清空输入框，搜索关键词查找是否存在相似issue。
+      options:
+        - label: 我已经搜索过issues和disscussions，没有发现相似issue
+          required: true
+  - type: textarea
+    attributes:
+      label: 总结
+      description: 描述feature的功能。
+  - type: textarea
+    attributes:
+      label: 举例
+      description: 提供聊天示例，草图或相关网址。
+  - type: textarea
+    attributes:
+      label: 动机
+      description: 描述你提出该feature的动机，比如没有这项feature对你的使用造成了怎样的影响。 请提供更详细的场景描述，这可能会帮助我们发现并提出更好的解决方案。

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,6 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 知识星球
+    url: https://public.zsxq.com/groups/88885848842852.html
+    about: 如果你想了解更多项目细节，并与开发者们交流更多关于AI技术的实践，欢迎加入星球
+

.github/workflows/deploy-image.yml

@@ -49,9 +49,9 @@ jobs:
           file: ./docker/Dockerfile.latest
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-      
+
       - uses: actions/delete-package-versions@v4
-        with: 
+        with:
           package-name: 'chatgpt-on-wechat'
           package-type: 'container'
           min-versions-to-keep: 10

.gitignore

@@ -1,5 +1,6 @@
 .DS_Store
 .idea
+.vscode
 .wechaty/
 __pycache__/
 venv*
@@ -12,6 +13,7 @@ plugins.json
 itchat.pkl
 *.log
 user_datas.pkl
+chatgpt_tool_hub/
 plugins/**/
 !plugins/bdunit
 !plugins/dungeon
@@ -19,5 +21,7 @@ plugins/**/
 !plugins/godcmd
 !plugins/tool
 !plugins/banwords
+!plugins/banwords/**/
 !plugins/hello
-!plugins/role
+!plugins/role
+!plugins/keyword

.pre-commit-config.yaml

@@ -0,0 +1,30 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: fix-byte-order-marker
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: debug-statements
+      - id: pretty-format-json
+        types: [text]
+        files: \.json(.template)?$
+        args: [ --autofix , --no-ensure-ascii, --indent=2, --no-sort-keys]
+      - id: trailing-whitespace
+        exclude: '(\/|^)lib\/'
+        args: [ --markdown-linebreak-ext=md ]
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+        exclude: '(\/|^)lib\/'
+  - repo: https://github.com/psf/black
+    rev: 23.3.0
+    hooks:
+      - id: black
+        exclude: '(\/|^)lib\/'
+  - repo: https://github.com/PyCQA/flake8
+    rev: 6.0.0
+    hooks:
+      - id: flake8
+        exclude: '(\/|^)lib\/'

README.md

@@ -2,28 +2,32 @@
 
 > ChatGPT近期以强大的对话和信息整合能力风靡全网，可以写代码、改论文、讲故事，几乎无所不能，这让人不禁有个大胆的想法，能否用他的对话模型把我们的微信打造成一个智能机器人，可以在与好友对话中给出意想不到的回应，而且再也不用担心女朋友影响我们 ~~打游戏~~ 工作了。
 
+最新版本支持的功能如下：
 
-基于ChatGPT的微信聊天机器人，通过 [ChatGPT](https://github.com/openai/openai-python) 接口生成对话内容，使用 [itchat](https://github.com/littlecodersh/ItChat) 实现微信消息的接收和自动回复。已实现的特性如下：
+- [x] **多端部署：** 有多种部署方式可选择且功能完备，目前已支持个人微信，微信公众号和企业微信应用等部署方式
+- [x] **基础对话：** 私聊及群聊的消息智能回复，支持多轮会话上下文记忆，支持 GPT-3，GPT-3.5，GPT-4模型
+- [x] **语音识别：** 可识别语音消息，通过文字或语音回复，支持 azure, baidu, google, openai等多种语音模型
+- [x] **图片生成：** 支持图片生成 和 图生图（如照片修复），可选择 Dell-E, stable diffusion, replicate模型
+- [x] **丰富插件：** 支持个性化插件扩展，已实现多角色切换、文字冒险、敏感词过滤、聊天记录总结等插件
+- [X] **Tool工具：** 与操作系统和互联网交互，支持最新信息搜索、数学计算、天气和资讯查询、网页总结，基于 [chatgpt-tool-hub](https://github.com/goldfishh/chatgpt-tool-hub) 实现
 
-- [x] **文本对话：** 接收私聊及群组中的微信消息，使用ChatGPT生成回复内容，完成自动回复
-- [x] **规则定制化：** 支持私聊中按指定规则触发自动回复，支持对群组设置自动回复白名单
-- [x] **多账号：** 支持多微信账号同时运行
-- [x] **图片生成：** 支持根据描述生成图片，并自动发送至个人聊天或群聊
-- [x] **上下文记忆**：支持多轮对话记忆，且为每个好友维护独立的上下会话
-- [x] **语音识别：** 支持接收和处理语音消息，通过文字或语音回复
-- [x] **插件化：** 支持个性化功能插件，提供角色扮演、文字冒险游戏等预设插件
+> 欢迎接入更多应用，参考 [Terminal代码](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/terminal/terminal_channel.py)实现接收和发送消息逻辑即可接入。 同时欢迎增加新的插件，参考 [插件说明文档](https://github.com/zhayujie/chatgpt-on-wechat/tree/master/plugins)。
 
-> 目前支持微信和微信个人号部署，欢迎接入更多应用，参考[`Terminal`代码](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/terminal/terminal_channel.py)实现接收和发送消息逻辑即可接入。
+**一键部署:**
 
+[![Deploy on Railway](https://railway.app/button.svg)](https://railway.app/template/qApznZ?referralCode=RC3znh)
 
-快速部署:
->
->[![Deploy on Railway](https://railway.app/button.svg)](https://railway.app/template/qApznZ?referralCode=RC3znh)
+# 演示
 
+https://user-images.githubusercontent.com/26161723/233777277-e3b9928e-b88f-43e2-b0e0-3cbc923bc799.mp4
+
+Demo made by [Visionn](https://www.wangpc.cc/)
 
 # 更新日志
 
->**2023.04.05：** 支持微信个人号部署，兼容角色扮演等预设插件，[使用文档](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/wechatmp/README.md)。(contributed by [@JS00000](https://github.com/JS00000) in [#686](https://github.com/zhayujie/chatgpt-on-wechat/pull/686))
+>**2023.04.26：** 支持企业微信应用号部署，兼容插件，并支持语音图片交互，支持Railway部署，[使用文档](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/wechatcom/README.md)。(contributed by [@lanvent](https://github.com/lanvent) in [#944](https://github.com/zhayujie/chatgpt-on-wechat/pull/944))
+
+>**2023.04.05：** 支持微信公众号部署，兼容插件，并支持语音图片交互，[使用文档](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/wechatmp/README.md)。(contributed by [@JS00000](https://github.com/JS00000) in [#686](https://github.com/zhayujie/chatgpt-on-wechat/pull/686))
 
 >**2023.04.05：** 增加能让ChatGPT使用工具的`tool`插件，[使用文档](https://github.com/goldfishh/chatgpt-on-wechat/blob/master/plugins/tool/README.md)。工具相关issue可反馈至[chatgpt-tool-hub](https://github.com/goldfishh/chatgpt-tool-hub)。(contributed by [@goldfishh](https://github.com/goldfishh) in [#663](https://github.com/zhayujie/chatgpt-on-wechat/pull/663))
 
@@ -33,28 +37,7 @@
 
 >**2023.03.02：** 接入[ChatGPT API](https://platform.openai.com/docs/guides/chat) (gpt-3.5-turbo)，默认使用该模型进行对话，需升级openai依赖 (`pip3 install --upgrade openai`)。网络问题参考 [#351](https://github.com/zhayujie/chatgpt-on-wechat/issues/351)
 
->**2023.02.09：** 扫码登录存在封号风险，请谨慎使用，参考[#58](https://github.com/AutumnWhj/ChatGPT-wechat-bot/issues/158)
-
->**2023.02.05：** 在openai官方接口方案中 (GPT-3模型) 实现上下文对话
-
->**2022.12.18：** 支持根据描述生成图片并发送，openai版本需大于0.25.0
-
->**2022.12.17：** 原来的方案是从 [ChatGPT页面](https://chat.openai.com/chat) 获取session_token，使用 [revChatGPT](https://github.com/acheong08/ChatGPT) 直接访问web接口，但随着ChatGPT接入Cloudflare人机验证，这一方案难以在服务器顺利运行。 所以目前使用的方案是调用 OpenAI 官方提供的 [API](https://beta.openai.com/docs/api-reference/introduction)，回复质量上基本接近于ChatGPT的内容，劣势是暂不支持有上下文记忆的对话，优势是稳定性和响应速度较好。
-
-# 使用效果
-
-### 个人聊天
-
-![single-chat-sample.jpg](docs/images/single-chat-sample.jpg)
-
-### 群组聊天
-
-![group-chat-sample.jpg](docs/images/group-chat-sample.jpg)
-
-### 图片生成
-
-![group-chat-sample.jpg](docs/images/image-create-sample.jpg)
-
+>**2023.02.09：** 扫码登录存在账号限制风险，请谨慎使用，参考[#58](https://github.com/AutumnWhj/ChatGPT-wechat-bot/issues/158)
 
 # 快速开始
 
@@ -64,7 +47,7 @@
 
 前往 [OpenAI注册页面](https://beta.openai.com/signup) 创建账号，参考这篇 [教程](https://www.pythonthree.com/register-openai-chatgpt/) 可以通过虚拟手机号来接收验证码。创建完账号则前往 [API管理页面](https://beta.openai.com/account/api-keys) 创建一个 API Key 并保存下来，后面需要在项目中配置这个key。
 
-> 项目中使用的对话模型是 davinci，计费方式是约每 750 字 (包含请求和回复) 消耗 $0.02，图片生成是每张消耗 $0.016，账号创建有免费的 $18 额度 (更新3.25: 最新注册的已经无免费额度了)，使用完可以更换邮箱重新注册。
+> 项目中默认使用的对话模型是 gpt3.5 turbo，计费方式是约每 500 汉字 (包含请求和回复) 消耗 $0.002，图片生成是每张消耗 $0.016。
 
 ### 2.运行环境
 
@@ -100,15 +83,13 @@ pip3 install -r requirements-optional.txt
 
 参考[#415](https://github.com/zhayujie/chatgpt-on-wechat/issues/415)
 
-使用`azure`语音功能需安装依赖（列在`requirements-optional.txt`内，但为便于`railway`部署已注释）:
+使用`azure`语音功能需安装依赖，并参考[文档](https://learn.microsoft.com/en-us/azure/cognitive-services/speech-service/quickstarts/setup-platform?pivots=programming-language-python&tabs=linux%2Cubuntu%2Cdotnet%2Cjre%2Cmaven%2Cnodejs%2Cmac%2Cpypi)的环境要求。
+:
 
 ```bash
 pip3 install azure-cognitiveservices-speech
 ```
 
-> 目前默认发布的镜像和`railway`部署，都基于`apline`，无法安装`azure`的依赖。若有需求请自行基于[`debian`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/docker/Dockerfile.debian.latest)打包。
-参考[文档](https://learn.microsoft.com/en-us/azure/cognitive-services/speech-service/quickstarts/setup-platform?pivots=programming-language-python&tabs=linux%2Cubuntu%2Cdotnet%2Cjre%2Cmaven%2Cnodejs%2Cmac%2Cpypi)
-
 ## 配置
 
 配置文件的模板在根目录的`config-template.json`中，需复制该模板创建最终生效的 `config.json` 文件：
@@ -117,11 +98,11 @@ pip3 install azure-cognitiveservices-speech
   cp config-template.json config.json
 ```
 
-然后在`config.json`中填入配置，以下是对默认配置的说明，可根据需要进行自定义修改：
+然后在`config.json`中填入配置，以下是对默认配置的说明，可根据需要进行自定义修改（请去掉注释）：
 
 ```bash
 # config.json文件内容示例
-{ 
+{
   "open_ai_api_key": "YOUR API KEY",                          # 填入上面创建的 OpenAI API KEY
   "model": "gpt-3.5-turbo",                                   # 模型名称。当use_azure_chatgpt为true时，其名称为Azure上model deployment名称
   "proxy": "127.0.0.1:7890",                                  # 代理客户端的ip和端口
@@ -129,13 +110,15 @@ pip3 install azure-cognitiveservices-speech
   "single_chat_reply_prefix": "[bot] ",                       # 私聊时自动回复的前缀，用于区分真人
   "group_chat_prefix": ["@bot"],                              # 群聊时包含该前缀则会触发机器人回复
   "group_name_white_list": ["ChatGPT测试群", "ChatGPT测试群2"], # 开启自动回复的群名称列表
-  "group_chat_in_one_session": ["ChatGPT测试群"],              # 支持会话上下文共享的群名称       
+  "group_chat_in_one_session": ["ChatGPT测试群"],              # 支持会话上下文共享的群名称  
   "image_create_prefix": ["画", "看", "找"],                   # 开启图片回复的前缀
   "conversation_max_tokens": 1000,                            # 支持上下文记忆的最多字符数
   "speech_recognition": false,                                # 是否开启语音识别
   "group_speech_recognition": false,                          # 是否开启群组语音识别
   "use_azure_chatgpt": false,                                 # 是否使用Azure ChatGPT service代替openai ChatGPT service. 当设置为true时需要设置 open_ai_api_base，如 https://xxx.openai.azure.com/
-  "character_desc": "你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。",  # 人格描述,
+  "character_desc": "你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。",  # 人格描述
+  # 订阅消息，公众号和企业微信channel中请填写，当被订阅时会自动回复，可使用特殊占位符。目前支持的占位符有{trigger_prefix}，在程序中它会自动替换成bot的触发词。
+  "subscribe_msg": "感谢您的关注！\n这里是ChatGPT，可以自由对话。\n支持语音对话。\n支持图片输出，画字开头的消息将按要求创作图片。\n支持角色扮演和文字冒险等丰富插件。\n输入{trigger_prefix}#help 查看详细指令。"
 }
 ```
 **配置说明：**
@@ -161,7 +144,7 @@ pip3 install azure-cognitiveservices-speech
 **4.其他配置**
 
 + `model`: 模型名称，目前支持 `gpt-3.5-turbo`, `text-davinci-003`, `gpt-4`, `gpt-4-32k`  (其中gpt-4 api暂未开放)
-+ `temperature`,`frequency_penalty`,`presence_penalty`: Chat API接口参数，详情参考[OpenAI官方文档。](https://platform.openai.com/docs/api-reference/chat) 
++ `temperature`,`frequency_penalty`,`presence_penalty`: Chat API接口参数，详情参考[OpenAI官方文档。](https://platform.openai.com/docs/api-reference/chat)
 + `proxy`：由于目前 `openai` 接口国内无法访问，需配置代理客户端的地址，详情参考  [#351](https://github.com/zhayujie/chatgpt-on-wechat/issues/351)
 + 对于图像生成，在满足个人或群组触发条件外，还需要额外的关键词前缀来触发，对应配置 `image_create_prefix `
 + 关于OpenAI对话及图片接口的参数配置（内容自由度、回复字数限制、图片大小等），可以参考 [对话接口](https://beta.openai.com/docs/api-reference/completions) 和 [图像接口](https://beta.openai.com/docs/api-reference/completions)  文档直接在 [代码](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/bot/openai/open_ai_bot.py) `bot/openai/open_ai_bot.py` 中进行调整。
@@ -170,6 +153,7 @@ pip3 install azure-cognitiveservices-speech
 + `clear_memory_commands`: 对话内指令，主动清空前文记忆，字符串数组可自定义指令别名。
 + `hot_reload`: 程序退出后，暂存微信扫码状态，默认关闭。
 + `character_desc` 配置中保存着你对机器人说的一段话，他会记住这段话并作为他的设定，你可以为他定制任何人格      (关于会话上下文的更多内容参考该 [issue](https://github.com/zhayujie/chatgpt-on-wechat/issues/43))
++ `subscribe_msg`：订阅消息，公众号和企业微信channel中请填写，当被订阅时会自动回复， 可使用特殊占位符。目前支持的占位符有{trigger_prefix}，在程序中它会自动替换成bot的触发词。
 
 **所有可选的配置项均在该[文件](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py)中列出。**
 
@@ -182,7 +166,7 @@ pip3 install azure-cognitiveservices-speech
 ```bash
 python3 app.py
 ```
-终端输出二维码后，使用微信进行扫码，当输出 "Start auto replying" 时表示自动回复程序已经成功运行了（注意：用于登录的微信需要在支付处已完成实名认证）。扫码登录后你的账号就成为机器人了，可以在微信手机端通过配置的关键词触发自动回复 (任意好友发送消息给你，或是自己发消息给好友)，参考[#142](https://github.com/zhayujie/chatgpt-on-wechat/issues/142)。 
+终端输出二维码后，使用微信进行扫码，当输出 "Start auto replying" 时表示自动回复程序已经成功运行了（注意：用于登录的微信需要在支付处已完成实名认证）。扫码登录后你的账号就成为机器人了，可以在微信手机端通过配置的关键词触发自动回复 (任意好友发送消息给你，或是自己发消息给好友)，参考[#142](https://github.com/zhayujie/chatgpt-on-wechat/issues/142)。
 
 
 ### 2.服务器部署
@@ -190,7 +174,7 @@ python3 app.py
 使用nohup命令在后台运行程序：
 
 ```bash
-touch nohup.out                                   # 首次运行需要新建日志文件                     
+touch nohup.out                                   # 首次运行需要新建日志文件  
 nohup python3 app.py & tail -f nohup.out          # 在后台运行程序并通过日志输出二维码
 ```
 扫码登录后程序即可运行于服务器后台，此时可通过 `ctrl+c` 关闭日志，不会影响后台程序的运行。使用 `ps -ef | grep app.py | grep -v grep` 命令可查看运行于后台的进程，如果想要重新启动程序可以先 `kill` 掉对应的进程。日志关闭后如果想要再次打开只需输入 `tail -f nohup.out`。此外，`scripts` 目录下有一键运行、关闭程序的脚本供使用。
@@ -204,7 +188,7 @@ nohup python3 app.py & tail -f nohup.out          # 在后台运行程序并通
 
 参考文档 [Docker部署](https://github.com/limccn/chatgpt-on-wechat/wiki/Docker%E9%83%A8%E7%BD%B2)   (Contributed by [limccn](https://github.com/limccn))。
 
-### 4. Railway部署(✅推荐)
+### 4. Railway部署 (✅推荐)
 > Railway每月提供5刀和最多500小时的免费额度。
 1. 进入 [Railway](https://railway.app/template/qApznZ?referralCode=RC3znh)。
 2. 点击 `Deploy Now` 按钮。
@@ -217,6 +201,6 @@ FAQs： <https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs>
 
 ## 联系
 
-欢迎提交PR、Issues，以及Star支持一下。程序运行遇到问题优先查看 [常见问题列表](https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs) ，其次前往 [Issues](https://github.com/zhayujie/chatgpt-on-wechat/issues) 中搜索，若无相似问题可创建Issue，或加微信 eijuyahz 交流。
+欢迎提交PR、Issues，以及Star支持一下。程序运行遇到问题优先查看 [常见问题列表](https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs) ，其次前往 [Issues](https://github.com/zhayujie/chatgpt-on-wechat/issues) 中搜索。如果你想了解更多项目细节，并与开发者们交流更多关于AI技术的实践，欢迎加入星球:
 
- 
+<a href="https://public.zsxq.com/groups/88885848842852.html"><img width="360" src="./docs/images/planet.jpg"></a>

app.py

@@ -1,21 +1,28 @@
 # encoding:utf-8
 
 import os
-from config import conf, load_config
-from channel import channel_factory
-from common.log import logger
-from plugins import *
 import signal
 import sys
 
+from channel import channel_factory
+from common.log import logger
+from config import conf, load_config
+from plugins import *
+
+
 def sigterm_handler_wrap(_signo):
     old_handler = signal.getsignal(_signo)
+
     def func(_signo, _stack_frame):
         logger.info("signal {} received, exiting...".format(_signo))
         conf().save_user_datas()
-        return old_handler(_signo, _stack_frame)
+        if callable(old_handler):  #  check old_handler
+            return old_handler(_signo, _stack_frame)
+        sys.exit(0)
+
     signal.signal(_signo, func)
 
+
 def run():
     try:
         # load config
@@ -26,17 +33,17 @@ def run():
         sigterm_handler_wrap(signal.SIGTERM)
 
         # create channel
-        channel_name=conf().get('channel_type', 'wx')
+        channel_name = conf().get("channel_type", "wx")
 
         if "--cmd" in sys.argv:
-            channel_name = 'terminal'
+            channel_name = "terminal"
 
-        if channel_name == 'wxy':
-            os.environ['WECHATY_LOG']="warn"
+        if channel_name == "wxy":
+            os.environ["WECHATY_LOG"] = "warn"
             # os.environ['WECHATY_PUPPET_SERVICE_ENDPOINT'] = '127.0.0.1:9001'
 
         channel = channel_factory.create_channel(channel_name)
-        if channel_name in ['wx','wxy','wechatmp','terminal']:
+        if channel_name in ["wx", "wxy", "terminal", "wechatmp", "wechatmp_service", "wechatcom_app"]:
             PluginManager().load_plugins()
 
         # startup channel
@@ -45,5 +52,6 @@ def run():
         logger.error("App startup failed!")
         logger.exception(e)
 
-if __name__ == '__main__':
-    run()
+
+if __name__ == "__main__":
+    run()

bot/baidu/baidu_unit_bot.py

@@ -1,6 +1,7 @@
 # encoding:utf-8
 
 import requests
+
 from bot.bot import Bot
 from bridge.reply import Reply, ReplyType
 
@@ -9,20 +10,27 @@ from bridge.reply import Reply, ReplyType
 class BaiduUnitBot(Bot):
     def reply(self, query, context=None):
         token = self.get_token()
-        url = 'https://aip.baidubce.com/rpc/2.0/unit/service/v3/chat?access_token=' + token
-        post_data = "{\"version\":\"3.0\",\"service_id\":\"S73177\",\"session_id\":\"\",\"log_id\":\"7758521\",\"skill_ids\":[\"1221886\"],\"request\":{\"terminal_id\":\"88888\",\"query\":\"" + query + "\", \"hyper_params\": {\"chat_custom_bot_profile\": 1}}}"
+        url = "https://aip.baidubce.com/rpc/2.0/unit/service/v3/chat?access_token=" + token
+        post_data = (
+            '{"version":"3.0","service_id":"S73177","session_id":"","log_id":"7758521","skill_ids":["1221886"],"request":{"terminal_id":"88888","query":"'
+            + query
+            + '", "hyper_params": {"chat_custom_bot_profile": 1}}}'
+        )
         print(post_data)
-        headers = {'content-type': 'application/x-www-form-urlencoded'}
+        headers = {"content-type": "application/x-www-form-urlencoded"}
         response = requests.post(url, data=post_data.encode(), headers=headers)
         if response:
-            reply = Reply(ReplyType.TEXT, response.json()['result']['context']['SYS_PRESUMED_HIST'][1])
+            reply = Reply(
+                ReplyType.TEXT,
+                response.json()["result"]["context"]["SYS_PRESUMED_HIST"][1],
+            )
             return reply
 
     def get_token(self):
-        access_key = 'YOUR_ACCESS_KEY'
-        secret_key = 'YOUR_SECRET_KEY'
-        host = 'https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=' + access_key + '&client_secret=' + secret_key
+        access_key = "YOUR_ACCESS_KEY"
+        secret_key = "YOUR_SECRET_KEY"
+        host = "https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=" + access_key + "&client_secret=" + secret_key
         response = requests.get(host)
         if response:
             print(response.json())
-            return response.json()['access_token']
+            return response.json()["access_token"]

bot/bot.py

@@ -8,7 +8,7 @@ from bridge.reply import Reply
 
 
 class Bot(object):
-    def reply(self, query, context : Context =None) -> Reply:
+    def reply(self, query, context: Context = None) -> Reply:
         """
         bot auto-reply content
         :param req: received message

bot/bot_factory.py

@@ -13,20 +13,24 @@ def create_bot(bot_type):
     if bot_type == const.BAIDU:
         # Baidu Unit对话接口
         from bot.baidu.baidu_unit_bot import BaiduUnitBot
+
         return BaiduUnitBot()
 
     elif bot_type == const.CHATGPT:
         # ChatGPT 网页端web接口
         from bot.chatgpt.chat_gpt_bot import ChatGPTBot
+
         return ChatGPTBot()
 
     elif bot_type == const.OPEN_AI:
         # OpenAI 官方对话模型API
         from bot.openai.open_ai_bot import OpenAIBot
+
         return OpenAIBot()
 
     elif bot_type == const.CHATGPTONAZURE:
         # Azure chatgpt service https://azure.microsoft.com/en-in/products/cognitive-services/openai-service/
         from bot.chatgpt.chat_gpt_bot import AzureChatGPTBot
+
         return AzureChatGPTBot()
     raise RuntimeError

bot/chatgpt/chat_gpt_bot.py

@@ -1,73 +1,92 @@
 # encoding:utf-8
 
+import time
+
+import openai
+import openai.error
+import requests
+
 from bot.bot import Bot
 from bot.chatgpt.chat_gpt_session import ChatGPTSession
 from bot.openai.open_ai_image import OpenAIImage
-from bot.session_manager import Session, SessionManager
+from bot.session_manager import SessionManager
 from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
-from config import conf, load_config
 from common.log import logger
 from common.token_bucket import TokenBucket
-from common.expired_dict import ExpiredDict
-import openai
-import openai.error
-import time
+from config import conf, load_config
+
 
 # OpenAI对话模型API (可用)
-class ChatGPTBot(Bot,OpenAIImage):
+class ChatGPTBot(Bot, OpenAIImage):
     def __init__(self):
         super().__init__()
         # set the default api_key
-        openai.api_key = conf().get('open_ai_api_key')
-        if conf().get('open_ai_api_base'):
-            openai.api_base = conf().get('open_ai_api_base')
-        proxy = conf().get('proxy')
+        openai.api_key = conf().get("open_ai_api_key")
+        if conf().get("open_ai_api_base"):
+            openai.api_base = conf().get("open_ai_api_base")
+        proxy = conf().get("proxy")
         if proxy:
             openai.proxy = proxy
-        if conf().get('rate_limit_chatgpt'):
-            self.tb4chatgpt = TokenBucket(conf().get('rate_limit_chatgpt', 20))
-        
-        self.sessions = SessionManager(ChatGPTSession, model= conf().get("model") or "gpt-3.5-turbo")
+        if conf().get("rate_limit_chatgpt"):
+            self.tb4chatgpt = TokenBucket(conf().get("rate_limit_chatgpt", 20))
+
+        self.sessions = SessionManager(ChatGPTSession, model=conf().get("model") or "gpt-3.5-turbo")
+        self.args = {
+            "model": conf().get("model") or "gpt-3.5-turbo",  # 对话模型的名称
+            "temperature": conf().get("temperature", 0.9),  # 值在[0,1]之间，越大表示回复越具有不确定性
+            # "max_tokens":4096,  # 回复最大的字符数
+            "top_p": 1,
+            "frequency_penalty": conf().get("frequency_penalty", 0.0),  # [-2,2]之间，该值越大则更倾向于产生不同的内容
+            "presence_penalty": conf().get("presence_penalty", 0.0),  # [-2,2]之间，该值越大则更倾向于产生不同的内容
+            "request_timeout": conf().get("request_timeout", None),  # 请求超时时间，openai接口默认设置为600，对于难问题一般需要较长时间
+            "timeout": conf().get("request_timeout", None),  # 重试超时时间，在这个时间内，将会自动重试
+        }
 
     def reply(self, query, context=None):
         # acquire reply content
         if context.type == ContextType.TEXT:
             logger.info("[CHATGPT] query={}".format(query))
 
-
-            session_id = context['session_id']
+            session_id = context["session_id"]
             reply = None
-            clear_memory_commands = conf().get('clear_memory_commands', ['#清除记忆'])
+            clear_memory_commands = conf().get("clear_memory_commands", ["#清除记忆"])
             if query in clear_memory_commands:
                 self.sessions.clear_session(session_id)
-                reply = Reply(ReplyType.INFO, '记忆已清除')
-            elif query == '#清除所有':
+                reply = Reply(ReplyType.INFO, "记忆已清除")
+            elif query == "#清除所有":
                 self.sessions.clear_all_session()
-                reply = Reply(ReplyType.INFO, '所有人记忆已清除')
-            elif query == '#更新配置':
+                reply = Reply(ReplyType.INFO, "所有人记忆已清除")
+            elif query == "#更新配置":
                 load_config()
-                reply = Reply(ReplyType.INFO, '配置已更新')
+                reply = Reply(ReplyType.INFO, "配置已更新")
             if reply:
                 return reply
             session = self.sessions.session_query(query, session_id)
             logger.debug("[CHATGPT] session query={}".format(session.messages))
 
-            api_key = context.get('openai_api_key')
+            api_key = context.get("openai_api_key")
 
             # if context.get('stream'):
             #     # reply in stream
             #     return self.reply_text_stream(query, new_query, session_id)
 
-            reply_content = self.reply_text(session, session_id, api_key, 0)
-            logger.debug("[CHATGPT] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(session.messages, session_id, reply_content["content"], reply_content["completion_tokens"]))
-            if reply_content['completion_tokens'] == 0 and len(reply_content['content']) > 0:
-                reply = Reply(ReplyType.ERROR, reply_content['content'])
+            reply_content = self.reply_text(session, api_key)
+            logger.debug(
+                "[CHATGPT] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(
+                    session.messages,
+                    session_id,
+                    reply_content["content"],
+                    reply_content["completion_tokens"],
+                )
+            )
+            if reply_content["completion_tokens"] == 0 and len(reply_content["content"]) > 0:
+                reply = Reply(ReplyType.ERROR, reply_content["content"])
             elif reply_content["completion_tokens"] > 0:
                 self.sessions.session_reply(reply_content["content"], session_id, reply_content["total_tokens"])
                 reply = Reply(ReplyType.TEXT, reply_content["content"])
             else:
-                reply = Reply(ReplyType.ERROR, reply_content['content'])
+                reply = Reply(ReplyType.ERROR, reply_content["content"])
                 logger.debug("[CHATGPT] reply {} used 0 tokens.".format(reply_content))
             return reply
 
@@ -80,65 +99,53 @@ class ChatGPTBot(Bot,OpenAIImage):
                 reply = Reply(ReplyType.ERROR, retstring)
             return reply
         else:
-            reply = Reply(ReplyType.ERROR, 'Bot不支持处理{}类型的消息'.format(context.type))
+            reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))
             return reply
 
-    def compose_args(self):
-        return {
-            "model": conf().get("model") or "gpt-3.5-turbo",  # 对话模型的名称
-            "temperature":conf().get('temperature', 0.9),  # 值在[0,1]之间，越大表示回复越具有不确定性
-            # "max_tokens":4096,  # 回复最大的字符数
-            "top_p":1,
-            "frequency_penalty":conf().get('frequency_penalty', 0.0),  # [-2,2]之间，该值越大则更倾向于产生不同的内容
-            "presence_penalty":conf().get('presence_penalty', 0.0),  # [-2,2]之间，该值越大则更倾向于产生不同的内容
-            "request_timeout": conf().get('request_timeout', 60),  # 请求超时时间，openai接口默认设置为600，对于难问题一般需要较长时间
-            "timeout": conf().get('request_timeout', 120), #重试超时时间，在这个时间内，将会自动重试
-        }
-
-    def reply_text(self, session:ChatGPTSession, session_id, api_key, retry_count=0) -> dict:
-        '''
+    def reply_text(self, session: ChatGPTSession, api_key=None, retry_count=0) -> dict:
+        """
         call openai's ChatCompletion to get the answer
         :param session: a conversation session
         :param session_id: session id
         :param retry_count: retry count
         :return: {}
-        '''
+        """
         try:
-            if conf().get('rate_limit_chatgpt') and not self.tb4chatgpt.get_token():
+            if conf().get("rate_limit_chatgpt") and not self.tb4chatgpt.get_token():
                 raise openai.error.RateLimitError("RateLimitError: rate limit exceeded")
             # if api_key == None, the default openai.api_key will be used
-            response = openai.ChatCompletion.create(
-                api_key=api_key, messages=session.messages, **self.compose_args()
-            )
+            response = openai.ChatCompletion.create(api_key=api_key, messages=session.messages, **self.args)
             # logger.info("[ChatGPT] reply={}, total_tokens={}".format(response.choices[0]['message']['content'], response["usage"]["total_tokens"]))
-            return {"total_tokens": response["usage"]["total_tokens"],
-                    "completion_tokens": response["usage"]["completion_tokens"],
-                    "content": response.choices[0]['message']['content']}
+            return {
+                "total_tokens": response["usage"]["total_tokens"],
+                "completion_tokens": response["usage"]["completion_tokens"],
+                "content": response.choices[0]["message"]["content"],
+            }
         except Exception as e:
             need_retry = retry_count < 2
             result = {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}
             if isinstance(e, openai.error.RateLimitError):
                 logger.warn("[CHATGPT] RateLimitError: {}".format(e))
-                result['content'] = "提问太快啦，请休息一下再问我吧"
+                result["content"] = "提问太快啦，请休息一下再问我吧"
                 if need_retry:
-                    time.sleep(5)
+                    time.sleep(20)
             elif isinstance(e, openai.error.Timeout):
                 logger.warn("[CHATGPT] Timeout: {}".format(e))
-                result['content'] = "我没有收到你的消息"
+                result["content"] = "我没有收到你的消息"
                 if need_retry:
                     time.sleep(5)
             elif isinstance(e, openai.error.APIConnectionError):
                 logger.warn("[CHATGPT] APIConnectionError: {}".format(e))
                 need_retry = False
-                result['content'] = "我连接不到你的网络"
+                result["content"] = "我连接不到你的网络"
             else:
                 logger.warn("[CHATGPT] Exception: {}".format(e))
                 need_retry = False
-                self.sessions.clear_session(session_id)
+                self.sessions.clear_session(session.session_id)
 
             if need_retry:
-                logger.warn("[CHATGPT] 第{}次重试".format(retry_count+1))
-                return self.reply_text(session, session_id, api_key, retry_count+1)
+                logger.warn("[CHATGPT] 第{}次重试".format(retry_count + 1))
+                return self.reply_text(session, api_key, retry_count + 1)
             else:
                 return result
 
@@ -148,9 +155,27 @@ class AzureChatGPTBot(ChatGPTBot):
         super().__init__()
         openai.api_type = "azure"
         openai.api_version = "2023-03-15-preview"
+        self.args["deployment_id"] = conf().get("azure_deployment_id")
 
-    def compose_args(self):
-        args = super().compose_args()
-        args["engine"] = args["model"]
-        del(args["model"])
-        return args
+    def create_img(self, query, retry_count=0, api_key=None):
+        api_version = "2022-08-03-preview"
+        url = "{}dalle/text-to-image?api-version={}".format(openai.api_base, api_version)
+        api_key = api_key or openai.api_key
+        headers = {"api-key": api_key, "Content-Type": "application/json"}
+        try:
+            body = {"caption": query, "resolution": conf().get("image_create_size", "256x256")}
+            submission = requests.post(url, headers=headers, json=body)
+            operation_location = submission.headers["Operation-Location"]
+            retry_after = submission.headers["Retry-after"]
+            status = ""
+            image_url = ""
+            while status != "Succeeded":
+                logger.info("waiting for image create..., " + status + ",retry after " + retry_after + " seconds")
+                time.sleep(int(retry_after))
+                response = requests.get(operation_location, headers=headers)
+                status = response.json()["status"]
+            image_url = response.json()["result"]["contentUrl"]
+            return True, image_url
+        except Exception as e:
+            logger.error("create image error: {}".format(e))
+            return False, "图片生成失败"

bot/chatgpt/chat_gpt_session.py

@@ -1,23 +1,26 @@
 from bot.session_manager import Session
 from common.log import logger
-'''
+
+"""
     e.g.  [
         {"role": "system", "content": "You are a helpful assistant."},
         {"role": "user", "content": "Who won the world series in 2020?"},
         {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
         {"role": "user", "content": "Where was it played?"}
     ]
-'''
+"""
+
+
 class ChatGPTSession(Session):
-    def __init__(self, session_id, system_prompt=None, model= "gpt-3.5-turbo"):
+    def __init__(self, session_id, system_prompt=None, model="gpt-3.5-turbo"):
         super().__init__(session_id, system_prompt)
         self.model = model
         self.reset()
-    
-    def discard_exceeding(self, max_tokens, cur_tokens= None):
+
+    def discard_exceeding(self, max_tokens, cur_tokens=None):
         precise = True
         try:
-            cur_tokens = num_tokens_from_messages(self.messages, self.model)
+            cur_tokens = self.calc_tokens()
         except Exception as e:
             precise = False
             if cur_tokens is None:
@@ -29,7 +32,7 @@ class ChatGPTSession(Session):
             elif len(self.messages) == 2 and self.messages[1]["role"] == "assistant":
                 self.messages.pop(1)
                 if precise:
-                    cur_tokens = num_tokens_from_messages(self.messages, self.model)
+                    cur_tokens = self.calc_tokens()
                 else:
                     cur_tokens = cur_tokens - max_tokens
                 break
@@ -40,22 +43,26 @@ class ChatGPTSession(Session):
                 logger.debug("max_tokens={}, total_tokens={}, len(messages)={}".format(max_tokens, cur_tokens, len(self.messages)))
                 break
             if precise:
-                cur_tokens = num_tokens_from_messages(self.messages, self.model)
+                cur_tokens = self.calc_tokens()
             else:
                 cur_tokens = cur_tokens - max_tokens
         return cur_tokens
-    
+
+    def calc_tokens(self):
+        return num_tokens_from_messages(self.messages, self.model)
+
 
 # refer to https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
 def num_tokens_from_messages(messages, model):
     """Returns the number of tokens used by a list of messages."""
     import tiktoken
+
     try:
         encoding = tiktoken.encoding_for_model(model)
     except KeyError:
         logger.debug("Warning: model not found. Using cl100k_base encoding.")
         encoding = tiktoken.get_encoding("cl100k_base")
-    if model == "gpt-3.5-turbo":
+    if model == "gpt-3.5-turbo" or model == "gpt-35-turbo":
         return num_tokens_from_messages(messages, model="gpt-3.5-turbo-0301")
     elif model == "gpt-4":
         return num_tokens_from_messages(messages, model="gpt-4-0314")
@@ -76,4 +83,4 @@ def num_tokens_from_messages(messages, model):
             if key == "name":
                 num_tokens += tokens_per_name
     num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
-    return num_tokens
+    return num_tokens

bot/openai/open_ai_bot.py

@@ -1,54 +1,72 @@
 # encoding:utf-8
 
+import time
+
+import openai
+import openai.error
+
 from bot.bot import Bot
 from bot.openai.open_ai_image import OpenAIImage
 from bot.openai.open_ai_session import OpenAISession
 from bot.session_manager import SessionManager
 from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
-from config import conf
 from common.log import logger
-import openai
-import openai.error
-import time
+from config import conf
 
 user_session = dict()
 
+
 # OpenAI对话模型API (可用)
 class OpenAIBot(Bot, OpenAIImage):
     def __init__(self):
         super().__init__()
-        openai.api_key = conf().get('open_ai_api_key')
-        if conf().get('open_ai_api_base'):
-            openai.api_base = conf().get('open_ai_api_base')
-        proxy = conf().get('proxy')
+        openai.api_key = conf().get("open_ai_api_key")
+        if conf().get("open_ai_api_base"):
+            openai.api_base = conf().get("open_ai_api_base")
+        proxy = conf().get("proxy")
         if proxy:
             openai.proxy = proxy
 
-        self.sessions = SessionManager(OpenAISession, model= conf().get("model") or "text-davinci-003")
+        self.sessions = SessionManager(OpenAISession, model=conf().get("model") or "text-davinci-003")
+        self.args = {
+            "model": conf().get("model") or "text-davinci-003",  # 对话模型的名称
+            "temperature": conf().get("temperature", 0.9),  # 值在[0,1]之间，越大表示回复越具有不确定性
+            "max_tokens": 1200,  # 回复最大的字符数
+            "top_p": 1,
+            "frequency_penalty": conf().get("frequency_penalty", 0.0),  # [-2,2]之间，该值越大则更倾向于产生不同的内容
+            "presence_penalty": conf().get("presence_penalty", 0.0),  # [-2,2]之间，该值越大则更倾向于产生不同的内容
+            "request_timeout": conf().get("request_timeout", None),  # 请求超时时间，openai接口默认设置为600，对于难问题一般需要较长时间
+            "timeout": conf().get("request_timeout", None),  # 重试超时时间，在这个时间内，将会自动重试
+            "stop": ["\n\n\n"],
+        }
 
     def reply(self, query, context=None):
         # acquire reply content
         if context and context.type:
             if context.type == ContextType.TEXT:
                 logger.info("[OPEN_AI] query={}".format(query))
-                session_id = context['session_id']
+                session_id = context["session_id"]
                 reply = None
-                if query == '#清除记忆':
+                if query == "#清除记忆":
                     self.sessions.clear_session(session_id)
-                    reply = Reply(ReplyType.INFO, '记忆已清除')
-                elif query == '#清除所有':
+                    reply = Reply(ReplyType.INFO, "记忆已清除")
+                elif query == "#清除所有":
                     self.sessions.clear_all_session()
-                    reply = Reply(ReplyType.INFO, '所有人记忆已清除')
+                    reply = Reply(ReplyType.INFO, "所有人记忆已清除")
                 else:
                     session = self.sessions.session_query(query, session_id)
-                    new_query = str(session)
-                    logger.debug("[OPEN_AI] session query={}".format(new_query))
+                    result = self.reply_text(session)
+                    total_tokens, completion_tokens, reply_content = (
+                        result["total_tokens"],
+                        result["completion_tokens"],
+                        result["content"],
+                    )
+                    logger.debug(
+                        "[OPEN_AI] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(str(session), session_id, reply_content, completion_tokens)
+                    )
 
-                    total_tokens, completion_tokens, reply_content = self.reply_text(new_query, session_id, 0)
-                    logger.debug("[OPEN_AI] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(new_query, session_id, reply_content, completion_tokens))
-
-                    if total_tokens == 0 :
+                    if total_tokens == 0:
                         reply = Reply(ReplyType.ERROR, reply_content)
                     else:
                         self.sessions.session_reply(reply_content, session_id, total_tokens)
@@ -63,47 +81,42 @@ class OpenAIBot(Bot, OpenAIImage):
                     reply = Reply(ReplyType.ERROR, retstring)
                 return reply
 
-    def reply_text(self, query, session_id, retry_count=0):
+    def reply_text(self, session: OpenAISession, retry_count=0):
         try:
-            response = openai.Completion.create(
-                model= conf().get("model") or "text-davinci-003",  # 对话模型的名称
-                prompt=query,
-                temperature=0.9,  # 值在[0,1]之间，越大表示回复越具有不确定性
-                max_tokens=1200,  # 回复最大的字符数
-                top_p=1,
-                frequency_penalty=0.0,  # [-2,2]之间，该值越大则更倾向于产生不同的内容
-                presence_penalty=0.0,  # [-2,2]之间，该值越大则更倾向于产生不同的内容
-                stop=["\n\n\n"]
-            )
-            res_content = response.choices[0]['text'].strip().replace('<|endoftext|>', '')
+            response = openai.Completion.create(prompt=str(session), **self.args)
+            res_content = response.choices[0]["text"].strip().replace("<|endoftext|>", "")
             total_tokens = response["usage"]["total_tokens"]
             completion_tokens = response["usage"]["completion_tokens"]
             logger.info("[OPEN_AI] reply={}".format(res_content))
-            return total_tokens, completion_tokens, res_content
+            return {
+                "total_tokens": total_tokens,
+                "completion_tokens": completion_tokens,
+                "content": res_content,
+            }
         except Exception as e:
             need_retry = retry_count < 2
-            result = [0,0,"我现在有点累了，等会再来吧"]
+            result = {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}
             if isinstance(e, openai.error.RateLimitError):
                 logger.warn("[OPEN_AI] RateLimitError: {}".format(e))
-                result[2] = "提问太快啦，请休息一下再问我吧"
+                result["content"] = "提问太快啦，请休息一下再问我吧"
                 if need_retry:
-                    time.sleep(5)
+                    time.sleep(20)
             elif isinstance(e, openai.error.Timeout):
                 logger.warn("[OPEN_AI] Timeout: {}".format(e))
-                result[2] = "我没有收到你的消息"
+                result["content"] = "我没有收到你的消息"
                 if need_retry:
                     time.sleep(5)
             elif isinstance(e, openai.error.APIConnectionError):
                 logger.warn("[OPEN_AI] APIConnectionError: {}".format(e))
                 need_retry = False
-                result[2] = "我连接不到你的网络"
+                result["content"] = "我连接不到你的网络"
             else:
                 logger.warn("[OPEN_AI] Exception: {}".format(e))
                 need_retry = False
-                self.sessions.clear_session(session_id)
+                self.sessions.clear_session(session.session_id)
 
             if need_retry:
-                logger.warn("[OPEN_AI] 第{}次重试".format(retry_count+1))
-                return self.reply_text(query, session_id, retry_count+1)
+                logger.warn("[OPEN_AI] 第{}次重试".format(retry_count + 1))
+                return self.reply_text(session, retry_count + 1)
             else:
-                return result
+                return result

bot/openai/open_ai_image.py

@@ -1,38 +1,42 @@
 import time
+
 import openai
 import openai.error
-from common.token_bucket import TokenBucket
+
 from common.log import logger
+from common.token_bucket import TokenBucket
 from config import conf
 
+
 # OPENAI提供的画图接口
 class OpenAIImage(object):
     def __init__(self):
-        openai.api_key = conf().get('open_ai_api_key')
-        if conf().get('rate_limit_dalle'):
-            self.tb4dalle = TokenBucket(conf().get('rate_limit_dalle', 50))
-            
-    def create_img(self, query, retry_count=0):
+        openai.api_key = conf().get("open_ai_api_key")
+        if conf().get("rate_limit_dalle"):
+            self.tb4dalle = TokenBucket(conf().get("rate_limit_dalle", 50))
+
+    def create_img(self, query, retry_count=0, api_key=None):
         try:
-            if conf().get('rate_limit_dalle') and not self.tb4dalle.get_token():
+            if conf().get("rate_limit_dalle") and not self.tb4dalle.get_token():
                 return False, "请求太快了，请休息一下再问我吧"
             logger.info("[OPEN_AI] image_query={}".format(query))
             response = openai.Image.create(
-                prompt=query,    #图片描述
-                n=1,             #每次生成图片的数量
-                size="256x256"   #图片大小,可选有 256x256, 512x512, 1024x1024
+                api_key=api_key,
+                prompt=query,  # 图片描述
+                n=1,  # 每次生成图片的数量
+                size=conf().get("image_create_size", "256x256"),  # 图片大小,可选有 256x256, 512x512, 1024x1024
             )
-            image_url = response['data'][0]['url']
+            image_url = response["data"][0]["url"]
             logger.info("[OPEN_AI] image_url={}".format(image_url))
             return True, image_url
         except openai.error.RateLimitError as e:
             logger.warn(e)
             if retry_count < 1:
                 time.sleep(5)
-                logger.warn("[OPEN_AI] ImgCreate RateLimit exceed, 第{}次重试".format(retry_count+1))
-                return self.create_img(query, retry_count+1)
+                logger.warn("[OPEN_AI] ImgCreate RateLimit exceed, 第{}次重试".format(retry_count + 1))
+                return self.create_img(query, retry_count + 1)
             else:
                 return False, "提问太快啦，请休息一下再问我吧"
         except Exception as e:
             logger.exception(e)
-            return False, str(e)
+            return False, str(e)

bot/openai/open_ai_session.py

@@ -1,35 +1,37 @@
 from bot.session_manager import Session
 from common.log import logger
+
+
 class OpenAISession(Session):
-    def __init__(self, session_id, system_prompt=None, model= "text-davinci-003"):
+    def __init__(self, session_id, system_prompt=None, model="text-davinci-003"):
         super().__init__(session_id, system_prompt)
         self.model = model
         self.reset()
 
     def __str__(self):
         # 构造对话模型的输入
-        '''
+        """
         e.g.  Q: xxx
               A: xxx
               Q: xxx
-        '''
+        """
         prompt = ""
         for item in self.messages:
-            if item['role'] == 'system':
-                prompt += item['content'] + "<|endoftext|>\n\n\n"
-            elif item['role'] == 'user':
-                prompt += "Q: " + item['content'] + "\n"
-            elif item['role'] == 'assistant':
-                prompt += "\n\nA: " + item['content'] + "<|endoftext|>\n"
+            if item["role"] == "system":
+                prompt += item["content"] + "<|endoftext|>\n\n\n"
+            elif item["role"] == "user":
+                prompt += "Q: " + item["content"] + "\n"
+            elif item["role"] == "assistant":
+                prompt += "\n\nA: " + item["content"] + "<|endoftext|>\n"
 
-        if len(self.messages) > 0 and self.messages[-1]['role'] == 'user':
+        if len(self.messages) > 0 and self.messages[-1]["role"] == "user":
             prompt += "A: "
         return prompt
 
-    def discard_exceeding(self, max_tokens, cur_tokens= None):
+    def discard_exceeding(self, max_tokens, cur_tokens=None):
         precise = True
         try:
-            cur_tokens = num_tokens_from_string(str(self), self.model)
+            cur_tokens = self.calc_tokens()
         except Exception as e:
             precise = False
             if cur_tokens is None:
@@ -41,7 +43,7 @@ class OpenAISession(Session):
             elif len(self.messages) == 1 and self.messages[0]["role"] == "assistant":
                 self.messages.pop(0)
                 if precise:
-                    cur_tokens = num_tokens_from_string(str(self), self.model)
+                    cur_tokens = self.calc_tokens()
                 else:
                     cur_tokens = len(str(self))
                 break
@@ -52,16 +54,20 @@ class OpenAISession(Session):
                 logger.debug("max_tokens={}, total_tokens={}, len(conversation)={}".format(max_tokens, cur_tokens, len(self.messages)))
                 break
             if precise:
-                cur_tokens = num_tokens_from_string(str(self), self.model)
+                cur_tokens = self.calc_tokens()
             else:
                 cur_tokens = len(str(self))
         return cur_tokens
-    
+
+    def calc_tokens(self):
+        return num_tokens_from_string(str(self), self.model)
+
 
 # refer to https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
 def num_tokens_from_string(string: str, model: str) -> int:
     """Returns the number of tokens in a text string."""
     import tiktoken
+
     encoding = tiktoken.encoding_for_model(model)
-    num_tokens = len(encoding.encode(string,disallowed_special=()))
-    return num_tokens
+    num_tokens = len(encoding.encode(string, disallowed_special=()))
+    return num_tokens

bot/session_manager.py

@@ -2,6 +2,7 @@ from common.expired_dict import ExpiredDict
 from common.log import logger
 from config import conf
 
+
 class Session(object):
     def __init__(self, session_id, system_prompt=None):
         self.session_id = session_id
@@ -13,7 +14,7 @@ class Session(object):
 
     # 重置会话
     def reset(self):
-        system_item = {'role': 'system', 'content': self.system_prompt}
+        system_item = {"role": "system", "content": self.system_prompt}
         self.messages = [system_item]
 
     def set_system_prompt(self, system_prompt):
@@ -21,22 +22,24 @@ class Session(object):
         self.reset()
 
     def add_query(self, query):
-        user_item = {'role': 'user', 'content': query}
+        user_item = {"role": "user", "content": query}
         self.messages.append(user_item)
 
     def add_reply(self, reply):
-        assistant_item = {'role': 'assistant', 'content': reply}
+        assistant_item = {"role": "assistant", "content": reply}
         self.messages.append(assistant_item)
-    
+
     def discard_exceeding(self, max_tokens=None, cur_tokens=None):
         raise NotImplementedError
 
+    def calc_tokens(self):
+        raise NotImplementedError
 
 
 class SessionManager(object):
     def __init__(self, sessioncls, **session_args):
-        if conf().get('expires_in_seconds'):
-            sessions = ExpiredDict(conf().get('expires_in_seconds'))
+        if conf().get("expires_in_seconds"):
+            sessions = ExpiredDict(conf().get("expires_in_seconds"))
         else:
             sessions = dict()
         self.sessions = sessions
@@ -44,17 +47,20 @@ class SessionManager(object):
         self.session_args = session_args
 
     def build_session(self, session_id, system_prompt=None):
-        '''
-            如果session_id不在sessions中，创建一个新的session并添加到sessions中
-            如果system_prompt不会空，会更新session的system_prompt并重置session
-        '''
+        """
+        如果session_id不在sessions中，创建一个新的session并添加到sessions中
+        如果system_prompt不会空，会更新session的system_prompt并重置session
+        """
+        if session_id is None:
+            return self.sessioncls(session_id, system_prompt, **self.session_args)
+
         if session_id not in self.sessions:
             self.sessions[session_id] = self.sessioncls(session_id, system_prompt, **self.session_args)
         elif system_prompt is not None:  # 如果有新的system_prompt，更新并重置session
             self.sessions[session_id].set_system_prompt(system_prompt)
         session = self.sessions[session_id]
         return session
-    
+
     def session_query(self, query, session_id):
         session = self.build_session(session_id)
         session.add_query(query)
@@ -66,7 +72,7 @@ class SessionManager(object):
             logger.debug("Exception when counting tokens precisely for prompt: {}".format(str(e)))
         return session
 
-    def session_reply(self, reply, session_id, total_tokens = None):
+    def session_reply(self, reply, session_id, total_tokens=None):
         session = self.build_session(session_id)
         session.add_reply(reply)
         try:
@@ -79,7 +85,7 @@ class SessionManager(object):
 
     def clear_session(self, session_id):
         if session_id in self.sessions:
-            del(self.sessions[session_id])
+            del self.sessions[session_id]
 
     def clear_all_session(self):
         self.sessions.clear()

bridge/bridge.py

@@ -1,50 +1,54 @@
+from bot.bot_factory import create_bot
 from bridge.context import Context
 from bridge.reply import Reply
-from common.log import logger
-from bot import bot_factory
-from common.singleton import singleton
-from voice import voice_factory
-from config import conf
 from common import const
+from common.log import logger
+from common.singleton import singleton
+from config import conf
+from translate.factory import create_translator
+from voice.factory import create_voice
 
 
 @singleton
 class Bridge(object):
     def __init__(self):
-        self.btype={
+        self.btype = {
             "chat": const.CHATGPT,
             "voice_to_text": conf().get("voice_to_text", "openai"),
-            "text_to_voice": conf().get("text_to_voice", "google")
+            "text_to_voice": conf().get("text_to_voice", "google"),
+            "translate": conf().get("translate", "baidu"),
         }
         model_type = conf().get("model")
         if model_type in ["text-davinci-003"]:
-            self.btype['chat'] = const.OPEN_AI
-        if conf().get("use_azure_chatgpt"):
-            self.btype['chat'] = const.CHATGPTONAZURE
-        self.bots={}
+            self.btype["chat"] = const.OPEN_AI
+        if conf().get("use_azure_chatgpt", False):
+            self.btype["chat"] = const.CHATGPTONAZURE
+        self.bots = {}
 
-    def get_bot(self,typename):
+    def get_bot(self, typename):
         if self.bots.get(typename) is None:
-            logger.info("create bot {} for {}".format(self.btype[typename],typename))
+            logger.info("create bot {} for {}".format(self.btype[typename], typename))
             if typename == "text_to_voice":
-                self.bots[typename] = voice_factory.create_voice(self.btype[typename])
+                self.bots[typename] = create_voice(self.btype[typename])
             elif typename == "voice_to_text":
-                self.bots[typename] = voice_factory.create_voice(self.btype[typename])
+                self.bots[typename] = create_voice(self.btype[typename])
             elif typename == "chat":
-                self.bots[typename] = bot_factory.create_bot(self.btype[typename])
+                self.bots[typename] = create_bot(self.btype[typename])
+            elif typename == "translate":
+                self.bots[typename] = create_translator(self.btype[typename])
         return self.bots[typename]
-    
-    def get_bot_type(self,typename):
+
+    def get_bot_type(self, typename):
         return self.btype[typename]
 
-
-    def fetch_reply_content(self, query, context : Context) -> Reply:
+    def fetch_reply_content(self, query, context: Context) -> Reply:
         return self.get_bot("chat").reply(query, context)
 
-
     def fetch_voice_to_text(self, voiceFile) -> Reply:
         return self.get_bot("voice_to_text").voiceToText(voiceFile)
 
     def fetch_text_to_voice(self, text) -> Reply:
         return self.get_bot("text_to_voice").textToVoice(text)
 
+    def fetch_translate(self, text, from_lang="", to_lang="en") -> Reply:
+        return self.get_bot("translate").translate(text, from_lang, to_lang)

bridge/context.py

@@ -2,35 +2,41 @@
 
 from enum import Enum
 
-class ContextType (Enum):
-    TEXT = 1         # 文本消息
-    VOICE = 2        # 音频消息
-    IMAGE_CREATE = 3 # 创建图片命令
-    
+
+class ContextType(Enum):
+    TEXT = 1  # 文本消息
+    VOICE = 2  # 音频消息
+    IMAGE = 3  # 图片消息
+    IMAGE_CREATE = 10  # 创建图片命令
+    JOIN_GROUP = 20  # 加入群聊
+    PATPAT = 21  # 拍了拍
+
     def __str__(self):
         return self.name
+
+
 class Context:
-    def __init__(self, type : ContextType = None , content = None,  kwargs = dict()):
+    def __init__(self, type: ContextType = None, content=None, kwargs=dict()):
         self.type = type
         self.content = content
         self.kwargs = kwargs
 
     def __contains__(self, key):
-        if key == 'type':
+        if key == "type":
             return self.type is not None
-        elif key == 'content':
+        elif key == "content":
             return self.content is not None
         else:
             return key in self.kwargs
-        
+
     def __getitem__(self, key):
-        if key == 'type':
+        if key == "type":
             return self.type
-        elif key == 'content':
+        elif key == "content":
             return self.content
         else:
             return self.kwargs[key]
-    
+
     def get(self, key, default=None):
         try:
             return self[key]
@@ -38,20 +44,20 @@ class Context:
             return default
 
     def __setitem__(self, key, value):
-        if key == 'type':
+        if key == "type":
             self.type = value
-        elif key == 'content':
+        elif key == "content":
             self.content = value
         else:
             self.kwargs[key] = value
 
     def __delitem__(self, key):
-        if key == 'type':
+        if key == "type":
             self.type = None
-        elif key == 'content':
+        elif key == "content":
             self.content = None
         else:
             del self.kwargs[key]
-    
+
     def __str__(self):
-        return "Context(type={}, content={}, kwargs={})".format(self.type, self.content, self.kwargs)
+        return "Context(type={}, content={}, kwargs={})".format(self.type, self.content, self.kwargs)

bridge/reply.py

@@ -1,22 +1,25 @@
-
 # encoding:utf-8
 
 from enum import Enum
 
+
 class ReplyType(Enum):
-    TEXT = 1        # 文本
-    VOICE = 2       # 音频文件
-    IMAGE = 3       # 图片文件
-    IMAGE_URL = 4   # 图片URL
-    
+    TEXT = 1  # 文本
+    VOICE = 2  # 音频文件
+    IMAGE = 3  # 图片文件
+    IMAGE_URL = 4  # 图片URL
+
     INFO = 9
     ERROR = 10
+
     def __str__(self):
         return self.name
 
+
 class Reply:
-    def __init__(self, type : ReplyType = None , content = None):
+    def __init__(self, type: ReplyType = None, content=None):
         self.type = type
         self.content = content
+
     def __str__(self):
-        return "Reply(type={}, content={})".format(self.type, self.content)
+        return "Reply(type={}, content={})".format(self.type, self.content)

channel/channel.py

@@ -6,8 +6,10 @@ from bridge.bridge import Bridge
 from bridge.context import Context
 from bridge.reply import *
 
+
 class Channel(object):
     NOT_SUPPORT_REPLYTYPE = [ReplyType.VOICE, ReplyType.IMAGE]
+
     def startup(self):
         """
         init channel
@@ -27,15 +29,15 @@ class Channel(object):
         send message to user
         :param msg: message content
         :param receiver: receiver channel account
-        :return: 
+        :return:
         """
         raise NotImplementedError
 
-    def build_reply_content(self, query, context : Context=None) -> Reply:
+    def build_reply_content(self, query, context: Context = None) -> Reply:
         return Bridge().fetch_reply_content(query, context)
 
     def build_voice_to_text(self, voice_file) -> Reply:
         return Bridge().fetch_voice_to_text(voice_file)
-    
+
     def build_text_to_voice(self, text) -> Reply:
         return Bridge().fetch_text_to_voice(text)

channel/channel_factory.py

@@ -2,22 +2,35 @@
 channel factory
 """
 
+
 def create_channel(channel_type):
     """
     create a channel instance
     :param channel_type: channel type code
     :return: channel instance
     """
-    if channel_type == 'wx':
+    if channel_type == "wx":
         from channel.wechat.wechat_channel import WechatChannel
+
         return WechatChannel()
-    elif channel_type == 'wxy':
+    elif channel_type == "wxy":
         from channel.wechat.wechaty_channel import WechatyChannel
+
         return WechatyChannel()
-    elif channel_type == 'terminal':
+    elif channel_type == "terminal":
         from channel.terminal.terminal_channel import TerminalChannel
+
         return TerminalChannel()
-    elif channel_type == 'wechatmp':
+    elif channel_type == "wechatmp":
         from channel.wechatmp.wechatmp_channel import WechatMPChannel
-        return WechatMPChannel()
+
+        return WechatMPChannel(passive_reply=True)
+    elif channel_type == "wechatmp_service":
+        from channel.wechatmp.wechatmp_channel import WechatMPChannel
+
+        return WechatMPChannel(passive_reply=False)
+    elif channel_type == "wechatcom_app":
+        from channel.wechatcom.wechatcomapp_channel import WechatComAppChannel
+
+        return WechatComAppChannel()
     raise RuntimeError

channel/chat_channel.py

@@ -1,133 +1,150 @@
-
-
-from asyncio import CancelledError
-from concurrent.futures import Future, ThreadPoolExecutor
 import os
 import re
 import threading
 import time
-from common.dequeue import Dequeue
-from channel.channel import Channel
-from bridge.reply import *
+from asyncio import CancelledError
+from concurrent.futures import Future, ThreadPoolExecutor
+
 from bridge.context import *
-from config import conf
+from bridge.reply import *
+from channel.channel import Channel
+from common.dequeue import Dequeue
 from common.log import logger
+from config import conf
 from plugins import *
+
 try:
     from voice.audio_convert import any_to_wav
 except Exception as e:
     pass
 
+
 # 抽象类, 它包含了与消息通道无关的通用处理逻辑
 class ChatChannel(Channel):
-    name = None # 登录的用户名
-    user_id = None # 登录的用户id
-    futures = {} # 记录每个session_id提交到线程池的future对象, 用于重置会话时把没执行的future取消掉，正在执行的不会被取消
-    sessions = {} # 用于控制并发，每个session_id同时只能有一个context在处理
-    lock = threading.Lock() # 用于控制对sessions的访问
+    name = None  # 登录的用户名
+    user_id = None  # 登录的用户id
+    futures = {}  # 记录每个session_id提交到线程池的future对象, 用于重置会话时把没执行的future取消掉，正在执行的不会被取消
+    sessions = {}  # 用于控制并发，每个session_id同时只能有一个context在处理
+    lock = threading.Lock()  # 用于控制对sessions的访问
     handler_pool = ThreadPoolExecutor(max_workers=8)  # 处理消息的线程池
 
     def __init__(self):
         _thread = threading.Thread(target=self.consume)
         _thread.setDaemon(True)
         _thread.start()
-        
 
     # 根据消息构造context，消息内容相关的触发项写在这里
     def _compose_context(self, ctype: ContextType, content, **kwargs):
         context = Context(ctype, content)
         context.kwargs = kwargs
-        # context首次传入时，origin_ctype是None, 
+        # context首次传入时，origin_ctype是None,
         # 引入的起因是：当输入语音时，会嵌套生成两个context，第一步语音转文本，第二步通过文本生成文字回复。
         # origin_ctype用于第二步文本回复时，判断是否需要匹配前缀，如果是私聊的语音，就不需要匹配前缀
-        if 'origin_ctype' not in context:  
-            context['origin_ctype'] = ctype
+        if "origin_ctype" not in context:
+            context["origin_ctype"] = ctype
         # context首次传入时，receiver是None，根据类型设置receiver
-        first_in = 'receiver' not in context
+        first_in = "receiver" not in context
         # 群名匹配过程，设置session_id和receiver
-        if first_in: # context首次传入时，receiver是None，根据类型设置receiver
+        if first_in:  # context首次传入时，receiver是None，根据类型设置receiver
             config = conf()
-            cmsg = context['msg']
-            if cmsg.from_user_id == self.user_id and not config.get('trigger_by_self', True):
-                logger.debug("[WX]self message skipped")
-                return None
+            cmsg = context["msg"]
+            user_data = conf().get_user_data(cmsg.from_user_id)
+            context["openai_api_key"] = user_data.get("openai_api_key")
             if context.get("isgroup", False):
                 group_name = cmsg.other_user_nickname
                 group_id = cmsg.other_user_id
 
-                group_name_white_list = config.get('group_name_white_list', [])
-                group_name_keyword_white_list = config.get('group_name_keyword_white_list', [])
-                if any([group_name in group_name_white_list, 'ALL_GROUP' in group_name_white_list, check_contain(group_name, group_name_keyword_white_list)]):
-                    group_chat_in_one_session = conf().get('group_chat_in_one_session', [])
+                group_name_white_list = config.get("group_name_white_list", [])
+                group_name_keyword_white_list = config.get("group_name_keyword_white_list", [])
+                if any(
+                    [
+                        group_name in group_name_white_list,
+                        "ALL_GROUP" in group_name_white_list,
+                        check_contain(group_name, group_name_keyword_white_list),
+                    ]
+                ):
+                    group_chat_in_one_session = conf().get("group_chat_in_one_session", [])
                     session_id = cmsg.actual_user_id
-                    if any([group_name in group_chat_in_one_session, 'ALL_GROUP' in group_chat_in_one_session]):
+                    if any(
+                        [
+                            group_name in group_chat_in_one_session,
+                            "ALL_GROUP" in group_chat_in_one_session,
+                        ]
+                    ):
                         session_id = group_id
                 else:
                     return None
-                context['session_id'] = session_id
-                context['receiver'] = group_id
+                context["session_id"] = session_id
+                context["receiver"] = group_id
             else:
-                context['session_id'] = cmsg.other_user_id
-                context['receiver'] = cmsg.other_user_id
+                context["session_id"] = cmsg.other_user_id
+                context["receiver"] = cmsg.other_user_id
+            e_context = PluginManager().emit_event(EventContext(Event.ON_RECEIVE_MESSAGE, {"channel": self, "context": context}))
+            context = e_context["context"]
+            if e_context.is_pass() or context is None:
+                return context
+            if cmsg.from_user_id == self.user_id and not config.get("trigger_by_self", True):
+                logger.debug("[WX]self message skipped")
+                return None
 
         # 消息内容匹配过程，并处理content
         if ctype == ContextType.TEXT:
-            if first_in and "」\n- - - - - - -" in content: # 初次匹配 过滤引用消息
+            if first_in and "」\n- - - - - - -" in content:  # 初次匹配 过滤引用消息
                 logger.debug("[WX]reference query skipped")
                 return None
-            
-            if context.get("isgroup", False): # 群聊
+
+            if context.get("isgroup", False):  # 群聊
                 # 校验关键字
-                match_prefix = check_prefix(content, conf().get('group_chat_prefix'))
-                match_contain = check_contain(content, conf().get('group_chat_keyword'))
+                match_prefix = check_prefix(content, conf().get("group_chat_prefix"))
+                match_contain = check_contain(content, conf().get("group_chat_keyword"))
                 flag = False
                 if match_prefix is not None or match_contain is not None:
                     flag = True
                     if match_prefix:
-                        content = content.replace(match_prefix, '', 1).strip()
-                if context['msg'].is_at:
+                        content = content.replace(match_prefix, "", 1).strip()
+                if context["msg"].is_at:
                     logger.info("[WX]receive group at")
                     if not conf().get("group_at_off", False):
                         flag = True
-                    pattern = f'@{self.name}(\u2005|\u0020)'
-                    content = re.sub(pattern, r'', content)
-                
+                    pattern = f"@{re.escape(self.name)}(\u2005|\u0020)"
+                    content = re.sub(pattern, r"", content)
+
                 if not flag:
                     if context["origin_ctype"] == ContextType.VOICE:
                         logger.info("[WX]receive group voice, but checkprefix didn't match")
                     return None
-            else: # 单聊
-                match_prefix = check_prefix(content, conf().get('single_chat_prefix',['']))
-                if match_prefix is not None: # 判断如果匹配到自定义前缀，则返回过滤掉前缀+空格后的内容
-                    content = content.replace(match_prefix, '', 1).strip()
-                elif context["origin_ctype"] == ContextType.VOICE: # 如果源消息是私聊的语音消息，允许不匹配前缀，放宽条件
+            else:  # 单聊
+                match_prefix = check_prefix(content, conf().get("single_chat_prefix", [""]))
+                if match_prefix is not None:  # 判断如果匹配到自定义前缀，则返回过滤掉前缀+空格后的内容
+                    content = content.replace(match_prefix, "", 1).strip()
+                elif context["origin_ctype"] == ContextType.VOICE:  # 如果源消息是私聊的语音消息，允许不匹配前缀，放宽条件
                     pass
                 else:
-                    return None     
-                                                  
-            img_match_prefix = check_prefix(content, conf().get('image_create_prefix'))
+                    return None
+            content = content.strip()
+            img_match_prefix = check_prefix(content, conf().get("image_create_prefix"))
             if img_match_prefix:
-                content = content.replace(img_match_prefix, '', 1).strip()
+                content = content.replace(img_match_prefix, "", 1)
                 context.type = ContextType.IMAGE_CREATE
             else:
                 context.type = ContextType.TEXT
-            context.content = content
-            if 'desire_rtype' not in context and conf().get('always_reply_voice') and ReplyType.VOICE not in self.NOT_SUPPORT_REPLYTYPE:
-                context['desire_rtype'] = ReplyType.VOICE
-        elif context.type == ContextType.VOICE: 
-            if 'desire_rtype' not in context and conf().get('voice_reply_voice') and ReplyType.VOICE not in self.NOT_SUPPORT_REPLYTYPE:
-                context['desire_rtype'] = ReplyType.VOICE
+            context.content = content.strip()
+            if "desire_rtype" not in context and conf().get("always_reply_voice") and ReplyType.VOICE not in self.NOT_SUPPORT_REPLYTYPE:
+                context["desire_rtype"] = ReplyType.VOICE
+        elif context.type == ContextType.VOICE:
+            if "desire_rtype" not in context and conf().get("voice_reply_voice") and ReplyType.VOICE not in self.NOT_SUPPORT_REPLYTYPE:
+                context["desire_rtype"] = ReplyType.VOICE
 
         return context
 
     def _handle(self, context: Context):
         if context is None or not context.content:
             return
-        logger.debug('[WX] ready to handle context: {}'.format(context))
+        logger.debug("[WX] ready to handle context: {}".format(context))
         # reply的构建步骤
         reply = self._generate_reply(context)
 
-        logger.debug('[WX] ready to decorate reply: {}'.format(reply))
+        logger.debug("[WX] ready to decorate reply: {}".format(reply))
         # reply的包装步骤
         reply = self._decorate_reply(context, reply)
 
@@ -135,20 +152,24 @@ class ChatChannel(Channel):
         self._send_reply(context, reply)
 
     def _generate_reply(self, context: Context, reply: Reply = Reply()) -> Reply:
-        e_context = PluginManager().emit_event(EventContext(Event.ON_HANDLE_CONTEXT, {
-            'channel': self, 'context': context, 'reply': reply}))
-        reply = e_context['reply']
+        e_context = PluginManager().emit_event(
+            EventContext(
+                Event.ON_HANDLE_CONTEXT,
+                {"channel": self, "context": context, "reply": reply},
+            )
+        )
+        reply = e_context["reply"]
         if not e_context.is_pass():
-            logger.debug('[WX] ready to handle context: type={}, content={}'.format(context.type, context.content))
+            logger.debug("[WX] ready to handle context: type={}, content={}".format(context.type, context.content))
             if context.type == ContextType.TEXT or context.type == ContextType.IMAGE_CREATE:  # 文字和图片消息
                 reply = super().build_reply_content(context.content, context)
             elif context.type == ContextType.VOICE:  # 语音消息
-                cmsg = context['msg']
+                cmsg = context["msg"]
                 cmsg.prepare()
                 file_path = context.content
-                wav_path = os.path.splitext(file_path)[0] + '.wav'
+                wav_path = os.path.splitext(file_path)[0] + ".wav"
                 try:
-                    any_to_wav(file_path, wav_path) 
+                    any_to_wav(file_path, wav_path)
                 except Exception as e:  # 转换失败，直接使用mp3，对于某些api，mp3也可以识别
                     logger.warning("[WX]any to wav error, use raw path. " + str(e))
                     wav_path = file_path
@@ -164,25 +185,29 @@ class ChatChannel(Channel):
                     # logger.warning("[WX]delete temp file error: " + str(e))
 
                 if reply.type == ReplyType.TEXT:
-                    new_context = self._compose_context(
-                        ContextType.TEXT, reply.content, **context.kwargs)
+                    new_context = self._compose_context(ContextType.TEXT, reply.content, **context.kwargs)
                     if new_context:
                         reply = self._generate_reply(new_context)
                     else:
                         return
+            elif context.type == ContextType.IMAGE:  # 图片消息，当前无默认逻辑
+                pass
             else:
-                logger.error('[WX] unknown context type: {}'.format(context.type))
+                logger.error("[WX] unknown context type: {}".format(context.type))
                 return
         return reply
 
     def _decorate_reply(self, context: Context, reply: Reply) -> Reply:
         if reply and reply.type:
-            e_context = PluginManager().emit_event(EventContext(Event.ON_DECORATE_REPLY, {
-                'channel': self, 'context': context, 'reply': reply}))
-            reply = e_context['reply']
-            desire_rtype = context.get('desire_rtype')
+            e_context = PluginManager().emit_event(
+                EventContext(
+                    Event.ON_DECORATE_REPLY,
+                    {"channel": self, "context": context, "reply": reply},
+                )
+            )
+            reply = e_context["reply"]
+            desire_rtype = context.get("desire_rtype")
             if not e_context.is_pass() and reply and reply.type:
-                
                 if reply.type in self.NOT_SUPPORT_REPLYTYPE:
                     logger.error("[WX]reply type not support: " + str(reply.type))
                     reply.type = ReplyType.ERROR
@@ -194,67 +219,80 @@ class ChatChannel(Channel):
                         reply = super().build_text_to_voice(reply.content)
                         return self._decorate_reply(context, reply)
                     if context.get("isgroup", False):
-                        reply_text = '@' +  context['msg'].actual_user_nickname + ' ' + reply_text.strip()
+                        reply_text = "@" + context["msg"].actual_user_nickname + " " + reply_text.strip()
                         reply_text = conf().get("group_chat_reply_prefix", "") + reply_text
                     else:
                         reply_text = conf().get("single_chat_reply_prefix", "") + reply_text
                     reply.content = reply_text
                 elif reply.type == ReplyType.ERROR or reply.type == ReplyType.INFO:
-                    reply.content = "["+str(reply.type)+"]\n" + reply.content
+                    reply.content = "[" + str(reply.type) + "]\n" + reply.content
                 elif reply.type == ReplyType.IMAGE_URL or reply.type == ReplyType.VOICE or reply.type == ReplyType.IMAGE:
                     pass
                 else:
-                    logger.error('[WX] unknown reply type: {}'.format(reply.type))
+                    logger.error("[WX] unknown reply type: {}".format(reply.type))
                     return
             if desire_rtype and desire_rtype != reply.type and reply.type not in [ReplyType.ERROR, ReplyType.INFO]:
-                logger.warning('[WX] desire_rtype: {}, but reply type: {}'.format(context.get('desire_rtype'), reply.type))
+                logger.warning("[WX] desire_rtype: {}, but reply type: {}".format(context.get("desire_rtype"), reply.type))
             return reply
 
     def _send_reply(self, context: Context, reply: Reply):
         if reply and reply.type:
-            e_context = PluginManager().emit_event(EventContext(Event.ON_SEND_REPLY, {
-                'channel': self, 'context': context, 'reply': reply}))
-            reply = e_context['reply']
+            e_context = PluginManager().emit_event(
+                EventContext(
+                    Event.ON_SEND_REPLY,
+                    {"channel": self, "context": context, "reply": reply},
+                )
+            )
+            reply = e_context["reply"]
             if not e_context.is_pass() and reply and reply.type:
-                logger.debug('[WX] ready to send reply: {}, context: {}'.format(reply, context))
+                logger.debug("[WX] ready to send reply: {}, context: {}".format(reply, context))
                 self._send(reply, context)
 
-    def _send(self, reply: Reply, context: Context, retry_cnt = 0):
+    def _send(self, reply: Reply, context: Context, retry_cnt=0):
         try:
             self.send(reply, context)
         except Exception as e:
-            logger.error('[WX] sendMsg error: {}'.format(str(e)))
+            logger.error("[WX] sendMsg error: {}".format(str(e)))
             if isinstance(e, NotImplementedError):
                 return
             logger.exception(e)
             if retry_cnt < 2:
-                time.sleep(3+3*retry_cnt)
-                self._send(reply, context, retry_cnt+1)
+                time.sleep(3 + 3 * retry_cnt)
+                self._send(reply, context, retry_cnt + 1)
 
-    def _fail_callback(self, session_id, exception, **kwargs): # 线程异常结束时的回调函数
+    def _success_callback(self, session_id, **kwargs):  # 线程正常结束时的回调函数
+        logger.debug("Worker return success, session_id = {}".format(session_id))
+
+    def _fail_callback(self, session_id, exception, **kwargs):  # 线程异常结束时的回调函数
         logger.exception("Worker return exception: {}".format(exception))
 
     def _thread_pool_callback(self, session_id, **kwargs):
-        def func(worker:Future):
+        def func(worker: Future):
             try:
                 worker_exception = worker.exception()
                 if worker_exception:
-                    self._fail_callback(session_id, exception = worker_exception, **kwargs)
+                    self._fail_callback(session_id, exception=worker_exception, **kwargs)
+                else:
+                    self._success_callback(session_id, **kwargs)
             except CancelledError as e:
                 logger.info("Worker cancelled, session_id = {}".format(session_id))
             except Exception as e:
                 logger.exception("Worker raise exception: {}".format(e))
             with self.lock:
                 self.sessions[session_id][1].release()
+
         return func
 
     def produce(self, context: Context):
-        session_id = context['session_id']
+        session_id = context["session_id"]
         with self.lock:
             if session_id not in self.sessions:
-                self.sessions[session_id] = [Dequeue(), threading.BoundedSemaphore(conf().get("concurrency_in_session", 4))]
-            if context.type == ContextType.TEXT and context.content.startswith("#"): 
-                self.sessions[session_id][0].putleft(context) # 优先处理管理命令
+                self.sessions[session_id] = [
+                    Dequeue(),
+                    threading.BoundedSemaphore(conf().get("concurrency_in_session", 4)),
+                ]
+            if context.type == ContextType.TEXT and context.content.startswith("#"):
+                self.sessions[session_id][0].putleft(context)  # 优先处理管理命令
             else:
                 self.sessions[session_id][0].put(context)
 
@@ -265,16 +303,16 @@ class ChatChannel(Channel):
                 session_ids = list(self.sessions.keys())
                 for session_id in session_ids:
                     context_queue, semaphore = self.sessions[session_id]
-                    if semaphore.acquire(blocking = False): # 等线程处理完毕才能删除
+                    if semaphore.acquire(blocking=False):  # 等线程处理完毕才能删除
                         if not context_queue.empty():
                             context = context_queue.get()
                             logger.debug("[WX] consume context: {}".format(context))
-                            future:Future = self.handler_pool.submit(self._handle, context)
-                            future.add_done_callback(self._thread_pool_callback(session_id, context = context))
+                            future: Future = self.handler_pool.submit(self._handle, context)
+                            future.add_done_callback(self._thread_pool_callback(session_id, context=context))
                             if session_id not in self.futures:
                                 self.futures[session_id] = []
                             self.futures[session_id].append(future)
-                        elif semaphore._initial_value == semaphore._value+1: # 除了当前，没有任务再申请到信号量，说明所有任务都处理完毕
+                        elif semaphore._initial_value == semaphore._value + 1:  # 除了当前，没有任务再申请到信号量，说明所有任务都处理完毕
                             self.futures[session_id] = [t for t in self.futures[session_id] if not t.done()]
                             assert len(self.futures[session_id]) == 0, "thread pool error"
                             del self.sessions[session_id]
@@ -283,26 +321,26 @@ class ChatChannel(Channel):
             time.sleep(0.1)
 
     # 取消session_id对应的所有任务，只能取消排队的消息和已提交线程池但未执行的任务
-    def cancel_session(self, session_id): 
+    def cancel_session(self, session_id):
         with self.lock:
             if session_id in self.sessions:
                 for future in self.futures[session_id]:
                     future.cancel()
                 cnt = self.sessions[session_id][0].qsize()
-                if cnt>0:
+                if cnt > 0:
                     logger.info("Cancel {} messages in session {}".format(cnt, session_id))
                 self.sessions[session_id][0] = Dequeue()
-    
+
     def cancel_all_session(self):
         with self.lock:
             for session_id in self.sessions:
                 for future in self.futures[session_id]:
                     future.cancel()
                 cnt = self.sessions[session_id][0].qsize()
-                if cnt>0:
+                if cnt > 0:
                     logger.info("Cancel {} messages in session {}".format(cnt, session_id))
                 self.sessions[session_id][0] = Dequeue()
-    
+
 
 def check_prefix(content, prefix_list):
     if not prefix_list:
@@ -312,6 +350,7 @@ def check_prefix(content, prefix_list):
             return prefix
     return None
 
+
 def check_contain(content, keyword_list):
     if not keyword_list:
         return None

channel/chat_message.py

@@ -1,5 +1,4 @@
-
-""" 
+"""
 本类表示聊天消息，用于对itchat和wechaty的消息进行统一的封装。
 
 填好必填项(群聊6个，非群聊8个)，即可接入ChatChannel，并支持插件，参考TerminalChannel
@@ -20,7 +19,7 @@ other_user_id: 对方的id，如果你是发送者，那这个就是接收者id
 other_user_nickname: 同上
 
 is_group: 是否是群消息 (群聊必填)
-is_at: 是否被at 
+is_at: 是否被at
 
 - (群消息时，一般会存在实际发送者，是群内某个成员的id和昵称，下列项仅在群消息时存在)
 actual_user_id: 实际发送者id (群聊必填)
@@ -34,20 +33,22 @@ _prepared: 是否已经调用过准备函数
 _rawmsg: 原始消息对象
 
 """
+
+
 class ChatMessage(object):
     msg_id = None
     create_time = None
-    
+
     ctype = None
     content = None
-    
+
     from_user_id = None
     from_user_nickname = None
     to_user_id = None
     to_user_nickname = None
     other_user_id = None
     other_user_nickname = None
-    
+
     is_group = False
     is_at = False
     actual_user_id = None
@@ -57,8 +58,7 @@ class ChatMessage(object):
     _prepared = False
     _rawmsg = None
 
-
-    def __init__(self,_rawmsg):
+    def __init__(self, _rawmsg):
         self._rawmsg = _rawmsg
 
     def prepare(self):
@@ -67,7 +67,7 @@ class ChatMessage(object):
             self._prepare_fn()
 
     def __str__(self):
-        return 'ChatMessage: id={}, create_time={}, ctype={}, content={}, from_user_id={}, from_user_nickname={}, to_user_id={}, to_user_nickname={}, other_user_id={}, other_user_nickname={}, is_group={}, is_at={}, actual_user_id={}, actual_user_nickname={}'.format(
+        return "ChatMessage: id={}, create_time={}, ctype={}, content={}, from_user_id={}, from_user_nickname={}, to_user_id={}, to_user_nickname={}, other_user_id={}, other_user_nickname={}, is_group={}, is_at={}, actual_user_id={}, actual_user_nickname={}".format(
             self.msg_id,
             self.create_time,
             self.ctype,
@@ -82,4 +82,4 @@ class ChatMessage(object):
             self.is_at,
             self.actual_user_id,
             self.actual_user_nickname,
-        )
+        )

channel/terminal/terminal_channel.py

@@ -1,14 +1,23 @@
+import sys
+
 from bridge.context import *
 from bridge.reply import Reply, ReplyType
 from channel.chat_channel import ChatChannel, check_prefix
 from channel.chat_message import ChatMessage
-import sys
-
-from config import conf
 from common.log import logger
+from config import conf
+
 
 class TerminalMessage(ChatMessage):
-    def __init__(self, msg_id, content, ctype = ContextType.TEXT,  from_user_id = "User", to_user_id = "Chatgpt", other_user_id = "Chatgpt"):
+    def __init__(
+        self,
+        msg_id,
+        content,
+        ctype=ContextType.TEXT,
+        from_user_id="User",
+        to_user_id="Chatgpt",
+        other_user_id="Chatgpt",
+    ):
         self.msg_id = msg_id
         self.ctype = ctype
         self.content = content
@@ -16,6 +25,7 @@ class TerminalMessage(ChatMessage):
         self.to_user_id = to_user_id
         self.other_user_id = other_user_id
 
+
 class TerminalChannel(ChatChannel):
     NOT_SUPPORT_REPLYTYPE = [ReplyType.VOICE]
 
@@ -23,14 +33,18 @@ class TerminalChannel(ChatChannel):
         print("\nBot:")
         if reply.type == ReplyType.IMAGE:
             from PIL import Image
+
             image_storage = reply.content
             image_storage.seek(0)
             img = Image.open(image_storage)
             print("<IMAGE>")
             img.show()
-        elif reply.type == ReplyType.IMAGE_URL: # 从网络下载图片
+        elif reply.type == ReplyType.IMAGE_URL:  # 从网络下载图片
+            import io
+
+            import requests
             from PIL import Image
-            import requests,io
+
             img_url = reply.content
             pic_res = requests.get(img_url, stream=True)
             image_storage = io.BytesIO()
@@ -59,11 +73,11 @@ class TerminalChannel(ChatChannel):
                 print("\nExiting...")
                 sys.exit()
             msg_id += 1
-            trigger_prefixs = conf().get("single_chat_prefix",[""])
+            trigger_prefixs = conf().get("single_chat_prefix", [""])
             if check_prefix(prompt, trigger_prefixs) is None:
-                prompt = trigger_prefixs[0] + prompt # 给没触发的消息加上触发前缀
-                
-            context = self._compose_context(ContextType.TEXT, prompt, msg = TerminalMessage(msg_id, prompt))
+                prompt = trigger_prefixs[0] + prompt  # 给没触发的消息加上触发前缀
+
+            context = self._compose_context(ContextType.TEXT, prompt, msg=TerminalMessage(msg_id, prompt))
             if context:
                 self.produce(context)
             else:

channel/wechat/wechat_channel.py

@@ -4,44 +4,49 @@
 wechat channel
 """
 
+import io
+import json
 import os
 import threading
-import requests
-import io
 import time
-import json
+
+import requests
+
+from bridge.context import *
+from bridge.reply import *
 from channel.chat_channel import ChatChannel
 from channel.wechat.wechat_message import *
-from common.singleton import singleton
+from common.expired_dict import ExpiredDict
 from common.log import logger
+from common.singleton import singleton
+from common.time_check import time_checker
+from config import conf, get_appdata_dir
 from lib import itchat
 from lib.itchat.content import *
-from bridge.reply import *
-from bridge.context import *
-from config import conf
-from common.time_check import time_checker
-from common.expired_dict import ExpiredDict
 from plugins import *
 
-@itchat.msg_register(TEXT)
+
+@itchat.msg_register([TEXT, VOICE, PICTURE, NOTE])
 def handler_single_msg(msg):
-    WechatChannel().handle_text(WeChatMessage(msg))
+    try:
+        cmsg = WechatMessage(msg, False)
+    except NotImplementedError as e:
+        logger.debug("[WX]single message {} skipped: {}".format(msg["MsgId"], e))
+        return None
+    WechatChannel().handle_single(cmsg)
     return None
 
-@itchat.msg_register(TEXT, isGroupChat=True)
+
+@itchat.msg_register([TEXT, VOICE, PICTURE, NOTE], isGroupChat=True)
 def handler_group_msg(msg):
-    WechatChannel().handle_group(WeChatMessage(msg,True))
+    try:
+        cmsg = WechatMessage(msg, True)
+    except NotImplementedError as e:
+        logger.debug("[WX]group message {} skipped: {}".format(msg["MsgId"], e))
+        return None
+    WechatChannel().handle_group(cmsg)
     return None
 
-@itchat.msg_register(VOICE)
-def handler_single_voice(msg):
-    WechatChannel().handle_voice(WeChatMessage(msg))
-    return None
-    
-@itchat.msg_register(VOICE, isGroupChat=True)
-def handler_group_voice(msg):
-    WechatChannel().handle_group_voice(WeChatMessage(msg,True))
-    return None
 
 def _check(func):
     def wrapper(self, cmsg: ChatMessage):
@@ -50,21 +55,24 @@ def _check(func):
             logger.info("Wechat message {} already received, ignore".format(msgId))
             return
         self.receivedMsgs[msgId] = cmsg
-        create_time = cmsg.create_time            # 消息时间戳
-        if conf().get('hot_reload') == True and int(create_time) < int(time.time()) - 60:  # 跳过1分钟前的历史消息
+        create_time = cmsg.create_time  # 消息时间戳
+        if conf().get("hot_reload") == True and int(create_time) < int(time.time()) - 60:  # 跳过1分钟前的历史消息
             logger.debug("[WX]history message {} skipped".format(msgId))
             return
         return func(self, cmsg)
+
     return wrapper
 
-#可用的二维码生成接口
-#https://api.qrserver.com/v1/create-qr-code/?size=400×400&data=https://www.abc.com
-#https://api.isoyu.com/qr/?m=1&e=L&p=20&url=https://www.abc.com
-def qrCallback(uuid,status,qrcode):
+
+# 可用的二维码生成接口
+# https://api.qrserver.com/v1/create-qr-code/?size=400×400&data=https://www.abc.com
+# https://api.isoyu.com/qr/?m=1&e=L&p=20&url=https://www.abc.com
+def qrCallback(uuid, status, qrcode):
     # logger.debug("qrCallback: {} {}".format(uuid,status))
-    if status == '0':
+    if status == "0":
         try:
             from PIL import Image
+
             img = Image.open(io.BytesIO(qrcode))
             _thread = threading.Thread(target=img.show, args=("QRCode",))
             _thread.setDaemon(True)
@@ -73,52 +81,51 @@ def qrCallback(uuid,status,qrcode):
             pass
 
         import qrcode
+
         url = f"https://login.weixin.qq.com/l/{uuid}"
-        
-        qr_api1="https://api.isoyu.com/qr/?m=1&e=L&p=20&url={}".format(url)
-        qr_api2="https://api.qrserver.com/v1/create-qr-code/?size=400×400&data={}".format(url)
-        qr_api3="https://api.pwmqr.com/qrcode/create/?url={}".format(url)
-        qr_api4="https://my.tv.sohu.com/user/a/wvideo/getQRCode.do?text={}".format(url)
+
+        qr_api1 = "https://api.isoyu.com/qr/?m=1&e=L&p=20&url={}".format(url)
+        qr_api2 = "https://api.qrserver.com/v1/create-qr-code/?size=400×400&data={}".format(url)
+        qr_api3 = "https://api.pwmqr.com/qrcode/create/?url={}".format(url)
+        qr_api4 = "https://my.tv.sohu.com/user/a/wvideo/getQRCode.do?text={}".format(url)
         print("You can also scan QRCode in any website below:")
         print(qr_api3)
         print(qr_api4)
         print(qr_api2)
         print(qr_api1)
-        
+
         qr = qrcode.QRCode(border=1)
         qr.add_data(url)
         qr.make(fit=True)
         qr.print_ascii(invert=True)
 
+
 @singleton
 class WechatChannel(ChatChannel):
     NOT_SUPPORT_REPLYTYPE = []
+
     def __init__(self):
         super().__init__()
-        self.receivedMsgs = ExpiredDict(60*60*24) 
+        self.receivedMsgs = ExpiredDict(60 * 60 * 24)
 
     def startup(self):
-
         itchat.instance.receivingRetryCount = 600  # 修改断线超时时间
         # login by scan QRCode
-        hotReload = conf().get('hot_reload', False)
-        try:
-            itchat.auto_login(enableCmdQR=2, hotReload=hotReload, qrCallback=qrCallback)
-        except Exception as e:
-            if hotReload:
-                logger.error("Hot reload failed, try to login without hot reload")
-                itchat.logout()
-                os.remove("itchat.pkl")
-                itchat.auto_login(enableCmdQR=2, hotReload=hotReload, qrCallback=qrCallback)
-            else:
-                raise e
+        hotReload = conf().get("hot_reload", False)
+        status_path = os.path.join(get_appdata_dir(), "itchat.pkl")
+        itchat.auto_login(
+            enableCmdQR=2,
+            hotReload=hotReload,
+            statusStorageDir=status_path,
+            qrCallback=qrCallback,
+        )
         self.user_id = itchat.instance.storageClass.userName
         self.name = itchat.instance.storageClass.nickName
         logger.info("Wechat login success, user_id: {}, nickname: {}".format(self.user_id, self.name))
         # start message listener
         itchat.run()
 
-    # handle_* 系列函数处理收到的消息后构造Context，然后传入_handle函数中处理Context和发送回复
+    # handle_* 系列函数处理收到的消息后构造Context，然后传入produce函数中处理Context和发送回复
     # Context包含了消息的所有信息，包括以下属性
     #   type 消息类型, 包括TEXT、VOICE、IMAGE_CREATE
     #   content 消息内容，如果是TEXT类型，content就是文本内容，如果是VOICE类型，content就是语音文件名，如果是IMAGE_CREATE类型，content就是图片生成命令
@@ -132,53 +139,56 @@ class WechatChannel(ChatChannel):
 
     @time_checker
     @_check
-    def handle_voice(self, cmsg : ChatMessage):
-        if conf().get('speech_recognition') != True:
-            return
-        logger.debug("[WX]receive voice msg: {}".format(cmsg.content))
-        context = self._compose_context(ContextType.VOICE, cmsg.content, isgroup=False, msg=cmsg)
+    def handle_single(self, cmsg: ChatMessage):
+        if cmsg.ctype == ContextType.VOICE:
+            if conf().get("speech_recognition") != True:
+                return
+            logger.debug("[WX]receive voice msg: {}".format(cmsg.content))
+        elif cmsg.ctype == ContextType.IMAGE:
+            logger.debug("[WX]receive image msg: {}".format(cmsg.content))
+        elif cmsg.ctype == ContextType.PATPAT:
+            logger.debug("[WX]receive patpat msg: {}".format(cmsg.content))
+        elif cmsg.ctype == ContextType.TEXT:
+            logger.debug("[WX]receive text msg: {}, cmsg={}".format(json.dumps(cmsg._rawmsg, ensure_ascii=False), cmsg))
+        else:
+            logger.debug("[WX]receive msg: {}, cmsg={}".format(cmsg.content, cmsg))
+        context = self._compose_context(cmsg.ctype, cmsg.content, isgroup=False, msg=cmsg)
         if context:
             self.produce(context)
 
     @time_checker
     @_check
-    def handle_text(self, cmsg : ChatMessage):
-        logger.debug("[WX]receive text msg: {}, cmsg={}".format(json.dumps(cmsg._rawmsg, ensure_ascii=False), cmsg))
-        context = self._compose_context(ContextType.TEXT, cmsg.content, isgroup=False, msg=cmsg)
+    def handle_group(self, cmsg: ChatMessage):
+        if cmsg.ctype == ContextType.VOICE:
+            if conf().get("speech_recognition") != True:
+                return
+            logger.debug("[WX]receive voice for group msg: {}".format(cmsg.content))
+        elif cmsg.ctype == ContextType.IMAGE:
+            logger.debug("[WX]receive image for group msg: {}".format(cmsg.content))
+        elif cmsg.ctype in [ContextType.JOIN_GROUP, ContextType.PATPAT]:
+            logger.debug("[WX]receive note msg: {}".format(cmsg.content))
+        elif cmsg.ctype == ContextType.TEXT:
+            # logger.debug("[WX]receive group msg: {}, cmsg={}".format(json.dumps(cmsg._rawmsg, ensure_ascii=False), cmsg))
+            pass
+        else:
+            logger.debug("[WX]receive group msg: {}".format(cmsg.content))
+        context = self._compose_context(cmsg.ctype, cmsg.content, isgroup=True, msg=cmsg)
         if context:
             self.produce(context)
 
-    @time_checker
-    @_check
-    def handle_group(self, cmsg : ChatMessage):
-        logger.debug("[WX]receive group msg: {}, cmsg={}".format(json.dumps(cmsg._rawmsg, ensure_ascii=False), cmsg))
-        context = self._compose_context(ContextType.TEXT, cmsg.content, isgroup=True, msg=cmsg)
-        if context:
-            self.produce(context)
-    
-    @time_checker
-    @_check
-    def handle_group_voice(self, cmsg : ChatMessage):
-        if conf().get('group_speech_recognition', False) != True:
-            return
-        logger.debug("[WX]receive voice for group msg: {}".format(cmsg.content))
-        context = self._compose_context(ContextType.VOICE, cmsg.content, isgroup=True, msg=cmsg)
-        if context:
-            self.produce(context)
-    
     # 统一的发送函数，每个Channel自行实现，根据reply的type字段发送不同类型的消息
     def send(self, reply: Reply, context: Context):
         receiver = context["receiver"]
         if reply.type == ReplyType.TEXT:
             itchat.send(reply.content, toUserName=receiver)
-            logger.info('[WX] sendMsg={}, receiver={}'.format(reply, receiver))
+            logger.info("[WX] sendMsg={}, receiver={}".format(reply, receiver))
         elif reply.type == ReplyType.ERROR or reply.type == ReplyType.INFO:
             itchat.send(reply.content, toUserName=receiver)
-            logger.info('[WX] sendMsg={}, receiver={}'.format(reply, receiver))
+            logger.info("[WX] sendMsg={}, receiver={}".format(reply, receiver))
         elif reply.type == ReplyType.VOICE:
             itchat.send_file(reply.content, toUserName=receiver)
-            logger.info('[WX] sendFile={}, receiver={}'.format(reply.content, receiver))
-        elif reply.type == ReplyType.IMAGE_URL: # 从网络下载图片
+            logger.info("[WX] sendFile={}, receiver={}".format(reply.content, receiver))
+        elif reply.type == ReplyType.IMAGE_URL:  # 从网络下载图片
             img_url = reply.content
             pic_res = requests.get(img_url, stream=True)
             image_storage = io.BytesIO()
@@ -186,9 +196,9 @@ class WechatChannel(ChatChannel):
                 image_storage.write(block)
             image_storage.seek(0)
             itchat.send_image(image_storage, toUserName=receiver)
-            logger.info('[WX] sendImage url={}, receiver={}'.format(img_url,receiver))
-        elif reply.type == ReplyType.IMAGE: # 从文件读取图片
+            logger.info("[WX] sendImage url={}, receiver={}".format(img_url, receiver))
+        elif reply.type == ReplyType.IMAGE:  # 从文件读取图片
             image_storage = reply.content
             image_storage.seek(0)
             itchat.send_image(image_storage, toUserName=receiver)
-            logger.info('[WX] sendImage, receiver={}'.format(receiver))
+            logger.info("[WX] sendImage, receiver={}".format(receiver))

channel/wechat/wechat_message.py

@@ -1,50 +1,70 @@
-
+import re
 
 from bridge.context import ContextType
 from channel.chat_message import ChatMessage
-from common.tmp_dir import TmpDir
 from common.log import logger
-from lib.itchat.content import *
+from common.tmp_dir import TmpDir
 from lib import itchat
+from lib.itchat.content import *
 
-class WeChatMessage(ChatMessage):
 
+class WechatMessage(ChatMessage):
     def __init__(self, itchat_msg, is_group=False):
-        super().__init__( itchat_msg)
-        self.msg_id = itchat_msg['MsgId']
-        self.create_time = itchat_msg['CreateTime']
+        super().__init__(itchat_msg)
+        self.msg_id = itchat_msg["MsgId"]
+        self.create_time = itchat_msg["CreateTime"]
         self.is_group = is_group
-        
-        if itchat_msg['Type'] == TEXT:
+
+        if itchat_msg["Type"] == TEXT:
             self.ctype = ContextType.TEXT
-            self.content = itchat_msg['Text']
-        elif itchat_msg['Type'] == VOICE:
+            self.content = itchat_msg["Text"]
+        elif itchat_msg["Type"] == VOICE:
             self.ctype = ContextType.VOICE
-            self.content = TmpDir().path() + itchat_msg['FileName']  # content直接存临时目录路径
+            self.content = TmpDir().path() + itchat_msg["FileName"]  # content直接存临时目录路径
             self._prepare_fn = lambda: itchat_msg.download(self.content)
+        elif itchat_msg["Type"] == PICTURE and itchat_msg["MsgType"] == 3:
+            self.ctype = ContextType.IMAGE
+            self.content = TmpDir().path() + itchat_msg["FileName"]  # content直接存临时目录路径
+            self._prepare_fn = lambda: itchat_msg.download(self.content)
+        elif itchat_msg["Type"] == NOTE and itchat_msg["MsgType"] == 10000:
+            if is_group and ("加入群聊" in itchat_msg["Content"] or "加入了群聊" in itchat_msg["Content"]):
+                self.ctype = ContextType.JOIN_GROUP
+                self.content = itchat_msg["Content"]
+                # 这里只能得到nickname， actual_user_id还是机器人的id
+                if "加入了群聊" in itchat_msg["Content"]:
+                    self.actual_user_nickname = re.findall(r"\"(.*?)\"", itchat_msg["Content"])[-1]
+                elif "加入群聊" in itchat_msg["Content"]:
+                    self.actual_user_nickname = re.findall(r"\"(.*?)\"", itchat_msg["Content"])[0]
+            elif "拍了拍我" in itchat_msg["Content"]:
+                self.ctype = ContextType.PATPAT
+                self.content = itchat_msg["Content"]
+                if is_group:
+                    self.actual_user_nickname = re.findall(r"\"(.*?)\"", itchat_msg["Content"])[0]
+            else:
+                raise NotImplementedError("Unsupported note message: " + itchat_msg["Content"])
         else:
-            raise NotImplementedError("Unsupported message type: {}".format(itchat_msg['Type']))
-        
-        self.from_user_id = itchat_msg['FromUserName']
-        self.to_user_id = itchat_msg['ToUserName']
-        
+            raise NotImplementedError("Unsupported message type: Type:{} MsgType:{}".format(itchat_msg["Type"], itchat_msg["MsgType"]))
+
+        self.from_user_id = itchat_msg["FromUserName"]
+        self.to_user_id = itchat_msg["ToUserName"]
+
         user_id = itchat.instance.storageClass.userName
         nickname = itchat.instance.storageClass.nickName
-        
+
         # 虽然from_user_id和to_user_id用的少，但是为了保持一致性，还是要填充一下
         # 以下很繁琐，一句话总结：能填的都填了。
         if self.from_user_id == user_id:
             self.from_user_nickname = nickname
         if self.to_user_id == user_id:
             self.to_user_nickname = nickname
-        try: # 陌生人时候, 'User'字段可能不存在
-            self.other_user_id = itchat_msg['User']['UserName']
-            self.other_user_nickname = itchat_msg['User']['NickName']
+        try:  # 陌生人时候, 'User'字段可能不存在
+            self.other_user_id = itchat_msg["User"]["UserName"]
+            self.other_user_nickname = itchat_msg["User"]["NickName"]
             if self.other_user_id == self.from_user_id:
                 self.from_user_nickname = self.other_user_nickname
             if self.other_user_id == self.to_user_id:
                 self.to_user_nickname = self.other_user_nickname
-        except KeyError as e: # 处理偶尔没有对方信息的情况
+        except KeyError as e:  # 处理偶尔没有对方信息的情况
             logger.warn("[WX]get other_user_id failed: " + str(e))
             if self.from_user_id == user_id:
                 self.other_user_id = self.to_user_id
@@ -52,6 +72,7 @@ class WeChatMessage(ChatMessage):
                 self.other_user_id = self.from_user_id
 
         if self.is_group:
-            self.is_at = itchat_msg['IsAt']
-            self.actual_user_id = itchat_msg['ActualUserName']
-            self.actual_user_nickname = itchat_msg['ActualNickName']
+            self.is_at = itchat_msg["IsAt"]
+            self.actual_user_id = itchat_msg["ActualUserName"]
+            if self.ctype not in [ContextType.JOIN_GROUP, ContextType.PATPAT]:
+                self.actual_user_nickname = itchat_msg["ActualNickName"]

channel/wechat/wechaty_channel.py

@@ -4,104 +4,108 @@
 wechaty channel
 Python Wechaty - https://github.com/wechaty/python-wechaty
 """
+import asyncio
 import base64
 import os
 import time
-import asyncio
-from bridge.context import Context
-from wechaty_puppet import FileBox
-from wechaty import Wechaty, Contact
+
+from wechaty import Contact, Wechaty
 from wechaty.user import Message
-from bridge.reply import *
+from wechaty_puppet import FileBox
+
 from bridge.context import *
+from bridge.context import Context
+from bridge.reply import *
 from channel.chat_channel import ChatChannel
 from channel.wechat.wechaty_message import WechatyMessage
 from common.log import logger
 from common.singleton import singleton
 from config import conf
+
 try:
     from voice.audio_convert import any_to_sil
 except Exception as e:
     pass
 
+
 @singleton
 class WechatyChannel(ChatChannel):
     NOT_SUPPORT_REPLYTYPE = []
+
     def __init__(self):
         super().__init__()
 
     def startup(self):
         config = conf()
-        token = config.get('wechaty_puppet_service_token')
-        os.environ['WECHATY_PUPPET_SERVICE_TOKEN'] = token
+        token = config.get("wechaty_puppet_service_token")
+        os.environ["WECHATY_PUPPET_SERVICE_TOKEN"] = token
         asyncio.run(self.main())
 
     async def main(self):
-        
         loop = asyncio.get_event_loop()
-        #将asyncio的loop传入处理线程
-        self.handler_pool._initializer= lambda: asyncio.set_event_loop(loop)
+        # 将asyncio的loop传入处理线程
+        self.handler_pool._initializer = lambda: asyncio.set_event_loop(loop)
         self.bot = Wechaty()
-        self.bot.on('login', self.on_login)
-        self.bot.on('message', self.on_message)
+        self.bot.on("login", self.on_login)
+        self.bot.on("message", self.on_message)
         await self.bot.start()
 
     async def on_login(self, contact: Contact):
         self.user_id = contact.contact_id
         self.name = contact.name
-        logger.info('[WX] login user={}'.format(contact))
+        logger.info("[WX] login user={}".format(contact))
 
     # 统一的发送函数，每个Channel自行实现，根据reply的type字段发送不同类型的消息
     def send(self, reply: Reply, context: Context):
-        receiver_id = context['receiver']
+        receiver_id = context["receiver"]
         loop = asyncio.get_event_loop()
-        if context['isgroup']:
-            receiver = asyncio.run_coroutine_threadsafe(self.bot.Room.find(receiver_id),loop).result()
+        if context["isgroup"]:
+            receiver = asyncio.run_coroutine_threadsafe(self.bot.Room.find(receiver_id), loop).result()
         else:
-            receiver = asyncio.run_coroutine_threadsafe(self.bot.Contact.find(receiver_id),loop).result()
+            receiver = asyncio.run_coroutine_threadsafe(self.bot.Contact.find(receiver_id), loop).result()
         msg = None
         if reply.type == ReplyType.TEXT:
             msg = reply.content
-            asyncio.run_coroutine_threadsafe(receiver.say(msg),loop).result()
-            logger.info('[WX] sendMsg={}, receiver={}'.format(reply, receiver))
+            asyncio.run_coroutine_threadsafe(receiver.say(msg), loop).result()
+            logger.info("[WX] sendMsg={}, receiver={}".format(reply, receiver))
         elif reply.type == ReplyType.ERROR or reply.type == ReplyType.INFO:
             msg = reply.content
-            asyncio.run_coroutine_threadsafe(receiver.say(msg),loop).result()
-            logger.info('[WX] sendMsg={}, receiver={}'.format(reply, receiver))
+            asyncio.run_coroutine_threadsafe(receiver.say(msg), loop).result()
+            logger.info("[WX] sendMsg={}, receiver={}".format(reply, receiver))
         elif reply.type == ReplyType.VOICE:
             voiceLength = None
             file_path = reply.content
-            sil_file = os.path.splitext(file_path)[0] + '.sil'
+            sil_file = os.path.splitext(file_path)[0] + ".sil"
             voiceLength = int(any_to_sil(file_path, sil_file))
             if voiceLength >= 60000:
                 voiceLength = 60000
-                logger.info('[WX] voice too long, length={}, set to 60s'.format(voiceLength))
+                logger.info("[WX] voice too long, length={}, set to 60s".format(voiceLength))
             # 发送语音
             t = int(time.time())
-            msg = FileBox.from_file(sil_file, name=str(t) + '.sil')
+            msg = FileBox.from_file(sil_file, name=str(t) + ".sil")
             if voiceLength is not None:
-                msg.metadata['voiceLength'] = voiceLength
-            asyncio.run_coroutine_threadsafe(receiver.say(msg),loop).result()
+                msg.metadata["voiceLength"] = voiceLength
+            asyncio.run_coroutine_threadsafe(receiver.say(msg), loop).result()
             try:
                 os.remove(file_path)
                 if sil_file != file_path:
                     os.remove(sil_file)
             except Exception as e:
                 pass
-            logger.info('[WX] sendVoice={}, receiver={}'.format(reply.content, receiver))
-        elif reply.type == ReplyType.IMAGE_URL: # 从网络下载图片
+            logger.info("[WX] sendVoice={}, receiver={}".format(reply.content, receiver))
+        elif reply.type == ReplyType.IMAGE_URL:  # 从网络下载图片
             img_url = reply.content
             t = int(time.time())
-            msg = FileBox.from_url(url=img_url, name=str(t) + '.png')
-            asyncio.run_coroutine_threadsafe(receiver.say(msg),loop).result()
-            logger.info('[WX] sendImage url={}, receiver={}'.format(img_url,receiver))
-        elif reply.type == ReplyType.IMAGE: # 从文件读取图片
+            msg = FileBox.from_url(url=img_url, name=str(t) + ".png")
+            asyncio.run_coroutine_threadsafe(receiver.say(msg), loop).result()
+            logger.info("[WX] sendImage url={}, receiver={}".format(img_url, receiver))
+        elif reply.type == ReplyType.IMAGE:  # 从文件读取图片
             image_storage = reply.content
             image_storage.seek(0)
             t = int(time.time())
-            msg = FileBox.from_base64(base64.b64encode(image_storage.read()), str(t) + '.png')
-            asyncio.run_coroutine_threadsafe(receiver.say(msg),loop).result()
-            logger.info('[WX] sendImage, receiver={}'.format(receiver))
+            msg = FileBox.from_base64(base64.b64encode(image_storage.read()), str(t) + ".png")
+            asyncio.run_coroutine_threadsafe(receiver.say(msg), loop).result()
+            logger.info("[WX] sendImage, receiver={}".format(receiver))
 
     async def on_message(self, msg: Message):
         """
@@ -110,16 +114,16 @@ class WechatyChannel(ChatChannel):
         try:
             cmsg = await WechatyMessage(msg)
         except NotImplementedError as e:
-            logger.debug('[WX] {}'.format(e))
+            logger.debug("[WX] {}".format(e))
             return
         except Exception as e:
-            logger.exception('[WX] {}'.format(e))
+            logger.exception("[WX] {}".format(e))
             return
-        logger.debug('[WX] message:{}'.format(cmsg))
+        logger.debug("[WX] message:{}".format(cmsg))
         room = msg.room()  # 获取消息来自的群聊. 如果消息不是来自群聊, 则返回None
         isgroup = room is not None
         ctype = cmsg.ctype
         context = self._compose_context(ctype, cmsg.content, isgroup=isgroup, msg=cmsg)
         if context:
-            logger.info('[WX] receiveMsg={}, context={}'.format(cmsg, context))
-            self.produce(context)
+            logger.info("[WX] receiveMsg={}, context={}".format(cmsg, context))
+            self.produce(context)

channel/wechat/wechaty_message.py

@@ -1,17 +1,21 @@
 import asyncio
 import re
+
 from wechaty import MessageType
+from wechaty.user import Message
+
 from bridge.context import ContextType
 from channel.chat_message import ChatMessage
-from common.tmp_dir import TmpDir
 from common.log import logger
-from wechaty.user import Message
+from common.tmp_dir import TmpDir
+
 
 class aobject(object):
     """Inheriting this class allows you to define an async __init__.
 
     So you can create objects by doing something like `await MyClass(params)`
     """
+
     async def __new__(cls, *a, **kw):
         instance = super().__new__(cls)
         await instance.__init__(*a, **kw)
@@ -19,17 +23,18 @@ class aobject(object):
 
     async def __init__(self):
         pass
-class WechatyMessage(ChatMessage, aobject):
 
+
+class WechatyMessage(ChatMessage, aobject):
     async def __init__(self, wechaty_msg: Message):
         super().__init__(wechaty_msg)
-        
+
         room = wechaty_msg.room()
 
         self.msg_id = wechaty_msg.message_id
         self.create_time = wechaty_msg.payload.timestamp
         self.is_group = room is not None
-        
+
         if wechaty_msg.type() == MessageType.MESSAGE_TYPE_TEXT:
             self.ctype = ContextType.TEXT
             self.content = wechaty_msg.text()
@@ -40,12 +45,13 @@ class WechatyMessage(ChatMessage, aobject):
 
             def func():
                 loop = asyncio.get_event_loop()
-                asyncio.run_coroutine_threadsafe(voice_file.to_file(self.content),loop).result()
+                asyncio.run_coroutine_threadsafe(voice_file.to_file(self.content), loop).result()
+
             self._prepare_fn = func
-            
+
         else:
             raise NotImplementedError("Unsupported message type: {}".format(wechaty_msg.type()))
-        
+
         from_contact = wechaty_msg.talker()  # 获取消息的发送者
         self.from_user_id = from_contact.contact_id
         self.from_user_nickname = from_contact.name
@@ -54,7 +60,7 @@ class WechatyMessage(ChatMessage, aobject):
         # wecahty: from是消息实际发送者, to:所在群
         # itchat: 如果是你发送群消息，from和to是你自己和所在群，如果是别人发群消息，from和to是所在群和你自己
         # 但这个差别不影响逻辑，group中只使用到：1.用from来判断是否是自己发的，2.actual_user_id来判断实际发送用户
-        
+
         if self.is_group:
             self.to_user_id = room.room_id
             self.to_user_nickname = await room.topic()
@@ -63,22 +69,20 @@ class WechatyMessage(ChatMessage, aobject):
             self.to_user_id = to_contact.contact_id
             self.to_user_nickname = to_contact.name
 
-        if self.is_group or wechaty_msg.is_self(): # 如果是群消息，other_user设置为群，如果是私聊消息，而且自己发的，就设置成对方。
+        if self.is_group or wechaty_msg.is_self():  # 如果是群消息，other_user设置为群，如果是私聊消息，而且自己发的，就设置成对方。
             self.other_user_id = self.to_user_id
             self.other_user_nickname = self.to_user_nickname
         else:
             self.other_user_id = self.from_user_id
             self.other_user_nickname = self.from_user_nickname
 
-        
-
-        if self.is_group: # wechaty群聊中，实际发送用户就是from_user
+        if self.is_group:  # wechaty群聊中，实际发送用户就是from_user
             self.is_at = await wechaty_msg.mention_self()
-            if not self.is_at: # 有时候复制粘贴的消息，不算做@，但是内容里面会有@xxx，这里做一下兼容
+            if not self.is_at:  # 有时候复制粘贴的消息，不算做@，但是内容里面会有@xxx，这里做一下兼容
                 name = wechaty_msg.wechaty.user_self().name
-                pattern = f'@{name}(\u2005|\u0020)'
-                if re.search(pattern,self.content):
-                    logger.debug(f'wechaty message {self.msg_id} include at')
+                pattern = f"@{re.escape(name)}(\u2005|\u0020)"
+                if re.search(pattern, self.content):
+                    logger.debug(f"wechaty message {self.msg_id} include at")
                     self.is_at = True
 
             self.actual_user_id = self.from_user_id

channel/wechatcom/README.md

@@ -0,0 +1,87 @@
+# 企业微信应用号channel
+
+企业微信官方提供了客服、应用等API，本channel使用的是企业微信的应用API的能力。
+
+因为未来可能还会开发客服能力，所以本channel的类型名叫作`wechatcom_app`。
+
+`wechatcom_app` channel支持插件系统和图片声音交互等能力，除了无法加入群聊，作为个人使用的私人助理已绰绰有余。
+
+## 开始之前
+
+- 在企业中确认自己拥有在企业内自建应用的权限。
+- 如果没有权限或者是个人用户，也可创建未认证的企业。操作方式：登录手机企业微信，选择`创建/加入企业`来创建企业，类型请选择企业，企业名称可随意填写。
+    未认证的企业有100人的服务人数上限，其他功能与认证企业没有差异。
+
+本channel需安装的依赖与公众号一致，需要安装`wechatpy`和`web.py`，它们包含在`requirements-optional.txt`中。
+
+此外，如果你是`Linux`系统，除了`ffmpeg`还需要安装`amr`编码器，否则会出现找不到编码器的错误，无法正常使用语音功能。
+
+- Ubuntu/Debian
+
+```bash
+apt-get install libavcodec-extra
+```
+
+- Alpine
+
+需自行编译`ffmpeg`，在编译参数里加入`amr`编码器的支持
+
+## 使用方法
+
+1.查看企业ID
+
+- 扫码登陆[企业微信后台](https://work.weixin.qq.com)
+- 选择`我的企业`，点击`企业信息`，记住该`企业ID`
+
+2.创建自建应用
+
+- 选择应用管理, 在自建区选创建应用来创建企业自建应用
+- 上传应用logo，填写应用名称等项
+- 创建应用后进入应用详情页面，记住`AgentId`和`Secert`
+
+3.配置应用
+
+- 在详情页点击`企业可信IP`的配置(没看到可以不管)，填入你服务器的公网IP，如果不知道可以先不填
+- 点击`接收消息`下的启用API接收消息
+- `URL`填写格式为`http://url:port/wxcomapp`，`port`是程序监听的端口，默认是9898
+    如果是未认证的企业，url可直接使用服务器的IP。如果是认证企业，需要使用备案的域名，可使用二级域名。
+- `Token`可随意填写，停留在这个页面
+- 在程序根目录`config.json`中增加配置（**去掉注释**），`wechatcomapp_aes_key`是当前页面的`wechatcomapp_aes_key`
+
+```python
+    "channel_type": "wechatcom_app",
+    "wechatcom_corp_id": "",  # 企业微信公司的corpID
+    "wechatcomapp_token": "",  # 企业微信app的token
+    "wechatcomapp_port": 9898,  # 企业微信app的服务端口, 不需要端口转发
+    "wechatcomapp_secret": "",  # 企业微信app的secret
+    "wechatcomapp_agent_id": "",  # 企业微信app的agent_id
+    "wechatcomapp_aes_key": "",  # 企业微信app的aes_key
+```
+
+- 运行程序，在页面中点击保存，保存成功说明验证成功
+
+4.连接个人微信
+
+选择`我的企业`，点击`微信插件`，下面有个邀请关注的二维码。微信扫码后，即可在微信中看到对应企业，在这里你便可以和机器人沟通。
+
+向机器人发送消息，如果日志里出现报错:
+
+```bash
+Error code: 60020, message: "not allow to access from your ip, ...from ip: xx.xx.xx.xx"
+```
+
+意思是IP不可信，需要参考上一步的`企业可信IP`配置，把这里的IP加进去。
+
+### Railway部署方式
+
+公众号不能在`Railway`上部署，但企业微信应用[可以](https://railway.app/template/-FHS--?referralCode=RC3znh)!
+
+[![Deploy on Railway](https://railway.app/button.svg)](https://railway.app/template/-FHS--?referralCode=RC3znh)
+
+填写配置后，将部署完成后的网址```**.railway.app/wxcomapp```，填写在上一步的URL中。发送信息后观察日志，把报错的IP加入到可信IP。（每次重启后都需要加入可信IP）
+
+## 测试体验
+
+AIGC开放社区中已经部署了多个可免费使用的Bot，扫描下方的二维码会自动邀请你来体验。
+
+<img width="200" src="../../docs/images/aigcopen.png">

channel/wechatcom/wechatcomapp_channel.py

@@ -0,0 +1,176 @@
+# -*- coding=utf-8 -*-
+import io
+import os
+import time
+
+import requests
+import web
+from wechatpy.enterprise import create_reply, parse_message
+from wechatpy.enterprise.crypto import WeChatCrypto
+from wechatpy.enterprise.exceptions import InvalidCorpIdException
+from wechatpy.exceptions import InvalidSignatureException, WeChatClientException
+
+from bridge.context import Context
+from bridge.reply import Reply, ReplyType
+from channel.chat_channel import ChatChannel
+from channel.wechatcom.wechatcomapp_client import WechatComAppClient
+from channel.wechatcom.wechatcomapp_message import WechatComAppMessage
+from common.log import logger
+from common.singleton import singleton
+from common.utils import compress_imgfile, fsize, split_string_by_utf8_length
+from config import conf, subscribe_msg
+from voice.audio_convert import any_to_amr, split_audio
+
+MAX_UTF8_LEN = 2048
+
+
+@singleton
+class WechatComAppChannel(ChatChannel):
+    NOT_SUPPORT_REPLYTYPE = []
+
+    def __init__(self):
+        super().__init__()
+        self.corp_id = conf().get("wechatcom_corp_id")
+        self.secret = conf().get("wechatcomapp_secret")
+        self.agent_id = conf().get("wechatcomapp_agent_id")
+        self.token = conf().get("wechatcomapp_token")
+        self.aes_key = conf().get("wechatcomapp_aes_key")
+        print(self.corp_id, self.secret, self.agent_id, self.token, self.aes_key)
+        logger.info(
+            "[wechatcom] init: corp_id: {}, secret: {}, agent_id: {}, token: {}, aes_key: {}".format(self.corp_id, self.secret, self.agent_id, self.token, self.aes_key)
+        )
+        self.crypto = WeChatCrypto(self.token, self.aes_key, self.corp_id)
+        self.client = WechatComAppClient(self.corp_id, self.secret)
+
+    def startup(self):
+        # start message listener
+        urls = ("/wxcomapp", "channel.wechatcom.wechatcomapp_channel.Query")
+        app = web.application(urls, globals(), autoreload=False)
+        port = conf().get("wechatcomapp_port", 9898)
+        web.httpserver.runsimple(app.wsgifunc(), ("0.0.0.0", port))
+
+    def send(self, reply: Reply, context: Context):
+        receiver = context["receiver"]
+        if reply.type in [ReplyType.TEXT, ReplyType.ERROR, ReplyType.INFO]:
+            reply_text = reply.content
+            texts = split_string_by_utf8_length(reply_text, MAX_UTF8_LEN)
+            if len(texts) > 1:
+                logger.info("[wechatcom] text too long, split into {} parts".format(len(texts)))
+            for i, text in enumerate(texts):
+                self.client.message.send_text(self.agent_id, receiver, text)
+                if i != len(texts) - 1:
+                    time.sleep(0.5)  # 休眠0.5秒，防止发送过快乱序
+            logger.info("[wechatcom] Do send text to {}: {}".format(receiver, reply_text))
+        elif reply.type == ReplyType.VOICE:
+            try:
+                media_ids = []
+                file_path = reply.content
+                amr_file = os.path.splitext(file_path)[0] + ".amr"
+                any_to_amr(file_path, amr_file)
+                duration, files = split_audio(amr_file, 60 * 1000)
+                if len(files) > 1:
+                    logger.info("[wechatcom] voice too long {}s > 60s , split into {} parts".format(duration / 1000.0, len(files)))
+                for path in files:
+                    response = self.client.media.upload("voice", open(path, "rb"))
+                    logger.debug("[wechatcom] upload voice response: {}".format(response))
+                    media_ids.append(response["media_id"])
+            except WeChatClientException as e:
+                logger.error("[wechatcom] upload voice failed: {}".format(e))
+                return
+            try:
+                os.remove(file_path)
+                if amr_file != file_path:
+                    os.remove(amr_file)
+            except Exception:
+                pass
+            for media_id in media_ids:
+                self.client.message.send_voice(self.agent_id, receiver, media_id)
+                time.sleep(1)
+            logger.info("[wechatcom] sendVoice={}, receiver={}".format(reply.content, receiver))
+        elif reply.type == ReplyType.IMAGE_URL:  # 从网络下载图片
+            img_url = reply.content
+            pic_res = requests.get(img_url, stream=True)
+            image_storage = io.BytesIO()
+            for block in pic_res.iter_content(1024):
+                image_storage.write(block)
+            if (sz := fsize(image_storage)) >= 10 * 1024 * 1024:
+                logger.info("[wechatcom] image too large, ready to compress, sz={}".format(sz))
+                image_storage = compress_imgfile(image_storage, 10 * 1024 * 1024 - 1)
+                logger.info("[wechatcom] image compressed, sz={}".format(fsize(image_storage)))
+            image_storage.seek(0)
+            try:
+                response = self.client.media.upload("image", image_storage)
+                logger.debug("[wechatcom] upload image response: {}".format(response))
+            except WeChatClientException as e:
+                logger.error("[wechatcom] upload image failed: {}".format(e))
+                return
+
+            self.client.message.send_image(self.agent_id, receiver, response["media_id"])
+            logger.info("[wechatcom] sendImage url={}, receiver={}".format(img_url, receiver))
+        elif reply.type == ReplyType.IMAGE:  # 从文件读取图片
+            image_storage = reply.content
+            if (sz := fsize(image_storage)) >= 10 * 1024 * 1024:
+                logger.info("[wechatcom] image too large, ready to compress, sz={}".format(sz))
+                image_storage = compress_imgfile(image_storage, 10 * 1024 * 1024 - 1)
+                logger.info("[wechatcom] image compressed, sz={}".format(fsize(image_storage)))
+            image_storage.seek(0)
+            try:
+                response = self.client.media.upload("image", image_storage)
+                logger.debug("[wechatcom] upload image response: {}".format(response))
+            except WeChatClientException as e:
+                logger.error("[wechatcom] upload image failed: {}".format(e))
+                return
+            self.client.message.send_image(self.agent_id, receiver, response["media_id"])
+            logger.info("[wechatcom] sendImage, receiver={}".format(receiver))
+
+
+class Query:
+    def GET(self):
+        channel = WechatComAppChannel()
+        params = web.input()
+        logger.info("[wechatcom] receive params: {}".format(params))
+        try:
+            signature = params.msg_signature
+            timestamp = params.timestamp
+            nonce = params.nonce
+            echostr = params.echostr
+            echostr = channel.crypto.check_signature(signature, timestamp, nonce, echostr)
+        except InvalidSignatureException:
+            raise web.Forbidden()
+        return echostr
+
+    def POST(self):
+        channel = WechatComAppChannel()
+        params = web.input()
+        logger.info("[wechatcom] receive params: {}".format(params))
+        try:
+            signature = params.msg_signature
+            timestamp = params.timestamp
+            nonce = params.nonce
+            message = channel.crypto.decrypt_message(web.data(), signature, timestamp, nonce)
+        except (InvalidSignatureException, InvalidCorpIdException):
+            raise web.Forbidden()
+        msg = parse_message(message)
+        logger.debug("[wechatcom] receive message: {}, msg= {}".format(message, msg))
+        if msg.type == "event":
+            if msg.event == "subscribe":
+                reply_content = subscribe_msg()
+                if reply_content:
+                    reply = create_reply(reply_content, msg).render()
+                    res = channel.crypto.encrypt_message(reply, nonce, timestamp)
+                    return res
+        else:
+            try:
+                wechatcom_msg = WechatComAppMessage(msg, client=channel.client)
+            except NotImplementedError as e:
+                logger.debug("[wechatcom] " + str(e))
+                return "success"
+            context = channel._compose_context(
+                wechatcom_msg.ctype,
+                wechatcom_msg.content,
+                isgroup=False,
+                msg=wechatcom_msg,
+            )
+            if context:
+                channel.produce(context)
+        return "success"

channel/wechatcom/wechatcomapp_client.py

@@ -0,0 +1,21 @@
+import threading
+import time
+
+from wechatpy.enterprise import WeChatClient
+
+
+class WechatComAppClient(WeChatClient):
+    def __init__(self, corp_id, secret, access_token=None, session=None, timeout=None, auto_retry=True):
+        super(WechatComAppClient, self).__init__(corp_id, secret, access_token, session, timeout, auto_retry)
+        self.fetch_access_token_lock = threading.Lock()
+
+    def fetch_access_token(self):  # 重载父类方法，加锁避免多线程重复获取access_token
+        with self.fetch_access_token_lock:
+            access_token = self.session.get(self.access_token_key)
+            if access_token:
+                if not self.expires_at:
+                    return access_token
+                timestamp = time.time()
+                if self.expires_at - timestamp > 60:
+                    return access_token
+            return super().fetch_access_token()

channel/wechatcom/wechatcomapp_message.py

@@ -0,0 +1,52 @@
+from wechatpy.enterprise import WeChatClient
+
+from bridge.context import ContextType
+from channel.chat_message import ChatMessage
+from common.log import logger
+from common.tmp_dir import TmpDir
+
+
+class WechatComAppMessage(ChatMessage):
+    def __init__(self, msg, client: WeChatClient, is_group=False):
+        super().__init__(msg)
+        self.msg_id = msg.id
+        self.create_time = msg.time
+        self.is_group = is_group
+
+        if msg.type == "text":
+            self.ctype = ContextType.TEXT
+            self.content = msg.content
+        elif msg.type == "voice":
+            self.ctype = ContextType.VOICE
+            self.content = TmpDir().path() + msg.media_id + "." + msg.format  # content直接存临时目录路径
+
+            def download_voice():
+                # 如果响应状态码是200，则将响应内容写入本地文件
+                response = client.media.download(msg.media_id)
+                if response.status_code == 200:
+                    with open(self.content, "wb") as f:
+                        f.write(response.content)
+                else:
+                    logger.info(f"[wechatcom] Failed to download voice file, {response.content}")
+
+            self._prepare_fn = download_voice
+        elif msg.type == "image":
+            self.ctype = ContextType.IMAGE
+            self.content = TmpDir().path() + msg.media_id + ".png"  # content直接存临时目录路径
+
+            def download_image():
+                # 如果响应状态码是200，则将响应内容写入本地文件
+                response = client.media.download(msg.media_id)
+                if response.status_code == 200:
+                    with open(self.content, "wb") as f:
+                        f.write(response.content)
+                else:
+                    logger.info(f"[wechatcom] Failed to download image file, {response.content}")
+
+            self._prepare_fn = download_image
+        else:
+            raise NotImplementedError("Unsupported message type: Type:{} ".format(msg.type))
+
+        self.from_user_id = msg.source
+        self.to_user_id = msg.target
+        self.other_user_id = msg.source

channel/wechatmp/README.md

@@ -1,46 +1,100 @@
-# 个人微信公众号channel
+# 微信公众号channel
 
-鉴于个人微信号在服务器上通过itchat登录有封号风险，这里新增了个人微信公众号channel，提供无风险的服务。
-但是由于个人微信公众号的众多接口限制，目前支持的功能有限，实现简陋，提供了一个最基本的文本对话服务，支持加载插件，优化了命令格式，支持私有api_key。暂未实现图片输入输出、语音输入输出等交互形式。
-如有公众号是企业主体且可以通过微信认证，即可获得更多接口，解除大多数限制。欢迎大家提供更多的支持。
+鉴于个人微信号在服务器上通过itchat登录有封号风险，这里新增了微信公众号channel，提供无风险的服务。
+目前支持订阅号和服务号两种类型的公众号，它们都支持文本交互，语音和图片输入。其中个人主体的微信订阅号由于无法通过微信认证，存在回复时间限制，每天的图片和声音回复次数也有限制。
 
-## 使用方法
+## 使用方法（订阅号，服务号类似）
 
 在开始部署前，你需要一个拥有公网IP的服务器，以提供微信服务器和我们自己服务器的连接。或者你需要进行内网穿透，否则微信服务器无法将消息发送给我们的服务器。
 
-此外，需要在我们的服务器上安装python的web框架web.py。
+此外，需要在我们的服务器上安装python的web框架web.py和wechatpy。
 以ubuntu为例(在ubuntu 22.04上测试):
 ```
 pip3 install web.py
+pip3 install wechatpy
 ```
 
 然后在[微信公众平台](https://mp.weixin.qq.com)注册一个自己的公众号，类型选择订阅号，主体为个人即可。
 
-然后根据[接入指南](https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Access_Overview.html)的说明，在[微信公众平台](https://mp.weixin.qq.com)的“设置与开发”-“基本配置”-“服务器配置”中填写服务器地址`URL`和令牌`Token`。这里的`URL`是`example.com/wx`的形式，不可以使用IP，`Token`是你自己编的一个特定的令牌。消息加解密方式目前选择的是明文模式。
+然后根据[接入指南](https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Access_Overview.html)的说明，在[微信公众平台](https://mp.weixin.qq.com)的“设置与开发”-“基本配置”-“服务器配置”中填写服务器地址`URL`和令牌`Token`。`URL`填写格式为`http://url/wx`，可使用IP（成功几率看脸），`Token`是你自己编的一个特定的令牌。消息加解密方式如果选择了需要加密的模式，需要在配置中填写`wechatmp_aes_key`。
 
 相关的服务器验证代码已经写好，你不需要再添加任何代码。你只需要在本项目根目录的`config.json`中添加
 ```
-"channel_type": "wechatmp", 
-"wechatmp_token": "your Token", 
-"wechatmp_port": 8080,
-``` 
-然后运行`python3 app.py`启动web服务器。这里会默认监听8080端口，但是微信公众号的服务器配置只支持80/443端口，有两种方法来解决这个问题。第一个是推荐的方法，使用端口转发命令将80端口转发到8080端口（443同理，注意需要支持SSL，也就是https的访问，在`wechatmp_channel.py`需要修改相应的证书路径）：
+"channel_type": "wechatmp",     # 如果通过了微信认证，将"wechatmp"替换为"wechatmp_service"，可极大的优化使用体验
+"wechatmp_token": "xxxx",       # 微信公众平台的Token
+"wechatmp_port": 8080,          # 微信公众平台的端口,需要端口转发到80或443
+"wechatmp_app_id": "xxxx",      # 微信公众平台的appID
+"wechatmp_app_secret": "xxxx",  # 微信公众平台的appsecret
+"wechatmp_aes_key": "",         # 微信公众平台的EncodingAESKey，加密模式需要
+"single_chat_prefix": [""],     # 推荐设置，任意对话都可以触发回复，不添加前缀
+"single_chat_reply_prefix": "", # 推荐设置，回复不设置前缀
+"plugin_trigger_prefix": "&",   # 推荐设置，在手机微信客户端中，$%^等符号与中文连在一起时会自动显示一段较大的间隔，用户体验不好。请不要使用管理员指令前缀"#"，这会造成未知问题。
+```
+然后运行`python3 app.py`启动web服务器。这里会默认监听8080端口，但是微信公众号的服务器配置只支持80/443端口，有两种方法来解决这个问题。第一个是推荐的方法，使用端口转发命令将80端口转发到8080端口：
 ```
 sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080
 sudo iptables-save > /etc/iptables/rules.v4
 ```
-第二个方法是让python程序直接监听80端口。这样可能会导致权限问题，在linux上需要使用`sudo`。然而这会导致后续缓存文件的权限问题，因此不是推荐的方法。
-最后在刚才的“服务器配置”中点击`提交`即可验证你的服务器。
+第二个方法是让python程序直接监听80端口，在配置文件中设置`"wechatmp_port": 80` ，在linux上需要使用`sudo python3 app.py`启动程序。然而这会导致一系列环境和权限问题，因此不是推荐的方法。
 
+443端口同理，注意需要支持SSL，也就是https的访问，在`wechatmp_channel.py`中需要修改相应的证书路径。
+
+程序启动并监听端口后，在刚才的“服务器配置”中点击`提交`即可验证你的服务器。
 随后在[微信公众平台](https://mp.weixin.qq.com)启用服务器，关闭手动填写规则的自动回复，即可实现ChatGPT的自动回复。
 
-## 个人微信公众号的限制
-由于目前测试的公众号不是企业主体，所以没有客服接口，因此公众号无法主动发出消息，只能被动回复。而微信官方对被动回复有5秒的时间限制，最多重试2次，因此最多只有15秒的自动回复时间窗口。因此如果问题比较复杂或者我们的服务器比较忙，ChatGPT的回答就没办法及时回复给用户。为了解决这个问题，这里做了回答缓存，它需要你在回复超时后，再次主动发送任意文字（例如1）来尝试拿到回答缓存。为了优化使用体验，目前设置了两分钟（120秒）的timeout，用户在至多两分钟后即可得到查询到回复或者错误原因。
+之后需要在公众号开发信息下将本机IP加入到IP白名单。
 
-另外，由于微信官方的限制，自动回复有长度限制。因此这里将ChatGPT的回答拆分，分成每段600字回复（限制大约在700字）。
+不然在启用后，发送语音、图片等消息可能会遇到如下报错：
+```
+'errcode': 40164, 'errmsg': 'invalid ip xx.xx.xx.xx not in whitelist rid
+```
+
+
+## 个人微信公众号的限制
+由于人微信公众号不能通过微信认证，所以没有客服接口，因此公众号无法主动发出消息，只能被动回复。而微信官方对被动回复有5秒的时间限制，最多重试2次，因此最多只有15秒的自动回复时间窗口。因此如果问题比较复杂或者我们的服务器比较忙，ChatGPT的回答就没办法及时回复给用户。为了解决这个问题，这里做了回答缓存，它需要你在回复超时后，再次主动发送任意文字（例如1）来尝试拿到回答缓存。为了优化使用体验，目前设置了两分钟（120秒）的timeout，用户在至多两分钟后即可得到查询到回复或者错误原因。
+
+另外，由于微信官方的限制，自动回复有长度限制。因此这里将ChatGPT的回答进行了拆分，以满足限制。
 
 ## 私有api_key
-公共api有访问频率限制（免费账号每分钟最多20次ChatGPT的API调用），这在服务多人的时候会遇到问题。因此这里多加了一个设置私有api_key的功能。目前通过godcmd插件的命令来设置私有api_key。
+公共api有访问频率限制（免费账号每分钟最多3次ChatGPT的API调用），这在服务多人的时候会遇到问题。因此这里多加了一个设置私有api_key的功能。目前通过godcmd插件的命令来设置私有api_key。
 
-## 测试范围
-目前在`RoboStyle`这个公众号上进行了测试，感兴趣的可以关注并体验。开启了godcmd, Banwords, role, dungeon, finish这五个插件，其他的插件还没有测试。百度的接口暂未测试。语音对话没有测试。图片直接以链接形式回复（没有临时素材上传接口的权限）。
+## 语音输入
+利用微信自带的语音识别功能，提供语音输入能力。需要在公众号管理页面的“设置与开发”->“接口权限”页面开启“接收语音识别结果”。
+
+## 语音回复
+请在配置文件中添加以下词条：
+```
+  "voice_reply_voice": true,
+```
+这样公众号将会用语音回复语音消息，实现语音对话。
+
+默认的语音合成引擎是`google`，它是免费使用的。
+
+如果要选择其他的语音合成引擎，请添加以下配置项：
+```
+"text_to_voice": "pytts"
+```
+
+pytts是本地的语音合成引擎。还支持baidu,azure，这些你需要自行配置相关的依赖和key。
+
+如果使用pytts，在ubuntu上需要安装如下依赖：
+```
+sudo apt update
+sudo apt install espeak
+sudo apt install ffmpeg
+python3 -m pip install pyttsx3
+```
+不是很建议开启pytts语音回复，因为它是离线本地计算，算的慢会拖垮服务器，且声音不好听。
+
+## 图片回复
+现在认证公众号和非认证公众号都可以实现的图片和语音回复。但是非认证公众号使用了永久素材接口，每天有1000次的调用上限（每个月有10次重置机会，程序中已设定遇到上限会自动重置），且永久素材库存也有上限。因此对于非认证公众号，我们会在回复图片或者语音消息后的10秒内从永久素材库存内删除该素材。
+
+## 测试
+目前在`RoboStyle`这个公众号上进行了测试（基于[wechatmp分支](https://github.com/JS00000/chatgpt-on-wechat/tree/wechatmp)），感兴趣的可以关注并体验。开启了godcmd, Banwords, role, dungeon, finish这五个插件，其他的插件还没有详尽测试。百度的接口暂未测试。[wechatmp-stable分支](https://github.com/JS00000/chatgpt-on-wechat/tree/wechatmp-stable)是较稳定的上个版本，但也缺少最新的功能支持。
+
+## TODO
+ - [x] 语音输入
+ - [x] 图片输入
+ - [x] 使用临时素材接口提供认证公众号的图片和语音回复
+ - [x] 使用永久素材接口提供未认证公众号的图片和语音回复
+ - [ ] 高并发支持

channel/wechatmp/active_reply.py

@@ -0,0 +1,75 @@
+import time
+
+import web
+from wechatpy import parse_message
+from wechatpy.replies import create_reply
+
+from bridge.context import *
+from bridge.reply import *
+from channel.wechatmp.common import *
+from channel.wechatmp.wechatmp_channel import WechatMPChannel
+from channel.wechatmp.wechatmp_message import WeChatMPMessage
+from common.log import logger
+from config import conf, subscribe_msg
+
+
+# This class is instantiated once per query
+class Query:
+    def GET(self):
+        return verify_server(web.input())
+
+    def POST(self):
+        # Make sure to return the instance that first created, @singleton will do that.
+        try:
+            args = web.input()
+            verify_server(args)
+            channel = WechatMPChannel()
+            message = web.data()
+            encrypt_func = lambda x: x
+            if args.get("encrypt_type") == "aes":
+                logger.debug("[wechatmp] Receive encrypted post data:\n" + message.decode("utf-8"))
+                if not channel.crypto:
+                    raise Exception("Crypto not initialized, Please set wechatmp_aes_key in config.json")
+                message = channel.crypto.decrypt_message(message, args.msg_signature, args.timestamp, args.nonce)
+                encrypt_func = lambda x: channel.crypto.encrypt_message(x, args.nonce, args.timestamp)
+            else:
+                logger.debug("[wechatmp] Receive post data:\n" + message.decode("utf-8"))
+            msg = parse_message(message)
+            if msg.type in ["text", "voice", "image"]:
+                wechatmp_msg = WeChatMPMessage(msg, client=channel.client)
+                from_user = wechatmp_msg.from_user_id
+                content = wechatmp_msg.content
+                message_id = wechatmp_msg.msg_id
+
+                logger.info(
+                    "[wechatmp] {}:{} Receive post query {} {}: {}".format(
+                        web.ctx.env.get("REMOTE_ADDR"),
+                        web.ctx.env.get("REMOTE_PORT"),
+                        from_user,
+                        message_id,
+                        content,
+                    )
+                )
+                if msg.type == "voice" and wechatmp_msg.ctype == ContextType.TEXT and conf().get("voice_reply_voice", False):
+                    context = channel._compose_context(wechatmp_msg.ctype, content, isgroup=False, desire_rtype=ReplyType.VOICE, msg=wechatmp_msg)
+                else:
+                    context = channel._compose_context(wechatmp_msg.ctype, content, isgroup=False, msg=wechatmp_msg)
+                if context:
+                    channel.produce(context)
+                # The reply will be sent by channel.send() in another thread
+                return "success"
+            elif msg.type == "event":
+                logger.info("[wechatmp] Event {} from {}".format(msg.event, msg.source))
+                if msg.event in ["subscribe", "subscribe_scan"]:
+                    reply_text = subscribe_msg()
+                    if reply_text:
+                        replyPost = create_reply(reply_text, msg)
+                        return encrypt_func(replyPost.render())
+                else:
+                    return "success"
+            else:
+                logger.info("暂且不处理")
+            return "success"
+        except Exception as exc:
+            logger.exception(exc)
+            return exc

channel/wechatmp/common.py

@@ -0,0 +1,27 @@
+import web
+from wechatpy.crypto import WeChatCrypto
+from wechatpy.exceptions import InvalidSignatureException
+from wechatpy.utils import check_signature
+
+from config import conf
+
+MAX_UTF8_LEN = 2048
+
+
+class WeChatAPIException(Exception):
+    pass
+
+
+def verify_server(data):
+    try:
+        signature = data.signature
+        timestamp = data.timestamp
+        nonce = data.nonce
+        echostr = data.get("echostr", None)
+        token = conf().get("wechatmp_token")  # 请按照公众平台官网\基本配置中信息填写
+        check_signature(token, signature, timestamp, nonce)
+        return echostr
+    except InvalidSignatureException:
+        raise web.Forbidden("Invalid signature")
+    except Exception as e:
+        raise web.Forbidden(str(e))

channel/wechatmp/passive_reply.py

@@ -0,0 +1,209 @@
+import asyncio
+import time
+
+import web
+from wechatpy import parse_message
+from wechatpy.replies import ImageReply, VoiceReply, create_reply
+
+from bridge.context import *
+from bridge.reply import *
+from channel.wechatmp.common import *
+from channel.wechatmp.wechatmp_channel import WechatMPChannel
+from channel.wechatmp.wechatmp_message import WeChatMPMessage
+from common.log import logger
+from common.utils import split_string_by_utf8_length
+from config import conf, subscribe_msg
+
+
+# This class is instantiated once per query
+class Query:
+    def GET(self):
+        return verify_server(web.input())
+
+    def POST(self):
+        try:
+            args = web.input()
+            verify_server(args)
+            request_time = time.time()
+            channel = WechatMPChannel()
+            message = web.data()
+            encrypt_func = lambda x: x
+            if args.get("encrypt_type") == "aes":
+                logger.debug("[wechatmp] Receive encrypted post data:\n" + message.decode("utf-8"))
+                if not channel.crypto:
+                    raise Exception("Crypto not initialized, Please set wechatmp_aes_key in config.json")
+                message = channel.crypto.decrypt_message(message, args.msg_signature, args.timestamp, args.nonce)
+                encrypt_func = lambda x: channel.crypto.encrypt_message(x, args.nonce, args.timestamp)
+            else:
+                logger.debug("[wechatmp] Receive post data:\n" + message.decode("utf-8"))
+            msg = parse_message(message)
+            if msg.type in ["text", "voice", "image"]:
+                wechatmp_msg = WeChatMPMessage(msg, client=channel.client)
+                from_user = wechatmp_msg.from_user_id
+                content = wechatmp_msg.content
+                message_id = wechatmp_msg.msg_id
+
+                supported = True
+                if "【收到不支持的消息类型，暂无法显示】" in content:
+                    supported = False  # not supported, used to refresh
+
+                # New request
+                if (
+                    from_user not in channel.cache_dict
+                    and from_user not in channel.running
+                    or content.startswith("#")
+                    and message_id not in channel.request_cnt  # insert the godcmd
+                ):
+                    # The first query begin
+                    if msg.type == "voice" and wechatmp_msg.ctype == ContextType.TEXT and conf().get("voice_reply_voice", False):
+                        context = channel._compose_context(wechatmp_msg.ctype, content, isgroup=False, desire_rtype=ReplyType.VOICE, msg=wechatmp_msg)
+                    else:
+                        context = channel._compose_context(wechatmp_msg.ctype, content, isgroup=False, msg=wechatmp_msg)
+                    logger.debug("[wechatmp] context: {} {} {}".format(context, wechatmp_msg, supported))
+
+                    if supported and context:
+                        channel.running.add(from_user)
+                        channel.produce(context)
+                    else:
+                        trigger_prefix = conf().get("single_chat_prefix", [""])[0]
+                        if trigger_prefix or not supported:
+                            if trigger_prefix:
+                                reply_text = textwrap.dedent(
+                                    f"""\
+                                    请输入'{trigger_prefix}'接你想说的话跟我说话。
+                                    例如:
+                                    {trigger_prefix}你好，很高兴见到你。"""
+                                )
+                            else:
+                                reply_text = textwrap.dedent(
+                                    """\
+                                    你好，很高兴见到你。
+                                    请跟我说话吧。"""
+                                )
+                        else:
+                            logger.error(f"[wechatmp] unknown error")
+                            reply_text = textwrap.dedent(
+                                """\
+                                未知错误，请稍后再试"""
+                            )
+
+                        replyPost = create_reply(reply_text, msg)
+                        return encrypt_func(replyPost.render())
+
+                # Wechat official server will request 3 times (5 seconds each), with the same message_id.
+                # Because the interval is 5 seconds, here assumed that do not have multithreading problems.
+                request_cnt = channel.request_cnt.get(message_id, 0) + 1
+                channel.request_cnt[message_id] = request_cnt
+                logger.info(
+                    "[wechatmp] Request {} from {} {} {}:{}\n{}".format(
+                        request_cnt, from_user, message_id, web.ctx.env.get("REMOTE_ADDR"), web.ctx.env.get("REMOTE_PORT"), content
+                    )
+                )
+
+                task_running = True
+                waiting_until = request_time + 4
+                while time.time() < waiting_until:
+                    if from_user in channel.running:
+                        time.sleep(0.1)
+                    else:
+                        task_running = False
+                        break
+
+                reply_text = ""
+                if task_running:
+                    if request_cnt < 3:
+                        # waiting for timeout (the POST request will be closed by Wechat official server)
+                        time.sleep(2)
+                        # and do nothing, waiting for the next request
+                        return "success"
+                    else:  # request_cnt == 3:
+                        # return timeout message
+                        reply_text = "【正在思考中，回复任意文字尝试获取回复】"
+                        replyPost = create_reply(reply_text, msg)
+                        return encrypt_func(replyPost.render())
+
+                # reply is ready
+                channel.request_cnt.pop(message_id)
+
+                # no return because of bandwords or other reasons
+                if from_user not in channel.cache_dict and from_user not in channel.running:
+                    return "success"
+
+                # Only one request can access to the cached data
+                try:
+                    (reply_type, reply_content) = channel.cache_dict.pop(from_user)
+                except KeyError:
+                    return "success"
+
+                if reply_type == "text":
+                    if len(reply_content.encode("utf8")) <= MAX_UTF8_LEN:
+                        reply_text = reply_content
+                    else:
+                        continue_text = "\n【未完待续，回复任意文字以继续】"
+                        splits = split_string_by_utf8_length(
+                            reply_content,
+                            MAX_UTF8_LEN - len(continue_text.encode("utf-8")),
+                            max_split=1,
+                        )
+                        reply_text = splits[0] + continue_text
+                        channel.cache_dict[from_user] = ("text", splits[1])
+
+                    logger.info(
+                        "[wechatmp] Request {} do send to {} {}: {}\n{}".format(
+                            request_cnt,
+                            from_user,
+                            message_id,
+                            content,
+                            reply_text,
+                        )
+                    )
+                    replyPost = create_reply(reply_text, msg)
+                    return encrypt_func(replyPost.render())
+
+                elif reply_type == "voice":
+                    media_id = reply_content
+                    asyncio.run_coroutine_threadsafe(channel.delete_media(media_id), channel.delete_media_loop)
+                    logger.info(
+                        "[wechatmp] Request {} do send to {} {}: {} voice media_id {}".format(
+                            request_cnt,
+                            from_user,
+                            message_id,
+                            content,
+                            media_id,
+                        )
+                    )
+                    replyPost = VoiceReply(message=msg)
+                    replyPost.media_id = media_id
+                    return encrypt_func(replyPost.render())
+
+                elif reply_type == "image":
+                    media_id = reply_content
+                    asyncio.run_coroutine_threadsafe(channel.delete_media(media_id), channel.delete_media_loop)
+                    logger.info(
+                        "[wechatmp] Request {} do send to {} {}: {} image media_id {}".format(
+                            request_cnt,
+                            from_user,
+                            message_id,
+                            content,
+                            media_id,
+                        )
+                    )
+                    replyPost = ImageReply(message=msg)
+                    replyPost.media_id = media_id
+                    return encrypt_func(replyPost.render())
+
+            elif msg.type == "event":
+                logger.info("[wechatmp] Event {} from {}".format(msg.event, msg.source))
+                if msg.event in ["subscribe", "subscribe_scan"]:
+                    reply_text = subscribe_msg()
+                    if reply_text:
+                        replyPost = create_reply(reply_text, msg)
+                        return encrypt_func(replyPost.render())
+                else:
+                    return "success"
+            else:
+                logger.info("暂且不处理")
+            return "success"
+        except Exception as exc:
+            logger.exception(exc)
+            return exc

channel/wechatmp/receive.py

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-#
-# filename: receive.py
-import xml.etree.ElementTree as ET
-from bridge.context import ContextType
-from channel.chat_message import ChatMessage
-from common.log import logger
-
-
-def parse_xml(web_data):
-    if len(web_data) == 0:
-        return None
-    xmlData = ET.fromstring(web_data)
-    return WeChatMPMessage(xmlData)
-
-class WeChatMPMessage(ChatMessage):
-    def __init__(self, xmlData):
-        super().__init__(xmlData)
-        self.to_user_id = xmlData.find('ToUserName').text
-        self.from_user_id = xmlData.find('FromUserName').text
-        self.create_time = xmlData.find('CreateTime').text
-        self.msg_type = xmlData.find('MsgType').text
-        try:
-            self.msg_id = xmlData.find('MsgId').text
-        except:
-            self.msg_id = self.from_user_id+self.create_time
-        self.is_group = False
-        
-        # reply to other_user_id
-        self.other_user_id = self.from_user_id
-
-        if self.msg_type == 'text':
-            self.ctype = ContextType.TEXT
-            self.content = xmlData.find('Content').text.encode("utf-8")
-        elif self.msg_type == 'voice':
-            self.ctype = ContextType.TEXT
-            self.content = xmlData.find('Recognition').text.encode("utf-8")  # 接收语音识别结果
-        elif self.msg_type == 'image':
-            # not implemented
-            self.pic_url = xmlData.find('PicUrl').text
-            self.media_id = xmlData.find('MediaId').text
-        elif self.msg_type == 'event':
-            self.content = xmlData.find('Event').text
-        else: # video, shortvideo, location, link
-            # not implemented
-            pass

channel/wechatmp/reply.py

@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-#
-# filename: reply.py
-import time
-
-class Msg(object):
-    def __init__(self):
-        pass
-
-    def send(self):
-        return "success"
-
-class TextMsg(Msg):
-    def __init__(self, toUserName, fromUserName, content):
-        self.__dict = dict()
-        self.__dict['ToUserName'] = toUserName
-        self.__dict['FromUserName'] = fromUserName
-        self.__dict['CreateTime'] = int(time.time())
-        self.__dict['Content'] = content
-
-    def send(self):
-        XmlForm = """
-            <xml>
-                <ToUserName><![CDATA[{ToUserName}]]></ToUserName>
-                <FromUserName><![CDATA[{FromUserName}]]></FromUserName>
-                <CreateTime>{CreateTime}</CreateTime>
-                <MsgType><![CDATA[text]]></MsgType>
-                <Content><![CDATA[{Content}]]></Content>
-            </xml>
-            """
-        return XmlForm.format(**self.__dict)
-
-class ImageMsg(Msg):
-    def __init__(self, toUserName, fromUserName, mediaId):
-        self.__dict = dict()
-        self.__dict['ToUserName'] = toUserName
-        self.__dict['FromUserName'] = fromUserName
-        self.__dict['CreateTime'] = int(time.time())
-        self.__dict['MediaId'] = mediaId
-
-    def send(self):
-        XmlForm = """
-            <xml>
-                <ToUserName><![CDATA[{ToUserName}]]></ToUserName>
-                <FromUserName><![CDATA[{FromUserName}]]></FromUserName>
-                <CreateTime>{CreateTime}</CreateTime>
-                <MsgType><![CDATA[image]]></MsgType>
-                <Image>
-                <MediaId><![CDATA[{MediaId}]]></MediaId>
-                </Image>
-            </xml>
-            """
-        return XmlForm.format(**self.__dict)

channel/wechatmp/wechatmp_channel.py

@@ -1,20 +1,26 @@
 # -*- coding: utf-8 -*-
-import web
+import asyncio
+import imghdr
+import io
+import os
+import threading
 import time
-import math
-import hashlib
-import textwrap
-from channel.chat_channel import ChatChannel
-import channel.wechatmp.reply as reply
-import channel.wechatmp.receive as receive
-from common.expired_dict import ExpiredDict
-from common.singleton import singleton
-from common.log import logger
-from config import conf
-from bridge.reply import *
+
+import requests
+import web
+from wechatpy.crypto import WeChatCrypto
+from wechatpy.exceptions import WeChatClientException
+
 from bridge.context import *
-from plugins import *
-import traceback
+from bridge.reply import *
+from channel.chat_channel import ChatChannel
+from channel.wechatmp.common import *
+from channel.wechatmp.wechatmp_client import WechatMPClient
+from common.log import logger
+from common.singleton import singleton
+from common.utils import split_string_by_utf8_length
+from config import conf
+from voice.audio_convert import any_to_mp3
 
 # If using SSL, uncomment the following lines, and modify the certificate path.
 # from cheroot.server import HTTPServer
@@ -24,245 +30,187 @@ import traceback
 #         private_key='/ssl/cert.key')
 
 
-# from concurrent.futures import ThreadPoolExecutor
-# thread_pool = ThreadPoolExecutor(max_workers=8)
-
-MAX_UTF8_LEN = 2048
 @singleton
 class WechatMPChannel(ChatChannel):
-    NOT_SUPPORT_REPLYTYPE = [ReplyType.IMAGE, ReplyType.VOICE]
-    def __init__(self):
+    def __init__(self, passive_reply=True):
         super().__init__()
-        self.cache_dict = dict()
-        self.running = set()
-        self.query1 = dict()
-        self.query2 = dict()
-        self.query3 = dict()
-        self.received_msgs = ExpiredDict(60*60*24) 
+        self.passive_reply = passive_reply
+        self.NOT_SUPPORT_REPLYTYPE = []
+        appid = conf().get("wechatmp_app_id")
+        secret = conf().get("wechatmp_app_secret")
+        token = conf().get("wechatmp_token")
+        aes_key = conf().get("wechatmp_aes_key")
+        self.client = WechatMPClient(appid, secret)
+        self.crypto = None
+        if aes_key:
+            self.crypto = WeChatCrypto(token, aes_key, appid)
+        if self.passive_reply:
+            # Cache the reply to the user's first message
+            self.cache_dict = dict()
+            # Record whether the current message is being processed
+            self.running = set()
+            # Count the request from wechat official server by message_id
+            self.request_cnt = dict()
+            # The permanent media need to be deleted to avoid media number limit
+            self.delete_media_loop = asyncio.new_event_loop()
+            t = threading.Thread(target=self.start_loop, args=(self.delete_media_loop,))
+            t.setDaemon(True)
+            t.start()
 
     def startup(self):
-        urls = (
-            '/wx', 'SubsribeAccountQuery',
-        )
+        if self.passive_reply:
+            urls = ("/wx", "channel.wechatmp.passive_reply.Query")
+        else:
+            urls = ("/wx", "channel.wechatmp.active_reply.Query")
         app = web.application(urls, globals(), autoreload=False)
-        port = conf().get('wechatmp_port', 8080)
-        web.httpserver.runsimple(app.wsgifunc(), ('0.0.0.0', port))
+        port = conf().get("wechatmp_port", 8080)
+        web.httpserver.runsimple(app.wsgifunc(), ("0.0.0.0", port))
 
+    def start_loop(self, loop):
+        asyncio.set_event_loop(loop)
+        loop.run_forever()
+
+    async def delete_media(self, media_id):
+        logger.debug("[wechatmp] permanent media {} will be deleted in 10s".format(media_id))
+        await asyncio.sleep(10)
+        self.client.material.delete(media_id)
+        logger.info("[wechatmp] permanent media {} has been deleted".format(media_id))
 
     def send(self, reply: Reply, context: Context):
         receiver = context["receiver"]
-        self.cache_dict[receiver] = reply.content
-        self.running.remove(receiver)
-        logger.debug("[send] reply to {} saved to cache: {}".format(receiver, reply))
+        if self.passive_reply:
+            if reply.type == ReplyType.TEXT or reply.type == ReplyType.INFO or reply.type == ReplyType.ERROR:
+                reply_text = reply.content
+                logger.info("[wechatmp] text cached, receiver {}\n{}".format(receiver, reply_text))
+                self.cache_dict[receiver] = ("text", reply_text)
+            elif reply.type == ReplyType.VOICE:
+                try:
+                    voice_file_path = reply.content
+                    with open(voice_file_path, "rb") as f:
+                        # support: <2M, <60s, mp3/wma/wav/amr
+                        response = self.client.material.add("voice", f)
+                        logger.debug("[wechatmp] upload voice response: {}".format(response))
+                        # 根据文件大小估计一个微信自动审核的时间，审核结束前返回将会导致语音无法播放，这个估计有待验证
+                        f_size = os.fstat(f.fileno()).st_size
+                        time.sleep(1.0 + 2 * f_size / 1024 / 1024)
+                        # todo check media_id
+                except WeChatClientException as e:
+                    logger.error("[wechatmp] upload voice failed: {}".format(e))
+                    return
+                media_id = response["media_id"]
+                logger.info("[wechatmp] voice uploaded, receiver {}, media_id {}".format(receiver, media_id))
+                self.cache_dict[receiver] = ("voice", media_id)
 
-    def _fail_callback(self, session_id, exception, context, **kwargs):
-        logger.exception("[wechatmp] Fail to generation message to user, msgId={}, exception={}".format(context['msg'].msg_id, exception))
-        assert session_id not in self.cache_dict
-        self.running.remove(session_id)
-
-
-def verify_server():
-    try:
-        data = web.input()
-        if len(data) == 0:
-            return "None"
-        signature = data.signature
-        timestamp = data.timestamp
-        nonce = data.nonce
-        echostr = data.echostr
-        token = conf().get('wechatmp_token') #请按照公众平台官网\基本配置中信息填写
-
-        data_list = [token, timestamp, nonce]
-        data_list.sort()
-        sha1 = hashlib.sha1()
-        # map(sha1.update, data_list) #python2
-        sha1.update("".join(data_list).encode('utf-8'))
-        hashcode = sha1.hexdigest()
-        print("handle/GET func: hashcode, signature: ", hashcode, signature)
-        if hashcode == signature:
-            return echostr
+            elif reply.type == ReplyType.IMAGE_URL:  # 从网络下载图片
+                img_url = reply.content
+                pic_res = requests.get(img_url, stream=True)
+                image_storage = io.BytesIO()
+                for block in pic_res.iter_content(1024):
+                    image_storage.write(block)
+                image_storage.seek(0)
+                image_type = imghdr.what(image_storage)
+                filename = receiver + "-" + str(context["msg"].msg_id) + "." + image_type
+                content_type = "image/" + image_type
+                try:
+                    response = self.client.material.add("image", (filename, image_storage, content_type))
+                    logger.debug("[wechatmp] upload image response: {}".format(response))
+                except WeChatClientException as e:
+                    logger.error("[wechatmp] upload image failed: {}".format(e))
+                    return
+                media_id = response["media_id"]
+                logger.info("[wechatmp] image uploaded, receiver {}, media_id {}".format(receiver, media_id))
+                self.cache_dict[receiver] = ("image", media_id)
+            elif reply.type == ReplyType.IMAGE:  # 从文件读取图片
+                image_storage = reply.content
+                image_storage.seek(0)
+                image_type = imghdr.what(image_storage)
+                filename = receiver + "-" + str(context["msg"].msg_id) + "." + image_type
+                content_type = "image/" + image_type
+                try:
+                    response = self.client.material.add("image", (filename, image_storage, content_type))
+                    logger.debug("[wechatmp] upload image response: {}".format(response))
+                except WeChatClientException as e:
+                    logger.error("[wechatmp] upload image failed: {}".format(e))
+                    return
+                media_id = response["media_id"]
+                logger.info("[wechatmp] image uploaded, receiver {}, media_id {}".format(receiver, media_id))
+                self.cache_dict[receiver] = ("image", media_id)
         else:
-            return ""
-    except Exception as Argument:
-        return Argument
-
-
-# This class is instantiated once per query
-class SubsribeAccountQuery():
-
-    def GET(self):
-        return verify_server()
-
-    def POST(self):
-        channel = WechatMPChannel()
-        try:
-            query_time = time.time()
-            webData = web.data()
-            logger.debug("[wechatmp] Receive request:\n" + webData.decode("utf-8"))
-            wechat_msg = receive.parse_xml(webData)
-            if wechat_msg.msg_type == 'text':
-                from_user = wechat_msg.from_user_id
-                to_user = wechat_msg.to_user_id
-                message = wechat_msg.content.decode("utf-8")
-                message_id = wechat_msg.msg_id
-
-                logger.info("[wechatmp] {}:{} Receive post query {} {}: {}".format(web.ctx.env.get('REMOTE_ADDR'), web.ctx.env.get('REMOTE_PORT'), from_user, message_id, message))
-                supported = True
-                if "【收到不支持的消息类型，暂无法显示】" in message:
-                    supported = False # not supported, used to refresh
-                cache_key = from_user
-
-                reply_text = ""
-                # New request
-                if cache_key not in channel.cache_dict and cache_key not in channel.running:
-                    # The first query begin, reset the cache
-                    context = channel._compose_context(ContextType.TEXT, message, isgroup=False, msg=wechat_msg)
-                    logger.debug("[wechatmp] context: {} {}".format(context, wechat_msg))
-                    if message_id in channel.received_msgs: # received and finished
-                        return 
-                    if supported and context:
-                        # set private openai_api_key
-                        # if from_user is not changed in itchat, this can be placed at chat_channel
-                        user_data = conf().get_user_data(from_user)
-                        context['openai_api_key'] = user_data.get('openai_api_key') # None or user openai_api_key
-                        channel.received_msgs[message_id] = wechat_msg
-                        channel.running.add(cache_key)
-                        channel.produce(context)
+            if reply.type == ReplyType.TEXT or reply.type == ReplyType.INFO or reply.type == ReplyType.ERROR:
+                reply_text = reply.content
+                texts = split_string_by_utf8_length(reply_text, MAX_UTF8_LEN)
+                if len(texts) > 1:
+                    logger.info("[wechatmp] text too long, split into {} parts".format(len(texts)))
+                for i, text in enumerate(texts):
+                    self.client.message.send_text(receiver, text)
+                    if i != len(texts) - 1:
+                        time.sleep(0.5)  # 休眠0.5秒，防止发送过快乱序
+                logger.info("[wechatmp] Do send text to {}: {}".format(receiver, reply_text))
+            elif reply.type == ReplyType.VOICE:
+                try:
+                    file_path = reply.content
+                    file_name = os.path.basename(file_path)
+                    file_type = os.path.splitext(file_name)[1]
+                    if file_type == ".mp3":
+                        file_type = "audio/mpeg"
+                    elif file_type == ".amr":
+                        file_type = "audio/amr"
                     else:
-                        trigger_prefix = conf().get('single_chat_prefix',[''])[0]
-                        if trigger_prefix or not supported:
-                            if trigger_prefix:
-                                content = textwrap.dedent(f"""\
-                                    请输入'{trigger_prefix}'接你想说的话跟我说话。
-                                    例如:
-                                    {trigger_prefix}你好，很高兴见到你。""")
-                            else:
-                                content = textwrap.dedent("""\
-                                    你好，很高兴见到你。
-                                    请跟我说话吧。""")
-                        else:
-                            logger.error(f"[wechatmp] unknown error")
-                            content = textwrap.dedent("""\
-                                未知错误，请稍后再试""")
-                        replyMsg = reply.TextMsg(wechat_msg.from_user_id, wechat_msg.to_user_id, content)
-                        return replyMsg.send()
-                    channel.query1[cache_key] = False
-                    channel.query2[cache_key] = False
-                    channel.query3[cache_key] = False
-                # Request again
-                elif cache_key in channel.running and channel.query1.get(cache_key) == True and channel.query2.get(cache_key) == True and channel.query3.get(cache_key) == True:
-                    channel.query1[cache_key] = False  #To improve waiting experience, this can be set to True.
-                    channel.query2[cache_key] = False  #To improve waiting experience, this can be set to True.
-                    channel.query3[cache_key] = False
-                elif cache_key in channel.cache_dict:
-                    # Skip the waiting phase
-                    channel.query1[cache_key] = True
-                    channel.query2[cache_key] = True
-                    channel.query3[cache_key] = True
+                        mp3_file = os.path.splitext(file_path)[0] + ".mp3"
+                        any_to_mp3(file_path, mp3_file)
+                        file_path = mp3_file
+                        file_name = os.path.basename(file_path)
+                        file_type = "audio/mpeg"
+                    logger.info("[wechatmp] file_name: {}, file_type: {} ".format(file_name, file_type))
+                    # support: <2M, <60s, AMR\MP3
+                    response = self.client.media.upload("voice", (file_name, open(file_path, "rb"), file_type))
+                    logger.debug("[wechatmp] upload voice response: {}".format(response))
+                except WeChatClientException as e:
+                    logger.error("[wechatmp] upload voice failed: {}".format(e))
+                    return
+                self.client.message.send_voice(receiver, response["media_id"])
+                logger.info("[wechatmp] Do send voice to {}".format(receiver))
+            elif reply.type == ReplyType.IMAGE_URL:  # 从网络下载图片
+                img_url = reply.content
+                pic_res = requests.get(img_url, stream=True)
+                image_storage = io.BytesIO()
+                for block in pic_res.iter_content(1024):
+                    image_storage.write(block)
+                image_storage.seek(0)
+                image_type = imghdr.what(image_storage)
+                filename = receiver + "-" + str(context["msg"].msg_id) + "." + image_type
+                content_type = "image/" + image_type
+                try:
+                    response = self.client.media.upload("image", (filename, image_storage, content_type))
+                    logger.debug("[wechatmp] upload image response: {}".format(response))
+                except WeChatClientException as e:
+                    logger.error("[wechatmp] upload image failed: {}".format(e))
+                    return
+                self.client.message.send_image(receiver, response["media_id"])
+                logger.info("[wechatmp] Do send image to {}".format(receiver))
+            elif reply.type == ReplyType.IMAGE:  # 从文件读取图片
+                image_storage = reply.content
+                image_storage.seek(0)
+                image_type = imghdr.what(image_storage)
+                filename = receiver + "-" + str(context["msg"].msg_id) + "." + image_type
+                content_type = "image/" + image_type
+                try:
+                    response = self.client.media.upload("image", (filename, image_storage, content_type))
+                    logger.debug("[wechatmp] upload image response: {}".format(response))
+                except WeChatClientException as e:
+                    logger.error("[wechatmp] upload image failed: {}".format(e))
+                    return
+                self.client.message.send_image(receiver, response["media_id"])
+                logger.info("[wechatmp] Do send image to {}".format(receiver))
+        return
 
-                assert not (cache_key in channel.cache_dict and cache_key in channel.running)
+    def _success_callback(self, session_id, context, **kwargs):  # 线程异常结束时的回调函数
+        logger.debug("[wechatmp] Success to generate reply, msgId={}".format(context["msg"].msg_id))
+        if self.passive_reply:
+            self.running.remove(session_id)
 
-                if channel.query1.get(cache_key) == False:
-                    # The first query from wechat official server
-                    logger.debug("[wechatmp] query1 {}".format(cache_key))
-                    channel.query1[cache_key] = True
-                    cnt = 0
-                    while cache_key not in channel.cache_dict and cnt < 45:
-                        cnt = cnt + 1
-                        time.sleep(0.1)
-                    if cnt == 45:
-                        # waiting for timeout (the POST query will be closed by wechat official server)
-                        time.sleep(1)
-                        # and do nothing
-                        return
-                    else:
-                        pass
-                elif channel.query2.get(cache_key) == False:
-                    # The second query from wechat official server
-                    logger.debug("[wechatmp] query2 {}".format(cache_key))
-                    channel.query2[cache_key] = True
-                    cnt = 0
-                    while cache_key not in channel.cache_dict and cnt < 45:
-                        cnt = cnt + 1
-                        time.sleep(0.1)
-                    if cnt == 45:
-                        # waiting for timeout (the POST query will be closed by wechat official server)
-                        time.sleep(1)
-                        # and do nothing
-                        return
-                    else:
-                        pass
-                elif channel.query3.get(cache_key) == False:
-                    # The third query from wechat official server
-                    logger.debug("[wechatmp] query3 {}".format(cache_key))
-                    channel.query3[cache_key] = True
-                    cnt = 0
-                    while cache_key not in channel.cache_dict and cnt < 40:
-                        cnt = cnt + 1
-                        time.sleep(0.1)
-                    if cnt == 40:
-                        # Have waiting for 3x5 seconds
-                        # return timeout message
-                        reply_text = "【正在思考中，回复任意文字尝试获取回复】"
-                        logger.info("[wechatmp] Three queries has finished For {}: {}".format(from_user, message_id))
-                        replyPost = reply.TextMsg(from_user, to_user, reply_text).send()
-                        return replyPost
-                    else:
-                        pass
-
-                if float(time.time()) - float(query_time) > 4.8:
-                    reply_text = "【正在思考中，回复任意文字尝试获取回复】"
-                    logger.info("[wechatmp] Timeout for {} {}, return".format(from_user, message_id))
-                    replyPost = reply.TextMsg(from_user, to_user, reply_text).send()
-                    return replyPost
-                
-                if cache_key in channel.cache_dict:
-                    content = channel.cache_dict[cache_key]
-                    if len(content.encode('utf8'))<=MAX_UTF8_LEN:
-                        reply_text = channel.cache_dict[cache_key]
-                        channel.cache_dict.pop(cache_key)
-                    else:
-                        continue_text = "\n【未完待续，回复任意文字以继续】"
-                        splits = split_string_by_utf8_length(content, MAX_UTF8_LEN - len(continue_text.encode('utf-8')), max_split= 1)
-                        reply_text = splits[0] + continue_text
-                        channel.cache_dict[cache_key] = splits[1]
-                logger.info("[wechatmp] {}:{} Do send {}".format(web.ctx.env.get('REMOTE_ADDR'), web.ctx.env.get('REMOTE_PORT'), reply_text))
-                replyPost = reply.TextMsg(from_user, to_user, reply_text).send()
-                return replyPost
-
-            elif wechat_msg.msg_type == 'event':
-                logger.info("[wechatmp] Event {} from {}".format(wechat_msg.content, wechat_msg.from_user_id))
-                trigger_prefix = conf().get('single_chat_prefix',[''])[0]
-                content = textwrap.dedent(f"""\
-                    感谢您的关注！
-                    这里是ChatGPT，可以自由对话。
-                    资源有限，回复较慢，请勿着急。
-                    支持通用表情输入。
-                    暂时不支持图片输入。
-                    支持图片输出，画字开头的问题将回复图片链接。
-                    支持角色扮演和文字冒险两种定制模式对话。
-                    输入'{trigger_prefix}#帮助' 查看详细指令。""")
-                replyMsg = reply.TextMsg(wechat_msg.from_user_id, wechat_msg.to_user_id, content)
-                return replyMsg.send()
-            else:
-                logger.info("暂且不处理")
-                return "success"
-        except Exception as exc:
-            logger.exception(exc)
-            return exc
-
-def split_string_by_utf8_length(string, max_length, max_split=0):
-    encoded = string.encode('utf-8')
-    start, end = 0, 0
-    result = []
-    while end < len(encoded):
-        if max_split > 0 and len(result) >= max_split:
-            result.append(encoded[start:].decode('utf-8'))
-            break
-        end = start + max_length
-        # 如果当前字节不是 UTF-8 编码的开始字节，则向前查找直到找到开始字节为止
-        while end < len(encoded) and (encoded[end] & 0b11000000) == 0b10000000:
-            end -= 1
-        result.append(encoded[start:end].decode('utf-8'))
-        start = end
-    return result
+    def _fail_callback(self, session_id, exception, context, **kwargs):  # 线程异常结束时的回调函数
+        logger.exception("[wechatmp] Fail to generate reply to user, msgId={}, exception={}".format(context["msg"].msg_id, exception))
+        if self.passive_reply:
+            assert session_id not in self.cache_dict
+            self.running.remove(session_id)

channel/wechatmp/wechatmp_client.py

@@ -0,0 +1,49 @@
+import threading
+import time
+
+from wechatpy.client import WeChatClient
+from wechatpy.exceptions import APILimitedException
+
+from channel.wechatmp.common import *
+from common.log import logger
+
+
+class WechatMPClient(WeChatClient):
+    def __init__(self, appid, secret, access_token=None, session=None, timeout=None, auto_retry=True):
+        super(WechatMPClient, self).__init__(appid, secret, access_token, session, timeout, auto_retry)
+        self.fetch_access_token_lock = threading.Lock()
+        self.clear_quota_lock = threading.Lock()
+        self.last_clear_quota_time = -1
+
+    def clear_quota(self):
+        return self.post("clear_quota", data={"appid": self.appid})
+
+    def clear_quota_v2(self):
+        return self.post("clear_quota/v2", params={"appid": self.appid, "appsecret": self.secret})
+
+    def fetch_access_token(self):  # 重载父类方法，加锁避免多线程重复获取access_token
+        with self.fetch_access_token_lock:
+            access_token = self.session.get(self.access_token_key)
+            if access_token:
+                if not self.expires_at:
+                    return access_token
+                timestamp = time.time()
+                if self.expires_at - timestamp > 60:
+                    return access_token
+            return super().fetch_access_token()
+
+    def _request(self, method, url_or_endpoint, **kwargs):  # 重载父类方法，遇到API限流时，清除quota后重试
+        try:
+            return super()._request(method, url_or_endpoint, **kwargs)
+        except APILimitedException as e:
+            logger.error("[wechatmp] API quata has been used up. {}".format(e))
+            if self.last_clear_quota_time == -1 or time.time() - self.last_clear_quota_time > 60:
+                with self.clear_quota_lock:
+                    if self.last_clear_quota_time == -1 or time.time() - self.last_clear_quota_time > 60:
+                        self.last_clear_quota_time = time.time()
+                        response = self.clear_quota_v2()
+                        logger.debug("[wechatmp] API quata has been cleard, {}".format(response))
+                return super()._request(method, url_or_endpoint, **kwargs)
+            else:
+                logger.error("[wechatmp] last clear quota time is {}, less than 60s, skip clear quota")
+                raise e

channel/wechatmp/wechatmp_message.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-#
+
+from bridge.context import ContextType
+from channel.chat_message import ChatMessage
+from common.log import logger
+from common.tmp_dir import TmpDir
+
+
+class WeChatMPMessage(ChatMessage):
+    def __init__(self, msg, client=None):
+        super().__init__(msg)
+        self.msg_id = msg.id
+        self.create_time = msg.time
+        self.is_group = False
+
+        if msg.type == "text":
+            self.ctype = ContextType.TEXT
+            self.content = msg.content
+        elif msg.type == "voice":
+            if msg.recognition == None:
+                self.ctype = ContextType.VOICE
+                self.content = TmpDir().path() + msg.media_id + "." + msg.format  # content直接存临时目录路径
+
+                def download_voice():
+                    # 如果响应状态码是200，则将响应内容写入本地文件
+                    response = client.media.download(msg.media_id)
+                    if response.status_code == 200:
+                        with open(self.content, "wb") as f:
+                            f.write(response.content)
+                    else:
+                        logger.info(f"[wechatmp] Failed to download voice file, {response.content}")
+
+                self._prepare_fn = download_voice
+            else:
+                self.ctype = ContextType.TEXT
+                self.content = msg.recognition
+        elif msg.type == "image":
+            self.ctype = ContextType.IMAGE
+            self.content = TmpDir().path() + msg.media_id + ".png"  # content直接存临时目录路径
+
+            def download_image():
+                # 如果响应状态码是200，则将响应内容写入本地文件
+                response = client.media.download(msg.media_id)
+                if response.status_code == 200:
+                    with open(self.content, "wb") as f:
+                        f.write(response.content)
+                else:
+                    logger.info(f"[wechatmp] Failed to download image file, {response.content}")
+
+            self._prepare_fn = download_image
+        else:
+            raise NotImplementedError("Unsupported message type: Type:{} ".format(msg.type))
+
+        self.from_user_id = msg.source
+        self.to_user_id = msg.target
+        self.other_user_id = msg.source

common/const.py

@@ -2,4 +2,6 @@
 OPEN_AI = "openAI"
 CHATGPT = "chatGPT"
 BAIDU = "baidu"
-CHATGPTONAZURE = "chatGPTOnAzure"
+CHATGPTONAZURE = "chatGPTOnAzure"
+
+VERSION = "1.3.0"

common/dequeue.py

@@ -1,7 +1,7 @@
-
 from queue import Full, Queue
 from time import monotonic as time
 
+
 # add implementation of putleft to Queue
 class Dequeue(Queue):
     def putleft(self, item, block=True, timeout=None):
@@ -30,4 +30,4 @@ class Dequeue(Queue):
         return self.putleft(item, block=False)
 
     def _putleft(self, item):
-        self.queue.appendleft(item)
+        self.queue.appendleft(item)

common/expired_dict.py

@@ -39,4 +39,4 @@ class ExpiredDict(dict):
         return [(key, self[key]) for key in self.keys()]
 
     def __iter__(self):
-        return self.keys().__iter__()
+        return self.keys().__iter__()

common/log.py

@@ -10,20 +10,29 @@ def _reset_logger(log):
     log.handlers.clear()
     log.propagate = False
     console_handle = logging.StreamHandler(sys.stdout)
-    console_handle.setFormatter(logging.Formatter('[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d] - %(message)s',
-                                                  datefmt='%Y-%m-%d %H:%M:%S'))
-    file_handle = logging.FileHandler('run.log', encoding='utf-8')
-    file_handle.setFormatter(logging.Formatter('[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d] - %(message)s',
-                                                  datefmt='%Y-%m-%d %H:%M:%S'))
+    console_handle.setFormatter(
+        logging.Formatter(
+            "[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d] - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+    )
+    file_handle = logging.FileHandler("run.log", encoding="utf-8")
+    file_handle.setFormatter(
+        logging.Formatter(
+            "[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d] - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+    )
     log.addHandler(file_handle)
     log.addHandler(console_handle)
 
+
 def _get_logger():
-    log = logging.getLogger('log')
+    log = logging.getLogger("log")
     _reset_logger(log)
     log.setLevel(logging.INFO)
     return log
 
 
 # 日志句柄
-logger = _get_logger()
+logger = _get_logger()

common/package_manager.py

@@ -1,15 +1,20 @@
 import time
+
 import pip
 from pip._internal import main as pipmain
-from common.log import logger,_reset_logger
+
+from common.log import _reset_logger, logger
+
 
 def install(package):
-    pipmain(['install', package])
+    pipmain(["install", package])
+
 
 def install_requirements(file):
-    pipmain(['install', '-r', file, "--upgrade"])
+    pipmain(["install", "-r", file, "--upgrade"])
     _reset_logger(logger)
 
+
 def check_dulwich():
     needwait = False
     for i in range(2):
@@ -18,13 +23,14 @@ def check_dulwich():
             needwait = False
         try:
             import dulwich
+
             return
         except ImportError:
             try:
-                install('dulwich')
+                install("dulwich")
             except:
                 needwait = True
     try:
         import dulwich
     except ImportError:
-        raise ImportError("Unable to import dulwich")
+        raise ImportError("Unable to import dulwich")

common/sorted_dict.py

@@ -62,4 +62,4 @@ class SortedDict(dict):
         return iter(self.keys())
 
     def __repr__(self):
-        return f'{type(self).__name__}({dict(self)}, sort_func={self.sort_func.__name__}, reverse={self.reverse})'
+        return f"{type(self).__name__}({dict(self)}, sort_func={self.sort_func.__name__}, reverse={self.reverse})"

common/time_check.py

@@ -1,7 +1,11 @@
-import time,re,hashlib
+import hashlib
+import re
+import time
+
 import config
 from common.log import logger
 
+
 def time_checker(f):
     def _time_checker(self, *args, **kwargs):
         _config = config.conf()
@@ -9,17 +13,17 @@ def time_checker(f):
         if chat_time_module:
             chat_start_time = _config.get("chat_start_time", "00:00")
             chat_stopt_time = _config.get("chat_stop_time", "24:00")
-            time_regex = re.compile(r'^([01]?[0-9]|2[0-4])(:)([0-5][0-9])$')  #时间匹配，包含24:00
+            time_regex = re.compile(r"^([01]?[0-9]|2[0-4])(:)([0-5][0-9])$")  # 时间匹配，包含24:00
 
             starttime_format_check = time_regex.match(chat_start_time)  # 检查停止时间格式
             stoptime_format_check = time_regex.match(chat_stopt_time)  # 检查停止时间格式
-            chat_time_check = chat_start_time < chat_stopt_time # 确定启动时间<停止时间
+            chat_time_check = chat_start_time < chat_stopt_time  # 确定启动时间<停止时间
 
             # 时间格式检查
             if not (starttime_format_check and stoptime_format_check and chat_time_check):
-                logger.warn('时间格式不正确,请在config.json中修改您的CHAT_START_TIME/CHAT_STOP_TIME,否则可能会影响您正常使用,开始({})-结束({})'.format(starttime_format_check,stoptime_format_check))
-            if chat_start_time>"23:59":
-                logger.error('启动时间可能存在问题，请修改!')
+                logger.warn("时间格式不正确,请在config.json中修改您的CHAT_START_TIME/CHAT_STOP_TIME,否则可能会影响您正常使用,开始({})-结束({})".format(starttime_format_check, stoptime_format_check))
+            if chat_start_time > "23:59":
+                logger.error("启动时间可能存在问题，请修改!")
 
             # 服务时间检查
             now_time = time.strftime("%H:%M", time.localtime())
@@ -27,12 +31,12 @@ def time_checker(f):
                 f(self, *args, **kwargs)
                 return None
             else:
-                if args[0]['Content'] == "#更新配置":  # 不在服务时间内也可以更新配置
+                if args[0]["Content"] == "#更新配置":  # 不在服务时间内也可以更新配置
                     f(self, *args, **kwargs)
                 else:
-                    logger.info('非服务时间内,不接受访问')
+                    logger.info("非服务时间内,不接受访问")
                     return None
         else:
             f(self, *args, **kwargs)  # 未开启时间模块则直接回答
-    return _time_checker
 
+    return _time_checker

common/tmp_dir.py

@@ -1,20 +1,18 @@
-
 import os
 import pathlib
+
 from config import conf
 
 
 class TmpDir(object):
-    """A temporary directory that is deleted when the object is destroyed.
-    """
+    """A temporary directory that is deleted when the object is destroyed."""
+
+    tmpFilePath = pathlib.Path("./tmp/")
 
-    tmpFilePath = pathlib.Path('./tmp/')
-    
     def __init__(self):
         pathExists = os.path.exists(self.tmpFilePath)
-        if not pathExists and conf().get('speech_recognition') == True:
+        if not pathExists:
             os.makedirs(self.tmpFilePath)
 
     def path(self):
-        return str(self.tmpFilePath) + '/'
-    
+        return str(self.tmpFilePath) + "/"

common/utils.py

@@ -0,0 +1,51 @@
+import io
+import os
+
+from PIL import Image
+
+
+def fsize(file):
+    if isinstance(file, io.BytesIO):
+        return file.getbuffer().nbytes
+    elif isinstance(file, str):
+        return os.path.getsize(file)
+    elif hasattr(file, "seek") and hasattr(file, "tell"):
+        pos = file.tell()
+        file.seek(0, os.SEEK_END)
+        size = file.tell()
+        file.seek(pos)
+        return size
+    else:
+        raise TypeError("Unsupported type")
+
+
+def compress_imgfile(file, max_size):
+    if fsize(file) <= max_size:
+        return file
+    file.seek(0)
+    img = Image.open(file)
+    rgb_image = img.convert("RGB")
+    quality = 95
+    while True:
+        out_buf = io.BytesIO()
+        rgb_image.save(out_buf, "JPEG", quality=quality)
+        if fsize(out_buf) <= max_size:
+            return out_buf
+        quality -= 5
+
+
+def split_string_by_utf8_length(string, max_length, max_split=0):
+    encoded = string.encode("utf-8")
+    start, end = 0, 0
+    result = []
+    while end < len(encoded):
+        if max_split > 0 and len(result) >= max_split:
+            result.append(encoded[start:].decode("utf-8"))
+            break
+        end = min(start + max_length, len(encoded))
+        # 如果当前字节不是 UTF-8 编码的开始字节，则向前查找直到找到开始字节为止
+        while end < len(encoded) and (encoded[end] & 0b11000000) == 0b10000000:
+            end -= 1
+        result.append(encoded[start:end].decode("utf-8"))
+        start = end
+    return result

config-template.json

@@ -2,17 +2,31 @@
   "open_ai_api_key": "YOUR API KEY",
   "model": "gpt-3.5-turbo",
   "proxy": "",
-  "use_azure_chatgpt": false,
-  "single_chat_prefix": ["bot", "@bot"],
+  "single_chat_prefix": [
+    "bot",
+    "@bot"
+  ],
   "single_chat_reply_prefix": "[bot] ",
-  "group_chat_prefix": ["@bot"],
-  "group_name_white_list": ["ChatGPT测试群", "ChatGPT测试群2"],
-  "group_chat_in_one_session": ["ChatGPT测试群"],
-  "image_create_prefix": ["画", "看", "找"],
+  "group_chat_prefix": [
+    "@bot"
+  ],
+  "group_name_white_list": [
+    "ChatGPT测试群",
+    "ChatGPT测试群2"
+  ],
+  "group_chat_in_one_session": [
+    "ChatGPT测试群"
+  ],
+  "image_create_prefix": [
+    "画",
+    "看",
+    "找"
+  ],
   "speech_recognition": false,
   "group_speech_recognition": false,
   "voice_reply_voice": false,
   "conversation_max_tokens": 1000,
   "expires_in_seconds": 3600,
-  "character_desc": "你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。"
-}
+  "character_desc": "你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。",
+  "subscribe_msg": "感谢您的关注！\n这里是ChatGPT，可以自由对话。\n支持语音对话。\n支持图片输入。\n支持图片输出，画字开头的消息将按要求创作图片。\n支持tool、角色扮演和文字冒险等丰富的插件。\n输入{trigger_prefix}#help 查看详细指令。"
+}

config.py

@@ -3,10 +3,12 @@
 import json
 import logging
 import os
-from common.log import logger
 import pickle
 
+from common.log import logger
+
 # 将所有可用的配置项写在字典里, 请使用小写字母
+# 此处的配置值无实际意义，程序不会读取此处的配置，仅用于提示格式，请将配置加入到config.json中
 available_setting = {
     # openai api配置
     "open_ai_api_key": "",  # openai api key
@@ -16,7 +18,7 @@ available_setting = {
     # chatgpt模型， 当use_azure_chatgpt为true时，其名称为Azure上model deployment名称
     "model": "gpt-3.5-turbo",
     "use_azure_chatgpt": False,  # 是否使用azure的chatgpt
-
+    "azure_deployment_id": "",  # azure 模型部署名称
     # Bot触发配置
     "single_chat_prefix": ["bot", "@bot"],  # 私聊时文本需要包含该前缀才能触发机器人回复
     "single_chat_reply_prefix": "[bot] ",  # 私聊时自动回复的前缀，用于区分真人
@@ -29,75 +31,84 @@ available_setting = {
     "group_chat_in_one_session": ["ChatGPT测试群"],  # 支持会话上下文共享的群名称
     "trigger_by_self": False,  # 是否允许机器人触发
     "image_create_prefix": ["画", "看", "找"],  # 开启图片回复的前缀
-    "concurrency_in_session": 1, # 同一会话最多有多少条消息在处理中，大于1可能乱序
-
+    "concurrency_in_session": 1,  # 同一会话最多有多少条消息在处理中，大于1可能乱序
+    "image_create_size": "256x256",  # 图片大小,可选有 256x256, 512x512, 1024x1024
     # chatgpt会话参数
     "expires_in_seconds": 3600,  # 无操作会话的过期时间
     "character_desc": "你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。",  # 人格描述
     "conversation_max_tokens": 1000,  # 支持上下文记忆的最多字符数
-
     # chatgpt限流配置
     "rate_limit_chatgpt": 20,  # chatgpt的调用频率限制
     "rate_limit_dalle": 50,  # openai dalle的调用频率限制
-
     # chatgpt api参数 参考https://platform.openai.com/docs/api-reference/chat/create
     "temperature": 0.9,
     "top_p": 1,
     "frequency_penalty": 0,
     "presence_penalty": 0,
-    "request_timeout": 60, # chatgpt请求超时时间，openai接口默认设置为600，对于难问题一般需要较长时间
-    "timeout": 120,         # chatgpt重试超时时间，在这个时间内，将会自动重试
-
+    "request_timeout": 60,  # chatgpt请求超时时间，openai接口默认设置为600，对于难问题一般需要较长时间
+    "timeout": 120,  # chatgpt重试超时时间，在这个时间内，将会自动重试
     # 语音设置
     "speech_recognition": False,  # 是否开启语音识别
     "group_speech_recognition": False,  # 是否开启群组语音识别
     "voice_reply_voice": False,  # 是否使用语音回复语音，需要设置对应语音合成引擎的api key
     "always_reply_voice": False,  # 是否一直使用语音回复
-    "voice_to_text": "openai",  # 语音识别引擎，支持openai,google,azure
+    "voice_to_text": "openai",  # 语音识别引擎，支持openai,baidu,google,azure
     "text_to_voice": "baidu",  # 语音合成引擎，支持baidu,google,pytts(offline),azure
-
     # baidu 语音api配置， 使用百度语音识别和语音合成时需要
     "baidu_app_id": "",
     "baidu_api_key": "",
     "baidu_secret_key": "",
     # 1536普通话(支持简单的英文识别) 1737英语 1637粤语 1837四川话 1936普通话远场
     "baidu_dev_pid": "1536",
-
     # azure 语音api配置， 使用azure语音识别和语音合成时需要
     "azure_voice_api_key": "",
     "azure_voice_region": "japaneast",
-
     # 服务时间限制，目前支持itchat
     "chat_time_module": False,  # 是否开启服务时间限制
     "chat_start_time": "00:00",  # 服务开始时间
     "chat_stop_time": "24:00",  # 服务结束时间
-
+    # 翻译api
+    "translate": "baidu",  # 翻译api，支持baidu
+    # baidu翻译api的配置
+    "baidu_translate_app_id": "",  # 百度翻译api的appid
+    "baidu_translate_app_key": "",  # 百度翻译api的秘钥
     # itchat的配置
     "hot_reload": False,  # 是否开启热重载
-
     # wechaty的配置
     "wechaty_puppet_service_token": "",  # wechaty的token
-
     # wechatmp的配置
     "wechatmp_token": "",  # 微信公众平台的Token
-    "wechatmp_port": 8080, # 微信公众平台的端口,需要端口转发到80或443
-
+    "wechatmp_port": 8080,  # 微信公众平台的端口,需要端口转发到80或443
+    "wechatmp_app_id": "",  # 微信公众平台的appID
+    "wechatmp_app_secret": "",  # 微信公众平台的appsecret
+    "wechatmp_aes_key": "",  # 微信公众平台的EncodingAESKey，加密模式需要
+    # wechatcom的通用配置
+    "wechatcom_corp_id": "",  # 企业微信公司的corpID
+    # wechatcomapp的配置
+    "wechatcomapp_token": "",  # 企业微信app的token
+    "wechatcomapp_port": 9898,  # 企业微信app的服务端口,不需要端口转发
+    "wechatcomapp_secret": "",  # 企业微信app的secret
+    "wechatcomapp_agent_id": "",  # 企业微信app的agent_id
+    "wechatcomapp_aes_key": "",  # 企业微信app的aes_key
     # chatgpt指令自定义触发词
-    "clear_memory_commands": ['#清除记忆'],  # 重置会话指令，必须以#开头
-
+    "clear_memory_commands": ["#清除记忆"],  # 重置会话指令，必须以#开头
     # channel配置
-    "channel_type": "wx", # 通道类型，支持：{wx,wxy,terminal,wechatmp}
-
+    "channel_type": "wx",  # 通道类型，支持：{wx,wxy,terminal,wechatmp,wechatmp_service,wechatcom_app}
+    "subscribe_msg": "",  # 订阅消息, 支持: wechatmp, wechatmp_service, wechatcom_app
     "debug": False,  # 是否开启debug模式，开启后会打印更多日志
-
+    "appdata_dir": "",  # 数据目录
     # 插件配置
     "plugin_trigger_prefix": "$",  # 规范插件提供聊天相关指令的前缀，建议不要和管理员指令前缀"#"冲突
 }
 
 
 class Config(dict):
-    def __init__(self, d:dict={}):
-        super().__init__(d)
+    def __init__(self, d=None):
+        super().__init__()
+        if d is None:
+            d = {}
+        for k, v in d.items():
+            self[k] = v
         # user_datas: 用户数据，key为用户名，value为用户数据，也是dict
         self.user_datas = {}
 
@@ -127,7 +138,7 @@ class Config(dict):
 
     def load_user_datas(self):
         try:
-            with open('user_datas.pkl', 'rb') as f:
+            with open(os.path.join(get_appdata_dir(), "user_datas.pkl"), "rb") as f:
                 self.user_datas = pickle.load(f)
                 logger.info("[Config] User datas loaded.")
         except FileNotFoundError as e:
@@ -138,12 +149,13 @@ class Config(dict):
 
     def save_user_datas(self):
         try:
-            with open('user_datas.pkl', 'wb') as f:
+            with open(os.path.join(get_appdata_dir(), "user_datas.pkl"), "wb") as f:
                 pickle.dump(self.user_datas, f)
                 logger.info("[Config] User datas saved.")
         except Exception as e:
             logger.info("[Config] User datas error: {}".format(e))
 
+
 config = Config()
 
 
@@ -151,7 +163,7 @@ def load_config():
     global config
     config_path = "./config.json"
     if not os.path.exists(config_path):
-        logger.info('配置文件不存在，将使用config-template.json模板')
+        logger.info("配置文件不存在，将使用config-template.json模板")
         config_path = "./config-template.json"
 
     config_str = read_file(config_path)
@@ -165,8 +177,7 @@ def load_config():
     for name, value in os.environ.items():
         name = name.lower()
         if name in available_setting:
-            logger.info(
-                "[INIT] override config by environ args: {}={}".format(name, value))
+            logger.info("[INIT] override config by environ args: {}={}".format(name, value))
             try:
                 config[name] = eval(value)
             except:
@@ -179,20 +190,35 @@ def load_config():
 
     if config.get("debug", False):
         logger.setLevel(logging.DEBUG)
-        logger.debug("[INIT] set log level to DEBUG")        
+        logger.debug("[INIT] set log level to DEBUG")
 
     logger.info("[INIT] load config: {}".format(config))
 
     config.load_user_datas()
 
+
 def get_root():
     return os.path.dirname(os.path.abspath(__file__))
 
 
 def read_file(path):
-    with open(path, mode='r', encoding='utf-8') as f:
+    with open(path, mode="r", encoding="utf-8") as f:
         return f.read()
 
 
 def conf():
     return config
+
+
+def get_appdata_dir():
+    data_path = os.path.join(get_root(), conf().get("appdata_dir", ""))
+    if not os.path.exists(data_path):
+        logger.info("[INIT] data path not exists, create it: {}".format(data_path))
+        os.makedirs(data_path)
+    return data_path
+
+
+def subscribe_msg():
+    trigger_prefix = conf().get("single_chat_prefix", [""])[0]
+    msg = conf().get("subscribe_msg", "")
+    return msg.format(trigger_prefix=trigger_prefix)

docker/Dockerfile.alpine

@@ -22,8 +22,8 @@ RUN apk add --no-cache \
     && cd ${BUILD_PREFIX} \
     && cp config-template.json ${BUILD_PREFIX}/config.json \
     && /usr/local/bin/python -m pip install --no-cache --upgrade pip \
-    && pip install --no-cache -r requirements.txt \
-    && pip install --no-cache -r requirements-optional.txt \
+    && pip install --no-cache -r requirements.txt --extra-index-url https://alpine-wheels.github.io/index\
+    && pip install --no-cache -r requirements-optional.txt --extra-index-url https://alpine-wheels.github.io/index\
     && apk del curl wget
 
 WORKDIR ${BUILD_PREFIX}

docker/Dockerfile.alpine.latest

@@ -1,4 +1,4 @@
-FROM python:3.10-slim
+FROM python:3.10-alpine
 
 LABEL maintainer="foo@bar.com"
 ARG TZ='Asia/Shanghai'
@@ -9,23 +9,19 @@ ENV BUILD_PREFIX=/app
 
 ADD . ${BUILD_PREFIX}
 
-RUN apt-get update \
-    &&apt-get install -y --no-install-recommends  bash \
-    ffmpeg espeak \
+RUN apk add --no-cache bash ffmpeg espeak \
     && cd ${BUILD_PREFIX} \
     && cp config-template.json config.json \
     && /usr/local/bin/python -m pip install --no-cache --upgrade pip \
-    && pip install --no-cache -r requirements.txt \
-    && pip install --no-cache -r requirements-optional.txt \
-    && pip install azure-cognitiveservices-speech
-    
+    && pip install --no-cache -r requirements.txt --extra-index-url https://alpine-wheels.github.io/index\
+    && pip install --no-cache -r requirements-optional.txt --extra-index-url https://alpine-wheels.github.io/index
+
 WORKDIR ${BUILD_PREFIX}
 
 ADD docker/entrypoint.sh /entrypoint.sh
 
 RUN chmod +x /entrypoint.sh \
-    && groupadd -r noroot \
-    && useradd -r -g noroot -s /bin/bash -d /home/noroot noroot \
+    && adduser -D -h /home/noroot -u 1000 -s /bin/bash noroot \
     && chown -R noroot:noroot ${BUILD_PREFIX}
 
 USER noroot

docker/Dockerfile.debian

@@ -33,7 +33,7 @@ ADD ./entrypoint.sh /entrypoint.sh
 RUN chmod +x /entrypoint.sh \
     && groupadd -r noroot \
     && useradd -r -g noroot -s /bin/bash -d /home/noroot noroot \
-    && chown -R noroot:noroot ${BUILD_PREFIX} 
+    && chown -R noroot:noroot ${BUILD_PREFIX}
 
 USER noroot
 

docker/Dockerfile.latest

@@ -1,27 +1,32 @@
-FROM python:3.10-alpine
+FROM python:3.10-slim
 
 LABEL maintainer="foo@bar.com"
 ARG TZ='Asia/Shanghai'
 
 ARG CHATGPT_ON_WECHAT_VER
 
+RUN echo /etc/apt/sources.list
+RUN sed -i 's/deb.debian.org/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list
 ENV BUILD_PREFIX=/app
 
 ADD . ${BUILD_PREFIX}
 
-RUN apk add --no-cache bash ffmpeg espeak \
+RUN apt-get update \
+    &&apt-get install -y --no-install-recommends bash ffmpeg espeak libavcodec-extra\
     && cd ${BUILD_PREFIX} \
     && cp config-template.json config.json \
     && /usr/local/bin/python -m pip install --no-cache --upgrade pip \
     && pip install --no-cache -r requirements.txt \
-    && pip install --no-cache -r requirements-optional.txt
+    && pip install --no-cache -r requirements-optional.txt \
+    && pip install azure-cognitiveservices-speech
 
 WORKDIR ${BUILD_PREFIX}
 
 ADD docker/entrypoint.sh /entrypoint.sh
 
 RUN chmod +x /entrypoint.sh \
-    && adduser -D -h /home/noroot -u 1000 -s /bin/bash noroot \
+    && groupadd -r noroot \
+    && useradd -r -g noroot -s /bin/bash -d /home/noroot noroot \
     && chown -R noroot:noroot ${BUILD_PREFIX}
 
 USER noroot

docker/build.alpine.sh

@@ -11,6 +11,5 @@ docker build -f Dockerfile.alpine \
              -t zhayujie/chatgpt-on-wechat .
 
 # tag image
-docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:alpine 
+docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:alpine
 docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:$CHATGPT_ON_WECHAT_TAG-alpine
-           

docker/build.debian.sh

@@ -11,5 +11,5 @@ docker build -f Dockerfile.debian \
              -t zhayujie/chatgpt-on-wechat .
 
 # tag image
-docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:debian 
+docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:debian
 docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:$CHATGPT_ON_WECHAT_TAG-debian

docker/build.latest.sh

@@ -1,4 +1,8 @@
 #!/bin/bash
 
+unset KUBECONFIG
+
 cd .. && docker build -f docker/Dockerfile.latest \
-             -t zhayujie/chatgpt-on-wechat .
+             -t zhayujie/chatgpt-on-wechat .
+
+docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:$(date +%y%m%d)

docker/chatgpt-on-wechat-voice-reply/Dockerfile.alpine

@@ -9,7 +9,7 @@ RUN apk add --no-cache \
         ffmpeg  \
         espeak \
     && pip install --no-cache \
-        baidu-aip \ 
+        baidu-aip \
         chardet \
         SpeechRecognition
 

docker/chatgpt-on-wechat-voice-reply/Dockerfile.debian

@@ -10,7 +10,7 @@ RUN apt-get update  \
         ffmpeg \
         espeak  \
     && pip install --no-cache \
-        baidu-aip \ 
+        baidu-aip \
         chardet \
         SpeechRecognition
 

docker/entrypoint.sh

@@ -38,9 +38,9 @@ if [ "$CHATGPT_ON_WECHAT_EXEC" == "" ] ; then
 fi
 
 # modify content in config.json
-if [ "$OPEN_AI_API_KEY" == "YOUR API KEY" ] || [ "$OPEN_AI_API_KEY" == "" ]; then
-    echo -e "\033[31m[Warning] You need to set OPEN_AI_API_KEY before running!\033[0m"
-fi
+# if [ "$OPEN_AI_API_KEY" == "YOUR API KEY" ] || [ "$OPEN_AI_API_KEY" == "" ]; then
+#     echo -e "\033[31m[Warning] You need to set OPEN_AI_API_KEY before running!\033[0m"
+# fi
 
 
 # go to prefix dir

docker/sample-chatgpt-on-wechat/Makefile

@@ -11,13 +11,13 @@ run_d:
 	docker rm $(CONTAINER_NAME) || echo
 	docker run -dt  --name $(CONTAINER_NAME) $(PORT_MAP) \
 			--env-file=$(DOTENV) \
-			$(MOUNT) $(IMG) 
+			$(MOUNT) $(IMG)
 
 run_i:
 	docker rm $(CONTAINER_NAME) || echo
 	docker run -it  --name $(CONTAINER_NAME) $(PORT_MAP) \
 			--env-file=$(DOTENV) \
-			$(MOUNT) $(IMG) 
+			$(MOUNT) $(IMG)
 
 stop:
 	docker stop $(CONTAINER_NAME)

lib/itchat/components/login.py

@@ -43,6 +43,7 @@ def login(self, enableCmdQR=False, picDir=None, qrCallback=None,
         logger.warning('itchat has already logged in.')
         return
     self.isLogging = True
+    logger.info('Ready to login.')
     while self.isLogging:
         uuid = push_login(self)
         if uuid:
@@ -84,7 +85,7 @@ def login(self, enableCmdQR=False, picDir=None, qrCallback=None,
     if hasattr(loginCallback, '__call__'):
         r = loginCallback()
     else:
-        utils.clear_screen()
+        # utils.clear_screen()
         if os.path.exists(picDir or config.DEFAULT_QR):
             os.remove(picDir or config.DEFAULT_QR)
         logger.info('Login successfully as %s' % self.storageClass.nickName)
@@ -195,13 +196,17 @@ def process_login_info(core, loginContent):
     core.loginInfo['logintime'] = int(time.time() * 1e3)
     core.loginInfo['BaseRequest'] = {}
     cookies = core.s.cookies.get_dict()
-    skey = re.findall('<skey>(.*?)</skey>', r.text, re.S)[0]
-    pass_ticket = re.findall(
-        '<pass_ticket>(.*?)</pass_ticket>', r.text, re.S)[0]
-    core.loginInfo['skey'] = core.loginInfo['BaseRequest']['Skey'] = skey
+    res = re.findall('<skey>(.*?)</skey>', r.text, re.S)
+    skey = res[0] if res else None
+    res = re.findall(
+        '<pass_ticket>(.*?)</pass_ticket>', r.text, re.S)
+    pass_ticket = res[0] if res else None
+    if skey is not None:
+        core.loginInfo['skey'] = core.loginInfo['BaseRequest']['Skey'] = skey
     core.loginInfo['wxsid'] = core.loginInfo['BaseRequest']['Sid'] = cookies["wxsid"]
     core.loginInfo['wxuin'] = core.loginInfo['BaseRequest']['Uin'] = cookies["wxuin"]
-    core.loginInfo['pass_ticket'] = pass_ticket
+    if pass_ticket is not None:
+        core.loginInfo['pass_ticket'] = pass_ticket
     # A question : why pass_ticket == DeviceID ?
     #               deviceID is only a randomly generated number
 
@@ -317,6 +322,8 @@ def start_receiving(self, exitCallback=None, getReceivingFnOnly=False):
                 retryCount += 1
                 logger.error(traceback.format_exc())
                 if self.receivingRetryCount < retryCount:
+                    logger.error("Having tried %s times, but still failed. " % (
+                        retryCount) + "Stop trying...")
                     self.alive = False
                 else:
                     time.sleep(1)
@@ -363,7 +370,7 @@ def sync_check(self):
     regx = r'window.synccheck={retcode:"(\d+)",selector:"(\d+)"}'
     pm = re.search(regx, r.text)
     if pm is None or pm.group(1) != '0':
-        logger.debug('Unexpected sync check result: %s' % r.text)
+        logger.error('Unexpected sync check result: %s' % r.text)
         return None
     return pm.group(2)
 

lib/itchat/components/register.py

@@ -25,9 +25,11 @@ def auto_login(self, hotReload=False, statusStorageDir='itchat.pkl',
     self.useHotReload = hotReload
     self.hotReloadDir = statusStorageDir
     if hotReload:
-        if self.load_login_status(statusStorageDir,
+        if rval:=self.load_login_status(statusStorageDir,
                 loginCallback=loginCallback, exitCallback=exitCallback):
             return
+        logger.error('Hot reload failed, logging in normally, error={}'.format(rval))
+        self.logout()
         self.login(enableCmdQR=enableCmdQR, picDir=picDir, qrCallback=qrCallback,
             loginCallback=loginCallback, exitCallback=exitCallback)
         self.dump_login_status(statusStorageDir)

nixpacks.toml

@@ -2,6 +2,6 @@ providers = ['python']
 
 [phases.setup]
 nixPkgs = ['python310']
-cmds = ['apt-get update','apt-get install -y --no-install-recommends ffmpeg espeak']
+cmds = ['apt-get update','apt-get install -y --no-install-recommends ffmpeg espeak libavcodec-extra','python -m venv /opt/venv && . /opt/venv/bin/activate && pip install -r requirements-optional.txt']
 [start]
 cmd = "python ./app.py"

plugins/README.md

@@ -1,7 +1,7 @@
 **Table of Content**
 
 - [插件化初衷](#插件化初衷)
-- [插件安装方法](#插件化安装方法)
+- [插件安装方法](#插件安装方法)
 - [插件化实现](#插件化实现)
 - [插件编写示例](#插件编写示例)
 - [插件设计建议](#插件设计建议)
@@ -24,17 +24,17 @@
 在本仓库中预置了一些插件，如果要安装其他仓库的插件，有两种方法。
 
 - 第一种方法是在将下载的插件文件都解压到"plugins"文件夹的一个单独的文件夹，最终插件的代码都位于"plugins/PLUGIN_NAME/*"中。启动程序后，如果插件的目录结构正确，插件会自动被扫描加载。除此以外，注意你还需要安装文件夹中`requirements.txt`中的依赖。
-    
+
 - 第二种方法是`Godcmd`插件，它是预置的管理员插件，能够让程序在运行时就能安装插件，它能够自动安装依赖。
-    
+
     安装插件的命令是"#installp [仓库源](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/plugins/source.json)记录的插件名/仓库地址"。这是管理员命令，认证方法在[这里](https://github.com/zhayujie/chatgpt-on-wechat/tree/master/plugins/godcmd)。
-    
+
     - 安装[仓库源](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/plugins/source.json)记录的插件：#installp sdwebui
 
     - 安装指定仓库的插件：#installp https://github.com/lanvent/plugin_sdwebui.git
-    
+
     在安装之后，需要执行"#scanp"命令来扫描加载新安装的插件（或者重新启动程序）。
-    
+
 安装插件后需要注意有些插件有自己的配置模板，一般要去掉".template"新建一个配置文件。
 
 ## 插件化实现
@@ -52,6 +52,8 @@
 
 以下是它们的默认处理逻辑(太长不看，可跳到[插件编写示例](#插件编写示例))：
 
+**注意以下包含的代码是`v1.1.0`中的片段，已过时，只可用于理解事件，最新的默认代码逻辑请参考[chat_channel](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/chat_channel.py)**
+
 #### 1. 收到消息
 
 负责接收用户消息，根据用户的配置，判断本条消息是否触发机器人。如果触发，则会判断该消息的类型（声音、文本、画图命令等），将消息包装成如下的`Context`交付给下一个步骤。
@@ -91,9 +93,9 @@
     if context.type == ContextType.TEXT or context.type == ContextType.IMAGE_CREATE:
         reply = super().build_reply_content(context.content, context) #文字跟画图交付给chatgpt
     elif context.type == ContextType.VOICE: # 声音先进行语音转文字后，修改Context类型为文字后，再交付给chatgpt
-        msg = context['msg']
-        file_name = TmpDir().path() + context.content
-        msg.download(file_name)
+        cmsg = context['msg']
+        cmsg.prepare()
+        file_name = context.content
         reply = super().build_voice_to_text(file_name)
         if reply.type != ReplyType.ERROR and reply.type != ReplyType.INFO:
             context.content = reply.content # 语音转文字后，将文字内容作为新的context
@@ -105,14 +107,14 @@
 ```
 
 回复`Reply`的定义如下所示，它允许Bot可以回复多类不同的消息。同时也加入了`INFO`和`ERROR`消息类型区分系统提示和系统错误。
-    
+
 ```python
     class ReplyType(Enum):
         TEXT = 1        # 文本
         VOICE = 2       # 音频文件
         IMAGE = 3       # 图片文件
         IMAGE_URL = 4   # 图片URL
-        
+
         INFO = 9
         ERROR = 10
     class Reply:
@@ -157,12 +159,12 @@
 
 目前支持三类触发事件：
 ```
-1.收到消息 
----> `ON_HANDLE_CONTEXT` 
-2.产生回复 
----> `ON_DECORATE_REPLY` 
-3.装饰回复 
----> `ON_SEND_REPLY` 
+1.收到消息
+---> `ON_HANDLE_CONTEXT`
+2.产生回复
+---> `ON_DECORATE_REPLY`
+3.装饰回复
+---> `ON_SEND_REPLY`
 4.发送回复
 ```
 
@@ -266,6 +268,6 @@ class Hello(Plugin):
 - 一个插件目录建议只注册一个插件类。建议使用单独的仓库维护插件，便于更新。
 
   在测试调试好后提交`PR`，把自己的仓库加入到[仓库源](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/plugins/source.json)中。
-  
+
 - 插件的config文件、使用说明`README.md`、`requirement.txt`等放置在插件目录中。
 - 默认优先级不要超过管理员插件`Godcmd`的优先级(999)，`Godcmd`插件提供了配置管理、插件管理等功能。

plugins/__init__.py

@@ -1,9 +1,9 @@
-from .plugin_manager import PluginManager
 from .event import *
 from .plugin import *
+from .plugin_manager import PluginManager
 
 instance = PluginManager()
 
-register                    = instance.register
+register = instance.register
 # load_plugins                = instance.load_plugins
 # emit_event                  = instance.emit_event

plugins/banwords/README.md

@@ -1,9 +1,27 @@
+
 ## 插件描述
+
 简易的敏感词插件，暂不支持分词，请自行导入词库到插件文件夹中的`banwords.txt`，每行一个词，一个参考词库是[1](https://github.com/cjh0613/tencent-sensitive-words/blob/main/sensitive_words_lines.txt)。
 
-`config.json`中能够填写默认的处理行为，目前行为有：
+使用前将`config.json.template`复制为`config.json`，并自行配置。
+
+目前插件对消息的默认处理行为有如下两种：
+
 - `ignore` : 无视这条消息。
 - `replace` : 将消息中的敏感词替换成"*"，并回复违规。
 
+```json
+    "action": "replace",  
+    "reply_filter": true,
+    "reply_action": "ignore"
+```
+
+在以上配置项中：
+
+- `action`: 对用户消息的默认处理行为
+- `reply_filter`: 是否对ChatGPT的回复也进行敏感词过滤
+- `reply_action`: 如果开启了回复过滤，对回复的默认处理行为
+
 ## 致谢
+
 搜索功能实现来自https://github.com/toolgood/ToolGood.Words

plugins/banwords/__init__.py

@@ -1 +1 @@
-from .banwords import *
+from .banwords import *

plugins/banwords/banwords.py

@@ -2,66 +2,98 @@
 
 import json
 import os
+
+import plugins
 from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
-import plugins
-from plugins import *
 from common.log import logger
-from .WordsSearch import WordsSearch
+from plugins import *
+
+from .lib.WordsSearch import WordsSearch
 
 
-@plugins.register(name="Banwords", desire_priority=100, hidden=True, desc="判断消息中是否有敏感词、决定是否回复。", version="1.0", author="lanvent")
+@plugins.register(
+    name="Banwords",
+    desire_priority=100,
+    hidden=True,
+    desc="判断消息中是否有敏感词、决定是否回复。",
+    version="1.0",
+    author="lanvent",
+)
 class Banwords(Plugin):
     def __init__(self):
         super().__init__()
         try:
-            curdir=os.path.dirname(__file__)
-            config_path=os.path.join(curdir,"config.json")
-            conf=None
+            curdir = os.path.dirname(__file__)
+            config_path = os.path.join(curdir, "config.json")
+            conf = None
             if not os.path.exists(config_path):
-                conf={"action":"ignore"}
-                with open(config_path,"w") as f:
-                    json.dump(conf,f,indent=4)
+                conf = {"action": "ignore"}
+                with open(config_path, "w") as f:
+                    json.dump(conf, f, indent=4)
             else:
-                with open(config_path,"r") as f:
-                    conf=json.load(f)
+                with open(config_path, "r") as f:
+                    conf = json.load(f)
             self.searchr = WordsSearch()
             self.action = conf["action"]
-            banwords_path = os.path.join(curdir,"banwords.txt")
-            with open(banwords_path, 'r', encoding='utf-8') as f:
-                words=[]
+            banwords_path = os.path.join(curdir, "banwords.txt")
+            with open(banwords_path, "r", encoding="utf-8") as f:
+                words = []
                 for line in f:
                     word = line.strip()
                     if word:
                         words.append(word)
             self.searchr.SetKeywords(words)
             self.handlers[Event.ON_HANDLE_CONTEXT] = self.on_handle_context
+            if conf.get("reply_filter", True):
+                self.handlers[Event.ON_DECORATE_REPLY] = self.on_decorate_reply
+                self.reply_action = conf.get("reply_action", "ignore")
             logger.info("[Banwords] inited")
         except Exception as e:
             logger.warn("[Banwords] init failed, ignore or see https://github.com/zhayujie/chatgpt-on-wechat/tree/master/plugins/banwords .")
             raise e
-        
-
 
     def on_handle_context(self, e_context: EventContext):
-
-        if e_context['context'].type not in [ContextType.TEXT,ContextType.IMAGE_CREATE]:
+        if e_context["context"].type not in [
+            ContextType.TEXT,
+            ContextType.IMAGE_CREATE,
+        ]:
             return
-        
-        content = e_context['context'].content
+
+        content = e_context["context"].content
         logger.debug("[Banwords] on_handle_context. content: %s" % content)
         if self.action == "ignore":
             f = self.searchr.FindFirst(content)
             if f:
-                logger.info("Banwords: %s" % f["Keyword"])
+                logger.info("[Banwords] %s in message" % f["Keyword"])
                 e_context.action = EventAction.BREAK_PASS
                 return
         elif self.action == "replace":
             if self.searchr.ContainsAny(content):
-                reply = Reply(ReplyType.INFO, "发言中包含敏感词，请重试: \n"+self.searchr.Replace(content))
-                e_context['reply'] = reply
+                reply = Reply(ReplyType.INFO, "发言中包含敏感词，请重试: \n" + self.searchr.Replace(content))
+                e_context["reply"] = reply
                 e_context.action = EventAction.BREAK_PASS
                 return
-            
+
+    def on_decorate_reply(self, e_context: EventContext):
+        if e_context["reply"].type not in [ReplyType.TEXT]:
+            return
+
+        reply = e_context["reply"]
+        content = reply.content
+        if self.reply_action == "ignore":
+            f = self.searchr.FindFirst(content)
+            if f:
+                logger.info("[Banwords] %s in reply" % f["Keyword"])
+                e_context["reply"] = None
+                e_context.action = EventAction.BREAK_PASS
+                return
+        elif self.reply_action == "replace":
+            if self.searchr.ContainsAny(content):
+                reply = Reply(ReplyType.INFO, "已替换回复中的敏感词: \n" + self.searchr.Replace(content))
+                e_context["reply"] = reply
+                e_context.action = EventAction.CONTINUE
+                return
+
     def get_help_text(self, **kwargs):
-        return Banwords.desc
+        return "过滤消息中的敏感词。"

plugins/banwords/config.json.template

@@ -1,3 +1,5 @@
 {
-    "action": "ignore"
-}
+  "action": "replace",
+  "reply_filter": true,
+  "reply_action": "ignore"
+}

plugins/bdunit/README.md

@@ -24,7 +24,7 @@ see https://ai.baidu.com/unit/home#/home?track=61fe1b0d3407ce3face1d92cb5c291087
 ``` json
     {
     "service_id": "s...", #"机器人ID"
-    "api_key": "", 
+    "api_key": "",
     "secret_key": ""
     }
 ```

plugins/bdunit/__init__.py

@@ -1 +1 @@
-from .bdunit import *
+from .bdunit import *

plugins/bdunit/bdunit.py

@@ -2,21 +2,29 @@
 import json
 import os
 import uuid
+from uuid import getnode as get_mac
+
 import requests
+
+import plugins
 from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
 from common.log import logger
-import plugins
 from plugins import *
-from uuid import getnode as get_mac
-
 
 """利用百度UNIT实现智能对话
     如果命中意图，返回意图对应的回复，否则返回继续交付给下个插件处理
 """
 
 
-@plugins.register(name="BDunit", desire_priority=0, hidden=True, desc="Baidu unit bot system", version="0.1", author="jackson")
+@plugins.register(
+    name="BDunit",
+    desire_priority=0,
+    hidden=True,
+    desc="Baidu unit bot system",
+    version="0.1",
+    author="jackson",
+)
 class BDunit(Plugin):
     def __init__(self):
         super().__init__()
@@ -40,11 +48,10 @@ class BDunit(Plugin):
             raise e
 
     def on_handle_context(self, e_context: EventContext):
-
-        if e_context['context'].type != ContextType.TEXT:
+        if e_context["context"].type != ContextType.TEXT:
             return
 
-        content = e_context['context'].content
+        content = e_context["context"].content
         logger.debug("[BDunit] on_handle_context. content: %s" % content)
         parsed = self.getUnit2(content)
         intent = self.getIntent(parsed)
@@ -53,7 +60,7 @@ class BDunit(Plugin):
             reply = Reply()
             reply.type = ReplyType.TEXT
             reply.content = self.getSay(parsed)
-            e_context['reply'] = reply
+            e_context["reply"] = reply
             e_context.action = EventAction.BREAK_PASS  # 事件结束，并跳过处理context的默认逻辑
         else:
             e_context.action = EventAction.CONTINUE  # 事件继续，交付给下个插件或默认逻辑
@@ -69,18 +76,14 @@ class BDunit(Plugin):
         Returns:
             string: access_token
         """
-        url = "https://aip.baidubce.com/oauth/2.0/token?client_id={}&client_secret={}&grant_type=client_credentials".format(
-            self.api_key, self.secret_key)
+        url = "https://aip.baidubce.com/oauth/2.0/token?client_id={}&client_secret={}&grant_type=client_credentials".format(self.api_key, self.secret_key)
         payload = ""
-        headers = {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json'
-        }
+        headers = {"Content-Type": "application/json", "Accept": "application/json"}
 
         response = requests.request("POST", url, headers=headers, data=payload)
 
         # print(response.text)
-        return response.json()['access_token']
+        return response.json()["access_token"]
 
     def getUnit(self, query):
         """
@@ -89,12 +92,12 @@ class BDunit(Plugin):
         :returns: UNIT 解析结果。如果解析失败，返回 None
         """
 
-        url = (
-            'https://aip.baidubce.com/rpc/2.0/unit/service/v3/chat?access_token='
-            + self.access_token
-        )
-        request = {"query": query, "user_id": str(
-            get_mac())[:32], "terminal_id": "88888"}
+        url = "https://aip.baidubce.com/rpc/2.0/unit/service/v3/chat?access_token=" + self.access_token
+        request = {
+            "query": query,
+            "user_id": str(get_mac())[:32],
+            "terminal_id": "88888",
+        }
         body = {
             "log_id": str(uuid.uuid1()),
             "version": "3.0",
@@ -116,10 +119,7 @@ class BDunit(Plugin):
         :param query: 用户的指令字符串
         :returns: UNIT 解析结果。如果解析失败，返回 None
         """
-        url = (
-            "https://aip.baidubce.com/rpc/2.0/unit/service/chat?access_token="
-            + self.access_token
-        )
+        url = "https://aip.baidubce.com/rpc/2.0/unit/service/chat?access_token=" + self.access_token
         request = {"query": query, "user_id": str(get_mac())[:32]}
         body = {
             "log_id": str(uuid.uuid1()),
@@ -142,11 +142,7 @@ class BDunit(Plugin):
         :param parsed: UNIT 解析结果
         :returns: 意图数组
         """
-        if (
-            parsed
-            and "result" in parsed
-            and "response_list" in parsed["result"]
-        ):
+        if parsed and "result" in parsed and "response_list" in parsed["result"]:
             try:
                 return parsed["result"]["response_list"][0]["schema"]["intent"]
             except Exception as e:
@@ -163,18 +159,10 @@ class BDunit(Plugin):
         :param intent: 意图的名称
         :returns: True: 包含; False: 不包含
         """
-        if (
-            parsed
-            and "result" in parsed
-            and "response_list" in parsed["result"]
-        ):
+        if parsed and "result" in parsed and "response_list" in parsed["result"]:
             response_list = parsed["result"]["response_list"]
             for response in response_list:
-                if (
-                    "schema" in response
-                    and "intent" in response["schema"]
-                    and response["schema"]["intent"] == intent
-                ):
+                if "schema" in response and "intent" in response["schema"] and response["schema"]["intent"] == intent:
                     return True
             return False
         else:
@@ -189,11 +177,7 @@ class BDunit(Plugin):
             :returns: 词槽列表。你可以通过 name 属性筛选词槽，
         再通过 normalized_word 属性取出相应的值
         """
-        if (
-            parsed
-            and "result" in parsed
-            and "response_list" in parsed["result"]
-        ):
+        if parsed and "result" in parsed and "response_list" in parsed["result"]:
             response_list = parsed["result"]["response_list"]
             if intent == "":
                 try:
@@ -202,12 +186,7 @@ class BDunit(Plugin):
                     logger.warning(e)
                     return []
             for response in response_list:
-                if (
-                    "schema" in response
-                    and "intent" in response["schema"]
-                    and "slots" in response["schema"]
-                    and response["schema"]["intent"] == intent
-                ):
+                if "schema" in response and "intent" in response["schema"] and "slots" in response["schema"] and response["schema"]["intent"] == intent:
                     return response["schema"]["slots"]
             return []
         else:
@@ -236,22 +215,14 @@ class BDunit(Plugin):
         :param parsed: UNIT 解析结果
         :returns: UNIT 的回复文本
         """
-        if (
-            parsed
-            and "result" in parsed
-            and "response_list" in parsed["result"]
-        ):
+        if parsed and "result" in parsed and "response_list" in parsed["result"]:
             response_list = parsed["result"]["response_list"]
             answer = {}
             for response in response_list:
                 if (
                     "schema" in response
                     and "intent_confidence" in response["schema"]
-                    and (
-                        not answer
-                        or response["schema"]["intent_confidence"]
-                        > answer["schema"]["intent_confidence"]
-                    )
+                    and (not answer or response["schema"]["intent_confidence"] > answer["schema"]["intent_confidence"])
                 ):
                     answer = response
             return answer["action_list"][0]["say"]
@@ -266,11 +237,7 @@ class BDunit(Plugin):
         :param intent: 意图的名称
         :returns: UNIT 的回复文本
         """
-        if (
-            parsed
-            and "result" in parsed
-            and "response_list" in parsed["result"]
-        ):
+        if parsed and "result" in parsed and "response_list" in parsed["result"]:
             response_list = parsed["result"]["response_list"]
             if intent == "":
                 try:
@@ -279,11 +246,7 @@ class BDunit(Plugin):
                     logger.warning(e)
                     return ""
             for response in response_list:
-                if (
-                    "schema" in response
-                    and "intent" in response["schema"]
-                    and response["schema"]["intent"] == intent
-                ):
+                if "schema" in response and "intent" in response["schema"] and response["schema"]["intent"] == intent:
                     try:
                         return response["action_list"][0]["say"]
                     except Exception as e:

plugins/bdunit/config.json.template

@@ -1,5 +1,5 @@
 {
-    "service_id": "s...",
-    "api_key": "",
-    "secret_key": ""
-}
+  "service_id": "s...",
+  "api_key": "",
+  "secret_key": ""
+}

plugins/dungeon/__init__.py

@@ -1 +1 @@
-from .dungeon import *
+from .dungeon import *

plugins/dungeon/dungeon.py

@@ -1,17 +1,18 @@
 # encoding:utf-8
 
+import plugins
 from bridge.bridge import Bridge
 from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
-from common.expired_dict import ExpiredDict
-from config import conf
-import plugins
-from plugins import *
-from common.log import logger
 from common import const
+from common.expired_dict import ExpiredDict
+from common.log import logger
+from config import conf
+from plugins import *
+
 
 # https://github.com/bupticybee/ChineseAiDungeonChatGPT
-class StoryTeller():
+class StoryTeller:
     def __init__(self, bot, sessionid, story):
         self.bot = bot
         self.sessionid = sessionid
@@ -27,67 +28,79 @@ class StoryTeller():
         if user_action[-1] != "。":
             user_action = user_action + "。"
         if self.first_interact:
-            prompt = """现在来充当一个文字冒险游戏，描述时候注意节奏，不要太快，仔细描述各个人物的心情和周边环境。一次只需写四到六句话。
-            开头是，""" + self.story + " " + user_action
+            prompt = (
+                """现在来充当一个文字冒险游戏，描述时候注意节奏，不要太快，仔细描述各个人物的心情和周边环境。一次只需写四到六句话。
+            开头是，"""
+                + self.story
+                + " "
+                + user_action
+            )
             self.first_interact = False
         else:
             prompt = """继续，一次只需要续写四到六句话，总共就只讲5分钟内发生的事情。""" + user_action
         return prompt
 
 
-@plugins.register(name="Dungeon", desire_priority=0, namecn="文字冒险", desc="A plugin to play dungeon game", version="1.0", author="lanvent")
+@plugins.register(
+    name="Dungeon",
+    desire_priority=0,
+    namecn="文字冒险",
+    desc="A plugin to play dungeon game",
+    version="1.0",
+    author="lanvent",
+)
 class Dungeon(Plugin):
     def __init__(self):
         super().__init__()
         self.handlers[Event.ON_HANDLE_CONTEXT] = self.on_handle_context
         logger.info("[Dungeon] inited")
         # 目前没有设计session过期事件，这里先暂时使用过期字典
-        if conf().get('expires_in_seconds'):
-            self.games = ExpiredDict(conf().get('expires_in_seconds'))
+        if conf().get("expires_in_seconds"):
+            self.games = ExpiredDict(conf().get("expires_in_seconds"))
         else:
             self.games = dict()
 
     def on_handle_context(self, e_context: EventContext):
-
-        if e_context['context'].type != ContextType.TEXT:
+        if e_context["context"].type != ContextType.TEXT:
             return
         bottype = Bridge().get_bot_type("chat")
-        if bottype not in (const.CHATGPT, const.OPEN_AI):
+        if bottype not in [const.OPEN_AI, const.CHATGPT, const.CHATGPTONAZURE]:
             return
         bot = Bridge().get_bot("chat")
-        content = e_context['context'].content[:]
-        clist = e_context['context'].content.split(maxsplit=1)
-        sessionid = e_context['context']['session_id']
+        content = e_context["context"].content[:]
+        clist = e_context["context"].content.split(maxsplit=1)
+        sessionid = e_context["context"]["session_id"]
         logger.debug("[Dungeon] on_handle_context. content: %s" % clist)
-        trigger_prefix = conf().get('plugin_trigger_prefix', "$")
+        trigger_prefix = conf().get("plugin_trigger_prefix", "$")
         if clist[0] == f"{trigger_prefix}停止冒险":
             if sessionid in self.games:
                 self.games[sessionid].reset()
                 del self.games[sessionid]
                 reply = Reply(ReplyType.INFO, "冒险结束!")
-                e_context['reply'] = reply
+                e_context["reply"] = reply
                 e_context.action = EventAction.BREAK_PASS
         elif clist[0] == f"{trigger_prefix}开始冒险" or sessionid in self.games:
             if sessionid not in self.games or clist[0] == f"{trigger_prefix}开始冒险":
-                if len(clist)>1 :
+                if len(clist) > 1:
                     story = clist[1]
                 else:
                     story = "你在树林里冒险，指不定会从哪里蹦出来一些奇怪的东西，你握紧手上的手枪，希望这次冒险能够找到一些值钱的东西，你往树林深处走去。"
                 self.games[sessionid] = StoryTeller(bot, sessionid, story)
                 reply = Reply(ReplyType.INFO, "冒险开始，你可以输入任意内容，让故事继续下去。故事背景是：" + story)
-                e_context['reply'] = reply
-                e_context.action = EventAction.BREAK_PASS # 事件结束，并跳过处理context的默认逻辑
+                e_context["reply"] = reply
+                e_context.action = EventAction.BREAK_PASS  # 事件结束，并跳过处理context的默认逻辑
             else:
                 prompt = self.games[sessionid].action(content)
-                e_context['context'].type = ContextType.TEXT
-                e_context['context'].content = prompt
-                e_context.action = EventAction.BREAK # 事件结束，不跳过处理context的默认逻辑
+                e_context["context"].type = ContextType.TEXT
+                e_context["context"].content = prompt
+                e_context.action = EventAction.BREAK  # 事件结束，不跳过处理context的默认逻辑
+
     def get_help_text(self, **kwargs):
         help_text = "可以和机器人一起玩文字冒险游戏。\n"
-        if kwargs.get('verbose') != True:
+        if kwargs.get("verbose") != True:
             return help_text
-        trigger_prefix = conf().get('plugin_trigger_prefix', "$")
-        help_text = f"{trigger_prefix}开始冒险 "+"背景故事: 开始一个基于{背景故事}的文字冒险，之后你的所有消息会协助完善这个故事。\n"+f"{trigger_prefix}停止冒险: 结束游戏。\n"
-        if kwargs.get('verbose') == True:
+        trigger_prefix = conf().get("plugin_trigger_prefix", "$")
+        help_text = f"{trigger_prefix}开始冒险 " + "背景故事: 开始一个基于{背景故事}的文字冒险，之后你的所有消息会协助完善这个故事。\n" + f"{trigger_prefix}停止冒险: 结束游戏。\n"
+        if kwargs.get("verbose") == True:
             help_text += f"\n命令例子: '{trigger_prefix}开始冒险 你在树林里冒险，指不定会从哪里蹦出来一些奇怪的东西，你握紧手上的手枪，希望这次冒险能够找到一些值钱的东西，你往树林深处走去。'"
-        return help_text
+        return help_text

plugins/event.py

@@ -4,19 +4,22 @@ from enum import Enum
 
 
 class Event(Enum):
-    # ON_RECEIVE_MESSAGE = 1  # 收到消息
+    ON_RECEIVE_MESSAGE = 1  # 收到消息
+    """
+    e_context = {  "channel": 消息channel, "context" : 本次消息的context}
+    """
 
-    ON_HANDLE_CONTEXT = 2   # 处理消息前
+    ON_HANDLE_CONTEXT = 2  # 处理消息前
     """
     e_context = {  "channel": 消息channel, "context" : 本次消息的context, "reply" : 目前的回复，初始为空  }
     """
 
-    ON_DECORATE_REPLY = 3   # 得到回复后准备装饰
+    ON_DECORATE_REPLY = 3  # 得到回复后准备装饰
     """
     e_context = {  "channel": 消息channel, "context" : 本次消息的context, "reply" : 目前的回复 }
     """
 
-    ON_SEND_REPLY = 4       # 发送回复前
+    ON_SEND_REPLY = 4  # 发送回复前
     """
     e_context = {  "channel": 消息channel, "context" : 本次消息的context, "reply" : 目前的回复 }
     """
@@ -25,9 +28,9 @@ class Event(Enum):
 
 
 class EventAction(Enum):
-    CONTINUE = 1            # 事件未结束，继续交给下个插件处理，如果没有下个插件，则交付给默认的事件处理逻辑
-    BREAK = 2               # 事件结束，不再给下个插件处理，交付给默认的事件处理逻辑
-    BREAK_PASS = 3          # 事件结束，不再给下个插件处理，不交付给默认的事件处理逻辑
+    CONTINUE = 1  # 事件未结束，继续交给下个插件处理，如果没有下个插件，则交付给默认的事件处理逻辑
+    BREAK = 2  # 事件结束，不再给下个插件处理，交付给默认的事件处理逻辑
+    BREAK_PASS = 3  # 事件结束，不再给下个插件处理，不交付给默认的事件处理逻辑
 
 
 class EventContext:

plugins/finish/__init__.py

@@ -1 +1 @@
-from .finish import *
+from .finish import *

plugins/finish/finish.py

@@ -1,14 +1,21 @@
 # encoding:utf-8
 
+import plugins
 from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
-from config import conf
-import plugins
-from plugins import *
 from common.log import logger
+from config import conf
+from plugins import *
 
 
-@plugins.register(name="Finish", desire_priority=-999, hidden=True, desc="A plugin that check unknown command", version="1.0", author="js00000")
+@plugins.register(
+    name="Finish",
+    desire_priority=-999,
+    hidden=True,
+    desc="A plugin that check unknown command",
+    version="1.0",
+    author="js00000",
+)
 class Finish(Plugin):
     def __init__(self):
         super().__init__()
@@ -16,19 +23,18 @@ class Finish(Plugin):
         logger.info("[Finish] inited")
 
     def on_handle_context(self, e_context: EventContext):
-
-        if e_context['context'].type != ContextType.TEXT:
+        if e_context["context"].type != ContextType.TEXT:
             return
 
-        content = e_context['context'].content
+        content = e_context["context"].content
         logger.debug("[Finish] on_handle_context. content: %s" % content)
-        trigger_prefix = conf().get('plugin_trigger_prefix',"$")
+        trigger_prefix = conf().get("plugin_trigger_prefix", "$")
         if content.startswith(trigger_prefix):
             reply = Reply()
             reply.type = ReplyType.ERROR
             reply.content = "未知插件命令\n查看插件命令列表请输入#help 插件名\n"
-            e_context['reply'] = reply
-            e_context.action = EventAction.BREAK_PASS # 事件结束，并跳过处理context的默认逻辑
+            e_context["reply"] = reply
+            e_context.action = EventAction.BREAK_PASS  # 事件结束，并跳过处理context的默认逻辑
 
     def get_help_text(self, **kwargs):
         return ""

plugins/godcmd/__init__.py

@@ -1 +1 @@
-from .godcmd import *
+from .godcmd import *

plugins/godcmd/config.json.template

@@ -1,4 +1,4 @@
 {
-    "password": "",
-    "admin_users": []
-}
+  "password": "",
+  "admin_users": []
+}

plugins/godcmd/godcmd.py

@@ -6,14 +6,16 @@ import random
 import string
 import traceback
 from typing import Tuple
+
+import plugins
 from bridge.bridge import Bridge
 from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
-from config import conf, load_config
-import plugins
-from plugins import *
 from common import const
 from common.log import logger
+from config import conf, load_config
+from plugins import *
+
 # 定义指令集
 COMMANDS = {
     "help": {
@@ -41,7 +43,7 @@ COMMANDS = {
     },
     "id": {
         "alias": ["id", "用户"],
-        "desc": "获取用户id", # wechaty和wechatmp的用户id不会变化，可用于绑定管理员
+        "desc": "获取用户id",  # wechaty和wechatmp的用户id不会变化，可用于绑定管理员
     },
     "reset": {
         "alias": ["reset", "重置会话"],
@@ -114,18 +116,20 @@ ADMIN_COMMANDS = {
         "desc": "开启机器调试日志",
     },
 }
+
+
 # 定义帮助函数
 def get_help_text(isadmin, isgroup):
     help_text = "通用指令：\n"
     for cmd, info in COMMANDS.items():
-        if cmd=="auth": #不提示认证指令
+        if cmd == "auth":  # 不提示认证指令
             continue
-        if cmd=="id" and conf().get("channel_type","wx") not in ["wxy","wechatmp"]:
+        if cmd == "id" and conf().get("channel_type", "wx") not in ["wxy", "wechatmp"]:
             continue
-        alias=["#"+a for a in info['alias'][:1]]
+        alias = ["#" + a for a in info["alias"][:1]]
         help_text += f"{','.join(alias)} "
-        if 'args' in info:
-            args=[a for a in info['args']]
+        if "args" in info:
+            args = [a for a in info["args"]]
             help_text += f"{' '.join(args)}"
         help_text += f": {info['desc']}\n"
 
@@ -135,39 +139,46 @@ def get_help_text(isadmin, isgroup):
     for plugin in plugins:
         if plugins[plugin].enabled and not plugins[plugin].hidden:
             namecn = plugins[plugin].namecn
-            help_text += "\n%s:"%namecn
+            help_text += "\n%s:" % namecn
             help_text += PluginManager().instances[plugin].get_help_text(verbose=False).strip()
 
     if ADMIN_COMMANDS and isadmin:
         help_text += "\n\n管理员指令：\n"
         for cmd, info in ADMIN_COMMANDS.items():
-            alias=["#"+a for a in info['alias'][:1]]
+            alias = ["#" + a for a in info["alias"][:1]]
             help_text += f"{','.join(alias)} "
-            if 'args' in info:
-                args=[a for a in info['args']]
+            if "args" in info:
+                args = [a for a in info["args"]]
                 help_text += f"{' '.join(args)}"
             help_text += f": {info['desc']}\n"
     return help_text
 
-@plugins.register(name="Godcmd", desire_priority=999, hidden=True, desc="为你的机器人添加指令集，有用户和管理员两种角色，加载顺序请放在首位，初次运行后插件目录会生成配置文件, 填充管理员密码后即可认证", version="1.0", author="lanvent")
-class Godcmd(Plugin):
 
+@plugins.register(
+    name="Godcmd",
+    desire_priority=999,
+    hidden=True,
+    desc="为你的机器人添加指令集，有用户和管理员两种角色，加载顺序请放在首位，初次运行后插件目录会生成配置文件, 填充管理员密码后即可认证",
+    version="1.0",
+    author="lanvent",
+)
+class Godcmd(Plugin):
     def __init__(self):
         super().__init__()
 
-        curdir=os.path.dirname(__file__)
-        config_path=os.path.join(curdir,"config.json")
-        gconf=None
+        curdir = os.path.dirname(__file__)
+        config_path = os.path.join(curdir, "config.json")
+        gconf = None
         if not os.path.exists(config_path):
-            gconf={"password":"","admin_users":[]}
-            with open(config_path,"w") as f:
-                json.dump(gconf,f,indent=4)
+            gconf = {"password": "", "admin_users": []}
+            with open(config_path, "w") as f:
+                json.dump(gconf, f, indent=4)
         else:
-            with open(config_path,"r") as f:
-                gconf=json.load(f)
+            with open(config_path, "r") as f:
+                gconf = json.load(f)
         if gconf["password"] == "":
             self.temp_password = "".join(random.sample(string.digits, 4))
-            logger.info("[Godcmd] 因未设置口令，本次的临时口令为%s。"%self.temp_password)
+            logger.info("[Godcmd] 因未设置口令，本次的临时口令为%s。" % self.temp_password)
         else:
             self.temp_password = None
         custom_commands = conf().get("clear_memory_commands", [])
@@ -178,41 +189,47 @@ class Godcmd(Plugin):
                     COMMANDS["reset"]["alias"].append(custom_command)
 
         self.password = gconf["password"]
-        self.admin_users = gconf["admin_users"] # 预存的管理员账号，这些账号不需要认证。itchat的用户名每次都会变，不可用
-        self.isrunning = True # 机器人是否运行中
+        self.admin_users = gconf["admin_users"]  # 预存的管理员账号，这些账号不需要认证。itchat的用户名每次都会变，不可用
+        self.isrunning = True  # 机器人是否运行中
 
         self.handlers[Event.ON_HANDLE_CONTEXT] = self.on_handle_context
         logger.info("[Godcmd] inited")
 
-
     def on_handle_context(self, e_context: EventContext):
-        context_type = e_context['context'].type
+        context_type = e_context["context"].type
         if context_type != ContextType.TEXT:
             if not self.isrunning:
                 e_context.action = EventAction.BREAK_PASS
             return
 
-        content = e_context['context'].content
+        content = e_context["context"].content
         logger.debug("[Godcmd] on_handle_context. content: %s" % content)
         if content.startswith("#"):
+            if len(content) == 1:
+                reply = Reply()
+                reply.type = ReplyType.ERROR
+                reply.content = f"空指令，输入#help查看指令列表\n"
+                e_context["reply"] = reply
+                e_context.action = EventAction.BREAK_PASS
+                return
             # msg = e_context['context']['msg']
-            channel = e_context['channel']
-            user = e_context['context']['receiver']
-            session_id = e_context['context']['session_id']
-            isgroup = e_context['context'].get("isgroup", False)
+            channel = e_context["channel"]
+            user = e_context["context"]["receiver"]
+            session_id = e_context["context"]["session_id"]
+            isgroup = e_context["context"].get("isgroup", False)
             bottype = Bridge().get_bot_type("chat")
             bot = Bridge().get_bot("chat")
             # 将命令和参数分割
             command_parts = content[1:].strip().split()
             cmd = command_parts[0]
             args = command_parts[1:]
-            isadmin=False
+            isadmin = False
             if user in self.admin_users:
-                isadmin=True
-            ok=False
-            result="string"
-            if any(cmd in info['alias'] for info in COMMANDS.values()):
-                cmd = next(c for c, info in COMMANDS.items() if cmd in info['alias'])
+                isadmin = True
+            ok = False
+            result = "string"
+            if any(cmd in info["alias"] for info in COMMANDS.values()):
+                cmd = next(c for c, info in COMMANDS.items() if cmd in info["alias"])
                 if cmd == "auth":
                     ok, result = self.authenticate(user, args, isadmin, isgroup)
                 elif cmd == "help" or cmd == "helpp":
@@ -224,7 +241,7 @@ class Godcmd(Plugin):
                         query_name = args[0].upper()
                         # search name and namecn
                         for name, plugincls in plugins.items():
-                            if not plugincls.enabled :
+                            if not plugincls.enabled:
                                 continue
                             if query_name == name or query_name == plugincls.namecn:
                                 ok, result = True, PluginManager().instances[name].get_help_text(isgroup=isgroup, isadmin=isadmin, verbose=True)
@@ -236,31 +253,31 @@ class Godcmd(Plugin):
                 elif cmd == "set_openai_api_key":
                     if len(args) == 1:
                         user_data = conf().get_user_data(user)
-                        user_data['openai_api_key'] = args[0]
+                        user_data["openai_api_key"] = args[0]
                         ok, result = True, "你的OpenAI私有api_key已设置为" + args[0]
                     else:
                         ok, result = False, "请提供一个api_key"
                 elif cmd == "reset_openai_api_key":
                     try:
                         user_data = conf().get_user_data(user)
-                        user_data.pop('openai_api_key')
+                        user_data.pop("openai_api_key")
                         ok, result = True, "你的OpenAI私有api_key已清除"
                     except Exception as e:
                         ok, result = False, "你没有设置私有api_key"
                 elif cmd == "reset":
-                    if bottype in (const.CHATGPT, const.OPEN_AI):
+                    if bottype in [const.OPEN_AI, const.CHATGPT, const.CHATGPTONAZURE]:
                         bot.sessions.clear_session(session_id)
                         channel.cancel_session(session_id)
                         ok, result = True, "会话已重置"
                     else:
                         ok, result = False, "当前对话机器人不支持重置会话"
                 logger.debug("[Godcmd] command: %s by %s" % (cmd, user))
-            elif any(cmd in info['alias'] for info in ADMIN_COMMANDS.values()):
+            elif any(cmd in info["alias"] for info in ADMIN_COMMANDS.values()):
                 if isadmin:
                     if isgroup:
                         ok, result = False, "群聊不可执行管理员指令"
                     else:
-                        cmd = next(c for c, info in ADMIN_COMMANDS.items() if cmd in info['alias'])
+                        cmd = next(c for c, info in ADMIN_COMMANDS.items() if cmd in info["alias"])
                         if cmd == "stop":
                             self.isrunning = False
                             ok, result = True, "服务已暂停"
@@ -271,20 +288,20 @@ class Godcmd(Plugin):
                             load_config()
                             ok, result = True, "配置已重载"
                         elif cmd == "resetall":
-                            if bottype in (const.CHATGPT, const.OPEN_AI):
+                            if bottype in [const.OPEN_AI, const.CHATGPT, const.CHATGPTONAZURE]:
                                 channel.cancel_all_session()
                                 bot.sessions.clear_all_session()
                                 ok, result = True, "重置所有会话成功"
                             else:
                                 ok, result = False, "当前对话机器人不支持重置会话"
                         elif cmd == "debug":
-                            logger.setLevel('DEBUG')
+                            logger.setLevel("DEBUG")
                             ok, result = True, "DEBUG模式已开启"
                         elif cmd == "plist":
                             plugins = PluginManager().list_plugins()
                             ok = True
                             result = "插件列表：\n"
-                            for name,plugincls in plugins.items():
+                            for name, plugincls in plugins.items():
                                 result += f"{plugincls.name}_v{plugincls.version} {plugincls.priority} - "
                                 if plugincls.enabled:
                                     result += "已启用\n"
@@ -294,11 +311,11 @@ class Godcmd(Plugin):
                             new_plugins = PluginManager().scan_plugins()
                             ok, result = True, "插件扫描完成"
                             PluginManager().activate_plugins()
-                            if len(new_plugins) >0 :
+                            if len(new_plugins) > 0:
                                 result += "\n发现新插件：\n"
                                 result += "\n".join([f"{p.name}_v{p.version}" for p in new_plugins])
-                            else :
-                                result +=", 未发现新插件"
+                            else:
+                                result += ", 未发现新插件"
                         elif cmd == "setpri":
                             if len(args) != 2:
                                 ok, result = False, "请提供插件名和优先级"
@@ -350,42 +367,42 @@ class Godcmd(Plugin):
                 else:
                     ok, result = False, "需要管理员权限才能执行该指令"
             else:
-                trigger_prefix = conf().get('plugin_trigger_prefix',"$")
-                if trigger_prefix == "#": # 跟插件聊天指令前缀相同，继续递交
+                trigger_prefix = conf().get("plugin_trigger_prefix", "$")
+                if trigger_prefix == "#":  # 跟插件聊天指令前缀相同，继续递交
                     return
                 ok, result = False, f"未知指令：{cmd}\n查看指令列表请输入#help \n"
-            
+
             reply = Reply()
             if ok:
                 reply.type = ReplyType.INFO
             else:
                 reply.type = ReplyType.ERROR
             reply.content = result
-            e_context['reply'] = reply
+            e_context["reply"] = reply
 
-            e_context.action = EventAction.BREAK_PASS # 事件结束，并跳过处理context的默认逻辑
+            e_context.action = EventAction.BREAK_PASS  # 事件结束，并跳过处理context的默认逻辑
         elif not self.isrunning:
             e_context.action = EventAction.BREAK_PASS
 
-    def authenticate(self, userid, args, isadmin, isgroup) -> Tuple[bool,str] : 
+    def authenticate(self, userid, args, isadmin, isgroup) -> Tuple[bool, str]:
         if isgroup:
-            return False,"请勿在群聊中认证"
-        
+            return False, "请勿在群聊中认证"
+
         if isadmin:
-            return False,"管理员账号无需认证"
-        
+            return False, "管理员账号无需认证"
+
         if len(args) != 1:
-            return False,"请提供口令"
-        
+            return False, "请提供口令"
+
         password = args[0]
         if password == self.password:
             self.admin_users.append(userid)
-            return True,"认证成功"
+            return True, "认证成功"
         elif password == self.temp_password:
             self.admin_users.append(userid)
-            return True,"认证成功，请尽快设置口令"
+            return True, "认证成功，请尽快设置口令"
         else:
-            return False,"认证失败"
+            return False, "认证失败"
 
-    def get_help_text(self, isadmin = False, isgroup = False, **kwargs):
-        return get_help_text(isadmin, isgroup)
+    def get_help_text(self, isadmin=False, isgroup=False, **kwargs):
+        return get_help_text(isadmin, isgroup)

plugins/hello/__init__.py

@@ -1 +1 @@
-from .hello import *
+from .hello import *

plugins/hello/hello.py

@@ -1,14 +1,21 @@
 # encoding:utf-8
 
+import plugins
 from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
 from channel.chat_message import ChatMessage
-import plugins
-from plugins import *
 from common.log import logger
+from plugins import *
 
 
-@plugins.register(name="Hello", desire_priority=-1, hidden=True, desc="A simple plugin that says hello", version="0.1", author="lanvent")
+@plugins.register(
+    name="Hello",
+    desire_priority=-1,
+    hidden=True,
+    desc="A simple plugin that says hello",
+    version="0.1",
+    author="lanvent",
+)
 class Hello(Plugin):
     def __init__(self):
         super().__init__()
@@ -16,33 +23,50 @@ class Hello(Plugin):
         logger.info("[Hello] inited")
 
     def on_handle_context(self, e_context: EventContext):
-
-        if e_context['context'].type != ContextType.TEXT:
+        if e_context["context"].type not in [
+            ContextType.TEXT,
+            ContextType.JOIN_GROUP,
+            ContextType.PATPAT,
+        ]:
             return
-        
-        content = e_context['context'].content
+
+        if e_context["context"].type == ContextType.JOIN_GROUP:
+            e_context["context"].type = ContextType.TEXT
+            msg: ChatMessage = e_context["context"]["msg"]
+            e_context["context"].content = f'请你随机使用一种风格说一句问候语来欢迎新用户"{msg.actual_user_nickname}"加入群聊。'
+            e_context.action = EventAction.CONTINUE  # 事件继续，交付给下个插件或默认逻辑
+            return
+
+        if e_context["context"].type == ContextType.PATPAT:
+            e_context["context"].type = ContextType.TEXT
+            msg: ChatMessage = e_context["context"]["msg"]
+            e_context["context"].content = f"请你随机使用一种风格介绍你自己，并告诉用户输入#help可以查看帮助信息。"
+            e_context.action = EventAction.CONTINUE  # 事件继续，交付给下个插件或默认逻辑
+            return
+
+        content = e_context["context"].content
         logger.debug("[Hello] on_handle_context. content: %s" % content)
         if content == "Hello":
             reply = Reply()
             reply.type = ReplyType.TEXT
-            msg:ChatMessage = e_context['context']['msg']
-            if e_context['context']['isgroup']:
+            msg: ChatMessage = e_context["context"]["msg"]
+            if e_context["context"]["isgroup"]:
                 reply.content = f"Hello, {msg.actual_user_nickname} from {msg.from_user_nickname}"
             else:
                 reply.content = f"Hello, {msg.from_user_nickname}"
-            e_context['reply'] = reply
-            e_context.action = EventAction.BREAK_PASS # 事件结束，并跳过处理context的默认逻辑
+            e_context["reply"] = reply
+            e_context.action = EventAction.BREAK_PASS  # 事件结束，并跳过处理context的默认逻辑
 
         if content == "Hi":
             reply = Reply()
             reply.type = ReplyType.TEXT
             reply.content = "Hi"
-            e_context['reply'] = reply
+            e_context["reply"] = reply
             e_context.action = EventAction.BREAK  # 事件结束，进入默认处理逻辑，一般会覆写reply
 
         if content == "End":
             # 如果是文本消息"End"，将请求转换成"IMAGE_CREATE"，并将content设置为"The World"
-            e_context['context'].type = ContextType.IMAGE_CREATE
+            e_context["context"].type = ContextType.IMAGE_CREATE
             content = "The World"
             e_context.action = EventAction.CONTINUE  # 事件继续，交付给下个插件或默认逻辑
 

plugins/keyword/README.md

@@ -0,0 +1,13 @@
+# 目的
+关键字匹配并回复
+
+# 试用场景
+目前是在微信公众号下面使用过。
+
+# 使用步骤
+1. 复制 `config.json.template` 为 `config.json`
+2. 在关键字 `keyword` 新增需要关键字匹配的内容
+3. 重启程序做验证
+
+# 验证结果
+![结果](test-keyword.png)

plugins/keyword/__init__.py

@@ -0,0 +1 @@
+from .keyword import *

plugins/keyword/config.json.template

@@ -0,0 +1,5 @@
+{
+  "keyword": {
+    "关键字匹配": "测试成功"
+  }
+}

plugins/keyword/keyword.py

@@ -0,0 +1,65 @@
+# encoding:utf-8
+
+import json
+import os
+
+import plugins
+from bridge.context import ContextType
+from bridge.reply import Reply, ReplyType
+from common.log import logger
+from plugins import *
+
+
+@plugins.register(
+    name="Keyword",
+    desire_priority=900,
+    hidden=True,
+    desc="关键词匹配过滤",
+    version="0.1",
+    author="fengyege.top",
+)
+class Keyword(Plugin):
+    def __init__(self):
+        super().__init__()
+        try:
+            curdir = os.path.dirname(__file__)
+            config_path = os.path.join(curdir, "config.json")
+            conf = None
+            if not os.path.exists(config_path):
+                logger.debug(f"[keyword]不存在配置文件{config_path}")
+                conf = {"keyword": {}}
+                with open(config_path, "w", encoding="utf-8") as f:
+                    json.dump(conf, f, indent=4)
+            else:
+                logger.debug(f"[keyword]加载配置文件{config_path}")
+                with open(config_path, "r", encoding="utf-8") as f:
+                    conf = json.load(f)
+            # 加载关键词
+            self.keyword = conf["keyword"]
+
+            logger.info("[keyword] {}".format(self.keyword))
+            self.handlers[Event.ON_HANDLE_CONTEXT] = self.on_handle_context
+            logger.info("[keyword] inited.")
+        except Exception as e:
+            logger.warn("[keyword] init failed, ignore or see https://github.com/zhayujie/chatgpt-on-wechat/tree/master/plugins/keyword .")
+            raise e
+
+    def on_handle_context(self, e_context: EventContext):
+        if e_context["context"].type != ContextType.TEXT:
+            return
+
+        content = e_context["context"].content.strip()
+        logger.debug("[keyword] on_handle_context. content: %s" % content)
+        if content in self.keyword:
+            logger.debug(f"[keyword] 匹配到关键字【{content}】")
+            reply_text = self.keyword[content]
+
+            reply = Reply()
+            reply.type = ReplyType.TEXT
+            reply.content = reply_text
+            e_context["reply"] = reply
+            e_context.action = EventAction.BREAK_PASS  # 事件结束，并跳过处理context的默认逻辑
+
+    def get_help_text(self, **kwargs):
+        help_text = "关键词过滤"
+        return help_text

plugins/plugin.py

@@ -3,4 +3,4 @@ class Plugin:
         self.handlers = {}
 
     def get_help_text(self, **kwargs):
-        return "暂无帮助信息"
+        return "暂无帮助信息"

plugins/plugin_manager.py

@@ -5,17 +5,19 @@ import importlib.util
 import json
 import os
 import sys
+
+from common.log import logger
 from common.singleton import singleton
 from common.sorted_dict import SortedDict
-from .event import *
-from common.log import logger
 from config import conf
 
+from .event import *
+
 
 @singleton
 class PluginManager:
     def __init__(self):
-        self.plugins = SortedDict(lambda k,v: v.priority,reverse=True)
+        self.plugins = SortedDict(lambda k, v: v.priority, reverse=True)
         self.listening_plugins = {}
         self.instances = {}
         self.pconf = {}
@@ -26,17 +28,18 @@ class PluginManager:
         def wrapper(plugincls):
             plugincls.name = name
             plugincls.priority = desire_priority
-            plugincls.desc = kwargs.get('desc')
-            plugincls.author = kwargs.get('author')
+            plugincls.desc = kwargs.get("desc")
+            plugincls.author = kwargs.get("author")
             plugincls.path = self.current_plugin_path
-            plugincls.version = kwargs.get('version') if kwargs.get('version') != None else "1.0"
-            plugincls.namecn = kwargs.get('namecn') if kwargs.get('namecn') != None else name
-            plugincls.hidden = kwargs.get('hidden') if kwargs.get('hidden') != None else False
+            plugincls.version = kwargs.get("version") if kwargs.get("version") != None else "1.0"
+            plugincls.namecn = kwargs.get("namecn") if kwargs.get("namecn") != None else name
+            plugincls.hidden = kwargs.get("hidden") if kwargs.get("hidden") != None else False
             plugincls.enabled = True
             if self.current_plugin_path == None:
                 raise Exception("Plugin path not set")
             self.plugins[name.upper()] = plugincls
             logger.info("Plugin %s_v%s registered, path=%s" % (name, plugincls.version, plugincls.path))
+
         return wrapper
 
     def save_config(self):
@@ -50,10 +53,10 @@ class PluginManager:
         if os.path.exists("./plugins/plugins.json"):
             with open("./plugins/plugins.json", "r", encoding="utf-8") as f:
                 pconf = json.load(f)
-                pconf['plugins'] = SortedDict(lambda k,v: v["priority"],pconf['plugins'],reverse=True)
+                pconf["plugins"] = SortedDict(lambda k, v: v["priority"], pconf["plugins"], reverse=True)
         else:
             modified = True
-            pconf = {"plugins": SortedDict(lambda k,v: v["priority"],reverse=True)}
+            pconf = {"plugins": SortedDict(lambda k, v: v["priority"], reverse=True)}
         self.pconf = pconf
         if modified:
             self.save_config()
@@ -67,7 +70,7 @@ class PluginManager:
             plugin_path = os.path.join(plugins_dir, plugin_name)
             if os.path.isdir(plugin_path):
                 # 判断插件是否包含同名__init__.py文件
-                main_module_path = os.path.join(plugin_path,"__init__.py")
+                main_module_path = os.path.join(plugin_path, "__init__.py")
                 if os.path.isfile(main_module_path):
                     # 导入插件
                     import_path = "plugins.{}".format(plugin_name)
@@ -77,7 +80,7 @@ class PluginManager:
                             if self.loaded[plugin_path] == None:
                                 logger.info("reload module %s" % plugin_name)
                                 self.loaded[plugin_path] = importlib.reload(sys.modules[import_path])
-                                dependent_module_names = [name for name in sys.modules.keys() if name.startswith( import_path+ '.')]
+                                dependent_module_names = [name for name in sys.modules.keys() if name.startswith(import_path + ".")]
                                 for name in dependent_module_names:
                                     logger.info("reload module %s" % name)
                                     importlib.reload(sys.modules[name])
@@ -96,11 +99,14 @@ class PluginManager:
             if rawname not in pconf["plugins"]:
                 modified = True
                 logger.info("Plugin %s not found in pconfig, adding to pconfig..." % name)
-                pconf["plugins"][rawname] = {"enabled": plugincls.enabled, "priority": plugincls.priority}
+                pconf["plugins"][rawname] = {
+                    "enabled": plugincls.enabled,
+                    "priority": plugincls.priority,
+                }
             else:
                 self.plugins[name].enabled = pconf["plugins"][rawname]["enabled"]
                 self.plugins[name].priority = pconf["plugins"][rawname]["priority"]
-                self.plugins._update_heap(name) # 更新下plugins中的顺序
+                self.plugins._update_heap(name)  # 更新下plugins中的顺序
         if modified:
             self.save_config()
         return new_plugins
@@ -109,7 +115,7 @@ class PluginManager:
         for event in self.listening_plugins.keys():
             self.listening_plugins[event].sort(key=lambda name: self.plugins[name].priority, reverse=True)
 
-    def activate_plugins(self): # 生成新开启的插件实例
+    def activate_plugins(self):  # 生成新开启的插件实例
         failed_plugins = []
         for name, plugincls in self.plugins.items():
             if plugincls.enabled:
@@ -117,7 +123,7 @@ class PluginManager:
                     try:
                         instance = plugincls()
                     except Exception as e:
-                        logger.warn("Failed to init %s, diabled. %s" % (name, e))
+                        logger.error("Failed to init %s, diabled. %s" % (name, e))
                         self.disable_plugin(name)
                         failed_plugins.append(name)
                         continue
@@ -129,7 +135,7 @@ class PluginManager:
         self.refresh_order()
         return failed_plugins
 
-    def reload_plugin(self, name:str):
+    def reload_plugin(self, name: str):
         name = name.upper()
         if name in self.instances:
             for event in self.listening_plugins:
@@ -139,13 +145,13 @@ class PluginManager:
             self.activate_plugins()
             return True
         return False
-    
+
     def load_plugins(self):
         self.load_config()
         self.scan_plugins()
         pconf = self.pconf
         logger.debug("plugins.json config={}".format(pconf))
-        for name,plugin in pconf["plugins"].items():
+        for name, plugin in pconf["plugins"].items():
             if name.upper() not in self.plugins:
                 logger.error("Plugin %s not found, but found in plugins.json" % name)
         self.activate_plugins()
@@ -154,12 +160,12 @@ class PluginManager:
         if e_context.event in self.listening_plugins:
             for name in self.listening_plugins[e_context.event]:
                 if self.plugins[name].enabled and e_context.action == EventAction.CONTINUE:
-                    logger.debug("Plugin %s triggered by event %s" % (name,e_context.event))
+                    logger.debug("Plugin %s triggered by event %s" % (name, e_context.event))
                     instance = self.instances[name]
                     instance.handlers[e_context.event](e_context, *args, **kwargs)
         return e_context
 
-    def set_plugin_priority(self, name:str, priority:int):
+    def set_plugin_priority(self, name: str, priority: int):
         name = name.upper()
         if name not in self.plugins:
             return False
@@ -174,11 +180,11 @@ class PluginManager:
         self.refresh_order()
         return True
 
-    def enable_plugin(self, name:str):
+    def enable_plugin(self, name: str):
         name = name.upper()
         if name not in self.plugins:
             return False, "插件不存在"
-        if not self.plugins[name].enabled :
+        if not self.plugins[name].enabled:
             self.plugins[name].enabled = True
             rawname = self.plugins[name].name
             self.pconf["plugins"][rawname]["enabled"] = True
@@ -188,39 +194,41 @@ class PluginManager:
                 return False, "插件开启失败"
             return True, "插件已开启"
         return True, "插件已开启"
-    
-    def disable_plugin(self, name:str):
+
+    def disable_plugin(self, name: str):
         name = name.upper()
         if name not in self.plugins:
             return False
-        if self.plugins[name].enabled :
+        if self.plugins[name].enabled:
             self.plugins[name].enabled = False
             rawname = self.plugins[name].name
             self.pconf["plugins"][rawname]["enabled"] = False
             self.save_config()
             return True
         return True
-    
+
     def list_plugins(self):
         return self.plugins
-    
-    def install_plugin(self, repo:str):
+
+    def install_plugin(self, repo: str):
         try:
             import common.package_manager as pkgmgr
+
             pkgmgr.check_dulwich()
         except Exception as e:
             logger.error("Failed to install plugin, {}".format(e))
             return False, "无法导入dulwich，安装插件失败"
         import re
+
         from dulwich import porcelain
 
         logger.info("clone git repo: {}".format(repo))
-        
+
         match = re.match(r"^(https?:\/\/|git@)([^\/:]+)[\/:]([^\/:]+)\/(.+).git$", repo)
-        
+
         if not match:
             try:
-                with open("./plugins/source.json","r", encoding="utf-8") as f:
+                with open("./plugins/source.json", "r", encoding="utf-8") as f:
                     source = json.load(f)
                 if repo in source["repo"]:
                     repo = source["repo"][repo]["url"]
@@ -232,42 +240,53 @@ class PluginManager:
             except Exception as e:
                 logger.error("Failed to install plugin, {}".format(e))
                 return False, "安装插件失败，请检查仓库地址是否正确"
-        dirname = os.path.join("./plugins",match.group(4))
+        dirname = os.path.join("./plugins", match.group(4))
         try:
             repo = porcelain.clone(repo, dirname, checkout=True)
-            if os.path.exists(os.path.join(dirname,"requirements.txt")):
+            if os.path.exists(os.path.join(dirname, "requirements.txt")):
                 logger.info("detect requirements.txt，installing...")
-            pkgmgr.install_requirements(os.path.join(dirname,"requirements.txt"))
+            pkgmgr.install_requirements(os.path.join(dirname, "requirements.txt"))
             return True, "安装插件成功，请使用 #scanp 命令扫描插件或重启程序，开启前请检查插件是否需要配置"
         except Exception as e:
             logger.error("Failed to install plugin, {}".format(e))
-            return False, "安装插件失败，"+str(e)
-        
-    def update_plugin(self, name:str):
+            return False, "安装插件失败，" + str(e)
+
+    def update_plugin(self, name: str):
         try:
             import common.package_manager as pkgmgr
+
             pkgmgr.check_dulwich()
         except Exception as e:
             logger.error("Failed to install plugin, {}".format(e))
             return False, "无法导入dulwich，更新插件失败"
         from dulwich import porcelain
+
         name = name.upper()
         if name not in self.plugins:
             return False, "插件不存在"
-        if name in ["HELLO","GODCMD","ROLE","TOOL","BDUNIT","BANWORDS","FINISH","DUNGEON"]:
+        if name in [
+            "HELLO",
+            "GODCMD",
+            "ROLE",
+            "TOOL",
+            "BDUNIT",
+            "BANWORDS",
+            "FINISH",
+            "DUNGEON",
+        ]:
             return False, "预置插件无法更新，请更新主程序仓库"
         dirname = self.plugins[name].path
         try:
             porcelain.pull(dirname, "origin")
-            if os.path.exists(os.path.join(dirname,"requirements.txt")):
+            if os.path.exists(os.path.join(dirname, "requirements.txt")):
                 logger.info("detect requirements.txt，installing...")
-            pkgmgr.install_requirements(os.path.join(dirname,"requirements.txt"))
+            pkgmgr.install_requirements(os.path.join(dirname, "requirements.txt"))
             return True, "更新插件成功，请重新运行程序"
         except Exception as e:
             logger.error("Failed to update plugin, {}".format(e))
-            return False, "更新插件失败，"+str(e)
-        
-    def uninstall_plugin(self, name:str):
+            return False, "更新插件失败，" + str(e)
+
+    def uninstall_plugin(self, name: str):
         name = name.upper()
         if name not in self.plugins:
             return False, "插件不存在"
@@ -276,6 +295,7 @@ class PluginManager:
         dirname = self.plugins[name].path
         try:
             import shutil
+
             shutil.rmtree(dirname)
             rawname = self.plugins[name].name
             for event in self.listening_plugins:
@@ -288,4 +308,4 @@ class PluginManager:
             return True, "卸载插件成功"
         except Exception as e:
             logger.error("Failed to uninstall plugin, {}".format(e))
-            return False, "卸载插件失败，请手动删除文件夹完成卸载，"+str(e)
+            return False, "卸载插件失败，请手动删除文件夹完成卸载，" + str(e)

plugins/role/__init__.py

@@ -1 +1 @@
-from .role import *
+from .role import *