使用docker搭建cow

2024-10-22 15:03:21 +08:00
parent 41f8655aeb
commit ca219143d0
5 changed files with 960 additions and 0 deletions
@@ -0,0 +1,548 @@
+import os
+import re
+import threading
+import time
+import requests
+from asyncio import CancelledError
+from concurrent.futures import Future, ThreadPoolExecutor
+
+from bridge.context import *
+from bridge.reply import *
+from channel.channel import Channel
+from common.dequeue import Dequeue
+from common import memory
+from plugins import *
+
+try:
+    from voice.audio_convert import any_to_wav
+except Exception as e:
+    pass
+
+handler_pool = ThreadPoolExecutor(max_workers=8)  # 处理消息的线程池
+
+
+# 抽象类, 它包含了与消息通道无关的通用处理逻辑
+class ChatChannel(Channel):
+    name = None  # 登录的用户名
+    user_id = None  # 登录的用户id
+    futures = {}  # 记录每个session_id提交到线程池的future对象, 用于重置会话时把没执行的future取消掉，正在执行的不会被取消
+    sessions = {}  # 用于控制并发，每个session_id同时只能有一个context在处理
+    lock = threading.Lock()  # 用于控制对sessions的访问
+
+    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用于第二步文本回复时，判断是否需要匹配前缀，如果是私聊的语音，就不需要匹配前缀
+        if "origin_ctype" not in context:
+            context["origin_ctype"] = ctype
+        # context首次传入时，receiver是None，根据类型设置receiver
+        first_in = "receiver" not in context
+        # 群名匹配过程，设置session_id和receiver
+        if first_in:  # context首次传入时，receiver是None，根据类型设置receiver
+            config = conf()
+            cmsg = context["msg"]
+            user_data = conf().get_user_data(cmsg.from_user_id)
+            context["openai_api_key"] = user_data.get("openai_api_key")
+            context["gpt_model"] = user_data.get("gpt_model")
+            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", [])
+                    session_id = cmsg.actual_user_id
+                    if any(
+                        [
+                            group_name in group_chat_in_one_session,
+                            "ALL_GROUP" in group_chat_in_one_session,
+                        ]
+                    ):
+                        session_id = group_id
+                else:
+                    logger.debug(f"No need reply, groupName not in whitelist, group_name={group_name}")
+                    return None
+                context["session_id"] = session_id
+                context["receiver"] = group_id
+            else:
+                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("[chat_channel]self message skipped")
+                return None
+
+        # 消息内容匹配过程，并处理content
+        if ctype == ContextType.TEXT:
+            if first_in and "」\n- - - - - - -" in content:  # 初次匹配 过滤引用消息
+                logger.debug(content)
+                logger.debug("[chat_channel]reference query skipped")
+                return None
+            
+            pattern = f"@{re.escape(self.name)}(\u2005|\u0020)"
+            content_search = re.sub(pattern, r"", content)
+            if isinstance(context["msg"].at_list, list):
+                for at in context["msg"].at_list:
+                    pattern = f"@{re.escape(at)}(\u2005|\u0020)"
+                    content_search = re.sub(pattern, r"", content_search)
+            if content_search == content and context["msg"].self_display_name:
+                # 前缀移除后没有变化，使用群昵称再次移除
+                pattern = f"@{re.escape(context['msg'].self_display_name)}(\u2005|\u0020)"
+                content_search = re.sub(pattern, r"", content)
+                
+            
+            # 去除字符串开头和结尾的所有空格字符
+            content_search = content_search.strip()
+            # logger.info("[来消息了] content={}, content_search={}".format(content, content_search))
+            content_search = process_string(content_search)
+
+
+            nick_name_black_list = conf().get("nick_name_black_list", [])
+            if context.get("isgroup", False):  # 群聊
+            
+                if any(content_search.startswith(prefix) for prefix in ["搜剧", "搜", "全网搜"]) and not content_search.startswith("搜索"):
+                    content_search = process_string2(content_search)
+                    user_nickname = context['msg'].actual_user_nickname
+                    reply_text = f"@{user_nickname}"
+                    
+
+                    contentSearch = remove_prefix(content_search, ["搜剧", "搜", "全网搜"]).strip()
+                
+                    def perform_search():
+                        # 初次搜索
+                        response_data = search_question(contentSearch) if not content_search.startswith("全网搜") else []
+                        if not response_data:
+                            # 通知用户深入搜索
+                            reply_text2 = f"@{user_nickname}\n正在深入搜索，请稍等..."
+                            self._send_reply(context, Reply(ReplyType.TEXT, reply_text2))
+                
+                            # 启动线程进行第二次搜索
+                            def perform_second_search():
+                                response_data = search_alone(contentSearch)
+                                send_final_reply(response_data, reply_text, context)
+                            
+                            second_search_thread = threading.Thread(target=perform_second_search)
+                            second_search_thread.start()
+                        else:
+                            # 如果第一次搜索找到结果，发送最终回复
+                            send_final_reply(response_data, reply_text, context)
+                
+                    def send_final_reply(response_data, reply_text, context):
+                        is_times = 0
+                        if not response_data:
+                            reply_text_final = f"{reply_text}\n未找到，可换个关键词尝试哦~"
+                            reply_text_final += "\n⚠️宁少写，不多写、错写~"
+                            # reply_text_final += "\n--------------------"
+                            # reply_text_final += "\n可访问以下链接提交资源需求"
+                            # reply_text_final += "\nhttps://pan.xinyuedh.com"
+                            # reply_text_final += "\n--------------------"
+                            # reply_text_final += "\nGPT小助手分享"
+                            # reply_text_final += "\n--------------------"
+                            # reply_text_final += "\nhttps://chat.xinyuedh.com"
+                        else:
+                            reply_text_final = f"{reply_text}\n--------------------"
+                            for item in response_data:
+                                if item.get('is_time') == 1:
+                                    reply_text_final += f"\n 🌐️ {item.get('title', '未知标题')}"
+                                    is_times += 1
+                                else:
+                                    reply_text_final += f"\n{item.get('title', '未知标题')}"
+                                reply_text_final += f"\n{item.get('url', '未知URL')}"
+                                reply_text_final += "\n--------------------"
+                            
+                            if is_times > 0:
+                                reply_text_final += "\n 🌐️资源来源网络，30分钟后删除"
+                                reply_text_final += "\n--------------------"
+                            else:
+                                reply_text_final += "\n 不是短剧？请尝试：全网搜XX"
+                                reply_text_final += "\n--------------------"
+                            
+                            reply_text_final += "\n欢迎观看！如果喜欢可以喊你的朋友一起来哦"
+                
+                        reply = Reply(ReplyType.TEXT, reply_text_final)
+                        self._send_reply(context, reply)
+
+                
+                    # 启动线程执行第一次搜索
+                    first_search_thread = threading.Thread(target=perform_search)
+                    first_search_thread.start()
+                    return None
+                
+                # 校验关键字
+                match_prefix = check_prefix(content, conf().get("group_chat_prefix"))
+                match_contain = check_contain(content, conf().get("group_chat_keyword"))
+                flag = False
+                if context["msg"].to_user_id != context["msg"].actual_user_id:
+                    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:
+                        nick_name = context["msg"].actual_user_nickname
+                        if nick_name and nick_name in nick_name_black_list:
+                            # 黑名单过滤
+                            logger.warning(f"[chat_channel] Nickname {nick_name} in In BlackList, ignore")
+                            return None
+
+                        logger.info("[chat_channel]receive group at")
+                        if not conf().get("group_at_off", False):
+                            flag = True
+                        pattern = f"@{re.escape(self.name)}(\u2005|\u0020)"
+                        subtract_res = re.sub(pattern, r"", content)
+                        if subtract_res.startswith("画"):
+                            subtract_res = "生成图片要求如下：\n" + subtract_res[1:]
+                        
+                        if isinstance(context["msg"].at_list, list):
+                            for at in context["msg"].at_list:
+                                pattern = f"@{re.escape(at)}(\u2005|\u0020)"
+                                subtract_res = re.sub(pattern, r"", subtract_res)
+                        if subtract_res == content and context["msg"].self_display_name:
+                            # 前缀移除后没有变化，使用群昵称再次移除
+                            pattern = f"@{re.escape(context['msg'].self_display_name)}(\u2005|\u0020)"
+                            subtract_res = re.sub(pattern, r"", content)
+                        content = subtract_res
+                if not flag:
+                    if context["origin_ctype"] == ContextType.VOICE:
+                        logger.info("[chat_channel]receive group voice, but checkprefix didn't match")
+                    return None
+            else:  # 单聊
+                nick_name = context["msg"].from_user_nickname
+                if nick_name and nick_name in nick_name_black_list:
+                    # 黑名单过滤
+                    logger.warning(f"[chat_channel] Nickname '{nick_name}' in In BlackList, ignore")
+                    return None
+
+                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
+            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)
+                context.type = ContextType.IMAGE_CREATE
+            else:
+                context.type = ContextType.TEXT
+            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("[chat_channel] ready to handle context: {}".format(context))
+        # reply的构建步骤
+        reply = self._generate_reply(context)
+
+        logger.debug("[chat_channel] ready to decorate reply: {}".format(reply))
+
+        # reply的包装步骤
+        if reply and reply.content:
+            reply = self._decorate_reply(context, reply)
+
+            # reply的发送步骤
+            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"]
+        if not e_context.is_pass():
+            logger.debug("[chat_channel] ready to handle context: type={}, content={}".format(context.type, context.content))
+            if context.type == ContextType.TEXT or context.type == ContextType.IMAGE_CREATE:  # 文字和图片消息
+                context["channel"] = e_context["channel"]
+                reply = super().build_reply_content(context.content, context)
+            elif context.type == ContextType.VOICE:  # 语音消息
+                cmsg = context["msg"]
+                cmsg.prepare()
+                file_path = context.content
+                wav_path = os.path.splitext(file_path)[0] + ".wav"
+                try:
+                    any_to_wav(file_path, wav_path)
+                except Exception as e:  # 转换失败，直接使用mp3，对于某些api，mp3也可以识别
+                    logger.warning("[chat_channel]any to wav error, use raw path. " + str(e))
+                    wav_path = file_path
+                # 语音识别
+                reply = super().build_voice_to_text(wav_path)
+                # 删除临时文件
+                try:
+                    os.remove(file_path)
+                    if wav_path != file_path:
+                        os.remove(wav_path)
+                except Exception as e:
+                    pass
+                    # logger.warning("[chat_channel]delete temp file error: " + str(e))
+
+                if reply.type == ReplyType.TEXT:
+                    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:  # 图片消息，当前仅做下载保存到本地的逻辑
+                memory.USER_IMAGE_CACHE[context["session_id"]] = {
+                    "path": context.content,
+                    "msg": context.get("msg")
+                }
+            elif context.type == ContextType.SHARING:  # 分享信息，当前无默认逻辑
+                pass
+            elif context.type == ContextType.FUNCTION or context.type == ContextType.FILE:  # 文件消息及函数调用等，当前无默认逻辑
+                pass
+            else:
+                logger.warning("[chat_channel] 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")
+            if not e_context.is_pass() and reply and reply.type:
+                if reply.type in self.NOT_SUPPORT_REPLYTYPE:
+                    logger.error("[chat_channel]reply type not support: " + str(reply.type))
+                    reply.type = ReplyType.ERROR
+                    reply.content = "不支持发送的消息类型: " + str(reply.type)
+
+                if reply.type == ReplyType.TEXT:
+                    reply_text = reply.content
+                    if desire_rtype == ReplyType.VOICE and ReplyType.VOICE not in self.NOT_SUPPORT_REPLYTYPE:
+                        reply = super().build_text_to_voice(reply.content)
+                        return self._decorate_reply(context, reply)
+                    if context.get("isgroup", False):
+                        if not context.get("no_need_at", False):
+                            reply_text = "@" + context["msg"].actual_user_nickname + "\n" + reply_text.strip()
+                        reply_text = conf().get("group_chat_reply_prefix", "") + reply_text + conf().get("group_chat_reply_suffix", "")
+                    else:
+                        reply_text = conf().get("single_chat_reply_prefix", "") + reply_text + conf().get("single_chat_reply_suffix", "")
+                    reply.content = reply_text
+                elif reply.type == ReplyType.ERROR or reply.type == ReplyType.INFO:
+                    reply.content = "[" + str(reply.type) + "]\n" + reply.content
+                elif reply.type == ReplyType.IMAGE_URL or reply.type == ReplyType.VOICE or reply.type == ReplyType.IMAGE or reply.type == ReplyType.FILE or reply.type == ReplyType.VIDEO or reply.type == ReplyType.VIDEO_URL:
+                    pass
+                else:
+                    logger.error("[chat_channel] 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("[chat_channel] 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"]
+            if not e_context.is_pass() and reply and reply.type:
+                logger.debug("[chat_channel] ready to send reply: {}, context: {}".format(reply, context))
+                self._send(reply, context)
+
+    def _send(self, reply: Reply, context: Context, retry_cnt=0):
+        try:
+            self.send(reply, context)
+        except Exception as e:
+            logger.error("[chat_channel] 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)
+
+    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):
+            try:
+                worker_exception = worker.exception()
+                if worker_exception:
+                    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"]
+        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)  # 优先处理管理命令
+            else:
+                self.sessions[session_id][0].put(context)
+
+    # 消费者函数，单独线程，用于从消息队列中取出消息并处理
+    def consume(self):
+        while True:
+            with self.lock:
+                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 not context_queue.empty():
+                            context = context_queue.get()
+                            logger.debug("[chat_channel] consume context: {}".format(context))
+                            future: Future = 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:  # 除了当前，没有任务再申请到信号量，说明所有任务都处理完毕
+                            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]
+                        else:
+                            semaphore.release()
+            time.sleep(0.1)
+
+    # 取消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:
+                    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:
+                    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:
+        return None
+    for prefix in prefix_list:
+        if content.startswith(prefix):
+            return prefix
+    return None
+
+
+def check_contain(content, keyword_list):
+    if not keyword_list:
+        return None
+    for ky in keyword_list:
+        if content.find(ky) != -1:
+            return True
+    return None
+
+
+def remove_prefix(content, prefixes):
+    for prefix in prefixes:
+        if content.startswith(prefix):
+            return content[len(prefix):].strip()
+    return content.strip()
+    
+
+    
+def process_string(s):
+    # 判断是否以@开头并且包含"搜"字
+    if s.startswith('@') and '搜' in s:
+        # 找到"搜"字的位置
+        index = s.index('搜')
+        # 去除"搜"字前面的内容
+        return s[index:]
+    else:
+        return s
+        
+def process_string2(s):
+    # 判断是否包含@
+    if '@' in s:
+        # 找到@字符的位置
+        index = s.index('@')
+        # 删除包含@在内后面的所有字符
+        return s[:index]
+    else:
+        return s
+
+
+
+def search_question(question):
+    url = conf().get("duanju_url", "") + '/api/search'
+    params = {
+        'is_time': '1',
+        'page_no': '1',
+        'page_size': '5',
+        'title': question
+    }
+    try:
+        response = requests.get(url, params=params)
+        response.raise_for_status()  # 检查请求是否成功
+        responseData = response.json().get('data', {}).get('items', [])
+        return responseData
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching data: {e}")
+        return []
+
+def search_alone(question):
+    url = conf().get("duanju_url", "") + '/api/other/all_search'
+    payload = {
+        'title': question
+    }
+    try:
+        response = requests.post(url, json=payload)
+        response.raise_for_status()
+        responseData = response.json().get('data', [])
+        return responseData
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching data: {e}")
+        return []    
@@ -0,0 +1,36 @@
+{
+    "debug": true,
+    "duanju_url": "https://pan.xinyuedh.com",
+    "channel_type": "wx",
+    "model": "gpt-4",
+    "open_ai_api_key": "",
+    "open_ai_api_base": "",
+    "text_to_image": "dall-e-3",
+    "claude_api_key": "YOUR API KEY",
+    "voice_to_text": "openai",
+    "text_to_voice": "openai",
+    "proxy": "",
+    "hot_reload": true,
+    "single_chat_prefix": [""],
+    "single_chat_reply_prefix": "[bot]",
+    "group_chat_prefix": [
+        "@bot"
+    ],
+    "group_name_white_list": [
+        "测试群群群",
+        "测试群群群2"
+    ], 
+    "image_create_prefix": [],
+    "speech_recognition": true,
+    "group_speech_recognition": false,
+    "voice_reply_voice": false,
+    "conversation_max_tokens": 2500,
+    "expires_in_seconds": 3600,
+    "character_desc": "你是基于大语言模型的AI智能助手，旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。",
+    "temperature": 0.7,
+    "subscribe_msg": "感谢您的关注！\n这里是AI智能助手，可以自由对话。\n支持语音对话。\n支持图片输入。\n支持图片输出，画字开头的消息将按要求创作图片。\n支持tool、角色扮演和文字冒险等丰富的插件。",
+    "use_linkai": false,
+    "linkai_api_key": "",
+    "linkai_app_code": "",
+    "linkai_api_base": ""
+}
@@ -0,0 +1,357 @@
+# encoding:utf-8
+
+import json
+import logging
+import os
+import pickle
+import copy
+
+from common.log import logger
+
+# 将所有可用的配置项写在字典里, 请使用小写字母
+# 此处的配置值无实际意义，程序不会读取此处的配置，仅用于提示格式，请将配置加入到config.json中
+available_setting = {
+    # 你的心悦搜索网址
+    "duanju_url": "",
+    # openai api配置
+    "open_ai_api_key": "",  # openai api key
+    # openai apibase，当use_azure_chatgpt为true时，需要设置对应的api base
+    "open_ai_api_base": "https://api.openai.com/v1",
+    "proxy": "",  # openai使用的代理
+    # chatgpt模型， 当use_azure_chatgpt为true时，其名称为Azure上model deployment名称
+    "model": "gpt-3.5-turbo",  # 可选择: gpt-4o, pt-4o-mini, gpt-4-turbo, claude-3-sonnet, wenxin, moonshot, qwen-turbo, xunfei, glm-4, minimax, gemini等模型，全部可选模型详见common/const.py文件
+    "bot_type": "",  # 可选配置，使用兼容openai格式的三方服务时候，需填"chatGPT"。bot具体名称详见common/const.py文件列出的bot_type，如不填根据model名称判断，
+    "use_azure_chatgpt": False,  # 是否使用azure的chatgpt
+    "azure_deployment_id": "",  # azure 模型部署名称
+    "azure_api_version": "",  # azure api版本
+    # Bot触发配置
+    "single_chat_prefix": ["bot", "@bot"],  # 私聊时文本需要包含该前缀才能触发机器人回复
+    "single_chat_reply_prefix": "[bot] ",  # 私聊时自动回复的前缀，用于区分真人
+    "single_chat_reply_suffix": "",  # 私聊时自动回复的后缀，\n 可以换行
+    "group_chat_prefix": ["@bot"],  # 群聊时包含该前缀则会触发机器人回复
+    "no_need_at": False,  # 群聊回复时是否不需要艾特
+    "group_chat_reply_prefix": "",  # 群聊时自动回复的前缀
+    "group_chat_reply_suffix": "",  # 群聊时自动回复的后缀，\n 可以换行
+    "group_chat_keyword": [],  # 群聊时包含该关键词则会触发机器人回复
+    "group_at_off": False,  # 是否关闭群聊时@bot的触发
+    "group_name_white_list": ["ChatGPT测试群", "ChatGPT测试群2"],  # 开启自动回复的群名称列表
+    "group_name_keyword_white_list": [],  # 开启自动回复的群名称关键词列表
+    "group_chat_in_one_session": ["ChatGPT测试群"],  # 支持会话上下文共享的群名称
+    "nick_name_black_list": [],  # 用户昵称黑名单
+    "group_welcome_msg": "",  # 配置新人进群固定欢迎语，不配置则使用随机风格欢迎
+    "trigger_by_self": False,  # 是否允许机器人触发
+    "text_to_image": "dall-e-2",  # 图片生成模型，可选 dall-e-2, dall-e-3
+    # Azure OpenAI dall-e-3 配置
+    "dalle3_image_style": "vivid", # 图片生成dalle3的风格，可选有 vivid, natural
+    "dalle3_image_quality": "hd", # 图片生成dalle3的质量，可选有 standard, hd
+    # Azure OpenAI DALL-E API 配置, 当use_azure_chatgpt为true时,用于将文字回复的资源和Dall-E的资源分开.
+    "azure_openai_dalle_api_base": "", # [可选] azure openai 用于回复图片的资源 endpoint，默认使用 open_ai_api_base
+    "azure_openai_dalle_api_key": "", # [可选] azure openai 用于回复图片的资源 key，默认使用 open_ai_api_key
+    "azure_openai_dalle_deployment_id":"", # [可选] azure openai 用于回复图片的资源 deployment id，默认使用 text_to_image
+    "image_proxy": True,  # 是否需要图片代理，国内访问LinkAI时需要
+    "image_create_prefix": ["画", "看", "找"],  # 开启图片回复的前缀
+    "concurrency_in_session": 1,  # 同一会话最多有多少条消息在处理中，大于1可能乱序
+    "image_create_size": "256x256",  # 图片大小,可选有 256x256, 512x512, 1024x1024 (dall-e-3默认为1024x1024)
+    "group_chat_exit_group": False,
+    # 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": 180,  # chatgpt请求超时时间，openai接口默认设置为600，对于难问题一般需要较长时间
+    "timeout": 120,  # chatgpt重试超时时间，在这个时间内，将会自动重试
+    # Baidu 文心一言参数
+    "baidu_wenxin_model": "eb-instant",  # 默认使用ERNIE-Bot-turbo模型
+    "baidu_wenxin_api_key": "",  # Baidu api key
+    "baidu_wenxin_secret_key": "",  # Baidu secret key
+    "baidu_wenxin_prompt_enabled": False,  # Enable prompt if you are using ernie character model
+    # 讯飞星火API
+    "xunfei_app_id": "",  # 讯飞应用ID
+    "xunfei_api_key": "",  # 讯飞 API key
+    "xunfei_api_secret": "",  # 讯飞 API secret
+    "xunfei_domain": "",  # 讯飞模型对应的domain参数，Spark4.0 Ultra为 4.0Ultra，其他模型详见: https://www.xfyun.cn/doc/spark/Web.html
+    "xunfei_spark_url": "",  # 讯飞模型对应的请求地址，Spark4.0 Ultra为 wss://spark-api.xf-yun.com/v4.0/chat，其他模型参考详见: https://www.xfyun.cn/doc/spark/Web.html
+    # claude 配置
+    "claude_api_cookie": "",
+    "claude_uuid": "",
+    # claude api key
+    "claude_api_key": "",
+    # 通义千问API, 获取方式查看文档 https://help.aliyun.com/document_detail/2587494.html
+    "qwen_access_key_id": "",
+    "qwen_access_key_secret": "",
+    "qwen_agent_key": "",
+    "qwen_app_id": "",
+    "qwen_node_id": "",  # 流程编排模型用到的id，如果没有用到qwen_node_id，请务必保持为空字符串
+    # 阿里灵积(通义新版sdk)模型api key
+    "dashscope_api_key": "",
+    # Google Gemini Api Key
+    "gemini_api_key": "",
+    # wework的通用配置
+    "wework_smart": True,  # 配置wework是否使用已登录的企业微信，False为多开
+    # 语音设置
+    "speech_recognition": True,  # 是否开启语音识别
+    "group_speech_recognition": False,  # 是否开启群组语音识别
+    "voice_reply_voice": False,  # 是否使用语音回复语音，需要设置对应语音合成引擎的api key
+    "always_reply_voice": False,  # 是否一直使用语音回复
+    "voice_to_text": "openai",  # 语音识别引擎，支持openai,baidu,google,azure,xunfei,ali
+    "text_to_voice": "openai",  # 语音合成引擎，支持openai,baidu,google,azure,xunfei,ali,pytts(offline),elevenlabs,edge(online)
+    "text_to_voice_model": "tts-1",
+    "tts_voice_id": "alloy",
+    # 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",
+    # elevenlabs 语音api配置
+    "xi_api_key": "",  # 获取ap的方法可以参考https://docs.elevenlabs.io/api-reference/quick-start/authentication
+    "xi_voice_id": "",  # ElevenLabs提供了9种英式、美式等英语发音id，分别是“Adam/Antoni/Arnold/Bella/Domi/Elli/Josh/Rachel/Sam”
+    # 服务时间限制，目前支持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_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
+    # 飞书配置
+    "feishu_port": 80,  # 飞书bot监听端口
+    "feishu_app_id": "",  # 飞书机器人应用APP Id
+    "feishu_app_secret": "",  # 飞书机器人APP secret
+    "feishu_token": "",  # 飞书 verification token
+    "feishu_bot_name": "",  # 飞书机器人的名字
+    # 钉钉配置
+    "dingtalk_client_id": "",  # 钉钉机器人Client ID 
+    "dingtalk_client_secret": "",  # 钉钉机器人Client Secret
+    "dingtalk_card_enabled": False,
+    
+    # chatgpt指令自定义触发词
+    "clear_memory_commands": ["#清除记忆"],  # 重置会话指令，必须以#开头
+    # channel配置
+    "channel_type": "",  # 通道类型，支持：{wx,wxy,terminal,wechatmp,wechatmp_service,wechatcom_app,dingtalk}
+    "subscribe_msg": "",  # 订阅消息, 支持: wechatmp, wechatmp_service, wechatcom_app
+    "debug": False,  # 是否开启debug模式，开启后会打印更多日志
+    "appdata_dir": "",  # 数据目录
+    # 插件配置
+    "plugin_trigger_prefix": "$",  # 规范插件提供聊天相关指令的前缀，建议不要和管理员指令前缀"#"冲突
+    # 是否使用全局插件配置
+    "use_global_plugin_config": False,
+    "max_media_send_count": 3,  # 单次最大发送媒体资源的个数
+    "media_send_interval": 1,  # 发送图片的事件间隔，单位秒
+    # 智谱AI 平台配置
+    "zhipu_ai_api_key": "",
+    "zhipu_ai_api_base": "https://open.bigmodel.cn/api/paas/v4",
+    "moonshot_api_key": "",
+    "moonshot_base_url": "https://api.moonshot.cn/v1/chat/completions",
+    # LinkAI平台配置
+    "use_linkai": False,
+    "linkai_api_key": "",
+    "linkai_app_code": "",
+    "linkai_api_base": "https://api.link-ai.tech",  # linkAI服务地址
+    "Minimax_api_key": "",
+    "Minimax_group_id": "",
+    "Minimax_base_url": "",
+}
+
+
+class Config(dict):
+    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 = {}
+
+    def __getitem__(self, key):
+        if key not in available_setting:
+            raise Exception("key {} not in available_setting".format(key))
+        return super().__getitem__(key)
+
+    def __setitem__(self, key, value):
+        if key not in available_setting:
+            raise Exception("key {} not in available_setting".format(key))
+        return super().__setitem__(key, value)
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError as e:
+            return default
+        except Exception as e:
+            raise e
+
+    # Make sure to return a dictionary to ensure atomic
+    def get_user_data(self, user) -> dict:
+        if self.user_datas.get(user) is None:
+            self.user_datas[user] = {}
+        return self.user_datas[user]
+
+    def load_user_datas(self):
+        try:
+            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:
+            logger.info("[Config] User datas file not found, ignore.")
+        except Exception as e:
+            logger.info("[Config] User datas error: {}".format(e))
+            self.user_datas = {}
+
+    def save_user_datas(self):
+        try:
+            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()
+
+
+def drag_sensitive(config):
+    try:
+        if isinstance(config, str):
+            conf_dict: dict = json.loads(config)
+            conf_dict_copy = copy.deepcopy(conf_dict)
+            for key in conf_dict_copy:
+                if "key" in key or "secret" in key:
+                    if isinstance(conf_dict_copy[key], str):
+                        conf_dict_copy[key] = conf_dict_copy[key][0:3] + "*" * 5 + conf_dict_copy[key][-3:]
+            return json.dumps(conf_dict_copy, indent=4)
+
+        elif isinstance(config, dict):
+            config_copy = copy.deepcopy(config)
+            for key in config:
+                if "key" in key or "secret" in key:
+                    if isinstance(config_copy[key], str):
+                        config_copy[key] = config_copy[key][0:3] + "*" * 5 + config_copy[key][-3:]
+            return config_copy
+    except Exception as e:
+        logger.exception(e)
+        return config
+    return config
+
+
+def load_config():
+    global config
+    config_path = "./config.json"
+    if not os.path.exists(config_path):
+        logger.info("配置文件不存在，将使用config-template.json模板")
+        config_path = "./config-template.json"
+
+    config_str = read_file(config_path)
+    logger.debug("[INIT] config str: {}".format(drag_sensitive(config_str)))
+
+    # 将json字符串反序列化为dict类型
+    config = Config(json.loads(config_str))
+
+    # override config with environment variables.
+    # Some online deployment platforms (e.g. Railway) deploy project from github directly. So you shouldn't put your secrets like api key in a config file, instead use environment variables to override the default 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))
+            try:
+                config[name] = eval(value)
+            except:
+                if value == "false":
+                    config[name] = False
+                elif value == "true":
+                    config[name] = True
+                else:
+                    config[name] = value
+
+    if config.get("debug", False):
+        logger.setLevel(logging.DEBUG)
+        logger.debug("[INIT] set log level to DEBUG")
+
+    logger.info("[INIT] load config: {}".format(drag_sensitive(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:
+        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)
+
+
+# global plugin config
+plugin_config = {}
+
+
+def write_plugin_config(pconf: dict):
+    """
+    写入插件全局配置
+    :param pconf: 全量插件配置
+    """
+    global plugin_config
+    for k in pconf:
+        plugin_config[k.lower()] = pconf[k]
+
+
+def pconf(plugin_name: str) -> dict:
+    """
+    根据插件名称获取配置
+    :param plugin_name: 插件名称
+    :return: 该插件的配置项
+    """
+    return plugin_config.get(plugin_name.lower())
+
+
+# 全局配置，用于存放全局生效的状态
+global_config = {"admin_users": []}
@@ -0,0 +1,11 @@
+version: '2.0'
+services:
+  chatgpt-on-wechat:
+    image: zhayujie/chatgpt-on-wechat
+    container_name: chatgpt-on-wechat
+    security_opt:
+      - seccomp:unconfined
+    volumes:
+      - ./config.json:/app/config.json
+      - ./config.py:/app/config.py
+      - ./chat_channel.py:/app/channel/chat_channel.py
@@ -0,0 +1,8 @@
+打开config.json  修改第3行网址即可，其它功能看官方教程
+
+在chatgpt-on-wechat所在目录下执行以下命令启动容器：
+sudo docker compose up -d
+
+
+
+用python搭建的不用换，一段时间后还是会出现无响应断开的情况