3.43

统一azure-gpt-3.5的格式
Merge branch 'master' of https://github.com/binary-husky/chatgpt_academic into master
2025-12-06 06:26:47 +00:00 · 2023-07-07 10:47:30 +08:00 · 2023-07-07 10:45:11 +08:00 · 2023-07-07 10:42:41 +08:00 · 2023-07-07 10:42:38 +08:00 · 2023-07-06 10:47:06 +08:00
--- a/22
+++ b/22
@@ -1,28 +1,34 @@
-# 此Dockerfile适用于“无本地模型”的环境构建，如果需要使用chatglm等本地模型，请参考 docs/Dockerfile+ChatGLM
-# 如何构建: 先修改 `config.py`， 然后 docker build -t gpt-academic .
-# 如何运行: docker run --rm -it --net=host gpt-academic
+# 此Dockerfile适用于“无本地模型”的环境构建，如果需要使用chatglm等本地模型或者latex运行依赖，请参考 docker-compose.yml
+# 如何构建: 先修改 `config.py`， 然后 `docker build -t gpt-academic . `
+# 如何运行(Linux下): `docker run --rm -it --net=host gpt-academic `
+# 如何运行(其他操作系统，选择任意一个固定端口50923): `docker run --rm -it -e WEB_PORT=50923 -p 50923:50923 gpt-academic `
 FROM python:3.11

+
+# 非必要步骤，更换pip源
 RUN echo '[global]' > /etc/pip.conf && \
    echo 'index-url = https://mirrors.aliyun.com/pypi/simple/' >> /etc/pip.conf && \
    echo 'trusted-host = mirrors.aliyun.com' >> /etc/pip.conf


+# 进入工作路径
 WORKDIR /gpt


-
-
-# 安装依赖
+# 安装大部分依赖，利用Docker缓存加速以后的构建
 COPY requirements.txt ./
 COPY ./docs/gradio-3.32.2-py3-none-any.whl ./docs/gradio-3.32.2-py3-none-any.whl
 RUN pip3 install -r requirements.txt
-# 装载项目文件
+
+
+# 装载项目文件，安装剩余依赖
 COPY . .
 RUN pip3 install -r requirements.txt

-# 可选步骤，用于预热模块
+
+# 非必要步骤，用于预热模块
 RUN python3  -c 'from check_proxy import warm_up_modules; warm_up_modules()'

+
 # 启动
 CMD ["python3", "-u", "main.py"]
--- a/README.md
+++ b/README.md
@@ -1,24 +1,24 @@
 > **Note**
 >
-> 2023.5.27 对Gradio依赖进行了调整，Fork并解决了官方Gradio的若干Bugs。请及时**更新代码**并重新更新pip依赖。安装依赖时，请严格选择`requirements.txt`中**指定的版本**： 
-> 
-> `pip install -r requirements.txt`
+> 2023.7.5: 对Gradio依赖进行了调整。请及时**更新代码**。安装依赖时，请严格选择`requirements.txt`中**指定的版本**：
 >
+> `pip install -r requirements.txt`

-# <img src="docs/logo.png" width="40" > GPT 学术优化 (GPT Academic)

-**如果喜欢这个项目，请给它一个Star；如果你发明了更好用的快捷键或函数插件，欢迎发pull requests**
+# <div align=center><img src="docs/logo.png" width="40" > GPT 学术优化 (GPT Academic)</div>
+
+**如果喜欢这个项目，请给它一个Star；如果您发明了好用的快捷键或函数插件，欢迎发pull requests！**

 If you like this project, please give it a Star. If you've come up with more useful academic shortcuts or functional plugins, feel free to open an issue or pull request. We also have a README in [English|](docs/README_EN.md)[日本語|](docs/README_JP.md)[한국어|](https://github.com/mldljyh/ko_gpt_academic)[Русский|](docs/README_RS.md)[Français](docs/README_FR.md) translated by this project itself.
 To translate this project to arbitary language with GPT, read and run [`multi_language.py`](multi_language.py) (experimental).

 > **Note**
 >
