Upload 33 files

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2022 zhayujie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,13 @@
 ---
-title: LLMspace
-emoji: 🚀
-colorFrom: indigo
-colorTo: pink
+title: wechat-bot
+emoji: 👀
+colorFrom: red
+colorTo: yellow
 sdk: gradio
-sdk_version: 4.12.0
+sdk_version: 3.19.1
 app_file: app.py
 pinned: false
+duplicated_from: lewisliuX123/wechatgpt35
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,22 +1,45 @@
+# encoding:utf-8
+
+import config
 import gradio as gr
-def predict(message, history):
-    history_openai_format = []
-    for human, assistant in history:
-        history_openai_format.append({"role": "user", "content": human })
-        history_openai_format.append({"role": "assistant", "content":assistant})
-    history_openai_format.append({"role": "user", "content": message})
-
-    response = openai.ChatCompletion.create(
-        model='gpt-3.5-turbo',
-        messages= history_openai_format,
-        temperature=1.0,
-        stream=True
-    )
-
-    partial_message = ""
-    for chunk in response:
-        if len(chunk['choices'][0]['delta']) != 0:
-            partial_message = partial_message + chunk['choices'][0]['delta']['content']
-            yield partial_message
-
-gr.ChatInterface(predict).launch()
+from channel import channel_factory
+from common.log import logger
+from io import BytesIO
+from PIL import Image
+from concurrent.futures import ThreadPoolExecutor
+thread_pool = ThreadPoolExecutor(max_workers=8)
+
+def getImage(bytes):
+    bytes_stream = BytesIO(bytes)
+    image = Image.open(bytes_stream)
+    return image
+
+def getLoginUrl():
+    # load config
+        config.load_config()
+        
+        # create channel
+        bot = channel_factory.create_channel("wx")
+        thread_pool.submit(bot.startup)
+
+        while (True):
+            if bot.getQrCode():
+                return getImage(bot.getQrCode())
+
+if __name__ == '__main__':
+    try:
+        
+        with gr.Blocks() as demo:
+            with gr.Row():
+                with gr.Column():
+                    btn = gr.Button(value="生成二维码")
+                with gr.Column():
+                    outputs=[gr.Pil()]
+                btn.click(getLoginUrl, outputs=outputs)
+
+        demo.launch()
+
+
+    except Exception as e:
+        logger.error("App startup failed!")
+        logger.exception(e)

bot/baidu/baidu_unit_bot.py

@@ -0,0 +1,26 @@
+# encoding:utf-8
+
+import requests
+from bot.bot import Bot
+
+
+# Baidu Unit对话接口 (可用, 但能力较弱)
+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}}}"
+        print(post_data)
+        headers = {'content-type': 'application/x-www-form-urlencoded'}
+        response = requests.post(url, data=post_data.encode(), headers=headers)
+        if response:
+            return response.json()['result']['context']['SYS_PRESUMED_HIST'][1]
+
+    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
+        response = requests.get(host)
+        if response:
+            print(response.json())
+            return response.json()['access_token']

bot/bot.py

@@ -0,0 +1,13 @@
+"""
+Auto-replay chat robot abstract class
+"""
+
+
+class Bot(object):
+    def reply(self, query, context=None):
+        """
+        bot auto-reply content
+        :param req: received message
+        :return: reply content
+        """
+        raise NotImplementedError

bot/bot_factory.py

@@ -0,0 +1,26 @@
+"""
+channel factory
+"""
+
+
+def create_bot(bot_type):
+    """
+    create a channel instance
+    :param channel_type: channel type code
+    :return: channel instance
+    """
+    if bot_type == 'baidu':
+        # Baidu Unit对话接口
+        from bot.baidu.baidu_unit_bot import BaiduUnitBot
+        return BaiduUnitBot()
+
+    elif bot_type == 'chatGPT':
+        # ChatGPT 网页端web接口
+        from bot.chatgpt.chat_gpt_bot import ChatGPTBot
+        return ChatGPTBot()
+
+    elif bot_type == 'openAI':
+        # OpenAI 官方对话模型API
+        from bot.openai.open_ai_bot import OpenAIBot
+        return OpenAIBot()
+    raise RuntimeError

bot/chatgpt/chat_gpt_bot.py

