Upload 6 files

Chatbot.py

@@ -1,11 +1,13 @@
+# -*- coding:utf-8 -*-
 import gradio as gr
-# import openai
 import os
+import logging
 import sys
 import argparse
 from utils import *
 from presets import *
 
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] [%(filename)s:%(lineno)d] %(message)s")
 
 my_api_key = os.getenv("OpenAI-API")    # 在这里输入你的 API 密钥
 
@@ -20,7 +22,7 @@ authflag = False
 if dockerflag:
     my_api_key = os.environ.get('my_api_key')
     if my_api_key == "empty":
-        print("Please give a api key!")
+        logging.error("Please give a api key!")
         sys.exit(1)
     #auth
     username = os.environ.get('USERNAME')
@@ -42,12 +44,6 @@ else:
 gr.Chatbot.postprocess = postprocess
 
 with gr.Blocks(css=customCSS) as demo:
-    gr.HTML(title)
-    with gr.Row():
-        keyTxt = gr.Textbox(show_label=False, placeholder=f"在这里输入你的OpenAI API-key...",
-                            value=my_api_key, type="password", visible=not HIDE_MY_KEY).style(container=True)
-        use_streaming_checkbox = gr.Checkbox(label="实时传输回答", value=True, visible=enable_streaming_option)
-    chatbot = gr.Chatbot()  # .style(color_map=("#1D51EE", "#585A5B"))
     history = gr.State([])
     token_count = gr.State([])
     promptTemplates = gr.State(load_template(get_template_names(plain=True)[0], mode=2))
@@ -56,71 +52,82 @@ with gr.Blocks(css=customCSS) as demo:
     topic = gr.State("未命名对话历史记录")
 
     with gr.Row():
-        with gr.Column(scale=12):
-            user_input = gr.Textbox(show_label=False, placeholder="在这里输入").style(
-                container=False)
-        with gr.Column(min_width=50, scale=1):
-            submitBtn = gr.Button("🚀", variant="primary")
-    with gr.Row():
-        emptyBtn = gr.Button("🧹 新的对话")
-        retryBtn = gr.Button("🔄 重新生成")
-        delLastBtn = gr.Button("🗑️ 删除最近一条对话")
-        reduceTokenBtn = gr.Button("♻️ 总结对话")
-    status_display = gr.Markdown("status: ready")
-    systemPromptTxt = gr.Textbox(show_label=True, placeholder=f"在这里输入System Prompt...",
-                                 label="System prompt", value=initial_prompt).style(container=True)
-    with gr.Accordion(label="加载Prompt模板", open=False):
-        with gr.Column():
-            with gr.Row():
-                with gr.Column(scale=6):
-                    templateFileSelectDropdown = gr.Dropdown(label="选择Prompt模板集合文件", choices=get_template_names(plain=True), multiselect=False, value=get_template_names(plain=True)[0])
-                with gr.Column(scale=1):
-                    templateRefreshBtn = gr.Button("🔄 刷新")
-                    templaeFileReadBtn = gr.Button("📂 读入模板")
-            with gr.Row():
-                with gr.Column(scale=6):
-                    templateSelectDropdown = gr.Dropdown(label="从Prompt模板中加载", choices=load_template(get_template_names(plain=True)[0], mode=1), multiselect=False, value=load_template(get_template_names(plain=True)[0], mode=1)[0])
-                with gr.Column(scale=1):
-                    templateApplyBtn = gr.Button("⬇️ 应用")
-    with gr.Accordion(label="保存/加载对话历史记录", open=False):
+        gr.HTML(title)
+        status_display = gr.Markdown("status: ready", elem_id="status_display")
+
+    with gr.Row(scale=1).style(equal_height=True):
+        with gr.Column(scale=5):
+            with gr.Row(scale=1):
+                chatbot = gr.Chatbot().style(height=600)  # .style(color_map=("#1D51EE", "#585A5B"))
+            with gr.Row(scale=1):
+                with gr.Column(scale=12):
+                    user_input = gr.Textbox(show_label=False, placeholder="在这里输入").style(
+                        container=False)
+                with gr.Column(min_width=50, scale=1):
+                    submitBtn = gr.Button("🚀", variant="primary")
+            with gr.Row(scale=1):
+                emptyBtn = gr.Button("🧹 新的对话",)
+                retryBtn = gr.Button("🔄 重新生成")
+                delLastBtn = gr.Button("🗑️ 删除一条对话")
+                reduceTokenBtn = gr.Button("♻️ 总结对话")
+
         with gr.Column():
