Upload 5 files

app.py

@@ -0,0 +1,92 @@
+import gradio as gr
+import os
+import sys
+import argparse
+from utils import *
+from presets import *
+from chat_func import *
+my_api_key = "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"    # 在这里输入你的 API 密钥
+
+if my_api_key == "":
+    my_api_key = os.environ.get('my_api_key')
+
+if my_api_key == "empty":
+    print("Please give a api key!")
+    sys.exit(1)
+
+gr.Chatbot.postprocess = postprocess
+
+# css = """
+#       #col-container {max-width: 80%; margin-left: auto; margin-right: auto;}
+#       #chatbox {min-height: 150px}
+#       #header {text-align: center;font-size: 2.8em}
+#       #prompt_template_preview {padding: 1em; border-width: 1px; border-style: solid; border-color: #e0e0e0; border-radius: 4px;}
+#       #submit {text-align: center; background-color: #e0e0e0;}
+#       #label {font-size: 0.8em; padding: 0.5em; margin: 0;}
+#       """
+with gr.Blocks() as demo:
+    history = gr.State([])
+    token_count = gr.State([])
+    promptTemplates = gr.State(load_template(get_template_names(plain=True)[0], mode=2))
+    user_api_key = gr.State(my_api_key)
+    TRUECOMSTANT = gr.State(True)
+    FALSECONSTANT = gr.State(False)
+    gr.Markdown(title)
+
+    with gr.Accordion("Build by [45度科研人](WeChat Public Accounts)", open=False):
+        gr.Markdown(description)
+        
+    with gr.Row(scale=1).style(equal_height=True):
+        with gr.Column(scale=5):
+            with gr.Column():
+                chatbot = gr.Chatbot().style(color_map=("blue", "green"))
+                user_input = gr.Textbox(show_label=False, placeholder="Enter text and press submit", visible=True).style(container=False)
+                submitBtn = gr.Button("Submit", variant="primary").style(container=False)
+                emptyBtn = gr.Button("Restart Conversation")
+                status_display = gr.Markdown("")
+
+        with gr.Column():
+            with gr.Column(min_width=50):
+                with gr.Tab(label="ChatGPT"):
+                    with gr.Column():
+                        with gr.Row():
+                            keyTxt = gr.Textbox(show_label=False, placeholder=f"You can input your own openAI API-key",value=hide_middle_chars(my_api_key),visible=True, type="password",  label="API-Key")
+                            # keyTxt = gr.Textbox(show_label=False, placeholder=f"You can input your own openAI API-key",value=my_api_key,visible=True, type="password",  label="API-Key")
+                            systemPromptTxt = gr.Textbox(show_label=True,placeholder=f"Set a custom insruction for the chatbot: You are a helpful assistant.",label="Custom prompt",value=initial_prompt,lines=10,).style(container=False)
+
+                        with gr.Row():
+                            templateSelectDropdown = gr.Dropdown(label="load from template",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],).style(container=False)                
+                
+                with gr.Tab(label="Settings"):
+                    with gr.Column():
+                        with gr.Row():
+                            with gr.Column(scale=3):
+                                saveFileName = gr.Textbox(show_label=True, placeholder=f"output file name...",label='Save conversation history', value="").style(container=False)
+                            with gr.Column(scale=1):
+                                exportMarkdownBtn = gr.Button("Save")
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                downloadFile = gr.File(interactive=False)
+    gr.Markdown("""
+                                <div align=center>you can follow the WeChat public account [45度科研人] and leave me a message!
+                                <div align=center><img width = '200' height ='200' src ="https://dunazo.oss-cn-beijing.aliyuncs.com/blog/wechat-simple.png"/></div>""")
+    keyTxt.submit(submit_key, keyTxt, [user_api_key, status_display])
+    keyTxt.change(submit_key, keyTxt, [user_api_key, status_display])
+    # Chatbot
+    user_input.submit(predict,[user_api_key,systemPromptTxt,history,user_input,chatbot,token_count,],[chatbot, history, status_display, token_count],show_progress=True)
+    user_input.submit(reset_textbox, [], [user_input])
+
+    submitBtn.click(predict,[user_api_key,systemPromptTxt,history,user_input,chatbot,token_count,],[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,)
+
+    templateSelectDropdown.change(get_template_content,[promptTemplates, templateSelectDropdown, systemPromptTxt],[systemPromptTxt],show_progress=True,)
+    exportMarkdownBtn.click(export_markdown,[saveFileName, systemPromptTxt, history, chatbot],downloadFile,show_progress=True,)
+    downloadFile.change(load_chat_history,[downloadFile, systemPromptTxt, history, chatbot],[saveFileName, systemPromptTxt, history, chatbot],)
+
+# demo.title = "Sydney-AI 2.0"
+
+if __name__ == "__main__":
+    demo.queue().launch(debug=False,show_api=False,share=True) 

chat_func.py

@@ -0,0 +1,300 @@
+# -*- coding:utf-8 -*-
+from __future__ import annotations
+from typing import TYPE_CHECKING, List
+
+import logging
+import json
+import os
+import requests
+
+from tqdm import tqdm
+
+from presets import *
+# from llama_func import *
+from utils import *
+
+# logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] [%(filename)s:%(lineno)d] %(message)s")
+
+if TYPE_CHECKING:
+    from typing import TypedDict
+
+    class DataframeData(TypedDict):
+        headers: List[str]
+        data: List[List[str | int | bool]]
+
+
+initial_prompt = "You are a helpful assistant."
+API_URL = "https://api.openai.com/v1/chat/completions"
+TEMPLATES_DIR = "templates"
+
+def get_response(
+    openai_api_key, system_prompt, history, stream, selected_model
+):
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {openai_api_key}",
+    }
+
+    history = [construct_system(system_prompt), *history]
+
+    payload = {
+        "model": selected_model,
+        "messages": history,  # [{"role": "user", "content": f"{inputs}"}],
+        "temperature": 1.0,  # 1.0,
+        "top_p": 1.0,  # 1.0,
+        "n": 1,
+        "stream": stream,
+        "presence_penalty": 0,
+        "frequency_penalty": 0,
+    }
+    if stream:
+        timeout = timeout_streaming
+    else:
+        timeout = timeout_all
+
+    # 获取环境变量中的代理设置
+    http_proxy = os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy")
+    https_proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
+
+    # 如果存在代理设置，使用它们
+    proxies = {}
+    if http_proxy:
+        logging.info(f"Using HTTP proxy: {http_proxy}")
+        proxies["http"] = http_proxy
+    if https_proxy:
+        logging.info(f"Using HTTPS proxy: {https_proxy}")
+        proxies["https"] = https_proxy
+
+    # 如果有代理，使用代理发送请求，否则使用默认设置发送请求
+    if proxies:
+        response = requests.post(
+            API_URL,
+            headers=headers,
+            json=payload,
+            stream=True,
+            timeout=timeout,
+            proxies=proxies,
+        )
+    else:
+        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,
+    all_token_counts,
+    selected_model,
+    fake_input=None,
+    display_append=""
+):
+    def get_return_value():
+        return chatbot, history, status_text, all_token_counts
+    # logging.info("实时回答模式")
+    partial_words = ""
+    counter = 0
+    status_text = "answering……"
+    history.append(construct_user(inputs))
+    history.append(construct_assistant(""))
+    if fake_input:
+        chatbot.append((fake_input, ""))
+    else:
+        chatbot.append((inputs, ""))
+    user_token_count = 0
+    if len(all_token_counts) == 0:
+        system_prompt_token_count = count_token(construct_system(system_prompt))
+        user_token_count = (
+            count_token(construct_user(inputs)) + system_prompt_token_count
+        )
+    else:
+        user_token_count = count_token(construct_user(inputs))
+    all_token_counts.append(user_token_count)
+    logging.info(f"input token count: {user_token_count}")
+    yield get_return_value()
+    try:
+        response = get_response(
+            openai_api_key,
+            system_prompt,
+            history,
+            True,
+            selected_model,
+        )
+    except requests.exceptions.ConnectTimeout:
+        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
+
+    yield get_return_value()
+    error_json_str = ""
+
+    for chunk in tqdm(response.iter_lines()):
+        if counter == 0:
+            counter += 1
+            continue
+        counter += 1
+        # check whether each line is non-empty
+        if chunk:
+            chunk = chunk.decode()
+            chunklength = len(chunk)
+            try:
+                chunk = json.loads(chunk[6:])
+            except json.JSONDecodeError:
+                logging.info(chunk)
+                error_json_str += chunk
+                status_text = f"JSON file parsing error. Please reset the conversation. received content: {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(all_token_counts), stream=True
+                )
+                if finish_reason == "stop":
+                    yield get_return_value()
+                    break
+                try:
+                    partial_words = (
+                        partial_words + chunk["choices"][0]["delta"]["content"]
+                    )
+                except KeyError:
+                    status_text = (
+                        standard_error_msg
+                        + "Token count has reached the maxtoken limit. Please reset the conversation. Current Token Count: "
+                        + str(sum(all_token_counts))
+                    )
+                    yield get_return_value()
+                    break
+                history[-1] = construct_assistant(partial_words)
+                chatbot[-1] = (chatbot[-1][0], partial_words+display_append)
+                all_token_counts[-1] += 1
+                yield get_return_value()
+
+
+def predict_all(
+    openai_api_key,
+    system_prompt,
+    history,
+    inputs,
+    chatbot,
+    all_token_counts,
+    selected_model,
+    fake_input=None,
+    display_append=""
+):
+    # logging.info("一次性回答模式")
+    history.append(construct_user(inputs))
+    history.append(construct_assistant(""))
+    if fake_input:
+        chatbot.append((fake_input, ""))
+    else:
+        chatbot.append((inputs, ""))
+    all_token_counts.append(count_token(construct_user(inputs)))
+    try:
+        response = get_response(
+            openai_api_key,
+            system_prompt,
+            history,
+            False,
+            selected_model,
+        )
+    except requests.exceptions.ConnectTimeout:
+        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[-1] = construct_assistant(content)
+    chatbot[-1] = (chatbot[-1][0], content+display_append)
+    total_token_count = response["usage"]["total_tokens"]
+    all_token_counts[-1] = total_token_count - sum(all_token_counts)
+    status_text = construct_token_message(total_token_count)
+    return chatbot, history, status_text, all_token_counts
+
+
+def predict(
+    openai_api_key,
+    system_prompt,
+    history,
+    inputs,
+    chatbot,
+    all_token_counts,
+    stream=True,
+    selected_model=MODELS[0],
+    use_websearch=False,
+    files = None,
+    should_check_token_count=True,
+):  # repetition_penalty, top_k
+
+    old_inputs = ""
+    link_references = ""
+
+    if len(openai_api_key) != 51:
+        status_text = standard_error_msg + no_apikey_msg
+        logging.info(status_text)
+        chatbot.append((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
+
+    yield chatbot, history, "answering……", all_token_counts
+
+    if stream:
+        # logging.info("使用流式传输")
+        iter = stream_predict(
+            openai_api_key,
+            system_prompt,
+            history,
+            inputs,
+            chatbot,
+            all_token_counts,
+            selected_model,
+            fake_input=old_inputs,
+            display_append=link_references
+        )
+        for chatbot, history, status_text, all_token_counts in iter:
+            yield chatbot, history, status_text, all_token_counts
+    else:
+        # logging.info("不使用流式传输")
+        chatbot, history, status_text, all_token_counts = predict_all(
+            openai_api_key,
+            system_prompt,
+            history,
+            inputs,
+            chatbot,
+            all_token_counts,
+            selected_model,
+            fake_input=old_inputs,
+            display_append=link_references
+        )
+        yield chatbot, history, status_text, all_token_counts
+
+    logging.info(f"The current token count is{all_token_counts}")
+

presets.py

@@ -0,0 +1,46 @@
+# -*- coding:utf-8 -*-
+use_websearch_checkbox=False
+use_streaming_checkbox=True
+model_select_dropdown="gpt-3.5-turbo"
+# top_p=1
+dockerflag = True
+authflag = False
+
+# ChatGPT 设置
+initial_prompt = "You are a helpful assistant."
+API_URL = "https://api.openai.com/v1/chat/completions"
+HISTORY_DIR = "history"
+TEMPLATES_DIR = "templates"
+
+# 错误信息
+standard_error_msg = "Error："  # 错误信息的标准前缀
+error_retrieve_prompt = "Please check the network connection and the API-Key"  # 获取对话时发生错误
+connection_timeout_prompt = "Time out"  # 连接超时
+read_timeout_prompt = "Time out"  # 读取超时
+proxy_error_prompt = "Proxy error"  # 代理错误
+ssl_error_prompt = "SSL error"  # SSL 错误
+no_apikey_msg = "please check whether the input is correct"  # API key 长度不足 51 位
+
+max_token_streaming = 3500  # 流式对话时的最大 token 数
+timeout_streaming = 5  # 流式对话时的超时时间
+max_token_all = 3500  # 非流式对话时的最大 token 数
+timeout_all = 200  # 非流式对话时的超时时间
+enable_streaming_option = True  # 是否启用选择选择是否实时显示回答的勾选框
+HIDE_MY_KEY = True  # 如果你想在UI中隐藏你的 API 密钥，将此值设置为 True
+
+SIM_K = 5
+INDEX_QUERY_TEMPRATURE = 1.0
+title= """\
+# <p align="center">Sydney-AI 2.0<b>"""
+
+description = """\
+<p>
+<p>
+
+本应用是一款基于最新OpenAI API“gpt-3.5-turbo”开发的智能在线聊天应用。 该应用程序的运营成本由“45 Degrees Research Fellows”赞助。 目前，token 限制为 3500。如果你想取消这个限制，你可以输入你自己的 OpenAI API 密钥。 <p>
+App默认角色为ChatGPT原版助手，但您也可以从模板提供的角色中进行选择。 如果您对自定义Prompt有好的建议，请联系我们！<p>
+This app is an intelligent online chat app developed based on the newly released OpenAI API "gpt-3.5-turbo". The app's operating costs are sponsored by "45度科研人". Currently, the tokens is limited to 3500. If you want to remove this restriction, you can input your own OpenAI API key.<p>
+The default model role of the app is the original assistant of ChatGPT, but you can also choose from the provided roles. If you have good suggestions for customizing Prompt, please contact us!<p>
+"""
+        
+MODELS = ["gpt-3.5-turbo", "gpt-3.5-turbo-0301",]  

requirements.txt

@@ -0,0 +1,7 @@
+gradio==3.19.1
+mdtex2html
+pypinyin
+tiktoken
+tqdm
+Pygments
+markdown

utils.py

@@ -0,0 +1,301 @@
+# -*- coding:utf-8 -*-
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Tuple, Type
+import logging
+import json
+import os
+
+import csv
+import requests
+import re
+
+import gradio as gr
+from pypinyin import lazy_pinyin
+import tiktoken
+import mdtex2html
+from markdown import markdown
+from pygments import highlight
+from pygments.lexers import get_lexer_by_name
+from pygments.formatters import HtmlFormatter
+
+from presets import *
+
+# logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] [%(filename)s:%(lineno)d] %(message)s")
+
+if TYPE_CHECKING:
+    from typing import TypedDict
+
+    class DataframeData(TypedDict):
+        headers: List[str]
+        data: List[List[str | int | bool]]
+
+
+def count_token(message):
+    encoding = tiktoken.get_encoding("cl100k_base")
+    input_str = f"role: {message['role']}, content: {message['content']}"
+    length = len(encoding.encode(input_str))
+    return length
+
+
+def markdown_to_html_with_syntax_highlight(md_str):
+    def replacer(match):
+        lang = match.group(1) or "text"
+        code = match.group(2)
+
+        try:
+            lexer = get_lexer_by_name(lang, stripall=True)
+        except ValueError:
+            lexer = get_lexer_by_name("text", stripall=True)
+
+        formatter = HtmlFormatter()
+        highlighted_code = highlight(code, lexer, formatter)
+
+        return f'<pre><code class="{lang}">{highlighted_code}</code></pre>'
+
+    code_block_pattern = r"```(\w+)?\n([\s\S]+?)\n```"
+    md_str = re.sub(code_block_pattern, replacer, md_str, flags=re.MULTILINE)
+
+    html_str = markdown(md_str)
+    return html_str
+
+
+def normalize_markdown(md_text: str) -> str:
+    lines = md_text.split("\n")
+    normalized_lines = []
+    inside_list = False
+
+    for i, line in enumerate(lines):
+        if re.match(r"^(\d+\.|-|\*|\+)\s", line.strip()):
+            if not inside_list and i > 0 and lines[i - 1].strip() != "":
+                normalized_lines.append("")
+            inside_list = True
+            normalized_lines.append(line)
+        elif inside_list and line.strip() == "":
+            if i < len(lines) - 1 and not re.match(
+                r"^(\d+\.|-|\*|\+)\s", lines[i + 1].strip()
+            ):
+                normalized_lines.append(line)
+            continue
+        else:
+            inside_list = False
+            normalized_lines.append(line)
+
+    return "\n".join(normalized_lines)
+
+def postprocess(
+    self, y: List[Tuple[str | None, str | None]]
+) -> List[Tuple[str | None, str | None]]:
+    """
+    Parameters:
+        y: List of tuples representing the message and response pairs. Each message and response should be a string, which may be in Markdown format.
+    Returns:
+        List of tuples representing the message and response. Each message and response will be a string of HTML.
+    """
+    if y is None or y == []:
+        return []
+    tag_regex = re.compile(r"^<\w+>[^<]+</\w+>")
+    if tag_regex.search(y[-1][1]):
+        y[-1] = (convert_user(y[-1][0]), y[-1][1])
+    else:
+        y[-1] = (convert_user(y[-1][0]), convert_mdtext(y[-1][1]))
+    return y
+
+def convert_mdtext(md_text):
+    code_block_pattern = re.compile(r"```(.*?)(?:```|$)", re.DOTALL)
+    inline_code_pattern = re.compile(r"`(.*?)`", re.DOTALL)
+    code_blocks = code_block_pattern.findall(md_text)
+    non_code_parts = code_block_pattern.split(md_text)[::2]
+
+    result = []
+    for non_code, code in zip(non_code_parts, code_blocks + [""]):
+        if non_code.strip():
+            non_code = normalize_markdown(non_code)
+            if inline_code_pattern.search(non_code):
+                result.append(markdown(non_code, extensions=["tables"]))
+            else:
+                result.append(mdtex2html.convert(non_code, extensions=["tables"]))
+        if code.strip():
+            # _, code = detect_language(code)  # 暂时去除代码高亮功能，因为在大段代码的情况下会出现问题
+            # code = code.replace("\n\n", "\n") # 暂时去除代码中的空行，因为在大段代码的情况下会出现问题
+            code = f"```{code}\n\n```"
+            code = markdown_to_html_with_syntax_highlight(code)
+            result.append(code)
+    result = "".join(result)
+    return result
+
+def convert_user(userinput):
+    userinput = userinput.replace("\n", "<br>")
+    return f"<pre>{userinput}</pre>"
+
+def construct_text(role, text):
+    return {"role": role, "content": text}
+
+
+def construct_user(text):
+    return construct_text("user", text)
+
+
+def construct_system(text):
+    return construct_text("system", text)
+
+
+def construct_assistant(text):
+    return construct_text("assistant", text)
+
+
+def construct_token_message(token, stream=False):
+    return f"Token count: {token}"
+
+
+def save_file(filename, system, history, chatbot):
+    logging.info("saving......")
+    os.makedirs(HISTORY_DIR, exist_ok=True)
+    if filename.endswith(".json"):
+        json_s = {"system": system, "history": history, "chatbot": chatbot}
+        print(json_s)
+        with open(os.path.join(HISTORY_DIR, filename), "w") as f:
+            json.dump(json_s, f)
+    elif filename.endswith(".md"):
+        md_s = f"system: \n- {system} \n"
+        for data in history:
+            md_s += f"\n{data['role']}: \n- {data['content']} \n"
+        with open(os.path.join(HISTORY_DIR, filename), "w", encoding="utf8") as f:
+            f.write(md_s)
+    # logging.info("保存对话历史完毕")
+    return os.path.join(HISTORY_DIR, filename)
+
+
+def save_chat_history(filename, system, history, chatbot):
+    if filename == "":
+        return
+    if not filename.endswith(".json"):
+        filename += ".json"
+    return save_file(filename, system, history, chatbot)
+
+
+def export_markdown(filename, system, history, chatbot):
+    if filename == "":
+        return
+    if not filename.endswith(".md"):
+        filename += ".md"
+    return save_file(filename, system, history, chatbot)
+
+
+def load_chat_history(filename, system, history, chatbot):
+    # logging.info("加载对话历史中……")
+    if type(filename) != str:
+        filename = filename.name
+    try:
+        with open(os.path.join(HISTORY_DIR, filename), "r") as f:
+            json_s = json.load(f)
+        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:
+        # 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"]):
+    # logging.info(f"获取文件名列表，目录为{dir}，文件类型为{filetypes}，是否为纯文本列表{plain}")
+    files = []
+    try:
+        for type in filetypes:
+            files += [f for f in os.listdir(dir) if f.endswith(type)]
+    except FileNotFoundError:
+        files = []
+    files = sorted_by_pinyin(files)
+    if files == []:
+        files = [""]
+    if plain:
+        return files
+    else:
+        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 = []
+    logging.info("Loading template...")
+    # filename='中文Prompts.json'
+    if filename.endswith(".json"):
+        with open(os.path.join(TEMPLATES_DIR, filename), "r", encoding="utf8") as f:
+            lines = json.load(f)
+        lines = [[i["act"], i["prompt"]] for i in lines]
+    else:
+        with open(
+            os.path.join(TEMPLATES_DIR, filename), "r", encoding="utf8") as csvfile:
+            reader = csv.reader(csvfile)
+            lines = list(reader)
+        lines = lines[1:]
+    if mode == 1:
+        return sorted_by_pinyin([row[0] for row in lines])
+    elif mode == 2:
+        return {row[0]: row[1] for row in lines}
+    else:
+        choices = sorted_by_pinyin([row[0] for row in lines])
+        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"Prompt:  {selection}")
+    try:
+        return templates[selection]
+    except:
+        return original_system_prompt
+
+
+def reset_state():
+    logging.info("Reset")
+    return [], [], [], construct_token_message(0)
+
+
+def reset_textbox():
+    return gr.update(value="")
+
+
+def hide_middle_chars(s):
+    if len(s) <= 8:
+        return s
+    else:
+        head = s[:4]
+        tail = s[-4:]
+        hidden = "*" * (len(s) - 8)
+        return head + hidden + tail
+
+def submit_key(key):
+    key = key.strip()
+    msg = f"API-Key: {hide_middle_chars(key)}"
+    logging.info(msg)
+    return key, msg
+
+
+