@@ -0,0 +1,131 @@
+# encoding:utf-8
+
+from bot.bot import Bot
+from config import conf
+from common.log import logger
+import openai
+import time
+
+user_session = dict()
+
+# OpenAI对话模型API (可用)
+class ChatGPTBot(Bot):
+    def __init__(self):
+        openai.api_key = conf().get('open_ai_api_key')
+        # openai.api_base="https://apai.zyai.online/v1"
+
+    def reply(self, query, context=None):
+        # acquire reply content
+        if not context or not context.get('type') or context.get('type') == 'TEXT':
+            logger.info("[OPEN_AI] query={}".format(query))
+            from_user_id = context['from_user_id']
+            if query == '#清除记忆':
+                Session.clear_session(from_user_id)
+                return '记忆已清除'
+
+            new_query = Session.build_session_query(query, from_user_id)
+            logger.debug("[OPEN_AI] session query={}".format(new_query))
+
+            # if context.get('stream'):
+            #     # reply in stream
+            #     return self.reply_text_stream(query, new_query, from_user_id)
+
+            reply_content = self.reply_text(new_query, from_user_id, 0)
+            logger.debug("[OPEN_AI] new_query={}, user={}, reply_cont={}".format(new_query, from_user_id, reply_content))
+            if reply_content:
+                Session.save_session(query, reply_content, from_user_id)
+            return reply_content
+
+        elif context.get('type', None) == 'IMAGE_CREATE':
+            return self.create_img(query, 0)
+
+    def reply_text(self, query, user_id, retry_count=0):
+        try:
+            response = openai.ChatCompletion.create(
+                model="gpt-3.5-turbo",  # 对话模型的名称
+                messages=query,
+                temperature=1,  # 值在[0,1]之间，越大表示回复越具有不确定性
+                max_tokens=600,  # 回复最大的字符数
+                top_p=1,
+                frequency_penalty=0,  # [-2,2]之间，该值越大则更倾向于产生不同的内容
+                presence_penalty=0,  # [-2,2]之间，该值越大则更倾向于产生不同的内容
+            )
+            # res_content = response.choices[0]['text'].strip().replace('<|endoftext|>', '')
+            logger.info(response.choices[0]['message']['content'])
+            # log.info("[OPEN_AI] reply={}".format(res_content))
+            return response.choices[0]['message']['content']
+        # except openai.error.RateLimitError as e:
+        #     # rate limit exception
+        #     logger.warn(e)
+        #     if retry_count < 3:
+        #         time.sleep(5)
+        #         logger.warn("[OPEN_AI] RateLimit exceed, 第{}次重试".format(retry_count+1))
+        #         return self.reply_text(query, user_id, retry_count+1)
+        #     else:
+        #         return "问太快了，慢点行不行"
+        except Exception as e:
+            # unknown exception
+            logger.exception(e)
+            Session.clear_session(user_id)
+            return "没听懂"
+
+    def create_img(self, query, retry_count=0):
+        try:
+            logger.info("[OPEN_AI] image_query={}".format(query))
+            response = openai.Image.create(
+                prompt=query,    #图片描述
+                n=1,             #每次生成图片的数量
+                size="1024x1024"   #图片大小,可选有 256x256, 512x512, 1024x1024
+            )
+            image_url = response['data'][0]['url']
+            logger.info("[OPEN_AI] image_url={}".format(image_url))
+            return image_url
+        # except openai.error.RateLimitError as e:
+        #     logger.warn(e)
+        #     if retry_count < 3:
+        #         time.sleep(5)
+        #         logger.warn("[OPEN_AI] ImgCreate RateLimit exceed, 第{}次重试".format(retry_count+1))
+        #         return self.reply_text(query, retry_count+1)
+        #     else:
+        #         return "问太快了，慢点行不行"
+        except Exception as e:
+            logger.exception(e)
+            return None
+
+class Session(object):
+    @staticmethod
+    def build_session_query(query, user_id):
+        '''
+        build query with conversation history
+        e.g.  [
+            {"role": "system", "content": "You are a helpful assistant,let's think step by step in multiple different ways."},
+            {"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?"}
+        ]
+        :param query: query content
+        :param user_id: from user id
+        :return: query content with conversaction
+        '''
+        session = user_session.get(user_id, [])
+        if len(session) == 0:
+            system_prompt = conf().get("character_desc", "")
+            system_item = {'role': 'system', 'content': system_prompt}
+            session.append(system_item)
+            user_session[user_id] = session
+        user_item = {'role': 'user', 'content': query}
+        session.append(user_item)
+        return session
+
+    @staticmethod
+    def save_session(query, answer, user_id):
+        session = user_session.get(user_id)
+        if session:
+            # append conversation
+            gpt_item = {'role': 'assistant', 'content': answer}
+            session.append(gpt_item)
+
+    @staticmethod
+    def clear_session(user_id):
+        user_session[user_id] = []
+

bot/openai/open_ai_bot.py