-            with gr.Row():
-                with gr.Column(scale=6):
-                    saveFileName = gr.Textbox(
-                        show_label=True, placeholder=f"在这里输入保存的文件名...", label="设置保存文件名", value="对话历史记录").style(container=True)
-                with gr.Column(scale=1):
-                    saveHistoryBtn = gr.Button("💾 保存对话")
-            with gr.Row():
-                with gr.Column(scale=6):
-                    historyFileSelectDropdown = gr.Dropdown(label="从列表中加载对话", choices=get_history_names(plain=True), multiselect=False, value=get_history_names(plain=True)[0])
-                with gr.Column(scale=1):
-                    historyRefreshBtn = gr.Button("🔄 刷新")
-                    historyReadBtn = gr.Button("📂 读入对话")
-    #inputs, top_p, temperature, top_k, repetition_penalty
-    with gr.Accordion("参数", open=False):
-        top_p = gr.Slider(minimum=-0, maximum=1.0, value=1.0, step=0.05,
-                          interactive=True, label="Top-p (nucleus sampling)",)
-        temperature = gr.Slider(minimum=-0, maximum=5.0, value=1.0,
-                                step=0.1, interactive=True, label="Temperature",)
-        #top_k = gr.Slider( minimum=1, maximum=50, value=4, step=1, interactive=True, label="Top-k",)
-        #repetition_penalty = gr.Slider( minimum=0.1, maximum=3.0, value=1.03, step=0.01, interactive=True, label="Repetition Penalty", )
-    gr.Markdown(description)
+            with gr.Column(min_width=50,scale=1):
+                with gr.Tab(label="ChatGPT"):
+                    keyTxt = gr.Textbox(show_label=True, placeholder=f"OpenAI API-key...",value=my_api_key, type="password", visible=not HIDE_MY_KEY, label="API-Key")
+                    model_select_dropdown = gr.Dropdown(label="选择模型", choices=MODELS, multiselect=False, value=MODELS[0])
+                    with gr.Accordion("参数", open=False):
+                        top_p = gr.Slider(minimum=-0, maximum=1.0, value=1.0, step=0.05,
+                                        interactive=True, label="Top-p (nucleus sampling)",)
+                        temperature = gr.Slider(minimum=-0, maximum=2.0, value=1.0,
+                                                step=0.1, interactive=True, label="Temperature",)
+                    use_streaming_checkbox = gr.Checkbox(label="实时传输回答", value=True, visible=enable_streaming_option)
+                    use_websearch_checkbox = gr.Checkbox(label="使用在线搜索", value=False)
+
+                with gr.Tab(label="Prompt"):
+                    systemPromptTxt = gr.Textbox(show_label=True, placeholder=f"在这里输入System Prompt...", label="System prompt", value=initial_prompt).style(container=True)
+                    with gr.Accordion(label="加载Prompt模板", open=True):
+                        with gr.Column():
+                            with gr.Row():
+                                with gr.Column(scale=6):
+                                    templateFileSelectDropdown = gr.Dropdown(label="选择Prompt模板集合文件", choices=get_template_names(plain=True), multiselect=False, value=get_template_names(plain=True)[0])
+                                with gr.Column(scale=1):
+                                    templateRefreshBtn = gr.Button("🔄 刷新")
+                            with gr.Row():
+                                with gr.Column():
+                                    templateSelectDropdown = gr.Dropdown(label="从Prompt模板中加载", choices=load_template(get_template_names(plain=True)[0], mode=1), multiselect=False, value=load_template(get_template_names(plain=True)[0], mode=1)[0])
+
+                with gr.Tab(label="保存/加载"):
+                    with gr.Accordion(label="保存/加载对话历史记录", open=True):
+                        with gr.Column():
+                            with gr.Row():
+                                with gr.Column(scale=6):
+                                    saveFileName = gr.Textbox(
+                                        show_label=True, placeholder=f"在这里输入保存的文件名...", label="设置保存文件名", value="对话历史记录").style(container=True)
+                                with gr.Column(scale=1):
+                                    saveHistoryBtn = gr.Button("💾 保存对话")
+                            with gr.Row():
+                                with gr.Column(scale=6):
+                                    historyFileSelectDropdown = gr.Dropdown(label="从列表中加载对话", choices=get_history_names(plain=True), multiselect=False, value=get_history_names(plain=True)[0])
+                                with gr.Column(scale=1):
+                                    historyRefreshBtn = gr.Button("🔄 刷新")
 
+    gr.Markdown(description)
 
-    user_input.submit(predict, [keyTxt, systemPromptTxt, history, user_input, chatbot, token_count, top_p, temperature, use_streaming_checkbox], [chatbot, history, status_display, token_count], show_progress=True)
+    user_input.submit(predict, [keyTxt, systemPromptTxt, history, user_input, chatbot, token_count, top_p, temperature, use_streaming_checkbox, model_select_dropdown, use_websearch_checkbox], [chatbot, history, status_display, token_count], show_progress=True)
     user_input.submit(reset_textbox, [], [user_input])
 
-    submitBtn.click(predict, [keyTxt, systemPromptTxt, history, user_input, chatbot, token_count, top_p, temperature, use_streaming_checkbox], [chatbot, history, status_display, token_count], show_progress=True)
+    submitBtn.click(predict, [keyTxt, systemPromptTxt, history, user_input, chatbot, token_count, top_p, temperature, use_streaming_checkbox, model_select_dropdown, use_websearch_checkbox], [chatbot, history, status_display, token_count], show_progress=True)
     submitBtn.click(reset_textbox, [], [user_input])
 
     emptyBtn.click(reset_state, outputs=[chatbot, history, token_count, status_display], show_progress=True)
 
-    retryBtn.click(retry, [keyTxt, systemPromptTxt, history, chatbot, token_count, top_p, temperature, use_streaming_checkbox], [chatbot, history, status_display, token_count], show_progress=True)
+    retryBtn.click(retry, [keyTxt, systemPromptTxt, history, chatbot, token_count, top_p, temperature, use_streaming_checkbox, model_select_dropdown], [chatbot, history, status_display, token_count], show_progress=True)
 