-> 1.请注意只有**红颜色**标识的函数插件（按钮）才支持读取文件，部分插件位于插件区的**下拉菜单**中。另外我们以**最高优先级**欢迎和处理任何新插件的PR！
+> 1.请注意只有 **高亮(如红色)** 标识的函数插件（按钮）才支持读取文件，部分插件位于插件区的**下拉菜单**中。另外我们以**最高优先级**欢迎和处理任何新插件的PR。
 >
 > 2.本项目中每个文件的功能都在自译解[`self_analysis.md`](https://github.com/binary-husky/gpt_academic/wiki/chatgpt-academic%E9%A1%B9%E7%9B%AE%E8%87%AA%E8%AF%91%E8%A7%A3%E6%8A%A5%E5%91%8A)详细说明。随着版本的迭代，您也可以随时自行点击相关函数插件，调用GPT重新生成项目的自我解析报告。常见问题汇总在[`wiki`](https://github.com/binary-husky/gpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98)当中。[安装方法](#installation)。
 > 
-> 3.本项目兼容并鼓励尝试国产大语言模型chatglm和RWKV, 盘古等等。支持多个api-key共存，可在配置文件中填写如`API_KEY="openai-key1,openai-key2,api2d-key3"`。需要临时更换`API_KEY`时，在输入区输入临时的`API_KEY`然后回车键提交后即可生效。
+> 3.本项目兼容并鼓励尝试国产大语言模型ChatGLM和Moss等等。支持多个api-key共存，可在配置文件中填写如`API_KEY="openai-key1,openai-key2,api2d-key3"`。需要临时更换`API_KEY`时，在输入区输入临时的`API_KEY`然后回车键提交后即可生效。


 
@@ -42,13 +42,13 @@ chat分析报告生成 | [函数插件] 运行后自动生成总结汇报
 [PDF论文全文翻译功能](https://www.bilibili.com/video/BV1KT411x7Wn) | [函数插件] PDF论文提取题目&摘要+翻译全文（多线程）
 [Arxiv小助手](https://www.bilibili.com/video/BV1LM4y1279X) | [函数插件] 输入arxiv文章url即可一键翻译摘要+下载PDF
 [谷歌学术统合小助手](https://www.bilibili.com/video/BV19L411U7ia) | [函数插件] 给定任意谷歌学术搜索页面URL，让gpt帮你[写relatedworks](https://www.bilibili.com/video/BV1GP411U7Az/)
-互联网信息聚合+GPT | [函数插件] 一键[让GPT先从互联网获取信息](https://www.bilibili.com/video/BV1om4y127ck)，再回答问题，让信息永不过时
-⭐Arxiv论文精细翻译 | [函数插件] 一键[以超高质量翻译arxiv论文](https://www.bilibili.com/video/BV1dz4y1v77A/)，迄今为止最好的论文翻译工具⭐
+互联网信息聚合+GPT | [函数插件] 一键[让GPT从互联网获取信息](https://www.bilibili.com/video/BV1om4y127ck)回答问题，让信息永不过时
+⭐Arxiv论文精细翻译 | [函数插件] 一键[以超高质量翻译arxiv论文](https://www.bilibili.com/video/BV1dz4y1v77A/)，目前最好的论文翻译工具
 公式/图片/表格显示 | 可以同时显示公式的[tex形式和渲染形式](https://user-images.githubusercontent.com/96192199/230598842-1d7fcddd-815d-40ee-af60-baf488a199df.png)，支持公式、代码高亮
 多线程函数插件支持 | 支持多线调用chatgpt，一键处理[海量文本](https://www.bilibili.com/video/BV1FT411H7c5/)或程序
-启动暗色gradio[主题](https://github.com/binary-husky/gpt_academic/issues/173) | 在浏览器url后面添加```/?__theme=dark```可以切换dark主题
+启动暗色[主题](https://github.com/binary-husky/gpt_academic/issues/173) | 在浏览器url后面添加```/?__theme=dark```可以切换dark主题
 [多LLM模型](https://www.bilibili.com/video/BV1wT411p7yf)支持 | 同时被GPT3.5、GPT4、[清华ChatGLM](https://github.com/THUDM/ChatGLM-6B)、[复旦MOSS](https://github.com/OpenLMLab/MOSS)同时伺候的感觉一定会很不错吧？
-更多LLM模型接入，支持[huggingface部署](https://huggingface.co/spaces/qingxu98/gpt-academic) | 加入Newbing接口(新必应)，引入清华[Jittorllms](https://github.com/Jittor/JittorLLMs)支持[LLaMA](https://github.com/facebookresearch/llama)，[RWKV](https://github.com/BlinkDL/ChatRWKV)和[盘古α](https://openi.org.cn/pangu/)
+更多LLM模型接入，支持[huggingface部署](https://huggingface.co/spaces/qingxu98/gpt-academic) | 加入Newbing接口(新必应)，引入清华[Jittorllms](https://github.com/Jittor/JittorLLMs)支持[LLaMA](https://github.com/facebookresearch/llama)和[盘古α](https://openi.org.cn/pangu/)
 更多新功能展示(图像生成等) …… | 见本文档结尾处 ……

 </div>
@@ -85,9 +85,8 @@ chat分析报告生成 | [函数插件] 运行后自动生成总结汇报
 <img src="https://user-images.githubusercontent.com/96192199/232537274-deca0563-7aa6-4b5d-94a2-b7c453c47794.png" width="700" >
 </div>

---
 # Installation
-## 安装-方法1：直接运行 (Windows, Linux or MacOS) 
+### 安装方法I：直接运行 (Windows, Linux or MacOS) 

 1. 下载项目
 ```sh
@@ -140,7 +139,7 @@ AVAIL_LLM_MODELS = ["gpt-3.5-turbo", "api2d-gpt-3.5-turbo", "gpt-4", "api2d-gpt-
 python main.py
 ```

-## 安装-方法2：使用Docker
+### 安装方法II：使用Docker

 1. 仅ChatGPT（推荐大多数人选择，等价于docker-compose方案1）

@@ -171,7 +170,7 @@ docker-compose up
 ```


-## 安装-方法3：其他部署姿势
+### 安装方法III：其他部署姿势
 1. 一键运行脚本。
 完全不熟悉python环境的Windows用户可以下载[Release](https://github.com/binary-husky/gpt_academic/releases)中发布的一键运行脚本安装无本地模型的版本。
 脚本的贡献来源是[oobabooga](https://github.com/oobabooga/one-click-installers)。
@@ -194,11 +193,9 @@ docker-compose up
 7. 如何在二级网址（如`http://localhost/subpath`）下运行。
 请访问[FastAPI运行说明](docs/WithFastapi.md)

---
-# Advanced Usage
-## 自定义新的便捷按钮 / 自定义函数插件

-1. 自定义新的便捷按钮（学术快捷键）
+# Advanced Usage
+### I：自定义新的便捷按钮（学术快捷键）
 任意文本编辑器打开`core_functional.py`，添加条目如下，然后重启程序即可。（如果按钮已经添加成功并可见，那么前缀、后缀都支持热修改，无需重启程序即可生效。）
 例如
 ```
@@ -214,15 +211,15 @@ docker-compose up
 <img src="https://user-images.githubusercontent.com/96192199/226899272-477c2134-ed71-4326-810c-29891fe4a508.png" width="500" >
 </div>

-2. 自定义函数插件
+### II：自定义函数插件

 编写强大的函数插件来执行任何你想得到的和想不到的任务。
 本项目的插件编写、调试难度很低，只要您具备一定的python基础知识，就可以仿照我们提供的模板实现自己的插件功能。
 详情请参考[函数插件指南](https://github.com/binary-husky/gpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97)。

---
+
 # Latest Update
-## 新功能动态
+### I：新功能动态

 1. 对话保存功能。在函数插件区调用 `保存当前的对话` 即可将当前对话保存为可读+可复原的html文件，
 另外在函数插件区（下拉菜单）调用 `载入对话历史存档` ，即可还原之前的会话。
@@ -283,7 +280,7 @@ Tip：不指定文件直接点击 `载入对话历史存档` 可以查看历史h



-## 版本:
+### II：版本:
 - version 3.5(Todo): 使用自然语言调用本项目的所有函数插件（高优先级）
 - version 3.4: +arxiv论文翻译、latex论文批改功能
 - version 3.3: +互联网信息综合功能
@@ -305,7 +302,7 @@ gpt_academic开发者QQ群-2：610599535
    - 某些浏览器翻译插件干扰此软件前端的运行
    - 官方Gradio目前有很多兼容性Bug，请务必使用`requirement.txt`安装Gradio

-## 参考与学习
+### III：参考与学习

 ```
 代码中参考了很多其他优秀项目中的设计，顺序不分先后：
--- a/check_proxy.py
+++ b/check_proxy.py
@@ -12,6 +12,8 @@ def check_proxy(proxies):
            result = f"代理配置 {proxies_https}, 代理所在地：{country}"
        elif 'error' in data:
            result = f"代理配置 {proxies_https}, 代理所在地：未知，IP查询频率受限"
+        else:
+            result = f"代理配置 {proxies_https}, 代理数据解析失败：{data}"
        print(result)
        return result
    except:
--- a/config.py
+++ b/config.py
@@ -1,17 +1,27 @@
-# [step 1]>> 例如： API_KEY = "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" （此key无效）
+"""
+    以下所有配置也都支持利用环境变量覆写，环境变量配置格式见docker-compose.yml。
+    读取优先级：环境变量 > config_private.py > config.py
+    --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
+    All the following configurations also support using environment variables to override, 
+    and the environment variable configuration format can be seen in docker-compose.yml. 
+    Configuration reading priority: environment variable > config_private.py > config.py
+"""
+
+# [step 1]>> API_KEY = "sk-123456789xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx123456789"。极少数情况下，还需要填写组织（格式如org-123456789abcdefghijklmno的），请向下翻，找 API_ORG 设置项
 API_KEY = "sk-此处填API密钥"    # 可同时填写多个API-KEY，用英文逗号分割，例如API_KEY = "sk-openaikey1,sk-openaikey2,fkxxxx-api2dkey1,fkxxxx-api2dkey2"


 # [step 2]>> 改为True应用代理，如果直接在海外服务器部署，此处不修改
 USE_PROXY = False
 if USE_PROXY:
-    # 填写格式是 [协议]://  [地址] :[端口]，填写之前不要忘记把USE_PROXY改成True，如果直接在海外服务器部署，此处不修改
-    # 例如    "socks5h://localhost:11284"
-    # [协议] 常见协议无非socks5h/http; 例如 v2**y 和 ss* 的默认本地协议是socks5h; 而cl**h 的默认本地协议是http
-    # [地址] 懂的都懂，不懂就填localhost或者127.0.0.1肯定错不了（localhost意思是代理软件安装在本机上）
-    # [端口] 在代理软件的设置里找。虽然不同的代理软件界面不一样，但端口号都应该在最显眼的位置上
-
-    # 代理网络的地址，打开你的*学*网软件查看代理的协议(socks5/http)、地址(localhost)和端口(11284)
+    """
+    填写格式是 [协议]://  [地址] :[端口]，填写之前不要忘记把USE_PROXY改成True，如果直接在海外服务器部署，此处不修改
+            <配置教程&视频教程> https://github.com/binary-husky/gpt_academic/issues/1>
+    [协议] 常见协议无非socks5h/http; 例如 v2**y 和 ss* 的默认本地协议是socks5h; 而cl**h 的默认本地协议是http
+    [地址] 懂的都懂，不懂就填localhost或者127.0.0.1肯定错不了（localhost意思是代理软件安装在本机上）
+    [端口] 在代理软件的设置里找。虽然不同的代理软件界面不一样，但端口号都应该在最显眼的位置上
+    """
+    # 代理网络的地址，打开你的*学*网软件查看代理的协议(socks5h / http)、地址(localhost)和端口(11284)
    proxies = {
        #          [协议]://  [地址]  :[端口]
        "http":  "socks5h://localhost:11284",  # 再例如  "http":  "http://127.0.0.1:7890",
@@ -20,64 +30,78 @@ if USE_PROXY:
 else:
    proxies = None

-# [step 3]>> 多线程函数插件中，默认允许多少路线程同时访问OpenAI。Free trial users的限制是每分钟3次，Pay-as-you-go users的限制是每分钟3500次
-# 一言以蔽之：免费用户填3，OpenAI绑了信用卡的用户可以填 16 或者更高。提高限制请查询：https://platform.openai.com/docs/guides/rate-limits/overview
+# ------------------------------------ 以下配置可以优化体验, 但大部分场合下并不需要修改 ------------------------------------
+
+# 重新URL重新定向，实现更换API_URL的作用（常规情况下，不要修改!! 高危设置！通过修改此设置，您将把您的API-KEY和对话隐私完全暴露给您设定的中间人！）
+# 格式 API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions": "在这里填写重定向的api.openai.com的URL"} 
+# 例如 API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions":"https://reverse-proxy-url/v1/chat/completions"}
+API_URL_REDIRECT = {}
+
+
+# 多线程函数插件中，默认允许多少路线程同时访问OpenAI。Free trial users的限制是每分钟3次，Pay-as-you-go users的限制是每分钟3500次
+# 一言以蔽之：免费（5刀）用户填3，OpenAI绑了信用卡的用户可以填 16 或者更高。提高限制请查询：https://platform.openai.com/docs/guides/rate-limits/overview
 DEFAULT_WORKER_NUM = 3


-# [step 4]>> 以下配置可以优化体验，但大部分场合下并不需要修改
 # 对话窗的高度
 CHATBOT_HEIGHT = 1115

+
 # 代码高亮
 CODE_HIGHLIGHT = True

+
 # 窗口布局
-LAYOUT = "LEFT-RIGHT"  # "LEFT-RIGHT"（左右布局） # "TOP-DOWN"（上下布局）
-DARK_MODE = True  # "LEFT-RIGHT"（左右布局） # "TOP-DOWN"（上下布局）
+LAYOUT = "LEFT-RIGHT"   # "LEFT-RIGHT"（左右布局） # "TOP-DOWN"（上下布局）
+DARK_MODE = True        # 暗色模式 / 亮色模式
+

 # 发送请求到OpenAI后，等待多久判定为超时
 TIMEOUT_SECONDS = 30

+
 # 网页的端口, -1代表随机端口
 WEB_PORT = -1

+
 # 如果OpenAI不响应（网络卡顿、代理失败、KEY失效），重试的次数限制
 MAX_RETRY = 2

-# 模型选择是 (注意: LLM_MODEL是默认选中的模型, 同时它必须被包含在AVAIL_LLM_MODELS切换列表中 )
+
+# 模型选择是 (注意: LLM_MODEL是默认选中的模型, 它*必须*被包含在AVAIL_LLM_MODELS列表中 )
 LLM_MODEL = "gpt-3.5-turbo" # 可选 ↓↓↓
-AVAIL_LLM_MODELS = ["gpt-3.5-turbo-16k", "gpt-3.5-turbo", "azure-gpt35", "api2d-gpt-3.5-turbo", "gpt-4", "api2d-gpt-4", "chatglm", "moss", "newbing", "newbing-free", "stack-claude"]
+AVAIL_LLM_MODELS = ["gpt-3.5-turbo-16k", "gpt-3.5-turbo", "azure-gpt-3.5", "api2d-gpt-3.5-turbo", "gpt-4", "api2d-gpt-4", "chatglm", "moss", "newbing", "stack-claude"]
 # P.S. 其他可用的模型还包括 ["gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k-0613", "newbing-free", "jittorllms_rwkv", "jittorllms_pangualpha", "jittorllms_llama"]

+
 # 本地LLM模型如ChatGLM的执行方式 CPU/GPU
 LOCAL_MODEL_DEVICE = "cpu" # 可选 "cuda"

+
 # 设置gradio的并行线程数（不需要修改）
 CONCURRENT_COUNT = 100

+
+# 是否在提交时自动清空输入框
+AUTO_CLEAR_TXT = False
+
+
 # 加一个live2d装饰
 ADD_WAIFU = False

+
 # 设置用户名和密码（不需要修改）（相关功能不稳定，与gradio版本和网络都相关，如果本地使用不建议加这个）
 # [("username", "password"), ("username2", "password2"), ...]
 AUTHENTICATION = []

-# 重新URL重新定向，实现更换API_URL的作用（常规情况下，不要修改!!）
-# （高危设置！通过修改此设置，您将把您的API-KEY和对话隐私完全暴露给您设定的中间人！）
-# 格式 {"https://api.openai.com/v1/chat/completions": "在这里填写重定向的api.openai.com的URL"} 
-# 例如 API_URL_REDIRECT = {"https://api.openai.com/v1/chat/completions": "https://ai.open.com/api/conversation"}
-API_URL_REDIRECT = {}

 # 如果需要在二级路径下运行（常规情况下，不要修改!!）（需要配合修改main.py才能生效!）
 CUSTOM_PATH = "/"

-# 如果需要使用newbing，把newbing的长长的cookie放到这里
-NEWBING_STYLE = "creative"  # ["creative", "balanced", "precise"]
-# 从现在起，如果您调用"newbing-free"模型，则无需填写NEWBING_COOKIES
-NEWBING_COOKIES = """
-your bing cookies here
-"""
+
+# 极少数情况下，openai的官方KEY需要伴随组织编码（格式如org-xxxxxxxxxxxxxxxxxxxxxxxx）使用
+API_ORG = ""
+

 # 如果需要使用Slack Claude，使用教程详情见 request_llm/README.md
 SLACK_CLAUDE_BOT_ID = ''   
@@ -85,7 +109,14 @@ SLACK_CLAUDE_USER_TOKEN = ''


 # 如果需要使用AZURE 详情请见额外文档 docs\use_azure.md
-AZURE_ENDPOINT = "https://你的api名称.openai.azure.com/"
+AZURE_ENDPOINT = "https://你亲手写的api名称.openai.azure.com/"
 AZURE_API_KEY = "填入azure openai api的密钥"
-AZURE_API_VERSION = "填入api版本"
-AZURE_ENGINE = "填入ENGINE"
+AZURE_API_VERSION = "2023-05-15"        # 一般不修改
+AZURE_ENGINE = "填入你亲手写的部署名"     # 读 docs\use_azure.md
+
+
+# 使用Newbing
+NEWBING_STYLE = "creative"  # ["creative", "balanced", "precise"]
+NEWBING_COOKIES = """
+put your new bing cookies here
+"""
--- a/core_functional.py
+++ b/core_functional.py
@@ -63,6 +63,7 @@ def get_core_functions():
            "Prefix":   r"我需要你找一张网络图片。使用Unsplash API(https://source.unsplash.com/960x640/?<英语关键词>)获取图片URL，" +
                        r"然后请使用Markdown格式封装，并且不要有反斜线，不要用代码块。现在，请按以下描述给我发送图片：" + "\n\n",
            "Suffix":   r"",
+            "Visible": False,
        },
        "解释代码": {
            "Prefix":   r"请解释以下代码：" + "\n```\n",
@@ -73,6 +74,5 @@ def get_core_functions():
                        r"Note that, reference styles maybe more than one kind, you should transform each item correctly." +
                        r"Items need to be transformed:",
            "Suffix":   r"",
-            "Visible": False,
        }
    }
--- a/crazy_functional.py
+++ b/crazy_functional.py
@@ -226,12 +226,20 @@ def get_crazy_functions():
    try:
        from crazy_functions.联网的ChatGPT import 连接网络回答问题
        function_plugins.update({
-            "连接网络回答问题（先输入问题，再点击按钮，需要访问谷歌）": {
+            "连接网络回答问题（输入问题后点击该插件，需要访问谷歌）": {
                "Color": "stop",
                "AsButton": False,  # 加入下拉菜单中
                "Function": HotReload(连接网络回答问题)
            }
        })
+        from crazy_functions.联网的ChatGPT_bing版 import 连接bing搜索回答问题
+        function_plugins.update({
+            "连接网络回答问题（中文Bing版，输入问题后点击该插件）": {
+                "Color": "stop",
+                "AsButton": False,  # 加入下拉菜单中
+                "Function": HotReload(连接bing搜索回答问题)
+            }
+        })
    except:
        print('Load function plugin failed')

@@ -348,17 +356,28 @@ def get_crazy_functions():
    try:
        from crazy_functions.Latex输出PDF结果 import Latex英文纠错加PDF对比
        function_plugins.update({
-            "[功能尚不稳定] Latex英文纠错+LatexDiff高亮修正位置": {
+            "Latex英文纠错+高亮修正位置 [需Latex]": {
                "Color": "stop",
                "AsButton": False,
-                # "AdvancedArgs": True,
-                # "ArgsReminder": "",
+                "AdvancedArgs": True,
+                "ArgsReminder": "如果有必要, 请在此处追加更细致的矫错指令（使用英文）。",
                "Function": HotReload(Latex英文纠错加PDF对比)
            }
        })
        from crazy_functions.Latex输出PDF结果 import Latex翻译中文并重新编译PDF
        function_plugins.update({
-            "Arixv翻译（输入arxivID） [需Latex]": {
+            "Arixv翻译（输入arxivID）[需Latex]": {
+                "Color": "stop",
+                "AsButton": False,
+                "AdvancedArgs": True,
+                "ArgsReminder": 
+                    "如果有必要, 请在此处给出自定义翻译命令, 解决部分词汇翻译不准确的问题。 "+ 
+                    "例如当单词'agent'翻译不准确时, 请尝试把以下指令复制到高级参数区: " + 'If the term "agent" is used in this section, it should be translated to "智能体". ',
+                "Function": HotReload(Latex翻译中文并重新编译PDF)
+            }
+        })
+        function_plugins.update({
+            "本地论文翻译（上传Latex压缩包）[需Latex]": {
                "Color": "stop",
                "AsButton": False,
                "AdvancedArgs": True,
@@ -368,17 +387,6 @@ def get_crazy_functions():
                "Function": HotReload(Latex翻译中文并重新编译PDF)
            }
        })
-        # function_plugins.update({
-        #     "本地论文翻译（上传Latex压缩包） [需Latex]": {
-        #         "Color": "stop",
-        #         "AsButton": False,
-        #         "AdvancedArgs": True,
-        #         "ArgsReminder": 
-        #             "如果有必要, 请在此处给出自定义翻译命令, 解决部分词汇翻译不准确的问题。 "+ 
-        #             "例如当单词'agent'翻译不准确时, 请尝试把以下指令复制到高级参数区: " + 'If the term "agent" is used in this section, it should be translated to "智能体". ',
-        #         "Function": HotReload(Latex翻译中文并重新编译PDF)
-        #     }
-        # })
    except:
        print('Load function plugin failed')

--- a/crazy_functions/Latex输出PDF结果.py
+++ b/crazy_functions/Latex输出PDF结果.py
@@ -19,9 +19,9 @@ def switch_prompt(pfg, mode, more_requirement):
    - sys_prompt_array: A list of strings containing prompts for system prompts.
    """
    n_split = len(pfg.sp_file_contents)
-    if mode == 'proofread':
+    if mode == 'proofread_en':
        inputs_array = [r"Below is a section from an academic paper, proofread this section." + 
-                        r"Do not modify any latex command such as \section, \cite, \begin, \item and equations. " + 
+                        r"Do not modify any latex command such as \section, \cite, \begin, \item and equations. " + more_requirement +
                        r"Answer me only with the revised text:" + 
                        f"\n\n{frag}" for frag in pfg.sp_file_contents]
        sys_prompt_array = ["You are a professional academic paper writer." for _ in range(n_split)]
@@ -70,6 +70,12 @@ def move_project(project_folder, arxiv_id=None):
        shutil.rmtree(new_workfolder)
    except:
        pass
+
+    # align subfolder if there is a folder wrapper
+    items = glob.glob(pj(project_folder,'*'))
+    if len(glob.glob(pj(project_folder,'*.tex'))) == 0 and len(items) == 1:
+        if os.path.isdir(items[0]): project_folder = items[0]
+
    shutil.copytree(src=project_folder, dst=new_workfolder)
    return new_workfolder

@@ -141,7 +147,11 @@ def Latex英文纠错加PDF对比(txt, llm_kwargs, plugin_kwargs, chatbot, histo
    chatbot.append([ "函数插件功能？",
        "对整个Latex项目进行纠错, 用latex编译为PDF对修正处做高亮。函数插件贡献者: Binary-Husky。注意事项: 目前仅支持GPT3.5/GPT4，其他模型转化效果未知。目前对机器学习类文献转化效果最好，其他类型文献转化效果未知。仅在Windows系统进行了测试，其他操作系统表现未知。"])
    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
+    
+    # <-------------- more requirements ------------->
+    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
+    more_req = plugin_kwargs.get("advanced_arg", "")
+    _switch_prompt_ = partial(switch_prompt, more_requirement=more_req)

    # <-------------- check deps ------------->
    try:
@@ -180,13 +190,13 @@ def Latex英文纠错加PDF对比(txt, llm_kwargs, plugin_kwargs, chatbot, histo


    # <-------------- if merge_translate_zh is already generated, skip gpt req ------------->
-    if not os.path.exists(project_folder + '/merge_proofread.tex'):
+    if not os.path.exists(project_folder + '/merge_proofread_en.tex'):
        yield from Latex精细分解与转化(file_manifest, project_folder, llm_kwargs, plugin_kwargs, 
-                                chatbot, history, system_prompt, mode='proofread_latex', switch_prompt=switch_prompt)
+                                chatbot, history, system_prompt, mode='proofread_en', switch_prompt=_switch_prompt_)


    # <-------------- compile PDF ------------->
-    success = yield from 编译Latex(chatbot, history, main_file_original='merge', main_file_modified='merge_proofread', 
+    success = yield from 编译Latex(chatbot, history, main_file_original='merge', main_file_modified='merge_proofread_en', 
                             work_folder_original=project_folder, work_folder_modified=project_folder, work_folder=project_folder)
    

@@ -195,6 +205,7 @@ def Latex英文纠错加PDF对比(txt, llm_kwargs, plugin_kwargs, chatbot, histo
    if success:
        chatbot.append((f"成功啦", '请查收结果（压缩包）...'))
        yield from update_ui(chatbot=chatbot, history=history); time.sleep(1) # 刷新界面
+        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
    else:
        chatbot.append((f"失败了", '虽然PDF生成失败了, 但请查收结果（压缩包）, 内含已经翻译的Tex文档, 也是可读的, 您可以到Github Issue区, 用该压缩包+对话历史存档进行反馈 ...'))
        yield from update_ui(chatbot=chatbot, history=history); time.sleep(1) # 刷新界面
@@ -278,6 +289,7 @@ def Latex翻译中文并重新编译PDF(txt, llm_kwargs, plugin_kwargs, chatbot,
    if success:
        chatbot.append((f"成功啦", '请查收结果（压缩包）...'))
        yield from update_ui(chatbot=chatbot, history=history); time.sleep(1) # 刷新界面
+        promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
    else:
        chatbot.append((f"失败了", '虽然PDF生成失败了, 但请查收结果（压缩包）, 内含已经翻译的Tex文档, 也是可读的, 您可以到Github Issue区, 用该压缩包+对话历史存档进行反馈 ...'))
        yield from update_ui(chatbot=chatbot, history=history); time.sleep(1) # 刷新界面
--- a/crazy_functions/crazy_functions_test.py
+++ b/crazy_functions/crazy_functions_test.py
@@ -190,11 +190,12 @@ def test_Latex():
    # txt = r"C:\Users\x\arxiv_cache\2211.16068\workfolder"  #  ACE
    # txt = r"https://arxiv.org/abs/2002.09253"
    # txt = r"https://arxiv.org/abs/2306.07831"
-    txt = r"https://arxiv.org/abs/2212.10156"
+    # txt = r"https://arxiv.org/abs/2212.10156"
    # txt = r"https://arxiv.org/abs/2211.11559"
    # txt = r"https://arxiv.org/abs/2303.08774"
    # txt = r"https://arxiv.org/abs/2303.12712"
    # txt = r"C:\Users\fuqingxu\arxiv_cache\2303.12712\workfolder"
+    txt = r"2306.17157" # 这个paper有个input命令文件名大小写错误！
    

    for cookies, cb, hist, msg in (Latex翻译中文并重新编译PDF)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
--- a/crazy_functions/crazy_utils.py
+++ b/crazy_functions/crazy_utils.py
@@ -130,6 +130,11 @@ def request_gpt_model_in_new_thread_with_ui_alive(
    yield from update_ui(chatbot=chatbot, history=[]) # 如果最后成功了，则删除报错信息
    return final_result

+def can_multi_process(llm):
+    if llm.startswith('gpt-'): return True
+    if llm.startswith('api2d-'): return True
+    if llm.startswith('azure-'): return True
+    return False

 def request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
        inputs_array, inputs_show_user_array, llm_kwargs, 
@@ -175,7 +180,7 @@ def request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
        except: max_workers = 8
        if max_workers <= 0: max_workers = 3
    # 屏蔽掉 chatglm的多线程，可能会导致严重卡顿
-    if not (llm_kwargs['llm_model'].startswith('gpt-') or llm_kwargs['llm_model'].startswith('api2d-')):
+    if not can_multi_process(llm_kwargs['llm_model']):
        max_workers = 1
        
    executor = ThreadPoolExecutor(max_workers=max_workers)
--- a/crazy_functions/latex_utils.py
+++ b/crazy_functions/latex_utils.py
@@ -27,6 +27,24 @@ def set_forbidden_text(text, mask, pattern, flags=0):
        mask[res.span()[0]:res.span()[1]] = PRESERVE
    return text, mask

+def reverse_forbidden_text(text, mask, pattern, flags=0, forbid_wrapper=True):
+    """
+    Move area out of preserve area (make text editable for GPT)
+    count the number of the braces so as to catch compelete text area. 
+    e.g.
+    \begin{abstract} blablablablablabla. \end{abstract} 
+    """
+    if isinstance(pattern, list): pattern = '|'.join(pattern)
+    pattern_compile = re.compile(pattern, flags)
+    for res in pattern_compile.finditer(text):
+        if not forbid_wrapper:
+            mask[res.span()[0]:res.span()[1]] = TRANSFORM
+        else:
+            mask[res.regs[0][0]: res.regs[1][0]] = PRESERVE   # '\\begin{abstract}'
+            mask[res.regs[1][0]: res.regs[1][1]] = TRANSFORM   # abstract
+            mask[res.regs[1][1]: res.regs[0][1]] = PRESERVE   # abstract
+    return text, mask
+
 def set_forbidden_text_careful_brace(text, mask, pattern, flags=0):
    """
    Add a preserve text area in this paper (text become untouchable for GPT).
@@ -185,6 +203,7 @@ def merge_tex_files_(project_foler, main_file, mode):
                c = fx.read()
        else:  
            # e.g., \input{srcs/07_appendix}
+            assert os.path.exists(fp+'.tex'), f'即找不到{fp}，也找不到{fp}.tex，Tex源文件缺失！'
            with open(fp+'.tex', 'r', encoding='utf-8', errors='replace') as fx:
                c = fx.read()
        c = merge_tex_files_(project_foler, c, mode)
@@ -326,6 +345,7 @@ def split_subprocess(txt, project_folder, return_dict, opts):
    # reverse 操作必须放在最后
    text, mask = reverse_forbidden_text_careful_brace(text, mask, r"\\caption\{(.*?)\}", re.DOTALL, forbid_wrapper=True)
    text, mask = reverse_forbidden_text_careful_brace(text, mask, r"\\abstract\{(.*?)\}", re.DOTALL, forbid_wrapper=True)
+    text, mask = reverse_forbidden_text(text, mask, r"\\begin\{abstract\}(.*?)\\end\{abstract\}", re.DOTALL, forbid_wrapper=True)
    root = convert_to_linklist(text, mask)

    # 修复括号
@@ -430,7 +450,7 @@ class LatexPaperSplit():
    """
    def __init__(self) -> None:
        self.nodes = None
-        self.msg = "{\\scriptsize\\textbf{警告：该PDF由GPT-Academic开源项目调用大语言模型+Latex翻译插件一键生成，" + \
+        self.msg = "*{\\scriptsize\\textbf{警告：该PDF由GPT-Academic开源项目调用大语言模型+Latex翻译插件一键生成，" + \
            "版权归原文作者所有。翻译内容可靠性无保障，请仔细鉴别并以原文为准。" + \
            "项目Github地址 \\url{https://github.com/binary-husky/gpt_academic/}。"
        # 请您不要删除或修改这行警告，除非您是论文的原作者（如果您是论文原作者，欢迎加REAME中的QQ联系开发者）
@@ -532,11 +552,11 @@ class LatexPaperFileGroup():
                f.write(res)
        return manifest

-def write_html(sp_file_contents, sp_file_result, chatbot):
+def write_html(sp_file_contents, sp_file_result, chatbot, project_folder):

    # write html
    try:
-        import copy
+        import shutil
        from .crazy_utils import construct_html
        from toolbox import gen_time_str
        ch = construct_html() 
@@ -554,6 +574,7 @@ def write_html(sp_file_contents, sp_file_result, chatbot):
                ch.add_row(a=orig, b=trans)
        create_report_file_name = f"{gen_time_str()}.trans.html"
        ch.save_file(create_report_file_name)
+        shutil.copyfile(pj('./gpt_log/', create_report_file_name), pj(project_folder, create_report_file_name))
        promote_file_to_downloadzone(file=f'./gpt_log/{create_report_file_name}', chatbot=chatbot)
    except:
        from toolbox import trimmed_format_exc
@@ -634,7 +655,7 @@ def Latex精细分解与转化(file_manifest, project_folder, llm_kwargs, plugin
        pfg.get_token_num = None
        objdump(pfg, file=pj(project_folder,'temp.pkl'))

-    write_html(pfg.sp_file_contents, pfg.sp_file_result, chatbot=chatbot)
+    write_html(pfg.sp_file_contents, pfg.sp_file_result, chatbot=chatbot, project_folder=project_folder)

    #  <-------- 写出文件 ----------> 
    msg = f"当前大语言模型: {llm_kwargs['llm_model']}，当前语言模型温度设定: {llm_kwargs['temperature']}。"
@@ -671,10 +692,9 @@ def remove_buggy_lines(file_path, log_path, tex_name, tex_name_pure, n_fix, work
        print("Fatal error occurred, but we cannot identify error, please download zip, read latex log, and compile manually.")
        return False, -1, [-1]
    
-
-def compile_latex_with_timeout(command, timeout=60):
+def compile_latex_with_timeout(command, cwd, timeout=60):
    import subprocess
-    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd)
    try:
        stdout, stderr = process.communicate(timeout=timeout)
    except subprocess.TimeoutExpired:
@@ -698,24 +718,24 @@ def 编译Latex(chatbot, history, main_file_original, main_file_modified, work_f

        # https://stackoverflow.com/questions/738755/dont-make-me-manually-abort-a-latex-compile-when-theres-an-error
        yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 编译原始PDF ...', chatbot, history)   # 刷新Gradio前端界面
-        os.chdir(work_folder_original); ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_original}.tex'); os.chdir(current_dir)
+        ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_original}.tex', work_folder_original)

        yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 编译转化后的PDF ...', chatbot, history)   # 刷新Gradio前端界面
-        os.chdir(work_folder_modified); ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_modified}.tex'); os.chdir(current_dir)
+        ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_modified}.tex', work_folder_modified)
        
        if ok and os.path.exists(pj(work_folder_modified, f'{main_file_modified}.pdf')):
            # 只有第二步成功，才能继续下面的步骤
            yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 编译BibTex ...', chatbot, history)    # 刷新Gradio前端界面
            if not os.path.exists(pj(work_folder_original, f'{main_file_original}.bbl')):
-                os.chdir(work_folder_original); ok = compile_latex_with_timeout(f'bibtex  {main_file_original}.aux'); os.chdir(current_dir)
+                ok = compile_latex_with_timeout(f'bibtex  {main_file_original}.aux', work_folder_original)
            if not os.path.exists(pj(work_folder_modified, f'{main_file_modified}.bbl')):
-                os.chdir(work_folder_modified); ok = compile_latex_with_timeout(f'bibtex  {main_file_modified}.aux'); os.chdir(current_dir)
+                ok = compile_latex_with_timeout(f'bibtex  {main_file_modified}.aux', work_folder_modified)

            yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 编译文献交叉引用 ...', chatbot, history)  # 刷新Gradio前端界面
-            os.chdir(work_folder_original); ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_original}.tex'); os.chdir(current_dir)
-            os.chdir(work_folder_modified); ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_modified}.tex'); os.chdir(current_dir)
-            os.chdir(work_folder_original); ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_original}.tex'); os.chdir(current_dir)
-            os.chdir(work_folder_modified); ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_modified}.tex'); os.chdir(current_dir)
+            ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_original}.tex', work_folder_original)
+            ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_modified}.tex', work_folder_modified)
+            ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_original}.tex', work_folder_original)
+            ok = compile_latex_with_timeout(f'pdflatex -interaction=batchmode -file-line-error {main_file_modified}.tex', work_folder_modified)

            if mode!='translate_zh':
                yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 使用latexdiff生成论文转化前后对比 ...', chatbot, history) # 刷新Gradio前端界面
@@ -723,13 +743,11 @@ def 编译Latex(chatbot, history, main_file_original, main_file_modified, work_f
                ok = compile_latex_with_timeout(f'latexdiff --encoding=utf8 --append-safecmd=subfile {work_folder_original}/{main_file_original}.tex  {work_folder_modified}/{main_file_modified}.tex --flatten > {work_folder}/merge_diff.tex')

                yield from update_ui_lastest_msg(f'尝试第 {n_fix}/{max_try} 次编译, 正在编译对比PDF ...', chatbot, history)   # 刷新Gradio前端界面
-                os.chdir(work_folder); ok = compile_latex_with_timeout(f'pdflatex  -interaction=batchmode -file-line-error merge_diff.tex'); os.chdir(current_dir)
-                os.chdir(work_folder); ok = compile_latex_with_timeout(f'bibtex    merge_diff.aux'); os.chdir(current_dir)
-                os.chdir(work_folder); ok = compile_latex_with_timeout(f'pdflatex  -interaction=batchmode -file-line-error merge_diff.tex'); os.chdir(current_dir)
-                os.chdir(work_folder); ok = compile_latex_with_timeout(f'pdflatex  -interaction=batchmode -file-line-error merge_diff.tex'); os.chdir(current_dir)
+                ok = compile_latex_with_timeout(f'pdflatex  -interaction=batchmode -file-line-error merge_diff.tex', work_folder)
+                ok = compile_latex_with_timeout(f'bibtex    merge_diff.aux', work_folder)
+                ok = compile_latex_with_timeout(f'pdflatex  -interaction=batchmode -file-line-error merge_diff.tex', work_folder)
+                ok = compile_latex_with_timeout(f'pdflatex  -interaction=batchmode -file-line-error merge_diff.tex', work_folder)

-        # <--------------------->
-        os.chdir(current_dir)

        # <---------- 检查结果 ----------->
        results_ = ""
@@ -741,13 +759,15 @@ def 编译Latex(chatbot, history, main_file_original, main_file_modified, work_f
        results_ += f"对比PDF编译是否成功: {diff_pdf_success};" 
        yield from update_ui_lastest_msg(f'第{n_fix}编译结束:<br/>{results_}...', chatbot, history) # 刷新Gradio前端界面

+        if diff_pdf_success:
+            result_pdf = pj(work_folder_modified, f'merge_diff.pdf')    # get pdf path
+            promote_file_to_downloadzone(result_pdf, rename_file=None, chatbot=chatbot)  # promote file to web UI
        if modified_pdf_success:
            yield from update_ui_lastest_msg(f'转化PDF编译已经成功, 即将退出 ...', chatbot, history)    # 刷新Gradio前端界面
-            os.chdir(current_dir)
-            result_pdf = pj(work_folder_modified, f'{main_file_modified}.pdf')
+            result_pdf = pj(work_folder_modified, f'{main_file_modified}.pdf') # get pdf path
            if os.path.exists(pj(work_folder, '..', 'translation')):
                shutil.copyfile(result_pdf, pj(work_folder, '..', 'translation', 'translate_zh.pdf'))
-            promote_file_to_downloadzone(result_pdf, rename_file=None, chatbot=chatbot)
+            promote_file_to_downloadzone(result_pdf, rename_file=None, chatbot=chatbot)  # promote file to web UI
            return True # 成功啦
        else:
            if n_fix>=max_try: break
@@ -763,7 +783,6 @@ def 编译Latex(chatbot, history, main_file_original, main_file_modified, work_f
            yield from update_ui_lastest_msg(f'由于最为关键的转化PDF编译失败, 将根据报错信息修正tex源文件并重试, 当前报错的latex代码处于第{buggy_lines}行 ...', chatbot, history)   # 刷新Gradio前端界面
            if not can_retry: break

-    os.chdir(current_dir)
    return False # 失败啦


--- a/crazy_functions/图片生成.py
+++ b/crazy_functions/图片生成.py
@@ -27,8 +27,10 @@ def gen_image(llm_kwargs, prompt, resolution="256x256"):
    }
    response = requests.post(url, headers=headers, json=data, proxies=proxies)
    print(response.content)
-    image_url = json.loads(response.content.decode('utf8'))['data'][0]['url']
-
+    try:
+        image_url = json.loads(response.content.decode('utf8'))['data'][0]['url']
+    except:
+        raise RuntimeError(response.content.decode())
    # 文件保存到本地
    r = requests.get(image_url, proxies=proxies)
    file_path = 'gpt_log/image_gen/'
--- a/crazy_functions/批量总结PDF文档.py
+++ b/crazy_functions/批量总结PDF文档.py
@@ -71,7 +71,7 @@ def 解析PDF(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot,

        prefix = "接下来请你逐文件分析下面的论文文件，概括其内容" if index==0 else ""
        i_say = prefix + f'请对下面的文章片段用中文做一个概述，文件名是{os.path.relpath(fp, project_folder)}，文章内容是 ```{file_content}```'
-        i_say_show_user = prefix + f'[{index}/{len(file_manifest)}] 请对下面的文章片段做一个概述: {os.path.abspath(fp)}'
+        i_say_show_user = prefix + f'[{index + 1}/{len(file_manifest)}] 请对下面的文章片段做一个概述: {os.path.abspath(fp)}'
        chatbot.append((i_say_show_user, "[Local Message] waiting gpt response."))
        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

--- a/crazy_functions/批量翻译PDF文档_多线程.py
+++ b/crazy_functions/批量翻译PDF文档_多线程.py
@@ -1,5 +1,5 @@
 from toolbox import CatchException, report_execption, write_results_to_file
-from toolbox import update_ui
+from toolbox import update_ui, promote_file_to_downloadzone
 from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
 from .crazy_utils import request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency
 from .crazy_utils import read_and_clean_pdf_text
@@ -147,23 +147,14 @@ def 解析PDF(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot,
            print('writing html result failed:', trimmed_format_exc())

    # 准备文件的下载
-    import shutil
    for pdf_path in generated_conclusion_files:
        # 重命名文件
-        rename_file = f'./gpt_log/翻译-{os.path.basename(pdf_path)}'
-        if os.path.exists(rename_file):
-            os.remove(rename_file)
-        shutil.copyfile(pdf_path, rename_file)
-        if os.path.exists(pdf_path):
-            os.remove(pdf_path)
+        rename_file = f'翻译-{os.path.basename(pdf_path)}'
+        promote_file_to_downloadzone(pdf_path, rename_file=rename_file, chatbot=chatbot)
    for html_path in generated_html_files:
        # 重命名文件
-        rename_file = f'./gpt_log/翻译-{os.path.basename(html_path)}'
-        if os.path.exists(rename_file):
-            os.remove(rename_file)
-        shutil.copyfile(html_path, rename_file)
-        if os.path.exists(html_path):
-            os.remove(html_path)
+        rename_file = f'翻译-{os.path.basename(html_path)}'
+        promote_file_to_downloadzone(html_path, rename_file=rename_file, chatbot=chatbot)
    chatbot.append(("给出输出文件清单", str(generated_conclusion_files + generated_html_files)))
    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

--- a/crazy_functions/理解PDF文档内容.py
+++ b/crazy_functions/理解PDF文档内容.py
@@ -13,7 +13,9 @@ def 解析PDF(file_name, llm_kwargs, plugin_kwargs, chatbot, history, system_pro
    # 递归地切割PDF文件，每一块（尽量是完整的一个section，比如introduction，experiment等，必要时再进行切割）
    # 的长度必须小于 2500 个 Token
    file_content, page_one = read_and_clean_pdf_text(file_name) # （尝试）按照章节切割PDF
-
+    file_content = file_content.encode('utf-8', 'ignore').decode()   # avoid reading non-utf8 chars
+    page_one = str(page_one).encode('utf-8', 'ignore').decode()  # avoid reading non-utf8 chars
+    
    TOKEN_LIMIT_PER_FRAGMENT = 2500

    from .crazy_utils import breakdown_txt_to_satisfy_token_limit_for_pdf
--- a/crazy_functions/联网的ChatGPT_bing版.py
+++ b/crazy_functions/联网的ChatGPT_bing版.py
@@ -0,0 +1,102 @@
+from toolbox import CatchException, update_ui
+from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive, input_clipping
+import requests
+from bs4 import BeautifulSoup
+from request_llm.bridge_all import model_info
+
+
+def bing_search(query, proxies=None):
+    query = query
+    url = f"https://cn.bing.com/search?q={query}"
+    headers = {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36'}
+    response = requests.get(url, headers=headers, proxies=proxies)
+    soup = BeautifulSoup(response.content, 'html.parser')
+    results = []
+    for g in soup.find_all('li', class_='b_algo'):
+        anchors = g.find_all('a')
+        if anchors:
+            link = anchors[0]['href']
+            if not link.startswith('http'):
+                continue
+            title = g.find('h2').text
+            item = {'title': title, 'link': link}
+            results.append(item)
+
+    for r in results:
+        print(r['link'])
+    return results
+
+
+def scrape_text(url, proxies) -> str:
+    """Scrape text from a webpage
+
+    Args:
+        url (str): The URL to scrape text from
+
+    Returns:
+        str: The scraped text
+    """
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36',
+        'Content-Type': 'text/plain',
+    }
+    try:
+        response = requests.get(url, headers=headers, proxies=proxies, timeout=8)
+        if response.encoding == "ISO-8859-1": response.encoding = response.apparent_encoding
+    except:
+        return "无法连接到该网页"
+    soup = BeautifulSoup(response.text, "html.parser")
+    for script in soup(["script", "style"]):
+        script.extract()
+    text = soup.get_text()
+    lines = (line.strip() for line in text.splitlines())
+    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+    text = "\n".join(chunk for chunk in chunks if chunk)
+    return text
+
+@CatchException
+def 连接bing搜索回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    """
+    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
+    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
+    plugin_kwargs   插件模型的参数，暂时没有用武之地
+    chatbot         聊天显示框的句柄，用于显示给用户
+    history         聊天历史，前情提要
+    system_prompt   给gpt的静默提醒
+    web_port        当前软件运行的端口号
+    """
+    history = []    # 清空历史，以免输入溢出
+    chatbot.append((f"请结合互联网信息回答以下问题：{txt}",
+                    "[Local Message] 请注意，您正在调用一个[函数插件]的模板，该模板可以实现ChatGPT联网信息综合。该函数面向希望实现更多有趣功能的开发者，它可以作为创建新功能函数的模板。您若希望分享新的功能模组，请不吝PR！"))
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
+
+    # ------------- < 第1步：爬取搜索引擎的结果 > -------------
+    from toolbox import get_conf
+    proxies, = get_conf('proxies')
+    urls = bing_search(txt, proxies)
+    history = []
+
+    # ------------- < 第2步：依次访问网页 > -------------
+    max_search_result = 8   # 最多收纳多少个网页的结果
+    for index, url in enumerate(urls[:max_search_result]):
+        res = scrape_text(url['link'], proxies)
+        history.extend([f"第{index}份搜索结果：", res])
+        chatbot.append([f"第{index}份搜索结果：", res[:500]+"......"])
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
+
+    # ------------- < 第3步：ChatGPT综合 > -------------
+    i_say = f"从以上搜索结果中抽取信息，然后回答问题：{txt}"
+    i_say, history = input_clipping(    # 裁剪输入，从最长的条目开始裁剪，防止爆token
+        inputs=i_say,
+        history=history,
+        max_token_limit=model_info[llm_kwargs['llm_model']]['max_token']*3//4
+    )
+    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+        inputs=i_say, inputs_show_user=i_say,
+        llm_kwargs=llm_kwargs, chatbot=chatbot, history=history,
+        sys_prompt="请从给定的若干条搜索结果中抽取信息，对最相关的两个搜索结果进行总结，然后回答问题。"
+    )
+    chatbot[-1] = (i_say, gpt_say)
+    history.append(i_say);history.append(gpt_say)
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+
--- a/crazy_functions/辅助回答.py
+++ b/crazy_functions/辅助回答.py
@@ -0,0 +1,28 @@
+# encoding: utf-8
+# @Time   : 2023/4/19
+# @Author : Spike
+# @Descr   :
+from toolbox import update_ui
+from toolbox import CatchException, report_execption, write_results_to_file
+from crazy_functions.crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
+
+
+@CatchException
+def 猜你想问(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    if txt:
+        show_say = txt
+        prompt = txt+'\n回答完问题后，再列出用户可能提出的三个问题。'
+    else:
+        prompt = history[-1]+"\n分析上述回答，再列出用户可能提出的三个问题。"
+        show_say = '分析上述回答，再列出用户可能提出的三个问题。'
+    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+        inputs=prompt,
+        inputs_show_user=show_say,
+        llm_kwargs=llm_kwargs,
+        chatbot=chatbot,
+        history=history,
+        sys_prompt=system_prompt
+    )
+    chatbot[-1] = (show_say, gpt_say)
+    history.extend([show_say, gpt_say])
+    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
--- a/crazy_functions/高级功能函数模板.py
+++ b/crazy_functions/高级功能函数模板.py
@@ -6,7 +6,7 @@ def 高阶功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
    """
    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
-    plugin_kwargs   插件模型的参数，暂时没有用武之地
+    plugin_kwargs   插件模型的参数，如温度和top_p等，一般原样传递下去就行
    chatbot         聊天显示框的句柄，用于显示给用户
    history         聊天历史，前情提要
    system_prompt   给gpt的静默提醒
@@ -26,4 +26,4 @@ def 高阶功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
        )
        chatbot[-1] = (i_say, gpt_say)
        history.append(i_say);history.append(gpt_say)
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
--- a/docs/translate_english.json
+++ b/docs/translate_english.json
@@ -1667,5 +1667,294 @@
    "段音频的主要内容": "The main content of the segment audio is",
    "z$ 分别是空间直角坐标系中的三个坐标": "z$, respectively, are the three coordinates in the spatial rectangular coordinate system",
    "这个是怎么识别的呢我也不清楚": "I'm not sure how this is recognized",
-    "从现在起": "From now on"
+    "从现在起": "From now on",
+    "连接bing搜索回答问题": "ConnectBingSearchAnswerQuestion",
+    "联网的ChatGPT_bing版": "OnlineChatGPT_BingEdition",
+    "Markdown翻译指定语言": "TranslateMarkdownToSpecifiedLanguage",
+    "Langchain知识库": "LangchainKnowledgeBase",
+    "Latex英文纠错加PDF对比": "CorrectEnglishInLatexWithPDFComparison",
+    "Latex输出PDF结果": "OutputPDFFromLatex",
+    "Latex翻译中文并重新编译PDF": "TranslateChineseToEnglishInLatexAndRecompilePDF",
+    "sprint亮靛": "SprintIndigo",
+    "寻找Latex主文件": "FindLatexMainFile",
+    "专业词汇声明": "ProfessionalTerminologyDeclaration",
+    "Latex精细分解与转化": "DecomposeAndConvertLatex",
+    "编译Latex": "CompileLatex",
+    "如果您是论文原作者": "If you are the original author of the paper",
+    "正在编译对比PDF": "Compiling the comparison PDF",
+    "将 \\include 命令转换为 \\input 命令": "Converting the \\include command to the \\input command",
+    "取评分最高者返回": "Returning the highest-rated one",
+    "不要修改!! 高危设置！通过修改此设置": "Do not modify!! High-risk setting! By modifying this setting",
+    "Tex源文件缺失！": "Tex source file is missing!",
+    "6.25 加入判定latex模板的代码": "Added code to determine the latex template on June 25",
+    "正在精细切分latex文件": "Finely splitting the latex file",
+    "获取response失败": "Failed to get response",
+    "手动指定语言": "Manually specify the language",
+    "输入arxivID": "Enter arxivID",
+    "对输入的word文档进行摘要生成": "Generate a summary of the input word document",
+    "将指定目录下的PDF文件从英文翻译成中文": "Translate PDF files from English to Chinese in the specified directory",
+    "如果分析错误": "If the analysis is incorrect",
+    "尝试第": "Try the",
+    "用户填3": "User fills in 3",
+    "请在此处追加更细致的矫错指令": "Please append more detailed correction instructions here",
+    "为了防止大语言模型的意外谬误产生扩散影响": "To prevent the accidental spread of errors in large language models",
+    "前面是中文冒号": "The colon before is in Chinese",
+    "内含已经翻译的Tex文档": "Contains a Tex document that has been translated",
+    "成功啦": "Success!",
+    "刷新页面即可以退出UpdateKnowledgeArchive模式": "Refresh the page to exit UpdateKnowledgeArchive mode",
+    "或者不在环境变量PATH中": "Or not in the environment variable PATH",
+    "--读取文件": "--Read the file",
+    "才能继续下面的步骤": "To continue with the next steps",
+    "代理数据解析失败": "Proxy data parsing failed",
+    "详见项目主README.md": "See the main README.md of the project for details",
+    "临时存储用于调试": "Temporarily stored for debugging",
+    "屏蔽空行和太短的句子": "Filter out empty lines and sentences that are too short",
+    "gpt 多线程请求": "GPT multi-threaded request",
+    "编译已经开始": "Compilation has started",
+    "无法找到一个主Tex文件": "Cannot find a main Tex file",
+    "修复括号": "Fix parentheses",
+    "请您不要删除或修改这行警告": "Please do not delete or modify this warning",
+    "请登录OpenAI查看详情 https": "Please log in to OpenAI to view details at https",
+    "调用函数": "Call a function",
+    "请查看终端的输出或耐心等待": "Please check the output in the terminal or wait patiently",
+    "LatexEnglishCorrection+高亮修正位置": "Latex English correction + highlight correction position",
+    "行": "line",
+    "Newbing 请求失败": "Newbing request failed",
+    "转化PDF编译是否成功": "Check if the conversion to PDF and compilation were successful",
+    "建议更换代理协议": "Recommend changing the proxy protocol",
+    "========================================= 插件主程序1 =====================================================": "========================================= Plugin Main Program 1 =====================================================",
+    "终端": "terminal",
+    "请先上传文件素材": "Please upload file materials first",
+    "前面是中文逗号": "There is a Chinese comma in front",
+    "请尝试把以下指令复制到高级参数区": "Please try copying the following instructions to the advanced parameters section",
+    "翻译-": "Translation -",
+    "请耐心等待": "Please be patient",
+    "将前后断行符脱离": "Remove line breaks before and after",
+    "json等": "JSON, etc.",
+    "生成中文PDF": "Generate Chinese PDF",
+    "用红色标注处保留区": "Use red color to highlight the reserved area",
+    "对比PDF编译是否成功": "Compare if the PDF compilation was successful",
+    "回答完问题后": "After answering the question",
+    "其他操作系统表现未知": "Unknown performance on other operating systems",
+    "-构建知识库": "Build knowledge base",
+    "还原原文": "Restore original text",
+    "或者重启之后再度尝试": "Or try again after restarting",
+    "免费": "Free",
+    "仅在Windows系统进行了测试": "Tested only on Windows system",
+    "欢迎加REAME中的QQ联系开发者": "Feel free to contact the developer via QQ in REAME",
+    "当前知识库内的有效文件": "Valid files in the current knowledge base",
+    "您可以到Github Issue区": "You can go to the Github Issue area",
+    "刷新Gradio前端界面": "Refresh the Gradio frontend interface",
+    "吸收title与作者以上的部分": "Include the title and the above part of the author",
+    "给出一些判定模板文档的词作为扣分项": "Provide some words in the template document as deduction items",
+    "--读取参数": "-- Read parameters",
+    "然后进行问答": "And then perform question-answering",
+    "根据自然语言执行插件命令": "Execute plugin commands based on natural language",
+    "*{\\scriptsize\\textbf{警告": "*{\\scriptsize\\textbf{Warning",
+    "但请查收结果": "But please check the results",
+    "翻译内容可靠性无保障": "No guarantee of translation accuracy",
+    "寻找主文件": "Find the main file",
+    "消耗时间的函数": "Time-consuming function",
+    "当前语言模型温度设定": "Current language model temperature setting",
+    "这需要一段时间计算": "This requires some time to calculate",
+    "为啥chatgpt会把cite里面的逗号换成中文逗号呀": "Why does ChatGPT change commas inside 'cite' to Chinese commas?",
+    "发现已经存在翻译好的PDF文档": "Found an already translated PDF document",
+    "待提取的知识库名称id": "Knowledge base name ID to be extracted",
+    "文本碎片重组为完整的tex片段": "Reassemble text fragments into complete tex fragments",
+    "注意事项": "Notes",
+    "参数说明": "Parameter description",
+    "或代理节点": "Or proxy node",
+    "构建知识库": "Building knowledge base",
+    "报错信息如下. 如果是与网络相关的问题": "Error message as follows. If it is related to network issues",
+    "功能描述": "Function description",
+    "禁止移除或修改此警告": "Removal or modification of this warning is prohibited",
+    "Arixv翻译": "Arixv translation",
+    "读取优先级": "Read priority",
+    "包含documentclass关键字": "Contains the documentclass keyword",
+    "根据文本使用GPT模型生成相应的图像": "Generate corresponding images using GPT model based on the text",
+    "图像生成所用到的提示文本": "Prompt text used for image generation",
+    "Your account is not active. OpenAI以账户失效为由": "Your account is not active. OpenAI states that it is due to account expiration",
+    "快捷的调试函数": "Convenient debugging function",
+    "在多Tex文档中": "In multiple Tex documents",
+    "因此选择GenerateImage函数": "Therefore, choose the GenerateImage function",
+    "当前工作路径为": "The current working directory is",
+    "实际得到格式": "Obtained format in reality",
+    "这段代码定义了一个名为TempProxy的空上下文管理器": "This code defines an empty context manager named TempProxy",
+    "吸收其他杂项": "Absorb other miscellaneous items",
+    "请输入要翻译成哪种语言": "Please enter which language to translate into",
+    "的单词": "of the word",
+    "正在尝试自动安装": "Attempting automatic installation",
+    "如果有必要": "If necessary",
+    "开始下载": "Start downloading",
+    "项目Github地址 \\url{https": "Project GitHub address \\url{https",
+    "将根据报错信息修正tex源文件并重试": "The Tex source file will be corrected and retried based on the error message",
+    "发送至azure openai api": "Send to Azure OpenAI API",
+    "吸收匿名公式": "Absorb anonymous formulas",
+    "用该压缩包+ConversationHistoryArchive进行反馈": "Provide feedback using the compressed package + ConversationHistoryArchive",
+    "需要特殊依赖": "Requires special dependencies",
+    "还原部分原文": "Restore part of the original text",
+    "构建完成": "Build completed",
+    "解析arxiv网址失败": "Failed to parse arXiv URL",
+    "输入问题后点击该插件": "Click the plugin after entering the question",
+    "请求子进程": "Requesting subprocess",
+    "请务必用 pip install -r requirements.txt 指令安装依赖": "Please make sure to install the dependencies using the 'pip install -r requirements.txt' command",
+    "如果程序停顿5分钟以上": "If the program pauses for more than 5 minutes",
+    "转化PDF编译已经成功": "Conversion to PDF compilation was successful",
+    "虽然PDF生成失败了": "Although PDF generation failed",
+    "分析上述回答": "Analyze the above answer",
+    "吸收在42行以内的begin-end组合": "Absorb the begin-end combination within 42 lines",
+    "推荐http": "Recommend http",
+    "Latex没有安装": "Latex is not installed",
+    "用latex编译为PDF对修正处做高亮": "Compile to PDF using LaTeX and highlight the corrections",
+    "reverse 操作必须放在最后": "'reverse' operation must be placed at the end",
+    "AZURE OPENAI API拒绝了请求": "AZURE OPENAI API rejected the request",
+    "该项目的Latex主文件是": "The main LaTeX file of this project is",
+    "You are associated with a deactivated account. OpenAI以账户失效为由": "You are associated with a deactivated account. OpenAI considers it as an account expiration",
+    "它*必须*被包含在AVAIL_LLM_MODELS列表中": "It *must* be included in the AVAIL_LLM_MODELS list",
+    "未知指令": "Unknown command",
+    "尝试执行Latex指令失败": "Failed to execute the LaTeX command",
+    "摘要生成后的文档路径": "Path of the document after summary generation",
+    "GPT结果已输出": "GPT result has been outputted",
+    "使用Newbing": "Using Newbing",
+    "其他模型转化效果未知": "Unknown conversion effect of other models",
+    "P.S. 但愿没人把latex模板放在里面传进来": "P.S. Hopefully, no one passes a LaTeX template in it",
+    "定位主Latex文件": "Locate the main LaTeX file",
+    "后面是英文冒号": "English colon follows",
+    "文档越长耗时越长": "The longer the document, the longer it takes.",
+    "压缩包": "Compressed file",
+    "但通常不会出现在正文": "But usually does not appear in the body.",
+    "正在预热文本向量化模组": "Preheating text vectorization module",
+    "5刀": "5 dollars",
+    "提问吧! 但注意": "Ask questions! But be careful",
+    "发送至AZURE OPENAI API": "Send to AZURE OPENAI API",
+    "请仔细鉴别并以原文为准": "Please carefully verify and refer to the original text",
+    "如果需要使用AZURE 详情请见额外文档 docs\\use_azure.md": "If you need to use AZURE, please refer to the additional document docs\\use_azure.md for details",
+    "使用正则表达式查找半行注释": "Use regular expressions to find inline comments",
+    "只有第二步成功": "Only the second step is successful",
+    "P.S. 顺便把CTEX塞进去以支持中文": "P.S. By the way, include CTEX to support Chinese",
+    "安装方法https": "Installation method: https",
+    "则跳过GPT请求环节": "Then skip the GPT request process",
+    "请切换至“UpdateKnowledgeArchive”插件进行知识库访问": "Please switch to the 'UpdateKnowledgeArchive' plugin for knowledge base access",
+    "=================================== 工具函数 ===============================================": "=================================== Utility functions ===============================================",
+    "填入azure openai api的密钥": "Fill in the Azure OpenAI API key",
+    "上传Latex压缩包": "Upload LaTeX compressed file",
+    "远程云服务器部署": "Deploy to remote cloud server",
+    "用黑色标注转换区": "Use black color to annotate the conversion area",
+    "音频文件的路径": "Path to the audio file",
+    "必须包含documentclass": "Must include documentclass",
+    "再列出用户可能提出的三个问题": "List three more questions that the user might ask",
+    "根据需要切换prompt": "Switch the prompt as needed",
+    "将文件复制一份到下载区": "Make a copy of the file in the download area",
+    "次编译": "Second compilation",
+    "Latex文件融合完成": "LaTeX file merging completed",
+    "返回": "Return",
+    "后面是英文逗号": "Comma after this",
+    "对不同latex源文件扣分": "Deduct points for different LaTeX source files",
+    "失败啦": "Failed",
+    "编译BibTex": "Compile BibTeX",
+    "Linux下必须使用Docker安装": "Must install using Docker on Linux",
+    "报错信息": "Error message",
+    "删除或修改歧义文件": "Delete or modify ambiguous files",
+    "-预热文本向量化模组": "- Preheating text vectorization module",
+    "将每次对话记录写入Markdown格式的文件中": "Write each conversation record into a file in Markdown format",
+    "其他类型文献转化效果未知": "Unknown conversion effect for other types of literature",
+    "获取线程锁": "Acquire thread lock",
+    "使用英文": "Use English",
+    "如果存在调试缓存文件": "If there is a debug cache file",
+    "您需要首先调用构建知识库": "You need to call the knowledge base building first",
+    "原始PDF编译是否成功": "Whether the original PDF compilation is successful",
+    "生成 azure openai api请求": "Generate Azure OpenAI API requests",
+    "正在编译PDF": "Compiling PDF",
+    "仅调试": "Debug only",
+    "========================================= 插件主程序2 =====================================================": "========================================= Plugin Main Program 2 =====================================================",
+    "多线程翻译开始": "Multithreaded translation begins",
+    "出问题了": "There is a problem",
+    "版权归原文作者所有": "Copyright belongs to the original author",
+    "当前大语言模型": "Current large language model",
+    "目前对机器学习类文献转化效果最好": "Currently, the best conversion effect for machine learning literature",
+    "这个paper有个input命令文件名大小写错误！": "This paper has an input command with a filename case error!",
+    "期望格式例如": "Expected format, for example",
+    "解决部分词汇翻译不准确的问题": "Resolve the issue of inaccurate translation for some terms",
+    "待注入的知识库名称id": "Name/ID of the knowledge base to be injected",
+    "精细切分latex文件": "Fine-grained segmentation of LaTeX files",
+    "永远给定None": "Always given None",
+    "work_folder = Latex预处理": "work_folder = LaTeX preprocessing",
+    "请直接去该路径下取回翻译结果": "Please directly go to the path to retrieve the translation results",
+    "寻找主tex文件": "Finding the main .tex file",
+    "模型参数": "Model parameters",
+    "返回找到的第一个": "Return the first one found",
+    "编译转化后的PDF": "Compile the converted PDF",
+    "\\SEAFILE_LOCALŅ03047\\我的资料库\\music\\Akie秋绘-未来轮廓.mp3": "\\SEAFILE_LOCALŅ03047\\My Library\\music\\Akie秋绘-未来轮廓.mp3",
+    "拆分过长的latex片段": "Splitting overly long LaTeX fragments",
+    "没有找到任何可读取文件": "No readable files found",
+    "暗色模式 / 亮色模式": "Dark mode / Light mode",
+    "检测到arxiv文档连接": "Detected arXiv document link",
+    "此插件Windows支持最佳": "This plugin has best support for Windows",
+    "from crazy_functions.虚空终端 import 终端": "from crazy_functions.null_terminal import Terminal",
+    "本地论文翻译": "Local paper translation",
+    "输出html调试文件": "Output HTML debugging file",
+    "以下所有配置也都支持利用环境变量覆写": "All the following configurations can also be overridden using environment variables",
+    "PDF文件所在的路径": "Path of the PDF file",
+    "也是可读的": "It is also readable",
+    "将消耗较长时间下载中文向量化模型": "Downloading Chinese vectorization model will take a long time",
+    "环境变量配置格式见docker-compose.yml": "See docker-compose.yml for the format of environment variable configuration",
+    "编译文献交叉引用": "Compile bibliographic cross-references",
+    "默认为default": "Default is 'default'",
+    "或者使用此插件继续上传更多文件": "Or use this plugin to continue uploading more files",
+    "该PDF由GPT-Academic开源项目调用大语言模型+Latex翻译插件一键生成": "This PDF is generated by the GPT-Academic open-source project using a large language model + LaTeX translation plugin",
+    "使用latexdiff生成论文转化前后对比": "Use latexdiff to generate before and after comparison of paper transformation",
+    "正在编译PDF文档": "Compiling PDF document",
+    "读取config.py文件中关于AZURE OPENAI API的信息": "Read the information about AZURE OPENAI API from the config.py file",
+    "配置教程&视频教程": "Configuration tutorial & video tutorial",
+    "临时地启动代理网络": "Temporarily start proxy network",
+    "临时地激活代理网络": "Temporarily activate proxy network",
+    "功能尚不稳定": "Functionality is unstable",
+    "默认为Chinese": "Default is Chinese",
+    "请查收结果": "Please check the results",
+    "将 chatglm 直接对齐到 chatglm2": "Align chatglm directly to chatglm2",
+    "中读取数据构建知识库": "Build a knowledge base by reading data in",
+    "用于给一小段代码上代理": "Used to proxy a small piece of code",
+    "分析结果": "Analysis results",
+    "依赖不足": "Insufficient dependencies",
+    "Markdown翻译": "Markdown translation",
+    "除非您是论文的原作者": "Unless you are the original author of the paper",
+    "test_LangchainKnowledgeBase读取": "test_LangchainKnowledgeBase read",
+    "将多文件tex工程融合为一个巨型tex": "Merge multiple tex projects into one giant tex",
+    "吸收iffalse注释": "Absorb iffalser comments",
+    "您接下来不能再使用其他插件了": "You can no longer use other plugins next",
+    "正在构建知识库": "Building knowledge base",
+    "需Latex": "Requires Latex",
+    "即找不到": "That is not found",
+    "保证括号正确": "Ensure parentheses are correct",
+    "= 2 通过一些Latex模板中常见": "= 2 through some common Latex templates",
+    "请立即终止程序": "Please terminate the program immediately",
+    "解压失败! 需要安装pip install rarfile来解压rar文件": "Decompression failed! Install 'pip install rarfile' to decompress rar files",
+    "请在此处给出自定义翻译命令": "Please provide custom translation command here",
+    "解压失败! 需要安装pip install py7zr来解压7z文件": "Decompression failed! Install 'pip install py7zr' to decompress 7z files",
+    "执行错误": "Execution error",
+    "目前仅支持GPT3.5/GPT4": "Currently only supports GPT3.5/GPT4",
+    "P.S. 顺便把Latex的注释去除": "P.S. Also remove comments from Latex",
+    "写出文件": "Write out the file",
+    "当前报错的latex代码处于第": "The current error in the LaTeX code is on line",
+    "主程序即将开始": "Main program is about to start",
+    "详情信息见requirements.txt": "See details in requirements.txt",
+    "释放线程锁": "Release thread lock",
+    "由于最为关键的转化PDF编译失败": "Due to the critical failure of PDF conversion and compilation",
+    "即将退出": "Exiting soon",
+    "尝试下载": "Attempting to download",
+    "删除整行的空注释": "Remove empty comments from the entire line",
+    "也找不到": "Not found either",
+    "从一批文件": "From a batch of files",
+    "编译结束": "Compilation finished",
+    "调用缓存": "Calling cache",
+    "只有GenerateImage和生成图像相关": "Only GenerateImage and image generation related",
+    "待处理的word文档路径": "Path of the word document to be processed",
+    "是否在提交时自动清空输入框": "Whether to automatically clear the input box upon submission",
+    "检查结果": "Check the result",
+    "生成时间戳": "Generate a timestamp",
+    "编译原始PDF": "Compile the original PDF",
+    "填入ENGINE": "Fill in ENGINE",
+    "填入api版本": "Fill in the API version",
+    "中文Bing版": "Chinese Bing version",
+    "当前支持的格式包括": "Currently supported formats include"
 }
--- a/docs/use_azure.md
+++ b/docs/use_azure.md
@@ -90,11 +90,12 @@

 到现在为止，申请操作就完成了，需要记下来的有下面几个东西：

-● 密钥（1或2都可以）
+● 密钥（对应AZURE_API_KEY，1或2都可以）

-● 终结点
+● 终结点 （对应AZURE_ENDPOINT）
+
+● 部署名（对应AZURE_ENGINE，不是模型名）

-● 部署名（不是模型名）

 # 修改 config.py

@@ -102,50 +103,14 @@
 AZURE_ENDPOINT = "填入终结点"
 AZURE_API_KEY = "填入azure openai api的密钥"
 AZURE_API_VERSION = "2023-05-15"  # 默认使用 2023-05-15 版本，无需修改
-AZURE_ENGINE = "填入部署名"
-
-```
-# API的使用
-
-接下来就是具体怎么使用API了，还是可以参考官方文档：[快速入门 - 开始通过 Azure OpenAI 服务使用 ChatGPT 和 GPT-4 - Azure OpenAI Service | Microsoft Learn](https://learn.microsoft.com/zh-cn/azure/cognitive-services/openai/chatgpt-quickstart?pivots=programming-language-python)
-
-和openai自己的api调用有点类似，都需要安装openai库，不同的是调用方式
-
-```
-import openai
-openai.api_type = "azure" #固定格式，无需修改
-openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") #这里填入“终结点”
-openai.api_version = "2023-05-15" #固定格式，无需修改
-openai.api_key = os.getenv("AZURE_OPENAI_KEY") #这里填入“密钥1”或“密钥2”
-
-response = openai.ChatCompletion.create(
-    engine="gpt-35-turbo", #这里填入的不是模型名，是部署名
-    messages=[
-        {"role": "system", "content": "You are a helpful assistant."},
-        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
-        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
-        {"role": "user", "content": "Do other Azure Cognitive Services support this too?"}
-    ]
-)
-
-print(response)
-print(response['choices'][0]['message']['content'])
+AZURE_ENGINE = "填入部署名" # 见上图

 ```

-需要注意的是：
-
-1.  engine那里填入的是部署名，不是模型名
-
-2.  通过openai库获得的这个 response 和通过 request 库访问 url 获得的 response 不同，不需要 decode，已经是解析好的 json 了，直接根据键值读取即可。
-
-更细节的使用方法，详见官方API文档。

 # 关于费用

-Azure OpenAI API 还是需要一些费用的（免费订阅只有1个月有效期），费用如下：
-
-![image.png](https://note.youdao.com/yws/res/18095/WEBRESOURCEeba0ab6d3127b79e143ef2d5627c0e44)
+Azure OpenAI API 还是需要一些费用的（免费订阅只有1个月有效期）

 具体可以可以看这个网址 ：[Azure OpenAI 服务 - 定价| Microsoft Azure](https://azure.microsoft.com/zh-cn/pricing/details/cognitive-services/openai-service/?cdn=disable)

--- a/main.py
+++ b/main.py
@@ -6,8 +6,8 @@ def main():
    from request_llm.bridge_all import predict
    from toolbox import format_io, find_free_port, on_file_uploaded, on_report_generated, get_conf, ArgsGeneralWrapper, DummyWith
    # 建议您复制一个config_private.py放自己的秘密, 如API和代理网址, 避免不小心传github被别人看到
-    proxies, WEB_PORT, LLM_MODEL, CONCURRENT_COUNT, AUTHENTICATION, CHATBOT_HEIGHT, LAYOUT, API_KEY, AVAIL_LLM_MODELS = \
-        get_conf('proxies', 'WEB_PORT', 'LLM_MODEL', 'CONCURRENT_COUNT', 'AUTHENTICATION', 'CHATBOT_HEIGHT', 'LAYOUT', 'API_KEY', 'AVAIL_LLM_MODELS')
+    proxies, WEB_PORT, LLM_MODEL, CONCURRENT_COUNT, AUTHENTICATION, CHATBOT_HEIGHT, LAYOUT, API_KEY, AVAIL_LLM_MODELS, AUTO_CLEAR_TXT = \
+        get_conf('proxies', 'WEB_PORT', 'LLM_MODEL', 'CONCURRENT_COUNT', 'AUTHENTICATION', 'CHATBOT_HEIGHT', 'LAYOUT', 'API_KEY', 'AVAIL_LLM_MODELS', 'AUTO_CLEAR_TXT')

    # 如果WEB_PORT是-1, 则随机选取WEB端口
    PORT = find_free_port() if WEB_PORT <= 0 else WEB_PORT
@@ -104,7 +104,7 @@ def main():
                    system_prompt = gr.Textbox(show_label=True, placeholder=f"System Prompt", label="System prompt", value=initial_prompt)
                    top_p = gr.Slider(minimum=-0, maximum=1.0, value=1.0, step=0.01,interactive=True, label="Top-p (nucleus sampling)",)
                    temperature = gr.Slider(minimum=-0, maximum=2.0, value=1.0, step=0.01, interactive=True, label="Temperature",)
-                    max_length_sl = gr.Slider(minimum=256, maximum=4096, value=512, step=1, interactive=True, label="Local LLM MaxLength",)
+                    max_length_sl = gr.Slider(minimum=256, maximum=8192, value=4096, step=1, interactive=True, label="Local LLM MaxLength",)
                    checkboxes = gr.CheckboxGroup(["基础功能区", "函数插件区", "底部输入区", "输入清除键", "插件参数区"], value=["基础功能区", "函数插件区"], label="显示/隐藏功能区")
                    md_dropdown = gr.Dropdown(AVAIL_LLM_MODELS, value=LLM_MODEL, label="更换LLM模型/请求源").style(container=False)

@@ -144,6 +144,11 @@ def main():
        resetBtn2.click(lambda: ([], [], "已重置"), None, [chatbot, history, status])
        clearBtn.click(lambda: ("",""), None, [txt, txt2])
        clearBtn2.click(lambda: ("",""), None, [txt, txt2])
+        if AUTO_CLEAR_TXT:
+            submitBtn.click(lambda: ("",""), None, [txt, txt2])
+            submitBtn2.click(lambda: ("",""), None, [txt, txt2])
+            txt.submit(lambda: ("",""), None, [txt, txt2])
+            txt2.submit(lambda: ("",""), None, [txt, txt2])
        # 基础功能区的回调函数注册
        for k in functional:
            if ("Visible" in functional[k]) and (not functional[k]["Visible"]): continue
--- a/multi_language.py
+++ b/multi_language.py
@@ -33,7 +33,7 @@ import pickle
 import time

 CACHE_FOLDER = "gpt_log"
-blacklist = ['multi-language', 'gpt_log', '.git', 'private_upload', 'multi_language.py']
+blacklist = ['multi-language', 'gpt_log', '.git', 'private_upload', 'multi_language.py', 'build', '.github', '.vscode', '__pycache__', 'venv']

 # LANG = "TraditionalChinese"
 # TransPrompt = f"Replace each json value `#` with translated results in Traditional Chinese, e.g., \"原始文本\":\"翻譯後文字\". Keep Json format. Do not answer #."
@@ -301,6 +301,7 @@ def step_1_core_key_translate():
                elif isinstance(node, ast.ImportFrom):
                    for n in node.names:
                        if contains_chinese(n.name): syntax.append(n.name)
+                        # if node.module is None: print(node.module)
                        for k in node.module.split('.'):
                            if contains_chinese(k): syntax.append(k)
            return syntax
@@ -310,6 +311,7 @@ def step_1_core_key_translate():
        for root, dirs, files in os.walk(directory_path):
            if any([b in root for b in blacklist]):
                continue
+            print(files)
            for file in files:
                if file.endswith('.py'):
                    file_path = os.path.join(root, file)
@@ -505,6 +507,6 @@ def step_2_core_key_translate():
                    with open(file_path_new, 'w', encoding='utf-8') as f:
                        f.write(content)
                    os.remove(file_path)
-
 step_1_core_key_translate()
 step_2_core_key_translate()
+print('Finished, checkout generated results at ./multi-language/')
--- a/request_llm/bridge_all.py
+++ b/request_llm/bridge_all.py
@@ -22,9 +22,6 @@ from .bridge_azure_test import predict as azure_ui
 from .bridge_chatglm import predict_no_ui_long_connection as chatglm_noui
 from .bridge_chatglm import predict as chatglm_ui

-from .bridge_newbing import predict_no_ui_long_connection as newbing_noui
-from .bridge_newbing import predict as newbing_ui
-
 # from .bridge_tgui import predict_no_ui_long_connection as tgui_noui
 # from .bridge_tgui import predict as tgui_ui

@@ -124,7 +121,7 @@ model_info = {
    },

    # azure openai
-    "azure-gpt35":{
+    "azure-gpt-3.5":{
        "fn_with_ui": azure_ui,
        "fn_without_ui": azure_noui,
        "endpoint": get_conf("AZURE_ENDPOINT"),
@@ -152,7 +149,7 @@ model_info = {
        "token_cnt": get_token_num_gpt4,
    },

-    # chatglm
+    # 将 chatglm 直接对齐到 chatglm2
    "chatglm": {
        "fn_with_ui": chatglm_ui,
        "fn_without_ui": chatglm_noui,
@@ -161,12 +158,11 @@ model_info = {
        "tokenizer": tokenizer_gpt35,
        "token_cnt": get_token_num_gpt35,
    },
-    # newbing
-    "newbing": {
-        "fn_with_ui": newbing_ui,
-        "fn_without_ui": newbing_noui,
-        "endpoint": newbing_endpoint,
-        "max_token": 4096,
+    "chatglm2": {
+        "fn_with_ui": chatglm_ui,
+        "fn_without_ui": chatglm_noui,
+        "endpoint": None,
+        "max_token": 1024,
        "tokenizer": tokenizer_gpt35,
        "token_cnt": get_token_num_gpt35,
    },
@@ -258,6 +254,23 @@ if "newbing-free" in AVAIL_LLM_MODELS:
        })
    except:
        print(trimmed_format_exc())
+if "newbing" in AVAIL_LLM_MODELS:   # same with newbing-free
+    try:
+        from .bridge_newbingfree import predict_no_ui_long_connection as newbingfree_noui
+        from .bridge_newbingfree import predict as newbingfree_ui
+        # claude
+        model_info.update({
+            "newbing": {
+                "fn_with_ui": newbingfree_ui,
+                "fn_without_ui": newbingfree_noui,
+                "endpoint": newbing_endpoint,
+                "max_token": 4096,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+            }
+        })
+    except:
+        print(trimmed_format_exc())

 def LLM_CATCH_EXCEPTION(f):
    """
--- a/request_llm/bridge_azure_test.py
+++ b/request_llm/bridge_azure_test.py
@@ -14,7 +14,8 @@ import traceback
 import importlib
 import openai
 import time
-
+import requests
+import json

 # 读取config.py文件中关于AZURE OPENAI API的信息
 from toolbox import get_conf, update_ui, clip_history, trimmed_format_exc
@@ -43,7 +44,6 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
    chatbot 为WebUI中显示的对话列表，修改它，然后yeild出去，可以直接修改对话界面内容
    additional_fn代表点击的哪个按钮，按钮见functional.py
    """
-    print(llm_kwargs["llm_model"])    

    if additional_fn is not None:
        import core_functional
@@ -56,7 +56,6 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
    logging.info(f'[raw_input] {raw_input}')
    chatbot.append((inputs, ""))
    yield from update_ui(chatbot=chatbot, history=history, msg="等待响应") # 刷新界面
-
    
    payload = generate_azure_payload(inputs, llm_kwargs, history, system_prompt, stream)    
        
@@ -64,20 +63,22 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp

    retry = 0
    while True:
-        try:            
-                
+        try:
            openai.api_type = "azure"            
            openai.api_version = AZURE_API_VERSION
            openai.api_base = AZURE_ENDPOINT
            openai.api_key = AZURE_API_KEY
            response = openai.ChatCompletion.create(timeout=TIMEOUT_SECONDS, **payload);break
-        
+        except openai.error.AuthenticationError:
+            tb_str = '```\n' + trimmed_format_exc() + '```'
+            chatbot[-1] = [chatbot[-1][0], tb_str]
+            yield from update_ui(chatbot=chatbot, history=history, msg="openai返回错误") # 刷新界面
+            return
        except:
            retry += 1
-            chatbot[-1] = ((chatbot[-1][0], "获取response失败，重试中。。。"))
-            retry_msg = f"，正在重试 ({retry}/{MAX_RETRY}) ……" if MAX_RETRY > 0 else ""
-            yield from update_ui(chatbot=chatbot, history=history, msg="请求超时"+retry_msg) # 刷新界面
+            traceback.print_exc()
            if retry > MAX_RETRY: raise TimeoutError
+            if MAX_RETRY!=0: print(f'请求超时，正在重试 ({retry}/{MAX_RETRY}) ……')
            
    gpt_replying_buffer = ""    
    is_head_of_the_stream = True
@@ -141,20 +142,17 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",
    payload = generate_azure_payload(inputs, llm_kwargs, history, system_prompt=sys_prompt, stream=True)
    retry = 0
    while True:
-
        try:
            openai.api_type = "azure"            
            openai.api_version = AZURE_API_VERSION
            openai.api_base = AZURE_ENDPOINT
            openai.api_key = AZURE_API_KEY
            response = openai.ChatCompletion.create(timeout=TIMEOUT_SECONDS, **payload);break
-        
-        except:  
+        except:
            retry += 1
            traceback.print_exc()
            if retry > MAX_RETRY: raise TimeoutError
-            if MAX_RETRY!=0: print(f'请求超时，正在重试 ({retry}/{MAX_RETRY}) ……')     
-        
+            if MAX_RETRY!=0: print(f'请求超时，正在重试 ({retry}/{MAX_RETRY}) ……')

    stream_response =  response
    result = ''
@@ -164,19 +162,14 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",
            break
        except:
            chunk = next(stream_response) # 失败了，重试一次？再失败就没办法了。
-
        if len(chunk)==0: continue
-        if not chunk.startswith('data:'): 
-            error_msg = get_full_error(chunk, stream_response)
-            if "reduce the length" in error_msg:
-                raise ConnectionAbortedError("AZURE OPENAI API拒绝了请求:" + error_msg)
-            else:
-                raise RuntimeError("AZURE OPENAI API拒绝了请求：" + error_msg)
-        if ('data: [DONE]' in chunk): break 
-        
-        delta = chunk["delta"]
-        if len(delta) == 0: break
-        if "role" in delta: continue
+
+        json_data = json.loads(str(chunk))['choices'][0]
+        delta = json_data["delta"]
+        if len(delta) == 0:
+            break
+        if "role" in delta:
+            continue
        if "content" in delta: 
            result += delta["content"]
            if not console_slience: print(delta["content"], end='')
@@ -184,11 +177,14 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",
                # 观测窗，把已经获取的数据显示出去
                if len(observe_window) >= 1: observe_window[0] += delta["content"]
                # 看门狗，如果超过期限没有喂狗，则终止
-                if len(observe_window) >= 2:  
+                if len(observe_window) >= 2000:  
                    if (time.time()-observe_window[1]) > watch_dog_patience:
                        raise RuntimeError("用户取消了程序。")
-        else: raise RuntimeError("意外Json结构："+delta)
-    if chunk['finish_reason'] == 'length':
+        else:
+            raise RuntimeError("意外Json结构："+delta)
+    if json_data['finish_reason'] == 'content_filter':
+        raise RuntimeError("由于提问含不合规内容被Azure过滤。")
+    if json_data['finish_reason'] == 'length':
        raise ConnectionAbortedError("正常结束，但显示Token不足，导致输出不完整，请削减单次输入的文本量。")
    return result

--- a/request_llm/bridge_chatglm.py
+++ b/request_llm/bridge_chatglm.py
@@ -40,12 +40,12 @@ class GetGLMHandle(Process):
        while True:
            try:
                if self.chatglm_model is None:
-                    self.chatglm_tokenizer = AutoTokenizer.from_pretrained("THUDM/chatglm-6b", trust_remote_code=True)
+                    self.chatglm_tokenizer = AutoTokenizer.from_pretrained("THUDM/chatglm2-6b", trust_remote_code=True)
                    device, = get_conf('LOCAL_MODEL_DEVICE')
                    if device=='cpu':
-                        self.chatglm_model = AutoModel.from_pretrained("THUDM/chatglm-6b", trust_remote_code=True).float()
+                        self.chatglm_model = AutoModel.from_pretrained("THUDM/chatglm2-6b", trust_remote_code=True).float()
                    else:
-                        self.chatglm_model = AutoModel.from_pretrained("THUDM/chatglm-6b", trust_remote_code=True).half().cuda()
+                        self.chatglm_model = AutoModel.from_pretrained("THUDM/chatglm2-6b", trust_remote_code=True).half().cuda()
                    self.chatglm_model = self.chatglm_model.eval()
                    break
                else:
--- a/request_llm/bridge_chatgpt.py
+++ b/request_llm/bridge_chatgpt.py
@@ -22,8 +22,8 @@ import importlib
 # config_private.py放自己的秘密如API和代理网址
 # 读取时首先看是否存在私密的config_private配置文件（不受git管控），如果有，则覆盖原config文件
 from toolbox import get_conf, update_ui, is_any_api_key, select_api_key, what_keys, clip_history, trimmed_format_exc
-proxies, API_KEY, TIMEOUT_SECONDS, MAX_RETRY = \
-    get_conf('proxies', 'API_KEY', 'TIMEOUT_SECONDS', 'MAX_RETRY')
+proxies, API_KEY, TIMEOUT_SECONDS, MAX_RETRY, API_ORG = \
+    get_conf('proxies', 'API_KEY', 'TIMEOUT_SECONDS', 'MAX_RETRY', 'API_ORG')

 timeout_bot_msg = '[Local Message] Request timeout. Network error. Please check proxy settings in config.py.' + \
                  '网络错误，检查代理服务器是否可用，以及代理设置的格式是否正确，格式须是[协议]://[地址]:[端口]，缺一不可。'
@@ -205,6 +205,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                    chunk = get_full_error(chunk, stream_response)
                    chunk_decoded = chunk.decode()
                    error_msg = chunk_decoded
+                    openai_website = ' 请登录OpenAI查看详情 https://platform.openai.com/signup'
                    if "reduce the length" in error_msg:
                        if len(history) >= 2: history[-1] = ""; history[-2] = "" # 清除当前溢出的输入：history[-2] 是本次输入, history[-1] 是本次输出
                        history = clip_history(inputs=inputs, history=history, tokenizer=model_info[llm_kwargs['llm_model']]['tokenizer'], 
@@ -214,9 +215,13 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                    elif "does not exist" in error_msg:
                        chatbot[-1] = (chatbot[-1][0], f"[Local Message] Model {llm_kwargs['llm_model']} does not exist. 模型不存在, 或者您没有获得体验资格.")
                    elif "Incorrect API key" in error_msg:
-                        chatbot[-1] = (chatbot[-1][0], "[Local Message] Incorrect API key. OpenAI以提供了不正确的API_KEY为由, 拒绝服务.")
+                        chatbot[-1] = (chatbot[-1][0], "[Local Message] Incorrect API key. OpenAI以提供了不正确的API_KEY为由, 拒绝服务. " + openai_website)
                    elif "exceeded your current quota" in error_msg:
-                        chatbot[-1] = (chatbot[-1][0], "[Local Message] You exceeded your current quota. OpenAI以账户额度不足为由, 拒绝服务.")
+                        chatbot[-1] = (chatbot[-1][0], "[Local Message] You exceeded your current quota. OpenAI以账户额度不足为由, 拒绝服务." + openai_website)
+                    elif "account is not active" in error_msg:
+                        chatbot[-1] = (chatbot[-1][0], "[Local Message] Your account is not active. OpenAI以账户失效为由, 拒绝服务." + openai_website)
+                    elif "associated with a deactivated account" in error_msg:
+                        chatbot[-1] = (chatbot[-1][0], "[Local Message] You are associated with a deactivated account. OpenAI以账户失效为由, 拒绝服务." + openai_website)
                    elif "bad forward key" in error_msg:
                        chatbot[-1] = (chatbot[-1][0], "[Local Message] Bad forward key. API2D账户额度不足.")
                    elif "Not enough point" in error_msg:
@@ -241,6 +246,7 @@ def generate_payload(inputs, llm_kwargs, history, system_prompt, stream):
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
+    if API_ORG.startswith('org-'): headers.update({"OpenAI-Organization": API_ORG})

    conversation_cnt = len(history) // 2

--- a/request_llm/bridge_newbing.py
+++ b/request_llm/bridge_newbing.py
@@ -1,254 +0,0 @@
-"""
-========================================================================
-第一部分：来自EdgeGPT.py
-https://github.com/acheong08/EdgeGPT
-========================================================================
-"""
-from .edge_gpt import NewbingChatbot
-load_message = "等待NewBing响应。"
-
-"""
-========================================================================
-第二部分：子进程Worker（调用主体）
-========================================================================
-"""
-import time
-import json
-import re
-import logging
-import asyncio
-import importlib
-import threading
-from toolbox import update_ui, get_conf, trimmed_format_exc
-from multiprocessing import Process, Pipe
-
-def preprocess_newbing_out(s):
-    pattern = r'\^(\d+)\^' # 匹配^数字^
-    sub = lambda m: '('+m.group(1)+')' # 将匹配到的数字作为替换值
-    result = re.sub(pattern, sub, s) # 替换操作
-    if '[1]' in result:
-        result += '\n\n```reference\n' + "\n".join([r for r in result.split('\n') if r.startswith('[')]) + '\n```\n'
-    return result
-
-def preprocess_newbing_out_simple(result):
-    if '[1]' in result:
-        result += '\n\n```reference\n' + "\n".join([r for r in result.split('\n') if r.startswith('[')]) + '\n```\n'
-    return result
-
-class NewBingHandle(Process):
-    def __init__(self):
-        super().__init__(daemon=True)
-        self.parent, self.child = Pipe()
-        self.newbing_model = None
-        self.info = ""
-        self.success = True
-        self.local_history = []
-        self.check_dependency()
-        self.start()
-        self.threadLock = threading.Lock()
-        
-    def check_dependency(self):
-        try:
-            self.success = False
-            import certifi, httpx, rich
-            self.info = "依赖检测通过，等待NewBing响应。注意目前不能多人同时调用NewBing接口（有线程锁），否则将导致每个人的NewBing问询历史互相渗透。调用NewBing时，会自动使用已配置的代理。"
-            self.success = True
-        except:
-            self.info = "缺少的依赖，如果要使用Newbing，除了基础的pip依赖以外，您还需要运行`pip install -r request_llm/requirements_newbing.txt`安装Newbing的依赖。"
-            self.success = False
-
-    def ready(self):
-        return self.newbing_model is not None
-
-    async def async_run(self):
-        # 读取配置
-        NEWBING_STYLE, = get_conf('NEWBING_STYLE')
-        from request_llm.bridge_all import model_info
-        endpoint = model_info['newbing']['endpoint']
-        while True:
-            # 等待
-            kwargs = self.child.recv()
-            question=kwargs['query']
-            history=kwargs['history']
-            system_prompt=kwargs['system_prompt']
-
-            # 是否重置
-            if len(self.local_history) > 0 and len(history)==0:
-                await self.newbing_model.reset()
-                self.local_history = []
-
-            # 开始问问题
-            prompt = ""
-            if system_prompt not in self.local_history:
-                self.local_history.append(system_prompt)
-                prompt += system_prompt + '\n'
-
-            # 追加历史
-            for ab in history:
-                a, b = ab
-                if a not in self.local_history:
-                    self.local_history.append(a)
-                    prompt += a + '\n'
-                # if b not in self.local_history:
-                #     self.local_history.append(b)
-                #     prompt += b + '\n'
-
-            # 问题
-            prompt += question
-            self.local_history.append(question)
-            print('question:', prompt)
-            # 提交
-            async for final, response in self.newbing_model.ask_stream(
-                prompt=question,
-                conversation_style=NEWBING_STYLE,     # ["creative", "balanced", "precise"]
-                wss_link=endpoint,                      # "wss://sydney.bing.com/sydney/ChatHub"
-            ):
-                if not final:
-                    print(response)
-                    self.child.send(str(response))
-                else:
-                    print('-------- receive final ---------')
-                    self.child.send('[Finish]')
-                    # self.local_history.append(response)
-
-    
-    def run(self):
-        """
-        这个函数运行在子进程
-        """
-        # 第一次运行，加载参数
-        self.success = False
-        self.local_history = []
-        if (self.newbing_model is None) or (not self.success):
-            # 代理设置
-            proxies, = get_conf('proxies')
-            if proxies is None: 
-                self.proxies_https = None
-            else: 
-                self.proxies_https = proxies['https']
-            # cookie
-            NEWBING_COOKIES, = get_conf('NEWBING_COOKIES')
-            try:
-                cookies = json.loads(NEWBING_COOKIES)
-            except:
-                self.success = False
-                tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-                self.child.send(f'[Local Message] 不能加载Newbing组件。NEWBING_COOKIES未填写或有格式错误。')
-                self.child.send('[Fail]')
-                self.child.send('[Finish]')
-                raise RuntimeError(f"不能加载Newbing组件。NEWBING_COOKIES未填写或有格式错误。")
-
-            try:
-                self.newbing_model = NewbingChatbot(proxy=self.proxies_https, cookies=cookies)
-            except:
-                self.success = False
-                tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-                self.child.send(f'[Local Message] 不能加载Newbing组件。{tb_str}')
-                self.child.send('[Fail]')
-                self.child.send('[Finish]')
-                raise RuntimeError(f"不能加载Newbing组件。")
-
-        self.success = True
-        try:
-            # 进入任务等待状态
-            asyncio.run(self.async_run())
-        except Exception:
-            tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-            self.child.send(f'[Local Message] Newbing失败 {tb_str}.')
-            self.child.send('[Fail]')
-            self.child.send('[Finish]')
-        
-    def stream_chat(self, **kwargs):
-        """
-        这个函数运行在主进程
-        """
-        self.threadLock.acquire()
-        self.parent.send(kwargs)    # 发送请求到子进程
-        while True:
-            res = self.parent.recv()    # 等待newbing回复的片段
-            if res == '[Finish]':
-                break       # 结束
-            elif res == '[Fail]':
-                self.success = False
-                break
-            else:
-                yield res   # newbing回复的片段
-        self.threadLock.release()
-
-
-"""
-========================================================================
-第三部分：主进程统一调用函数接口
-========================================================================
-"""
-global newbing_handle
-newbing_handle = None
-
-def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=None, console_slience=False):
-    """
-        多线程方法
-        函数的说明请见 request_llm/bridge_all.py
-    """
-    global newbing_handle
-    if (newbing_handle is None) or (not newbing_handle.success):
-        newbing_handle = NewBingHandle()
-        observe_window[0] = load_message + "\n\n" + newbing_handle.info
-        if not newbing_handle.success: 
-            error = newbing_handle.info
-            newbing_handle = None
-            raise RuntimeError(error)
-
-    # 没有 sys_prompt 接口，因此把prompt加入 history
-    history_feedin = []
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]] )
-
-    watch_dog_patience = 5 # 看门狗 (watchdog) 的耐心, 设置5秒即可
-    response = ""
-    observe_window[0] = "[Local Message]: 等待NewBing响应中 ..."
-    for response in newbing_handle.stream_chat(query=inputs, history=history_feedin, system_prompt=sys_prompt, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
-        observe_window[0] = preprocess_newbing_out_simple(response)
-        if len(observe_window) >= 2:  
-            if (time.time()-observe_window[1]) > watch_dog_patience:
-                raise RuntimeError("程序终止。")
-    return preprocess_newbing_out_simple(response)
-
-def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream = True, additional_fn=None):
-    """
-        单线程方法
-        函数的说明请见 request_llm/bridge_all.py
-    """
-    chatbot.append((inputs, "[Local Message]: 等待NewBing响应中 ..."))
-
-    global newbing_handle
-    if (newbing_handle is None) or (not newbing_handle.success):
-        newbing_handle = NewBingHandle()
-        chatbot[-1] = (inputs, load_message + "\n\n" + newbing_handle.info)
-        yield from update_ui(chatbot=chatbot, history=[])
-        if not newbing_handle.success: 
-            newbing_handle = None
-            return
-
-    if additional_fn is not None:
-        import core_functional
-        importlib.reload(core_functional)    # 热更新prompt
-        core_functional = core_functional.get_core_functions()
-        if "PreProcess" in core_functional[additional_fn]: inputs = core_functional[additional_fn]["PreProcess"](inputs)  # 获取预处理函数（如果有的话）
-        inputs = core_functional[additional_fn]["Prefix"] + inputs + core_functional[additional_fn]["Suffix"]
-
-    history_feedin = []
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]] )
-
-    chatbot[-1] = (inputs, "[Local Message]: 等待NewBing响应中 ...")
-    response = "[Local Message]: 等待NewBing响应中 ..."
-    yield from update_ui(chatbot=chatbot, history=history, msg="NewBing响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。")
-    for response in newbing_handle.stream_chat(query=inputs, history=history_feedin, system_prompt=system_prompt, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
-        chatbot[-1] = (inputs, preprocess_newbing_out(response))
-        yield from update_ui(chatbot=chatbot, history=history, msg="NewBing响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。")
-    if response == "[Local Message]: 等待NewBing响应中 ...": response = "[Local Message]: NewBing响应异常，请刷新界面重试 ..."
-    history.extend([inputs, response])
-    logging.info(f'[raw_input] {inputs}')
-    logging.info(f'[response] {response}')
-    yield from update_ui(chatbot=chatbot, history=history, msg="完成全部响应，请提交新问题。")
-
--- a/request_llm/bridge_newbingfree.py
+++ b/request_llm/bridge_newbingfree.py
@@ -89,9 +89,6 @@ class NewBingHandle(Process):
                if a not in self.local_history:
                    self.local_history.append(a)
                    prompt += a + '\n'
-                # if b not in self.local_history:
-                #     self.local_history.append(b)
-                #     prompt += b + '\n'

            # 问题
            prompt += question
@@ -101,7 +98,7 @@ class NewBingHandle(Process):
            async for final, response in self.newbing_model.ask_stream(
                prompt=question,
                conversation_style=NEWBING_STYLE,     # ["creative", "balanced", "precise"]
-                wss_link=endpoint,                      # "wss://sydney.bing.com/sydney/ChatHub"
+                wss_link=endpoint,                    # "wss://sydney.bing.com/sydney/ChatHub"
            ):
                if not final:
                    print(response)
@@ -121,14 +118,26 @@ class NewBingHandle(Process):
        self.local_history = []
        if (self.newbing_model is None) or (not self.success):
            # 代理设置
-            proxies, = get_conf('proxies')
+            proxies, NEWBING_COOKIES = get_conf('proxies', 'NEWBING_COOKIES')
            if proxies is None: 
                self.proxies_https = None
            else: 
                self.proxies_https = proxies['https']

+            if (NEWBING_COOKIES is not None) and len(NEWBING_COOKIES) > 100:
+                try:
+                    cookies = json.loads(NEWBING_COOKIES)
+                except:
+                    self.success = False
+                    tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
+                    self.child.send(f'[Local Message] NEWBING_COOKIES未填写或有格式错误。')
+                    self.child.send('[Fail]'); self.child.send('[Finish]')
+                    raise RuntimeError(f"NEWBING_COOKIES未填写或有格式错误。")
+            else:
+                cookies = None
+
            try:
-                self.newbing_model = NewbingChatbot(proxy=self.proxies_https)
+                self.newbing_model = NewbingChatbot(proxy=self.proxies_https, cookies=cookies)
            except:
                self.success = False
                tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
@@ -143,7 +152,7 @@ class NewBingHandle(Process):
            asyncio.run(self.async_run())
        except Exception:
            tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-            self.child.send(f'[Local Message] Newbing失败 {tb_str}.')
+            self.child.send(f'[Local Message] Newbing 请求失败，报错信息如下. 如果是与网络相关的问题，建议更换代理协议（推荐http）或代理节点 {tb_str}.')
            self.child.send('[Fail]')
            self.child.send('[Finish]')
        
@@ -151,18 +160,14 @@ class NewBingHandle(Process):
        """
        这个函数运行在主进程
        """
-        self.threadLock.acquire()
-        self.parent.send(kwargs)    # 发送请求到子进程
+        self.threadLock.acquire()   # 获取线程锁
+        self.parent.send(kwargs)    # 请求子进程
        while True:
-            res = self.parent.recv()    # 等待newbing回复的片段
-            if res == '[Finish]':
-                break       # 结束
-            elif res == '[Fail]':
-                self.success = False
-                break
-            else:
-                yield res   # newbing回复的片段
-        self.threadLock.release()
+            res = self.parent.recv()                            # 等待newbing回复的片段
+            if res == '[Finish]': break                         # 结束
+            elif res == '[Fail]': self.success = False; break   # 失败
+            else: yield res                                     # newbing回复的片段
+        self.threadLock.release()   # 释放线程锁


 """
--- a/request_llm/bridge_stackclaude.py
+++ b/request_llm/bridge_stackclaude.py
@@ -1,4 +1,4 @@
-from .bridge_newbing import preprocess_newbing_out, preprocess_newbing_out_simple
+from .bridge_newbingfree import preprocess_newbing_out, preprocess_newbing_out_simple
 from multiprocessing import Process, Pipe
 from toolbox import update_ui, get_conf, trimmed_format_exc
 import threading
--- a/request_llm/edge_gpt.py
+++ b/request_llm/edge_gpt.py
@@ -1,409 +0,0 @@
-"""
-========================================================================
-第一部分：来自EdgeGPT.py
-https://github.com/acheong08/EdgeGPT
-========================================================================
-"""
-
-import argparse
-import asyncio
-import json
-import os
-import random
-import re
-import ssl
-import sys
-import uuid
-from enum import Enum
-from typing import Generator
-from typing import Literal
-from typing import Optional
-from typing import Union
-import websockets.client as websockets
-
-DELIMITER = "\x1e"
-
-
-# Generate random IP between range 13.104.0.0/14
-FORWARDED_IP = (
-    f"13.{random.randint(104, 107)}.{random.randint(0, 255)}.{random.randint(0, 255)}"
-)
-
-HEADERS = {
-    "accept": "application/json",
-    "accept-language": "en-US,en;q=0.9",
-    "content-type": "application/json",
-    "sec-ch-ua": '"Not_A Brand";v="99", "Microsoft Edge";v="110", "Chromium";v="110"',
-    "sec-ch-ua-arch": '"x86"',
-    "sec-ch-ua-bitness": '"64"',
-    "sec-ch-ua-full-version": '"109.0.1518.78"',
-    "sec-ch-ua-full-version-list": '"Chromium";v="110.0.5481.192", "Not A(Brand";v="24.0.0.0", "Microsoft Edge";v="110.0.1587.69"',
-    "sec-ch-ua-mobile": "?0",
-    "sec-ch-ua-model": "",
-    "sec-ch-ua-platform": '"Windows"',
-    "sec-ch-ua-platform-version": '"15.0.0"',
-    "sec-fetch-dest": "empty",
-    "sec-fetch-mode": "cors",
-    "sec-fetch-site": "same-origin",
-    "x-ms-client-request-id": str(uuid.uuid4()),
-    "x-ms-useragent": "azsdk-js-api-client-factory/1.0.0-beta.1 core-rest-pipeline/1.10.0 OS/Win32",
-    "Referer": "https://www.bing.com/search?q=Bing+AI&showconv=1&FORM=hpcodx",
-    "Referrer-Policy": "origin-when-cross-origin",
-    "x-forwarded-for": FORWARDED_IP,
-}
-
-HEADERS_INIT_CONVER = {
-    "authority": "edgeservices.bing.com",
-    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-    "accept-language": "en-US,en;q=0.9",
-    "cache-control": "max-age=0",
-    "sec-ch-ua": '"Chromium";v="110", "Not A(Brand";v="24", "Microsoft Edge";v="110"',
-    "sec-ch-ua-arch": '"x86"',
-    "sec-ch-ua-bitness": '"64"',
-    "sec-ch-ua-full-version": '"110.0.1587.69"',
-    "sec-ch-ua-full-version-list": '"Chromium";v="110.0.5481.192", "Not A(Brand";v="24.0.0.0", "Microsoft Edge";v="110.0.1587.69"',
-    "sec-ch-ua-mobile": "?0",
-    "sec-ch-ua-model": '""',
-    "sec-ch-ua-platform": '"Windows"',
-    "sec-ch-ua-platform-version": '"15.0.0"',
-    "sec-fetch-dest": "document",
-    "sec-fetch-mode": "navigate",
-    "sec-fetch-site": "none",
-    "sec-fetch-user": "?1",
-    "upgrade-insecure-requests": "1",
-    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36 Edg/110.0.1587.69",
-    "x-edge-shopping-flag": "1",
-    "x-forwarded-for": FORWARDED_IP,
-}
-
-def get_ssl_context():
-    import certifi
-    ssl_context = ssl.create_default_context()
-    ssl_context.load_verify_locations(certifi.where())
-    return ssl_context
-
-
-
-class NotAllowedToAccess(Exception):
-    pass
-
-
-class ConversationStyle(Enum):
-    creative = "h3imaginative,clgalileo,gencontentv3"
-    balanced = "galileo"
-    precise = "h3precise,clgalileo"
-
-
-CONVERSATION_STYLE_TYPE = Optional[
-    Union[ConversationStyle, Literal["creative", "balanced", "precise"]]
-]
-
-
-def _append_identifier(msg: dict) -> str:
-    """
-    Appends special character to end of message to identify end of message
-    """
-    # Convert dict to json string
-    return json.dumps(msg) + DELIMITER
-
-
-def _get_ran_hex(length: int = 32) -> str:
-    """
-    Returns random hex string
-    """
-    return "".join(random.choice("0123456789abcdef") for _ in range(length))
-
-
-class _ChatHubRequest:
-    """
-    Request object for ChatHub
-    """
-
-    def __init__(
-        self,
-        conversation_signature: str,
-        client_id: str,
-        conversation_id: str,
-        invocation_id: int = 0,
-    ) -> None:
-        self.struct: dict = {}
-
-        self.client_id: str = client_id
-        self.conversation_id: str = conversation_id
-        self.conversation_signature: str = conversation_signature
-        self.invocation_id: int = invocation_id
-
-    def update(
-        self,
-        prompt,
-        conversation_style,
-        options,
-    ) -> None:
-        """
-        Updates request object
-        """
-        if options is None:
-            options = [
-                "deepleo",
-                "enable_debug_commands",
-                "disable_emoji_spoken_text",
-                "enablemm",
-            ]
-        if conversation_style:
-            if not isinstance(conversation_style, ConversationStyle):
-                conversation_style = getattr(ConversationStyle, conversation_style)
-            options = [
-                "nlu_direct_response_filter",
-                "deepleo",
-                "disable_emoji_spoken_text",
-                "responsible_ai_policy_235",
-                "enablemm",
-                conversation_style.value,
-                "dtappid",
-                "cricinfo",
-                "cricinfov2",
-                "dv3sugg",
-            ]
-        self.struct = {
-            "arguments": [
-                {
-                    "source": "cib",
-                    "optionsSets": options,
-                    "sliceIds": [
-                        "222dtappid",
-                        "225cricinfo",
-                        "224locals0",
-                    ],
-                    "traceId": _get_ran_hex(32),
-                    "isStartOfSession": self.invocation_id == 0,
-                    "message": {
-                        "author": "user",
-                        "inputMethod": "Keyboard",
-                        "text": prompt,
-                        "messageType": "Chat",
-                    },
-                    "conversationSignature": self.conversation_signature,
-                    "participant": {
-                        "id": self.client_id,
-                    },
-                    "conversationId": self.conversation_id,
-                },
-            ],
-            "invocationId": str(self.invocation_id),
-            "target": "chat",
-            "type": 4,
-        }
-        self.invocation_id += 1
-
-
-class _Conversation:
-    """
-    Conversation API
-    """
-
-    def __init__(
-        self,
-        cookies,
-        proxy,
-    ) -> None:
-        self.struct: dict = {
-            "conversationId": None,
-            "clientId": None,
-            "conversationSignature": None,
-            "result": {"value": "Success", "message": None},
-        }
-        import httpx
-        self.proxy = proxy
-        proxy = (
-            proxy
-            or os.environ.get("all_proxy")
-            or os.environ.get("ALL_PROXY")
-            or os.environ.get("https_proxy")
-            or os.environ.get("HTTPS_PROXY")
-            or None
-        )
-        if proxy is not None and proxy.startswith("socks5h://"):
-            proxy = "socks5://" + proxy[len("socks5h://") :]
-        self.session = httpx.Client(
-            proxies=proxy,
-            timeout=30,
-            headers=HEADERS_INIT_CONVER,
-        )
-        for cookie in cookies:
-            self.session.cookies.set(cookie["name"], cookie["value"])
-
-        # Send GET request
-        response = self.session.get(
-            url=os.environ.get("BING_PROXY_URL")
-            or "https://edgeservices.bing.com/edgesvc/turing/conversation/create",
-        )
-        if response.status_code != 200:
-            response = self.session.get(
-                "https://edge.churchless.tech/edgesvc/turing/conversation/create",
-            )
-        if response.status_code != 200:
-            print(f"Status code: {response.status_code}")
-            print(response.text)
-            print(response.url)
-            raise Exception("Authentication failed")
-        try:
-            self.struct = response.json()
-        except (json.decoder.JSONDecodeError, NotAllowedToAccess) as exc:
-            raise Exception(
-                "Authentication failed. You have not been accepted into the beta.",
-            ) from exc
-        if self.struct["result"]["value"] == "UnauthorizedRequest":
-            raise NotAllowedToAccess(self.struct["result"]["message"])
-
-
-class _ChatHub:
-    """
-    Chat API
-    """
-
-    def __init__(self, conversation) -> None:
-        self.wss = None
-        self.request: _ChatHubRequest
-        self.loop: bool
-        self.task: asyncio.Task
-        print(conversation.struct)
-        self.request = _ChatHubRequest(
-            conversation_signature=conversation.struct["conversationSignature"],
-            client_id=conversation.struct["clientId"],
-            conversation_id=conversation.struct["conversationId"],
-        )
-
-    async def ask_stream(
-        self,
-        prompt: str,
-        wss_link: str,
-        conversation_style: CONVERSATION_STYLE_TYPE = None,
-        raw: bool = False,
-        options: dict = None,
-    ) -> Generator[str, None, None]:
-        """
-        Ask a question to the bot
-        """
-        if self.wss and not self.wss.closed:
-            await self.wss.close()
-        # Check if websocket is closed
-        self.wss = await websockets.connect(
-            wss_link,
-            extra_headers=HEADERS,
-            max_size=None,
-            ssl=get_ssl_context()
-        )
-        await self._initial_handshake()
-        # Construct a ChatHub request
-        self.request.update(
-            prompt=prompt,
-            conversation_style=conversation_style,
-            options=options,
-        )
-        # Send request
-        await self.wss.send(_append_identifier(self.request.struct))
-        final = False
-        while not final:
-            objects = str(await self.wss.recv()).split(DELIMITER)
-            for obj in objects:
-                if obj is None or not obj:
-                    continue
-                response = json.loads(obj)
-                if response.get("type") != 2 and raw:
-                    yield False, response
-                elif response.get("type") == 1 and response["arguments"][0].get(
-                    "messages",
-                ):
-                    resp_txt = response["arguments"][0]["messages"][0]["adaptiveCards"][
-                        0
-                    ]["body"][0].get("text")
-                    yield False, resp_txt
-                elif response.get("type") == 2:
-                    final = True
-                    yield True, response
-
-    async def _initial_handshake(self) -> None:
-        await self.wss.send(_append_identifier({"protocol": "json", "version": 1}))
-        await self.wss.recv()
-
-    async def close(self) -> None:
-        """
-        Close the connection
-        """
-        if self.wss and not self.wss.closed:
-            await self.wss.close()
-
-
-class NewbingChatbot:
-    """
-    Combines everything to make it seamless
-    """
-
-    def __init__(
-        self,
-        cookies,
-        proxy
-    ) -> None:
-        if cookies is None:
-            cookies = {}
-        self.cookies = cookies
-        self.proxy = proxy
-        self.chat_hub: _ChatHub = _ChatHub(
-            _Conversation(self.cookies, self.proxy),
-        )
-
-    async def ask(
-        self,
-        prompt: str,
-        wss_link: str,
-        conversation_style: CONVERSATION_STYLE_TYPE = None,
-        options: dict = None,
-    ) -> dict:
-        """
-        Ask a question to the bot
-        """
-        async for final, response in self.chat_hub.ask_stream(
-            prompt=prompt,
-            conversation_style=conversation_style,
-            wss_link=wss_link,
-            options=options,
-        ):
-            if final:
-                return response
-        await self.chat_hub.wss.close()
-        return None
-
-    async def ask_stream(
-        self,
-        prompt: str,
-        wss_link: str,
-        conversation_style: CONVERSATION_STYLE_TYPE = None,
-        raw: bool = False,
-        options: dict = None,
-    ) -> Generator[str, None, None]:
-        """
-        Ask a question to the bot
-        """
-        async for response in self.chat_hub.ask_stream(
-            prompt=prompt,
-            conversation_style=conversation_style,
-            wss_link=wss_link,
-            raw=raw,
-            options=options,
-        ):
-            yield response
-
-    async def close(self) -> None:
-        """
-        Close the connection
-        """
-        await self.chat_hub.close()
-
-    async def reset(self) -> None:
-        """
-        Reset the conversation
-        """
-        await self.close()
-        self.chat_hub = _ChatHub(_Conversation(self.cookies, self.proxy))
-
-
--- a/toolbox.py
+++ b/toolbox.py
@@ -498,7 +498,7 @@ def on_report_generated(cookies, files, chatbot):
    else:
        report_files = find_recent_files('gpt_log')
    if len(report_files) == 0:
-        return None, chatbot
+        return cookies, None, chatbot
    # files.extend(report_files)
    file_links = ''
    for f in report_files: file_links += f'<br/><a href="file={os.path.abspath(f)}" target="_blank">{f}</a>'
--- a/4
+++ b/4
@@ -1,5 +1,5 @@
 {
-  "version": 3.41,
+  "version": 3.43,
  "show_feature": true,
-  "new_feature": "增加gpt-3.5-16k的支持 <-> 新增最强Arxiv论文翻译插件 <-> 修复gradio复制按钮BUG <-> 修复PDF翻译的BUG, 新增HTML中英双栏对照 <-> 添加了OpenAI图片生成插件 <-> 添加了OpenAI音频转文本总结插件 <-> 通过Slack添加对Claude的支持"
+  "new_feature": "修复Azure接口的BUG <-> 完善多语言模块 <-> 完善本地Latex矫错和翻译功能 <-> 增加gpt-3.5-16k的支持 <-> 新增最强Arxiv论文翻译插件 <-> 修复gradio复制按钮BUG <-> 修复PDF翻译的BUG, 新增HTML中英双栏对照 <-> 添加了OpenAI图片生成插件"
 }
作者	SHA1	备注	提交日期
qingxu fu	eabd9d312f	3.43	2023-07-07 10:47:30 +08:00
qingxu fu	0da6fe78ac	统一azure-gpt-3.5的格式	2023-07-07 10:45:11 +08:00
qingxu fu	be990380a0	Merge branch 'master' of https://github.com/binary-husky/chatgpt_academic into master	2023-07-07 10:42:41 +08:00
qingxu fu	9c0bc48420	修复Azure OpenAI接口的各种bug	2023-07-07 10:42:38 +08:00
binary-husky	37fc550652	Update config.py	2023-07-06 10:47:06 +08:00
binary-husky	2c1d6ac212	修复Organization的bug	2023-07-05 21:14:13 +08:00
binary-husky	8c699c1b26	Update README.md	2023-07-05 21:04:28 +08:00
binary-husky	c620fa9011	Update README.md	2023-07-05 20:55:59 +08:00
binary-husky	f16fd60211	Update README.md	2023-07-05 20:34:22 +08:00
binary-husky	9674e59d26	更新说明	2023-07-05 20:22:57 +08:00
binary-husky	643c5e125a	更新提醒	2023-07-05 20:10:18 +08:00
binary-husky	e5099e1daa	极少数情况下，openai的官方KEY需要伴随组织编码	2023-07-05 20:05:20 +08:00
binary-husky	3e621bbec1	Update Dockerfile	2023-07-05 14:37:54 +08:00
qingxu fu	bb1d5a61c0	update translation matrix	2023-07-05 14:32:33 +08:00
binary-husky	fd3d0be2d8	Update config.py	2023-07-05 14:13:04 +08:00
binary-husky	ae623258f3	更详细的配置提示	2023-07-05 14:10:06 +08:00
binary-husky	cda281f08b	把newbing的cookie加回来	2023-07-05 13:48:50 +08:00
binary-husky	9f8e7a6efa	显示更详细的报错	2023-07-05 13:35:11 +08:00
qingxu fu	57643dd2b6	update error msg	2023-07-05 13:01:06 +08:00
qingxu fu	6bc8a78cfe	No more cookie for NewBing!	2023-07-05 12:45:10 +08:00
binary-husky	d2700e97fb	更新openai失效提醒	2023-07-05 11:03:11 +08:00
binary-husky	c4dd81dc9a	Update Dockerfile	2023-07-04 12:28:52 +08:00
binary-husky	e9b06d7cde	Merge pull request #927 from QuantumRoseinAmethystVase/master Update 批量总结PDF文档.py	2023-07-04 12:24:17 +08:00
qingxu fu	6e6ea69611	Unsplash恢复了	2023-07-04 12:16:01 +08:00
QuantumRoseinAmethystVase	16c17eb077	Update 批量总结PDF文档.py Improve the output.	2023-07-03 18:55:16 +08:00
kainstan	59877dd728	Local variable 'result' might be referenced before assignment, add else result	2023-07-01 22:27:11 +08:00
w_xiaolizu	5f7ffef238	增加基础功能判空	2023-07-01 22:04:42 +08:00
qingxu fu	41c10f5688	report image generation error in UI	2023-07-01 02:28:32 +08:00
qingxu fu	d7ac99f603	更正错误提示	2023-07-01 01:46:43 +08:00
qingxu fu	1616daae6a	Merge branch 'master' of https://github.com/binary-husky/chatgpt_academic into master	2023-07-01 00:17:30 +08:00
qingxu fu	a1092d8f92	提供自动清空输入框的选项	2023-07-01 00:17:26 +08:00
binary-husky	34ca9f138f	Merge branch 'master' of github.com:binary-husky/chatgpt_academic	2023-06-30 14:56:28 +08:00
binary-husky	df3f1aa3ca	更正ChatGLM2的默认Token数量	2023-06-30 14:56:22 +08:00
qingxu fu	bf805cf477	Merge branch 'master' of https://github.com/binary-husky/chatgpt_academic into master	2023-06-30 13:09:51 +08:00
qingxu fu	ecb08e69be	remove find picture core functionality	2023-06-30 13:08:54 +08:00
binary-husky	28c1e3f11b	Merge branch 'master' of github.com:binary-husky/chatgpt_academic	2023-06-30 12:06:33 +08:00
binary-husky	403667aec1	upgrade chatglm to chatglm2	2023-06-30 12:06:28 +08:00
qingxu fu	22f377e2fb	fix multi user cwd shift	2023-06-30 11:05:47 +08:00
binary-husky	37172906ef	修复文件导出的bug	2023-06-29 14:55:55 +08:00
binary-husky	3b78e0538b	修复插件demo的图像显示的问题	2023-06-29 14:52:58 +08:00
binary-husky	d8f9ac71d0	Merge pull request #907 from Xminry/master feat:联网搜索功能，cn.bing.com版，国内可用	2023-06-29 12:44:32 +08:00
qingxu fu	aced272d3c	微调插件提示	2023-06-29 12:43:50 +08:00
qingxu fu	aff77a086d	Merge branch 'master' of https://github.com/Xminry/gpt_academic into Xminry-master	2023-06-29 12:38:43 +08:00
qingxu fu	49253c4dc6	[arxiv trans] add html comparison to zip file	2023-06-29 12:29:49 +08:00
qingxu fu	1a00093015	修复提示	2023-06-29 12:15:52 +08:00
qingxu fu	64f76e7401	3.42	2023-06-29 11:32:19 +08:00
qingxu fu	eb4c07997e	修复Latex矫错和本地Latex论文翻译的问题	2023-06-29 11:30:42 +08:00
Xminry	99cf7205c3	feat:联网搜索功能，cn.bing.com版，国内可用	2023-06-28 10:30:08 +08:00
binary-husky	d684b4cdb3	Merge pull request #905 from Xminry/master Update 理解PDF文档内容.py	2023-06-27 23:37:25 +08:00
Xminry	4290821a50	Update 理解PDF文档内容.py	2023-06-27 01:57:31 +08:00