@@ -0,0 +1,166 @@
+# encoding:utf-8
+
+from bot.bot import Bot
+from config import conf
+from common.log import logger
+import openai
+import time
+
+user_session = dict()
+
+# OpenAI对话模型API (可用)
+class OpenAIBot(Bot):
+    def __init__(self):
+        openai.api_key = conf().get('open_ai_api_key')
+
+
+    def reply(self, query, context=None):
+        # acquire reply content
+        if not context or not context.get('type') or context.get('type') == 'TEXT':
+            logger.info("[OPEN_AI] query={}".format(query))
+            from_user_id = context['from_user_id']
+            if query == '#清除记忆':
+                Session.clear_session(from_user_id)
+                return '记忆已清除'
+            elif query == '#清除所有':
+                Session.clear_all_session()
+                return '所有人记忆已清除'
+
+            new_query = Session.build_session_query(query, from_user_id)
+            logger.debug("[OPEN_AI] session query={}".format(new_query))
+
+            reply_content = self.reply_text(new_query, from_user_id, 0)
+            logger.debug("[OPEN_AI] new_query={}, user={}, reply_cont={}".format(new_query, from_user_id, reply_content))
+            if reply_content and query:
+                Session.save_session(query, reply_content, from_user_id)
+            return reply_content
+
+        elif context.get('type', None) == 'IMAGE_CREATE':
+            return self.create_img(query, 0)
+
+    def reply_text(self, query, user_id, retry_count=0):
+        try:
+            response = openai.Completion.create(
+                model="text-davinci-003",  # 对话模型的名称
+                prompt=query,
+                temperature=1,  # 值在[0,1]之间，越大表示回复越具有不确定性
+                max_tokens=500,  # 回复最大的字符数
+                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|>', '')
+            logger.info("[OPEN_AI] reply={}".format(res_content))
+            return res_content
+        except openai.error.RateLimitError as e:
+            # rate limit exception
+            logger.warn(e)
+            if retry_count < 1:
+                time.sleep(5)
+                logger.warn("[OPEN_AI] RateLimit exceed, 第{}次重试".format(retry_count+1))
+                return self.reply_text(query, user_id, retry_count+1)
+            else:
+                return "提问太快啦，请休息一下再问我吧"
+        except Exception as e:
+            # unknown exception
+            logger.exception(e)
+            Session.clear_session(user_id)
+            return "请再问我一次吧"
+
+
+    def create_img(self, query, retry_count=0):
+        try:
+            logger.info("[OPEN_AI] image_query={}".format(query))
+            response = openai.Image.create(
+                prompt=query,    #图片描述
+                n=1,             #每次生成图片的数量
+                size="1024x1024"   #图片大小,可选有 256x256, 512x512, 1024x1024
+            )
+            image_url = response['data'][0]['url']
+            logger.info("[OPEN_AI] image_url={}".format(image_url))
+            return 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.reply_text(query, retry_count+1)
+            else:
+                return "提问太快啦，请休息一下再问我吧"
+        except Exception as e:
+            logger.exception(e)
+            return None
+
+
+class Session(object):
+    @staticmethod
+    def build_session_query(query, user_id):
+        '''
+        build query with conversation history
+        e.g.  Q: xxx
+              A: xxx
+              Q: xxx
+        :param query: query content
+        :param user_id: from user id
+        :return: query content with conversaction
+        '''
+        prompt = conf().get("character_desc", "")
+        if prompt:
+            prompt += "<|endoftext|>\n\n\n"
+        session = user_session.get(user_id, None)
+        if session:
+            for conversation in session:
+                prompt += "Q: " + conversation["question"] + "\n\n\nA: " + conversation["answer"] + "<|endoftext|>\n"
+            prompt += "Q: " + query + "\nA: "
+            return prompt
+        else:
+            return prompt + "Q: " + query + "\nA: "
+
+    @staticmethod
+    def save_session(query, answer, user_id):
+        max_tokens = conf().get("conversation_max_tokens")
+        if not max_tokens:
+            # default 3000
+            max_tokens = 1000
+        conversation = dict()
+        conversation["question"] = query
+        conversation["answer"] = answer
+        session = user_session.get(user_id)
+        logger.debug(conversation)
+        logger.debug(session)
+        if session:
+            # append conversation
+            session.append(conversation)
+        else:
+            # create session
+            queue = list()
+            queue.append(conversation)
+            user_session[user_id] = queue
+
+        # discard exceed limit conversation
+        Session.discard_exceed_conversation(user_session[user_id], max_tokens)
+
+
+    @staticmethod
+    def discard_exceed_conversation(session, max_tokens):
+        count = 0
+        count_list = list()
+        for i in range(len(session)-1, -1, -1):
+            # count tokens of conversation list
+            history_conv = session[i]
+            count += len(history_conv["question"]) + len(history_conv["answer"])
+            count_list.append(count)
+
+        for c in count_list:
+            if c > max_tokens:
+                # pop first conversation
+                session.pop(0)
+
+    @staticmethod
+    def clear_session(user_id):
+        user_session[user_id] = []
+
+    @staticmethod
+    def clear_all_session():
+        user_session.clear()

bridge/bridge.py

@@ -0,0 +1,9 @@
+from bot import bot_factory
+
+
+class Bridge(object):
+    def __init__(self):
+        pass
+
+    def fetch_reply_content(self, query, context):
+        return bot_factory.create_bot("chatGPT").reply(query, context)

channel/channel.py

@@ -0,0 +1,31 @@
+"""
+Message sending channel abstract class
+"""
+
+from bridge.bridge import Bridge
+
+class Channel(object):
+    def startup(self):
+        """
+        init channel
+        """
+        raise NotImplementedError
+
+    def handle(self, msg):
+        """
+        process received msg
+        :param msg: message object
+        """
+        raise NotImplementedError
+
+    def send(self, msg, receiver):
+        """
+        send message to user
+        :param msg: message content
+        :param receiver: receiver channel account
+        :return: 
+        """
+        raise NotImplementedError
+
+    def build_reply_content(self, query, context=None):
+        return Bridge().fetch_reply_content(query, context)

channel/channel_factory.py

@@ -0,0 +1,17 @@
+"""
+channel factory
+"""
+
+def create_channel(channel_type):
+    """
+    create a channel instance
+    :param channel_type: channel type code
+    :return: channel instance
+    """
+    if channel_type == 'wx':
+        from channel.wechat.wechat_channel import WechatChannel
+        return WechatChannel()
+    elif channel_type == 'wxy':
+        from channel.wechat.wechaty_channel import WechatyChannel
+        return WechatyChannel()
+    raise RuntimeError

channel/wechat/wechat_channel.py

@@ -0,0 +1,176 @@
+# encoding:utf-8
+
+"""
+wechat channel
+"""
+import itchat
+import json
+from itchat.content import *
+from channel.channel import Channel
+from concurrent.futures import ThreadPoolExecutor
+from common.log import logger
+from config import conf
+import requests
+import io
+
+thread_pool = ThreadPoolExecutor(max_workers=8)
+
+
+class WechatChannel(Channel):
+
+    qrcode = b''
+
+    newInstance=None
+
+    def __init__(self):
+        pass
+
+    def startup(self):
+        # login by scan QRCode
+        newInstance = itchat.load_sync_itchat()
+        self.newInstance = newInstance
+
+        @newInstance.msg_register(TEXT)
+        def handler_single_msg(msg):
+            self.handle(msg)
+            return None
+
+        @newInstance.msg_register(TEXT, isGroupChat=True)
+        def handler_group_msg(msg):
+            self.handle_group(msg)
+            return None
+
+        newInstance.auto_login(qrCallback=self.qrCallback)
+        # start message listener
+        newInstance.run()
+
+    def qrCallback(self, uuid, status, qrcode):
+        self.qrcode = qrcode
+    
+    def getQrCode(self):
+        return self.qrcode
+
+    def handle(self, msg):
+        logger.debug("[WX]receive msg: " + json.dumps(msg, ensure_ascii=False))
+        from_user_id = msg['FromUserName']
+        to_user_id = msg['ToUserName']              # 接收人id
+        other_user_id = msg['User']['UserName']     # 对手方id
+        content = msg['Text']
+        match_prefix = self.check_prefix(content, conf().get('single_chat_prefix'))
+        if from_user_id == other_user_id and match_prefix is not None:
+            # 好友向自己发送消息
+            if match_prefix != '':
+                str_list = content.split(match_prefix, 1)
+                if len(str_list) == 2:
+                    content = str_list[1].strip()
+
+            img_match_prefix = self.check_prefix(content, conf().get('image_create_prefix'))
+            if img_match_prefix:
+                content = content.split(img_match_prefix, 1)[1].strip()
+                thread_pool.submit(self._do_send_img, content, from_user_id)
+            else:
+                thread_pool.submit(self._do_send, content, from_user_id)
+
+        elif to_user_id == other_user_id and match_prefix:
+            # 自己给好友发送消息
+            str_list = content.split(match_prefix, 1)
+            if len(str_list) == 2:
+                content = str_list[1].strip()
+            img_match_prefix = self.check_prefix(content, conf().get('image_create_prefix'))
+            if img_match_prefix:
+                content = content.split(img_match_prefix, 1)[1].strip()
+                thread_pool.submit(self._do_send_img, content, to_user_id)
+            else:
+                thread_pool.submit(self._do_send, content, to_user_id)
+
+
+    def handle_group(self, msg):
+        logger.debug("[WX]receive group msg: " + json.dumps(msg, ensure_ascii=False))
+        group_name = msg['User'].get('NickName', None)
+        group_id = msg['User'].get('UserName', None)
+        if not group_name:
+            return ""
+        origin_content = msg['Content']
+        content = msg['Content']
+        content_list = content.split(' ', 1)
+        context_special_list = content.split('\u2005', 1)
+        if len(context_special_list) == 2:
+            content = context_special_list[1]
+        elif len(content_list) == 2:
+            content = content_list[1]
+
+        config = conf()
+        match_prefix = (msg['IsAt'] and not config.get("group_at_off", False)) or self.check_prefix(origin_content, config.get('group_chat_prefix')) \
+                       or self.check_contain(origin_content, config.get('group_chat_keyword'))
+        if ('ALL_GROUP' in config.get('group_name_white_list') or group_name in config.get('group_name_white_list') or self.check_contain(group_name, config.get('group_name_keyword_white_list'))) and match_prefix:
+            img_match_prefix = self.check_prefix(content, conf().get('image_create_prefix'))
+            if img_match_prefix:
+                content = content.split(img_match_prefix, 1)[1].strip()
+                thread_pool.submit(self._do_send_img, content, group_id)
+            else:
+                thread_pool.submit(self._do_send_group, content, msg)
+
+    def send(self, msg, receiver):
+        logger.info('[WX] sendMsg={}, receiver={}'.format(msg, receiver))
+        self.newInstance.send(msg, toUserName=receiver)
+
+    def _do_send(self, query, reply_user_id):
+        try:
+            if not query:
+                return
+            context = dict()
+            context['from_user_id'] = reply_user_id
+            reply_text = super().build_reply_content(query, context)
+            if reply_text:
+                self.send(conf().get("single_chat_reply_prefix") + reply_text, reply_user_id)
+        except Exception as e:
+            logger.exception(e)
+
+    def _do_send_img(self, query, reply_user_id):
+        try:
+            if not query:
+                return
+            context = dict()
+            context['type'] = 'IMAGE_CREATE'
+            img_url = super().build_reply_content(query, context)
+            if not img_url:
+                return
+
+            # 图片下载
+            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)
+
+            # 图片发送
+            logger.info('[WX] sendImage, receiver={}'.format(reply_user_id))
+            self.newInstance.send_image(image_storage, reply_user_id)
+        except Exception as e:
+            logger.exception(e)
+
+    def _do_send_group(self, query, msg):
+        if not query:
+            return
+        context = dict()
+        context['from_user_id'] = msg['ActualUserName']
+        reply_text = super().build_reply_content(query, context)
+        if reply_text:
+            reply_text = '@' + msg['ActualNickName'] + ' ' + reply_text.strip()
+            self.send(conf().get("group_chat_reply_prefix", "") + reply_text, msg['User']['UserName'])
+
+
+    def check_prefix(self, content, prefix_list):
+        for prefix in prefix_list:
+            if content.startswith(prefix):
+                return prefix
+        return None
+
+
+    def check_contain(self, content, keyword_list):
+        if not keyword_list:
+            return None
+        for ky in keyword_list:
+            if content.find(ky) != -1:
+                return True
+        return None