-    delLastBtn.click(delete_last_conversation, [chatbot, history, token_count, use_streaming_checkbox], [
+    delLastBtn.click(delete_last_conversation, [chatbot, history, token_count], [
                      chatbot, history, token_count, status_display], show_progress=True)
 
-    reduceTokenBtn.click(reduce_token_size, [keyTxt, systemPromptTxt, history, chatbot, token_count, top_p, temperature, use_streaming_checkbox], [chatbot, history, status_display, token_count], show_progress=True)
+    reduceTokenBtn.click(reduce_token_size, [keyTxt, systemPromptTxt, history, chatbot, token_count, top_p, temperature, use_streaming_checkbox, model_select_dropdown], [chatbot, history, status_display, token_count], show_progress=True)
 
     saveHistoryBtn.click(save_chat_history, [
                   saveFileName, systemPromptTxt, history, chatbot], None, show_progress=True)
@@ -129,15 +136,15 @@ with gr.Blocks(css=customCSS) as demo:
 
     historyRefreshBtn.click(get_history_names, None, [historyFileSelectDropdown])
 
-    historyReadBtn.click(load_chat_history, [historyFileSelectDropdown, systemPromptTxt, history, chatbot],  [saveFileName, systemPromptTxt, history, chatbot], show_progress=True)
+    historyFileSelectDropdown.change(load_chat_history, [historyFileSelectDropdown, systemPromptTxt, history, chatbot],  [saveFileName, systemPromptTxt, history, chatbot], show_progress=True)
 
     templateRefreshBtn.click(get_template_names, None, [templateFileSelectDropdown])
 
-    templaeFileReadBtn.click(load_template, [templateFileSelectDropdown],  [promptTemplates, templateSelectDropdown], show_progress=True)
+    templateFileSelectDropdown.change(load_template, [templateFileSelectDropdown],  [promptTemplates, templateSelectDropdown], show_progress=True)
 
-    templateApplyBtn.click(get_template_content, [promptTemplates, templateSelectDropdown, systemPromptTxt],  [systemPromptTxt], show_progress=True)
+    templateSelectDropdown.change(get_template_content, [promptTemplates, templateSelectDropdown, systemPromptTxt],  [systemPromptTxt], show_progress=True)
 
-print("Chatbot启动成功！")
+logging.info(colorama.Back.GREEN + "\n温馨提示：访问 http://localhost:7860 查看界面" + colorama.Style.RESET_ALL)
 # 默认开启本地服务器，默认可以直接从IP访问，默认不创建公开分享链接
 demo.title = "Chatbot"
 

README.md

@@ -1,12 +1,362 @@
+<img height="128" align="left" src="https://user-images.githubusercontent.com/51039745/222689546-7612df0e-e28b-4693-9f5f-4ef2be3daf48.png" alt="Logo">
+
+# 川虎 ChatGPT 🐯 Chuanhu ChatGPT
+
+[![LICENSE](https://img.shields.io/github/license/GaiZhenbiao/ChuanhuChatGPT)](https://github.com/GaiZhenbiao/ChuanhuChatGPT/blob/main/LICENSE)
+[![Base](https://img.shields.io/badge/Base-Gradio-fb7d1a?style=flat)](https://gradio.app/)
+[![Bilibili](https://img.shields.io/badge/Bilibili-%E8%A7%86%E9%A2%91%E6%95%99%E7%A8%8B-ff69b4?style=flat&logo=bilibili)](https://www.bilibili.com/video/BV1mo4y1r7eE)
+
 ---
-title: Chatbot
-emoji: 💻
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 3.20.1
-app_file: Chatbot.py
-pinned: false
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+为ChatGPT API提供了一个Web图形界面。在Bilibili上[观看视频教程](https://www.bilibili.com/video/BV1mo4y1r7eE/)。也可以在Hugging Face上[在线体验](https://huggingface.co/spaces/JohnSmith9982/ChuanhuChatGPT)。
+
+![Animation Demo](https://user-images.githubusercontent.com/51039745/223148794-f4fd2fcb-3e48-4cdf-a759-7aa463d3f14c.gif)
+
+
+## 重大更新 🎉🎉🎉
+
+- 像官方ChatGPT那样实时回复
+- 无限长度对话
+- 从互联网搜索结果
+- 改进的保存/加载功能
+- 从Prompt模板中选择预设
+- 将大段代码显示在代码块中
+- 渲染输出中的LaTex公式
+
+## 目录
+|[功能](#功能)|[使用技巧](#使用技巧)|[安装方式](#安装方式)|[疑难杂症解决](#疑难杂症解决)|
+|  ----  | ----  | ----  | ----  |
+
+
+## 功能
+- [x] 像官方客户端那样支持实时显示回答！
+- [x] 重试对话，让ChatGPT再回答一次。
+- [x] 优化Tokens，减少Tokens占用，以支持更长的对话。
+- [x] 设置System Prompt，有效地设定前置条件
+- [x] 保存/加载对话历史记录
+- [x] 在图形界面中添加API key
+- [x] System Prompt模板功能，从预置的Prompt库中选择System Prompt
+- [x] 实时显示Tokens用量
+
+## 使用技巧
+
+- 使用System Prompt可以很有效地设定前提条件
+- 对于长对话，可以使用“优化Tokens”按钮减少Tokens占用。
+- 如果部署到服务器，将程序最后一句改成`demo.launch(server_name="0.0.0.0", server_port=99999)`。其中`99999`是端口号，应该是1000-65535任意可用端口，请自行更改为实际端口号。
+- 如果需要获取公共链接，将程序最后一句改成`demo.launch(share=True)`。注意程序必须在运行，才能通过公共链接访问
+- 使用Prompt模板功能时，请先选择模板文件（`.csv`），然后点击载入按钮，然后就可以从下拉菜单中选择想要的prompt了，点击应用填入System Prmpt
+- 输入框支持换行，按`shift enter`即可
+- 在Hugging Face上使用时，建议在右上角**复制Space**再使用，这样能大大减少排队时间，App反应也会更加迅速。
+  <img width="300" alt="image" src="https://user-images.githubusercontent.com/51039745/223447310-e098a1f2-0dcf-48d6-bcc5-49472dd7ca0d.png">
+
+## 安装方式
+
+### 本地部署
+
+1. **下载本项目**
+
+	```shell
+	git clone https://github.com/GaiZhenbiao/ChuanhuChatGPT.git
+	cd ChuanhuChatGPT
+	```
+	或者，点击网页右上角的 `Download ZIP`，下载并解压完成后进入文件夹，进入`终端`或`命令提示符`。
+
+	<img width="200" alt="downloadZIP" src="https://user-images.githubusercontent.com/23137268/223696317-b89d2c71-c74d-4c6d-8060-a21406cfb8c8.png">
+
+2. **填写API密钥**
+
+	以下3种方法任选其一：
+
+	<details><summary>1. 在图形界面中填写你的API密钥</summary>
+
+	这样设置的密钥会在页面刷新后被清除。
+
+	<img width="760" alt="image" src="https://user-images.githubusercontent.com/51039745/222873756-3858bb82-30b9-49bc-9019-36e378ee624d.png"></details>
+	<details><summary>2. 在直接代码中填入你的 OpenAI API 密钥</summary>
+
+	这样设置的密钥会成为默认密钥。在这里还可以选择是否在UI中隐藏密钥输入框。
+
+	<img width="525" alt="image" src="https://user-images.githubusercontent.com/51039745/223440375-d472de4b-aa7f-4eae-9170-6dc2ed9f5480.png"></details>
+
+	<details><summary>3. 在文件中设定默认密钥、用户名密码</summary>
+
+	这样设置的密钥可以在拉取项目更新之后保留。
+	
+	在项目文件夹中新建这两个文件：`api_key.txt` 和 `auth.json`。
+
+	在`api_key.txt`中填写你的API-Key，注意不要填写任何无关内容。
+
+	在`auth.json`中填写你的用户名和密码。
+
+	```
+	{
+    "username": "用户名",
+    "password": "密码"
+	}
+	```
+
+	</details>
+
+3. **安装依赖**
+
+	```shell
+	pip install -r requirements.txt
+	```
+
+	如果报错，试试
+
+	```shell
+	pip3 install -r requirements.txt
+	```
+
+	如果还是不行，请先[安装Python](https://www.runoob.com/python/python-install.html)。
+
+	如果下载慢，建议[配置清华源](https://mirrors.tuna.tsinghua.edu.cn/help/pypi/)，或者科学上网。
+
+4. **启动**
+
+	```shell
+	python ChuanhuChatbot.py
+	```
+
+	如果报错，试试
+
+	```shell
+	python3 ChuanhuChatbot.py
+	```
+
+	如果还是不行，请先[安装Python](https://www.runoob.com/python/python-install.html)。
+<br />
+
+如果一切顺利，现在，你应该已经可以在浏览器地址栏中输入 [`http://localhost:7860`](http://localhost:7860) 查看并使用 ChuanhuChatGPT 了。
+
+**如果你在安装过程中碰到了问题，请先查看[疑难杂症解决](#疑难杂症解决)部分。**
+
+<details><summary><h3>或者，使用Docker 运行</h3></summary>
+
+#### 拉取镜像
+
+```shell
+docker pull tuchuanhuhuhu/chuanhuchatgpt:latest
+```
+
+#### 运行
+
+```shell
+docker run -d --name chatgpt \
+	-e my_api_key="替换成API" \
+	-e USERNAME="替换成用户名" \
+	-e PASSWORD="替换成密码" \
+	-v ~/chatGPThistory:/app/history \
+	-p 7860:7860 \
+	tuchuanhuhuhu/chuanhuchatgpt:latest
+```
+
+注：`USERNAME` 和 `PASSWORD` 两行可省略。若省略则不会启用认证。
+
+#### 查看运行状态
+```shell
+docker logs chatgpt
+```
+
+#### 也可修改脚本后手动构建镜像
+
+```shell
+docker build -t chuanhuchatgpt:latest .
+```
+</details>
+
+
+### 远程部署
+
+<details><summary>如果需要在公网服务器部署本项目，请阅读本部分</summary>
+
+### 部署到公网服务器
+
+将最后一句修改为
+
+```
+demo.queue().launch(server_name="0.0.0.0", server_port=7860, share=False) # 可自定义端口
+```
+### 用账号密码保护页面
+
+将最后一句修改为
+
+```
+demo.queue().launch(server_name="0.0.0.0", server_port=7860,auth=("在这里填写用户名", "在这里填写密码")) # 可设置用户名与密码
+```
+
+### 配置 Nginx 反向代理
+
+注意：配置反向代理不是必须的。如果需要使用域名，则需要配置 Nginx 反向代理。
+
+又及：目前配置认证后，Nginx 必须配置 SSL，否则会出现 [Cookie 不匹配问题](https://github.com/GaiZhenbiao/ChuanhuChatGPT/issues/89)。
+
+添加独立配置文件：
+```nginx
+server {
+	listen 80;
+	server_name /域名/;   # 请填入你设定的域名
+	access_log off;
+	error_log off;
+	location / {
+		proxy_pass http://127.0.0.1:7860;   # 注意端口号
+		proxy_redirect off;
+		proxy_set_header Host $host;
+		proxy_set_header X-Real-IP $remote_addr;
+		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+		proxy_set_header Upgrade $http_upgrade;		# Websocket配置
+		proxy_set_header Connection $connection_upgrade;		#Websocket配置
+		proxy_max_temp_file_size 0;
+		client_max_body_size 10m;
+		client_body_buffer_size 128k;
+		proxy_connect_timeout 90;
+		proxy_send_timeout 90;
+		proxy_read_timeout 90;
+		proxy_buffer_size 4k;
+		proxy_buffers 4 32k;
+		proxy_busy_buffers_size 64k;
+		proxy_temp_file_write_size 64k;
+	}
+}
+```
+
+修改`nginx.conf`配置文件（通常在`/etc/nginx/nginx.conf`），向http部分添加如下配置：
+（这一步是为了配置websocket连接，如之前配置过可忽略）
+```nginx
+map $http_upgrade $connection_upgrade {
+  default upgrade;
+  ''      close;
+  }
+```
+
+为了同时配置域名访问和身份认证，需要配置SSL的证书，可以参考[这篇博客](https://www.gzblog.tech/2020/12/25/how-to-config-hexo/#%E9%85%8D%E7%BD%AEHTTPS)一键配置
+
+</details>
+
+## 疑难杂症解决
+
+首先，请尝试拉取本项目的最新更改，使用最新的代码重试。
+
+点击网页上的 `Download ZIP` 下载最新代码，或
+```shell
+git pull https://github.com/GaiZhenbiao/ChuanhuChatGPT.git main -f
+```
+
+如果还有问题，可以再尝试重装 gradio:
+
+```
+pip install gradio --upgrade --force-reinstall
+```
+
+很多时候，这样就可以解决问题。
+
+<details><summary><h3><code>No module named '_bz2'</code></h3></summary>
+
+> 部署在CentOS7.6,Python3.11.0上,最后报错ModuleNotFoundError: No module named '_bz2'
+
+安装python前先下载 `bzip` 编译环境
+
+```
+sudo yum install bzip2-devel
+```
+</details>
+
+<details><summary><h3><code>openai.error.APIConnectionError</code></h3></summary>
+
+> 如果有人也出现了`openai.error.APIConnectionError`提示的报错，那可能是`urllib3`的版本导致的。`urllib3`版本大于`1.25.11`，就会出现这个问题。
+>
+> 解决方案是卸载`urllib3`然后重装至`1.25.11`版本再重新运行一遍就可以
+
+参见：[#5](https://github.com/GaiZhenbiao/ChuanhuChatGPT/issues/5)
+
+在终端或命令提示符中卸载`urllib3`
+
+```
+pip uninstall urllib3
+```
+
+然后，通过使用指定版本号的`pip install`命令来安装所需的版本：
+
+```
+pip install urllib3==1.25.11
+```
+
+参考自：
+[解决OpenAI API 挂了代理还是连接不上的问题](https://zhuanlan.zhihu.com/p/611080662)
+</details>
+
+<details><summary><h3>在 Python 文件里 设定 API Key 之后验证失败</h3></summary>
+
+> 在ChuanhuChatbot.py中设置APIkey后验证出错，提示“发生了未知错误Orz”
+
+参见：[#26](https://github.com/GaiZhenbiao/ChuanhuChatGPT/issues/26)
+</details>
+
+<details><summary><h3>一直等待/SSL Error</h3></summary>
+
+> 更新脚本文件后，SSLError [#49](https://github.com/GaiZhenbiao/ChuanhuChatGPT/issues/49)
+>
+> 跑起来之后，输入问题好像就没反应了，也没报错 [#25](https://github.com/GaiZhenbiao/ChuanhuChatGPT/issues/25)
+>
+> ```
+> requests.exceptions.SSLError: HTTPSConnectionPool(host='api.openai.com', port=443): Max retries exceeded with url: /v1/chat/completions (Caused by SSLError(SSLEOFError(8, 'EOF occurred in violation of protocol (_ssl.c:1129)')))
+> ```
+
+请将`openai.com`加入你使用的代理App的代理规则。注意不要将`127.0.0.1`加入代理，否则会有下一个错误。
+
+例如，在Clash配置文件中，加入：
+
+```
+rule-providers:
+  private:
+    type: http
+    behavior: domain
+    url: "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/lancidr.txt"
+    path: ./ruleset/ads.yaml
+    interval: 86400
+
+rules:
+ - RULE-SET,private,DIRECT
+ - DOMAIN-SUFFIX,openai.com,你的代理规则
+```
+
+Surge：
+
+```
+[Rule]
+DOMAIN-SET,https://cdn.jsdelivr.net/gh/Loyalsoldier/surge-rules@release/private.txt,DIRECT
+DOMAIN-SUFFIX,openai.com,你的代理规则
+```
+</details>
+
+<details><summary><h3>网页提示错误 Something went wrong</h3></summary>
+
+> ```
+> Something went wrong
+> Expecting value: 1ine 1 column 1 (char o)
+> ```
+
+出现这个错误的原因是`127.0.0.1`被代理了，导致网页无法和后端通信。请设置代理软件，将`127.0.0.1`加入直连。
+</details>
+
+<details><summary><h3><code>No matching distribution found for openai>=0.27.0</code></h3></summary>
+
+`openai`这个依赖已经被移除了。请尝试下载最新版脚本。
+</details>
+
+## Starchart
+
+[![Star History Chart](https://api.star-history.com/svg?repos=GaiZhenbiao/ChuanhuChatGPT&type=Date)](https://star-history.com/#GaiZhenbiao/ChuanhuChatGPT&Date)
+
+## Contributors
+
+<a href="https://github.com/GaiZhenbiao/ChuanhuChatGPT/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=GaiZhenbiao/ChuanhuChatGPT" />
+</a>
+
+## 捐款
+
+🐯请作者喝可乐～
+
+<img width="350" alt="image" src="https://user-images.githubusercontent.com/51039745/223626874-f471e5f5-8a06-43d5-aa31-9d2575b6f631.JPG">

presets.py

@@ -1,13 +1,39 @@
-title = """<h1 align="center"></h1>"""
-description = """<div align=center>
+# -*- coding:utf-8 -*-
+title = """<h1 align="left" style="min-width:200px; margin-top:0;"></h1>"""
+description = """<div align="center" style="margin:16px 0">
 
-此网页基于 `gpt-3.5-turbo` 大型自然语言处理模型
-
-Chatbot Mar 12 Version.
+Chatbot Mar 17 Version.
 
 </div>
 """
 customCSS = """
+#status_display {
+    display: flex;
+    min-height: 2.5em;
+    align-items: flex-end;
+    justify-content: flex-end;
+}
+#status_display p {
+    font-size: .85em;
+    font-family: monospace;
+    color: var(--text-color-subdued) !important;
+}
+[class *= "message"] {
+    border-radius: var(--radius-xl) !important;
+    border: none;
+    padding: var(--spacing-xl) !important;
+    font-size: var(--text-md) !important;
+    line-height: var(--line-md) !important;
+}
+[data-testid = "bot"] {
+    max-width: 85%;
+    border-bottom-left-radius: 0 !important;
+}
+[data-testid = "user"] {
+    max-width: 85%;
+    width: auto !important;
+    border-bottom-right-radius: 0 !important;
+}
 code {
     display: inline;
     white-space: break-spaces;
@@ -27,14 +53,35 @@ pre code {
     color: #FFF;
     box-shadow: inset 0px 8px 16px hsla(0, 0%, 0%, .2)
 }
+
+* {
+    transition: all 0.6s;
+}
 """
 
+summarize_prompt = "你是谁？我们刚才聊了什么？" # 总结对话时的 prompt
+MODELS = ["gpt-3.5-turbo", "gpt-3.5-turbo-0301", "gpt-4","gpt-4-0314", "gpt-4-32k", "gpt-4-32k-0314"] # 可选的模型
+websearch_prompt = """Web search results:
+
+{web_results}
+Current date: {current_date}
+
+Instructions: Using the provided web search results, write a comprehensive reply to the given query. Make sure to cite results using [[number](URL)] notation after the reference. If the provided search results refer to multiple subjects with the same name, write separate answers for each subject.
+Query: {query}
+Reply in 中文"""
+
+# 错误信息
 standard_error_msg = "☹️发生了错误：" # 错误信息的标准前缀
-error_retrieve_prompt = "连接超时，无法获取对话。请检查网络连接，或者API-Key是否有效。" # 获取对话时发生错误
-summarize_prompt = "请总结以上对话，不超过100字。" # 总结对话时的 prompt
-max_token_streaming = 4096 # 流式对话时的最大 token 数
-timeout_streaming = 5 # 流式对话时的超时时间
-max_token_all = 4096 # 非流式对话时的最大 token 数
+error_retrieve_prompt = "请检查网络连接，或者API-Key是否有效。" # 获取对话时发生错误
+connection_timeout_prompt = "连接超时，无法获取对话。" # 连接超时
+read_timeout_prompt = "读取超时，无法获取对话。" # 读取超时
+proxy_error_prompt = "代理错误，无法获取对话。" # 代理错误
+ssl_error_prompt = "SSL错误，无法获取对话。" # SSL 错误
+no_apikey_msg = "API key长度不是51位，请检查是否输入正确。" # API key 长度不足 51 位
+
+max_token_streaming = 3500 # 流式对话时的最大 token 数
+timeout_streaming = 15 # 流式对话时的超时时间
+max_token_all = 3500 # 非流式对话时的最大 token 数
 timeout_all = 200 # 非流式对话时的超时时间
-enable_streaming_option = False  # 是否启用选择选择是否实时显示回答的勾选框
+enable_streaming_option = True  # 是否启用选择选择是否实时显示回答的勾选框
 HIDE_MY_KEY = True # 如果你想在UI中隐藏你的 API 密钥，将此值设置为 True

requirements.txt

@@ -1,3 +1,8 @@
 gradio
 mdtex2html
 pypinyin
+tiktoken
+socksio
+tqdm
+colorama
+duckduckgo_search

utils.py

@@ -1,9 +1,7 @@
-"""Contains all of the components that can be used with Gradio Interface / Blocks.
-Along with the docs for each component, you can find the names of example demos that use
-each component. These demos are located in the `demo` directory."""
-
+# -*- coding:utf-8 -*-
 from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Tuple, Type
+import logging
 import json
 import gradio as gr
 # import openai
@@ -15,6 +13,13 @@ import csv
 import mdtex2html
 from pypinyin import lazy_pinyin
 from presets import *
+import tiktoken
+from tqdm import tqdm
+import colorama
+from duckduckgo_search import ddg
+import datetime
+
+# logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] [%(filename)s:%(lineno)d] %(message)s")
 
 if TYPE_CHECKING:
     from typing import TypedDict
@@ -23,7 +28,7 @@ if TYPE_CHECKING:
         headers: List[str]
         data: List[List[str | int | bool]]
 
-initial_prompt = "你是 ChatGPT，由 OpenAI 训练的大型语言模型。你的数据库截止日期为：2021年9。"
+initial_prompt = "You are a helpful assistant."
 API_URL = "https://api.openai.com/v1/chat/completions"
 HISTORY_DIR = "history"
 TEMPLATES_DIR = "templates"
@@ -48,6 +53,11 @@ def postprocess(
             )
         return y
 
+def count_token(input_str):
+    encoding = tiktoken.get_encoding("cl100k_base")
+    length = len(encoding.encode(input_str))
+    return length
+
 def parse_text(text):
     lines = text.split("\n")
     lines = [line for line in lines if line != ""]
@@ -92,10 +102,9 @@ def construct_assistant(text):
     return construct_text("assistant", text)
 
 def construct_token_message(token, stream=False):
-    extra = "【仅包含回答的计数】 " if stream else ""
-    return f"{extra}Token 计数: {token}"
+    return f"Token 计数: {token}"
 
-def get_response(openai_api_key, system_prompt, history, temperature, top_p, stream):
+def get_response(openai_api_key, system_prompt, history, temperature, top_p, stream, selected_model):
     headers = {
         "Content-Type": "application/json",
         "Authorization": f"Bearer {openai_api_key}"
@@ -104,7 +113,7 @@ def get_response(openai_api_key, system_prompt, history, temperature, top_p, str
     history = [construct_system(system_prompt), *history]
 
     payload = {
-        "model": "gpt-3.5-turbo",
+        "model": selected_model,
         "messages": history,  # [{"role": "user", "content": f"{inputs}"}],
         "temperature": temperature,  # 1.0,
         "top_p": top_p,  # 1.0,
@@ -120,25 +129,41 @@ def get_response(openai_api_key, system_prompt, history, temperature, top_p, str
     response = requests.post(API_URL, headers=headers, json=payload, stream=True, timeout=timeout)
     return response
 
-def stream_predict(openai_api_key, system_prompt, history, inputs, chatbot, previous_token_count, top_p, temperature):
+def stream_predict(openai_api_key, system_prompt, history, inputs, chatbot, all_token_counts, top_p, temperature, selected_model):
     def get_return_value():
-        return chatbot, history, status_text, [*previous_token_count, token_counter]
-    token_counter = 0
+        return chatbot, history, status_text, all_token_counts
+
+    logging.info("实时回答模式")
     partial_words = ""
     counter = 0
-    status_text = "OK"
+    status_text = "开始实时传输回答……"
     history.append(construct_user(inputs))
+    history.append(construct_assistant(""))
+    chatbot.append((parse_text(inputs), ""))
+    user_token_count = 0
+    if len(all_token_counts) == 0:
+        system_prompt_token_count = count_token(system_prompt)
+        user_token_count = count_token(inputs) + system_prompt_token_count
+    else:
+        user_token_count = count_token(inputs)
+    all_token_counts.append(user_token_count)
+    logging.info(f"输入token计数: {user_token_count}")
+    yield get_return_value()
     try:
-        response = get_response(openai_api_key, system_prompt, history, temperature, top_p, True)
+        response = get_response(openai_api_key, system_prompt, history, temperature, top_p, True, selected_model)
     except requests.exceptions.ConnectTimeout:
-        status_text = standard_error_msg + error_retrieve_prompt
+        status_text = standard_error_msg + connection_timeout_prompt + error_retrieve_prompt
+        yield get_return_value()
+        return
+    except requests.exceptions.ReadTimeout:
+        status_text = standard_error_msg + read_timeout_prompt + error_retrieve_prompt
         yield get_return_value()
         return
 
-    chatbot.append((parse_text(inputs), ""))
     yield get_return_value()
+    error_json_str = ""
 
-    for chunk in response.iter_lines():
+    for chunk in tqdm(response.iter_lines()):
         if counter == 0:
             counter += 1
             continue
@@ -147,130 +172,200 @@ def stream_predict(openai_api_key, system_prompt, history, inputs, chatbot, prev
         if chunk:
             chunk = chunk.decode()
             chunklength = len(chunk)
-            chunk = json.loads(chunk[6:])
+            try:
+                chunk = json.loads(chunk[6:])
+            except json.JSONDecodeError:
+                logging.info(chunk)
+                error_json_str += chunk
+                status_text = f"JSON解析错误。请重置对话。收到的内容: {error_json_str}"
+                yield get_return_value()
+                continue
             # decode each line as response data is in bytes
             if chunklength > 6 and "delta" in chunk['choices'][0]:
                 finish_reason = chunk['choices'][0]['finish_reason']
-                status_text = construct_token_message(sum(previous_token_count)+token_counter, stream=True)
+                status_text = construct_token_message(sum(all_token_counts), stream=True)
                 if finish_reason == "stop":
                     yield get_return_value()
                     break
-                partial_words = partial_words + chunk['choices'][0]["delta"]["content"]
-                if token_counter == 0:
-                    history.append(construct_assistant(" " + partial_words))
-                else:
-                    history[-1] = construct_assistant(partial_words)
+                try:
+                    partial_words = partial_words + chunk['choices'][0]["delta"]["content"]
+                except KeyError:
+                    status_text = standard_error_msg + "API回复中找不到内容。很可能是Token计数达到上限了。请重置对话。当前Token计数: " + str(sum(all_token_counts))
+                    yield get_return_value()
+                    break
+                history[-1] = construct_assistant(partial_words)
                 chatbot[-1] = (parse_text(inputs), parse_text(partial_words))
-                token_counter += 1
+                all_token_counts[-1] += 1
                 yield get_return_value()
 
 
-def predict_all(openai_api_key, system_prompt, history, inputs, chatbot, previous_token_count, top_p, temperature):
+def predict_all(openai_api_key, system_prompt, history, inputs, chatbot, all_token_counts, top_p, temperature, selected_model):
+    logging.info("一次性回答模式")
     history.append(construct_user(inputs))
+    history.append(construct_assistant(""))
+    chatbot.append((parse_text(inputs), ""))
+    all_token_counts.append(count_token(inputs))
     try:
-        response = get_response(openai_api_key, system_prompt, history, temperature, top_p, False)
+        response = get_response(openai_api_key, system_prompt, history, temperature, top_p, False, selected_model)
     except requests.exceptions.ConnectTimeout:
-        status_text = standard_error_msg + error_retrieve_prompt
-        return chatbot, history, status_text, previous_token_count
+        status_text = standard_error_msg + connection_timeout_prompt + error_retrieve_prompt
+        return chatbot, history, status_text, all_token_counts
+    except requests.exceptions.ProxyError:
+        status_text = standard_error_msg + proxy_error_prompt + error_retrieve_prompt
+        return chatbot, history, status_text, all_token_counts
+    except requests.exceptions.SSLError:
+        status_text = standard_error_msg + ssl_error_prompt + error_retrieve_prompt
+        return chatbot, history, status_text, all_token_counts
     response = json.loads(response.text)
     content = response["choices"][0]["message"]["content"]
-    history.append(construct_assistant(content))
-    chatbot.append((parse_text(inputs), parse_text(content)))
+    history[-1] = construct_assistant(content)
+    chatbot[-1] = (parse_text(inputs), parse_text(content))
     total_token_count = response["usage"]["total_tokens"]
-    previous_token_count.append(total_token_count - sum(previous_token_count))
+    all_token_counts[-1] = total_token_count - sum(all_token_counts)
     status_text = construct_token_message(total_token_count)
-    return chatbot, history, status_text, previous_token_count
-
-
-def predict(openai_api_key, system_prompt, history, inputs, chatbot, token_count, top_p, temperature, stream=False, should_check_token_count = True):  # repetition_penalty, top_k
+    return chatbot, history, status_text, all_token_counts
+
+
+def predict(openai_api_key, system_prompt, history, inputs, chatbot, all_token_counts, top_p, temperature, stream=False, selected_model = MODELS[0], use_websearch_checkbox = False, should_check_token_count = True):  # repetition_penalty, top_k
+    logging.info("输入为：" +colorama.Fore.BLUE + f"{inputs}" + colorama.Style.RESET_ALL)
+    if use_websearch_checkbox:
+        results = ddg(inputs, max_results=3)
+        web_results = []
+        for idx, result in enumerate(results):
+            logging.info(f"搜索结果{idx + 1}：{result}")
+            web_results.append(f'[{idx+1}]"{result["body"]}"\nURL: {result["href"]}')
+        web_results = "\n\n".join(web_results)
+        today = datetime.datetime.today().strftime("%Y-%m-%d")
+        inputs = websearch_prompt.replace("{current_date}", today).replace("{query}", inputs).replace("{web_results}", web_results)
+    if len(openai_api_key) != 51:
+        status_text = standard_error_msg + no_apikey_msg
+        logging.info(status_text)
+        chatbot.append((parse_text(inputs), ""))
+        if len(history) == 0:
+            history.append(construct_user(inputs))
+            history.append("")
+            all_token_counts.append(0)
+        else:
+            history[-2] = construct_user(inputs)
+        yield chatbot, history, status_text, all_token_counts
+        return
+    if stream:
+        yield chatbot, history, "开始生成回答……", all_token_counts
     if stream:
-        iter = stream_predict(openai_api_key, system_prompt, history, inputs, chatbot, token_count, top_p, temperature)
-        for chatbot, history, status_text, token_count in iter:
-            yield chatbot, history, status_text, token_count
+        logging.info("使用流式传输")
+        iter = stream_predict(openai_api_key, system_prompt, history, inputs, chatbot, all_token_counts, top_p, temperature, selected_model)
+        for chatbot, history, status_text, all_token_counts in iter:
+            yield chatbot, history, status_text, all_token_counts
     else:
-        chatbot, history, status_text, token_count = predict_all(openai_api_key, system_prompt, history, inputs, chatbot, token_count, top_p, temperature)
-        yield chatbot, history, status_text, token_count
+        logging.info("不使用流式传输")
+        chatbot, history, status_text, all_token_counts = predict_all(openai_api_key, system_prompt, history, inputs, chatbot, all_token_counts, top_p, temperature, selected_model)
+        yield chatbot, history, status_text, all_token_counts
+    logging.info(f"传输完毕。当前token计数为{all_token_counts}")
+    if len(history) > 1 and history[-1]['content'] != inputs:
+        logging.info("回答为：" +colorama.Fore.BLUE + f"{history[-1]['content']}" + colorama.Style.RESET_ALL)
     if stream:
         max_token = max_token_streaming
     else:
         max_token = max_token_all
-    if sum(token_count) > max_token and should_check_token_count:
-        iter = reduce_token_size(openai_api_key, system_prompt, history, chatbot, token_count, top_p, temperature, stream=False, hidden=True)
-        for chatbot, history, status_text, token_count in iter:
-            status_text = f"Token已达到上限，自动降低Token计数至 {status_text}"
-            yield chatbot, history, status_text, token_count
-
-
-def retry(openai_api_key, system_prompt, history, chatbot, token_count, top_p, temperature, stream=False):
+    if sum(all_token_counts) > max_token and should_check_token_count:
+        status_text = f"精简token中{all_token_counts}/{max_token}"
+        logging.info(status_text)
+        yield chatbot, history, status_text, all_token_counts
+        iter = reduce_token_size(openai_api_key, system_prompt, history, chatbot, all_token_counts, top_p, temperature, stream=False, selected_model=selected_model, hidden=True)
+        for chatbot, history, status_text, all_token_counts in iter:
+            status_text = f"Token 达到上限，已自动降低Token计数至 {status_text}"
+            yield chatbot, history, status_text, all_token_counts
+
+
+def retry(openai_api_key, system_prompt, history, chatbot, token_count, top_p, temperature, stream=False, selected_model = MODELS[0]):
+    logging.info("重试中……")
     if len(history) == 0:
         yield chatbot, history, f"{standard_error_msg}上下文是空的", token_count
         return
     history.pop()
     inputs = history.pop()["content"]
     token_count.pop()
-    iter = predict(openai_api_key, system_prompt, history, inputs, chatbot, token_count, top_p, temperature, stream=stream)
+    iter = predict(openai_api_key, system_prompt, history, inputs, chatbot, token_count, top_p, temperature, stream=stream, selected_model=selected_model)
+    logging.info("重试完毕")
     for x in iter:
         yield x
 
 
-def reduce_token_size(openai_api_key, system_prompt, history, chatbot, token_count, top_p, temperature, stream=False, hidden=False):
-    iter = predict(openai_api_key, system_prompt, history, summarize_prompt, chatbot, token_count, top_p, temperature, stream=stream, should_check_token_count=False)
+def reduce_token_size(openai_api_key, system_prompt, history, chatbot, token_count, top_p, temperature, stream=False, selected_model = MODELS[0], hidden=False):
+    logging.info("开始减少token数量……")
+    iter = predict(openai_api_key, system_prompt, history, summarize_prompt, chatbot, token_count, top_p, temperature, stream=stream, selected_model = selected_model, should_check_token_count=False)
+    logging.info(f"chatbot: {chatbot}")
     for chatbot, history, status_text, previous_token_count in iter:
         history = history[-2:]
         token_count = previous_token_count[-1:]
         if hidden:
             chatbot.pop()
         yield chatbot, history, construct_token_message(sum(token_count), stream=stream), token_count
+    logging.info("减少token数量完毕")
 
 
-def delete_last_conversation(chatbot, history, previous_token_count, streaming):
+def delete_last_conversation(chatbot, history, previous_token_count):
     if len(chatbot) > 0 and standard_error_msg in chatbot[-1][1]:
+        logging.info("由于包含报错信息，只删除chatbot记录")
         chatbot.pop()
         return chatbot, history
     if len(history) > 0:
+        logging.info("删除了一组对话历史")
         history.pop()
         history.pop()
     if len(chatbot) > 0:
+        logging.info("删除了一组chatbot对话")
         chatbot.pop()
     if len(previous_token_count) > 0:
+        logging.info("删除了一组对话的token计数记录")
         previous_token_count.pop()
-    return chatbot, history, previous_token_count, construct_token_message(sum(previous_token_count), streaming)
+    return chatbot, history, previous_token_count, construct_token_message(sum(previous_token_count))
 
 
 def save_chat_history(filename, system, history, chatbot):
+    logging.info("保存对话历史中……")
     if filename == "":
         return
     if not filename.endswith(".json"):
         filename += ".json"
     os.makedirs(HISTORY_DIR, exist_ok=True)
     json_s = {"system": system, "history": history, "chatbot": chatbot}
-    print(json_s)
+    logging.info(json_s)
     with open(os.path.join(HISTORY_DIR, filename), "w") as f:
-        json.dump(json_s, f)
+        json.dump(json_s, f, ensure_ascii=False, indent=4)
+    logging.info("保存对话历史完毕")
 
 
 def load_chat_history(filename, system, history, chatbot):
+    logging.info("加载对话历史中……")
     try:
         with open(os.path.join(HISTORY_DIR, filename), "r") as f:
             json_s = json.load(f)
-        if type(json_s["history"]) == list:
-            new_history = []
-            for index, item in enumerate(json_s["history"]):
-                if index % 2 == 0:
-                    new_history.append(construct_user(item))
-                else:
-                    new_history.append(construct_assistant(item))
-            json_s["history"] = new_history
+        try:
+            if type(json_s["history"][0]) == str:
+                logging.info("历史记录格式为旧版，正在转换……")
+                new_history = []
+                for index, item in enumerate(json_s["history"]):
+                    if index % 2 == 0:
+                        new_history.append(construct_user(item))
+                    else:
+                        new_history.append(construct_assistant(item))
+                json_s["history"] = new_history
+                logging.info(new_history)
+        except:
+            # 没有对话历史
+            pass
+        logging.info("加载对话历史完毕")
         return filename, json_s["system"], json_s["history"], json_s["chatbot"]
     except FileNotFoundError:
-        print("File not found.")
+        logging.info("没有找到对话历史文件，不执行任何操作")
         return filename, system, history, chatbot
 
 def sorted_by_pinyin(list):
     return sorted(list, key=lambda char: lazy_pinyin(char)[0][0])
 
 def get_file_names(dir, plain=False, filetypes=[".json"]):
-    # find all json files in the current directory and return their names
+    logging.info(f"获取文件名列表，目录为{dir}，文件类型为{filetypes}，是否为纯文本列表{plain}")
     files = []
     try:
         for type in filetypes:
@@ -286,11 +381,13 @@ def get_file_names(dir, plain=False, filetypes=[".json"]):
         return gr.Dropdown.update(choices=files)
 
 def get_history_names(plain=False):
+    logging.info("获取历史记录文件名列表")
     return get_file_names(HISTORY_DIR, plain)
 
 def load_template(filename, mode=0):
+    logging.info(f"加载模板文件{filename}，模式为{mode}（0为返回字典和下拉菜单，1为返回下拉菜单，2为返回字典）")
     lines = []
-    print("Loading template...")
+    logging.info("Loading template...")
     if filename.endswith(".json"):
         with open(os.path.join(TEMPLATES_DIR, filename), "r", encoding="utf8") as f:
             lines = json.load(f)
@@ -309,24 +406,19 @@ def load_template(filename, mode=0):
         return {row[0]:row[1] for row in lines}, gr.Dropdown.update(choices=choices, value=choices[0])
 
 def get_template_names(plain=False):
+    logging.info("获取模板文件名列表")
     return get_file_names(TEMPLATES_DIR, plain, filetypes=[".csv", "json"])
 
 def get_template_content(templates, selection, original_system_prompt):
+    logging.info(f"应用模板中，选择为{selection}，原始系统提示为{original_system_prompt}")
     try:
         return templates[selection]
     except:
         return original_system_prompt
 
 def reset_state():
+    logging.info("重置状态")
     return [], [], [], construct_token_message(0)
 
-def compose_system(system_prompt):
-    return {"role": "system", "content": system_prompt}
-
-
-def compose_user(user_input):
-    return {"role": "user", "content": user_input}
-
-
 def reset_textbox():
     return gr.update(value='')