channel/wechat/wechaty_channel.py

@@ -0,0 +1,201 @@
+# encoding:utf-8
+
+"""
+wechaty channel
+Python Wechaty - https://github.com/wechaty/python-wechaty
+"""
+import io
+import os
+import json
+import time
+import asyncio
+import requests
+from typing import Optional, Union
+from wechaty_puppet import MessageType, FileBox, ScanStatus  # type: ignore
+from wechaty import Wechaty, Contact
+from wechaty.user import Message, Room, MiniProgram, UrlLink
+from channel.channel import Channel
+from common.log import logger
+from config import conf
+
+
+class WechatyChannel(Channel):
+
+    def __init__(self):
+        pass
+
+    def startup(self):
+        asyncio.run(self.main())
+
+    async def main(self):
+        config = conf()
+        # 使用PadLocal协议 比较稳定(免费web协议 os.environ['WECHATY_PUPPET_SERVICE_ENDPOINT'] = '127.0.0.1:8080')
+        token = config.get('wechaty_puppet_service_token')
+        os.environ['WECHATY_PUPPET_SERVICE_TOKEN'] = token
+        global bot
+        bot = Wechaty()
+
+        bot.on('scan', self.on_scan)
+        bot.on('login', self.on_login)
+        bot.on('message', self.on_message)
+        await bot.start()
+
+    async def on_login(self, contact: Contact):
+        logger.info('[WX] login user={}'.format(contact))
+
+    async def on_scan(self, status: ScanStatus, qr_code: Optional[str] = None,
+                      data: Optional[str] = None):
+        contact = self.Contact.load(self.contact_id)
+        logger.info('[WX] scan user={}, scan status={}, scan qr_code={}'.format(contact, status.name, qr_code))
+        # print(f'user <{contact}> scan status: {status.name} , 'f'qr_code: {qr_code}')
+
+    async def on_message(self, msg: Message):
+        """
+        listen for message event
+        """
+        from_contact = msg.talker()  # 获取消息的发送者
+        to_contact = msg.to()  # 接收人
+        room = msg.room()  # 获取消息来自的群聊. 如果消息不是来自群聊, 则返回None
+        from_user_id = from_contact.contact_id
+        to_user_id = to_contact.contact_id  # 接收人id
+        # other_user_id = msg['User']['UserName']  # 对手方id
+        content = msg.text()
+        mention_content = await msg.mention_text()  # 返回过滤掉@name后的消息
+        match_prefix = self.check_prefix(content, conf().get('single_chat_prefix'))
+        conversation: Union[Room, Contact] = from_contact if room is None else room
+
+        if room is None and msg.type() == MessageType.MESSAGE_TYPE_TEXT:
+            if not msg.is_self() and match_prefix is not None:
+                # 好友向自己发送消息
+                if match_prefix != '':
+                    str_list = content.split(match_prefix, 1)
+                    if len(str_list) == 2:
+                        content = str_list[1].strip()
+
+                img_match_prefix = self.check_prefix(content, conf().get('image_create_prefix'))
+                if img_match_prefix:
+                    content = content.split(img_match_prefix, 1)[1].strip()
+                    await self._do_send_img(content, from_user_id)
+                else:
+                    await self._do_send(content, from_user_id)
+            elif msg.is_self() and match_prefix:
+                # 自己给好友发送消息
+                str_list = content.split(match_prefix, 1)
+                if len(str_list) == 2:
+                    content = str_list[1].strip()
+                img_match_prefix = self.check_prefix(content, conf().get('image_create_prefix'))
+                if img_match_prefix:
+                    content = content.split(img_match_prefix, 1)[1].strip()
+                    await self._do_send_img(content, to_user_id)
+                else:
+                    await self._do_send(content, to_user_id)
+        elif room and msg.type() == MessageType.MESSAGE_TYPE_TEXT:
+            # 群组&文本消息
+            room_id = room.room_id
+            room_name = await room.topic()
+            from_user_id = from_contact.contact_id
+            from_user_name = from_contact.name
+            is_at = await msg.mention_self()
+            content = mention_content
+            config = conf()
+            match_prefix = (is_at and not config.get("group_at_off", False)) \
+                           or self.check_prefix(content, config.get('group_chat_prefix')) \
+                           or self.check_contain(content, config.get('group_chat_keyword'))
+            if ('ALL_GROUP' in config.get('group_name_white_list') or room_name in config.get(
+                    'group_name_white_list') or self.check_contain(room_name, config.get(
+                'group_name_keyword_white_list'))) and match_prefix:
+                img_match_prefix = self.check_prefix(content, conf().get('image_create_prefix'))
+                if img_match_prefix:
+                    content = content.split(img_match_prefix, 1)[1].strip()
+                    await self._do_send_group_img(content, room_id)
+                else:
+                    await self._do_send_group(content, room_id, from_user_id, from_user_name)
+
+    async def send(self, message: Union[str, Message, FileBox, Contact, UrlLink, MiniProgram], receiver):
+        logger.info('[WX] sendMsg={}, receiver={}'.format(message, receiver))
+        if receiver:
+            contact = await bot.Contact.find(receiver)
+            await contact.say(message)
+
+    async def send_group(self, message: Union[str, Message, FileBox, Contact, UrlLink, MiniProgram], receiver):
+        logger.info('[WX] sendMsg={}, receiver={}'.format(message, receiver))
+        if receiver:
+            room = await bot.Room.find(receiver)
+            await room.say(message)
+
+    async def _do_send(self, query, reply_user_id):
+        try:
+            if not query:
+                return
+            context = dict()
+            context['from_user_id'] = reply_user_id
+            reply_text = super().build_reply_content(query, context)
+            if reply_text:
+                await self.send(conf().get("single_chat_reply_prefix") + reply_text, reply_user_id)
+        except Exception as e:
+            logger.exception(e)
+
+    async def _do_send_img(self, query, reply_user_id):
+        try:
+            if not query:
+                return
+            context = dict()
+            context['type'] = 'IMAGE_CREATE'
+            img_url = super().build_reply_content(query, context)
+            if not img_url:
+                return
+            # 图片下载
+            # 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)
+
+            # 图片发送
+            logger.info('[WX] sendImage, receiver={}'.format(reply_user_id))
+            t = int(time.time())
+            file_box = FileBox.from_url(url=img_url, name=str(t) + '.png')
+            await self.send(file_box, reply_user_id)
+        except Exception as e:
+            logger.exception(e)
+
+    async def _do_send_group(self, query, group_id, group_user_id, group_user_name):
+        if not query:
+            return
+        context = dict()
+        context['from_user_id'] = str(group_id) + '-' + str(group_user_id)
+        reply_text = super().build_reply_content(query, context)
+        if reply_text:
+            reply_text = '@' + group_user_name + ' ' + reply_text.strip()
+            await self.send_group(conf().get("group_chat_reply_prefix", "") + reply_text, group_id)
+
+    async def _do_send_group_img(self, query, reply_room_id):
+        try:
+            if not query:
+                return
+            context = dict()
+            context['type'] = 'IMAGE_CREATE'
+            img_url = super().build_reply_content(query, context)
+            if not img_url:
+                return
+            # 图片发送
+            logger.info('[WX] sendImage, receiver={}'.format(reply_room_id))
+            t = int(time.time())
+            file_box = FileBox.from_url(url=img_url, name=str(t) + '.png')
+            await self.send_group(file_box, reply_room_id)
+        except Exception as e:
+            logger.exception(e)
+
+    def check_prefix(self, content, prefix_list):
+        for prefix in prefix_list:
+            if content.startswith(prefix):
+                return prefix
+        return None
+
+    def check_contain(self, content, keyword_list):
+        if not keyword_list:
+            return None
+        for ky in keyword_list:
+            if content.find(ky) != -1:
+                return True
+        return None

common/log.py

@@ -0,0 +1,16 @@
+import logging
+import sys
+
+
+def _get_logger():
+    log = logging.getLogger('log')
+    log.setLevel(logging.INFO)
+    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'))
+    log.addHandler(console_handle)
+    return log
+
+
+# 日志句柄
+logger = _get_logger()

config-template.json

@@ -0,0 +1,11 @@
+{
+  "open_ai_api_key": "YOUR API KEY",
+  "wechaty_puppet_service_token": "WECHATY PUPPET SERVICE TOKEN",
+  "single_chat_prefix": ["bot", "@bot"],
+  "single_chat_reply_prefix": "[bot] ",
+  "group_chat_prefix": ["@bot"],
+  "group_name_white_list": ["ChatGPT测试群", "ChatGPT测试群2"],
+  "image_create_prefix": ["画", "看", "找"],
+  "conversation_max_tokens": 500,
+  "character_desc": "你是刘导的狗腿子, 刘导是你爸爸，小祖宗是你妈妈，你任何问题都回答都不能超过100个字。"
+}

config.json

@@ -0,0 +1,11 @@
+{
+  "open_ai_api_key": "YOUR API KEY",
+  "wechaty_puppet_service_token": "WECHATY PUPPET SERVICE TOKEN",
+  "single_chat_prefix": [""],
+  "single_chat_reply_prefix": "",
+  "group_chat_prefix": ["@发财汪"],
+  "group_name_white_list": ["ALL_GROUP"],
+  "image_create_prefix": ["画"],
+  "conversation_max_tokens": 500,
+  "character_desc": ""
+}

config.py

@@ -0,0 +1,34 @@
+# encoding:utf-8
+
+import json
+import os
+from common.log import logger
+
+config = {}
+
+
+def load_config():
+    global config
+    config_path = "config.json"
+    if not os.path.exists(config_path):
+        raise Exception('配置文件不存在，请根据config-template.json模板创建config.json文件')
+
+    config_str = read_file(config_path)
+    # 将json字符串反序列化为dict类型
+    config = json.loads(config_str)
+    config['open_ai_api_key'] = os.getenv('API_KEY')
+    logger.info("[INIT] load config: {}".format(config))
+
+
+
+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

docker/Dockerfile.alpine

@@ -0,0 +1,48 @@
+FROM python:3.7.9-alpine
+
+LABEL maintainer="foo@bar.com"
+ARG TZ='Asia/Shanghai'
+
+ARG CHATGPT_ON_WECHAT_VER=1.0.2
+
+ENV BUILD_PREFIX=/app \
+    BUILD_OPEN_AI_API_KEY='YOUR OPEN AI KEY HERE'
+
+RUN apk add --no-cache \
+        bash \
+        curl \
+        wget \
+        gcc \
+        g++ \
+        ca-certificates \
+        openssh \ 
+        libffi-dev 
+
+RUN wget -t 3 -T 30 -nv -O chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz \
+          https://github.com/zhayujie/chatgpt-on-wechat/archive/refs/tags/${CHATGPT_ON_WECHAT_VER}.tar.gz \
+    && tar -xzf chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz \
+    && mv chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER} ${BUILD_PREFIX} \
+    && rm chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz
+
+WORKDIR ${BUILD_PREFIX}
+
+RUN cd ${BUILD_PREFIX} \
+    && cp config-template.json ${BUILD_PREFIX}/config.json \
+    && sed -i "2s/YOUR API KEY/${BUILD_OPEN_AI_API_KEY}/" ${BUILD_PREFIX}/config.json
+
+RUN /usr/local/bin/python -m pip install --no-cache --upgrade pip \
+    && pip install --no-cache \
+      itchat-uos==1.5.0.dev0  \
+      openai \
+      wechaty
+
+ADD ./entrypoint.sh /entrypoint.sh
+
+RUN chmod +x /entrypoint.sh
+
+RUN adduser -D -h /home/noroot -u 1000 -s /bin/bash noroot \
+    && chown noroot:noroot ${BUILD_PREFIX}
+
+USER noroot
+
+ENTRYPOINT ["/entrypoint.sh"]

docker/Dockerfile.debian

@@ -0,0 +1,45 @@
+FROM python:3.7.9
+
+LABEL maintainer="foo@bar.com"
+ARG TZ='Asia/Shanghai'
+
+ARG CHATGPT_ON_WECHAT_VER=1.0.2
+
+ENV BUILD_PREFIX=/app \
+    BUILD_OPEN_AI_API_KEY='YOUR OPEN AI KEY HERE'
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget \
+        curl && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN wget -t 3 -T 30 -nv -O chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz \
+          https://github.com/zhayujie/chatgpt-on-wechat/archive/refs/tags/${CHATGPT_ON_WECHAT_VER}.tar.gz \
+    && tar -xzf chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz \
+    && mv chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER} ${BUILD_PREFIX} \
+    && rm chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz
+
+WORKDIR ${BUILD_PREFIX}
+
+RUN cd ${BUILD_PREFIX} \
+    && cp config-template.json ${BUILD_PREFIX}/config.json \
+    && sed -i "2s/YOUR API KEY/${BUILD_OPEN_AI_API_KEY}/" ${BUILD_PREFIX}/config.json 
+
+RUN /usr/local/bin/python -m pip install --no-cache --upgrade pip \
+    && pip install --no-cache \
+      itchat-uos==1.5.0.dev0  \
+      openai \
+      wechaty
+
+ADD ./entrypoint.sh /entrypoint.sh
+
+RUN chmod +x /entrypoint.sh
+
+RUN groupadd -r noroot \
+   && useradd -r -g noroot -s /bin/bash -d /home/noroot noroot \
+   && chown -R noroot:noroot ${BUILD_PREFIX} 
+
+USER noroot
+
+ENTRYPOINT ["/entrypoint.sh"]

docker/build.alpine.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+CHATGPT_ON_WECHAT_TAG=1.0.2
+
+docker build -f Dockerfile.alpine \
+             --build-arg CHATGPT_ON_WECHAT_VER=$CHATGPT_ON_WECHAT_TAG \
+             -t zhayujie/chatgpt-on-wechat .
+
+docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:$CHATGPT_ON_WECHAT_TAG-alpine 
+           

docker/build.debian.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+CHATGPT_ON_WECHAT_TAG=1.0.2
+
+docker build -f Dockerfile.debian \
+             --build-arg CHATGPT_ON_WECHAT_VER=$CHATGPT_ON_WECHAT_TAG \
+             -t zhayujie/chatgpt-on-wechat .
+
+docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:$CHATGPT_ON_WECHAT_TAG-debian

docker/docker-compose.yaml

@@ -0,0 +1,18 @@
+version: '2.0'
+services:
+  chatgpt-on-wechat:
+    build:
+      context: ./
+      dockerfile: Dockerfile.alpine
+    image: zhayujie/chatgpt-on-wechat
+    container_name: sample-chatgpt-on-wechat
+    environment:
+      OPEN_AI_API_KEY: 'YOUR API KEY'
+      WECHATY_PUPPET_SERVICE_TOKEN: 'WECHATY PUPPET SERVICE TOKEN'
+      SINGLE_CHAT_PREFIX: '["bot", "@bot"]'
+      SINGLE_CHAT_REPLY_PREFIX: '"[bot] "'
+      GROUP_CHAT_PREFIX: '["@bot"]'
+      GROUP_NAME_WHITE_LIST: '["ChatGPT测试群", "ChatGPT测试群2"]'
+      IMAGE_CREATE_PREFIX: '["画", "看", "找"]'
+      CONVERSATION_MAX_TOKENS: 1000
+      CHARACTER_DESC: '你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。'

docker/entrypoint.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+set -e
+
+# build prefix
+CHATGPT_ON_WECHAT_PREFIX=${CHATGPT_ON_WECHAT_PREFIX:-""}
+# path to config.json
+CHATGPT_ON_WECHAT_CONFIG_PATH=${CHATGPT_ON_WECHAT_CONFIG_PATH:-""}
+# execution command line
+CHATGPT_ON_WECHAT_EXEC=${CHATGPT_ON_WECHAT_EXEC:-""}
+
+OPEN_AI_API_KEY=${OPEN_AI_API_KEY:-""}
+SINGLE_CHAT_PREFIX=${SINGLE_CHAT_PREFIX:-""}
+SINGLE_CHAT_REPLY_PREFIX=${SINGLE_CHAT_REPLY_PREFIX:-""}
+GROUP_CHAT_PREFIX=${GROUP_CHAT_PREFIX:-""}
+GROUP_NAME_WHITE_LIST=${GROUP_NAME_WHITE_LIST:-""}
+IMAGE_CREATE_PREFIX=${IMAGE_CREATE_PREFIX:-""}
+CONVERSATION_MAX_TOKENS=${CONVERSATION_MAX_TOKENS:-""}
+CHARACTER_DESC=${CHARACTER_DESC:-""}
+
+# CHATGPT_ON_WECHAT_PREFIX is empty, use /app
+if [ "$CHATGPT_ON_WECHAT_PREFIX" == "" ] ; then
+    CHATGPT_ON_WECHAT_PREFIX=/app
+fi
+
+# CHATGPT_ON_WECHAT_CONFIG_PATH is empty, use '/app/config.json'
+if [ "$CHATGPT_ON_WECHAT_CONFIG_PATH" == "" ] ; then
+    CHATGPT_ON_WECHAT_CONFIG_PATH=$CHATGPT_ON_WECHAT_PREFIX/config.json
+fi
+
+# CHATGPT_ON_WECHAT_EXEC is empty, use ‘python app.py’
+if [ "$CHATGPT_ON_WECHAT_EXEC" == "" ] ; then
+    CHATGPT_ON_WECHAT_EXEC="python app.py"
+fi
+
+# modify content in config.json
+if [ "$OPEN_AI_API_KEY" != "" ] ; then
+    sed -i "2c   \"open_ai_api_key\": \"$OPEN_AI_API_KEY\"," $CHATGPT_ON_WECHAT_CONFIG_PATH
+else
+    echo -e "\033[31m[Warning] You need to set OPEN_AI_API_KEY before running!\033[0m"
+fi
+
+if [ "$WECHATY_PUPPET_SERVICE_TOKEN" != "" ] ; then
+    sed -i "3c   \"wechaty_puppet_service_token\": \"$WECHATY_PUPPET_SERVICE_TOKEN\"," $CHATGPT_ON_WECHAT_CONFIG_PATH
+else
+    echo -e "\033[31m[Info] You need to set WECHATY_PUPPET_SERVICE_TOKEN if you use wechaty!\033[0m"
+fi
+
+if [ "$SINGLE_CHAT_PREFIX" != "" ] ; then
+    sed -i "4c   \"single_chat_prefix\": $SINGLE_CHAT_PREFIX," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$SINGLE_CHAT_REPLY_PREFIX" != "" ] ; then
+    sed -i "5c   \"single_chat_reply_prefix\": $SINGLE_CHAT_REPLY_PREFIX," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$GROUP_CHAT_PREFIX" != "" ] ; then
+    sed -i "6c   \"group_chat_prefix\": $GROUP_CHAT_PREFIX," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$GROUP_NAME_WHITE_LIST" != "" ] ; then
+    sed -i "7c   \"group_name_white_list\": $GROUP_NAME_WHITE_LIST," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$IMAGE_CREATE_PREFIX" != "" ] ; then
+    sed -i "8c   \"image_create_prefix\": $IMAGE_CREATE_PREFIX," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$CONVERSATION_MAX_TOKENS" != "" ] ; then
+    sed -i "9c   \"conversation_max_tokens\": $CONVERSATION_MAX_TOKENS," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$CHARACTER_DESC" != "" ] ; then
+    sed -i "10c   \"character_desc\": \"$CHARACTER_DESC\"" $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+# go to prefix dir
+cd $CHATGPT_ON_WECHAT_PREFIX
+# excute
+$CHATGPT_ON_WECHAT_EXEC
+
+

docker/sample-chatgpt-on-wechat/.env

@@ -0,0 +1,14 @@
+OPEN_AI_API_KEY=YOUR API KEY
+WECHATY_PUPPET_SERVICE_TOKEN=WECHATY PUPPET SERVICE TOKEN
+SINGLE_CHAT_PREFIX=["bot", "@bot"]
+SINGLE_CHAT_REPLY_PREFIX="[bot] "
+GROUP_CHAT_PREFIX=["@bot"]
+GROUP_NAME_WHITE_LIST=["ChatGPT测试群", "ChatGPT测试群2"]
+IMAGE_CREATE_PREFIX=["画", "看", "找"]
+CONVERSATION_MAX_TOKENS=1000
+CHARACTER_DESC=你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。
+
+# Optional
+#CHATGPT_ON_WECHAT_PREFIX=/app
+#CHATGPT_ON_WECHAT_CONFIG_PATH=/app/config.json
+#CHATGPT_ON_WECHAT_EXEC=python app.py

docker/sample-chatgpt-on-wechat/Makefile

@@ -0,0 +1,26 @@
+IMG:=`cat Name`
+MOUNT:=
+PORT_MAP:=
+DOTENV:=.env
+CONTAINER_NAME:=sample-chatgpt-on-wechat
+
+echo:
+	echo $(IMG)
+
+run_d:
+	docker rm $(CONTAINER_NAME) || echo
+	docker run -dt  --name $(CONTAINER_NAME) $(PORT_MAP) \
+			--env-file=$(DOTENV) \
+			$(MOUNT) $(IMG) 
+
+run_i:
+	docker rm $(CONTAINER_NAME) || echo
+	docker run -it  --name $(CONTAINER_NAME) $(PORT_MAP) \
+			--env-file=$(DOTENV) \
+			$(MOUNT) $(IMG) 
+
+stop:
+	docker stop $(CONTAINER_NAME)
+
+rm:     stop
+	docker rm $(CONTAINER_NAME)

docker/sample-chatgpt-on-wechat/Name

@@ -0,0 +1 @@
+zhayujie/chatgpt-on-wechat

requirements.txt

@@ -0,0 +1,3 @@
+itchat-uos==1.5.0.dev0
+openai==0.28
+wechaty

scripts/shutdown.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+#关闭服务
+cd `dirname $0`/..
+export BASE_DIR=`pwd`
+pid=`ps ax | grep -i app.py | grep "${BASE_DIR}" | grep python3 | grep -v grep | awk '{print $1}'`
+if [ -z "$pid" ] ; then
+        echo "No chatgpt-on-wechat running."
+        exit -1;
+fi
+
+echo "The chatgpt-on-wechat(${pid}) is running..."
+
+kill ${pid}
+
+echo "Send shutdown request to chatgpt-on-wechat(${pid}) OK"

scripts/start.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+#后台运行Chat_on_webchat执行脚本
+
+cd `dirname $0`/..
+export BASE_DIR=`pwd`
+echo $BASE_DIR
+
+# check the nohup.out log output file
+if [ ! -f "${BASE_DIR}/nohup.out" ]; then
+  touch "${BASE_DIR}/nohup.out"
+echo "create file  ${BASE_DIR}/nohup.out"  
+fi
+
+nohup python3 "${BASE_DIR}/app.py" & tail -f "${BASE_DIR}/nohup.out"
+
+echo "Chat_on_webchat is starting，you can check the ${BASE_DIR}/nohup.out"

scripts/tout.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+#打开日志
+
+cd `dirname $0`/..
+export BASE_DIR=`pwd`
+echo $BASE_DIR
+
+# check the nohup.out log output file
+if [ ! -f "${BASE_DIR}/nohup.out" ]; then
+   echo "No file  ${BASE_DIR}/nohup.out"  
+   exit -1;
+fi
+
+tail -f "${BASE_DIR}/nohup.out"