fix minor bugs

插件分区新增插件分类选择

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -11,6 +11,8 @@ body:
         - Please choose | 请选择
         - Pip Install (I ignored requirements.txt)
         - Pip Install (I used latest requirements.txt)
+        - OneKeyInstall (一键安装脚本-windows)
+        - OneKeyInstall (一键安装脚本-mac)
         - Anaconda (I ignored requirements.txt)
         - Anaconda (I used latest requirements.txt)
         - Docker（Windows/Mac）

.github/workflows/build-with-audio-assistant.yml

@@ -0,0 +1,44 @@
+# https://docs.github.com/en/actions/publishing-packages/publishing-docker-images#publishing-images-to-github-packages
+name: build-with-audio-assistant
+
+on:
+  push:
+    branches:
+      - 'master'
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}_audio_assistant
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          file: docs/GithubAction+NoLocal+AudioAssistant
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.gitignore

@@ -151,3 +151,4 @@ multi-language
 request_llm/moss
 media
 flagged
+request_llm/ChatGLM-6b-onnx-u8s8

README.md

@@ -16,7 +16,7 @@ To translate this project to arbitary language with GPT, read and run [`multi_la
 >
 > 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)。
+> 2.本项目中每个文件的功能都在[自译解报告`self_analysis.md`](https://github.com/binary-husky/gpt_academic/wiki/GPT‐Academic项目自译解报告)详细说明。随着版本的迭代，您也可以随时自行点击相关函数插件，调用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和Moss等等。支持多个api-key共存，可在配置文件中填写如`API_KEY="openai-key1,openai-key2,azure-key3,api2d-key4"`。需要临时更换`API_KEY`时，在输入区输入临时的`API_KEY`然后回车键提交后即可生效。
 
@@ -27,6 +27,7 @@ To translate this project to arbitary language with GPT, read and run [`multi_la
 
 功能（⭐= 近期新增功能） | 描述
 --- | ---
+⭐[接入新模型](https://github.com/binary-husky/gpt_academic/wiki/%E5%A6%82%E4%BD%95%E5%88%87%E6%8D%A2%E6%A8%A1%E5%9E%8B)！ | 百度[千帆](https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Nlks5zkzu)与文心一言, [通义千问](https://modelscope.cn/models/qwen/Qwen-7B-Chat/summary)，上海AI-Lab[书生](https://github.com/InternLM/InternLM)，讯飞[星火](https://xinghuo.xfyun.cn/)，[LLaMa2](https://huggingface.co/meta-llama/Llama-2-7b-chat-hf)
 一键润色 | 支持一键润色、一键查找论文语法错误
 一键中英互译 | 一键中英互译
 一键代码解释 | 显示代码、解释代码、生成代码、给代码加注释
@@ -52,8 +53,8 @@ Latex论文一键校对 | [函数插件] 仿Grammarly对Latex文章进行语法
 [多LLM模型](https://www.bilibili.com/video/BV1wT411p7yf)支持 | 同时被GPT3.5、GPT4、[清华ChatGLM2](https://github.com/THUDM/ChatGLM2-6B)、[复旦MOSS](https://github.com/OpenLMLab/MOSS)同时伺候的感觉一定会很不错吧？
 ⭐ChatGLM2微调模型 | 支持加载ChatGLM2微调模型，提供ChatGLM2微调辅助插件
 更多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/)
+⭐[虚空终端](https://github.com/binary-husky/void-terminal)pip包 | 脱离GUI，在Python中直接调用本项目的函数插件（开发中）
 更多新功能展示 (图像生成等) …… | 见本文档结尾处 ……
-
 </div>
 
 
@@ -101,7 +102,7 @@ cd gpt_academic
 
 在`config.py`中，配置API KEY等设置，[点击查看特殊网络环境设置方法](https://github.com/binary-husky/gpt_academic/issues/1) 。
 
-(P.S. 程序运行时会优先检查是否存在名为`config_private.py`的私密配置文件，并用其中的配置覆盖`config.py`的同名配置。因此，如果您能理解我们的配置读取逻辑，我们强烈建议您在`config.py`旁边创建一个名为`config_private.py`的新配置文件，并把`config.py`中的配置转移（复制）到`config_private.py`中。`config_private.py`不受git管控，可以让您的隐私信息更加安全。P.S.项目同样支持通过`环境变量`配置大多数选项，环境变量的书写格式参考`docker-compose`文件。读取优先级: `环境变量` > `config_private.py` > `config.py`)
+(P.S. 程序运行时会优先检查是否存在名为`config_private.py`的私密配置文件，并用其中的配置覆盖`config.py`的同名配置。因此，如果您能理解我们的配置读取逻辑，我们强烈建议您在`config.py`旁边创建一个名为`config_private.py`的新配置文件，并把`config.py`中的配置转移（复制）到`config_private.py`中（仅复制您修改过的配置条目即可）。`config_private.py`不受git管控，可以让您的隐私信息更加安全。P.S.项目同样支持通过`环境变量`配置大多数选项，环境变量的书写格式参考`docker-compose`文件。读取优先级: `环境变量` > `config_private.py` > `config.py`)
 
 
 3. 安装依赖
@@ -116,7 +117,7 @@ python -m pip install -r requirements.txt # 这个步骤和pip安装一样的步
 ```
 
 
-<details><summary>如果需要支持清华ChatGLM2/复旦MOSS作为后端，请点击展开此处</summary>
+<details><summary>如果需要支持清华ChatGLM2/复旦MOSS/RWKV作为后端，请点击展开此处</summary>
 <p>
 
 【可选步骤】如果需要支持清华ChatGLM2/复旦MOSS作为后端，需要额外安装更多依赖（前提条件：熟悉Python + 用过Pytorch + 电脑配置够强）：
@@ -128,7 +129,10 @@ python -m pip install -r request_llm/requirements_chatglm.txt
 python -m pip install -r request_llm/requirements_moss.txt
 git clone --depth=1 https://github.com/OpenLMLab/MOSS.git request_llm/moss  # 注意执行此行代码时，必须处于项目根路径
 
-# 【可选步骤III】确保config.py配置文件的AVAIL_LLM_MODELS包含了期望的模型，目前支持的全部模型如下(jittorllms系列目前仅支持docker方案)：
+# 【可选步骤III】支持RWKV Runner
+参考wiki：https://github.com/binary-husky/gpt_academic/wiki/%E9%80%82%E9%85%8DRWKV-Runner
+
+# 【可选步骤IV】确保config.py配置文件的AVAIL_LLM_MODELS包含了期望的模型，目前支持的全部模型如下(jittorllms系列目前仅支持docker方案)：
 AVAIL_LLM_MODELS = ["gpt-3.5-turbo", "api2d-gpt-3.5-turbo", "gpt-4", "api2d-gpt-4", "chatglm", "newbing", "moss"] # + ["jittorllms_rwkv", "jittorllms_pangualpha", "jittorllms_llama"]
 ```
 
@@ -147,6 +151,7 @@ python main.py
 1. 仅ChatGPT（推荐大多数人选择，等价于docker-compose方案1）
 [![basic](https://github.com/binary-husky/gpt_academic/actions/workflows/build-without-local-llms.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-without-local-llms.yml)
 [![basiclatex](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-latex.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-latex.yml)
+[![basicaudio](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-audio-assistant.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-audio-assistant.yml)
 
 ``` sh
 git clone --depth=1 https://github.com/binary-husky/gpt_academic.git  # 下载项目
@@ -161,7 +166,7 @@ docker run --rm -it -e WEB_PORT=50923 -p 50923:50923 gpt-academic
 ```
 P.S. 如果需要依赖Latex的插件功能，请见Wiki。另外，您也可以直接使用docker-compose获取Latex功能（修改docker-compose.yml，保留方案4并删除其他方案）。
 
-2. ChatGPT + ChatGLM2 + MOSS（需要熟悉Docker）
+2. ChatGPT + ChatGLM2 + MOSS + LLAMA2 + 通义千问（需要熟悉[Nvidia Docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#installing-on-ubuntu-and-debian)运行时）
 [![chatglm](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-chatglm.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-chatglm.yml)
 
 ``` sh
@@ -169,7 +174,7 @@ P.S. 如果需要依赖Latex的插件功能，请见Wiki。另外，您也可以
 docker-compose up
 ```
 
-3. ChatGPT + LLAMA + 盘古 + RWKV（需要熟悉Docker）
+3. ChatGPT + LLAMA + 盘古 + RWKV（需要熟悉[Nvidia Docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#installing-on-ubuntu-and-debian)运行时）
 [![jittorllms](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-jittorllms.yml/badge.svg?branch=master)](https://github.com/binary-husky/gpt_academic/actions/workflows/build-with-jittorllms.yml)
 
 ``` sh
@@ -195,10 +200,12 @@ docker-compose up
 5. 远程云服务器部署（需要云服务器知识与经验）。
 请访问[部署wiki-1](https://github.com/binary-husky/gpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
 
-6. 使用WSL2（Windows Subsystem for Linux 子系统）。
+6. 使用Sealos[一键部署](https://github.com/binary-husky/gpt_academic/issues/993)。
+
+7. 使用WSL2（Windows Subsystem for Linux 子系统）。
 请访问[部署wiki-2](https://github.com/binary-husky/gpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
 
-7. 如何在二级网址（如`http://localhost/subpath`）下运行。
+8. 如何在二级网址（如`http://localhost/subpath`）下运行。
 请访问[FastAPI运行说明](docs/WithFastapi.md)
 
 
@@ -286,10 +293,17 @@ Tip：不指定文件直接点击 `载入对话历史存档` 可以查看历史h
 <img src="https://github.com/binary-husky/gpt_academic/assets/96192199/476f66d9-7716-4537-b5c1-735372c25adb" height="200">
 </div>
 
+11. 语言、主题切换
+<div align="center">
+<img src="https://github.com/binary-husky/gpt_academic/assets/96192199/b6799499-b6fb-4f0c-9c8e-1b441872f4e8" width="500" >
+</div>
 
 
 ### II：版本:
-- version 3.5(Todo): 使用自然语言调用本项目的所有函数插件（高优先级）
+- version 3.60（todo）: 优化虚空终端，引入code interpreter和更多插件
+- version 3.50: 使用自然语言调用本项目的所有函数插件（虚空终端），支持插件分类，改进UI，设计新主题
+- version 3.49: 支持百度千帆平台和文心一言
+- version 3.48: 支持阿里达摩院通义千问，上海AI-Lab书生，讯飞星火
 - version 3.46: 支持完全脱手操作的实时语音对话
 - version 3.45: 支持自定义ChatGLM2微调模型
 - version 3.44: 正式支持Azure，优化界面易用性

check_proxy.py

@@ -3,15 +3,18 @@ def check_proxy(proxies):
     import requests
     proxies_https = proxies['https'] if proxies is not None else '无'
     try:
-        response = requests.get("https://ipapi.co/json/",
-                                proxies=proxies, timeout=4)
+        response = requests.get("https://ipapi.co/json/", proxies=proxies, timeout=4)
         data = response.json()
         print(f'查询代理的地理位置，返回的结果是{data}')
         if 'country_name' in data:
             country = data['country_name']
             result = f"代理配置 {proxies_https}, 代理所在地：{country}"
         elif 'error' in data:
-            result = f"代理配置 {proxies_https}, 代理所在地：未知，IP查询频率受限"
+            alternative = _check_with_backup_source(proxies)
+            if alternative is None:
+                result = f"代理配置 {proxies_https}, 代理所在地：未知，IP查询频率受限"
+            else:
+                result = f"代理配置 {proxies_https}, 代理所在地：{alternative}"
         else:
             result = f"代理配置 {proxies_https}, 代理数据解析失败：{data}"
         print(result)
@@ -21,6 +24,11 @@ def check_proxy(proxies):
         print(result)
         return result
 
+def _check_with_backup_source(proxies):
+    import random, string, requests
+    random_string = ''.join(random.choices(string.ascii_letters + string.digits, k=32))
+    try: return requests.get(f"http://{random_string}.edns.ip-api.com/json", proxies=proxies, timeout=4).json()['dns']['geo']
+    except: return None
 
 def backup_and_download(current_version, remote_version):
     """

config.py

@@ -11,7 +11,7 @@
 API_KEY = "此处填API密钥"    # 可同时填写多个API-KEY，用英文逗号分割，例如API_KEY = "sk-openaikey1,sk-openaikey2,fkxxxx-api2dkey3,azure-apikey4"
 
 
-# [step 2]>> 改为True应用代理，如果直接在海外服务器部署，此处不修改
+# [step 2]>> 改为True应用代理，如果直接在海外服务器部署，此处不修改；如果使用本地或无地域限制的大模型时，此处也不需要修改
 USE_PROXY = False
 if USE_PROXY:
     """
@@ -43,7 +43,11 @@ API_URL_REDIRECT = {}
 DEFAULT_WORKER_NUM = 3
 
 
-# 对话窗的高度
+# 色彩主题，可选 ["Default", "Chuanhu-Small-and-Beautiful", "High-Contrast"]
+THEME = "Default"
+
+
+# 对话窗的高度 （仅在LAYOUT="TOP-DOWN"时生效）
 CHATBOT_HEIGHT = 1115
 
 
@@ -68,14 +72,26 @@ WEB_PORT = -1
 MAX_RETRY = 2
 
 
+# 插件分类默认选项
+DEFAULT_FN_GROUPS = ['对话', '编程', '学术']
+
+
 # 模型选择是 (注意: LLM_MODEL是默认选中的模型, 它*必须*被包含在AVAIL_LLM_MODELS列表中 )
 LLM_MODEL = "gpt-3.5-turbo" # 可选 ↓↓↓
-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", "claude-1-100k", "claude-2", "internlm", "jittorllms_rwkv", "jittorllms_pangualpha", "jittorllms_llama"]
+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. 其他可用的模型还包括 ["qianfan", "llama2", "qwen", "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k-0613", 
+# "spark", "sparkv2", "chatglm_onnx", "claude-1-100k", "claude-2", "internlm", "jittorllms_pangualpha", "jittorllms_llama"]
 
 
-# ChatGLM(2) Finetune Model Path （如果使用ChatGLM2微调模型，需要把"chatglmft"加入AVAIL_LLM_MODELS中）
-ChatGLM_PTUNING_CHECKPOINT = "" # 例如"/home/hmp/ChatGLM2-6B/ptuning/output/6b-pt-128-1e-2/checkpoint-100"
+# 百度千帆（LLM_MODEL="qianfan"）
+BAIDU_CLOUD_API_KEY = ''
+BAIDU_CLOUD_SECRET_KEY = ''
+BAIDU_CLOUD_QIANFAN_MODEL = 'ERNIE-Bot'    # 可选 "ERNIE-Bot"(文心一言), "ERNIE-Bot-turbo", "BLOOMZ-7B", "Llama-2-70B-Chat", "Llama-2-13B-Chat", "Llama-2-7B-Chat"
+
+
+# 如果使用ChatGLM2微调模型，请把 LLM_MODEL="chatglmft"，并在此处指定模型路径
+CHATGLM_PTUNING_CHECKPOINT = "" # 例如"/home/hmp/ChatGLM2-6B/ptuning/output/6b-pt-128-1e-2/checkpoint-100"
 
 
 # 本地LLM模型如ChatGLM的执行方式 CPU/GPU
@@ -91,10 +107,6 @@ CONCURRENT_COUNT = 100
 AUTO_CLEAR_TXT = False
 
 
-# 色彩主体，可选 ["Default", "Chuanhu-Small-and-Beautiful"]
-THEME = "Default"
-
-
 # 加一个live2d装饰
 ADD_WAIFU = False
 
@@ -132,8 +144,16 @@ put your new bing cookies here
 
 # 阿里云实时语音识别 配置难度较高 仅建议高手用户使用 参考 https://github.com/binary-husky/gpt_academic/blob/master/docs/use_audio.md
 ENABLE_AUDIO = False
-ALIYUN_TOKEN=""    # 例如 f37f30e0f9934c34a992f6f64f7eba4f
-ALIYUN_APPKEY=""   # 例如 RoPlZrM88DnAFkZK
+ALIYUN_TOKEN=""     # 例如 f37f30e0f9934c34a992f6f64f7eba4f
+ALIYUN_APPKEY=""    # 例如 RoPlZrM88DnAFkZK
+ALIYUN_ACCESSKEY="" # （无需填写）
+ALIYUN_SECRET=""    # （无需填写）
+
+
+# 接入讯飞星火大模型 https://console.xfyun.cn/services/iat
+XFYUN_APPID = "00000000"
+XFYUN_API_SECRET = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+XFYUN_API_KEY = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
 
 
 # Claude API KEY
@@ -141,4 +161,86 @@ ANTHROPIC_API_KEY = ""
 
 
 # 自定义API KEY格式
-CUSTOM_API_KEY_PATTERN = ""
+CUSTOM_API_KEY_PATTERN = ""
+
+
+# HUGGINGFACE的TOKEN，下载LLAMA时起作用 https://huggingface.co/docs/hub/security-tokens
+HUGGINGFACE_ACCESS_TOKEN = "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"
+
+
+# GROBID服务器地址（填写多个可以均衡负载），用于高质量地读取PDF文档
+# 获取方法：复制以下空间https://huggingface.co/spaces/qingxu98/grobid，设为public，然后GROBID_URL = "https://(你的hf用户名如qingxu98)-(你的填写的空间名如grobid).hf.space"
+GROBID_URLS = [
+    "https://qingxu98-grobid.hf.space","https://qingxu98-grobid2.hf.space","https://qingxu98-grobid3.hf.space",
+    "https://shaocongma-grobid.hf.space","https://FBR123-grobid.hf.space", "https://yeku-grobid.hf.space", 
+]
+
+
+# 是否允许通过自然语言描述修改本页的配置，该功能具有一定的危险性，默认关闭
+ALLOW_RESET_CONFIG = False
+
+
+"""
+在线大模型配置关联关系示意图
+│
+├── "gpt-3.5-turbo" 等openai模型
+│   ├── API_KEY
+│   ├── CUSTOM_API_KEY_PATTERN（不常用）
+│   ├── API_ORG（不常用）
+│   └── API_URL_REDIRECT（不常用）
+│
+├── "azure-gpt-3.5" 等azure模型
+│   ├── API_KEY
+│   ├── AZURE_ENDPOINT
+│   ├── AZURE_API_KEY
+│   ├── AZURE_ENGINE
+│   └── API_URL_REDIRECT
+│
+├── "spark" 星火认知大模型 spark & sparkv2
+│   ├── XFYUN_APPID
+│   ├── XFYUN_API_SECRET
+│   └── XFYUN_API_KEY
+│
+├── "claude-1-100k" 等claude模型
+│   └── ANTHROPIC_API_KEY
+│
+├── "stack-claude"
+│   ├── SLACK_CLAUDE_BOT_ID
+│   └── SLACK_CLAUDE_USER_TOKEN
+│
+├── "qianfan" 百度千帆大模型库
+│   ├── BAIDU_CLOUD_QIANFAN_MODEL
+│   ├── BAIDU_CLOUD_API_KEY
+│   └── BAIDU_CLOUD_SECRET_KEY
+│
+├── "newbing" Newbing接口不再稳定，不推荐使用
+    ├── NEWBING_STYLE
+    └── NEWBING_COOKIES
+
+    
+用户图形界面布局依赖关系示意图
+│
+├── CHATBOT_HEIGHT 对话窗的高度
+├── CODE_HIGHLIGHT 代码高亮
+├── LAYOUT 窗口布局
+├── DARK_MODE 暗色模式 / 亮色模式
+├── DEFAULT_FN_GROUPS 插件分类默认选项
+├── THEME 色彩主题
+├── AUTO_CLEAR_TXT 是否在提交时自动清空输入框
+├── ADD_WAIFU 加一个live2d装饰
+├── ALLOW_RESET_CONFIG 是否允许通过自然语言描述修改本页的配置，该功能具有一定的危险性
+
+
+插件在线服务配置依赖关系示意图
+│
+├── 语音功能
+│   ├── ENABLE_AUDIO
+│   ├── ALIYUN_TOKEN
+│   ├── ALIYUN_APPKEY
+│   ├── ALIYUN_ACCESSKEY
+│   └── ALIYUN_SECRET
+│
+├── PDF文档精准解析
+│   └── GROBID_URLS
+
+"""

core_functional.py

@@ -1,20 +1,25 @@
 # 'primary' 颜色对应 theme.py 中的 primary_hue
 # 'secondary' 颜色对应 theme.py 中的 neutral_hue
 # 'stop' 颜色对应 theme.py 中的 color_er
-# 默认按钮颜色是 secondary
+import importlib
 from toolbox import clear_line_break
 
 
 def get_core_functions():
     return {
         "英语学术润色": {
-            # 前言
+            # 前缀，会被加在你的输入之前。例如，用来描述你的要求，例如翻译、解释代码、润色等等
             "Prefix":   r"Below is a paragraph from an academic paper. Polish the writing to meet the academic style, " +
                         r"improve the spelling, grammar, clarity, concision and overall readability. When necessary, rewrite the whole sentence. " +
                         r"Furthermore, list all modification and explain the reasons to do so in markdown table." + "\n\n",
-            # 后语
+            # 后缀，会被加在你的输入之后。例如，配合前缀可以把你的输入内容用引号圈起来
             "Suffix":   r"",
-            "Color":    r"secondary",    # 按钮颜色
+            # 按钮颜色 (默认 secondary)
+            "Color":    r"secondary",
+            # 按钮是否可见 (默认 True，即可见)
+            "Visible": True,
+            # 是否在触发时清除历史 (默认 False，即不处理之前的对话历史)
+            "AutoClearHistory": False
         },
         "中文学术润色": {
             "Prefix":   r"作为一名中文学术论文写作改进助理，你的任务是改进所提供文本的拼写、语法、清晰、简洁和整体可读性，" +
@@ -58,6 +63,7 @@ def get_core_functions():
         "英译中": {
             "Prefix":   r"翻译成地道的中文：" + "\n\n",
             "Suffix":   r"",
+            "Visible": False,
         },
         "找图片": {
             "Prefix":   r"我需要你找一张网络图片。使用Unsplash API(https://source.unsplash.com/960x640/?<英语关键词>)获取图片URL，" +
@@ -73,6 +79,18 @@ def get_core_functions():
             "Prefix":   r"Here are some bibliography items, please transform them into bibtex style." +
                         r"Note that, reference styles maybe more than one kind, you should transform each item correctly." +
                         r"Items need to be transformed:",
+            "Visible": False,
             "Suffix":   r"",
         }
     }
+
+
+def handle_core_functionality(additional_fn, inputs, history, chatbot):
+    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"]
+    if core_functional[additional_fn].get("AutoClearHistory", False):
+        history = []
+    return inputs, history

crazy_functional.py

@@ -2,7 +2,6 @@ from toolbox import HotReload  # HotReload 的意思是热更新，修改函数
 
 
 def get_crazy_functions():
-    ###################### 第一组插件 ###########################
     from crazy_functions.读文章写摘要 import 读文章写摘要
     from crazy_functions.生成函数注释 import 批量生成函数注释
     from crazy_functions.解析项目源代码 import 解析项目本身
@@ -24,109 +23,9 @@ def get_crazy_functions():
     from crazy_functions.对话历史存档 import 对话历史存档
     from crazy_functions.对话历史存档 import 载入对话历史存档
     from crazy_functions.对话历史存档 import 删除所有本地对话历史记录
-    
+    from crazy_functions.辅助功能 import 清除缓存
     from crazy_functions.批量Markdown翻译 import Markdown英译中
-    function_plugins = {
-        "解析整个Python项目": {
-            "Color": "stop",    # 按钮颜色
-            "Function": HotReload(解析一个Python项目)
-        },
-        "载入对话历史存档（先上传存档或输入路径）": {
-            "Color": "stop",
-            "AsButton":False,
-            "Function": HotReload(载入对话历史存档)
-        },
-        "删除所有本地对话历史记录（请谨慎操作）": {
-            "AsButton":False,
-            "Function": HotReload(删除所有本地对话历史记录)
-        },
-        "[测试功能] 解析Jupyter Notebook文件": {
-            "Color": "stop",
-            "AsButton":False,
-            "Function": HotReload(解析ipynb文件),
-            "AdvancedArgs": True, # 调用时，唤起高级参数输入区（默认False）
-            "ArgsReminder": "若输入0，则不解析notebook中的Markdown块", # 高级参数输入区的显示提示
-        },
-        "批量总结Word文档": {
-            "Color": "stop",
-            "Function": HotReload(总结word文档)
-        },
-        "解析整个C++项目头文件": {
-            "Color": "stop",    # 按钮颜色
-            "AsButton": False,  # 加入下拉菜单中
-            "Function": HotReload(解析一个C项目的头文件)
-        },
-        "解析整个C++项目（.cpp/.hpp/.c/.h）": {
-            "Color": "stop",    # 按钮颜色
-            "AsButton": False,  # 加入下拉菜单中
-            "Function": HotReload(解析一个C项目)
-        },
-        "解析整个Go项目": {
-            "Color": "stop",    # 按钮颜色
-            "AsButton": False,  # 加入下拉菜单中
-            "Function": HotReload(解析一个Golang项目)
-        },
-        "解析整个Rust项目": {
-            "Color": "stop",    # 按钮颜色
-            "AsButton": False,  # 加入下拉菜单中
-            "Function": HotReload(解析一个Rust项目)
-        },
-        "解析整个Java项目": {
-            "Color": "stop",  # 按钮颜色
-            "AsButton": False,  # 加入下拉菜单中
-            "Function": HotReload(解析一个Java项目)
-        },
-        "解析整个前端项目（js,ts,css等）": {
-            "Color": "stop",  # 按钮颜色
-            "AsButton": False,  # 加入下拉菜单中
-            "Function": HotReload(解析一个前端项目)
-        },
-        "解析整个Lua项目": {
-            "Color": "stop",    # 按钮颜色
-            "AsButton": False,  # 加入下拉菜单中
-            "Function": HotReload(解析一个Lua项目)
-        },
-        "解析整个CSharp项目": {
-            "Color": "stop",    # 按钮颜色
-            "AsButton": False,  # 加入下拉菜单中
-            "Function": HotReload(解析一个CSharp项目)
-        },
-        "读Tex论文写摘要": {
-            "Color": "stop",    # 按钮颜色
-            "Function": HotReload(读文章写摘要)
-        },
-        "Markdown/Readme英译中": {
-            # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
-            "Color": "stop",
-            "Function": HotReload(Markdown英译中)
-        },
-        "批量生成函数注释": {
-            "Color": "stop",    # 按钮颜色
-            "AsButton": False,  # 加入下拉菜单中
-            "Function": HotReload(批量生成函数注释)
-        },
-        "保存当前的对话": {
-            "Function": HotReload(对话历史存档)
-        },
-        "[多线程Demo] 解析此项目本身（源码自译解）": {
-            "AsButton": False,  # 加入下拉菜单中
-            "Function": HotReload(解析项目本身)
-        },
-        # "[老旧的Demo] 把本项目源代码切换成全英文": {
-        #     # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
-        #     "AsButton": False,  # 加入下拉菜单中
-        #     "Function": HotReload(全项目切换英文)
-        # },
-        "[插件demo] 历史上的今天": {
-            # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
-            "Function": HotReload(高阶功能模板函数)
-        },
-
-    }
-    ###################### 第二组插件 ###########################
-    # [第二组插件]: 经过充分测试
     from crazy_functions.批量总结PDF文档 import 批量总结PDF文档
-    # from crazy_functions.批量总结PDF文档pdfminer import 批量总结PDF文档pdfminer
     from crazy_functions.批量翻译PDF文档_多线程 import 批量翻译PDF文档
     from crazy_functions.谷歌检索小助手 import 谷歌检索小助手
     from crazy_functions.理解PDF文档内容 import 理解PDF文档内容标准文件输入
@@ -135,88 +34,248 @@ def get_crazy_functions():
     from crazy_functions.Latex全文翻译 import Latex中译英
     from crazy_functions.Latex全文翻译 import Latex英译中
     from crazy_functions.批量Markdown翻译 import Markdown中译英
+    from crazy_functions.虚空终端 import 虚空终端
 
-    function_plugins.update({
-        "批量翻译PDF文档（多线程）": {
+
+    function_plugins = {
+        "虚空终端": {
+            "Group": "对话|编程|学术",
             "Color": "stop",
-            "AsButton": True,  # 加入下拉菜单中
+            "AsButton": True,
+            "Function": HotReload(虚空终端)
+        },
+        "解析整个Python项目": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": True,
+            "Info": "解析一个Python项目的所有源文件(.py) | 输入参数为路径",
+            "Function": HotReload(解析一个Python项目)
+        },
+        "载入对话历史存档（先上传存档或输入路径）": {
+            "Group": "对话",
+            "Color": "stop",
+            "AsButton": False,
+            "Info": "载入对话历史存档 | 输入参数为路径",
+            "Function": HotReload(载入对话历史存档)
+        },
+        "删除所有本地对话历史记录（谨慎操作）": {
+            "Group": "对话",
+            "AsButton": False,
+            "Info": "删除所有本地对话历史记录，谨慎操作 | 不需要输入参数",
+            "Function": HotReload(删除所有本地对话历史记录)
+        },
+        "清除所有缓存文件（谨慎操作）": {
+            "Group": "对话",
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "清除所有缓存文件，谨慎操作 | 不需要输入参数",
+            "Function": HotReload(清除缓存)
+        },
+        "批量总结Word文档": {
+            "Group": "学术",
+            "Color": "stop",
+            "AsButton": True,
+            "Info": "批量总结word文档 | 输入参数为路径",
+            "Function": HotReload(总结word文档)
+        },
+        "解析整个C++项目头文件": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "解析一个C++项目的所有头文件(.h/.hpp) | 输入参数为路径",
+            "Function": HotReload(解析一个C项目的头文件)
+        },
+        "解析整个C++项目（.cpp/.hpp/.c/.h）": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "解析一个C++项目的所有源文件（.cpp/.hpp/.c/.h）| 输入参数为路径",
+            "Function": HotReload(解析一个C项目)
+        },
+        "解析整个Go项目": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "解析一个Go项目的所有源文件 | 输入参数为路径",
+            "Function": HotReload(解析一个Golang项目)
+        },
+        "解析整个Rust项目": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "解析一个Rust项目的所有源文件 | 输入参数为路径",
+            "Function": HotReload(解析一个Rust项目)
+        },
+        "解析整个Java项目": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "解析一个Java项目的所有源文件 | 输入参数为路径",
+            "Function": HotReload(解析一个Java项目)
+        },
+        "解析整个前端项目（js,ts,css等）": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "解析一个前端项目的所有源文件（js,ts,css等） | 输入参数为路径",
+            "Function": HotReload(解析一个前端项目)
+        },
+        "解析整个Lua项目": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "解析一个Lua项目的所有源文件 | 输入参数为路径",
+            "Function": HotReload(解析一个Lua项目)
+        },
+        "解析整个CSharp项目": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "解析一个CSharp项目的所有源文件 | 输入参数为路径",
+            "Function": HotReload(解析一个CSharp项目)
+        },
+        "解析Jupyter Notebook文件": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,
+            "Info": "解析Jupyter Notebook文件 | 输入参数为路径",
+            "Function": HotReload(解析ipynb文件),
+            "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+            "ArgsReminder": "若输入0，则不解析notebook中的Markdown块",  # 高级参数输入区的显示提示
+        },
+        "读Tex论文写摘要": {
+            "Group": "学术",
+            "Color": "stop",
+            "AsButton": False,
+            "Info": "读取Tex论文并写摘要 | 输入参数为路径",
+            "Function": HotReload(读文章写摘要)
+        },
+        "翻译README或MD": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": True,
+            "Info": "将Markdown翻译为中文 | 输入参数为路径或URL",
+            "Function": HotReload(Markdown英译中)
+        },
+        "翻译Markdown或README（支持Github链接）": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,
+            "Info": "将Markdown或README翻译为中文 | 输入参数为路径或URL",
+            "Function": HotReload(Markdown英译中)
+        },
+        "批量生成函数注释": {
+            "Group": "编程",
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "批量生成函数的注释 | 输入参数为路径",
+            "Function": HotReload(批量生成函数注释)
+        },
+        "保存当前的对话": {
+            "Group": "对话",
+            "AsButton": True,
+            "Info": "保存当前的对话 | 不需要输入参数",
+            "Function": HotReload(对话历史存档)
+        },
+        "[多线程Demo]解析此项目本身（源码自译解）": {
+            "Group": "对话|编程",
+            "AsButton": False,  # 加入下拉菜单中
+            "Info": "多线程解析并翻译此项目的源码 | 不需要输入参数",
+            "Function": HotReload(解析项目本身)
+        },
+        "[插件demo]历史上的今天": {
+            "Group": "对话",
+            "AsButton": True,
+            "Info": "查看历史上的今天事件 | 不需要输入参数",
+            "Function": HotReload(高阶功能模板函数)
+        },
+        "精准翻译PDF论文": {
+            "Group": "学术",
+            "Color": "stop",
+            "AsButton": True,  
+            "Info": "精准翻译PDF论文为中文 | 输入参数为路径",
             "Function": HotReload(批量翻译PDF文档)
         },
         "询问多个GPT模型": {
-            "Color": "stop",    # 按钮颜色
+            "Group": "对话",
+            "Color": "stop",
+            "AsButton": True,
             "Function": HotReload(同时问询)
         },
-        "[测试功能] 批量总结PDF文档": {
+        "批量总结PDF文档": {
+            "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
-            # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
+            "Info": "批量总结PDF文档的内容 | 输入参数为路径",
             "Function": HotReload(批量总结PDF文档)
         },
-        # "[测试功能] 批量总结PDF文档pdfminer": {
-        #     "Color": "stop",
-        #     "AsButton": False,  # 加入下拉菜单中
-        #     "Function": HotReload(批量总结PDF文档pdfminer)
-        # },
         "谷歌学术检索助手（输入谷歌学术搜索页url）": {
+            "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
+            "Info": "使用谷歌学术检索助手搜索指定URL的结果 | 输入参数为谷歌学术搜索页的URL",
             "Function": HotReload(谷歌检索小助手)
         },
         "理解PDF文档内容 （模仿ChatPDF）": {
-            # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
+            "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
+            "Info": "理解PDF文档的内容并进行回答 | 输入参数为路径",
             "Function": HotReload(理解PDF文档内容标准文件输入)
         },
         "英文Latex项目全文润色（输入路径或上传压缩包）": {
-            # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
+            "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
+            "Info": "对英文Latex项目全文进行润色处理 | 输入参数为路径或上传压缩包",
             "Function": HotReload(Latex英文润色)
         },
         "英文Latex项目全文纠错（输入路径或上传压缩包）": {
-            # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
+            "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
+            "Info": "对英文Latex项目全文进行纠错处理 | 输入参数为路径或上传压缩包",
             "Function": HotReload(Latex英文纠错)
         },
         "中文Latex项目全文润色（输入路径或上传压缩包）": {
-            # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
+            "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
+            "Info": "对中文Latex项目全文进行润色处理 | 输入参数为路径或上传压缩包",
             "Function": HotReload(Latex中文润色)
         },
         "Latex项目全文中译英（输入路径或上传压缩包）": {
-            # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
+            "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
+            "Info": "对Latex项目全文进行中译英处理 | 输入参数为路径或上传压缩包",
             "Function": HotReload(Latex中译英)
         },
         "Latex项目全文英译中（输入路径或上传压缩包）": {
-            # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
+            "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
+            "Info": "对Latex项目全文进行英译中处理 | 输入参数为路径或上传压缩包",
             "Function": HotReload(Latex英译中)
         },
         "批量Markdown中译英（输入路径或上传压缩包）": {
-            # HotReload 的意思是热更新，修改函数插件代码后，不需要重启程序，代码直接生效
+            "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
+            "Info": "批量将Markdown文件中文翻译为英文 | 输入参数为路径或上传压缩包",
             "Function": HotReload(Markdown中译英)
         },
+    }
 
-
-    })
-
-    ###################### 第三组插件 ###########################
-    # [第三组插件]: 尚未充分测试的函数插件
-
+    # -=--=- 尚未充分测试的实验性插件 & 需要额外依赖的插件 -=--=-
     try:
         from crazy_functions.下载arxiv论文翻译摘要 import 下载arxiv论文并翻译摘要
         function_plugins.update({
             "一键下载arxiv论文并翻译摘要（先在input输入编号，如1812.10695）": {
+                "Group": "学术",
                 "Color": "stop",
                 "AsButton": False,  # 加入下拉菜单中
+                # "Info": "下载arxiv论文并翻译摘要 | 输入参数为arxiv编号如1812.10695",
                 "Function": HotReload(下载arxiv论文并翻译摘要)
             }
         })
@@ -227,16 +286,20 @@ def get_crazy_functions():
         from crazy_functions.联网的ChatGPT import 连接网络回答问题
         function_plugins.update({
             "连接网络回答问题（输入问题后点击该插件，需要访问谷歌）": {
+                "Group": "对话",
                 "Color": "stop",
                 "AsButton": False,  # 加入下拉菜单中
+                # "Info": "连接网络回答问题（需要访问谷歌）| 输入参数是一个问题",
                 "Function": HotReload(连接网络回答问题)
             }
         })
         from crazy_functions.联网的ChatGPT_bing版 import 连接bing搜索回答问题
         function_plugins.update({
             "连接网络回答问题（中文Bing版，输入问题后点击该插件）": {
+                "Group": "对话",
                 "Color": "stop",
                 "AsButton": False,  # 加入下拉菜单中
+                "Info": "连接网络回答问题（需要访问中文Bing）| 输入参数是一个问题",
                 "Function": HotReload(连接bing搜索回答问题)
             }
         })
@@ -247,10 +310,11 @@ def get_crazy_functions():
         from crazy_functions.解析项目源代码 import 解析任意code项目
         function_plugins.update({
             "解析项目源代码（手动指定和筛选源代码文件类型）": {
+                "Group": "编程",
                 "Color": "stop",
                 "AsButton": False,
-                "AdvancedArgs": True, # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "输入时用逗号隔开, *代表通配符, 加了^代表不匹配; 不输入代表全部匹配。例如: \"*.c, ^*.cpp, config.toml, ^*.toml\"", # 高级参数输入区的显示提示
+                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                "ArgsReminder": "输入时用逗号隔开, *代表通配符, 加了^代表不匹配; 不输入代表全部匹配。例如: \"*.c, ^*.cpp, config.toml, ^*.toml\"",  # 高级参数输入区的显示提示
                 "Function": HotReload(解析任意code项目)
             },
         })
@@ -261,10 +325,11 @@ def get_crazy_functions():
         from crazy_functions.询问多个大语言模型 import 同时问询_指定模型
         function_plugins.update({
             "询问多个GPT模型（手动指定询问哪些模型）": {
+                "Group": "对话",
                 "Color": "stop",
                 "AsButton": False,
-                "AdvancedArgs": True, # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "支持任意数量的llm接口，用&符号分隔。例如chatglm&gpt-3.5-turbo&api2d-gpt-4", # 高级参数输入区的显示提示
+                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                "ArgsReminder": "支持任意数量的llm接口，用&符号分隔。例如chatglm&gpt-3.5-turbo&api2d-gpt-4",  # 高级参数输入区的显示提示
                 "Function": HotReload(同时问询_指定模型)
             },
         })
@@ -275,10 +340,12 @@ def get_crazy_functions():
         from crazy_functions.图片生成 import 图片生成
         function_plugins.update({
             "图片生成（先切换模型到openai或api2d）": {
+                "Group": "对话",
                 "Color": "stop",
                 "AsButton": False,
-                "AdvancedArgs": True, # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "在这里输入分辨率, 如256x256（默认）", # 高级参数输入区的显示提示
+                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                "ArgsReminder": "在这里输入分辨率, 如256x256（默认）",  # 高级参数输入区的显示提示
+                "Info": "图片生成 | 输入参数字符串，提供图像的内容",
                 "Function": HotReload(图片生成)
             },
         })
@@ -289,10 +356,12 @@ def get_crazy_functions():
         from crazy_functions.总结音视频 import 总结音视频
         function_plugins.update({
             "批量总结音视频（输入路径或上传压缩包）": {
+                "Group": "对话",
                 "Color": "stop",
                 "AsButton": False,
                 "AdvancedArgs": True,
                 "ArgsReminder": "调用openai api 使用whisper-1模型, 目前支持的格式:mp4, m4a, wav, mpga, mpeg, mp3。此处可以输入解析提示，例如：解析为简体中文（默认）。",
+                "Info": "批量总结音频或视频 | 输入参数为路径",
                 "Function": HotReload(总结音视频)
             }
         })
@@ -303,8 +372,10 @@ def get_crazy_functions():
         from crazy_functions.数学动画生成manim import 动画生成
         function_plugins.update({
             "数学动画生成（Manim）": {
+                "Group": "对话",
                 "Color": "stop",
                 "AsButton": False,
+                "Info": "按照自然语言描述生成一个动画 | 输入参数是一段话",
                 "Function": HotReload(动画生成)
             }
         })
@@ -315,6 +386,7 @@ def get_crazy_functions():
         from crazy_functions.批量Markdown翻译 import Markdown翻译指定语言
         function_plugins.update({
             "Markdown翻译（手动指定语言）": {
+                "Group": "编程",
                 "Color": "stop",
                 "AsButton": False,
                 "AdvancedArgs": True,
@@ -328,7 +400,8 @@ def get_crazy_functions():
     try:
         from crazy_functions.Langchain知识库 import 知识库问答
         function_plugins.update({
-            "[功能尚不稳定] 构建知识库（请先上传文件素材）": {
+            "构建知识库（请先上传文件素材）": {
+                "Group": "对话",
                 "Color": "stop",
                 "AsButton": False,
                 "AdvancedArgs": True,
@@ -342,7 +415,8 @@ def get_crazy_functions():
     try:
         from crazy_functions.Langchain知识库 import 读取知识库作答
         function_plugins.update({
-            "[功能尚不稳定] 知识库问答": {
+            "知识库问答": {
+                "Group": "对话",
                 "Color": "stop",
                 "AsButton": False,
                 "AdvancedArgs": True,
@@ -352,11 +426,12 @@ def get_crazy_functions():
         })
     except:
         print('Load function plugin failed')
-        
+
     try:
         from crazy_functions.交互功能函数模板 import 交互功能模板函数
         function_plugins.update({
             "交互功能模板函数": {
+                "Group": "对话",
                 "Color": "stop",
                 "AsButton": False,
                 "Function": HotReload(交互功能模板函数)
@@ -365,6 +440,68 @@ def get_crazy_functions():
     except:
         print('Load function plugin failed')
 
+    try:
+        from crazy_functions.Latex输出PDF结果 import Latex英文纠错加PDF对比
+        function_plugins.update({
+            "Latex英文纠错+高亮修正位置 [需Latex]": {
+                "Group": "学术",
+                "Color": "stop",
+                "AsButton": False,
+                "AdvancedArgs": True,
+                "ArgsReminder": "如果有必要, 请在此处追加更细致的矫错指令（使用英文）。",
+                "Function": HotReload(Latex英文纠错加PDF对比)
+            }
+        })
+        from crazy_functions.Latex输出PDF结果 import Latex翻译中文并重新编译PDF
+        function_plugins.update({
+            "Arixv论文精细翻译（输入arxivID）[需Latex]": {
+                "Group": "学术",
+                "Color": "stop",
+                "AsButton": False,
+                "AdvancedArgs": True,
+                "ArgsReminder":
+                    "如果有必要, 请在此处给出自定义翻译命令, 解决部分词汇翻译不准确的问题。 " +
+                    "例如当单词'agent'翻译不准确时, 请尝试把以下指令复制到高级参数区: " +
+                    'If the term "agent" is used in this section, it should be translated to "智能体". ',
+                "Info": "Arixv论文精细翻译 | 输入参数arxiv论文的ID，比如1812.10695",
+                "Function": HotReload(Latex翻译中文并重新编译PDF)
+            }
+        })
+        function_plugins.update({
+            "本地Latex论文精细翻译（上传Latex项目）[需Latex]": {
+                "Group": "学术",
+                "Color": "stop",
+                "AsButton": False,
+                "AdvancedArgs": True,
+                "ArgsReminder":
+                    "如果有必要, 请在此处给出自定义翻译命令, 解决部分词汇翻译不准确的问题。 " +
+                    "例如当单词'agent'翻译不准确时, 请尝试把以下指令复制到高级参数区: " +
+                    'If the term "agent" is used in this section, it should be translated to "智能体". ',
+                "Info": "本地Latex论文精细翻译 | 输入参数是路径",
+                "Function": HotReload(Latex翻译中文并重新编译PDF)
+            }
+        })
+    except:
+        print('Load function plugin failed')
+
+    try:
+        from toolbox import get_conf
+        ENABLE_AUDIO, = get_conf('ENABLE_AUDIO')
+        if ENABLE_AUDIO:
+            from crazy_functions.语音助手 import 语音助手
+            function_plugins.update({
+                "实时音频采集": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": True,
+                    "Info": "开始语言对话 | 没有输入参数",
+                    "Function": HotReload(语音助手)
+                }
+            })
+    except:
+        print('Load function plugin failed')
+
+
     # try:
     #     from crazy_functions.chatglm微调工具 import 微调数据集生成
     #     function_plugins.update({
@@ -379,71 +516,23 @@ def get_crazy_functions():
     # except:
     #     print('Load function plugin failed')
 
-    try:
-        from crazy_functions.Latex输出PDF结果 import Latex英文纠错加PDF对比
-        function_plugins.update({
-            "Latex英文纠错+高亮修正位置 [需Latex]": {
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder": "如果有必要, 请在此处追加更细致的矫错指令（使用英文）。",
-                "Function": HotReload(Latex英文纠错加PDF对比)
-            }
-        })
-        from crazy_functions.Latex输出PDF结果 import Latex翻译中文并重新编译PDF
-        function_plugins.update({
-            "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项目）[需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')
 
 
-    try:
-        from toolbox import get_conf
-        ENABLE_AUDIO, = get_conf('ENABLE_AUDIO')
-        if ENABLE_AUDIO:
-            from crazy_functions.语音助手 import 语音助手
-            function_plugins.update({
-                "实时音频采集": {
-                    "Color": "stop",
-                    "AsButton": True,
-                    "Function": HotReload(语音助手)
-                }
-            })
-    except:
-        print('Load function plugin failed')
-        
-    # try:
-    #     from crazy_functions.虚空终端 import 终端
-    #     function_plugins.update({
-    #         "超级终端": {
-    #             "Color": "stop",
-    #             "AsButton": False,
-    #             # "AdvancedArgs": True,
-    #             # "ArgsReminder": "",
-    #             "Function": HotReload(终端)
-    #         }
-    #     })
-    # except:
-    #     print('Load function plugin failed')
+    """
+    设置默认值:
+    - 默认 Group = 对话
+    - 默认 AsButton = True
+    - 默认 AdvancedArgs = False
+    - 默认 Color = secondary
+    """
+    for name, function_meta in function_plugins.items():
+        if "Group" not in function_meta:
+            function_plugins[name]["Group"] = '对话'
+        if "AsButton" not in function_meta:
+            function_plugins[name]["AsButton"] = True
+        if "AdvancedArgs" not in function_meta:
+            function_plugins[name]["AdvancedArgs"] = False
+        if "Color" not in function_meta:
+            function_plugins[name]["Color"] = 'secondary'
 
     return function_plugins

crazy_functions/Latex输出PDF结果.py

@@ -6,7 +6,7 @@ pj = os.path.join
 ARXIV_CACHE_DIR = os.path.expanduser(f"~/arxiv_cache/")
 
 # =================================== 工具函数 ===============================================
-专业词汇声明  = 'If the term "agent" is used in this section, it should be translated to "智能体". '
+# 专业词汇声明  = 'If the term "agent" is used in this section, it should be translated to "智能体". '
 def switch_prompt(pfg, mode, more_requirement):
     """
     Generate prompts and system prompts based on the mode for proofreading or translating.
@@ -291,7 +291,7 @@ def Latex翻译中文并重新编译PDF(txt, llm_kwargs, plugin_kwargs, chatbot,
         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区, 用该压缩包+对话历史存档进行反馈 ...'))
+        chatbot.append((f"失败了", '虽然PDF生成失败了, 但请查收结果（压缩包）, 内含已经翻译的Tex文档, 您可以到Github Issue区, 用该压缩包进行反馈。如系统是Linux，请检查系统字体（见Github wiki） ...'))
         yield from update_ui(chatbot=chatbot, history=history); time.sleep(1) # 刷新界面
         promote_file_to_downloadzone(file=zip_res, chatbot=chatbot)
 

crazy_functions/crazy_functions_test.py

@@ -1,249 +0,0 @@
-"""
-这是什么？
-    这个文件用于函数插件的单元测试
-    运行方法 python crazy_functions/crazy_functions_test.py
-"""
-    
-# ==============================================================================================================================
-
-def validate_path():
-    import os, sys
-    dir_name = os.path.dirname(__file__)
-    root_dir_assume = os.path.abspath(os.path.dirname(__file__) +  '/..')
-    os.chdir(root_dir_assume)
-    sys.path.append(root_dir_assume)
-validate_path() # validate path so you can run from base directory
-
-# ==============================================================================================================================
-
-from colorful import *
-from toolbox import get_conf, ChatBotWithCookies
-import contextlib
-import os
-import sys
-from functools import wraps
-proxies, WEB_PORT, LLM_MODEL, CONCURRENT_COUNT, AUTHENTICATION, CHATBOT_HEIGHT, LAYOUT, API_KEY = \
-    get_conf('proxies', 'WEB_PORT', 'LLM_MODEL', 'CONCURRENT_COUNT', 'AUTHENTICATION', 'CHATBOT_HEIGHT', 'LAYOUT', 'API_KEY')
-
-llm_kwargs = {
-    'api_key': API_KEY,
-    'llm_model': LLM_MODEL,
-    'top_p':1.0, 
-    'max_length': None,
-    'temperature':1.0,
-}
-plugin_kwargs = { }
-chatbot = ChatBotWithCookies(llm_kwargs)
-history = []
-system_prompt = "Serve me as a writing and programming assistant."
-web_port = 1024
-
-# ==============================================================================================================================
-
-def silence_stdout(func):
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        _original_stdout = sys.stdout
-        sys.stdout = open(os.devnull, 'w')
-        for q in func(*args, **kwargs):
-            sys.stdout = _original_stdout
-            yield q
-            sys.stdout = open(os.devnull, 'w')
-        sys.stdout.close()
-        sys.stdout = _original_stdout
-    return wrapper
-
-class CLI_Printer():
-    def __init__(self) -> None:
-        self.pre_buf = ""
-
-    def print(self, buf):
-        bufp = ""
-        for index, chat in enumerate(buf):
-            a, b = chat
-            bufp += sprint亮靛('[Me]:' + a) + '\n'
-            bufp += '[GPT]:' + b
-            if index < len(buf)-1: 
-                bufp += '\n'
-
-        if self.pre_buf!="" and bufp.startswith(self.pre_buf):
-            print(bufp[len(self.pre_buf):], end='')
-        else:
-            print('\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'+bufp, end='')
-        self.pre_buf = bufp
-        return
-    
-cli_printer = CLI_Printer()
-# ==============================================================================================================================
-def test_解析一个Python项目():
-    from crazy_functions.解析项目源代码 import 解析一个Python项目
-    txt = "crazy_functions/test_project/python/dqn"
-    for cookies, cb, hist, msg in 解析一个Python项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        print(cb)
-
-def test_解析一个Cpp项目():
-    from crazy_functions.解析项目源代码 import 解析一个C项目
-    txt = "crazy_functions/test_project/cpp/cppipc"
-    for cookies, cb, hist, msg in 解析一个C项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        print(cb)
-
-def test_Latex英文润色():
-    from crazy_functions.Latex全文润色 import Latex英文润色
-    txt = "crazy_functions/test_project/latex/attention"
-    for cookies, cb, hist, msg in Latex英文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        print(cb)
-
-def test_Markdown中译英():
-    from crazy_functions.批量Markdown翻译 import Markdown中译英
-    txt = "README.md"
-    for cookies, cb, hist, msg in Markdown中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        print(cb)
-
-def test_批量翻译PDF文档():
-    from crazy_functions.批量翻译PDF文档_多线程 import 批量翻译PDF文档
-    txt = "crazy_functions/test_project/pdf_and_word"
-    for cookies, cb, hist, msg in 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        print(cb)
-
-def test_谷歌检索小助手():
-    from crazy_functions.谷歌检索小助手 import 谷歌检索小助手
-    txt = "https://scholar.google.com/scholar?hl=en&as_sdt=0%2C5&q=auto+reinforcement+learning&btnG="
-    for cookies, cb, hist, msg in 谷歌检索小助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        print(cb)
-
-def test_总结word文档():
-    from crazy_functions.总结word文档 import 总结word文档
-    txt = "crazy_functions/test_project/pdf_and_word"
-    for cookies, cb, hist, msg in 总结word文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        print(cb)
-
-def test_下载arxiv论文并翻译摘要():
-    from crazy_functions.下载arxiv论文翻译摘要 import 下载arxiv论文并翻译摘要
-    txt = "1812.10695"
-    for cookies, cb, hist, msg in 下载arxiv论文并翻译摘要(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        print(cb)
-
-def test_联网回答问题():
-    from crazy_functions.联网的ChatGPT import 连接网络回答问题
-    # txt = "谁是应急食品？"
-    # >>        '根据以上搜索结果可以得知，应急食品是“原神”游戏中的角色派蒙的外号。'
-    # txt = "道路千万条，安全第一条。后面两句是？"
-    # >>        '行车不规范，亲人两行泪。'
-    # txt = "You should have gone for the head. What does that mean?"
-    # >>        The phrase "You should have gone for the head" is a quote from the Marvel movies, Avengers: Infinity War and Avengers: Endgame. It was spoken by the character Thanos in Infinity War and by Thor in Endgame.
-    txt = "AutoGPT是什么？"
-    for cookies, cb, hist, msg in 连接网络回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port): 
-        print("当前问答：", cb[-1][-1].replace("\n"," "))
-    for i, it in enumerate(cb): print亮蓝(it[0]); print亮黄(it[1])
-
-def test_解析ipynb文件():
-    from crazy_functions.解析JupyterNotebook import 解析ipynb文件
-    txt = "crazy_functions/test_samples"
-    for cookies, cb, hist, msg in 解析ipynb文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        print(cb)
-
-
-def test_数学动画生成manim():
-    from crazy_functions.数学动画生成manim import 动画生成
-    txt = "A ball split into 2, and then split into 4, and finally split into 8."
-    for cookies, cb, hist, msg in 动画生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        print(cb)
-
-
-
-def test_Markdown多语言():
-    from crazy_functions.批量Markdown翻译 import Markdown翻译指定语言
-    txt = "README.md"
-    history = []
-    for lang in ["English", "French", "Japanese", "Korean", "Russian", "Italian", "German", "Portuguese", "Arabic"]:
-        plugin_kwargs = {"advanced_arg": lang}
-        for cookies, cb, hist, msg in Markdown翻译指定语言(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-            print(cb)
-
-def test_Langchain知识库():
-    from crazy_functions.Langchain知识库 import 知识库问答
-    txt = "./"
-    chatbot = ChatBotWithCookies(llm_kwargs)
-    for cookies, cb, hist, msg in silence_stdout(知识库问答)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        cli_printer.print(cb)   #  print(cb)
-    
-    chatbot = ChatBotWithCookies(cookies)
-    from crazy_functions.Langchain知识库 import 读取知识库作答
-    txt = "What is the installation method？"
-    for cookies, cb, hist, msg in silence_stdout(读取知识库作答)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        cli_printer.print(cb)   #  print(cb)
-
-def test_Langchain知识库读取():
-    from crazy_functions.Langchain知识库 import 读取知识库作答
-    txt = "远程云服务器部署？"
-    for cookies, cb, hist, msg in silence_stdout(读取知识库作答)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        cli_printer.print(cb)   #  print(cb)
-
-def test_Latex():
-    from crazy_functions.Latex输出PDF结果 import Latex英文纠错加PDF对比, Latex翻译中文并重新编译PDF
-
-    # txt = r"https://arxiv.org/abs/1706.03762"
-    # txt = r"https://arxiv.org/abs/1902.03185"
-    # txt = r"https://arxiv.org/abs/2305.18290"
-    # txt = r"https://arxiv.org/abs/2305.17608"
-    # txt = r"https://arxiv.org/abs/2211.16068"                     #  ACE
-    # 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/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命令文件名大小写错误！
-    # txt = "https://arxiv.org/abs/2205.14135"
-    # txt = r"C:\Users\fuqingxu\arxiv_cache\2205.14135\workfolder"
-    # txt = r"C:\Users\fuqingxu\arxiv_cache\2205.14135\workfolder"
-    txt = r"2210.03629"
-    txt = r"2307.04964"
-    for cookies, cb, hist, msg in (Latex翻译中文并重新编译PDF)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        cli_printer.print(cb)   #  print(cb)
-
-
-
-    # txt = "2302.02948.tar"
-    # print(txt)
-    # main_tex, work_folder = Latex预处理(txt)
-    # print('main tex:', main_tex)
-    # res = 编译Latex(main_tex, work_folder)
-    # # for cookies, cb, hist, msg in silence_stdout(编译Latex)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-    #     cli_printer.print(cb)   #  print(cb)
-
-def test_chatglm_finetune():
-    from crazy_functions.chatglm微调工具 import 微调数据集生成, 启动微调
-    txt = 'build/dev.json'
-    plugin_kwargs = {"advanced_arg":"--llm_to_learn=gpt-3.5-turbo --prompt_prefix='根据下面的服装类型提示，想象一个穿着者，对这个人外貌、身处的环境、内心世界、人设进行描写。要求：100字以内，用第二人称。' --system_prompt=''" }
-
-    # for cookies, cb, hist, msg in (微调数据集生成)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-    #     cli_printer.print(cb)
-
-    plugin_kwargs = {"advanced_arg":
-    "      --pre_seq_len=128 --learning_rate=2e-2 --num_gpus=1 --json_dataset='t_code.json' --ptuning_directory='/home/hmp/ChatGLM2-6B/ptuning'     " }
-
-    for cookies, cb, hist, msg in (启动微调)(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-        cli_printer.print(cb)
-
-
-if __name__ == "__main__":
-    # test_解析一个Python项目()
-    # test_Latex英文润色()
-    # test_Markdown中译英()
-    # test_批量翻译PDF文档()
-    # test_谷歌检索小助手()
-    # test_总结word文档()
-    # test_下载arxiv论文并翻译摘要()
-    # test_解析一个Cpp项目()
-    # test_联网回答问题()
-    # test_解析ipynb文件()
-    # test_数学动画生成manim()
-    # test_Langchain知识库()
-    # test_Langchain知识库读取()
-    test_Latex()
-    # test_chatglm_finetune()
-    input("程序完成，回车退出。")
-    print("退出。")

crazy_functions/json_fns/pydantic_io.py

@@ -0,0 +1,111 @@
+"""
+https://github.com/langchain-ai/langchain/blob/master/docs/extras/modules/model_io/output_parsers/pydantic.ipynb
+
+Example 1.
+
+# Define your desired data structure.
+class Joke(BaseModel):
+    setup: str = Field(description="question to set up a joke")
+    punchline: str = Field(description="answer to resolve the joke")
+
+    # You can add custom validation logic easily with Pydantic.
+    @validator("setup")
+    def question_ends_with_question_mark(cls, field):
+        if field[-1] != "?":
+            raise ValueError("Badly formed question!")
+        return field
+
+
+Example 2.
+
+# Here's another example, but with a compound typed field.
+class Actor(BaseModel):
+    name: str = Field(description="name of an actor")
+    film_names: List[str] = Field(description="list of names of films they starred in")
+"""
+
+import json, re, logging
+
+
+PYDANTIC_FORMAT_INSTRUCTIONS = """The output should be formatted as a JSON instance that conforms to the JSON schema below.
+
+As an example, for the schema {{"properties": {{"foo": {{"title": "Foo", "description": "a list of strings", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}
+the object {{"foo": ["bar", "baz"]}} is a well-formatted instance of the schema. The object {{"properties": {{"foo": ["bar", "baz"]}}}} is not well-formatted.
+
+Here is the output schema:
+```
+{schema}
+```"""
+
+
+PYDANTIC_FORMAT_INSTRUCTIONS_SIMPLE = """The output should be formatted as a JSON instance that conforms to the JSON schema below.
+```
+{schema}
+```"""
+
+class JsonStringError(Exception): ...
+
+class GptJsonIO():
+
+    def __init__(self, schema, example_instruction=True):
+        self.pydantic_object = schema
+        self.example_instruction = example_instruction
+        self.format_instructions = self.generate_format_instructions()
+
+    def generate_format_instructions(self):
+        schema = self.pydantic_object.schema()
+
+        # Remove extraneous fields.
+        reduced_schema = schema
+        if "title" in reduced_schema:
+            del reduced_schema["title"]
+        if "type" in reduced_schema:
+            del reduced_schema["type"]
+        # Ensure json in context is well-formed with double quotes.
+        if self.example_instruction:
+            schema_str = json.dumps(reduced_schema)
+            return PYDANTIC_FORMAT_INSTRUCTIONS.format(schema=schema_str)
+        else:
+            return PYDANTIC_FORMAT_INSTRUCTIONS_SIMPLE.format(schema=schema_str)
+
+    def generate_output(self, text):
+        # Greedy search for 1st json candidate.
+        match = re.search(
+            r"\{.*\}", text.strip(), re.MULTILINE | re.IGNORECASE | re.DOTALL
+        )
+        json_str = ""
+        if match: json_str = match.group()
+        json_object = json.loads(json_str, strict=False)
+        final_object = self.pydantic_object.parse_obj(json_object)
+        return final_object
+
+    def generate_repair_prompt(self, broken_json, error):
+        prompt = "Fix a broken json string.\n\n" + \
+                 "(1) The broken json string need to fix is: \n\n" + \
+                 "```" + "\n" + \
+                 broken_json + "\n" + \
+                 "```" + "\n\n" + \
+                 "(2) The error message is: \n\n" + \
+                 error + "\n\n" + \
+                "Now, fix this json string. \n\n"
+        return prompt
+    
+    def generate_output_auto_repair(self, response, gpt_gen_fn):
+        """
+        response: string containing canidate json
+        gpt_gen_fn: gpt_gen_fn(inputs, sys_prompt)
+        """
+        try:
+            result = self.generate_output(response)
+        except Exception as e:
+            try:
+                logging.info(f'Repairing json：{response}')
+                repair_prompt = self.generate_repair_prompt(broken_json = response, error=repr(e))
+                result = self.generate_output(gpt_gen_fn(repair_prompt, self.format_instructions))
+                logging.info('Repaire json success.')
+            except Exception as e:
+                # 没辙了，放弃治疗
+                logging.info('Repaire json fail.')
+                raise JsonStringError('Cannot repair json.', str(e))
+        return result
+

crazy_functions/latex_fns/latex_toolbox.py

@@ -281,9 +281,12 @@ def rm_comments(main_file):
 def find_tex_file_ignore_case(fp):
     dir_name = os.path.dirname(fp)
     base_name = os.path.basename(fp)
+    # 如果输入的文件路径是正确的
+    if os.path.exists(pj(dir_name, base_name)): return pj(dir_name, base_name)
+    # 如果不正确，试着加上.tex后缀试试
     if not base_name.endswith('.tex'): base_name+='.tex'
     if os.path.exists(pj(dir_name, base_name)): return pj(dir_name, base_name)
-    # go case in-sensitive
+    # 如果还找不到，解除大小写限制，再试一次
     import glob
     for f in glob.glob(dir_name+'/*.tex'):
         base_name_s = os.path.basename(fp)

crazy_functions/live_audio/aliyunASR.py

@@ -19,7 +19,7 @@ class AliyunASR():
         pass
 
     def test_on_error(self, message, *args):
-        # print("on_error args=>{}".format(args))
+        print("on_error args=>{}".format(args))
         pass
 
     def test_on_close(self, *args):
@@ -50,6 +50,8 @@ class AliyunASR():
         rad.clean_up()
         temp_folder = tempfile.gettempdir()
         TOKEN, APPKEY = get_conf('ALIYUN_TOKEN', 'ALIYUN_APPKEY')
+        if len(TOKEN) == 0:
+            TOKEN = self.get_token()
         self.aliyun_service_ok = True
         URL="wss://nls-gateway.aliyuncs.com/ws/v1"
         sr = nls.NlsSpeechTranscriber(
@@ -91,3 +93,38 @@ class AliyunASR():
                 self.stop = True
                 self.stop_msg = 'Aliyun音频服务异常，请检查ALIYUN_TOKEN和ALIYUN_APPKEY是否过期。'
         r = sr.stop()
+
+    def get_token(self):
+        from toolbox import get_conf
+        import json
+        from aliyunsdkcore.request import CommonRequest
+        from aliyunsdkcore.client import AcsClient
+        AccessKey_ID, AccessKey_secret = get_conf('ALIYUN_ACCESSKEY', 'ALIYUN_SECRET')
+
+        # 创建AcsClient实例
+        client = AcsClient(
+            AccessKey_ID,
+            AccessKey_secret,
+            "cn-shanghai"
+        )
+
+        # 创建request，并设置参数。
+        request = CommonRequest()
+        request.set_method('POST')
+        request.set_domain('nls-meta.cn-shanghai.aliyuncs.com')
+        request.set_version('2019-02-28')
+        request.set_action_name('CreateToken')
+
+        try:
+            response = client.do_action_with_exception(request)
+            print(response)
+            jss = json.loads(response)
+            if 'Token' in jss and 'Id' in jss['Token']:
+                token = jss['Token']['Id']
+                expireTime = jss['Token']['ExpireTime']
+                print("token = " + token)
+                print("expireTime = " + str(expireTime))
+        except Exception as e:
+            print(e)
+
+        return token

crazy_functions/pdf_fns/parse_pdf.py

@@ -0,0 +1,25 @@
+import requests
+import random
+from functools import lru_cache
+class GROBID_OFFLINE_EXCEPTION(Exception): pass
+
+def get_avail_grobid_url():
+    from toolbox import get_conf
+    GROBID_URLS, = get_conf('GROBID_URLS')
+    if len(GROBID_URLS) == 0: return None
+    try:
+        _grobid_url = random.choice(GROBID_URLS) # 随机负载均衡
+        if _grobid_url.endswith('/'): _grobid_url = _grobid_url.rstrip('/')
+        res = requests.get(_grobid_url+'/api/isalive')
+        if res.text=='true': return _grobid_url
+        else: return None
+    except:
+        return None
+
+@lru_cache(maxsize=32)
+def parse_pdf(pdf_path, grobid_url):
+    import scipdf   # pip install scipdf_parser
+    if grobid_url.endswith('/'): grobid_url = grobid_url.rstrip('/')
+    article_dict = scipdf.parse_pdf_to_dict(pdf_path, grobid_url=grobid_url)
+    return article_dict
+

crazy_functions/test_project/cpp/cppipc/buffer.cpp

@@ -1,87 +0,0 @@
-#include "libipc/buffer.h"
-#include "libipc/utility/pimpl.h"
-
-#include <cstring>
-
-namespace ipc {
-
-bool operator==(buffer const & b1, buffer const & b2) {
-    return (b1.size() == b2.size()) && (std::memcmp(b1.data(), b2.data(), b1.size()) == 0);
-}
-
-bool operator!=(buffer const & b1, buffer const & b2) {
-    return !(b1 == b2);
-}
-
-class buffer::buffer_ : public pimpl<buffer_> {
-public:
-    void*       p_;
-    std::size_t s_;
-    void*       a_;
-    buffer::destructor_t d_;
-
-    buffer_(void* p, std::size_t s, buffer::destructor_t d, void* a)
-        : p_(p), s_(s), a_(a), d_(d) {
-    }
-
-    ~buffer_() {
-        if (d_ == nullptr) return;
-        d_((a_ == nullptr) ? p_ : a_, s_);
-    }
-};
-
-buffer::buffer()
-    : buffer(nullptr, 0, nullptr, nullptr) {
-}
-
-buffer::buffer(void* p, std::size_t s, destructor_t d)
-    : p_(p_->make(p, s, d, nullptr)) {
-}
-
-buffer::buffer(void* p, std::size_t s, destructor_t d, void* additional)
-    : p_(p_->make(p, s, d, additional)) {
-}
-
-buffer::buffer(void* p, std::size_t s)
-    : buffer(p, s, nullptr) {
-}
-
-buffer::buffer(char const & c)
-    : buffer(const_cast<char*>(&c), 1) {
-}
-
-buffer::buffer(buffer&& rhs)
-    : buffer() {
-    swap(rhs);
-}
-
-buffer::~buffer() {
-    p_->clear();
-}
-
-void buffer::swap(buffer& rhs) {
-    std::swap(p_, rhs.p_);
-}
-
-buffer& buffer::operator=(buffer rhs) {
-    swap(rhs);
-    return *this;
-}
-
-bool buffer::empty() const noexcept {
-    return (impl(p_)->p_ == nullptr) || (impl(p_)->s_ == 0);
-}
-
-void* buffer::data() noexcept {
-    return impl(p_)->p_;
-}
-
-void const * buffer::data() const noexcept {
-    return impl(p_)->p_;
-}
-
-std::size_t buffer::size() const noexcept {
-    return impl(p_)->s_;
-}
-
-} // namespace ipc

crazy_functions/test_project/cpp/cppipc/ipc.cpp

@@ -1,701 +0,0 @@
-
-#include <type_traits>
-#include <cstring>
-#include <algorithm>
-#include <utility>          // std::pair, std::move, std::forward
-#include <atomic>
-#include <type_traits>      // aligned_storage_t
-#include <string>
-#include <vector>
-#include <array>
-#include <cassert>
-
-#include "libipc/ipc.h"
-#include "libipc/def.h"
-#include "libipc/shm.h"
-#include "libipc/pool_alloc.h"
-#include "libipc/queue.h"
-#include "libipc/policy.h"
-#include "libipc/rw_lock.h"
-#include "libipc/waiter.h"
-
-#include "libipc/utility/log.h"
-#include "libipc/utility/id_pool.h"
-#include "libipc/utility/scope_guard.h"
-#include "libipc/utility/utility.h"
-
-#include "libipc/memory/resource.h"
-#include "libipc/platform/detail.h"
-#include "libipc/circ/elem_array.h"
-
-namespace {
-
-using msg_id_t = std::uint32_t;
-using acc_t    = std::atomic<msg_id_t>;
-
-template <std::size_t DataSize, std::size_t AlignSize>
-struct msg_t;
-
-template <std::size_t AlignSize>
-struct msg_t<0, AlignSize> {
-    msg_id_t     cc_id_;
-    msg_id_t     id_;
-    std::int32_t remain_;
-    bool         storage_;
-};
-
-template <std::size_t DataSize, std::size_t AlignSize>
-struct msg_t : msg_t<0, AlignSize> {
-    std::aligned_storage_t<DataSize, AlignSize> data_ {};
-
-    msg_t() = default;
-    msg_t(msg_id_t cc_id, msg_id_t id, std::int32_t remain, void const * data, std::size_t size)
-        : msg_t<0, AlignSize> {cc_id, id, remain, (data == nullptr) || (size == 0)} {
-        if (this->storage_) {
-            if (data != nullptr) {
-                // copy storage-id
-                *reinterpret_cast<ipc::storage_id_t*>(&data_) =
-                     *static_cast<ipc::storage_id_t const *>(data);
-            }
-        }
-        else std::memcpy(&data_, data, size);
-    }
-};
-
-template <typename T>
-ipc::buff_t make_cache(T& data, std::size_t size) {
-    auto ptr = ipc::mem::alloc(size);
-    std::memcpy(ptr, &data, (ipc::detail::min)(sizeof(data), size));
-    return { ptr, size, ipc::mem::free };
-}
-
-struct cache_t {
-    std::size_t fill_;
-    ipc::buff_t buff_;
-
-    cache_t(std::size_t f, ipc::buff_t && b)
-        : fill_(f), buff_(std::move(b))
-    {}
-
-    void append(void const * data, std::size_t size) {
-        if (fill_ >= buff_.size() || data == nullptr || size == 0) return;
-        auto new_fill = (ipc::detail::min)(fill_ + size, buff_.size());
-        std::memcpy(static_cast<ipc::byte_t*>(buff_.data()) + fill_, data, new_fill - fill_);
-        fill_ = new_fill;
-    }
-};
-
-auto cc_acc() {
-    static ipc::shm::handle acc_h("__CA_CONN__", sizeof(acc_t));
-    return static_cast<acc_t*>(acc_h.get());
-}
-
-IPC_CONSTEXPR_ std::size_t align_chunk_size(std::size_t size) noexcept {
-    return (((size - 1) / ipc::large_msg_align) + 1) * ipc::large_msg_align;
-}
-
-IPC_CONSTEXPR_ std::size_t calc_chunk_size(std::size_t size) noexcept {
-    return ipc::make_align(alignof(std::max_align_t), align_chunk_size(
-           ipc::make_align(alignof(std::max_align_t), sizeof(std::atomic<ipc::circ::cc_t>)) + size));
-}
-
-struct chunk_t {
-    std::atomic<ipc::circ::cc_t> &conns() noexcept {
-        return *reinterpret_cast<std::atomic<ipc::circ::cc_t> *>(this);
-    }
-
-    void *data() noexcept {
-        return reinterpret_cast<ipc::byte_t *>(this)
-             + ipc::make_align(alignof(std::max_align_t), sizeof(std::atomic<ipc::circ::cc_t>));
-    }
-};
-
-struct chunk_info_t {
-    ipc::id_pool<> pool_;
-    ipc::spin_lock lock_;
-
-    IPC_CONSTEXPR_ static std::size_t chunks_mem_size(std::size_t chunk_size) noexcept {
-        return ipc::id_pool<>::max_count * chunk_size;
-    }
-
-    ipc::byte_t *chunks_mem() noexcept {
-        return reinterpret_cast<ipc::byte_t *>(this + 1);
-    }
-
-    chunk_t *at(std::size_t chunk_size, ipc::storage_id_t id) noexcept {
-        if (id < 0) return nullptr;
-        return reinterpret_cast<chunk_t *>(chunks_mem() + (chunk_size * id));
-    }
-};
-
-auto& chunk_storages() {
-    class chunk_handle_t {
-        ipc::shm::handle handle_;
-
-    public:
-        chunk_info_t *get_info(std::size_t chunk_size) {
-            if (!handle_.valid() &&
-                !handle_.acquire( ("__CHUNK_INFO__" + ipc::to_string(chunk_size)).c_str(), 
-                                  sizeof(chunk_info_t) + chunk_info_t::chunks_mem_size(chunk_size) )) {
-                ipc::error("[chunk_storages] chunk_shm.id_info_.acquire failed: chunk_size = %zd\n", chunk_size);
-                return nullptr;
-            }
-            auto info = static_cast<chunk_info_t*>(handle_.get());
-            if (info == nullptr) {
-                ipc::error("[chunk_storages] chunk_shm.id_info_.get failed: chunk_size = %zd\n", chunk_size);
-                return nullptr;
-            }
-            return info;
-        }
-    };
-    static ipc::map<std::size_t, chunk_handle_t> chunk_hs;
-    return chunk_hs;
-}
-
-chunk_info_t *chunk_storage_info(std::size_t chunk_size) {
-    auto &storages = chunk_storages();
-    std::decay_t<decltype(storages)>::iterator it;
-    {
-        static ipc::rw_lock lock;
-        IPC_UNUSED_ std::shared_lock<ipc::rw_lock> guard {lock};
-        if ((it = storages.find(chunk_size)) == storages.end()) {
-            using chunk_handle_t = std::decay_t<decltype(storages)>::value_type::second_type;
-            guard.unlock();
-            IPC_UNUSED_ std::lock_guard<ipc::rw_lock> guard {lock};
-            it = storages.emplace(chunk_size, chunk_handle_t{}).first;
-        }
-    }
-    return it->second.get_info(chunk_size);
-}
-
-std::pair<ipc::storage_id_t, void*> acquire_storage(std::size_t size, ipc::circ::cc_t conns) {
-    std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
-    if (info == nullptr) return {};
-
-    info->lock_.lock();
-    info->pool_.prepare();
-    // got an unique id
-    auto id = info->pool_.acquire();
-    info->lock_.unlock();
-
-    auto chunk = info->at(chunk_size, id);
-    if (chunk == nullptr) return {};
-    chunk->conns().store(conns, std::memory_order_relaxed);
-    return { id, chunk->data() };
-}
-
-void *find_storage(ipc::storage_id_t id, std::size_t size) {
-    if (id < 0) {
-        ipc::error("[find_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
-        return nullptr;
-    }
-    std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
-    if (info == nullptr) return nullptr;
-    return info->at(chunk_size, id)->data();
-}
-
-void release_storage(ipc::storage_id_t id, std::size_t size) {
-    if (id < 0) {
-        ipc::error("[release_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
-        return;
-    }
-    std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
-    if (info == nullptr) return;
-    info->lock_.lock();
-    info->pool_.release(id);
-    info->lock_.unlock();
-}
-
-template <ipc::relat Rp, ipc::relat Rc>
-bool sub_rc(ipc::wr<Rp, Rc, ipc::trans::unicast>, 
-            std::atomic<ipc::circ::cc_t> &/*conns*/, ipc::circ::cc_t /*curr_conns*/, ipc::circ::cc_t /*conn_id*/) noexcept {
-    return true;
-}
-
-template <ipc::relat Rp, ipc::relat Rc>
-bool sub_rc(ipc::wr<Rp, Rc, ipc::trans::broadcast>, 
-            std::atomic<ipc::circ::cc_t> &conns, ipc::circ::cc_t curr_conns, ipc::circ::cc_t conn_id) noexcept {
-    auto last_conns = curr_conns & ~conn_id;
-    for (unsigned k = 0;;) {
-        auto chunk_conns  = conns.load(std::memory_order_acquire);
-        if (conns.compare_exchange_weak(chunk_conns, chunk_conns & last_conns, std::memory_order_release)) {
-            return (chunk_conns & last_conns) == 0;
-        }
-        ipc::yield(k);
-    }
-}
-
-template <typename Flag>
-void recycle_storage(ipc::storage_id_t id, std::size_t size, ipc::circ::cc_t curr_conns, ipc::circ::cc_t conn_id) {
-    if (id < 0) {
-        ipc::error("[recycle_storage] id is invalid: id = %ld, size = %zd\n", (long)id, size);
-        return;
-    }
-    std::size_t chunk_size = calc_chunk_size(size);
-    auto info = chunk_storage_info(chunk_size);
-    if (info == nullptr) return;
-
-    auto chunk = info->at(chunk_size, id);
-    if (chunk == nullptr) return;
-
-    if (!sub_rc(Flag{}, chunk->conns(), curr_conns, conn_id)) {
-        return;
-    }
-    info->lock_.lock();
-    info->pool_.release(id);
-    info->lock_.unlock();
-}
-
-template <typename MsgT>
-bool clear_message(void* p) {
-    auto msg = static_cast<MsgT*>(p);
-    if (msg->storage_) {
-        std::int32_t r_size = static_cast<std::int32_t>(ipc::data_length) + msg->remain_;
-        if (r_size <= 0) {
-            ipc::error("[clear_message] invalid msg size: %d\n", (int)r_size);
-            return true;
-        }
-        release_storage(
-            *reinterpret_cast<ipc::storage_id_t*>(&msg->data_),
-            static_cast<std::size_t>(r_size));
-    }
-    return true;
-}
-
-struct conn_info_head {
-
-    ipc::string name_;
-    msg_id_t    cc_id_; // connection-info id
-    ipc::detail::waiter cc_waiter_, wt_waiter_, rd_waiter_;
-    ipc::shm::handle acc_h_;
-
-    conn_info_head(char const * name)
-        : name_     {name}
-        , cc_id_    {(cc_acc() == nullptr) ? 0 : cc_acc()->fetch_add(1, std::memory_order_relaxed)}
-        , cc_waiter_{("__CC_CONN__" + name_).c_str()}
-        , wt_waiter_{("__WT_CONN__" + name_).c_str()}
-        , rd_waiter_{("__RD_CONN__" + name_).c_str()}
-        , acc_h_    {("__AC_CONN__" + name_).c_str(), sizeof(acc_t)} {
-    }
-
-    void quit_waiting() {
-        cc_waiter_.quit_waiting();
-        wt_waiter_.quit_waiting();
-        rd_waiter_.quit_waiting();
-    }
-
-    auto acc() {
-        return static_cast<acc_t*>(acc_h_.get());
-    }
-
-    auto& recv_cache() {
-        thread_local ipc::unordered_map<msg_id_t, cache_t> tls;
-        return tls;
-    }
-};
-
-template <typename W, typename F>
-bool wait_for(W& waiter, F&& pred, std::uint64_t tm) {
-    if (tm == 0) return !pred();
-    for (unsigned k = 0; pred();) {
-        bool ret = true;
-        ipc::sleep(k, [&k, &ret, &waiter, &pred, tm] {
-            ret = waiter.wait_if(std::forward<F>(pred), tm);
-            k   = 0;
-        });
-        if (!ret) return false; // timeout or fail
-        if (k == 0) break; // k has been reset
-    }
-    return true;
-}
-
-template <typename Policy,
-          std::size_t DataSize  = ipc::data_length,
-          std::size_t AlignSize = (ipc::detail::min)(DataSize, alignof(std::max_align_t))>
-struct queue_generator {
-
-    using queue_t = ipc::queue<msg_t<DataSize, AlignSize>, Policy>;
-
-    struct conn_info_t : conn_info_head {
-        queue_t que_;
-
-        conn_info_t(char const * name)
-            : conn_info_head{name}
-            , que_{("__QU_CONN__" +
-                    ipc::to_string(DataSize) + "__" +
-                    ipc::to_string(AlignSize) + "__" + name).c_str()} {
-        }
-
-        void disconnect_receiver() {
-            bool dis = que_.disconnect();
-            this->quit_waiting();
-            if (dis) {
-                this->recv_cache().clear();
-            }
-        }
-    };
-};
-
-template <typename Policy>
-struct detail_impl {
-
-using policy_t    = Policy;
-using flag_t      = typename policy_t::flag_t;
-using queue_t     = typename queue_generator<policy_t>::queue_t;
-using conn_info_t = typename queue_generator<policy_t>::conn_info_t;
-
-constexpr static conn_info_t* info_of(ipc::handle_t h) noexcept {
-    return static_cast<conn_info_t*>(h);
-}
-
-constexpr static queue_t* queue_of(ipc::handle_t h) noexcept {
-    return (info_of(h) == nullptr) ? nullptr : &(info_of(h)->que_);
-}
-
-/* API implementations */
-
-static void disconnect(ipc::handle_t h) {
-    auto que = queue_of(h);
-    if (que == nullptr) {
-        return;
-    }
-    que->shut_sending();
-    assert(info_of(h) != nullptr);
-    info_of(h)->disconnect_receiver();
-}
-
-static bool reconnect(ipc::handle_t * ph, bool start_to_recv) {
-    assert(ph != nullptr);
-    assert(*ph != nullptr);
-    auto que = queue_of(*ph);
-    if (que == nullptr) {
-        return false;
-    }
-    if (start_to_recv) {
-        que->shut_sending();
-        if (que->connect()) { // wouldn't connect twice
-            info_of(*ph)->cc_waiter_.broadcast();
-            return true;
-        }
-        return false;
-    }
-    // start_to_recv == false
-    if (que->connected()) {
-        info_of(*ph)->disconnect_receiver();
-    }
-    return que->ready_sending();
-}
-
-static bool connect(ipc::handle_t * ph, char const * name, bool start_to_recv) {
-    assert(ph != nullptr);
-    if (*ph == nullptr) {
-        *ph = ipc::mem::alloc<conn_info_t>(name);
-    }
-    return reconnect(ph, start_to_recv);
-}
-
-static void destroy(ipc::handle_t h) {
-    disconnect(h);
-    ipc::mem::free(info_of(h));
-}
-
-static std::size_t recv_count(ipc::handle_t h) noexcept {
-    auto que = queue_of(h);
-    if (que == nullptr) {
-        return ipc::invalid_value;
-    }
-    return que->conn_count();
-}
-
-static bool wait_for_recv(ipc::handle_t h, std::size_t r_count, std::uint64_t tm) {
-    auto que = queue_of(h);
-    if (que == nullptr) {
-        return false;
-    }
-    return wait_for(info_of(h)->cc_waiter_, [que, r_count] {
-        return que->conn_count() < r_count;
-    }, tm);
-}
-
-template <typename F>
-static bool send(F&& gen_push, ipc::handle_t h, void const * data, std::size_t size) {
-    if (data == nullptr || size == 0) {
-        ipc::error("fail: send(%p, %zd)\n", data, size);
-        return false;
-    }
-    auto que = queue_of(h);
-    if (que == nullptr) {
-        ipc::error("fail: send, queue_of(h) == nullptr\n");
-        return false;
-    }
-    if (que->elems() == nullptr) {
-        ipc::error("fail: send, queue_of(h)->elems() == nullptr\n");
-        return false;
-    }
-    if (!que->ready_sending()) {
-        ipc::error("fail: send, que->ready_sending() == false\n");
-        return false;
-    }
-    ipc::circ::cc_t conns = que->elems()->connections(std::memory_order_relaxed);
-    if (conns == 0) {
-        ipc::error("fail: send, there is no receiver on this connection.\n");
-        return false;
-    }
-    // calc a new message id
-    auto acc = info_of(h)->acc();
-    if (acc == nullptr) {
-        ipc::error("fail: send, info_of(h)->acc() == nullptr\n");
-        return false;
-    }
-    auto msg_id   = acc->fetch_add(1, std::memory_order_relaxed);
-    auto try_push = std::forward<F>(gen_push)(info_of(h), que, msg_id);
-    if (size > ipc::large_msg_limit) {
-        auto   dat = acquire_storage(size, conns);
-        void * buf = dat.second;
-        if (buf != nullptr) {
-            std::memcpy(buf, data, size);
-            return try_push(static_cast<std::int32_t>(size) - 
-                            static_cast<std::int32_t>(ipc::data_length), &(dat.first), 0);
-        }
-        // try using message fragment
-        //ipc::log("fail: shm::handle for big message. msg_id: %zd, size: %zd\n", msg_id, size);
-    }
-    // push message fragment
-    std::int32_t offset = 0;
-    for (std::int32_t i = 0; i < static_cast<std::int32_t>(size / ipc::data_length); ++i, offset += ipc::data_length) {
-        if (!try_push(static_cast<std::int32_t>(size) - offset - static_cast<std::int32_t>(ipc::data_length),
-                      static_cast<ipc::byte_t const *>(data) + offset, ipc::data_length)) {
-            return false;
-        }
-    }
-    // if remain > 0, this is the last message fragment
-    std::int32_t remain = static_cast<std::int32_t>(size) - offset;
-    if (remain > 0) {
-        if (!try_push(remain - static_cast<std::int32_t>(ipc::data_length),
-                      static_cast<ipc::byte_t const *>(data) + offset, 
-                      static_cast<std::size_t>(remain))) {
-            return false;
-        }
-    }
-    return true;
-}
-
-static bool send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
-    return send([tm](auto info, auto que, auto msg_id) {
-        return [tm, info, que, msg_id](std::int32_t remain, void const * data, std::size_t size) {
-            if (!wait_for(info->wt_waiter_, [&] {
-                    return !que->push(
-                        [](void*) { return true; },
-                        info->cc_id_, msg_id, remain, data, size);
-                }, tm)) {
-                ipc::log("force_push: msg_id = %zd, remain = %d, size = %zd\n", msg_id, remain, size);
-                if (!que->force_push(
-                        clear_message<typename queue_t::value_t>,
-                        info->cc_id_, msg_id, remain, data, size)) {
-                    return false;
-                }
-            }
-            info->rd_waiter_.broadcast();
-            return true;
-        };
-    }, h, data, size);
-}
-
-static bool try_send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
-    return send([tm](auto info, auto que, auto msg_id) {
-        return [tm, info, que, msg_id](std::int32_t remain, void const * data, std::size_t size) {
-            if (!wait_for(info->wt_waiter_, [&] {
-                    return !que->push(
-                        [](void*) { return true; },
-                        info->cc_id_, msg_id, remain, data, size);
-                }, tm)) {
-                return false;
-            }
-            info->rd_waiter_.broadcast();
-            return true;
-        };
-    }, h, data, size);
-}
-
-static ipc::buff_t recv(ipc::handle_t h, std::uint64_t tm) {
-    auto que = queue_of(h);
-    if (que == nullptr) {
-        ipc::error("fail: recv, queue_of(h) == nullptr\n");
-        return {};
-    }
-    if (!que->connected()) {
-        // hasn't connected yet, just return.
-        return {};
-    }
-    auto& rc = info_of(h)->recv_cache();
-    for (;;) {
-        // pop a new message
-        typename queue_t::value_t msg;
-        if (!wait_for(info_of(h)->rd_waiter_, [que, &msg] {
-                return !que->pop(msg);
-            }, tm)) {
-            // pop failed, just return.
-            return {};
-        }
-        info_of(h)->wt_waiter_.broadcast();
-        if ((info_of(h)->acc() != nullptr) && (msg.cc_id_ == info_of(h)->cc_id_)) {
-            continue; // ignore message to self
-        }
-        // msg.remain_ may minus & abs(msg.remain_) < data_length
-        std::int32_t r_size = static_cast<std::int32_t>(ipc::data_length) + msg.remain_;
-        if (r_size <= 0) {
-            ipc::error("fail: recv, r_size = %d\n", (int)r_size);
-            return {};
-        }
-        std::size_t msg_size = static_cast<std::size_t>(r_size);
-        // large message
-        if (msg.storage_) {
-            ipc::storage_id_t buf_id = *reinterpret_cast<ipc::storage_id_t*>(&msg.data_);
-            void* buf = find_storage(buf_id, msg_size);
-            if (buf != nullptr) {
-                struct recycle_t {
-                    ipc::storage_id_t storage_id;
-                    ipc::circ::cc_t   curr_conns;
-                    ipc::circ::cc_t   conn_id;
-                } *r_info = ipc::mem::alloc<recycle_t>(recycle_t{
-                    buf_id, que->elems()->connections(std::memory_order_relaxed), que->connected_id()
-                });
-                if (r_info == nullptr) {
-                    ipc::log("fail: ipc::mem::alloc<recycle_t>.\n");
-                    return ipc::buff_t{buf, msg_size}; // no recycle
-                } else {
-                    return ipc::buff_t{buf, msg_size, [](void* p_info, std::size_t size) {
-                        auto r_info = static_cast<recycle_t *>(p_info);
-                        IPC_UNUSED_ auto finally = ipc::guard([r_info] {
-                            ipc::mem::free(r_info);
-                        });
-                        recycle_storage<flag_t>(r_info->storage_id, size, r_info->curr_conns, r_info->conn_id);
-                    }, r_info};
-                }
-            } else {
-                ipc::log("fail: shm::handle for large message. msg_id: %zd, buf_id: %zd, size: %zd\n", msg.id_, buf_id, msg_size);
-                continue;
-            }
-        }
-        // find cache with msg.id_
-        auto cac_it = rc.find(msg.id_);
-        if (cac_it == rc.end()) {
-            if (msg_size <= ipc::data_length) {
-                return make_cache(msg.data_, msg_size);
-            }
-            // gc
-            if (rc.size() > 1024) {
-                std::vector<msg_id_t> need_del;
-                for (auto const & pair : rc) {
-                    auto cmp = std::minmax(msg.id_, pair.first);
-                    if (cmp.second - cmp.first > 8192) {
-                        need_del.push_back(pair.first);
-                    }
-                }
-                for (auto id : need_del) rc.erase(id);
-            }
-            // cache the first message fragment
-            rc.emplace(msg.id_, cache_t { ipc::data_length, make_cache(msg.data_, msg_size) });
-        }
-        // has cached before this message
-        else {
-            auto& cac = cac_it->second;
-            // this is the last message fragment
-            if (msg.remain_ <= 0) {
-                cac.append(&(msg.data_), msg_size);
-                // finish this message, erase it from cache
-                auto buff = std::move(cac.buff_);
-                rc.erase(cac_it);
-                return buff;
-            }
-            // there are remain datas after this message
-            cac.append(&(msg.data_), ipc::data_length);
-        }
-    }
-}
-
-static ipc::buff_t try_recv(ipc::handle_t h) {
-    return recv(h, 0);
-}
-
-}; // detail_impl<Policy>
-
-template <typename Flag>
-using policy_t = ipc::policy::choose<ipc::circ::elem_array, Flag>;
-
-} // internal-linkage
-
-namespace ipc {
-
-template <typename Flag>
-ipc::handle_t chan_impl<Flag>::inited() {
-    ipc::detail::waiter::init();
-    return nullptr;
-}
-
-template <typename Flag>
-bool chan_impl<Flag>::connect(ipc::handle_t * ph, char const * name, unsigned mode) {
-    return detail_impl<policy_t<Flag>>::connect(ph, name, mode & receiver);
-}
-
-template <typename Flag>
-bool chan_impl<Flag>::reconnect(ipc::handle_t * ph, unsigned mode) {
-    return detail_impl<policy_t<Flag>>::reconnect(ph, mode & receiver);
-}
-
-template <typename Flag>
-void chan_impl<Flag>::disconnect(ipc::handle_t h) {
-    detail_impl<policy_t<Flag>>::disconnect(h);
-}
-
-template <typename Flag>
-void chan_impl<Flag>::destroy(ipc::handle_t h) {
-    detail_impl<policy_t<Flag>>::destroy(h);
-}
-
-template <typename Flag>
-char const * chan_impl<Flag>::name(ipc::handle_t h) {
-    auto info = detail_impl<policy_t<Flag>>::info_of(h);
-    return (info == nullptr) ? nullptr : info->name_.c_str();
-}
-
-template <typename Flag>
-std::size_t chan_impl<Flag>::recv_count(ipc::handle_t h) {
-    return detail_impl<policy_t<Flag>>::recv_count(h);
-}
-
-template <typename Flag>
-bool chan_impl<Flag>::wait_for_recv(ipc::handle_t h, std::size_t r_count, std::uint64_t tm) {
-    return detail_impl<policy_t<Flag>>::wait_for_recv(h, r_count, tm);
-}
-
-template <typename Flag>
-bool chan_impl<Flag>::send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
-    return detail_impl<policy_t<Flag>>::send(h, data, size, tm);
-}
-
-template <typename Flag>
-buff_t chan_impl<Flag>::recv(ipc::handle_t h, std::uint64_t tm) {
-    return detail_impl<policy_t<Flag>>::recv(h, tm);
-}
-
-template <typename Flag>
-bool chan_impl<Flag>::try_send(ipc::handle_t h, void const * data, std::size_t size, std::uint64_t tm) {
-    return detail_impl<policy_t<Flag>>::try_send(h, data, size, tm);
-}
-
-template <typename Flag>
-buff_t chan_impl<Flag>::try_recv(ipc::handle_t h) {
-    return detail_impl<policy_t<Flag>>::try_recv(h);
-}
-
-template struct chan_impl<ipc::wr<relat::single, relat::single, trans::unicast  >>;
-// template struct chan_impl<ipc::wr<relat::single, relat::multi , trans::unicast  >>; // TBD
-// template struct chan_impl<ipc::wr<relat::multi , relat::multi , trans::unicast  >>; // TBD
-template struct chan_impl<ipc::wr<relat::single, relat::multi , trans::broadcast>>;
-template struct chan_impl<ipc::wr<relat::multi , relat::multi , trans::broadcast>>;
-
-} // namespace ipc

crazy_functions/test_project/cpp/cppipc/policy.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <type_traits>
-
-#include "libipc/def.h"
-#include "libipc/prod_cons.h"
-
-#include "libipc/circ/elem_array.h"
-
-namespace ipc {
-namespace policy {
-
-template <template <typename, std::size_t...> class Elems, typename Flag>
-struct choose;
-
-template <typename Flag>
-struct choose<circ::elem_array, Flag> {
-    using flag_t = Flag;
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    using elems_t = circ::elem_array<ipc::prod_cons_impl<flag_t>, DataSize, AlignSize>;
-};
-
-} // namespace policy
-} // namespace ipc

crazy_functions/test_project/cpp/cppipc/pool_alloc.cpp

@@ -1,17 +0,0 @@
-#include "libipc/pool_alloc.h"
-
-#include "libipc/memory/resource.h"
-
-namespace ipc {
-namespace mem {
-
-void* pool_alloc::alloc(std::size_t size) {
-    return async_pool_alloc::alloc(size);
-}
-
-void pool_alloc::free(void* p, std::size_t size) {
-    async_pool_alloc::free(p, size);
-}
-
-} // namespace mem
-} // namespace ipc

crazy_functions/test_project/cpp/cppipc/prod_cons.h

@@ -1,433 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <utility>
-#include <cstring>
-#include <type_traits>
-#include <cstdint>
-
-#include "libipc/def.h"
-
-#include "libipc/platform/detail.h"
-#include "libipc/circ/elem_def.h"
-#include "libipc/utility/log.h"
-#include "libipc/utility/utility.h"
-
-namespace ipc {
-
-////////////////////////////////////////////////////////////////
-/// producer-consumer implementation
-////////////////////////////////////////////////////////////////
-
-template <typename Flag>
-struct prod_cons_impl;
-
-template <>
-struct prod_cons_impl<wr<relat::single, relat::single, trans::unicast>> {
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> rd_; // read index
-    alignas(cache_line_size) std::atomic<circ::u2_t> wt_; // write index
-
-    constexpr circ::u2_t cursor() const noexcept {
-        return 0;
-    }
-
-    template <typename W, typename F, typename E>
-    bool push(W* /*wrapper*/, F&& f, E* elems) {
-        auto cur_wt = circ::index_of(wt_.load(std::memory_order_relaxed));
-        if (cur_wt == circ::index_of(rd_.load(std::memory_order_acquire) - 1)) {
-            return false; // full
-        }
-        std::forward<F>(f)(&(elems[cur_wt].data_));
-        wt_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-
-    /**
-     * In single-single-unicast, 'force_push' means 'no reader' or 'the only one reader is dead'.
-     * So we could just disconnect all connections of receiver, and return false.
-    */
-    template <typename W, typename F, typename E>
-    bool force_push(W* wrapper, F&&, E*) {
-        wrapper->elems()->disconnect_receiver(~static_cast<circ::cc_t>(0u));
-        return false;
-    }
-
-    template <typename W, typename F, typename R, typename E>
-    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E* elems) {
-        auto cur_rd = circ::index_of(rd_.load(std::memory_order_relaxed));
-        if (cur_rd == circ::index_of(wt_.load(std::memory_order_acquire))) {
-            return false; // empty
-        }
-        std::forward<F>(f)(&(elems[cur_rd].data_));
-        std::forward<R>(out)(true);
-        rd_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::single, relat::multi , trans::unicast>>
-     : prod_cons_impl<wr<relat::single, relat::single, trans::unicast>> {
-
-    template <typename W, typename F, typename E>
-    bool force_push(W* wrapper, F&&, E*) {
-        wrapper->elems()->disconnect_receiver(1);
-        return false;
-    }
-
-    template <typename W, typename F, typename R, 
-              template <std::size_t, std::size_t> class E, std::size_t DS, std::size_t AS>
-    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E<DS, AS>* elems) {
-        byte_t buff[DS];
-        for (unsigned k = 0;;) {
-            auto cur_rd = rd_.load(std::memory_order_relaxed);
-            if (circ::index_of(cur_rd) ==
-                circ::index_of(wt_.load(std::memory_order_acquire))) {
-                return false; // empty
-            }
-            std::memcpy(buff, &(elems[circ::index_of(cur_rd)].data_), sizeof(buff));
-            if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
-                std::forward<F>(f)(buff);
-                std::forward<R>(out)(true);
-                return true;
-            }
-            ipc::yield(k);
-        }
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::multi , relat::multi, trans::unicast>>
-     : prod_cons_impl<wr<relat::single, relat::multi, trans::unicast>> {
-
-    using flag_t = std::uint64_t;
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-        std::atomic<flag_t> f_ct_ { 0 }; // commit flag
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> ct_; // commit index
-
-    template <typename W, typename F, typename E>
-    bool push(W* /*wrapper*/, F&& f, E* elems) {
-        circ::u2_t cur_ct, nxt_ct;
-        for (unsigned k = 0;;) {
-            cur_ct = ct_.load(std::memory_order_relaxed);
-            if (circ::index_of(nxt_ct = cur_ct + 1) ==
-                circ::index_of(rd_.load(std::memory_order_acquire))) {
-                return false; // full
-            }
-            if (ct_.compare_exchange_weak(cur_ct, nxt_ct, std::memory_order_acq_rel)) {
-                break;
-            }
-            ipc::yield(k);
-        }
-        auto* el = elems + circ::index_of(cur_ct);
-        std::forward<F>(f)(&(el->data_));
-        // set flag & try update wt
-        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
-        while (1) {
-            auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
-            if (cur_ct != wt_.load(std::memory_order_relaxed)) {
-                return true;
-            }
-            if ((~cac_ct) != cur_ct) {
-                return true;
-            }
-            if (!el->f_ct_.compare_exchange_strong(cac_ct, 0, std::memory_order_relaxed)) {
-                return true;
-            }
-            wt_.store(nxt_ct, std::memory_order_release);
-            cur_ct = nxt_ct;
-            nxt_ct = cur_ct + 1;
-            el = elems + circ::index_of(cur_ct);
-        }
-        return true;
-    }
-
-    template <typename W, typename F, typename E>
-    bool force_push(W* wrapper, F&&, E*) {
-        wrapper->elems()->disconnect_receiver(1);
-        return false;
-    }
-
-    template <typename W, typename F, typename R, 
-              template <std::size_t, std::size_t> class E, std::size_t DS, std::size_t AS>
-    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E<DS, AS>* elems) {
-        byte_t buff[DS];
-        for (unsigned k = 0;;) {
-            auto cur_rd = rd_.load(std::memory_order_relaxed);
-            auto cur_wt = wt_.load(std::memory_order_acquire);
-            auto id_rd  = circ::index_of(cur_rd);
-            auto id_wt  = circ::index_of(cur_wt);
-            if (id_rd == id_wt) {
-                auto* el = elems + id_wt;
-                auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
-                if ((~cac_ct) != cur_wt) {
-                    return false; // empty
-                }
-                if (el->f_ct_.compare_exchange_weak(cac_ct, 0, std::memory_order_relaxed)) {
-                    wt_.store(cur_wt + 1, std::memory_order_release);
-                }
-                k = 0;
-            }
-            else {
-                std::memcpy(buff, &(elems[circ::index_of(cur_rd)].data_), sizeof(buff));
-                if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
-                    std::forward<F>(f)(buff);
-                    std::forward<R>(out)(true);
-                    return true;
-                }
-                ipc::yield(k);
-            }
-        }
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::single, relat::multi, trans::broadcast>> {
-
-    using rc_t = std::uint64_t;
-
-    enum : rc_t {
-        ep_mask = 0x00000000ffffffffull,
-        ep_incr = 0x0000000100000000ull
-    };
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-        std::atomic<rc_t> rc_ { 0 }; // read-counter
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> wt_;   // write index
-    alignas(cache_line_size) rc_t epoch_ { 0 };             // only one writer
-
-    circ::u2_t cursor() const noexcept {
-        return wt_.load(std::memory_order_acquire);
-    }
-
-    template <typename W, typename F, typename E>
-    bool push(W* wrapper, F&& f, E* elems) {
-        E* el;
-        for (unsigned k = 0;;) {
-            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
-            if (cc == 0) return false; // no reader
-            el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
-            // check all consumers have finished reading this element
-            auto cur_rc = el->rc_.load(std::memory_order_acquire);
-            circ::cc_t rem_cc = cur_rc & ep_mask;
-            if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch_)) {
-                return false; // has not finished yet
-            }
-            // consider rem_cc to be 0 here
-            if (el->rc_.compare_exchange_weak(
-                        cur_rc, epoch_ | static_cast<rc_t>(cc), std::memory_order_release)) {
-                break;
-            }
-            ipc::yield(k);
-        }
-        std::forward<F>(f)(&(el->data_));
-        wt_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-
-    template <typename W, typename F, typename E>
-    bool force_push(W* wrapper, F&& f, E* elems) {
-        E* el;
-        epoch_ += ep_incr;
-        for (unsigned k = 0;;) {
-            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
-            if (cc == 0) return false; // no reader
-            el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
-            // check all consumers have finished reading this element
-            auto cur_rc = el->rc_.load(std::memory_order_acquire);
-            circ::cc_t rem_cc = cur_rc & ep_mask;
-            if (cc & rem_cc) {
-                ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc);
-                cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers
-                if (cc == 0) return false; // no reader
-            }
-            // just compare & exchange
-            if (el->rc_.compare_exchange_weak(
-                        cur_rc, epoch_ | static_cast<rc_t>(cc), std::memory_order_release)) {
-                break;
-            }
-            ipc::yield(k);
-        }
-        std::forward<F>(f)(&(el->data_));
-        wt_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-
-    template <typename W, typename F, typename R, typename E>
-    bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E* elems) {
-        if (cur == cursor()) return false; // acquire
-        auto* el = elems + circ::index_of(cur++);
-        std::forward<F>(f)(&(el->data_));
-        for (unsigned k = 0;;) {
-            auto cur_rc = el->rc_.load(std::memory_order_acquire);
-            if ((cur_rc & ep_mask) == 0) {
-                std::forward<R>(out)(true);
-                return true;
-            }
-            auto nxt_rc = cur_rc & ~static_cast<rc_t>(wrapper->connected_id());
-            if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) {
-                std::forward<R>(out)((nxt_rc & ep_mask) == 0);
-                return true;
-            }
-            ipc::yield(k);
-        }
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::multi, relat::multi, trans::broadcast>> {
-
-    using rc_t   = std::uint64_t;
-    using flag_t = std::uint64_t;
-
-    enum : rc_t {
-        rc_mask = 0x00000000ffffffffull,
-        ep_mask = 0x00ffffffffffffffull,
-        ep_incr = 0x0100000000000000ull,
-        ic_mask = 0xff000000ffffffffull,
-        ic_incr = 0x0000000100000000ull
-    };
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-        std::atomic<rc_t  > rc_   { 0 }; // read-counter
-        std::atomic<flag_t> f_ct_ { 0 }; // commit flag
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> ct_;   // commit index
-    alignas(cache_line_size) std::atomic<rc_t> epoch_ { 0 };
-
-    circ::u2_t cursor() const noexcept {
-        return ct_.load(std::memory_order_acquire);
-    }
-
-    constexpr static rc_t inc_rc(rc_t rc) noexcept {
-        return (rc & ic_mask) | ((rc + ic_incr) & ~ic_mask);
-    }
-
-    constexpr static rc_t inc_mask(rc_t rc) noexcept {
-        return inc_rc(rc) & ~rc_mask;
-    }
-
-    template <typename W, typename F, typename E>
-    bool push(W* wrapper, F&& f, E* elems) {
-        E* el;
-        circ::u2_t cur_ct;
-        rc_t epoch = epoch_.load(std::memory_order_acquire);
-        for (unsigned k = 0;;) {
-            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
-            if (cc == 0) return false; // no reader
-            el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed));
-            // check all consumers have finished reading this element
-            auto cur_rc = el->rc_.load(std::memory_order_relaxed);
-            circ::cc_t rem_cc = cur_rc & rc_mask;
-            if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch)) {
-                return false; // has not finished yet
-            }
-            else if (!rem_cc) {
-                auto cur_fl = el->f_ct_.load(std::memory_order_acquire);
-                if ((cur_fl != cur_ct) && cur_fl) {
-                    return false; // full
-                }
-            }
-            // consider rem_cc to be 0 here
-            if (el->rc_.compare_exchange_weak(
-                        cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast<rc_t>(cc), std::memory_order_relaxed) &&
-                epoch_.compare_exchange_weak(epoch, epoch, std::memory_order_acq_rel)) {
-                break;
-            }
-            ipc::yield(k);
-        }
-        // only one thread/process would touch here at one time
-        ct_.store(cur_ct + 1, std::memory_order_release);
-        std::forward<F>(f)(&(el->data_));
-        // set flag & try update wt
-        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
-        return true;
-    }
-
-    template <typename W, typename F, typename E>
-    bool force_push(W* wrapper, F&& f, E* elems) {
-        E* el;
-        circ::u2_t cur_ct;
-        rc_t epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr;
-        for (unsigned k = 0;;) {
-            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
-            if (cc == 0) return false; // no reader
-            el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed));
-            // check all consumers have finished reading this element
-            auto cur_rc = el->rc_.load(std::memory_order_acquire);
-            circ::cc_t rem_cc = cur_rc & rc_mask;
-            if (cc & rem_cc) {
-                ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc);
-                cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers
-                if (cc == 0) return false; // no reader
-            }
-            // just compare & exchange
-            if (el->rc_.compare_exchange_weak(
-                        cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast<rc_t>(cc), std::memory_order_relaxed)) {
-                if (epoch == epoch_.load(std::memory_order_acquire)) {
-                    break;
-                }
-                else if (push(wrapper, std::forward<F>(f), elems)) {
-                    return true;
-                }
-                epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr;
-            }
-            ipc::yield(k);
-        }
-        // only one thread/process would touch here at one time
-        ct_.store(cur_ct + 1, std::memory_order_release);
-        std::forward<F>(f)(&(el->data_));
-        // set flag & try update wt
-        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
-        return true;
-    }
-
-    template <typename W, typename F, typename R, typename E, std::size_t N>
-    bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E(& elems)[N]) {
-        auto* el = elems + circ::index_of(cur);
-        auto cur_fl = el->f_ct_.load(std::memory_order_acquire);
-        if (cur_fl != ~static_cast<flag_t>(cur)) {
-            return false; // empty
-        }
-        ++cur;
-        std::forward<F>(f)(&(el->data_));
-        for (unsigned k = 0;;) {
-            auto cur_rc = el->rc_.load(std::memory_order_acquire);
-            if ((cur_rc & rc_mask) == 0) {
-                std::forward<R>(out)(true);
-                el->f_ct_.store(cur + N - 1, std::memory_order_release);
-                return true;
-            }
-            auto nxt_rc = inc_rc(cur_rc) & ~static_cast<rc_t>(wrapper->connected_id());
-            bool last_one = false;
-            if ((last_one = (nxt_rc & rc_mask) == 0)) {
-                el->f_ct_.store(cur + N - 1, std::memory_order_release);
-            }
-            if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) {
-                std::forward<R>(out)(last_one);
-                return true;
-            }
-            ipc::yield(k);
-        }
-    }
-};
-
-} // namespace ipc

crazy_functions/test_project/cpp/cppipc/queue.h

@@ -1,216 +0,0 @@
-#pragma once
-
-#include <type_traits>
-#include <new>
-#include <utility>  // [[since C++14]]: std::exchange
-#include <algorithm>
-#include <atomic>
-#include <tuple>
-#include <thread>
-#include <chrono>
-#include <string>
-#include <cassert>  // assert
-
-#include "libipc/def.h"
-#include "libipc/shm.h"
-#include "libipc/rw_lock.h"
-
-#include "libipc/utility/log.h"
-#include "libipc/platform/detail.h"
-#include "libipc/circ/elem_def.h"
-
-namespace ipc {
-namespace detail {
-
-class queue_conn {
-protected:
-    circ::cc_t connected_ = 0;
-    shm::handle elems_h_;
-
-    template <typename Elems>
-    Elems* open(char const * name) {
-        if (name == nullptr || name[0] == '\0') {
-            ipc::error("fail open waiter: name is empty!\n");
-            return nullptr;
-        }
-        if (!elems_h_.acquire(name, sizeof(Elems))) {
-            return nullptr;
-        }
-        auto elems = static_cast<Elems*>(elems_h_.get());
-        if (elems == nullptr) {
-            ipc::error("fail acquire elems: %s\n", name);
-            return nullptr;
-        }
-        elems->init();
-        return elems;
-    }
-
-    void close() {
-        elems_h_.release();
-    }
-
-public:
-    queue_conn() = default;
-    queue_conn(const queue_conn&) = delete;
-    queue_conn& operator=(const queue_conn&) = delete;
-
-    bool connected() const noexcept {
-        return connected_ != 0;
-    }
-
-    circ::cc_t connected_id() const noexcept {
-        return connected_;
-    }
-
-    template <typename Elems>
-    auto connect(Elems* elems) noexcept
-                         /*needs 'optional' here*/
-     -> std::tuple<bool, bool, decltype(std::declval<Elems>().cursor())> {
-        if (elems == nullptr) return {};
-        // if it's already connected, just return
-        if (connected()) return {connected(), false, 0};
-        connected_ = elems->connect_receiver();
-        return {connected(), true, elems->cursor()};
-    }
-
-    template <typename Elems>
-    bool disconnect(Elems* elems) noexcept {
-        if (elems == nullptr) return false;
-        // if it's already disconnected, just return false
-        if (!connected()) return false;
-        elems->disconnect_receiver(std::exchange(connected_, 0));
-        return true;
-    }
-};
-
-template <typename Elems>
-class queue_base : public queue_conn {
-    using base_t = queue_conn;
-
-public:
-    using elems_t  = Elems;
-    using policy_t = typename elems_t::policy_t;
-
-protected:
-    elems_t * elems_ = nullptr;
-    decltype(std::declval<elems_t>().cursor()) cursor_ = 0;
-    bool sender_flag_ = false;
-
-public:
-    using base_t::base_t;
-
-    queue_base() = default;
-
-    explicit queue_base(char const * name)
-        : queue_base{} {
-        elems_ = open<elems_t>(name);
-    }
-
-    explicit queue_base(elems_t * elems) noexcept
-        : queue_base{} {
-        assert(elems != nullptr);
-        elems_ = elems;
-    }
-
-    /* not virtual */ ~queue_base() {
-        base_t::close();
-    }
-
-    elems_t       * elems()       noexcept { return elems_; }
-    elems_t const * elems() const noexcept { return elems_; }
-
-    bool ready_sending() noexcept {
-        if (elems_ == nullptr) return false;
-        return sender_flag_ || (sender_flag_ = elems_->connect_sender());
-    }
-
-    void shut_sending() noexcept {
-        if (elems_ == nullptr) return;
-        if (!sender_flag_) return;
-        elems_->disconnect_sender();
-    }
-
-    bool connect() noexcept {
-        auto tp = base_t::connect(elems_);
-        if (std::get<0>(tp) && std::get<1>(tp)) {
-            cursor_ = std::get<2>(tp);
-            return true;
-        }
-        return std::get<0>(tp);
-    }
-
-    bool disconnect() noexcept {
-        return base_t::disconnect(elems_);
-    }
-
-    std::size_t conn_count() const noexcept {
-        return (elems_ == nullptr) ? static_cast<std::size_t>(invalid_value) : elems_->conn_count();
-    }
-
-    bool valid() const noexcept {
-        return elems_ != nullptr;
-    }
-
-    bool empty() const noexcept {
-        return !valid() || (cursor_ == elems_->cursor());
-    }
-
-    template <typename T, typename F, typename... P>
-    bool push(F&& prep, P&&... params) {
-        if (elems_ == nullptr) return false;
-        return elems_->push(this, [&](void* p) {
-            if (prep(p)) ::new (p) T(std::forward<P>(params)...);
-        });
-    }
-
-    template <typename T, typename F, typename... P>
-    bool force_push(F&& prep, P&&... params) {
-        if (elems_ == nullptr) return false;
-        return elems_->force_push(this, [&](void* p) {
-            if (prep(p)) ::new (p) T(std::forward<P>(params)...);
-        });
-    }
-
-    template <typename T, typename F>
-    bool pop(T& item, F&& out) {
-        if (elems_ == nullptr) {
-            return false;
-        }
-        return elems_->pop(this, &(this->cursor_), [&item](void* p) {
-            ::new (&item) T(std::move(*static_cast<T*>(p)));
-        }, std::forward<F>(out));
-    }
-};
-
-} // namespace detail
-
-template <typename T, typename Policy>
-class queue final : public detail::queue_base<typename Policy::template elems_t<sizeof(T), alignof(T)>> {
-    using base_t = detail::queue_base<typename Policy::template elems_t<sizeof(T), alignof(T)>>;
-
-public:
-    using value_t = T;
-
-    using base_t::base_t;
-
-    template <typename... P>
-    bool push(P&&... params) {
-        return base_t::template push<T>(std::forward<P>(params)...);
-    }
-
-    template <typename... P>
-    bool force_push(P&&... params) {
-        return base_t::template force_push<T>(std::forward<P>(params)...);
-    }
-
-    bool pop(T& item) {
-        return base_t::pop(item, [](bool) {});
-    }
-
-    template <typename F>
-    bool pop(T& item, F&& out) {
-        return base_t::pop(item, std::forward<F>(out));
-    }
-};
-
-} // namespace ipc

crazy_functions/test_project/cpp/cppipc/shm.cpp

@@ -1,103 +0,0 @@
-
-#include <string>
-#include <utility>
-
-#include "libipc/shm.h"
-
-#include "libipc/utility/pimpl.h"
-#include "libipc/memory/resource.h"
-
-namespace ipc {
-namespace shm {
-
-class handle::handle_ : public pimpl<handle_> {
-public:
-    shm::id_t id_ = nullptr;
-    void*     m_  = nullptr;
-
-    ipc::string n_;
-    std::size_t s_ = 0;
-};
-
-handle::handle()
-    : p_(p_->make()) {
-}
-
-handle::handle(char const * name, std::size_t size, unsigned mode)
-    : handle() {
-    acquire(name, size, mode);
-}
-
-handle::handle(handle&& rhs)
-    : handle() {
-    swap(rhs);
-}
-
-handle::~handle() {
-    release();
-    p_->clear();
-}
-
-void handle::swap(handle& rhs) {
-    std::swap(p_, rhs.p_);
-}
-
-handle& handle::operator=(handle rhs) {
-    swap(rhs);
-    return *this;
-}
-
-bool handle::valid() const noexcept {
-    return impl(p_)->m_ != nullptr;
-}
-
-std::size_t handle::size() const noexcept {
-    return impl(p_)->s_;
-}
-
-char const * handle::name() const noexcept {
-    return impl(p_)->n_.c_str();
-}
-
-std::int32_t handle::ref() const noexcept {
-    return shm::get_ref(impl(p_)->id_);
-}
-
-void handle::sub_ref() noexcept {
-    shm::sub_ref(impl(p_)->id_);
-}
-
-bool handle::acquire(char const * name, std::size_t size, unsigned mode) {
-    release();
-    impl(p_)->id_ = shm::acquire((impl(p_)->n_ = name).c_str(), size, mode);
-    impl(p_)->m_  = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
-    return valid();
-}
-
-std::int32_t handle::release() {
-    if (impl(p_)->id_ == nullptr) return -1;
-    return shm::release(detach());
-}
-
-void* handle::get() const {
-    return impl(p_)->m_;
-}
-
-void handle::attach(id_t id) {
-    if (id == nullptr) return;
-    release();
-    impl(p_)->id_ = id;
-    impl(p_)->m_  = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
-}
-
-id_t handle::detach() {
-    auto old = impl(p_)->id_;
-    impl(p_)->id_ = nullptr;
-    impl(p_)->m_  = nullptr;
-    impl(p_)->s_  = 0;
-    impl(p_)->n_.clear();
-    return old;
-}
-
-} // namespace shm
-} // namespace ipc

crazy_functions/test_project/cpp/cppipc/waiter.h

@@ -1,83 +0,0 @@
-#pragma once
-
-#include <utility>
-#include <string>
-#include <mutex>
-#include <atomic>
-
-#include "libipc/def.h"
-#include "libipc/mutex.h"
-#include "libipc/condition.h"
-#include "libipc/platform/detail.h"
-
-namespace ipc {
-namespace detail {
-
-class waiter {
-    ipc::sync::condition cond_;
-    ipc::sync::mutex     lock_;
-    std::atomic<bool>    quit_ {false};
-
-public:
-    static void init();
-
-    waiter() = default;
-    waiter(char const *name) {
-        open(name);
-    }
-
-    ~waiter() {
-        close();
-    }
-
-    bool valid() const noexcept {
-        return cond_.valid() && lock_.valid();
-    }
-
-    bool open(char const *name) noexcept {
-        quit_.store(false, std::memory_order_relaxed);
-        if (!cond_.open((std::string{"_waiter_cond_"} + name).c_str())) {
-            return false;
-        }
-        if (!lock_.open((std::string{"_waiter_lock_"} + name).c_str())) {
-            cond_.close();
-            return false;
-        }
-        return valid();
-    }
-
-    void close() noexcept {
-        cond_.close();
-        lock_.close();
-    }
-
-    template <typename F>
-    bool wait_if(F &&pred, std::uint64_t tm = ipc::invalid_value) noexcept {
-        IPC_UNUSED_ std::lock_guard<ipc::sync::mutex> guard {lock_};
-        while ([this, &pred] {
-                    return !quit_.load(std::memory_order_relaxed)
-                        && std::forward<F>(pred)();
-                }()) {
-            if (!cond_.wait(lock_, tm)) return false;
-        }
-        return true;
-    }
-
-    bool notify() noexcept {
-        std::lock_guard<ipc::sync::mutex>{lock_}; // barrier
-        return cond_.notify(lock_);
-    }
-
-    bool broadcast() noexcept {
-        std::lock_guard<ipc::sync::mutex>{lock_}; // barrier
-        return cond_.broadcast(lock_);
-    }
-
-    bool quit_waiting() {
-        quit_.store(true, std::memory_order_release);
-        return broadcast();
-    }
-};
-
-} // namespace detail
-} // namespace ipc

crazy_functions/test_project/cpp/cppipc/来源

@@ -1,3 +0,0 @@
-https://github.com/mutouyun/cpp-ipc
-
-A high-performance inter-process communication library using shared memory on Linux/Windows.

crazy_functions/test_project/cpp/libJPG/jpgd.h

@@ -1,316 +0,0 @@
-// jpgd.h - C++ class for JPEG decompression.
-// Public domain, Rich Geldreich <richgel99@gmail.com>
-#ifndef JPEG_DECODER_H
-#define JPEG_DECODER_H
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <setjmp.h>
-
-namespace jpgd
-{
-  typedef unsigned char  uint8;
-  typedef   signed short int16;
-  typedef unsigned short uint16;
-  typedef unsigned int   uint;
-  typedef   signed int   int32;
-
-  // Loads a JPEG image from a memory buffer or a file.
-  // req_comps can be 1 (grayscale), 3 (RGB), or 4 (RGBA).
-  // On return, width/height will be set to the image's dimensions, and actual_comps will be set to the either 1 (grayscale) or 3 (RGB).
-  // Notes: For more control over where and how the source data is read, see the decompress_jpeg_image_from_stream() function below, or call the jpeg_decoder class directly.
-  // Requesting a 8 or 32bpp image is currently a little faster than 24bpp because the jpeg_decoder class itself currently always unpacks to either 8 or 32bpp.
-// BEGIN EPIC MOD
-//unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps);
-  unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps, int format);
-// END EPIC MOD
-  unsigned char *decompress_jpeg_image_from_file(const char *pSrc_filename, int *width, int *height, int *actual_comps, int req_comps);
-
-  // Success/failure error codes.
-  enum jpgd_status
-  {
-    JPGD_SUCCESS = 0, JPGD_FAILED = -1, JPGD_DONE = 1,
-    JPGD_BAD_DHT_COUNTS = -256, JPGD_BAD_DHT_INDEX, JPGD_BAD_DHT_MARKER, JPGD_BAD_DQT_MARKER, JPGD_BAD_DQT_TABLE, 
-    JPGD_BAD_PRECISION, JPGD_BAD_HEIGHT, JPGD_BAD_WIDTH, JPGD_TOO_MANY_COMPONENTS, 
-    JPGD_BAD_SOF_LENGTH, JPGD_BAD_VARIABLE_MARKER, JPGD_BAD_DRI_LENGTH, JPGD_BAD_SOS_LENGTH,
-    JPGD_BAD_SOS_COMP_ID, JPGD_W_EXTRA_BYTES_BEFORE_MARKER, JPGD_NO_ARITHMITIC_SUPPORT, JPGD_UNEXPECTED_MARKER,
-    JPGD_NOT_JPEG, JPGD_UNSUPPORTED_MARKER, JPGD_BAD_DQT_LENGTH, JPGD_TOO_MANY_BLOCKS,
-    JPGD_UNDEFINED_QUANT_TABLE, JPGD_UNDEFINED_HUFF_TABLE, JPGD_NOT_SINGLE_SCAN, JPGD_UNSUPPORTED_COLORSPACE,
-    JPGD_UNSUPPORTED_SAMP_FACTORS, JPGD_DECODE_ERROR, JPGD_BAD_RESTART_MARKER, JPGD_ASSERTION_ERROR,
-    JPGD_BAD_SOS_SPECTRAL, JPGD_BAD_SOS_SUCCESSIVE, JPGD_STREAM_READ, JPGD_NOTENOUGHMEM
-  };
-    
-  // Input stream interface.
-  // Derive from this class to read input data from sources other than files or memory. Set m_eof_flag to true when no more data is available.
-  // The decoder is rather greedy: it will keep on calling this method until its internal input buffer is full, or until the EOF flag is set.
-  // It the input stream contains data after the JPEG stream's EOI (end of image) marker it will probably be pulled into the internal buffer.
-  // Call the get_total_bytes_read() method to determine the actual size of the JPEG stream after successful decoding.
-  class jpeg_decoder_stream
-  {
-  public:
-    jpeg_decoder_stream() { }
-    virtual ~jpeg_decoder_stream() { }
-
-    // The read() method is called when the internal input buffer is empty.
-    // Parameters:
-    // pBuf - input buffer
-    // max_bytes_to_read - maximum bytes that can be written to pBuf
-    // pEOF_flag - set this to true if at end of stream (no more bytes remaining)
-    // Returns -1 on error, otherwise return the number of bytes actually written to the buffer (which may be 0).
-    // Notes: This method will be called in a loop until you set *pEOF_flag to true or the internal buffer is full.
-    virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag) = 0;
-  };
-
-  // stdio FILE stream class.
-  class jpeg_decoder_file_stream : public jpeg_decoder_stream
-  {
-    jpeg_decoder_file_stream(const jpeg_decoder_file_stream &);
-    jpeg_decoder_file_stream &operator =(const jpeg_decoder_file_stream &);
-
-    FILE *m_pFile;
-    bool m_eof_flag, m_error_flag;
-
-  public:
-    jpeg_decoder_file_stream();
-    virtual ~jpeg_decoder_file_stream();
-    
-    bool open(const char *Pfilename);
-    void close();
-
-    virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
-  };
-
-  // Memory stream class.
-  class jpeg_decoder_mem_stream : public jpeg_decoder_stream
-  {
-    const uint8 *m_pSrc_data;
-    uint m_ofs, m_size;
-
-  public:
-    jpeg_decoder_mem_stream() : m_pSrc_data(NULL), m_ofs(0), m_size(0) { }
-    jpeg_decoder_mem_stream(const uint8 *pSrc_data, uint size) : m_pSrc_data(pSrc_data), m_ofs(0), m_size(size) { }
-
-    virtual ~jpeg_decoder_mem_stream() { }
-
-    bool open(const uint8 *pSrc_data, uint size);
-    void close() { m_pSrc_data = NULL; m_ofs = 0; m_size = 0; }
-    
-    virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
-  };
-
-  // Loads JPEG file from a jpeg_decoder_stream.
-  unsigned char *decompress_jpeg_image_from_stream(jpeg_decoder_stream *pStream, int *width, int *height, int *actual_comps, int req_comps);
-
-  enum 
-  { 
-    JPGD_IN_BUF_SIZE = 8192, JPGD_MAX_BLOCKS_PER_MCU = 10, JPGD_MAX_HUFF_TABLES = 8, JPGD_MAX_QUANT_TABLES = 4, 
-    JPGD_MAX_COMPONENTS = 4, JPGD_MAX_COMPS_IN_SCAN = 4, JPGD_MAX_BLOCKS_PER_ROW = 8192, JPGD_MAX_HEIGHT = 16384, JPGD_MAX_WIDTH = 16384 
-  };
-          
-  typedef int16 jpgd_quant_t;
-  typedef int16 jpgd_block_t;
-
-  class jpeg_decoder
-  {
-  public:
-    // Call get_error_code() after constructing to determine if the stream is valid or not. You may call the get_width(), get_height(), etc.
-    // methods after the constructor is called. You may then either destruct the object, or begin decoding the image by calling begin_decoding(), then decode() on each scanline.
-    jpeg_decoder(jpeg_decoder_stream *pStream);
-
-    ~jpeg_decoder();
-
-    // Call this method after constructing the object to begin decompression.
-    // If JPGD_SUCCESS is returned you may then call decode() on each scanline.
-    int begin_decoding();
-
-    // Returns the next scan line.
-    // For grayscale images, pScan_line will point to a buffer containing 8-bit pixels (get_bytes_per_pixel() will return 1). 
-    // Otherwise, it will always point to a buffer containing 32-bit RGBA pixels (A will always be 255, and get_bytes_per_pixel() will return 4).
-    // Returns JPGD_SUCCESS if a scan line has been returned.
-    // Returns JPGD_DONE if all scan lines have been returned.
-    // Returns JPGD_FAILED if an error occurred. Call get_error_code() for a more info.
-    int decode(const void** pScan_line, uint* pScan_line_len);
-    
-    inline jpgd_status get_error_code() const { return m_error_code; }
-
-    inline int get_width() const { return m_image_x_size; }
-    inline int get_height() const { return m_image_y_size; }
-
-    inline int get_num_components() const { return m_comps_in_frame; }
-
-    inline int get_bytes_per_pixel() const { return m_dest_bytes_per_pixel; }
-    inline int get_bytes_per_scan_line() const { return m_image_x_size * get_bytes_per_pixel(); }
-
-    // Returns the total number of bytes actually consumed by the decoder (which should equal the actual size of the JPEG file).
-    inline int get_total_bytes_read() const { return m_total_bytes_read; }
-    
-  private:
-    jpeg_decoder(const jpeg_decoder &);
-    jpeg_decoder &operator =(const jpeg_decoder &);
-
-    typedef void (*pDecode_block_func)(jpeg_decoder *, int, int, int);
-
-    struct huff_tables
-    {
-      bool ac_table;
-      uint  look_up[256];
-      uint  look_up2[256];
-      uint8 code_size[256];
-      uint  tree[512];
-    };
-
-    struct coeff_buf
-    {
-      uint8 *pData;
-      int block_num_x, block_num_y;
-      int block_len_x, block_len_y;
-      int block_size;
-    };
-
-    struct mem_block
-    {
-      mem_block *m_pNext;
-      size_t m_used_count;
-      size_t m_size;
-      char m_data[1];
-    };
-
-    jmp_buf m_jmp_state;
-    mem_block *m_pMem_blocks;
-    int m_image_x_size;
-    int m_image_y_size;
-    jpeg_decoder_stream *m_pStream;
-    int m_progressive_flag;
-    uint8 m_huff_ac[JPGD_MAX_HUFF_TABLES];
-    uint8* m_huff_num[JPGD_MAX_HUFF_TABLES];      // pointer to number of Huffman codes per bit size
-    uint8* m_huff_val[JPGD_MAX_HUFF_TABLES];      // pointer to Huffman codes per bit size
-    jpgd_quant_t* m_quant[JPGD_MAX_QUANT_TABLES]; // pointer to quantization tables
-    int m_scan_type;                              // Gray, Yh1v1, Yh1v2, Yh2v1, Yh2v2 (CMYK111, CMYK4114 no longer supported)
-    int m_comps_in_frame;                         // # of components in frame
-    int m_comp_h_samp[JPGD_MAX_COMPONENTS];       // component's horizontal sampling factor
-    int m_comp_v_samp[JPGD_MAX_COMPONENTS];       // component's vertical sampling factor
-    int m_comp_quant[JPGD_MAX_COMPONENTS];        // component's quantization table selector
-    int m_comp_ident[JPGD_MAX_COMPONENTS];        // component's ID
-    int m_comp_h_blocks[JPGD_MAX_COMPONENTS];
-    int m_comp_v_blocks[JPGD_MAX_COMPONENTS];
-    int m_comps_in_scan;                          // # of components in scan
-    int m_comp_list[JPGD_MAX_COMPS_IN_SCAN];      // components in this scan
-    int m_comp_dc_tab[JPGD_MAX_COMPONENTS];       // component's DC Huffman coding table selector
-    int m_comp_ac_tab[JPGD_MAX_COMPONENTS];       // component's AC Huffman coding table selector
-    int m_spectral_start;                         // spectral selection start
-    int m_spectral_end;                           // spectral selection end
-    int m_successive_low;                         // successive approximation low
-    int m_successive_high;                        // successive approximation high
-    int m_max_mcu_x_size;                         // MCU's max. X size in pixels
-    int m_max_mcu_y_size;                         // MCU's max. Y size in pixels
-    int m_blocks_per_mcu;
-    int m_max_blocks_per_row;
-    int m_mcus_per_row, m_mcus_per_col;
-    int m_mcu_org[JPGD_MAX_BLOCKS_PER_MCU];
-    int m_total_lines_left;                       // total # lines left in image
-    int m_mcu_lines_left;                         // total # lines left in this MCU
-    int m_real_dest_bytes_per_scan_line;
-    int m_dest_bytes_per_scan_line;               // rounded up
-    int m_dest_bytes_per_pixel;                   // 4 (RGB) or 1 (Y)
-    huff_tables* m_pHuff_tabs[JPGD_MAX_HUFF_TABLES];
-    coeff_buf* m_dc_coeffs[JPGD_MAX_COMPONENTS];
-    coeff_buf* m_ac_coeffs[JPGD_MAX_COMPONENTS];
-    int m_eob_run;
-    int m_block_y_mcu[JPGD_MAX_COMPONENTS];
-    uint8* m_pIn_buf_ofs;
-    int m_in_buf_left;
-    int m_tem_flag;
-    bool m_eof_flag;
-    uint8 m_in_buf_pad_start[128];
-    uint8 m_in_buf[JPGD_IN_BUF_SIZE + 128];
-    uint8 m_in_buf_pad_end[128];
-    int m_bits_left;
-    uint m_bit_buf;
-    int m_restart_interval;
-    int m_restarts_left;
-    int m_next_restart_num;
-    int m_max_mcus_per_row;
-    int m_max_blocks_per_mcu;
-    int m_expanded_blocks_per_mcu;
-    int m_expanded_blocks_per_row;
-    int m_expanded_blocks_per_component;
-    bool  m_freq_domain_chroma_upsample;
-    int m_max_mcus_per_col;
-    uint m_last_dc_val[JPGD_MAX_COMPONENTS];
-    jpgd_block_t* m_pMCU_coefficients;
-    int m_mcu_block_max_zag[JPGD_MAX_BLOCKS_PER_MCU];
-    uint8* m_pSample_buf;
-    int m_crr[256];
-    int m_cbb[256];
-    int m_crg[256];
-    int m_cbg[256];
-    uint8* m_pScan_line_0;
-    uint8* m_pScan_line_1;
-    jpgd_status m_error_code;
-    bool m_ready_flag;
-    int m_total_bytes_read;
-
-    void free_all_blocks();
-    // BEGIN EPIC MOD
-    UE_NORETURN void stop_decoding(jpgd_status status);
-    // END EPIC MOD
-    void *alloc(size_t n, bool zero = false);
-    void word_clear(void *p, uint16 c, uint n);
-    void prep_in_buffer();
-    void read_dht_marker();
-    void read_dqt_marker();
-    void read_sof_marker();
-    void skip_variable_marker();
-    void read_dri_marker();
-    void read_sos_marker();
-    int next_marker();
-    int process_markers();
-    void locate_soi_marker();
-    void locate_sof_marker();
-    int locate_sos_marker();
-    void init(jpeg_decoder_stream * pStream);
-    void create_look_ups();
-    void fix_in_buffer();
-    void transform_mcu(int mcu_row);
-    void transform_mcu_expand(int mcu_row);
-    coeff_buf* coeff_buf_open(int block_num_x, int block_num_y, int block_len_x, int block_len_y);
-    inline jpgd_block_t *coeff_buf_getp(coeff_buf *cb, int block_x, int block_y);
-    void load_next_row();
-    void decode_next_row();
-    void make_huff_table(int index, huff_tables *pH);
-    void check_quant_tables();
-    void check_huff_tables();
-    void calc_mcu_block_order();
-    int init_scan();
-    void init_frame();
-    void process_restart();
-    void decode_scan(pDecode_block_func decode_block_func);
-    void init_progressive();
-    void init_sequential();
-    void decode_start();
-    void decode_init(jpeg_decoder_stream * pStream);
-    void H2V2Convert();
-    void H2V1Convert();
-    void H1V2Convert();
-    void H1V1Convert();
-    void gray_convert();
-    void expanded_convert();
-    void find_eoi();
-    inline uint get_char();
-    inline uint get_char(bool *pPadding_flag);
-    inline void stuff_char(uint8 q);
-    inline uint8 get_octet();
-    inline uint get_bits(int num_bits);
-    inline uint get_bits_no_markers(int numbits);
-    inline int huff_decode(huff_tables *pH);
-    inline int huff_decode(huff_tables *pH, int& extrabits);
-    static inline uint8 clamp(int i);
-    static void decode_block_dc_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
-    static void decode_block_dc_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
-    static void decode_block_ac_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
-    static void decode_block_ac_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
-  };
-  
-} // namespace jpgd
-
-#endif // JPEG_DECODER_H

crazy_functions/test_project/cpp/libJPG/jpge.h

@@ -1,172 +0,0 @@
-
-// jpge.h - C++ class for JPEG compression.
-// Public domain, Rich Geldreich <richgel99@gmail.com>
-// Alex Evans: Added RGBA support, linear memory allocator.
-#ifndef JPEG_ENCODER_H
-#define JPEG_ENCODER_H
-
-#include <stdint.h>
-
-namespace jpge
-{
-  typedef unsigned char  uint8;
-  typedef signed short   int16;
-  typedef signed int     int32;
-  typedef unsigned short uint16;
-  typedef unsigned int   uint32;
-  typedef unsigned int   uint;
-
-  // JPEG chroma subsampling factors. Y_ONLY (grayscale images) and H2V2 (color images) are the most common.
-  enum subsampling_t { Y_ONLY = 0, H1V1 = 1, H2V1 = 2, H2V2 = 3 };
-
-  // JPEG compression parameters structure.
-  struct params
-  {
-    inline params() : m_quality(85), m_subsampling(H2V2), m_no_chroma_discrim_flag(false), m_two_pass_flag(false) { }
-
-    inline bool check_valid() const
-    {
-      if ((m_quality < 1) || (m_quality > 100)) return false;
-      if ((uint)m_subsampling > (uint)H2V2) return false;
-      return true;
-    }
-
-    // Quality: 1-100, higher is better. Typical values are around 50-95.
-    int m_quality;
-
-    // m_subsampling:
-    // 0 = Y (grayscale) only
-    // 1 = YCbCr, no subsampling (H1V1, YCbCr 1x1x1, 3 blocks per MCU)
-    // 2 = YCbCr, H2V1 subsampling (YCbCr 2x1x1, 4 blocks per MCU)
-    // 3 = YCbCr, H2V2 subsampling (YCbCr 4x1x1, 6 blocks per MCU-- very common)
-    subsampling_t m_subsampling;
-
-    // Disables CbCr discrimination - only intended for testing.
-    // If true, the Y quantization table is also used for the CbCr channels.
-    bool m_no_chroma_discrim_flag;
-
-    bool m_two_pass_flag;
-  };
-  
-  // Writes JPEG image to a file. 
-  // num_channels must be 1 (Y) or 3 (RGB), image pitch must be width*num_channels.
-  bool compress_image_to_jpeg_file(const char *pFilename, int64_t width, int64_t height, int64_t num_channels, const uint8 *pImage_data, const params &comp_params = params());
-
-  // Writes JPEG image to memory buffer. 
-  // On entry, buf_size is the size of the output buffer pointed at by pBuf, which should be at least ~1024 bytes. 
-  // If return value is true, buf_size will be set to the size of the compressed data.
-  bool compress_image_to_jpeg_file_in_memory(void *pBuf, int64_t &buf_size, int64_t width, int64_t height, int64_t num_channels, const uint8 *pImage_data, const params &comp_params = params());
-    
-  // Output stream abstract class - used by the jpeg_encoder class to write to the output stream. 
-  // put_buf() is generally called with len==JPGE_OUT_BUF_SIZE bytes, but for headers it'll be called with smaller amounts.
-  class output_stream
-  {
-  public:
-    virtual ~output_stream() { };
-    virtual bool put_buf(const void* Pbuf, int64_t len) = 0;
-    template<class T> inline bool put_obj(const T& obj) { return put_buf(&obj, sizeof(T)); }
-  };
-    
-  // Lower level jpeg_encoder class - useful if more control is needed than the above helper functions.
-  class jpeg_encoder
-  {
-  public:
-    jpeg_encoder();
-    ~jpeg_encoder();
-
-    // Initializes the compressor.
-    // pStream: The stream object to use for writing compressed data.
-    // params - Compression parameters structure, defined above.
-    // width, height  - Image dimensions.
-    // channels - May be 1, or 3. 1 indicates grayscale, 3 indicates RGB source data.
-    // Returns false on out of memory or if a stream write fails.
-    bool init(output_stream *pStream, int64_t width, int64_t height, int64_t src_channels, const params &comp_params = params());
-    
-    const params &get_params() const { return m_params; }
-    
-    // Deinitializes the compressor, freeing any allocated memory. May be called at any time.
-    void deinit();
-
-    uint get_total_passes() const { return m_params.m_two_pass_flag ? 2 : 1; }
-    inline uint get_cur_pass() { return m_pass_num; }
-
-    // Call this method with each source scanline.
-    // width * src_channels bytes per scanline is expected (RGB or Y format).
-    // You must call with NULL after all scanlines are processed to finish compression.
-    // Returns false on out of memory or if a stream write fails.
-    bool process_scanline(const void* pScanline);
-        
-  private:
-    jpeg_encoder(const jpeg_encoder &);
-    jpeg_encoder &operator =(const jpeg_encoder &);
-
-    typedef int32 sample_array_t;
-        
-    output_stream *m_pStream;
-    params m_params;
-    uint8 m_num_components;
-    uint8 m_comp_h_samp[3], m_comp_v_samp[3];
-    int m_image_x, m_image_y, m_image_bpp, m_image_bpl;
-    int m_image_x_mcu, m_image_y_mcu;
-    int m_image_bpl_xlt, m_image_bpl_mcu;
-    int m_mcus_per_row;
-    int m_mcu_x, m_mcu_y;
-    uint8 *m_mcu_lines[16];
-    uint8 m_mcu_y_ofs;
-    sample_array_t m_sample_array[64];
-    int16 m_coefficient_array[64];
-    int32 m_quantization_tables[2][64];
-    uint m_huff_codes[4][256];
-    uint8 m_huff_code_sizes[4][256];
-    uint8 m_huff_bits[4][17];
-    uint8 m_huff_val[4][256];
-    uint32 m_huff_count[4][256];
-    int m_last_dc_val[3];
-    enum { JPGE_OUT_BUF_SIZE = 2048 };
-    uint8 m_out_buf[JPGE_OUT_BUF_SIZE];
-    uint8 *m_pOut_buf;
-    uint m_out_buf_left;
-    uint32 m_bit_buffer;
-    uint m_bits_in;
-    uint8 m_pass_num;
-    bool m_all_stream_writes_succeeded;
-        
-    void optimize_huffman_table(int table_num, int table_len);
-    void emit_byte(uint8 i);
-    void emit_word(uint i);
-    void emit_marker(int marker);
-    void emit_jfif_app0();
-    void emit_dqt();
-    void emit_sof();
-    void emit_dht(uint8 *bits, uint8 *val, int index, bool ac_flag);
-    void emit_dhts();
-    void emit_sos();
-    void emit_markers();
-    void compute_huffman_table(uint *codes, uint8 *code_sizes, uint8 *bits, uint8 *val);
-    void compute_quant_table(int32 *dst, int16 *src);
-    void adjust_quant_table(int32 *dst, int32 *src);
-    void first_pass_init();
-    bool second_pass_init();
-    bool jpg_open(int p_x_res, int p_y_res, int src_channels);
-    void load_block_8_8_grey(int x);
-    void load_block_8_8(int x, int y, int c);
-    void load_block_16_8(int x, int c);
-    void load_block_16_8_8(int x, int c);
-    void load_quantized_coefficients(int component_num);
-    void flush_output_buffer();
-    void put_bits(uint bits, uint len);
-    void code_coefficients_pass_one(int component_num);
-    void code_coefficients_pass_two(int component_num);
-    void code_block(int component_num);
-    void process_mcu_row();
-    bool terminate_pass_one();
-    bool terminate_pass_two();
-    bool process_end_of_image();
-    void load_mcu(const void* src);
-    void clear();
-    void init();
-  };
-
-} // namespace jpge
-
-#endif // JPEG_ENCODER

crazy_functions/test_project/cpp/libJPG/来源

@@ -1,3 +0,0 @@
-jpge.h - C++ class for JPEG compression.
-Public domain, Rich Geldreich <richgel99@gmail.com>
-Alex Evans: Added RGBA support, linear memory allocator.

crazy_functions/test_project/cpp/longcode/prod_cons.h

@@ -1,433 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <utility>
-#include <cstring>
-#include <type_traits>
-#include <cstdint>
-
-#include "libipc/def.h"
-
-#include "libipc/platform/detail.h"
-#include "libipc/circ/elem_def.h"
-#include "libipc/utility/log.h"
-#include "libipc/utility/utility.h"
-
-namespace ipc {
-
-////////////////////////////////////////////////////////////////
-/// producer-consumer implementation
-////////////////////////////////////////////////////////////////
-
-template <typename Flag>
-struct prod_cons_impl;
-
-template <>
-struct prod_cons_impl<wr<relat::single, relat::single, trans::unicast>> {
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> rd_; // read index
-    alignas(cache_line_size) std::atomic<circ::u2_t> wt_; // write index
-
-    constexpr circ::u2_t cursor() const noexcept {
-        return 0;
-    }
-
-    template <typename W, typename F, typename E>
-    bool push(W* /*wrapper*/, F&& f, E* elems) {
-        auto cur_wt = circ::index_of(wt_.load(std::memory_order_relaxed));
-        if (cur_wt == circ::index_of(rd_.load(std::memory_order_acquire) - 1)) {
-            return false; // full
-        }
-        std::forward<F>(f)(&(elems[cur_wt].data_));
-        wt_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-
-    /**
-     * In single-single-unicast, 'force_push' means 'no reader' or 'the only one reader is dead'.
-     * So we could just disconnect all connections of receiver, and return false.
-    */
-    template <typename W, typename F, typename E>
-    bool force_push(W* wrapper, F&&, E*) {
-        wrapper->elems()->disconnect_receiver(~static_cast<circ::cc_t>(0u));
-        return false;
-    }
-
-    template <typename W, typename F, typename R, typename E>
-    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E* elems) {
-        auto cur_rd = circ::index_of(rd_.load(std::memory_order_relaxed));
-        if (cur_rd == circ::index_of(wt_.load(std::memory_order_acquire))) {
-            return false; // empty
-        }
-        std::forward<F>(f)(&(elems[cur_rd].data_));
-        std::forward<R>(out)(true);
-        rd_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::single, relat::multi , trans::unicast>>
-     : prod_cons_impl<wr<relat::single, relat::single, trans::unicast>> {
-
-    template <typename W, typename F, typename E>
-    bool force_push(W* wrapper, F&&, E*) {
-        wrapper->elems()->disconnect_receiver(1);
-        return false;
-    }
-
-    template <typename W, typename F, typename R, 
-              template <std::size_t, std::size_t> class E, std::size_t DS, std::size_t AS>
-    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E<DS, AS>* elems) {
-        byte_t buff[DS];
-        for (unsigned k = 0;;) {
-            auto cur_rd = rd_.load(std::memory_order_relaxed);
-            if (circ::index_of(cur_rd) ==
-                circ::index_of(wt_.load(std::memory_order_acquire))) {
-                return false; // empty
-            }
-            std::memcpy(buff, &(elems[circ::index_of(cur_rd)].data_), sizeof(buff));
-            if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
-                std::forward<F>(f)(buff);
-                std::forward<R>(out)(true);
-                return true;
-            }
-            ipc::yield(k);
-        }
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::multi , relat::multi, trans::unicast>>
-     : prod_cons_impl<wr<relat::single, relat::multi, trans::unicast>> {
-
-    using flag_t = std::uint64_t;
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-        std::atomic<flag_t> f_ct_ { 0 }; // commit flag
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> ct_; // commit index
-
-    template <typename W, typename F, typename E>
-    bool push(W* /*wrapper*/, F&& f, E* elems) {
-        circ::u2_t cur_ct, nxt_ct;
-        for (unsigned k = 0;;) {
-            cur_ct = ct_.load(std::memory_order_relaxed);
-            if (circ::index_of(nxt_ct = cur_ct + 1) ==
-                circ::index_of(rd_.load(std::memory_order_acquire))) {
-                return false; // full
-            }
-            if (ct_.compare_exchange_weak(cur_ct, nxt_ct, std::memory_order_acq_rel)) {
-                break;
-            }
-            ipc::yield(k);
-        }
-        auto* el = elems + circ::index_of(cur_ct);
-        std::forward<F>(f)(&(el->data_));
-        // set flag & try update wt
-        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
-        while (1) {
-            auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
-            if (cur_ct != wt_.load(std::memory_order_relaxed)) {
-                return true;
-            }
-            if ((~cac_ct) != cur_ct) {
-                return true;
-            }
-            if (!el->f_ct_.compare_exchange_strong(cac_ct, 0, std::memory_order_relaxed)) {
-                return true;
-            }
-            wt_.store(nxt_ct, std::memory_order_release);
-            cur_ct = nxt_ct;
-            nxt_ct = cur_ct + 1;
-            el = elems + circ::index_of(cur_ct);
-        }
-        return true;
-    }
-
-    template <typename W, typename F, typename E>
-    bool force_push(W* wrapper, F&&, E*) {
-        wrapper->elems()->disconnect_receiver(1);
-        return false;
-    }
-
-    template <typename W, typename F, typename R, 
-              template <std::size_t, std::size_t> class E, std::size_t DS, std::size_t AS>
-    bool pop(W* /*wrapper*/, circ::u2_t& /*cur*/, F&& f, R&& out, E<DS, AS>* elems) {
-        byte_t buff[DS];
-        for (unsigned k = 0;;) {
-            auto cur_rd = rd_.load(std::memory_order_relaxed);
-            auto cur_wt = wt_.load(std::memory_order_acquire);
-            auto id_rd  = circ::index_of(cur_rd);
-            auto id_wt  = circ::index_of(cur_wt);
-            if (id_rd == id_wt) {
-                auto* el = elems + id_wt;
-                auto cac_ct = el->f_ct_.load(std::memory_order_acquire);
-                if ((~cac_ct) != cur_wt) {
-                    return false; // empty
-                }
-                if (el->f_ct_.compare_exchange_weak(cac_ct, 0, std::memory_order_relaxed)) {
-                    wt_.store(cur_wt + 1, std::memory_order_release);
-                }
-                k = 0;
-            }
-            else {
-                std::memcpy(buff, &(elems[circ::index_of(cur_rd)].data_), sizeof(buff));
-                if (rd_.compare_exchange_weak(cur_rd, cur_rd + 1, std::memory_order_release)) {
-                    std::forward<F>(f)(buff);
-                    std::forward<R>(out)(true);
-                    return true;
-                }
-                ipc::yield(k);
-            }
-        }
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::single, relat::multi, trans::broadcast>> {
-
-    using rc_t = std::uint64_t;
-
-    enum : rc_t {
-        ep_mask = 0x00000000ffffffffull,
-        ep_incr = 0x0000000100000000ull
-    };
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-        std::atomic<rc_t> rc_ { 0 }; // read-counter
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> wt_;   // write index
-    alignas(cache_line_size) rc_t epoch_ { 0 };             // only one writer
-
-    circ::u2_t cursor() const noexcept {
-        return wt_.load(std::memory_order_acquire);
-    }
-
-    template <typename W, typename F, typename E>
-    bool push(W* wrapper, F&& f, E* elems) {
-        E* el;
-        for (unsigned k = 0;;) {
-            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
-            if (cc == 0) return false; // no reader
-            el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
-            // check all consumers have finished reading this element
-            auto cur_rc = el->rc_.load(std::memory_order_acquire);
-            circ::cc_t rem_cc = cur_rc & ep_mask;
-            if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch_)) {
-                return false; // has not finished yet
-            }
-            // consider rem_cc to be 0 here
-            if (el->rc_.compare_exchange_weak(
-                        cur_rc, epoch_ | static_cast<rc_t>(cc), std::memory_order_release)) {
-                break;
-            }
-            ipc::yield(k);
-        }
-        std::forward<F>(f)(&(el->data_));
-        wt_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-
-    template <typename W, typename F, typename E>
-    bool force_push(W* wrapper, F&& f, E* elems) {
-        E* el;
-        epoch_ += ep_incr;
-        for (unsigned k = 0;;) {
-            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
-            if (cc == 0) return false; // no reader
-            el = elems + circ::index_of(wt_.load(std::memory_order_relaxed));
-            // check all consumers have finished reading this element
-            auto cur_rc = el->rc_.load(std::memory_order_acquire);
-            circ::cc_t rem_cc = cur_rc & ep_mask;
-            if (cc & rem_cc) {
-                ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc);
-                cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers
-                if (cc == 0) return false; // no reader
-            }
-            // just compare & exchange
-            if (el->rc_.compare_exchange_weak(
-                        cur_rc, epoch_ | static_cast<rc_t>(cc), std::memory_order_release)) {
-                break;
-            }
-            ipc::yield(k);
-        }
-        std::forward<F>(f)(&(el->data_));
-        wt_.fetch_add(1, std::memory_order_release);
-        return true;
-    }
-
-    template <typename W, typename F, typename R, typename E>
-    bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E* elems) {
-        if (cur == cursor()) return false; // acquire
-        auto* el = elems + circ::index_of(cur++);
-        std::forward<F>(f)(&(el->data_));
-        for (unsigned k = 0;;) {
-            auto cur_rc = el->rc_.load(std::memory_order_acquire);
-            if ((cur_rc & ep_mask) == 0) {
-                std::forward<R>(out)(true);
-                return true;
-            }
-            auto nxt_rc = cur_rc & ~static_cast<rc_t>(wrapper->connected_id());
-            if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) {
-                std::forward<R>(out)((nxt_rc & ep_mask) == 0);
-                return true;
-            }
-            ipc::yield(k);
-        }
-    }
-};
-
-template <>
-struct prod_cons_impl<wr<relat::multi, relat::multi, trans::broadcast>> {
-
-    using rc_t   = std::uint64_t;
-    using flag_t = std::uint64_t;
-
-    enum : rc_t {
-        rc_mask = 0x00000000ffffffffull,
-        ep_mask = 0x00ffffffffffffffull,
-        ep_incr = 0x0100000000000000ull,
-        ic_mask = 0xff000000ffffffffull,
-        ic_incr = 0x0000000100000000ull
-    };
-
-    template <std::size_t DataSize, std::size_t AlignSize>
-    struct elem_t {
-        std::aligned_storage_t<DataSize, AlignSize> data_ {};
-        std::atomic<rc_t  > rc_   { 0 }; // read-counter
-        std::atomic<flag_t> f_ct_ { 0 }; // commit flag
-    };
-
-    alignas(cache_line_size) std::atomic<circ::u2_t> ct_;   // commit index
-    alignas(cache_line_size) std::atomic<rc_t> epoch_ { 0 };
-
-    circ::u2_t cursor() const noexcept {
-        return ct_.load(std::memory_order_acquire);
-    }
-
-    constexpr static rc_t inc_rc(rc_t rc) noexcept {
-        return (rc & ic_mask) | ((rc + ic_incr) & ~ic_mask);
-    }
-
-    constexpr static rc_t inc_mask(rc_t rc) noexcept {
-        return inc_rc(rc) & ~rc_mask;
-    }
-
-    template <typename W, typename F, typename E>
-    bool push(W* wrapper, F&& f, E* elems) {
-        E* el;
-        circ::u2_t cur_ct;
-        rc_t epoch = epoch_.load(std::memory_order_acquire);
-        for (unsigned k = 0;;) {
-            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
-            if (cc == 0) return false; // no reader
-            el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed));
-            // check all consumers have finished reading this element
-            auto cur_rc = el->rc_.load(std::memory_order_relaxed);
-            circ::cc_t rem_cc = cur_rc & rc_mask;
-            if ((cc & rem_cc) && ((cur_rc & ~ep_mask) == epoch)) {
-                return false; // has not finished yet
-            }
-            else if (!rem_cc) {
-                auto cur_fl = el->f_ct_.load(std::memory_order_acquire);
-                if ((cur_fl != cur_ct) && cur_fl) {
-                    return false; // full
-                }
-            }
-            // consider rem_cc to be 0 here
-            if (el->rc_.compare_exchange_weak(
-                        cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast<rc_t>(cc), std::memory_order_relaxed) &&
-                epoch_.compare_exchange_weak(epoch, epoch, std::memory_order_acq_rel)) {
-                break;
-            }
-            ipc::yield(k);
-        }
-        // only one thread/process would touch here at one time
-        ct_.store(cur_ct + 1, std::memory_order_release);
-        std::forward<F>(f)(&(el->data_));
-        // set flag & try update wt
-        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
-        return true;
-    }
-
-    template <typename W, typename F, typename E>
-    bool force_push(W* wrapper, F&& f, E* elems) {
-        E* el;
-        circ::u2_t cur_ct;
-        rc_t epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr;
-        for (unsigned k = 0;;) {
-            circ::cc_t cc = wrapper->elems()->connections(std::memory_order_relaxed);
-            if (cc == 0) return false; // no reader
-            el = elems + circ::index_of(cur_ct = ct_.load(std::memory_order_relaxed));
-            // check all consumers have finished reading this element
-            auto cur_rc = el->rc_.load(std::memory_order_acquire);
-            circ::cc_t rem_cc = cur_rc & rc_mask;
-            if (cc & rem_cc) {
-                ipc::log("force_push: k = %u, cc = %u, rem_cc = %u\n", k, cc, rem_cc);
-                cc = wrapper->elems()->disconnect_receiver(rem_cc); // disconnect all invalid readers
-                if (cc == 0) return false; // no reader
-            }
-            // just compare & exchange
-            if (el->rc_.compare_exchange_weak(
-                        cur_rc, inc_mask(epoch | (cur_rc & ep_mask)) | static_cast<rc_t>(cc), std::memory_order_relaxed)) {
-                if (epoch == epoch_.load(std::memory_order_acquire)) {
-                    break;
-                }
-                else if (push(wrapper, std::forward<F>(f), elems)) {
-                    return true;
-                }
-                epoch = epoch_.fetch_add(ep_incr, std::memory_order_release) + ep_incr;
-            }
-            ipc::yield(k);
-        }
-        // only one thread/process would touch here at one time
-        ct_.store(cur_ct + 1, std::memory_order_release);
-        std::forward<F>(f)(&(el->data_));
-        // set flag & try update wt
-        el->f_ct_.store(~static_cast<flag_t>(cur_ct), std::memory_order_release);
-        return true;
-    }
-
-    template <typename W, typename F, typename R, typename E, std::size_t N>
-    bool pop(W* wrapper, circ::u2_t& cur, F&& f, R&& out, E(& elems)[N]) {
-        auto* el = elems + circ::index_of(cur);
-        auto cur_fl = el->f_ct_.load(std::memory_order_acquire);
-        if (cur_fl != ~static_cast<flag_t>(cur)) {
-            return false; // empty
-        }
-        ++cur;
-        std::forward<F>(f)(&(el->data_));
-        for (unsigned k = 0;;) {
-            auto cur_rc = el->rc_.load(std::memory_order_acquire);
-            if ((cur_rc & rc_mask) == 0) {
-                std::forward<R>(out)(true);
-                el->f_ct_.store(cur + N - 1, std::memory_order_release);
-                return true;
-            }
-            auto nxt_rc = inc_rc(cur_rc) & ~static_cast<rc_t>(wrapper->connected_id());
-            bool last_one = false;
-            if ((last_one = (nxt_rc & rc_mask) == 0)) {
-                el->f_ct_.store(cur + N - 1, std::memory_order_release);
-            }
-            if (el->rc_.compare_exchange_weak(cur_rc, nxt_rc, std::memory_order_release)) {
-                std::forward<R>(out)(last_one);
-                return true;
-            }
-            ipc::yield(k);
-        }
-    }
-};
-
-} // namespace ipc

crazy_functions/test_project/latex/attention/background.tex

@@ -1,58 +0,0 @@
-The goal of reducing sequential computation also forms the foundation of the Extended Neural GPU \citep{extendedngpu}, ByteNet \citep{NalBytenet2017} and ConvS2S \citep{JonasFaceNet2017}, all of which use convolutional neural networks as basic building block, computing hidden representations in parallel for all input and output positions. In these models, the number of operations required to relate signals from two arbitrary input or output positions grows in the distance between positions, linearly for ConvS2S and logarithmically for ByteNet. This makes it more difficult to learn dependencies between distant positions \citep{hochreiter2001gradient}. In the Transformer this is reduced to a constant number of operations, albeit at the cost of reduced effective resolution due to averaging attention-weighted positions, an effect we counteract with Multi-Head Attention as described in section~\ref{sec:attention}. 
-
-Self-attention, sometimes called intra-attention is an attention mechanism relating different positions of a single sequence in order to compute a representation of the sequence. Self-attention has been used successfully in a variety of tasks including reading comprehension, abstractive summarization, textual entailment and learning task-independent sentence representations \citep{cheng2016long, decomposableAttnModel, paulus2017deep, lin2017structured}.
-
-End-to-end memory networks are based on a recurrent attention mechanism instead of sequence-aligned recurrence and have been shown to perform well on simple-language question answering and language modeling tasks \citep{sukhbaatar2015}.
-
-To the best of our knowledge, however, the Transformer is the first transduction model relying entirely on self-attention to compute representations of its input and output without using sequence-aligned RNNs or convolution.
-In the following sections, we will describe the Transformer, motivate self-attention and discuss its advantages over models such as \citep{neural_gpu, NalBytenet2017} and \citep{JonasFaceNet2017}.
-
-
-%\citep{JonasFaceNet2017} report new SOTA on machine translation for English-to-German (EnDe), Enlish-to-French (EnFr) and English-to-Romanian language pairs. 
-
-%For example,! in MT, we must draw information from both input and previous output words to translate an output word accurately. An attention layer \citep{bahdanau2014neural} can connect a very large number of positions at low computation cost, making it an essential ingredient in competitive recurrent models for machine translation.
-
-%A natural question to ask then is, "Could we replace recurrence with attention?". \marginpar{Don't know if it's the most natural question to ask given the previous statements. Also, need to say that the complexity table summarizes these statements} Such a model would be blessed with the computational efficiency of attention and the power of cross-positional communication. In this work, show that pure attention models work remarkably well for MT, achieving new SOTA results on EnDe and EnFr, and can be trained in under $2$ days on xyz architecture. 
-
-%After the seminal models introduced in \citep{sutskever14, bahdanau2014neural, cho2014learning}, recurrent models have become the dominant solution for both sequence modeling and sequence-to-sequence transduction. Many efforts such as \citep{wu2016google,luong2015effective,jozefowicz2016exploring} have pushed the boundaries of machine translation (MT) and language modeling with recurrent endoder-decoder and recurrent language models. Recent effort \citep{shazeer2017outrageously} has successfully combined the power of conditional computation with sequence models to train very large models for MT, pushing SOTA at lower computational cost.
-
-%Recurrent models compute a vector of hidden states $h_t$, for each time step $t$ of computation. $h_t$ is a function of both the input at time $t$ and the previous hidden state $h_t$. This dependence on the previous hidden state precludes processing all timesteps at once, instead requiring long sequences of sequential operations.  In practice, this results in greatly reduced computational efficiency, as on modern computing hardware, a single operation on a large batch is much faster than a large number of operations on small batches.  The problem gets worse at longer sequence lengths. Although sequential computation is not a severe bottleneck at inference time, as autoregressively generating each output requires all previous outputs, the inability to compute scores at all output positions at once hinders us from rapidly training our models over large datasets. Although impressive work such as \citep{Kuchaiev2017Factorization} is able to significantly accelerate the training of LSTMs with factorization tricks, we are still bound by the linear dependence on sequence length.
-
-%If the model could compute hidden states at each time step using only the inputs and outputs,  it would be liberated from the dependence on results from previous time steps during training. This line of thought is the foundation of recent efforts such as the Markovian neural GPU \citep{neural_gpu}, ByteNet \citep{NalBytenet2017} and ConvS2S \citep{JonasFaceNet2017}, all of which use convolutional neural networks as a building block to compute hidden representations simultaneously for all timesteps, resulting in $O(1)$ sequential time complexity. \citep{JonasFaceNet2017} report new SOTA on machine translation for English-to-German (EnDe), Enlish-to-French (EnFr) and English-to-Romanian language pairs. 
-
-%A crucial component for accurate sequence prediction is modeling cross-positional communication. For example, in MT, we must draw information from both input and previous output words to translate an output word accurately. An attention layer \citep{bahdanau2014neural} can connect a very large number of positions at a low computation cost, also $O(1)$ sequential time complexity, making it an essential ingredient in recurrent encoder-decoder architectures for MT. A natural question to ask then is, "Could we replace recurrence with attention?". \marginpar{Don't know if it's the most natural question to ask given the previous statements. Also, need to say that the complexity table summarizes these statements} Such a model would be blessed with the computational efficiency of attention and the power of cross-positional communication. In this work, show that pure attention models work remarkably well for MT, achieving new SOTA results on EnDe and EnFr, and can be trained in under $2$ days on xyz architecture. 
-
-
-
-%Note: Facebook model is no better than RNNs in this regard, since it requires a number of layers proportional to the distance you want to communicate.  Bytenet is more promising, since it requires a logarithmnic number of layers (does bytenet have SOTA results)?   
-
-%Note: An attention  layer can connect a very large number of positions at a low computation cost in O(1) sequential operations.  This is why encoder-decoder attention has been so successful in seq-to-seq models so far.  It is only natural, then, to also use attention to connect the timesteps of the same sequence.
-
-%Note: I wouldn't say that long sequences are not a problem during inference.  It would be great if we could infer with no long sequences.  We could just say later on that, while our training graph is constant-depth, our model still requires sequential operations in the decoder part during inference due to the autoregressive nature of the model.   
-
-%\begin{table}[h!]
-%\caption{Attention models are quite efficient for cross-positional communications when sequence length is smaller than channel depth. $n$ represents the sequence length and $d$ represents the channel depth.}
-%\label{tab:op_complexities}
-%\begin{center}
-%\vspace{-5pt}
-%\scalebox{0.75}{
-
-%\begin{tabular}{l|c|c|c}
-%\hline \hline
-%Layer Type & Receptive & Complexity & Sequential  \\
-%           & Field     &            & Operations  \\
-%\hline
-%Pointwise Feed-Forward & $1$ & $O(n \cdot d^2)$ & $O(1)$ \\
-%\hline
-%Recurrent & $n$ & $O(n \cdot d^2)$ & $O(n)$ \\
-%\hline
-%Convolutional & $r$ & $O(r \cdot n \cdot d^2)$ & $O(1)$ \\
-%\hline
-%Convolutional (separable) & $r$ & $O(r \cdot n \cdot d + n %\cdot d^2)$ & $O(1)$ \\
-%\hline
-%Attention & $r$ & $O(r \cdot n \cdot d)$ & $O(1)$ \\
-%\hline \hline
-%\end{tabular}
-%}
-%\end{center}
-%\end{table}

crazy_functions/test_project/latex/attention/introduction.tex

@@ -1,18 +0,0 @@
-Recurrent neural networks, long short-term memory \citep{hochreiter1997} and gated recurrent \citep{gruEval14} neural networks in particular, have been firmly established as state of the art approaches in sequence modeling and transduction problems such as language modeling and machine translation \citep{sutskever14, bahdanau2014neural, cho2014learning}. Numerous efforts have since continued to push the boundaries of recurrent language models and encoder-decoder architectures \citep{wu2016google,luong2015effective,jozefowicz2016exploring}.
-
-Recurrent models typically factor computation along the symbol positions of the input and output sequences. Aligning the positions to steps in computation time, they generate a sequence of hidden states $h_t$, as a function of the previous hidden state $h_{t-1}$ and the input for position $t$. This inherently sequential nature precludes parallelization within training examples, which becomes critical at longer sequence lengths, as memory constraints limit batching across examples.
-%\marginpar{not sure if the memory constraints are understandable here}
-Recent work has achieved significant improvements in computational efficiency through factorization tricks \citep{Kuchaiev2017Factorization} and conditional computation \citep{shazeer2017outrageously}, while also improving model performance in case of the latter. The fundamental constraint of sequential computation, however, remains.
-
-%\marginpar{@all: there is work on analyzing what attention really does in seq2seq models, couldn't find it right away} 
-
-Attention mechanisms have become an integral part of compelling sequence modeling and transduction models in various tasks, allowing modeling of dependencies without regard to their distance in the input or output sequences \citep{bahdanau2014neural, structuredAttentionNetworks}. In all but a few cases \citep{decomposableAttnModel}, however, such attention mechanisms are used in conjunction with a recurrent network.
-
-%\marginpar{not sure if "cross-positional communication" is understandable without explanation}
-%\marginpar{insert exact training times and stats for the model that reaches sota earliest, maybe even a single GPU model?}
-
-In this work we propose the Transformer, a model architecture eschewing recurrence and instead relying entirely on an attention mechanism to draw global dependencies between input and output. The Transformer allows for significantly more parallelization and can reach a new state of the art in translation quality after being trained for as little as twelve hours on eight P100 GPUs. 
-%\marginpar{you removed the constant number of repetitions part. I wrote it because I wanted to make it clear that the model does not only perform attention once, while it's also not recurrent. I thought that might be important to get across early.}
-
-% Just a standard paragraph with citations, rewrite.
-%After the seminal papers of \citep{sutskever14}, \citep{bahdanau2014neural}, and \citep{cho2014learning}, recurrent models have become the dominant solution for both sequence modeling and sequence-to-sequence transduction. Many efforts such as \citep{wu2016google,luong2015effective,jozefowicz2016exploring} have pushed the boundaries of machine translation and language modeling with recurrent sequence models. Recent effort \citep{shazeer2017outrageously} has combined the power of conditional computation with sequence models to train very large models for machine translation, pushing SOTA at lower computational cost. Recurrent models compute a vector of hidden states $h_t$, for each time step $t$ of computation. $h_t$ is a function of both the input at time $t$ and the previous hidden state $h_t$. This dependence on the previous hidden state encumbers recurrnet models to process multiple inputs at once, and their time complexity is a linear function of the length of the input and output, both during training and inference. [What I want to say here is that although this is fine during decoding, at training time, we are given both input and output and this linear nature does not allow the RNN to process all inputs and outputs simultaneously and haven't been used on datasets that are the of the scale of the web. What's the largest dataset we have ? . Talk about Nividia and possibly other's effors to speed up things, and possibly other efforts that alleviate this, but are still limited by it's comptuational nature]. Rest of the intro: What if you could construct the state based on the actual inputs and outputs, then you could construct them all at once. This has been the foundation of many promising recent efforts, bytenet,facenet (Also talk about quasi rnn here). Now we talk about attention!! Along with cell architectures such as long short-term meory (LSTM) \citep{hochreiter1997}, and gated recurrent units (GRUs) \citep{cho2014learning}, attention has emerged as an essential ingredient in successful sequence models, in particular for machine translation. In recent years, many, if not all, state-of-the-art (SOTA) results in machine translation have been achieved with attention-based sequence models \citep{wu2016google,luong2015effective,jozefowicz2016exploring}. Talk about the neon work on how it played with attention to do self attention! Then talk about what we do.

crazy_functions/test_project/latex/attention/model_architecture.tex

@@ -1,155 +0,0 @@
-
-\begin{figure}
-  \centering
-  \includegraphics[scale=0.6]{Figures/ModalNet-21}
-  \caption{The Transformer - model architecture.}
-  \label{fig:model-arch}
-\end{figure}
-
-% Although the primary workhorse of our model is attention, 
-%Our model maintains the encoder-decoder structure that is common to many so-called sequence-to-sequence models \citep{bahdanau2014neural,sutskever14}.  As in all such architectures, the encoder computes a representation of the input sequence, and the decoder consumes these representations along with the output tokens to autoregressively produce the output sequence.  Where, traditionally, the encoder and decoder contain stacks of recurrent or convolutional layers, our encoder and decoder stacks are composed of attention layers and position-wise feed-forward layers (Figure~\ref{fig:model-arch}).  The following sections describe the gross architecture and these particular components in detail.
-
-Most competitive neural sequence transduction models have an encoder-decoder structure \citep{cho2014learning,bahdanau2014neural,sutskever14}. Here, the encoder maps an input sequence of symbol representations $(x_1, ..., x_n)$ to a sequence of continuous representations $\mathbf{z} = (z_1, ..., z_n)$. Given $\mathbf{z}$, the decoder then generates an output sequence $(y_1,...,y_m)$ of symbols one element at a time. At each step the model is auto-regressive \citep{graves2013generating}, consuming the previously generated symbols as additional input when generating the next.
-
-The Transformer follows this overall architecture using stacked self-attention and point-wise, fully connected layers for both the encoder and decoder, shown in the left and right halves of Figure~\ref{fig:model-arch}, respectively.
-
-\subsection{Encoder and Decoder Stacks}
-
-\paragraph{Encoder:}The encoder is composed of a stack of $N=6$ identical layers. Each layer has two sub-layers. The first is a multi-head self-attention mechanism, and the second is a simple, position-wise fully connected feed-forward network.   We employ a residual connection \citep{he2016deep} around each of the two sub-layers, followed by layer normalization \cite{layernorm2016}.  That is, the output of each sub-layer is $\mathrm{LayerNorm}(x + \mathrm{Sublayer}(x))$, where $\mathrm{Sublayer}(x)$ is the function implemented by the sub-layer itself.  To facilitate these residual connections, all sub-layers in the model, as well as the embedding layers, produce outputs of dimension $\dmodel=512$.
-
-\paragraph{Decoder:}The decoder is also composed of a stack of $N=6$ identical layers.  In addition to the two sub-layers in each encoder layer, the decoder inserts a third sub-layer, which performs multi-head attention over the output of the encoder stack.  Similar to the encoder, we employ residual connections around each of the sub-layers, followed by layer normalization.  We also modify the self-attention sub-layer in the decoder stack to prevent positions from attending to subsequent positions.  This masking, combined with fact that the output embeddings are offset by one position, ensures that the predictions for position $i$ can depend only on the known outputs at positions less than $i$.
-
-% In our model (Figure~\ref{fig:model-arch}), the encoder and decoder are composed of stacks of alternating self-attention layers (for cross-positional communication) and position-wise feed-forward layers (for in-place computation).  In addition, the decoder stack contains encoder-decoder attention layers.  Since attention is agnostic to the distances between words, our model requires a "positional encoding" to be added to the encoder and decoder input. The following sections describe all of these components in detail.
-
-\subsection{Attention} \label{sec:attention}
-An attention function can be described as mapping a query and a set of key-value pairs to an output, where the query, keys, values, and output are all vectors.  The output is computed as a weighted sum of the values, where the weight assigned to each value is computed by a compatibility function of the query with the corresponding key.
-
-\subsubsection{Scaled Dot-Product Attention} \label{sec:scaled-dot-prod}
-
-% \begin{figure}
-%   \centering
-%   \includegraphics[scale=0.6]{Figures/ModalNet-19}
-%   \caption{Scaled Dot-Product Attention.}
-%   \label{fig:multi-head-att}
-% \end{figure}
-
-We call our particular attention "Scaled Dot-Product Attention" (Figure~\ref{fig:multi-head-att}).   The input consists of queries and keys of dimension $d_k$, and values of dimension $d_v$.  We compute the dot products of the query with all keys, divide each by $\sqrt{d_k}$, and apply a softmax function to obtain the weights on the values.
-
-In practice, we compute the attention function on a set of queries simultaneously, packed together into a matrix $Q$.   The keys and values are also packed together into matrices $K$ and $V$.  We compute the matrix of outputs as:
-
-\begin{equation}
-   \mathrm{Attention}(Q, K, V) = \mathrm{softmax}(\frac{QK^T}{\sqrt{d_k}})V
-\end{equation}
-
-The two most commonly used attention functions are additive attention \citep{bahdanau2014neural}, and dot-product (multiplicative) attention.  Dot-product attention is identical to our algorithm, except for the scaling factor of $\frac{1}{\sqrt{d_k}}$. Additive attention computes the compatibility function using a feed-forward network with a single hidden layer.  While the two are similar in theoretical complexity, dot-product attention is much faster and more space-efficient in practice, since it can be implemented using highly optimized matrix multiplication code. 
-
-%We scale the dot products by $1/\sqrt{d_k}$ to limit the magnitude of the dot products, which works well in practice. Otherwise, we found applying the softmax to often result in weights very close to 0 or 1, and hence minuscule gradients.
-
-% Already described in the subsequent section
-%When used as part of decoder self-attention, an optional mask function is applied just before the softmax to prevent positions from attending to subsequent positions.   This mask simply sets the logits corresponding to all illegal connections (those outside of the lower triangle) to $-\infty$.
-
-%\paragraph{Comparison to Additive Attention: } We choose dot product attention over additive attention \citep{bahdanau2014neural} since it can be computed using highly optimized matrix multiplication code.  This optimization is particularly important to us, as we employ many attention layers in our model.
-
-While for small values of $d_k$ the two mechanisms perform similarly, additive attention outperforms dot product attention without scaling for larger values of $d_k$ \citep{DBLP:journals/corr/BritzGLL17}. We suspect that for large values of $d_k$, the dot products grow large in magnitude, pushing the softmax function into regions where it has extremely small gradients  \footnote{To illustrate why the dot products get large, assume that the components of $q$ and $k$ are independent random variables with mean $0$ and variance $1$.  Then their dot product, $q \cdot k = \sum_{i=1}^{d_k} q_ik_i$, has mean $0$ and variance $d_k$.}. To counteract this effect, we scale the dot products by $\frac{1}{\sqrt{d_k}}$.
-
-
-%We suspect this to be caused by the dot products growing too large in magnitude to result in useful gradients after applying the softmax function.  To counteract this, we scale the dot product by $1/\sqrt{d_k}$.
-
-
-\subsubsection{Multi-Head Attention} \label{sec:multihead}
-
-\begin{figure}
-\begin{minipage}[t]{0.5\textwidth}
-  \centering
-  Scaled Dot-Product Attention \\
-  \vspace{0.5cm}
-  \includegraphics[scale=0.6]{Figures/ModalNet-19}
-\end{minipage}
-\begin{minipage}[t]{0.5\textwidth}
-  \centering 
-  Multi-Head Attention \\
-  \vspace{0.1cm}
-  \includegraphics[scale=0.6]{Figures/ModalNet-20}  
-\end{minipage}
-
-
-  % \centering
-
-  \caption{(left) Scaled Dot-Product Attention. (right) Multi-Head Attention consists of several attention layers running in parallel.}
-  \label{fig:multi-head-att}
-\end{figure}
-
-Instead of performing a single attention function with $\dmodel$-dimensional keys, values and queries, we found it beneficial to linearly project the queries, keys and values $h$ times with different, learned linear projections to $d_k$, $d_k$ and $d_v$ dimensions, respectively.
-On each of these projected versions of queries, keys and values we then perform the attention function in parallel, yielding $d_v$-dimensional output values. These are concatenated and once again projected, resulting in the final values, as depicted in Figure~\ref{fig:multi-head-att}.
-
-Multi-head attention allows the model to jointly attend to information from different representation subspaces at different positions. With a single attention head, averaging inhibits this.
-
-\begin{align*}
-    \mathrm{MultiHead}(Q, K, V) &= \mathrm{Concat}(\mathrm{head_1}, ..., \mathrm{head_h})W^O\\
-%    \mathrm{where} \mathrm{head_i} &= \mathrm{Attention}(QW_Q_i^{\dmodel \times d_q}, KW_K_i^{\dmodel \times d_k}, VW^V_i^{\dmodel \times d_v})\\
-    \text{where}~\mathrm{head_i} &= \mathrm{Attention}(QW^Q_i, KW^K_i, VW^V_i)\\
-\end{align*}
-
-Where the projections are parameter matrices $W^Q_i \in \mathbb{R}^{\dmodel \times d_k}$, $W^K_i \in \mathbb{R}^{\dmodel \times d_k}$, $W^V_i \in \mathbb{R}^{\dmodel \times d_v}$ and $W^O \in \mathbb{R}^{hd_v \times \dmodel}$.
-
-
-%find it better (and no more expensive) to have multiple parallel attention layers (each over the full set of positions) with proportionally lower-dimensional keys, values and queries.  We call this "Multi-Head Attention" (Figure~\ref{fig:multi-head-att}).  The keys, values, and queries for each of these parallel attention layers are computed by learned linear transformations of the inputs to the multi-head attention.  We use different linear transformations across different parallel attention layers.  The output of the parallel attention layers are concatenated, and then passed through a final learned linear transformation. 
-
-In this work we employ $h=8$ parallel attention layers, or heads. For each of these we use $d_k=d_v=\dmodel/h=64$.
-Due to the reduced dimension of each head, the total computational cost is similar to that of single-head attention with full dimensionality.
-
-\subsubsection{Applications of Attention in our Model}
-
-The Transformer uses multi-head attention in three different ways: 
-\begin{itemize}
- \item In "encoder-decoder attention" layers, the queries come from the previous decoder layer, and the memory keys and values come from the output of the encoder.   This allows every position in the decoder to attend over all positions in the input sequence.  This mimics the typical encoder-decoder attention mechanisms in sequence-to-sequence models such as \citep{wu2016google, bahdanau2014neural,JonasFaceNet2017}.
-
- \item The encoder contains self-attention layers.  In a self-attention layer all of the keys, values and queries come from the same place, in this case, the output of the previous layer in the encoder.   Each position in the encoder can attend to all positions in the previous layer of the encoder.
-
- \item Similarly, self-attention layers in the decoder allow each position in the decoder to attend to all positions in the decoder up to and including that position.  We need to prevent leftward information flow in the decoder to preserve the auto-regressive property.  We implement this inside of scaled dot-product attention by masking out (setting to $-\infty$) all values in the input of the softmax which correspond to illegal connections.  See Figure~\ref{fig:multi-head-att}.
-
-\end{itemize}
-
-\subsection{Position-wise Feed-Forward Networks}\label{sec:ffn}
-
-In addition to attention sub-layers, each of the layers in our encoder and decoder contains a fully connected feed-forward network, which is applied to each position separately and identically.  This consists of two linear transformations with a ReLU activation in between.
-
-\begin{equation}
-   \mathrm{FFN}(x)=\max(0, xW_1 + b_1) W_2 + b_2
-\end{equation}
-
-While the linear transformations are the same across different positions, they use different parameters from layer to layer. Another way of describing this is as two convolutions with kernel size 1.  The dimensionality of input and output is $\dmodel=512$, and the inner-layer has dimensionality $d_{ff}=2048$.
-
-
-
-%In the appendix, we describe how the position-wise feed-forward network can also be seen as a form of attention.
-
-%from Jakob: The number of operations required for the model to relate signals from two arbitrary input or output positions grows in the distance between positions in input or output, linearly for ConvS2S and logarithmically for ByteNet, making it harder to learn dependencies between these positions \citep{hochreiter2001gradient}. In the transformer this is reduced to a constant number of operations, albeit at the cost of effective resolution caused by averaging attention-weighted positions, an effect we aim to counteract with multi-headed attention.
-
-
-%Figure~\ref{fig:simple-att} presents a simple attention function, $A$, with a single head, that forms the basis of our multi-head attention. $A$ takes a query key vector $\kq$, matrices of memory keys $\km$ and memory values $\vm$ ,and produces a query value vector $\vq$ as 
-%\begin{equation*} \label{eq:attention}
-%    A(\kq, \km, \vm) = {\vm}^T (Softmax(\km \kq).
-%\end{equation*}
-%We linearly transform $\kq,\,\km$, and $\vm$ with learned matrices ${\Wkq \text{,} \, \Wkm}$, and ${\Wvm}$ before calling the attention function, and transform the output query with $\Wvq$ before handing it to the feed forward layer. Each attention layer has it's own set of transformation matrices, which are shared across all query positions. $A$ is applied in parallel for each query position, and is implemented very efficiently as a batch of matrix multiplies. The self-attention and encoder-decoder attention layers use $A$, but with different arguments. For example, in encdoder self-attention, queries in encoder layer $i$ attention to memories in encoder layer $i-1$. To ensure that decoder self-attention layers do not look at future words, we add $- \inf$ to the softmax logits in positions $j+1$ to query length for query position $l$.  
-
-%In simple attention, the query value is a weighted combination of the memory values where the attention weights sum to one. Although this function performs well in practice, the constraint on attention weights can restrict the amount of information that flows from memories to queries because the query cannot focus on multiple memory positions at once, which might be desirable when translating long sequences. \marginpar{@usz, could you think of an example of this ?} We remedy this by maintaining multiple attention heads at each query position that attend to all memory positions in parallel, with a different set of parameters  per attention head $h$. 
-%\marginpar{}
-
-\subsection{Embeddings and Softmax}
-Similarly to other sequence transduction models, we use learned embeddings to convert the input tokens and output tokens to vectors of dimension $\dmodel$.  We also use the usual learned linear transformation and softmax function to convert the decoder output to predicted next-token probabilities.  In our model, we share the same weight matrix between the two embedding layers and the pre-softmax linear transformation, similar to \citep{press2016using}.   In the embedding layers, we multiply those weights by $\sqrt{\dmodel}$.
-
-
-\subsection{Positional Encoding}
-Since our model contains no recurrence and no convolution, in order for the model to make use of the order of the sequence, we must inject some information about the relative or absolute position of the tokens in the sequence.  To this end, we add "positional encodings" to the input embeddings at the bottoms of the encoder and decoder stacks.  The positional encodings have the same dimension $\dmodel$ as the embeddings, so that the two can be summed.   There are many choices of positional encodings, learned and fixed \citep{JonasFaceNet2017}.
-
-In this work, we use sine and cosine functions of different frequencies:
-
-\begin{align*}
-    PE_{(pos,2i)} = sin(pos / 10000^{2i/\dmodel}) \\
-    PE_{(pos,2i+1)} = cos(pos / 10000^{2i/\dmodel})
-\end{align*}
-
-where $pos$ is the position and $i$ is the dimension.  That is, each dimension of the positional encoding corresponds to a sinusoid.  The wavelengths form a geometric progression from $2\pi$ to $10000 \cdot 2\pi$.  We chose this function because we hypothesized it would allow the model to easily learn to attend by relative positions, since for any fixed offset $k$, $PE_{pos+k}$ can be represented as a linear function of $PE_{pos}$.
-
-We also experimented with using learned positional embeddings \citep{JonasFaceNet2017} instead, and found that the two versions produced nearly identical results (see Table~\ref{tab:variations} row (E)).  We chose the sinusoidal version because it may allow the model to extrapolate to sequence lengths longer than the ones encountered during training.

crazy_functions/test_project/latex/attention/parameter_attention.tex

@@ -1,45 +0,0 @@
-\pagebreak
-\section*{Two Feed-Forward Layers = Attention over Parameters}\label{sec:parameter_attention}
-
-In addition to attention layers, our model contains position-wise feed-forward networks (Section \ref{sec:ffn}), which consist of two linear transformations with a ReLU activation in between.  In fact, these networks too can be seen as a form of attention.  Compare the formula for such a network with the formula for a simple dot-product attention layer (biases and scaling factors omitted):
-
-\begin{align*}
-    FFN(x, W_1, W_2) = ReLU(xW_1)W_2 \\
-    A(q, K, V) = Softmax(qK^T)V
-\end{align*}
-
-Based on the similarity of these formulae, the two-layer feed-forward network can be seen as a kind of attention, where the keys and values are the rows of the trainable parameter matrices $W_1$ and $W_2$, and where we use ReLU instead of Softmax in the compatibility function.
-
-%the compatablity function is $compat(q, k_i) = ReLU(q \cdot k_i)$ instead of $Softmax(qK_T)_i$.
-
-Given this similarity, we experimented with replacing the position-wise feed-forward networks with attention layers similar to the ones we use everywhere else our model. The multi-head-attention-over-parameters sublayer is identical to the multi-head attention described in \ref{sec:multihead}, except that the "keys" and "values" inputs to each attention head are trainable model parameters, as opposed to being linear projections of a previous layer.  These parameters are scaled up by a factor of $\sqrt{d_{model}}$ in order to be more similar to activations.
-
-In our first experiment, we replaced each position-wise feed-forward network with a multi-head-attention-over-parameters sublayer with $h_p=8$ heads, key-dimensionality $d_{pk}=64$, and value-dimensionality $d_{pv}=64$, using $n_p=1536$ key-value pairs for each attention head.  The sublayer has a total of $2097152$ parameters, including the parameters in the query projection and the output projection.  This matches the number of parameters in the position-wise feed-forward network that we replaced.  While the theoretical amount of computation is also the same, in practice, the attention version caused the step times to be about 30\% longer.
-
-In our second experiment, we used $h_p=8$ heads, and $n_p=512$ key-value pairs for each attention head, again matching the total number of parameters in the base model.
-
-Results for the first experiment were slightly worse than for the base model, and results for the second experiment were slightly better, see Table~\ref{tab:parameter_attention}.
-
-\begin{table}[h]
-\caption{Replacing the position-wise feed-forward networks with multihead-attention-over-parameters produces similar results to the base model.  All metrics are on the English-to-German translation development set, newstest2013.}
-\label{tab:parameter_attention}
-\begin{center}
-\vspace{-2mm}
-%\scalebox{1.0}{
-\begin{tabular}{c|cccccc|cccc}
-\hline\rule{0pt}{2.0ex}
- & \multirow{2}{*}{$\dmodel$} & \multirow{2}{*}{$\dff$} &
-\multirow{2}{*}{$h_p$} & \multirow{2}{*}{$d_{pk}$} & \multirow{2}{*}{$d_{pv}$} &
- \multirow{2}{*}{$n_p$} &
- PPL & BLEU & params & training\\
- & & & & & &  & (dev) & (dev) & $\times10^6$ & time \\
-\hline\rule{0pt}{2.0ex}
-base & 512 & 2048 & & & & & 4.92 & 25.8 & 65 & 12 hours\\
-\hline\rule{0pt}{2.0ex}
-AOP$_1$ & 512 & & 8 & 64 & 64 & 1536 & 4.92& 25.5  & 65 & 16 hours\\
-AOP$_2$ & 512 & & 16 & 64 & 64 & 512 & \textbf{4.86} & \textbf{25.9}  & 65 & 16 hours \\
-\hline
-\end{tabular}
-%}
-\end{center}
-\end{table}

crazy_functions/test_project/latex/attention/来源

@@ -1,8 +0,0 @@
-chatgpt的老祖宗《Attention is all you need》
-
-Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, Illia Polosukhin
-
-真实的摘要如下
-The dominant sequence transduction models are based on complex recurrent or convolutional neural networks in an encoder-decoder configuration. The best performing models also connect the encoder and decoder through an attention mechanism. We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two machine translation tasks show these models to be superior in quality while being more parallelizable and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task, improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training costs of the best models from the literature. We show that the Transformer generalizes well to other tasks by applying it successfully to English constituency parsing both with large and limited training data.
-
-https://arxiv.org/abs/1706.03762

crazy_functions/test_project/python/dqn/__init__.py

@@ -1,2 +0,0 @@
-from stable_baselines3.dqn.dqn import DQN
-from stable_baselines3.dqn.policies import CnnPolicy, MlpPolicy

crazy_functions/test_project/python/dqn/dqn.py

@@ -1,245 +0,0 @@
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
-
-import gym
-import numpy as np
-import torch as th
-from torch.nn import functional as F
-
-from stable_baselines3.common import logger
-from stable_baselines3.common.off_policy_algorithm import OffPolicyAlgorithm
-from stable_baselines3.common.preprocessing import maybe_transpose
-from stable_baselines3.common.type_aliases import GymEnv, MaybeCallback, Schedule
-from stable_baselines3.common.utils import get_linear_fn, is_vectorized_observation, polyak_update
-from stable_baselines3.dqn.policies import DQNPolicy
-
-
-class DQN(OffPolicyAlgorithm):
-    """
-    Deep Q-Network (DQN)
-
-    Paper: https://arxiv.org/abs/1312.5602, https://www.nature.com/articles/nature14236
-    Default hyperparameters are taken from the nature paper,
-    except for the optimizer and learning rate that were taken from Stable Baselines defaults.
-
-    :param policy: The policy model to use (MlpPolicy, CnnPolicy, ...)
-    :param env: The environment to learn from (if registered in Gym, can be str)
-    :param learning_rate: The learning rate, it can be a function
-        of the current progress remaining (from 1 to 0)
-    :param buffer_size: size of the replay buffer
-    :param learning_starts: how many steps of the model to collect transitions for before learning starts
-    :param batch_size: Minibatch size for each gradient update
-    :param tau: the soft update coefficient ("Polyak update", between 0 and 1) default 1 for hard update
-    :param gamma: the discount factor
-    :param train_freq: Update the model every ``train_freq`` steps. Alternatively pass a tuple of frequency and unit
-        like ``(5, "step")`` or ``(2, "episode")``.
-    :param gradient_steps: How many gradient steps to do after each rollout (see ``train_freq``)
-        Set to ``-1`` means to do as many gradient steps as steps done in the environment
-        during the rollout.
-    :param optimize_memory_usage: Enable a memory efficient variant of the replay buffer
-        at a cost of more complexity.
-        See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195
-    :param target_update_interval: update the target network every ``target_update_interval``
-        environment steps.
-    :param exploration_fraction: fraction of entire training period over which the exploration rate is reduced
-    :param exploration_initial_eps: initial value of random action probability
-    :param exploration_final_eps: final value of random action probability
-    :param max_grad_norm: The maximum value for the gradient clipping
-    :param tensorboard_log: the log location for tensorboard (if None, no logging)
-    :param create_eval_env: Whether to create a second environment that will be
-        used for evaluating the agent periodically. (Only available when passing string for the environment)
-    :param policy_kwargs: additional arguments to be passed to the policy on creation
-    :param verbose: the verbosity level: 0 no output, 1 info, 2 debug
-    :param seed: Seed for the pseudo random generators
-    :param device: Device (cpu, cuda, ...) on which the code should be run.
-        Setting it to auto, the code will be run on the GPU if possible.
-    :param _init_setup_model: Whether or not to build the network at the creation of the instance
-    """
-
-    def __init__(
-        self,
-        policy: Union[str, Type[DQNPolicy]],
-        env: Union[GymEnv, str],
-        learning_rate: Union[float, Schedule] = 1e-4,
-        buffer_size: int = 1000000,
-        learning_starts: int = 50000,
-        batch_size: Optional[int] = 32,
-        tau: float = 1.0,
-        gamma: float = 0.99,
-        train_freq: Union[int, Tuple[int, str]] = 4,
-        gradient_steps: int = 1,
-        optimize_memory_usage: bool = False,
-        target_update_interval: int = 10000,
-        exploration_fraction: float = 0.1,
-        exploration_initial_eps: float = 1.0,
-        exploration_final_eps: float = 0.05,
-        max_grad_norm: float = 10,
-        tensorboard_log: Optional[str] = None,
-        create_eval_env: bool = False,
-        policy_kwargs: Optional[Dict[str, Any]] = None,
-        verbose: int = 0,
-        seed: Optional[int] = None,
-        device: Union[th.device, str] = "auto",
-        _init_setup_model: bool = True,
-    ):
-
-        super(DQN, self).__init__(
-            policy,
-            env,
-            DQNPolicy,
-            learning_rate,
-            buffer_size,
-            learning_starts,
-            batch_size,
-            tau,
-            gamma,
-            train_freq,
-            gradient_steps,
-            action_noise=None,  # No action noise
-            policy_kwargs=policy_kwargs,
-            tensorboard_log=tensorboard_log,
-            verbose=verbose,
-            device=device,
-            create_eval_env=create_eval_env,
-            seed=seed,
-            sde_support=False,
-            optimize_memory_usage=optimize_memory_usage,
-            supported_action_spaces=(gym.spaces.Discrete,),
-        )
-
-        self.exploration_initial_eps = exploration_initial_eps
-        self.exploration_final_eps = exploration_final_eps
-        self.exploration_fraction = exploration_fraction
-        self.target_update_interval = target_update_interval
-        self.max_grad_norm = max_grad_norm
-        # "epsilon" for the epsilon-greedy exploration
-        self.exploration_rate = 0.0
-        # Linear schedule will be defined in `_setup_model()`
-        self.exploration_schedule = None
-        self.q_net, self.q_net_target = None, None
-
-        if _init_setup_model:
-            self._setup_model()
-
-    def _setup_model(self) -> None:
-        super(DQN, self)._setup_model()
-        self._create_aliases()
-        self.exploration_schedule = get_linear_fn(
-            self.exploration_initial_eps, self.exploration_final_eps, self.exploration_fraction
-        )
-
-    def _create_aliases(self) -> None:
-        self.q_net = self.policy.q_net
-        self.q_net_target = self.policy.q_net_target
-
-    def _on_step(self) -> None:
-        """
-        Update the exploration rate and target network if needed.
-        This method is called in ``collect_rollouts()`` after each step in the environment.
-        """
-        if self.num_timesteps % self.target_update_interval == 0:
-            polyak_update(self.q_net.parameters(), self.q_net_target.parameters(), self.tau)
-
-        self.exploration_rate = self.exploration_schedule(self._current_progress_remaining)
-        logger.record("rollout/exploration rate", self.exploration_rate)
-
-    def train(self, gradient_steps: int, batch_size: int = 100) -> None:
-        # Update learning rate according to schedule
-        self._update_learning_rate(self.policy.optimizer)
-
-        losses = []
-        for _ in range(gradient_steps):
-            # Sample replay buffer
-            replay_data = self.replay_buffer.sample(batch_size, env=self._vec_normalize_env)
-
-            with th.no_grad():
-                # Compute the next Q-values using the target network
-                next_q_values = self.q_net_target(replay_data.next_observations)
-                # Follow greedy policy: use the one with the highest value
-                next_q_values, _ = next_q_values.max(dim=1)
-                # Avoid potential broadcast issue
-                next_q_values = next_q_values.reshape(-1, 1)
-                # 1-step TD target
-                target_q_values = replay_data.rewards + (1 - replay_data.dones) * self.gamma * next_q_values
-
-            # Get current Q-values estimates
-            current_q_values = self.q_net(replay_data.observations)
-
-            # Retrieve the q-values for the actions from the replay buffer
-            current_q_values = th.gather(current_q_values, dim=1, index=replay_data.actions.long())
-
-            # Compute Huber loss (less sensitive to outliers)
-            loss = F.smooth_l1_loss(current_q_values, target_q_values)
-            losses.append(loss.item())
-
-            # Optimize the policy
-            self.policy.optimizer.zero_grad()
-            loss.backward()
-            # Clip gradient norm
-            th.nn.utils.clip_grad_norm_(self.policy.parameters(), self.max_grad_norm)
-            self.policy.optimizer.step()
-
-        # Increase update counter
-        self._n_updates += gradient_steps
-
-        logger.record("train/n_updates", self._n_updates, exclude="tensorboard")
-        logger.record("train/loss", np.mean(losses))
-
-    def predict(
-        self,
-        observation: np.ndarray,
-        state: Optional[np.ndarray] = None,
-        mask: Optional[np.ndarray] = None,
-        deterministic: bool = False,
-    ) -> Tuple[np.ndarray, Optional[np.ndarray]]:
-        """
-        Overrides the base_class predict function to include epsilon-greedy exploration.
-
-        :param observation: the input observation
-        :param state: The last states (can be None, used in recurrent policies)
-        :param mask: The last masks (can be None, used in recurrent policies)
-        :param deterministic: Whether or not to return deterministic actions.
-        :return: the model's action and the next state
-            (used in recurrent policies)
-        """
-        if not deterministic and np.random.rand() < self.exploration_rate:
-            if is_vectorized_observation(maybe_transpose(observation, self.observation_space), self.observation_space):
-                n_batch = observation.shape[0]
-                action = np.array([self.action_space.sample() for _ in range(n_batch)])
-            else:
-                action = np.array(self.action_space.sample())
-        else:
-            action, state = self.policy.predict(observation, state, mask, deterministic)
-        return action, state
-
-    def learn(
-        self,
-        total_timesteps: int,
-        callback: MaybeCallback = None,
-        log_interval: int = 4,
-        eval_env: Optional[GymEnv] = None,
-        eval_freq: int = -1,
-        n_eval_episodes: int = 5,
-        tb_log_name: str = "DQN",
-        eval_log_path: Optional[str] = None,
-        reset_num_timesteps: bool = True,
-    ) -> OffPolicyAlgorithm:
-
-        return super(DQN, self).learn(
-            total_timesteps=total_timesteps,
-            callback=callback,
-            log_interval=log_interval,
-            eval_env=eval_env,
-            eval_freq=eval_freq,
-            n_eval_episodes=n_eval_episodes,
-            tb_log_name=tb_log_name,
-            eval_log_path=eval_log_path,
-            reset_num_timesteps=reset_num_timesteps,
-        )
-
-    def _excluded_save_params(self) -> List[str]:
-        return super(DQN, self)._excluded_save_params() + ["q_net", "q_net_target"]
-
-    def _get_torch_save_params(self) -> Tuple[List[str], List[str]]:
-        state_dicts = ["policy", "policy.optimizer"]
-
-        return state_dicts, []

crazy_functions/test_project/python/dqn/policies.py

@@ -1,237 +0,0 @@
-from typing import Any, Dict, List, Optional, Type
-
-import gym
-import torch as th
-from torch import nn
-
-from stable_baselines3.common.policies import BasePolicy, register_policy
-from stable_baselines3.common.torch_layers import BaseFeaturesExtractor, FlattenExtractor, NatureCNN, create_mlp
-from stable_baselines3.common.type_aliases import Schedule
-
-
-class QNetwork(BasePolicy):
-    """
-    Action-Value (Q-Value) network for DQN
-
-    :param observation_space: Observation space
-    :param action_space: Action space
-    :param net_arch: The specification of the policy and value networks.
-    :param activation_fn: Activation function
-    :param normalize_images: Whether to normalize images or not,
-         dividing by 255.0 (True by default)
-    """
-
-    def __init__(
-        self,
-        observation_space: gym.spaces.Space,
-        action_space: gym.spaces.Space,
-        features_extractor: nn.Module,
-        features_dim: int,
-        net_arch: Optional[List[int]] = None,
-        activation_fn: Type[nn.Module] = nn.ReLU,
-        normalize_images: bool = True,
-    ):
-        super(QNetwork, self).__init__(
-            observation_space,
-            action_space,
-            features_extractor=features_extractor,
-            normalize_images=normalize_images,
-        )
-
-        if net_arch is None:
-            net_arch = [64, 64]
-
-        self.net_arch = net_arch
-        self.activation_fn = activation_fn
-        self.features_extractor = features_extractor
-        self.features_dim = features_dim
-        self.normalize_images = normalize_images
-        action_dim = self.action_space.n  # number of actions
-        q_net = create_mlp(self.features_dim, action_dim, self.net_arch, self.activation_fn)
-        self.q_net = nn.Sequential(*q_net)
-
-    def forward(self, obs: th.Tensor) -> th.Tensor:
-        """
-        Predict the q-values.
-
-        :param obs: Observation
-        :return: The estimated Q-Value for each action.
-        """
-        return self.q_net(self.extract_features(obs))
-
-    def _predict(self, observation: th.Tensor, deterministic: bool = True) -> th.Tensor:
-        q_values = self.forward(observation)
-        # Greedy action
-        action = q_values.argmax(dim=1).reshape(-1)
-        return action
-
-    def _get_constructor_parameters(self) -> Dict[str, Any]:
-        data = super()._get_constructor_parameters()
-
-        data.update(
-            dict(
-                net_arch=self.net_arch,
-                features_dim=self.features_dim,
-                activation_fn=self.activation_fn,
-                features_extractor=self.features_extractor,
-            )
-        )
-        return data
-
-
-class DQNPolicy(BasePolicy):
-    """
-    Policy class with Q-Value Net and target net for DQN
-
-    :param observation_space: Observation space
-    :param action_space: Action space
-    :param lr_schedule: Learning rate schedule (could be constant)
-    :param net_arch: The specification of the policy and value networks.
-    :param activation_fn: Activation function
-    :param features_extractor_class: Features extractor to use.
-    :param features_extractor_kwargs: Keyword arguments
-        to pass to the features extractor.
-    :param normalize_images: Whether to normalize images or not,
-         dividing by 255.0 (True by default)
-    :param optimizer_class: The optimizer to use,
-        ``th.optim.Adam`` by default
-    :param optimizer_kwargs: Additional keyword arguments,
-        excluding the learning rate, to pass to the optimizer
-    """
-
-    def __init__(
-        self,
-        observation_space: gym.spaces.Space,
-        action_space: gym.spaces.Space,
-        lr_schedule: Schedule,
-        net_arch: Optional[List[int]] = None,
-        activation_fn: Type[nn.Module] = nn.ReLU,
-        features_extractor_class: Type[BaseFeaturesExtractor] = FlattenExtractor,
-        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
-        normalize_images: bool = True,
-        optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,
-        optimizer_kwargs: Optional[Dict[str, Any]] = None,
-    ):
-        super(DQNPolicy, self).__init__(
-            observation_space,
-            action_space,
-            features_extractor_class,
-            features_extractor_kwargs,
-            optimizer_class=optimizer_class,
-            optimizer_kwargs=optimizer_kwargs,
-        )
-
-        if net_arch is None:
-            if features_extractor_class == FlattenExtractor:
-                net_arch = [64, 64]
-            else:
-                net_arch = []
-
-        self.net_arch = net_arch
-        self.activation_fn = activation_fn
-        self.normalize_images = normalize_images
-
-        self.net_args = {
-            "observation_space": self.observation_space,
-            "action_space": self.action_space,
-            "net_arch": self.net_arch,
-            "activation_fn": self.activation_fn,
-            "normalize_images": normalize_images,
-        }
-
-        self.q_net, self.q_net_target = None, None
-        self._build(lr_schedule)
-
-    def _build(self, lr_schedule: Schedule) -> None:
-        """
-        Create the network and the optimizer.
-
-        :param lr_schedule: Learning rate schedule
-            lr_schedule(1) is the initial learning rate
-        """
-
-        self.q_net = self.make_q_net()
-        self.q_net_target = self.make_q_net()
-        self.q_net_target.load_state_dict(self.q_net.state_dict())
-
-        # Setup optimizer with initial learning rate
-        self.optimizer = self.optimizer_class(self.parameters(), lr=lr_schedule(1), **self.optimizer_kwargs)
-
-    def make_q_net(self) -> QNetwork:
-        # Make sure we always have separate networks for features extractors etc
-        net_args = self._update_features_extractor(self.net_args, features_extractor=None)
-        return QNetwork(**net_args).to(self.device)
-
-    def forward(self, obs: th.Tensor, deterministic: bool = True) -> th.Tensor:
-        return self._predict(obs, deterministic=deterministic)
-
-    def _predict(self, obs: th.Tensor, deterministic: bool = True) -> th.Tensor:
-        return self.q_net._predict(obs, deterministic=deterministic)
-
-    def _get_constructor_parameters(self) -> Dict[str, Any]:
-        data = super()._get_constructor_parameters()
-
-        data.update(
-            dict(
-                net_arch=self.net_args["net_arch"],
-                activation_fn=self.net_args["activation_fn"],
-                lr_schedule=self._dummy_schedule,  # dummy lr schedule, not needed for loading policy alone
-                optimizer_class=self.optimizer_class,
-                optimizer_kwargs=self.optimizer_kwargs,
-                features_extractor_class=self.features_extractor_class,
-                features_extractor_kwargs=self.features_extractor_kwargs,
-            )
-        )
-        return data
-
-
-MlpPolicy = DQNPolicy
-
-
-class CnnPolicy(DQNPolicy):
-    """
-    Policy class for DQN when using images as input.
-
-    :param observation_space: Observation space
-    :param action_space: Action space
-    :param lr_schedule: Learning rate schedule (could be constant)
-    :param net_arch: The specification of the policy and value networks.
-    :param activation_fn: Activation function
-    :param features_extractor_class: Features extractor to use.
-    :param normalize_images: Whether to normalize images or not,
-         dividing by 255.0 (True by default)
-    :param optimizer_class: The optimizer to use,
-        ``th.optim.Adam`` by default
-    :param optimizer_kwargs: Additional keyword arguments,
-        excluding the learning rate, to pass to the optimizer
-    """
-
-    def __init__(
-        self,
-        observation_space: gym.spaces.Space,
-        action_space: gym.spaces.Space,
-        lr_schedule: Schedule,
-        net_arch: Optional[List[int]] = None,
-        activation_fn: Type[nn.Module] = nn.ReLU,
-        features_extractor_class: Type[BaseFeaturesExtractor] = NatureCNN,
-        features_extractor_kwargs: Optional[Dict[str, Any]] = None,
-        normalize_images: bool = True,
-        optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,
-        optimizer_kwargs: Optional[Dict[str, Any]] = None,
-    ):
-        super(CnnPolicy, self).__init__(
-            observation_space,
-            action_space,
-            lr_schedule,
-            net_arch,
-            activation_fn,
-            features_extractor_class,
-            features_extractor_kwargs,
-            normalize_images,
-            optimizer_class,
-            optimizer_kwargs,
-        )
-
-
-register_policy("MlpPolicy", MlpPolicy)
-register_policy("CnnPolicy", CnnPolicy)

crazy_functions/test_project/python/dqn/来源

@@ -1,2 +0,0 @@
-github stablebaseline3
-https://github.com/DLR-RM/stable-baselines3

crazy_functions/test_project/其他测试

@@ -1,27 +0,0 @@
-"In practice, we found that a high-entropy initial state is more likely to increase the speed of training.
-The entropy is calculated by:
-$$H=-\sum_{k= 1}^{n_k} p(k) \cdot \log p(k), p(k)=\frac{|A_k|}{|\mathcal{A}|}$$
-where $H$ is the entropy, $|A_k|$ is the number of agent nodes in $k$-th cluster, $|\mathcal{A}|$ is the total number of agents.
-To ensure the Cooperation Graph initialization has higher entropy,
-we will randomly generate multiple initial states, 
-rank by their entropy and then pick the one with maximum $H$."
-
-```
-FROM ubuntu:latest
-
-RUN apt-get update && \
-    apt-get install -y python3 python3-pip && \
-    rm -rf /var/lib/apt/lists/*
-
-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
-
-RUN pip3 install gradio requests[socks] mdtex2html
-
-COPY . /gpt
-WORKDIR /gpt
-
-
-CMD ["python3", "main.py"]
-```

crazy_functions/vt_fns/vt_call_plugin.py

@@ -0,0 +1,114 @@
+from pydantic import BaseModel, Field
+from typing import List
+from toolbox import update_ui_lastest_msg, disable_auto_promotion
+from request_llm.bridge_all import predict_no_ui_long_connection
+from crazy_functions.json_fns.pydantic_io import GptJsonIO, JsonStringError
+import copy, json, pickle, os, sys, time
+
+
+def read_avail_plugin_enum():
+    from crazy_functional import get_crazy_functions
+    plugin_arr = get_crazy_functions()
+    # remove plugins with out explaination
+    plugin_arr = {k:v for k, v in plugin_arr.items() if 'Info' in v}
+    plugin_arr_info = {"F_{:04d}".format(i):v["Info"] for i, v in enumerate(plugin_arr.values(), start=1)}
+    plugin_arr_dict = {"F_{:04d}".format(i):v for i, v in enumerate(plugin_arr.values(), start=1)}
+    plugin_arr_dict_parse = {"F_{:04d}".format(i):v for i, v in enumerate(plugin_arr.values(), start=1)}
+    plugin_arr_dict_parse.update({f"F_{i}":v for i, v in enumerate(plugin_arr.values(), start=1)})
+    prompt = json.dumps(plugin_arr_info, ensure_ascii=False, indent=2)
+    prompt = "\n\nThe defination of PluginEnum:\nPluginEnum=" + prompt
+    return prompt, plugin_arr_dict, plugin_arr_dict_parse
+
+def wrap_code(txt):
+    txt = txt.replace('```','')
+    return f"\n```\n{txt}\n```\n"
+
+def have_any_recent_upload_files(chatbot):
+    _5min = 5 * 60
+    if not chatbot: return False    # chatbot is None
+    most_recent_uploaded = chatbot._cookies.get("most_recent_uploaded", None)
+    if not most_recent_uploaded: return False   # most_recent_uploaded is None
+    if time.time() - most_recent_uploaded["time"] < _5min: return True # most_recent_uploaded is new
+    else: return False  # most_recent_uploaded is too old
+
+def get_recent_file_prompt_support(chatbot):
+    most_recent_uploaded = chatbot._cookies.get("most_recent_uploaded", None)
+    path = most_recent_uploaded['path']
+    prompt =   "\nAdditional Information:\n"
+    prompt =   "In case that this plugin requires a path or a file as argument," 
+    prompt += f"it is important for you to know that the user has recently uploaded a file, located at: `{path}`" 
+    prompt += f"Only use it when necessary, otherwise, you can ignore this file." 
+    return prompt
+
+def get_inputs_show_user(inputs, plugin_arr_enum_prompt):
+    # remove plugin_arr_enum_prompt from inputs string
+    inputs_show_user = inputs.replace(plugin_arr_enum_prompt, "")
+    inputs_show_user += plugin_arr_enum_prompt[:200] + '...'
+    inputs_show_user += '\n...\n'
+    inputs_show_user += '...\n'
+    inputs_show_user += '...}'
+    return inputs_show_user
+
+def execute_plugin(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_intention):
+    plugin_arr_enum_prompt, plugin_arr_dict, plugin_arr_dict_parse = read_avail_plugin_enum()
+    class Plugin(BaseModel):
+        plugin_selection: str = Field(description="The most related plugin from one of the PluginEnum.", default="F_0000")
+        reason_of_selection: str = Field(description="The reason why you should select this plugin.", default="This plugin satisfy user requirement most")
+    # ⭐ ⭐ ⭐ 选择插件
+    yield from update_ui_lastest_msg(lastmsg=f"正在执行任务: {txt}\n\n查找可用插件中...", chatbot=chatbot, history=history, delay=0)
+    gpt_json_io = GptJsonIO(Plugin)
+    gpt_json_io.format_instructions = "The format of your output should be a json that can be parsed by json.loads.\n"
+    gpt_json_io.format_instructions += """Output example: {"plugin_selection":"F_1234", "reason_of_selection":"F_1234 plugin satisfy user requirement most"}\n"""
+    gpt_json_io.format_instructions += "The plugins you are authorized to use are listed below:\n"
+    gpt_json_io.format_instructions += plugin_arr_enum_prompt
+    inputs = "Choose the correct plugin according to user requirements, the user requirement is: \n\n" + \
+             ">> " + txt.rstrip('\n').replace('\n','\n>> ') + '\n\n' + gpt_json_io.format_instructions
+
+    run_gpt_fn = lambda inputs, sys_prompt: predict_no_ui_long_connection(
+        inputs=inputs, llm_kwargs=llm_kwargs, history=[], sys_prompt=sys_prompt, observe_window=[])
+    try:
+        gpt_reply = run_gpt_fn(inputs, "")
+        plugin_sel = gpt_json_io.generate_output_auto_repair(gpt_reply, run_gpt_fn)
+    except JsonStringError:
+        msg = f"抱歉, {llm_kwargs['llm_model']}无法理解您的需求。"
+        msg += "请求的Prompt为：\n" + wrap_code(get_inputs_show_user(inputs, plugin_arr_enum_prompt))
+        msg += "语言模型回复为：\n" + wrap_code(gpt_reply)
+        msg += "\n但您可以尝试再试一次\n"
+        yield from update_ui_lastest_msg(lastmsg=msg, chatbot=chatbot, history=history, delay=2)
+        return
+    if plugin_sel.plugin_selection not in plugin_arr_dict_parse:
+        msg = f"抱歉, 找不到合适插件执行该任务, 或者{llm_kwargs['llm_model']}无法理解您的需求。"
+        msg += f"语言模型{llm_kwargs['llm_model']}选择了不存在的插件：\n" + wrap_code(gpt_reply)
+        msg += "\n但您可以尝试再试一次\n"
+        yield from update_ui_lastest_msg(lastmsg=msg, chatbot=chatbot, history=history, delay=2)
+        return
+    
+    # ⭐ ⭐ ⭐ 确认插件参数
+    if not have_any_recent_upload_files(chatbot):
+        appendix_info = ""
+    else:
+        appendix_info = get_recent_file_prompt_support(chatbot)
+
+    plugin = plugin_arr_dict_parse[plugin_sel.plugin_selection]
+    yield from update_ui_lastest_msg(lastmsg=f"正在执行任务: {txt}\n\n提取插件参数...", chatbot=chatbot, history=history, delay=0)
+    class PluginExplicit(BaseModel):
+        plugin_selection: str = plugin_sel.plugin_selection
+        plugin_arg: str = Field(description="The argument of the plugin.", default="")
+    gpt_json_io = GptJsonIO(PluginExplicit)
+    gpt_json_io.format_instructions += "The information about this plugin is:" + plugin["Info"]
+    inputs = f"A plugin named {plugin_sel.plugin_selection} is selected, " + \
+             "you should extract plugin_arg from the user requirement, the user requirement is: \n\n" + \
+             ">> " + (txt + appendix_info).rstrip('\n').replace('\n','\n>> ') + '\n\n' + \
+             gpt_json_io.format_instructions 
+    run_gpt_fn = lambda inputs, sys_prompt: predict_no_ui_long_connection(
+        inputs=inputs, llm_kwargs=llm_kwargs, history=[], sys_prompt=sys_prompt, observe_window=[])
+    plugin_sel = gpt_json_io.generate_output_auto_repair(run_gpt_fn(inputs, ""), run_gpt_fn)
+
+
+    # ⭐ ⭐ ⭐ 执行插件
+    fn = plugin['Function']
+    fn_name = fn.__name__
+    msg = f'{llm_kwargs["llm_model"]}为您选择了插件: `{fn_name}`\n\n插件说明：{plugin["Info"]}\n\n插件参数：{plugin_sel.plugin_arg}\n\n假如偏离了您的要求，按停止键终止。'
+    yield from update_ui_lastest_msg(lastmsg=msg, chatbot=chatbot, history=history, delay=2)
+    yield from fn(plugin_sel.plugin_arg, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, -1)
+    return

crazy_functions/vt_fns/vt_modify_config.py

@@ -0,0 +1,81 @@
+from pydantic import BaseModel, Field
+from typing import List
+from toolbox import update_ui_lastest_msg, get_conf
+from request_llm.bridge_all import predict_no_ui_long_connection
+from crazy_functions.json_fns.pydantic_io import GptJsonIO
+import copy, json, pickle, os, sys
+
+
+def modify_configuration_hot(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_intention):
+    ALLOW_RESET_CONFIG, = get_conf('ALLOW_RESET_CONFIG')
+    if not ALLOW_RESET_CONFIG:
+        yield from update_ui_lastest_msg(
+            lastmsg=f"当前配置不允许被修改！如需激活本功能，请在config.py中设置ALLOW_RESET_CONFIG=True后重启软件。", 
+            chatbot=chatbot, history=history, delay=2
+        )
+        return
+
+    # ⭐ ⭐ ⭐ 读取可配置项目条目
+    names = {}
+    from enum import Enum
+    import config
+    for k, v in config.__dict__.items():
+        if k.startswith('__'): continue
+        names.update({k:k})
+        # if len(names) > 20: break   # 限制最多前10个配置项，如果太多了会导致gpt无法理解
+
+    ConfigOptions = Enum('ConfigOptions', names)
+    class ModifyConfigurationIntention(BaseModel):
+        which_config_to_modify: ConfigOptions = Field(description="the name of the configuration to modify, you must choose from one of the ConfigOptions enum.", default=None)
+        new_option_value: str = Field(description="the new value of the option", default=None)
+
+    # ⭐ ⭐ ⭐ 分析用户意图
+    yield from update_ui_lastest_msg(lastmsg=f"正在执行任务: {txt}\n\n读取新配置中", chatbot=chatbot, history=history, delay=0)
+    gpt_json_io = GptJsonIO(ModifyConfigurationIntention)
+    inputs = "Analyze how to change configuration according to following user input, answer me with json: \n\n" + \
+             ">> " + txt.rstrip('\n').replace('\n','\n>> ') + '\n\n' + \
+             gpt_json_io.format_instructions
+    
+    run_gpt_fn = lambda inputs, sys_prompt: predict_no_ui_long_connection(
+        inputs=inputs, llm_kwargs=llm_kwargs, history=[], sys_prompt=sys_prompt, observe_window=[])
+    user_intention = gpt_json_io.generate_output_auto_repair(run_gpt_fn(inputs, ""), run_gpt_fn)
+
+    explicit_conf = user_intention.which_config_to_modify.value
+
+    ok = (explicit_conf in txt)
+    if ok:
+        yield from update_ui_lastest_msg(
+            lastmsg=f"正在执行任务: {txt}\n\n新配置{explicit_conf}={user_intention.new_option_value}", 
+            chatbot=chatbot, history=history, delay=1
+        )
+        yield from update_ui_lastest_msg(
+            lastmsg=f"正在执行任务: {txt}\n\n新配置{explicit_conf}={user_intention.new_option_value}\n\n正在修改配置中", 
+            chatbot=chatbot, history=history, delay=2
+        )
+
+        # ⭐ ⭐ ⭐ 立即应用配置
+        from toolbox import set_conf
+        set_conf(explicit_conf, user_intention.new_option_value)
+
+        yield from update_ui_lastest_msg(
+            lastmsg=f"正在执行任务: {txt}\n\n配置修改完成，重新页面即可生效。", chatbot=chatbot, history=history, delay=1
+        )
+    else:
+        yield from update_ui_lastest_msg(
+            lastmsg=f"失败，如果需要配置{explicit_conf}，您需要明确说明并在指令中提到它。", chatbot=chatbot, history=history, delay=5
+        )
+
+def modify_configuration_reboot(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_intention):
+    ALLOW_RESET_CONFIG, = get_conf('ALLOW_RESET_CONFIG')
+    if not ALLOW_RESET_CONFIG:
+        yield from update_ui_lastest_msg(
+            lastmsg=f"当前配置不允许被修改！如需激活本功能，请在config.py中设置ALLOW_RESET_CONFIG=True后重启软件。", 
+            chatbot=chatbot, history=history, delay=2
+        )
+        return
+
+    yield from modify_configuration_hot(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_intention)
+    yield from update_ui_lastest_msg(
+        lastmsg=f"正在执行任务: {txt}\n\n配置修改完成，五秒后即将重启！若出现报错请无视即可。", chatbot=chatbot, history=history, delay=5
+    )
+    os.execl(sys.executable, sys.executable, *sys.argv)

crazy_functions/vt_fns/vt_state.py

@@ -0,0 +1,28 @@
+import pickle
+
+class VoidTerminalState():
+    def __init__(self):
+        self.reset_state()
+
+    def reset_state(self):
+        self.has_provided_explaination = False
+ 
+    def lock_plugin(self, chatbot):
+        chatbot._cookies['lock_plugin'] = 'crazy_functions.虚空终端->虚空终端'
+        chatbot._cookies['plugin_state'] = pickle.dumps(self)
+
+    def unlock_plugin(self, chatbot):
+        self.reset_state()
+        chatbot._cookies['lock_plugin'] = None
+        chatbot._cookies['plugin_state'] = pickle.dumps(self)
+
+    def set_state(self, chatbot, key, value):
+        setattr(self, key, value)
+        chatbot._cookies['plugin_state'] = pickle.dumps(self)
+
+    def get_state(chatbot):
+        state = chatbot._cookies.get('plugin_state', None)
+        if state is not None:   state = pickle.loads(state)
+        else:                   state = VoidTerminalState()
+        state.chatbot = chatbot
+        return state

crazy_functions/命令行助手.py

@@ -0,0 +1,31 @@
+from toolbox import CatchException, update_ui, gen_time_str
+from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
+from .crazy_utils import input_clipping
+import copy, json
+
+@CatchException
+def 命令行助手(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 = []
+
+    # 输入
+    i_say = "请写bash命令实现以下功能：" + txt
+    # 开始
+    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+        inputs=i_say, inputs_show_user=txt, 
+        llm_kwargs=llm_kwargs, chatbot=chatbot, history=[], 
+        sys_prompt="你是一个Linux大师级用户。注意，当我要求你写bash命令时，尽可能地仅用一行命令解决我的要求。"
+    )
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+
+
+

crazy_functions/图片生成.py

@@ -55,7 +55,7 @@ def 图片生成(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_pro
     web_port        当前软件运行的端口号
     """
     history = []    # 清空历史，以免输入溢出
-    chatbot.append(("这是什么功能？", "[Local Message] 生成图像, 请先把模型切换至gpt-xxxx或者api2d-xxxx。如果中文效果不理想, 尝试Prompt。正在处理中 ....."))
+    chatbot.append(("这是什么功能？", "[Local Message] 生成图像, 请先把模型切换至gpt-*或者api2d-*。如果中文效果不理想, 请尝试英文Prompt。正在处理中 ....."))
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
     if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
     resolution = plugin_kwargs.get("advanced_arg", '256x256')

crazy_functions/批量Markdown翻译.py

@@ -1,5 +1,7 @@
-from toolbox import update_ui, trimmed_format_exc, gen_time_str
-from toolbox import CatchException, report_execption, write_results_to_file
+import glob, time, os, re
+from toolbox import update_ui, trimmed_format_exc, gen_time_str, disable_auto_promotion
+from toolbox import CatchException, report_execption, write_history_to_file
+from toolbox import promote_file_to_downloadzone, get_log_folder
 fast_debug = False
 
 class PaperFileGroup():
@@ -42,13 +44,13 @@ class PaperFileGroup():
     def write_result(self, language):
         manifest = []
         for path, res in zip(self.file_paths, self.file_result):
-            with open(path + f'.{gen_time_str()}.{language}.md', 'w', encoding='utf8') as f:
-                manifest.append(path + f'.{gen_time_str()}.{language}.md')
+            dst_file = os.path.join(get_log_folder(), f'{gen_time_str()}.md')
+            with open(dst_file, 'w', encoding='utf8') as f:
+                manifest.append(dst_file)
                 f.write(res)
         return manifest
 
 def 多文件翻译(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, language='en'):
-    import time, os, re
     from .crazy_utils import request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency
 
     #  <-------- 读取Markdown文件，删除其中的所有注释 ----------> 
@@ -102,28 +104,38 @@ def 多文件翻译(file_manifest, project_folder, llm_kwargs, plugin_kwargs, ch
         print(trimmed_format_exc())
 
     #  <-------- 整理结果，退出 ----------> 
-    create_report_file_name = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime()) + f"-chatgpt.polish.md"
-    res = write_results_to_file(gpt_response_collection, file_name=create_report_file_name)
+    create_report_file_name = gen_time_str() + f"-chatgpt.md"
+    res = write_history_to_file(gpt_response_collection, file_basename=create_report_file_name)
+    promote_file_to_downloadzone(res, chatbot=chatbot)
     history = gpt_response_collection
     chatbot.append((f"{fp}完成了吗？", res))
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
 
 
-def get_files_from_everything(txt):
-    import glob, os
-
+def get_files_from_everything(txt, preference=''):
+    if txt == "": return False, None, None
     success = True
     if txt.startswith('http'):
-        # 网络的远程文件
-        txt = txt.replace("https://github.com/", "https://raw.githubusercontent.com/")
-        txt = txt.replace("/blob/", "/")
         import requests
         from toolbox import get_conf
         proxies, = get_conf('proxies')
+        # 网络的远程文件
+        if preference == 'Github':
+            print('正在从github下载资源 ...')
+            if not txt.endswith('.md'):
+                # Make a request to the GitHub API to retrieve the repository information
+                url = txt.replace("https://github.com/", "https://api.github.com/repos/") + '/readme'
+                response = requests.get(url, proxies=proxies)
+                txt = response.json()['download_url']
+            else:
+                txt = txt.replace("https://github.com/", "https://raw.githubusercontent.com/")
+                txt = txt.replace("/blob/", "/")
+
         r = requests.get(txt, proxies=proxies)
-        with open('./gpt_log/temp.md', 'wb+') as f: f.write(r.content)
-        project_folder = './gpt_log/'
-        file_manifest = ['./gpt_log/temp.md']
+        download_local = f'{get_log_folder(plugin_name="批量Markdown翻译")}/raw-readme-{gen_time_str()}.md'
+        project_folder = f'{get_log_folder(plugin_name="批量Markdown翻译")}'
+        with open(download_local, 'wb+') as f: f.write(r.content)
+        file_manifest = [download_local]
     elif txt.endswith('.md'):
         # 直接给定文件
         file_manifest = [txt]
@@ -133,6 +145,8 @@ def get_files_from_everything(txt):
         project_folder = txt
         file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.md', recursive=True)]
     else:
+        project_folder = None
+        file_manifest = []
         success = False
 
     return success, file_manifest, project_folder
@@ -145,11 +159,11 @@ def Markdown英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p
         "函数插件功能？",
         "对整个Markdown项目进行翻译。函数插件贡献者: Binary-Husky"])
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+    disable_auto_promotion(chatbot)
 
     # 尝试导入依赖，如果缺少依赖，则给出安装建议
     try:
         import tiktoken
-        import glob, os
     except:
         report_execption(chatbot, history,
                          a=f"解析项目: {txt}",
@@ -158,7 +172,7 @@ def Markdown英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p
         return
     history = []    # 清空历史，以免输入溢出
 
-    success, file_manifest, project_folder = get_files_from_everything(txt)
+    success, file_manifest, project_folder = get_files_from_everything(txt, preference="Github")
 
     if not success:
         # 什么都没有
@@ -185,11 +199,11 @@ def Markdown中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p
         "函数插件功能？",
         "对整个Markdown项目进行翻译。函数插件贡献者: Binary-Husky"])
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+    disable_auto_promotion(chatbot)
 
     # 尝试导入依赖，如果缺少依赖，则给出安装建议
     try:
         import tiktoken
-        import glob, os
     except:
         report_execption(chatbot, history,
                          a=f"解析项目: {txt}",
@@ -218,11 +232,11 @@ def Markdown翻译指定语言(txt, llm_kwargs, plugin_kwargs, chatbot, history,
         "函数插件功能？",
         "对整个Markdown项目进行翻译。函数插件贡献者: Binary-Husky"])
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+    disable_auto_promotion(chatbot)
 
     # 尝试导入依赖，如果缺少依赖，则给出安装建议
     try:
         import tiktoken
-        import glob, os
     except:
         report_execption(chatbot, history,
                          a=f"解析项目: {txt}",

crazy_functions/批量翻译PDF文档_多线程.py

@@ -1,15 +1,19 @@
 from toolbox import CatchException, report_execption, write_results_to_file
-from toolbox import update_ui, promote_file_to_downloadzone
+from toolbox import update_ui, promote_file_to_downloadzone, update_ui_lastest_msg, disable_auto_promotion
+from toolbox import write_history_to_file, get_log_folder
 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
+from .pdf_fns.parse_pdf import parse_pdf, get_avail_grobid_url
 from colorful import *
+import glob
+import os
+import math
 
 @CatchException
-def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, sys_prompt, web_port):
-    import glob
-    import os
+def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
 
+    disable_auto_promotion(chatbot)
     # 基本信息：功能、贡献者
     chatbot.append([
         "函数插件功能？",
@@ -30,20 +34,11 @@ def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, sys_
     # 清空历史，以免输入溢出
     history = []
 
+    from .crazy_utils import get_files_from_everything
+    success, file_manifest, project_folder = get_files_from_everything(txt, type='.pdf')
     # 检测输入参数，如没有给定输入参数，直接退出
-    if os.path.exists(txt):
-        project_folder = txt
-    else:
-        if txt == "":
-            txt = '空空如也的输入栏'
-        report_execption(chatbot, history,
-                         a=f"解析项目: {txt}", b=f"找不到本地项目或无权访问: {txt}")
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-
-    # 搜索需要处理的文件清单
-    file_manifest = [f for f in glob.glob(
-        f'{project_folder}/**/*.pdf', recursive=True)]
+    if not success:
+        if txt == "": txt = '空空如也的输入栏'
 
     # 如果没找到任何文件
     if len(file_manifest) == 0:
@@ -53,22 +48,130 @@ def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, sys_
         return
 
     # 开始正式执行任务
-    yield from 解析PDF(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, sys_prompt)
+    grobid_url = get_avail_grobid_url()
+    if grobid_url is not None:
+        yield from 解析PDF_基于GROBID(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, grobid_url)
+    else:
+        yield from update_ui_lastest_msg("GROBID服务不可用，请检查config中的GROBID_URL。作为替代，现在将执行效果稍差的旧版代码。", chatbot, history, delay=3)
+        yield from 解析PDF(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)
 
 
-def 解析PDF(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, sys_prompt):
-    import os
+def 解析PDF_基于GROBID(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, grobid_url):
     import copy
     import tiktoken
     TOKEN_LIMIT_PER_FRAGMENT = 1280
     generated_conclusion_files = []
     generated_html_files = []
+    DST_LANG = "中文"
     for index, fp in enumerate(file_manifest):
+        chatbot.append(["当前进度：", f"正在连接GROBID服务，请稍候: {grobid_url}\n如果等待时间过长，请修改config中的GROBID_URL，可修改成本地GROBID服务。"]); yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+        article_dict = parse_pdf(fp, grobid_url)
+        print(article_dict)
+        prompt = "以下是一篇学术论文的基本信息:\n"
+        # title
+        title = article_dict.get('title', '无法获取 title'); prompt += f'title:{title}\n\n'
+        # authors
+        authors = article_dict.get('authors', '无法获取 authors'); prompt += f'authors:{authors}\n\n'
+        # abstract
+        abstract = article_dict.get('abstract', '无法获取 abstract'); prompt += f'abstract:{abstract}\n\n'
+        # command
+        prompt += f"请将题目和摘要翻译为{DST_LANG}。"
+        meta = [f'# Title:\n\n', title, f'# Abstract:\n\n', abstract ]
 
+        # 单线，获取文章meta信息
+        paper_meta_info = yield from request_gpt_model_in_new_thread_with_ui_alive(
+            inputs=prompt,
+            inputs_show_user=prompt,
+            llm_kwargs=llm_kwargs,
+            chatbot=chatbot, history=[],
+            sys_prompt="You are an academic paper reader。",
+        )
+
+        # 多线，翻译
+        inputs_array = []
+        inputs_show_user_array = []
+
+        # get_token_num
+        from request_llm.bridge_all import model_info
+        enc = model_info[llm_kwargs['llm_model']]['tokenizer']
+        def get_token_num(txt): return len(enc.encode(txt, disallowed_special=()))
+        from .crazy_utils import breakdown_txt_to_satisfy_token_limit_for_pdf
+
+        def break_down(txt):
+            raw_token_num = get_token_num(txt)
+            if raw_token_num <= TOKEN_LIMIT_PER_FRAGMENT:
+                return [txt]
+            else:
+                # raw_token_num > TOKEN_LIMIT_PER_FRAGMENT
+                # find a smooth token limit to achieve even seperation
+                count = int(math.ceil(raw_token_num / TOKEN_LIMIT_PER_FRAGMENT))
+                token_limit_smooth = raw_token_num // count + count
+                return breakdown_txt_to_satisfy_token_limit_for_pdf(txt, get_token_fn=get_token_num, limit=token_limit_smooth)
+
+        for section in article_dict.get('sections'):
+            if len(section['text']) == 0: continue
+            section_frags = break_down(section['text'])
+            for i, fragment in enumerate(section_frags):
+                heading = section['heading']
+                if len(section_frags) > 1: heading += f' Part-{i+1}'
+                inputs_array.append(
+                    f"你需要翻译{heading}章节，内容如下: \n\n{fragment}"
+                )
+                inputs_show_user_array.append(
+                    f"# {heading}\n\n{fragment}"
+                )
+
+        gpt_response_collection = yield from request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
+            inputs_array=inputs_array,
+            inputs_show_user_array=inputs_show_user_array,
+            llm_kwargs=llm_kwargs,
+            chatbot=chatbot,
+            history_array=[meta for _ in inputs_array],
+            sys_prompt_array=[
+                "请你作为一个学术翻译，负责把学术论文准确翻译成中文。注意文章中的每一句话都要翻译。" for _ in inputs_array],
+        )
+        res_path = write_history_to_file(meta +  ["# Meta Translation" , paper_meta_info] + gpt_response_collection, file_basename=None, file_fullname=None)
+        promote_file_to_downloadzone(res_path, rename_file=os.path.basename(fp)+'.md', chatbot=chatbot)
+        generated_conclusion_files.append(res_path)
+
+        ch = construct_html() 
+        orig = ""
+        trans = ""
+        gpt_response_collection_html = copy.deepcopy(gpt_response_collection)
+        for i,k in enumerate(gpt_response_collection_html): 
+            if i%2==0:
+                gpt_response_collection_html[i] = inputs_show_user_array[i//2]
+            else:
+                gpt_response_collection_html[i] = gpt_response_collection_html[i]
+
+        final = ["", "", "一、论文概况",  "", "Abstract", paper_meta_info,  "二、论文翻译",  ""]
+        final.extend(gpt_response_collection_html)
+        for i, k in enumerate(final): 
+            if i%2==0:
+                orig = k
+            if i%2==1:
+                trans = k
+                ch.add_row(a=orig, b=trans)
+        create_report_file_name = f"{os.path.basename(fp)}.trans.html"
+        html_file = ch.save_file(create_report_file_name)
+        generated_html_files.append(html_file)
+        promote_file_to_downloadzone(html_file, rename_file=os.path.basename(html_file), chatbot=chatbot)
+
+    chatbot.append(("给出输出文件清单", str(generated_conclusion_files + generated_html_files)))
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+
+
+def 解析PDF(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt):
+    import copy
+    TOKEN_LIMIT_PER_FRAGMENT = 1280
+    generated_conclusion_files = []
+    generated_html_files = []
+    for index, fp in enumerate(file_manifest):
         # 读取PDF文件
         file_content, page_one = read_and_clean_pdf_text(fp)
         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
+
         # 递归地切割PDF文件
         from .crazy_utils import breakdown_txt_to_satisfy_token_limit_for_pdf
         from request_llm.bridge_all import model_info
@@ -140,8 +243,7 @@ def 解析PDF(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot,
                     trans = k
                     ch.add_row(a=orig, b=trans)
             create_report_file_name = f"{os.path.basename(fp)}.trans.html"
-            ch.save_file(create_report_file_name)
-            generated_html_files.append(f'./gpt_log/{create_report_file_name}')
+            generated_html_files.append(ch.save_file(create_report_file_name))
         except:
             from toolbox import trimmed_format_exc
             print('writing html result failed:', trimmed_format_exc())
@@ -202,6 +304,6 @@ class construct_html():
 
 
     def save_file(self, file_name):
-        with open(f'./gpt_log/{file_name}', 'w', encoding='utf8') as f:
+        with open(os.path.join(get_log_folder(), file_name), 'w', encoding='utf8') as f:
             f.write(self.html_string.encode('utf-8', 'ignore').decode())
-
+        return os.path.join(get_log_folder(), file_name)

crazy_functions/虚空终端.py

@@ -1,131 +1,179 @@
-from toolbox import CatchException, update_ui, gen_time_str
-from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
-from .crazy_utils import input_clipping
-
-
-prompt = """
-I have to achieve some functionalities by calling one of the functions below.
-Your job is to find the correct funtion to use to satisfy my requirement,
-and then write python code to call this function with correct parameters.
-
-These are functions you are allowed to choose from:
-1. 
-    功能描述: 总结音视频内容
-    调用函数: ConcludeAudioContent(txt, llm_kwargs)
-    参数说明: 
-            txt: 音频文件的路径
-            llm_kwargs: 模型参数, 永远给定None
-2. 
-    功能描述: 将每次对话记录写入Markdown格式的文件中
-    调用函数: WriteMarkdown()
-3.
-    功能描述: 将指定目录下的PDF文件从英文翻译成中文
-    调用函数: BatchTranslatePDFDocuments_MultiThreaded(txt, llm_kwargs)
-    参数说明: 
-            txt: PDF文件所在的路径
-            llm_kwargs: 模型参数, 永远给定None
-4.
-    功能描述: 根据文本使用GPT模型生成相应的图像
-    调用函数: ImageGeneration(txt, llm_kwargs)
-    参数说明: 
-            txt: 图像生成所用到的提示文本
-            llm_kwargs: 模型参数, 永远给定None
-5.
-    功能描述: 对输入的word文档进行摘要生成 
-    调用函数: SummarizingWordDocuments(input_path, output_path)
-    参数说明: 
-            input_path: 待处理的word文档路径
-            output_path: 摘要生成后的文档路径
-
-
-You should always anwser with following format:
-----------------
-Code:
-```
-class AutoAcademic(object):
-    def __init__(self):
-        self.selected_function = "FILL_CORRECT_FUNCTION_HERE"      # e.g., "GenerateImage"
-        self.txt = "FILL_MAIN_PARAMETER_HERE"      # e.g., "荷叶上的蜻蜓"
-        self.llm_kwargs = None
-```
-Explanation:
-只有GenerateImage和生成图像相关, 因此选择GenerateImage函数。
-----------------
-
-Now, this is my requirement: 
-
 """
-def get_fn_lib():
-    return {
-        "BatchTranslatePDFDocuments_MultiThreaded": ("crazy_functions.批量翻译PDF文档_多线程",  "批量翻译PDF文档"),
-        "SummarizingWordDocuments": ("crazy_functions.总结word文档",  "总结word文档"),
-        "ImageGeneration": ("crazy_functions.图片生成",  "图片生成"),
-        "TranslateMarkdownFromEnglishToChinese": ("crazy_functions.批量Markdown翻译",  "Markdown中译英"),
-        "SummaryAudioVideo": ("crazy_functions.总结音视频",  "总结音视频"),
-    }
+Explanation of the Void Terminal Plugin:
 
-def inspect_dependency(chatbot, history):
-    return True
+Please describe in natural language what you want to do.
 
-def eval_code(code, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
-    import subprocess, sys, os, shutil, importlib
+1. You can open the plugin's dropdown menu to explore various capabilities of this project, and then describe your needs in natural language, for example:
+- "Please call the plugin to translate a PDF paper for me. I just uploaded the paper to the upload area."
+- "Please use the plugin to translate a PDF paper, with the address being https://www.nature.com/articles/s41586-019-1724-z.pdf."
+- "Generate an image with blooming flowers and lush green grass using the plugin."
+- "Translate the README using the plugin. The GitHub URL is https://github.com/facebookresearch/co-tracker."
+- "Translate an Arxiv paper for me. The Arxiv ID is 1812.10695. Remember to use the plugin and don't do it manually!"
+- "I don't like the current interface color. Modify the configuration and change the theme to THEME="High-Contrast"."
+- "Could you please explain the structure of the Transformer network?"
 
-    with open('gpt_log/void_terminal_runtime.py', 'w', encoding='utf8') as f:
-        f.write(code)
+2. If you use keywords like "call the plugin xxx", "modify the configuration xxx", "please", etc., your intention can be recognized more accurately.
 
-    try:
-        AutoAcademic = getattr(importlib.import_module('gpt_log.void_terminal_runtime', 'AutoAcademic'), 'AutoAcademic')
-        # importlib.reload(AutoAcademic)
-        auto_dict = AutoAcademic()
-        selected_function = auto_dict.selected_function
-        txt = auto_dict.txt
-        fp, fn = get_fn_lib()[selected_function]
-        fn_plugin = getattr(importlib.import_module(fp, fn), fn)
-        yield from fn_plugin(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port)
-    except:
-        from toolbox import trimmed_format_exc
-        chatbot.append(["执行错误", f"\n```\n{trimmed_format_exc()}\n```\n"])
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+3. Your intention can be recognized more accurately when using powerful models like GPT4. This plugin is relatively new, so please feel free to provide feedback on GitHub.
+
+4. Now, if you need to process a file, please upload the file (drag the file to the file upload area) or describe the path to the file.
+
+5. If you don't need to upload a file, you can simply repeat your command again.
+"""
+explain_msg = """
+## 虚空终端插件说明:
+
+1. 请用**自然语言**描述您需要做什么。例如：
+    - 「请调用插件，为我翻译PDF论文，论文我刚刚放到上传区了。」
+    - 「请调用插件翻译PDF论文，地址为https://www.nature.com/articles/s41586-019-1724-z.pdf」
+    - 「生成一张图片，图中鲜花怒放，绿草如茵，用插件实现。」
+    - 「用插件翻译README，Github网址是https://github.com/facebookresearch/co-tracker」
+    - 「给爷翻译Arxiv论文，arxiv论文的ID是1812.10695，记得用插件，不要自己瞎搞！」
+    - 「我不喜欢当前的界面颜色，修改配置，把主题THEME更换为THEME="High-Contrast"。」
+    - 「请问Transformer网络的结构是怎样的？」
+
+2. 您可以打开插件下拉菜单以了解本项目的各种能力。    
+
+3. 如果您使用「调用插件xxx」、「修改配置xxx」、「请问」等关键词，您的意图可以被识别的更准确。
+
+4. 建议使用 GPT3.5 或更强的模型，弱模型可能无法理解您的想法。该插件诞生时间不长，欢迎您前往Github反馈问题。
+
+5. 现在，如果需要处理文件，请您上传文件（将文件拖动到文件上传区），或者描述文件所在的路径。
+
+6. 如果不需要上传文件，现在您只需要再次重复一次您的指令即可。
+"""
+
+from pydantic import BaseModel, Field
+from typing import List
+from toolbox import CatchException, update_ui, gen_time_str
+from toolbox import update_ui_lastest_msg, disable_auto_promotion
+from request_llm.bridge_all import predict_no_ui_long_connection
+from crazy_functions.crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
+from crazy_functions.crazy_utils import input_clipping
+from crazy_functions.json_fns.pydantic_io import GptJsonIO, JsonStringError
+from crazy_functions.vt_fns.vt_state import VoidTerminalState
+from crazy_functions.vt_fns.vt_modify_config import modify_configuration_hot
+from crazy_functions.vt_fns.vt_modify_config import modify_configuration_reboot
+from crazy_functions.vt_fns.vt_call_plugin import execute_plugin
+
+class UserIntention(BaseModel):
+    user_prompt: str = Field(description="the content of user input", default="")
+    intention_type: str = Field(description="the type of user intention, choose from ['ModifyConfiguration', 'ExecutePlugin', 'Chat']", default="ExecutePlugin")
+    user_provide_file: bool = Field(description="whether the user provides a path to a file", default=False)
+    user_provide_url: bool = Field(description="whether the user provides a url", default=False)
+
+
+def chat(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_intention):
+    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+        inputs=txt, inputs_show_user=txt,
+        llm_kwargs=llm_kwargs, chatbot=chatbot, history=[], 
+        sys_prompt=system_prompt
+    )
+    chatbot[-1] = [txt, gpt_say]
+    history.extend([txt, gpt_say])
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+    pass
+
+
+explain_intention_to_user = {
+    'Chat': "聊天对话",
+    'ExecutePlugin': "调用插件",
+    'ModifyConfiguration': "修改配置",
+}
+
+
+def analyze_intention_with_simple_rules(txt):
+    user_intention = UserIntention()
+    user_intention.user_prompt = txt
+    is_certain = False
+
+    if '请问' in txt:
+        is_certain = True
+        user_intention.intention_type = 'Chat'
+
+    if '用插件' in txt:
+        is_certain = True
+        user_intention.intention_type = 'ExecutePlugin'
+
+    if '修改配置' in txt:
+        is_certain = True
+        user_intention.intention_type = 'ModifyConfiguration'
+
+    return is_certain, user_intention
 
-def get_code_block(reply):
-    import re
-    pattern = r"```([\s\S]*?)```" # regex pattern to match code blocks
-    matches = re.findall(pattern, reply) # find all code blocks in text
-    if len(matches) != 1: 
-        raise RuntimeError("GPT is not generating proper code.")
-    return matches[0].strip('python') #  code block
 
 @CatchException
-def 终端(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 = []    
+def 虚空终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    disable_auto_promotion(chatbot=chatbot)
+    # 获取当前虚空终端状态
+    state = VoidTerminalState.get_state(chatbot)
+    appendix_msg = ""
 
-    # 基本信息：功能、贡献者
-    chatbot.append(["函数插件功能？", "根据自然语言执行插件命令, 作者: binary-husky, 插件初始化中 ..."])
+    # 用简单的关键词检测用户意图
+    is_certain, _ = analyze_intention_with_simple_rules(txt)
+    if txt.startswith('private_upload/') and len(txt) == 34:
+        state.set_state(chatbot=chatbot, key='has_provided_explaination', value=False)
+        appendix_msg = "\n\n**很好，您已经上传了文件**，现在请您描述您的需求。"
+        
+    if is_certain or (state.has_provided_explaination):
+        # 如果意图明确，跳过提示环节
+        state.set_state(chatbot=chatbot, key='has_provided_explaination', value=True)
+        state.unlock_plugin(chatbot=chatbot)
+        yield from update_ui(chatbot=chatbot, history=history)
+        yield from 虚空终端主路由(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port)
+        return
+    else:
+        # 如果意图模糊，提示
+        state.set_state(chatbot=chatbot, key='has_provided_explaination', value=True)
+        state.lock_plugin(chatbot=chatbot)
+        chatbot.append(("虚空终端状态:", explain_msg+appendix_msg))
+        yield from update_ui(chatbot=chatbot, history=history)
+        return
+
+
+
+def 虚空终端主路由(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    history = []
+    chatbot.append(("虚空终端状态: ", f"正在执行任务: {txt}"))
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
 
-    # # 尝试导入依赖, 如果缺少依赖, 则给出安装建议
-    # dep_ok = yield from inspect_dependency(chatbot=chatbot, history=history) # 刷新界面
-    # if not dep_ok: return
-    
-    # 输入
-    i_say = prompt + txt
-    # 开始
-    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
-        inputs=i_say, inputs_show_user=txt, 
-        llm_kwargs=llm_kwargs, chatbot=chatbot, history=[], 
-        sys_prompt=""
-    )
+    # ⭐ ⭐ ⭐ 分析用户意图
+    is_certain, user_intention = analyze_intention_with_simple_rules(txt)
+    if not is_certain:
+        yield from update_ui_lastest_msg(
+            lastmsg=f"正在执行任务: {txt}\n\n分析用户意图中", chatbot=chatbot, history=history, delay=0)
+        gpt_json_io = GptJsonIO(UserIntention)
+        rf_req = "\nchoose from ['ModifyConfiguration', 'ExecutePlugin', 'Chat']"
+        inputs = "Analyze the intention of the user according to following user input: \n\n" + \
+            ">> " + (txt+rf_req).rstrip('\n').replace('\n','\n>> ') + '\n\n' + gpt_json_io.format_instructions
+        run_gpt_fn = lambda inputs, sys_prompt: predict_no_ui_long_connection(
+            inputs=inputs, llm_kwargs=llm_kwargs, history=[], sys_prompt=sys_prompt, observe_window=[])
+        analyze_res = run_gpt_fn(inputs, "")
+        try:
+            user_intention = gpt_json_io.generate_output_auto_repair(analyze_res, run_gpt_fn)
+            lastmsg=f"正在执行任务: {txt}\n\n用户意图理解: 意图={explain_intention_to_user[user_intention.intention_type]}", 
+        except JsonStringError as e:
+            yield from update_ui_lastest_msg(
+                lastmsg=f"正在执行任务: {txt}\n\n用户意图理解: 失败 当前语言模型（{llm_kwargs['llm_model']}）不能理解您的意图", chatbot=chatbot, history=history, delay=0)
+            return
+    else:
+        pass
+
+    yield from update_ui_lastest_msg(
+        lastmsg=f"正在执行任务: {txt}\n\n用户意图理解: 意图={explain_intention_to_user[user_intention.intention_type]}", 
+        chatbot=chatbot, history=history, delay=0)
+
+    # 用户意图: 修改本项目的配置
+    if user_intention.intention_type == 'ModifyConfiguration':
+        yield from modify_configuration_reboot(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_intention)
+
+    # 用户意图: 调度插件
+    if user_intention.intention_type == 'ExecutePlugin':
+        yield from execute_plugin(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_intention)
+
+    # 用户意图: 聊天
+    if user_intention.intention_type == 'Chat':
+        yield from chat(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_intention)
+
+    return
 
-    # 将代码转为动画
-    code = get_code_block(gpt_say)
-    yield from eval_code(code, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port)

crazy_functions/询问多个大语言模型.py

@@ -42,12 +42,14 @@ def 同时问询_指定模型(txt, llm_kwargs, plugin_kwargs, chatbot, history,
     web_port        当前软件运行的端口号
     """
     history = []    # 清空历史，以免输入溢出
-    chatbot.append((txt, "正在同时咨询ChatGPT和ChatGLM……"))
-    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
 
     if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
     # llm_kwargs['llm_model'] = 'chatglm&gpt-3.5-turbo&api2d-gpt-3.5-turbo' # 支持任意数量的llm接口，用&符号分隔
     llm_kwargs['llm_model'] = plugin_kwargs.get("advanced_arg", 'chatglm&gpt-3.5-turbo') # 'chatglm&gpt-3.5-turbo' # 支持任意数量的llm接口，用&符号分隔
+
+    chatbot.append((txt, f"正在同时咨询{llm_kwargs['llm_model']}"))
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
+
     gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
         inputs=txt, inputs_show_user=txt, 
         llm_kwargs=llm_kwargs, chatbot=chatbot, history=history, 

crazy_functions/语音助手.py

@@ -97,7 +97,7 @@ class InterviewAssistant(AliyunASR):
         # 初始化音频采集线程
         self.captured_audio = np.array([])
         self.keep_latest_n_second = 10
-        self.commit_after_pause_n_second = 1.5
+        self.commit_after_pause_n_second = 2.0
         self.ready_audio_flagment = None
         self.stop = False
         self.plugin_wd = WatchDog(timeout=5, bark_fn=self.__del__, msg="程序终止")
@@ -179,12 +179,12 @@ def 语音助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
         import nls
         from scipy import io
     except:
-        chatbot.append(["导入依赖失败", "使用该模块需要额外依赖, 安装方法:```pip install --upgrade pyOpenSSL scipy git+https://github.com/aliyun/alibabacloud-nls-python-sdk.git```"])
+        chatbot.append(["导入依赖失败", "使用该模块需要额外依赖, 安装方法:```pip install --upgrade aliyun-python-sdk-core==2.13.3 pyOpenSSL scipy git+https://github.com/aliyun/alibabacloud-nls-python-sdk.git```"])
         yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
         return
 
-    TOKEN, APPKEY = get_conf('ALIYUN_TOKEN', 'ALIYUN_APPKEY')
-    if TOKEN == "" or APPKEY == "":
+    APPKEY = get_conf('ALIYUN_APPKEY')
+    if APPKEY == "":
         chatbot.append(["导入依赖失败", "没有阿里云语音识别APPKEY和TOKEN, 详情见https://help.aliyun.com/document_detail/450255.html"])
         yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
         return

crazy_functions/辅助功能.py

@@ -3,7 +3,7 @@
 # @Author : Spike
 # @Descr   :
 from toolbox import update_ui
-from toolbox import CatchException, report_execption, write_results_to_file
+from toolbox import CatchException, report_execption, write_results_to_file, get_log_folder
 from crazy_functions.crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
 
 
@@ -25,4 +25,19 @@ def 猜你想问(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
     )
     chatbot[-1] = (show_say, gpt_say)
     history.extend([show_say, gpt_say])
+    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+
+
+@CatchException
+def 清除缓存(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    chatbot.append(['清除本地缓存数据', '执行中. 删除 gpt_log & private_upload'])
+    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+
+    import shutil, os
+    gpt_log_dir = os.path.join(os.path.dirname(__file__), '..', 'gpt_log')
+    private_upload_dir = os.path.join(os.path.dirname(__file__), '..', 'private_upload')
+    shutil.rmtree(gpt_log_dir, ignore_errors=True)
+    shutil.rmtree(private_upload_dir, ignore_errors=True)
+
+    chatbot.append(['清除本地缓存数据', '执行完成'])
     yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面

docker-compose.yml

@@ -16,6 +16,7 @@ services:
       AVAIL_LLM_MODELS:         '    ["gpt-3.5-turbo", "api2d-gpt-3.5-turbo", "gpt-4", "api2d-gpt-4", "newbing"]                    '
       WEB_PORT:                 '    22303                                                                                          '
       ADD_WAIFU:                '    True                                                                                           '
+      # THEME:                    '    Chuanhu-Small-and-Beautiful                                                                    '
       # DEFAULT_WORKER_NUM:       '    10                                                                                             '
       # AUTHENTICATION:           '    [("username", "passwd"), ("username2", "passwd2")]                                             '
 
@@ -28,7 +29,7 @@ services:
 
 
 ### ===================================================
-### 【方案二】 如果需要运行ChatGLM本地模型
+### 【方案二】 如果需要运行ChatGLM + Qwen + MOSS等本地模型
 ### ===================================================
 version: '3'
 services:
@@ -36,11 +37,11 @@ services:
     image: ghcr.io/binary-husky/gpt_academic_chatglm_moss:master  # (Auto Built by Dockerfile: docs/Dockerfile+ChatGLM)
     environment:
       # 请查阅 `config.py` 以查看所有的配置信息
-      API_KEY:                  '    sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,fkxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  '
+      API_KEY:                  '    sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx                                            '
       USE_PROXY:                '    True                                                                                           '
       proxies:                  '    { "http": "socks5h://localhost:10880", "https": "socks5h://localhost:10880", }                 '
       LLM_MODEL:                '    gpt-3.5-turbo                                                                                  '
-      AVAIL_LLM_MODELS:         '    ["chatglm", "moss", "gpt-3.5-turbo", "gpt-4", "newbing"]                                       '
+      AVAIL_LLM_MODELS:         '    ["chatglm", "qwen", "moss", "gpt-3.5-turbo", "gpt-4", "newbing"]                               '
       LOCAL_MODEL_DEVICE:       '    cuda                                                                                           '
       DEFAULT_WORKER_NUM:       '    10                                                                                             '
       WEB_PORT:                 '    12303                                                                                          '
@@ -57,6 +58,10 @@ services:
     command: >
       bash -c "python3 -u main.py"
 
+    # P.S. 通过对 command 进行微调，可以便捷地安装额外的依赖
+    # command: >
+    #   bash -c "pip install -r request_llm/requirements_qwen.txt && python3 -u main.py"
+
 ### ===================================================
 ### 【方案三】 如果需要运行ChatGPT + LLAMA + 盘古 + RWKV本地模型
 ### ===================================================
@@ -115,3 +120,36 @@ services:
     command: >
       bash -c "python3 -u main.py"
 
+
+## ===================================================
+## 【方案五】 ChatGPT + 语音助手 （请先阅读 docs/use_audio.md）
+## ===================================================
+version: '3'
+services:
+  gpt_academic_with_audio:
+    image: ghcr.io/binary-husky/gpt_academic_audio_assistant:master
+    environment:
+      # 请查阅 `config.py` 以查看所有的配置信息
+      API_KEY:                  '    fk195831-IdP0Pb3W6DCMUIbQwVX6MsSiyxwqybyS                        '
+      USE_PROXY:                '    False                                                            '
+      proxies:                  '    None                                                             '
+      LLM_MODEL:                '    gpt-3.5-turbo                                                    '
+      AVAIL_LLM_MODELS:         '    ["gpt-3.5-turbo", "gpt-4"]                                       '
+      ENABLE_AUDIO:             '    True                                                             '
+      LOCAL_MODEL_DEVICE:       '    cuda                                                             '
+      DEFAULT_WORKER_NUM:       '    20                                                               '
+      WEB_PORT:                 '    12343                                                            '
+      ADD_WAIFU:                '    True                                                             '
+      THEME:                    '    Chuanhu-Small-and-Beautiful                                      '
+      ALIYUN_APPKEY:            '    RoP1ZrM84DnAFkZK                                                 '
+      ALIYUN_TOKEN:             '    f37f30e0f9934c34a992f6f64f7eba4f                                 '
+      # (无需填写) ALIYUN_ACCESSKEY:         '    LTAI5q6BrFUzoRXVGUWnekh1                                         '
+      # (无需填写) ALIYUN_SECRET:            '    eHmI20AVWIaQZ0CiTD2bGQVsaP9i68                                   '
+
+    # 与宿主的网络融合
+    network_mode: "host"
+
+    # 不使用代理网络拉取最新代码
+    command: >
+      bash -c "python3 -u main.py"
+

docs/Dockerfile+ChatGLM

@@ -26,8 +26,8 @@ RUN curl -sS https://bootstrap.pypa.io/get-pip.py | python3.8
 RUN $useProxyNetwork python3 -m pip install torch --extra-index-url https://download.pytorch.org/whl/cu113
 # 下载分支
 WORKDIR /gpt
-RUN $useProxyNetwork git clone https://github.com/binary-husky/chatgpt_academic.git
-WORKDIR /gpt/chatgpt_academic
+RUN $useProxyNetwork git clone https://github.com/binary-husky/gpt_academic.git
+WORKDIR /gpt/gpt_academic
 RUN $useProxyNetwork python3 -m pip install -r requirements.txt
 RUN $useProxyNetwork python3 -m pip install -r request_llm/requirements_chatglm.txt
 RUN $useProxyNetwork python3 -m pip install -r request_llm/requirements_newbing.txt

docs/Dockerfile+JittorLLM

@@ -26,8 +26,8 @@ RUN curl -sS https://bootstrap.pypa.io/get-pip.py | python3.8
 RUN $useProxyNetwork python3 -m pip install torch --extra-index-url https://download.pytorch.org/whl/cu113
 # 下载分支
 WORKDIR /gpt
-RUN $useProxyNetwork git clone https://github.com/binary-husky/chatgpt_academic.git
-WORKDIR /gpt/chatgpt_academic
+RUN $useProxyNetwork git clone https://github.com/binary-husky/gpt_academic.git
+WORKDIR /gpt/gpt_academic
 RUN $useProxyNetwork python3 -m pip install -r requirements.txt
 RUN $useProxyNetwork python3 -m pip install -r request_llm/requirements_chatglm.txt
 RUN $useProxyNetwork python3 -m pip install -r request_llm/requirements_newbing.txt

docs/GithubAction+ChatGLM+Moss

@@ -13,11 +13,12 @@ RUN curl -sS https://bootstrap.pypa.io/get-pip.py | python3.8
 RUN python3 -m pip install torch --extra-index-url https://download.pytorch.org/whl/cu113
 # 下载分支
 WORKDIR /gpt
-RUN git clone https://github.com/binary-husky/chatgpt_academic.git
-WORKDIR /gpt/chatgpt_academic
+RUN git clone --depth=1 https://github.com/binary-husky/gpt_academic.git
+WORKDIR /gpt/gpt_academic
 RUN git clone https://github.com/OpenLMLab/MOSS.git request_llm/moss
 RUN python3 -m pip install -r requirements.txt
 RUN python3 -m pip install -r request_llm/requirements_moss.txt
+RUN python3 -m pip install -r request_llm/requirements_qwen.txt
 RUN python3 -m pip install -r request_llm/requirements_chatglm.txt
 RUN python3 -m pip install -r request_llm/requirements_newbing.txt
 

docs/GithubAction+JittorLLMs

@@ -13,8 +13,8 @@ RUN python3 -m pip install torch --extra-index-url https://download.pytorch.org/
 
 # 下载分支
 WORKDIR /gpt
-RUN git clone https://github.com/binary-husky/chatgpt_academic.git
-WORKDIR /gpt/chatgpt_academic
+RUN git clone --depth=1 https://github.com/binary-husky/gpt_academic.git
+WORKDIR /gpt/gpt_academic
 RUN python3 -m pip install -r requirements.txt
 RUN python3 -m pip install -r request_llm/requirements_chatglm.txt
 RUN python3 -m pip install -r request_llm/requirements_newbing.txt

docs/GithubAction+NoLocal+AudioAssistant

@@ -0,0 +1,22 @@
+# 此Dockerfile适用于“无本地模型”的环境构建，如果需要使用chatglm等本地模型，请参考 docs/Dockerfile+ChatGLM
+# 如何构建: 先修改 `config.py`， 然后 docker build -t gpt-academic-nolocal -f docs/Dockerfile+NoLocal .
+# 如何运行: docker run --rm -it --net=host gpt-academic-nolocal
+FROM python:3.11
+
+# 指定路径
+WORKDIR /gpt
+
+# 装载项目文件
+COPY . .
+
+# 安装依赖
+RUN pip3 install -r requirements.txt
+
+# 安装语音插件的额外依赖
+RUN pip3 install pyOpenSSL scipy git+https://github.com/aliyun/alibabacloud-nls-python-sdk.git
+
+# 可选步骤，用于预热模块
+RUN python3  -c 'from check_proxy import warm_up_modules; warm_up_modules()'
+
+# 启动
+CMD ["python3", "-u", "main.py"]

docs/README.md.German.md

@@ -15,7 +15,7 @@ Um dieses Projekt in eine beliebige Sprache mit GPT zu übersetzen, lesen Sie `m
 >
 > 1. Beachten Sie bitte, dass nur Funktionserweiterungen (Schaltflächen) mit **roter Farbe** Dateien lesen können und einige Erweiterungen im **Dropdown-Menü** des Erweiterungsbereichs zu finden sind. Außerdem begrüßen wir jede neue Funktionserweiterung mit **höchster Priorität** und bearbeiten sie.
 >
-> 2. Die Funktionalität jeder Datei in diesem Projekt wird in der Selbstanalyse [`self_analysis.md`](https://github.com/binary-husky/chatgpt_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) detailliert beschrieben. Mit der Weiterentwicklung der Versionen können Sie jederzeit die zugehörigen Funktions-Erweiterungen aufrufen, um durch Aufruf von GPT einen Selbstanalysebericht des Projekts zu erstellen. Häufig gestellte Fragen finden Sie in der [`Wiki`](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Installationsanweisungen](#Installation).
+> 2. Die Funktionalität jeder Datei in diesem Projekt wird in der Selbstanalyse [`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) detailliert beschrieben. Mit der Weiterentwicklung der Versionen können Sie jederzeit die zugehörigen Funktions-Erweiterungen aufrufen, um durch Aufruf von GPT einen Selbstanalysebericht des Projekts zu erstellen. Häufig gestellte Fragen finden Sie in der [`Wiki`](https://github.com/binary-husky/gpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Installationsanweisungen](#Installation).
 >
 > 3. Dieses Projekt ist kompatibel und fördert die Verwendung von inländischen Sprachmodellen wie ChatGLM und RWKV, Pangu, etc. Es unterstützt das Vorhandensein mehrerer api-keys, die in der Konfigurationsdatei wie folgt angegeben werden können: `API_KEY="openai-key1,openai-key2,api2d-key3"`. Wenn ein `API_KEY` temporär geändert werden muss, geben Sie den temporären `API_KEY` im Eingabebereich ein und drücken Sie dann die Eingabetaste, um ihn zu übernehmen.Funktion | Beschreibung
 --- | ---
@@ -23,13 +23,13 @@ Ein-Klick-Polieren | Unterstützt ein-Klick-Polieren und ein-Klick-Suche nach gr
 Ein-Klick Chinesisch-Englisch Übersetzung | Ein-Klick Chinesisch-Englisch Übersetzung
 Ein-Klick-Code-Erklärung | Zeigt Code, erklärt Code, erzeugt Code und fügt Kommentare zum Code hinzu
 [Benutzerdefinierte Tastenkombinationen](https://www.bilibili.com/video/BV14s4y1E7jN) | Unterstützt benutzerdefinierte Tastenkombinationen
-Modulare Gestaltung | Unterstützt leistungsstarke individuelle [Funktions-Plugins](https://github.com/binary-husky/chatgpt_academic/tree/master/crazy_functions). Plugins unterstützen [Hot-Updates](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97)
-[Selbstprogramm-Analyse](https://www.bilibili.com/video/BV1cj411A7VW) | [Funktions-Plugin] [Ein-Klick Verstehen](https://github.com/binary-husky/chatgpt_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) der Quellcode dieses Projekts
+Modulare Gestaltung | Unterstützt leistungsstarke individuelle [Funktions-Plugins](https://github.com/binary-husky/gpt_academic/tree/master/crazy_functions). Plugins unterstützen [Hot-Updates](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)
+[Selbstprogramm-Analyse](https://www.bilibili.com/video/BV1cj411A7VW) | [Funktions-Plugin] [Ein-Klick Verstehen](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) der Quellcode dieses Projekts
 [Programmanalyse](https://www.bilibili.com/video/BV1cj411A7VW) | [Funktions-Plugin] Ein-Klick-Analyse des Projektbaums anderer Python/C/C++/Java/Lua/...-Projekte
 Lesen von Papieren, [Übersetzen](https://www.bilibili.com/video/BV1KT411x7Wn) von Papieren | [Funktions-Plugin] Ein-Klick Erklärung des gesamten LaTeX/PDF-Artikels und Erstellung einer Zusammenfassung
 LaTeX-Volltext-Übersetzung und [Polieren](https://www.bilibili.com/video/BV1FT411H7c5/) | [Funktions-Plugin] Ein-Klick-Übersetzung oder-Polieren des LaTeX-Artikels
 Bulk-Kommentargenerierung | [Funktions-Plugin] Ein-Klick Massenerstellung von Funktionskommentaren
-Markdown [Chinesisch-Englisch Übersetzung](https://www.bilibili.com/video/BV1yo4y157jV/) | [Funktions-Plugin] Haben Sie die [README](https://github.com/binary-husky/chatgpt_academic/blob/master/docs/README_EN.md) in den oben genannten 5 Sprachen gesehen?
+Markdown [Chinesisch-Englisch Übersetzung](https://www.bilibili.com/video/BV1yo4y157jV/) | [Funktions-Plugin] Haben Sie die [README](https://github.com/binary-husky/gpt_academic/blob/master/docs/README_EN.md) in den oben genannten 5 Sprachen gesehen?
 Analyse-Berichtserstellung von chat | [Funktions-Plugin] Automatische Zusammenfassung nach der Ausführung
 [Funktion zur vollständigen Übersetzung von PDF-Artikeln](https://www.bilibili.com/video/BV1KT411x7Wn) | [Funktions-Plugin] Extrahiert Titel und Zusammenfassung der PDF-Artikel und übersetzt den gesamten Text (mehrere Threads)
 [Arxiv-Assistent](https://www.bilibili.com/video/BV1LM4y1279X) | [Funktions-Plugin] Geben Sie die Arxiv-Artikel-URL ein und klicken Sie auf Eine-Klick-Übersetzung-Zusammenfassung + PDF-Download
@@ -37,7 +37,7 @@ Analyse-Berichtserstellung von chat | [Funktions-Plugin] Automatische Zusammenfa
 Internet-Informationen Aggregation + GPT | [Funktions-Plugin] Lassen Sie GPT eine Frage beantworten, indem es [zuerst Informationen aus dem Internet](https://www.bilibili.com/video/BV1om4y127ck/) sammelt und so die Informationen nie veralten
 Anzeige von Formeln / Bildern / Tabellen | Zeigt Formeln in beiden Formen, [TeX-Format und gerendeter Form](https://user-images.githubusercontent.com/96192199/230598842-1d7fcddd-815d-40ee-af60-baf488a199df.png), unterstützt Formeln und Code-Highlights
 Unterstützung von PlugIns mit mehreren Threads | Unterstützt den Aufruf mehrerer Threads in Chatgpt, um Text oder Programme [Batch zu verarbeiten](https://www.bilibili.com/video/BV1FT411H7c5/)
-Starten Sie das dunkle Gradio-[Thema](https://github.com/binary-husky/chatgpt_academic/issues/173) | Fügen Sie ```/?__theme=dark``` an das Ende der Browser-URL an, um das dunkle Thema zu aktivieren
+Starten Sie das dunkle Gradio-[Thema](https://github.com/binary-husky/gpt_academic/issues/173) | Fügen Sie ```/?__theme=dark``` an das Ende der Browser-URL an, um das dunkle Thema zu aktivieren
 [Unterstützung für mehrere LLM-Modelle](https://www.bilibili.com/video/BV1wT411p7yf), [API2D](https://api2d.com/) Interface-Unterstützung | Das Gefühl, gleichzeitig von GPT3.5, GPT4, [Tshinghua ChatGLM](https://github.com/THUDM/ChatGLM-6B), [Fudan MOSS](https://github.com/OpenLMLab/MOSS) bedient zu werden, muss toll sein, oder?
 Zugriff auf weitere LLM-Modelle, Unterstützung von [huggingface deployment](https://huggingface.co/spaces/qingxu98/gpt-academic) | Hinzufügen der Newbing-Schnittstelle (neues Bing), Einführung der Unterstützung von [Jittorllms](https://github.com/Jittor/JittorLLMs) der Tsinghua-Universität, [LLaMA](https://github.com/facebookresearch/llama), [RWKV](https://github.com/BlinkDL/ChatRWKV) und [Pangu alpha](https://openi.org.cn/pangu/)
 Weitere neue Funktionen (wie Bildgenerierung) …… | Siehe Ende dieses Dokuments ……
@@ -76,8 +76,8 @@ Weitere neue Funktionen (wie Bildgenerierung) …… | Siehe Ende dieses Dokumen
 
 1. Download the project
 ```sh
-git clone https://github.com/binary-husky/chatgpt_academic.git
-cd chatgpt_academic
+git clone https://github.com/binary-husky/gpt_academic.git
+cd gpt_academic
 ```
 
 2. Configure API_KEY
@@ -133,8 +133,8 @@ python main.py
 1. Only ChatGPT (Recommended for most people)
 
 ``` sh
-git clone https://github.com/binary-husky/chatgpt_academic.git  # Download the project
-cd chatgpt_academic                                 # Enter the path
+git clone https://github.com/binary-husky/gpt_academic.git  # Download the project
+cd gpt_academic                                 # Enter the path
 nano config.py                                      # Edit config.py with any text editor, Configure "Proxy","API_KEY"and"WEB_PORT" (e.g 50923) etc.
 docker build -t gpt-academic .                      # Install
 
@@ -164,10 +164,10 @@ docker-compose up
 Configure API_URL_REDIRECT according to the instructions in `config.py`.
 
 2. Remote cloud server deployment (requires cloud server knowledge and experience)
-Please visit [Deployment wiki-1](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
+Please visit [Deployment wiki-1](https://github.com/binary-husky/gpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
 
 3. Using WSL 2 (Windows subsystem for Linux)
-Please visit [Deployment wiki-2](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
+Please visit [Deployment wiki-2](https://github.com/binary-husky/gpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
 
 4. How to run at a secondary URL (such as `http://localhost/subpath`)
 Please visit [FastAPI operating instructions](docs/WithFastapi.md)
@@ -199,7 +199,7 @@ For example
 
 Write powerful function plugins to perform any task you want and can't think of.
 The difficulty of plugin writing and debugging is very low in this project. As long as you have a certain knowledge of Python, you can implement your own plugin functions by imitating the template we provided.
-For more information, please refer to the [Function Plugin Guide](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97).
+For more information, please refer to the [Function Plugin Guide](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

docs/README.md.Italian.md

@@ -13,7 +13,7 @@ Per tradurre questo progetto in qualsiasi lingua con GPT, leggere e eseguire [`m
 >
 > 1. Si prega di notare che solo i plugin (pulsanti) contrassegnati in **rosso** supportano la lettura di file, alcuni plugin sono posizionati nel **menu a discesa** nella zona dei plugin. Accettiamo e gestiamo PR per qualsiasi nuovo plugin con **massima priorità**!
 >
-> 2. Le funzionalità di ogni file di questo progetto sono descritte dettagliatamente nella propria analisi di autotraduzione [`self_analysis.md`](https://github.com/binary-husky/chatgpt_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). Con l'iterazione delle versioni, è possibile fare clic sui plugin funzionali correlati in qualsiasi momento per richiamare GPT e generare nuovamente il rapporto di analisi automatica del progetto. Le domande frequenti sono riassunte nella [`wiki`](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Metodo di installazione] (#installazione).
+> 2. Le funzionalità di ogni file di questo progetto sono descritte dettagliatamente nella propria analisi di autotraduzione [`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). Con l'iterazione delle versioni, è possibile fare clic sui plugin funzionali correlati in qualsiasi momento per richiamare GPT e generare nuovamente il rapporto di analisi automatica del progetto. Le domande frequenti sono riassunte nella [`wiki`](https://github.com/binary-husky/gpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Metodo di installazione] (#installazione).
 >
 > 3. Questo progetto è compatibile e incoraggia l'utilizzo di grandi modelli di linguaggio di produzione nazionale come chatglm, RWKV, Pangu ecc. Supporta la coesistenza di più api-key e può essere compilato nel file di configurazione come `API_KEY="openai-key1,openai-key2,api2d-key3"`. Per sostituire temporaneamente `API_KEY`, inserire `API_KEY` temporaneo nell'area di input e premere Invio per renderlo effettivo. 
 
@@ -25,13 +25,13 @@ Correzione immediata | Supporta correzione immediata e ricerca degli errori di g
 Traduzione cinese-inglese immediata | Traduzione cinese-inglese immediata con un solo clic
 Spiegazione del codice immediata | Visualizzazione del codice, spiegazione del codice, generazione del codice, annotazione del codice con un solo clic
 [Scorciatoie personalizzate](https://www.bilibili.com/video/BV14s4y1E7jN) | Supporta scorciatoie personalizzate
-Design modularizzato | Supporta potenti [plugin di funzioni](https://github.com/binary-husky/chatgpt_academic/tree/master/crazy_functions) personalizzati, i plugin supportano l'[aggiornamento in tempo reale](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97)
-[Auto-profiling del programma](https://www.bilibili.com/video/BV1cj411A7VW) | [Plugin di funzioni] [Comprensione immediata](https://github.com/binary-husky/chatgpt_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) del codice sorgente di questo progetto
+Design modularizzato | Supporta potenti [plugin di funzioni](https://github.com/binary-husky/gpt_academic/tree/master/crazy_functions) personalizzati, i plugin supportano l'[aggiornamento in tempo reale](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)
+[Auto-profiling del programma](https://www.bilibili.com/video/BV1cj411A7VW) | [Plugin di funzioni] [Comprensione immediata](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) del codice sorgente di questo progetto
 [Analisi del programma](https://www.bilibili.com/video/BV1cj411A7VW) | [Plugin di funzioni] Un clic può analizzare l'albero di altri progetti Python/C/C++/Java/Lua/...
 Lettura del documento, [traduzione](https://www.bilibili.com/video/BV1KT411x7Wn) del documento | [Plugin di funzioni] La lettura immediata dell'intero documento latex/pdf di un documento e la generazione di un riassunto
 Traduzione completa di un documento Latex, [correzione immediata](https://www.bilibili.com/video/BV1FT411H7c5/) | [Plugin di funzioni] Una traduzione o correzione immediata di un documento Latex
 Generazione di annotazioni in batch | [Plugin di funzioni] Generazione automatica delle annotazioni di funzione con un solo clic
-[Traduzione cinese-inglese di Markdown](https://www.bilibili.com/video/BV1yo4y157jV/) | [Plugin di funzioni] Hai letto il [README](https://github.com/binary-husky/chatgpt_academic/blob/master/docs/README_EN.md) delle cinque lingue sopra?
+[Traduzione cinese-inglese di Markdown](https://www.bilibili.com/video/BV1yo4y157jV/) | [Plugin di funzioni] Hai letto il [README](https://github.com/binary-husky/gpt_academic/blob/master/docs/README_EN.md) delle cinque lingue sopra?
 Generazione di report di analisi di chat | [Plugin di funzioni] Generazione automatica di un rapporto di sintesi dopo l'esecuzione
 [Funzione di traduzione di tutto il documento PDF](https://www.bilibili.com/video/BV1KT411x7Wn) | [Plugin di funzioni] Estrarre il titolo e il sommario dell'articolo PDF + tradurre l'intero testo (multithreading)
 [Assistente di Arxiv](https://www.bilibili.com/video/BV1LM4y1279X) | [Plugin di funzioni] Inserire l'URL dell'articolo di Arxiv e tradurre il sommario con un clic + scaricare il PDF
@@ -39,7 +39,7 @@ Generazione di report di analisi di chat | [Plugin di funzioni] Generazione auto
 Aggregazione delle informazioni su Internet + GPT | [Plugin di funzioni] Fai in modo che GPT rilevi le informazioni su Internet prima di rispondere alle domande, senza mai diventare obsolete
 Visualizzazione di formule/img/tabelle | È possibile visualizzare un'equazione in forma [tex e render](https://user-images.githubusercontent.com/96192199/230598842-1d7fcddd-815d-40ee-af60-baf488a199df.png) contemporaneamente, supporta equazioni e evidenziazione del codice
 Supporto per plugin di funzioni multithreading | Supporto per chiamata multithreaded di chatgpt, elaborazione con un clic di grandi quantità di testo o di un programma
-Avvia il tema di gradio [scuro](https://github.com/binary-husky/chatgpt_academic/issues/173) | Aggiungere ```/?__theme=dark``` dopo l'URL del browser per passare a un tema scuro
+Avvia il tema di gradio [scuro](https://github.com/binary-husky/gpt_academic/issues/173) | Aggiungere ```/?__theme=dark``` dopo l'URL del browser per passare a un tema scuro
 Supporto per maggiori modelli LLM, supporto API2D | Sentirsi serviti simultaneamente da GPT3.5, GPT4, [Tsinghua ChatGLM](https://github.com/THUDM/ChatGLM-6B), [Fudan MOSS](https://github.com/OpenLMLab/MOSS) deve essere una grande sensazione, giusto?
 Ulteriori modelli LLM supportat,i supporto per l'implementazione di Huggingface | Aggiunta di un'interfaccia Newbing (Nuovo Bing), introdotta la compatibilità con Tsinghua [Jittorllms](https://github.com/Jittor/JittorLLMs), [LLaMA](https://github.com/facebookresearch/llama), [RWKV](https://github.com/BlinkDL/ChatRWKV) e [PanGu-α](https://openi.org.cn/pangu/)
 Ulteriori dimostrazioni di nuove funzionalità (generazione di immagini, ecc.)... | Vedere la fine di questo documento...
@@ -82,8 +82,8 @@ Ulteriori dimostrazioni di nuove funzionalità (generazione di immagini, ecc.)..
 
 1. Scarica il progetto
 ```sh
-git clone https://github.com/binary-husky/chatgpt_academic.git
-cd chatgpt_academic
+git clone https://github.com/binary-husky/gpt_academic.git
+cd gpt_academic
 ```
 
 2. Configura API_KEY
@@ -139,8 +139,8 @@ python main.py
 1. Solo ChatGPT (consigliato per la maggior parte delle persone)
 
 ``` sh
-git clone https://github.com/binary-husky/chatgpt_academic.git  # scarica il progetto
-cd chatgpt_academic                                 # entra nel percorso
+git clone https://github.com/binary-husky/gpt_academic.git  # scarica il progetto
+cd gpt_academic                                 # entra nel percorso
 nano config.py                                      # con un qualsiasi editor di testo, modifica config.py configurando "Proxy", "API_KEY" e "WEB_PORT" (ad esempio 50923)
 docker build -t gpt-academic .                      # installa
 
@@ -171,10 +171,10 @@ docker-compose up
 Configura API_URL_REDIRECT seguendo le istruzioni nel file `config.py`.
 
 2. Distribuzione su un server cloud remoto (richiede conoscenze ed esperienza di server cloud)
-Si prega di visitare [wiki di distribuzione-1] (https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
+Si prega di visitare [wiki di distribuzione-1] (https://github.com/binary-husky/gpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
 
 3. Utilizzo di WSL2 (Windows Subsystem for Linux)
-Si prega di visitare [wiki di distribuzione-2] (https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
+Si prega di visitare [wiki di distribuzione-2] (https://github.com/binary-husky/gpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
 
 4. Come far funzionare ChatGPT all'interno di un sottodominio (ad es. `http://localhost/subpath`)
 Si prega di visitare [Istruzioni per l'esecuzione con FastAPI] (docs/WithFastapi.md)
@@ -206,7 +206,7 @@ ad esempio
 2. Plugin di funzione personalizzati
 
 Scrivi plugin di funzione personalizzati e esegui tutte le attività che desideri o non hai mai pensato di fare.
-La difficoltà di scrittura e debug dei plugin del nostro progetto è molto bassa. Se si dispone di una certa conoscenza di base di Python, è possibile realizzare la propria funzione del plugin seguendo il nostro modello. Per maggiori dettagli, consultare la [guida al plugin per funzioni](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97).
+La difficoltà di scrittura e debug dei plugin del nostro progetto è molto bassa. Se si dispone di una certa conoscenza di base di Python, è possibile realizzare la propria funzione del plugin seguendo il nostro modello. Per maggiori dettagli, consultare la [guida al plugin per funzioni](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).
 
 ---
 # Ultimo aggiornamento

docs/README.md.Korean.md

@@ -13,7 +13,7 @@ GPT를 이용하여 프로젝트를 임의의 언어로 번역하려면 [`multi_
 >
 > 1. 파일을 읽기 위해 **빨간색**으로 표시된 기능 플러그인 (버튼) 만 지원됩니다. 일부 플러그인은 플러그인 영역의 **드롭다운 메뉴**에 있습니다. 또한 새로운 플러그인은 **가장 높은 우선순위**로 환영하며 처리합니다!
 >
-> 2. 이 프로젝트의 각 파일의 기능을 [`self_analysis.md`](https://github.com/binary-husky/chatgpt_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를 호출하여 프로젝트의 자체 분석 보고서를 다시 생성할 수도 있습니다. 자주 묻는 질문은 [`위키`](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98)에서 볼 수 있습니다. [설치 방법](#installation).
+> 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를 호출하여 프로젝트의 자체 분석 보고서를 다시 생성할 수도 있습니다. 자주 묻는 질문은 [`위키`](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`를 입력 한 후 엔터 키를 누르면 즉시 적용됩니다. 
 
@@ -25,13 +25,13 @@ GPT를 이용하여 프로젝트를 임의의 언어로 번역하려면 [`multi_
 한-영 키워드 | 한-영 키워드 지원
 코드 설명 | 코드 표시, 코드 설명, 코드 생성, 코드에 주석 추가
 [사용자 정의 바로 가기 키](https://www.bilibili.com/video/BV14s4y1E7jN) | 사용자 정의 바로 가기 키 지원
-모듈식 설계 | 강력한[함수 플러그인](https://github.com/binary-husky/chatgpt_academic/tree/master/crazy_functions) 지원, 플러그인이 [램 업데이트](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97)를 지원합니다.
+모듈식 설계 | 강력한[함수 플러그인](https://github.com/binary-husky/gpt_academic/tree/master/crazy_functions) 지원, 플러그인이 [램 업데이트](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)를 지원합니다.
 [자체 프로그램 분석](https://www.bilibili.com/video/BV1cj411A7VW) | [함수 플러그인] [원 키 우드] 프로젝트 소스 코드의 내용을 이해하는 기능을 제공
 [프로그램 분석](https://www.bilibili.com/video/BV1cj411A7VW) | [함수 플러그인] 프로젝트 트리를 분석할 수 있습니다 (Python/C/C++/Java/Lua/...)
 논문 읽기, 번역 | [함수 플러그인] LaTex/PDF 논문의 전문을 읽고 요약을 생성합니다.
 LaTeX 텍스트[번역](https://www.bilibili.com/video/BV1nk4y1Y7Js/), [원 키워드](https://www.bilibili.com/video/BV1FT411H7c5/) | [함수 플러그인] LaTeX 논문의 번역 또는 개량을 위해 일련의 모드를 번역할 수 있습니다.
 대량의 주석 생성 | [함수 플러그인] 함수 코멘트를 대량으로 생성할 수 있습니다.
-Markdown 한-영 번역 | [함수 플러그인] 위의 5 종 언어의 [README](https://github.com/binary-husky/chatgpt_academic/blob/master/docs/README_EN.md)를 볼 수 있습니다.
+Markdown 한-영 번역 | [함수 플러그인] 위의 5 종 언어의 [README](https://github.com/binary-husky/gpt_academic/blob/master/docs/README_EN.md)를 볼 수 있습니다.
 chat 분석 보고서 생성 | [함수 플러그인] 수행 후 요약 보고서를 자동으로 생성합니다.
 [PDF 논문 번역](https://www.bilibili.com/video/BV1KT411x7Wn) | [함수 플러그인] PDF 논문이 제목 및 요약을 추출한 후 번역됩니다. (멀티 스레드)
 [Arxiv 도우미](https://www.bilibili.com/video/BV1LM4y1279X) | [함수 플러그인] Arxiv 논문 URL을 입력하면 요약을 번역하고 PDF를 다운로드 할 수 있습니다.
@@ -73,8 +73,8 @@ LLM 모델 추가 및[huggingface 배치](https://huggingface.co/spaces/qingxu98
 
 1. 프로젝트 다운로드
 ```sh
-git clone https://github.com/binary-husky/chatgpt_academic.git
-cd chatgpt_academic
+git clone https://github.com/binary-husky/gpt_academic.git
+cd gpt_academic
 ```
 
 2. API_KEY 구성
@@ -134,8 +134,8 @@ python main.py
 1. ChatGPT 만 (대부분의 사람들이 선택하는 것을 권장합니다.)
 
 ``` sh
-git clone https://github.com/binary-husky/chatgpt_academic.git  # 다운로드
-cd chatgpt_academic                                 # 경로 이동
+git clone https://github.com/binary-husky/gpt_academic.git  # 다운로드
+cd gpt_academic                                 # 경로 이동
 nano config.py                                      # 아무 텍스트 에디터로 config.py를 열고 "Proxy","API_KEY","WEB_PORT" (예 : 50923) 등을 구성합니다.
 docker build -t gpt-academic .                      # 설치
 
@@ -165,10 +165,10 @@ docker-compose up
 API_URL_REDIRECT를 `config.py`에 따라 구성하면됩니다.
 
 2. 원격 클라우드 서버 배치 (클라우드 서버 지식과 경험이 필요합니다.)
-[배치위키-1](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)에 방문하십시오.
+[배치위키-1](https://github.com/binary-husky/gpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)에 방문하십시오.
 
 3. WSL2 사용 (Windows Subsystem for Linux 하위 시스템)
-[배치 위키-2](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)에 방문하십시오.
+[배치 위키-2](https://github.com/binary-husky/gpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)에 방문하십시오.
 
 4. 2 차 URL (예 : `http : //localhost/subpath`)에서 실행하는 방법
 [FastAPI 실행 설명서] (docs / WithFastapi.md)를 참조하십시오.
@@ -197,7 +197,7 @@ docker-compose.yml을 읽은 후 지시 사항에 따라 작업하십시오.
 
 2. 사용자 지정 함수 플러그인
 강력한 함수 플러그인을 작성하여 원하는 작업을 수행하십시오.
-이 프로젝트의 플러그인 작성 및 디버깅 난이도는 매우 낮으며, 일부 파이썬 기본 지식만 있으면 제공된 템플릿을 모방하여 플러그인 기능을 구현할 수 있습니다. 자세한 내용은 [함수 플러그인 가이드]를 참조하십시오. (https://github.com/binary -husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E 4%BB%B6%E6%8C%87%E5%8D%97).
+이 프로젝트의 플러그인 작성 및 디버깅 난이도는 매우 낮으며, 일부 파이썬 기본 지식만 있으면 제공된 템플릿을 모방하여 플러그인 기능을 구현할 수 있습니다. 자세한 내용은 [함수 플러그인 가이드]를 참조하십시오. (https://github.com/binary -husky/gpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E 4%BB%B6%E6%8C%87%E5%8D%97).
 ---
 # 최신 업데이트
 ## 새로운 기능 동향1. 대화 저장 기능. 

docs/README.md.Portuguese.md

@@ -14,7 +14,7 @@ Para traduzir este projeto para qualquer idioma com o GPT, leia e execute [`mult
 >
 > 1. Por favor, preste atenção que somente os plugins de funções (botões) com a cor **vermelha** podem ler arquivos. Alguns plugins estão localizados no **menu suspenso** na área de plugins. Além disso, nós damos as boas-vindas com a **maior prioridade** e gerenciamos quaisquer novos plugins PR!
 >
-> 2. As funções de cada arquivo neste projeto são detalhadas em [`self_analysis.md`](https://github.com/binary-husky/chatgpt_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), auto-análises do projeto geradas pelo GPT também estão podem ser chamadas a qualquer momento ao clicar nos plugins relacionados. As perguntas frequentes estão resumidas no [`wiki`](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Instruções de Instalação](#installation).
+> 2. As funções de cada arquivo neste projeto são detalhadas em [`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), auto-análises do projeto geradas pelo GPT também estão podem ser chamadas a qualquer momento ao clicar nos plugins relacionados. As perguntas frequentes estão resumidas no [`wiki`](https://github.com/binary-husky/gpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Instruções de Instalação](#installation).
 >
 > 3. Este projeto é compatível com e incentiva o uso de modelos de linguagem nacionais, como chatglm e RWKV, Pangolin, etc. Suporta a coexistência de várias chaves de API e pode ser preenchido no arquivo de configuração como `API_KEY="openai-key1,openai-key2,api2d-key3"`. Quando precisar alterar temporariamente o `API_KEY`, basta digitar o `API_KEY` temporário na área de entrada e pressionar Enter para que ele entre em vigor. 
 
@@ -26,8 +26,8 @@ Um clique de polimento | Suporte a um clique polimento, um clique encontrar erro
 Tradução chinês-inglês de um clique | Tradução chinês-inglês de um clique
 Explicação de código de um único clique | Exibir código, explicar código, gerar código, adicionar comentários ao código
 [Teclas de atalho personalizadas](https://www.bilibili.com/video/BV14s4y1E7jN) | Suporte a atalhos personalizados
-Projeto modular | Suporte para poderosos plugins[de função personalizada](https://github.com/binary-husky/chatgpt_academic/tree/master/crazy_functions), os plugins suportam[hot-reload](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97)
-[Análise automática do programa](https://www.bilibili.com/video/BV1cj411A7VW) | [Plugin de função][um clique para entender](https://github.com/binary-husky/chatgpt_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) o código-fonte do projeto
+Projeto modular | Suporte para poderosos plugins[de função personalizada](https://github.com/binary-husky/gpt_academic/tree/master/crazy_functions), os plugins suportam[hot-reload](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)
+[Análise automática do programa](https://www.bilibili.com/video/BV1cj411A7VW) | [Plugin de função][um clique para entender](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) o código-fonte do projeto
 [Análise do programa](https://www.bilibili.com/video/BV1cj411A7VW) | [Plugin de função] Um clique pode analisar a árvore de projetos do Python/C/C++/Java/Lua/...
 Leitura de artigos, [tradução](https://www.bilibili.com/video/BV1KT411x7Wn) de artigos | [Plugin de função] um clique para interpretar o resumo de artigos LaTeX/PDF e gerar resumo
 Tradução completa LATEX, polimento|[Plugin de função] Uma clique para traduzir ou polir um artigo LATEX
@@ -91,8 +91,8 @@ Mais recursos novos mostrados (geração de imagens, etc.) ... | Consulte o fina
 1. Download the project
 
 ```sh
-git clone https://github.com/binary-husky/chatgpt_academic.git
-cd chatgpt_academic
+git clone https://github.com/binary-husky/gpt_academic.git
+cd gpt_academic
 ```
 
 2. Configure the API KEY
@@ -149,8 +149,8 @@ python main.py
 1. Apenas ChatGPT (recomendado para a maioria das pessoas)
 
 ``` sh
-git clone https://github.com/binary-husky/chatgpt_academic.git  # Baixar o projeto
-cd chatgpt_academic                                 # Entrar no caminho
+git clone https://github.com/binary-husky/gpt_academic.git  # Baixar o projeto
+cd gpt_academic                                 # Entrar no caminho
 nano config.py                                       # Editar config.py com qualquer editor de texto configurando "Proxy", "API_KEY" e "WEB_PORT" (por exemplo, 50923), etc.
 docker build -t gpt-academic .                      # Instale
 
@@ -180,10 +180,10 @@ docker-compose up
 Basta configurar o API_URL_REDIRECT de acordo com as instruções em `config.py`.
 
 2. Implantação em servidores em nuvem remotos (requer conhecimento e experiência de servidores em nuvem)
-Acesse [Wiki de implementação remota do servidor em nuvem](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
+Acesse [Wiki de implementação remota do servidor em nuvem](https://github.com/binary-husky/gpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
 
 3. Usando a WSL2 (sub-sistema do Windows para Linux)
-Acesse [Wiki da implantação da WSL2](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
+Acesse [Wiki da implantação da WSL2](https://github.com/binary-husky/gpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
 
 4. Como executar em um subdiretório (ex. `http://localhost/subpath`)
 Acesse [Instruções de execução FastAPI](docs/WithFastapi.md)
@@ -214,7 +214,7 @@ Por exemplo,
 
 Escreva plug-ins de função poderosos para executar tarefas que você deseja e não pensava possível.
 A dificuldade geral de escrever e depurar plug-ins neste projeto é baixa e, se você tem algum conhecimento básico de python, pode implementar suas próprias funções sobre o modelo que fornecemos.
-Para mais detalhes, consulte o [Guia do plug-in de função.](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97).
+Para mais detalhes, consulte o [Guia do plug-in de função.](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).
 
 ---
 # Última atualização

docs/README_EN.md

@@ -14,7 +14,7 @@ To translate this project to arbitary language with GPT, read and run [`multi_la
 > Note:
 > 
 > 1. Please note that only the function plugins (buttons) marked in **red** support reading files. Some plugins are in the **drop-down menu** in the plugin area. We welcome and process any new plugins with the **highest priority**!
-> 2. The function of each file in this project is detailed in the self-translation analysis [`self_analysis.md`](https://github.com/binary-husky/chatgpt_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). With version iteration, you can also click on related function plugins at any time to call GPT to regenerate the project's self-analysis report. Common questions are summarized in the [`wiki`](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Installation method](#installation).
+> 2. The function of each file in this project is detailed in the self-translation analysis [`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). With version iteration, you can also click on related function plugins at any time to call GPT to regenerate the project's self-analysis report. Common questions are summarized in the [`wiki`](https://github.com/binary-husky/gpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Installation method](#installation).
 > 3. This project is compatible with and encourages trying domestic large language models such as chatglm, RWKV, Pangu, etc. Multiple API keys are supported and can be filled in the configuration file like `API_KEY="openai-key1,openai-key2,api2d-key3"`. When temporarily changing `API_KEY`, enter the temporary `API_KEY` in the input area and press enter to submit, which will take effect. 
 
 <div align="center">
@@ -25,13 +25,13 @@ One-click polishing | Supports one-click polishing and one-click searching for g
 One-click Chinese-English translation | One-click Chinese-English translation.
 One-click code interpretation | Displays, explains, generates, and adds comments to code.
 [Custom shortcut keys](https://www.bilibili.com/video/BV14s4y1E7jN) | Supports custom shortcut keys.
-Modular design | Supports custom powerful [function plug-ins](https://github.com/binary-husky/chatgpt_academic/tree/master/crazy_functions), plug-ins support [hot update](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97).
-[Self-program profiling](https://www.bilibili.com/video/BV1cj411A7VW) | [Function plug-in] [One-click understanding](https://github.com/binary-husky/chatgpt_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) of the source code of this project
+Modular design | Supports custom powerful [function plug-ins](https://github.com/binary-husky/gpt_academic/tree/master/crazy_functions), plug-ins support [hot update](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).
+[Self-program profiling](https://www.bilibili.com/video/BV1cj411A7VW) | [Function plug-in] [One-click understanding](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) of the source code of this project
 [Program profiling](https://www.bilibili.com/video/BV1cj411A7VW) | [Function plug-in] One-click profiling of other project trees in Python/C/C++/Java/Lua/...
 Reading papers, [translating](https://www.bilibili.com/video/BV1KT411x7Wn) papers | [Function Plug-in] One-click interpretation of latex/pdf full-text papers and generation of abstracts.
 Latex full-text [translation](https://www.bilibili.com/video/BV1nk4y1Y7Js/), [polishing](https://www.bilibili.com/video/BV1FT411H7c5/) | [Function plug-in] One-click translation or polishing of latex papers.
 Batch annotation generation | [Function plug-in] One-click batch generation of function annotations.
-Markdown [Chinese-English translation](https://www.bilibili.com/video/BV1yo4y157jV/) | [Function plug-in] Have you seen the [README](https://github.com/binary-husky/chatgpt_academic/blob/master/docs/README_EN.md) in the five languages above?
+Markdown [Chinese-English translation](https://www.bilibili.com/video/BV1yo4y157jV/) | [Function plug-in] Have you seen the [README](https://github.com/binary-husky/gpt_academic/blob/master/docs/README_EN.md) in the five languages above?
 Chat analysis report generation | [Function plug-in] Automatically generate summary reports after running.
 [PDF full-text translation function](https://www.bilibili.com/video/BV1KT411x7Wn) | [Function plug-in] PDF paper extract title & summary + translate full text (multi-threaded)
 [Arxiv Assistant](https://www.bilibili.com/video/BV1LM4y1279X) | [Function plug-in] Enter the arxiv article url and you can translate abstracts and download PDFs with one click.
@@ -39,7 +39,7 @@ Chat analysis report generation | [Function plug-in] Automatically generate summ
 Internet information aggregation+GPT | [Function plug-in] One-click [let GPT get information from the Internet first](https://www.bilibili.com/video/BV1om4y127ck), then answer questions, and let the information never be outdated.
 Formula/image/table display | Can display formulas in both [tex form and render form](https://user-images.githubusercontent.com/96192199/230598842-1d7fcddd-815d-40ee-af60-baf488a199df.png), support formulas and code highlighting.
 Multi-threaded function plug-in support | Supports multi-threaded calling of chatgpt, and can process [massive text](https://www.bilibili.com/video/BV1FT411H7c5/) or programs with one click.
-Start Dark Gradio [theme](https://github.com/binary-husky/chatgpt_academic/issues/173) | Add ```/?__theme=dark``` after the browser URL to switch to the dark theme.
+Start Dark Gradio [theme](https://github.com/binary-husky/gpt_academic/issues/173) | Add ```/?__theme=dark``` after the browser URL to switch to the dark theme.
 [Multiple LLM models](https://www.bilibili.com/video/BV1wT411p7yf) support, [API2D](https://api2d.com/) interface support | The feeling of being served by GPT3.5, GPT4, [Tsinghua ChatGLM](https://github.com/THUDM/ChatGLM-6B), and [Fudan MOSS](https://github.com/OpenLMLab/MOSS) at the same time must be great, right?
 More LLM model access, support [huggingface deployment](https://huggingface.co/spaces/qingxu98/gpt-academic) | Add Newbing interface (New Bing), introduce Tsinghua [Jittorllms](https://github.com/Jittor/JittorLLMs) to support [LLaMA](https://github.com/facebookresearch/llama), [RWKV](https://github.com/BlinkDL/ChatRWKV) and [Panguα](https://openi.org.cn/pangu/)
 More new feature displays (image generation, etc.)…… | See the end of this document for more... 
@@ -79,8 +79,8 @@ More new feature displays (image generation, etc.)…… | See the end of this d
 
 1. Download the project
 ```sh
-git clone https://github.com/binary-husky/chatgpt_academic.git
-cd chatgpt_academic
+git clone https://github.com/binary-husky/gpt_academic.git
+cd gpt_academic
 ```
 
 2. Configure the API_KEY
@@ -136,8 +136,8 @@ python main.py
 1. ChatGPT Only (Recommended for Most People)
 
 ``` sh
-git clone https://github.com/binary-husky/chatgpt_academic.git  # Download project
-cd chatgpt_academic                                 # Enter path
+git clone https://github.com/binary-husky/gpt_academic.git  # Download project
+cd gpt_academic                                 # Enter path
 nano config.py                                      # Edit config.py with any text editor, configure "Proxy", "API_KEY" and "WEB_PORT" (e.g. 50923), etc.
 docker build -t gpt-academic .                      # Install
 
@@ -167,10 +167,10 @@ docker-compose up
 Configure API_URL_REDIRECT according to the instructions in 'config.py'.
 
 2. Deploy to a Remote Server (Requires Knowledge and Experience with Cloud Servers)
-Please visit [Deployment Wiki-1](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
+Please visit [Deployment Wiki-1](https://github.com/binary-husky/gpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
 
 3. Using WSL2 (Windows Subsystem for Linux)
-Please visit [Deployment Wiki-2](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
+Please visit [Deployment Wiki-2](https://github.com/binary-husky/gpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
 
 4. How to Run Under a Subdomain (e.g. `http://localhost/subpath`)
 Please visit [FastAPI Running Instructions](docs/WithFastapi.md)
@@ -202,7 +202,7 @@ For example,
 
 Write powerful function plugins to perform any task you can think of, even those you cannot think of.
 The difficulty of plugin writing and debugging in this project is very low. As long as you have a certain knowledge of Python, you can implement your own plug-in functions based on the template we provide.
-For details, please refer to the [Function Plugin Guide](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97).
+For details, please refer to the [Function Plugin Guide](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

docs/README_FR.md

@@ -16,7 +16,7 @@ Pour traduire ce projet dans une langue arbitraire avec GPT, lisez et exécutez
 >
 > 1. Veuillez noter que seuls les plugins de fonctions (boutons) **en rouge** prennent en charge la lecture de fichiers. Certains plugins se trouvent dans le **menu déroulant** de la zone de plugins. De plus, nous accueillons et traitons les nouvelles pull requests pour les plugins avec **la plus haute priorité**!
 >
-> 2. Les fonctions de chaque fichier de ce projet sont expliquées en détail dans l'auto-analyse [`self_analysis.md`](https://github.com/binary-husky/chatgpt_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). Avec l'itération des versions, vous pouvez également cliquer sur les plugins de fonctions pertinents et appeler GPT pour régénérer le rapport d'auto-analyse du projet à tout moment. Les FAQ sont résumées dans [le wiki](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Méthode d'installation](#installation).
+> 2. Les fonctions de chaque fichier de ce projet sont expliquées en détail dans l'auto-analyse [`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). Avec l'itération des versions, vous pouvez également cliquer sur les plugins de fonctions pertinents et appeler GPT pour régénérer le rapport d'auto-analyse du projet à tout moment. Les FAQ sont résumées dans [le wiki](https://github.com/binary-husky/gpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Méthode d'installation](#installation).
 >
 > 3. Ce projet est compatible avec et encourage l'utilisation de grands modèles de langage nationaux tels que chatglm, RWKV, Pangu, etc. La coexistence de plusieurs clés API est prise en charge et peut être remplie dans le fichier de configuration, tel que `API_KEY="openai-key1,openai-key2,api2d-key3"`. Lorsque vous souhaitez remplacer temporairement `API_KEY`, saisissez temporairement `API_KEY` dans la zone de saisie, puis appuyez sur Entrée pour soumettre et activer. 
 
@@ -28,13 +28,13 @@ Révision en un clic | prend en charge la révision en un clic et la recherche d
 Traduction chinois-anglais en un clic | Traduction chinois-anglais en un clic
 Explication de code en un clic | Affichage, explication, génération et ajout de commentaires de code
 [Raccourcis personnalisés](https://www.bilibili.com/video/BV14s4y1E7jN) | prend en charge les raccourcis personnalisés
-Conception modulaire | prend en charge de puissants plugins de fonction personnalisée, les plugins prennent en charge la [mise à jour à chaud](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97)  
-[Autoscanner](https://www.bilibili.com/video/BV1cj411A7VW) | [Plug-in de fonction] [Compréhension instantanée](https://github.com/binary-husky/chatgpt_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) du code source de ce projet
+Conception modulaire | prend en charge de puissants plugins de fonction personnalisée, les plugins prennent en charge la [mise à jour à chaud](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)  
+[Autoscanner](https://www.bilibili.com/video/BV1cj411A7VW) | [Plug-in de fonction] [Compréhension instantanée](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) du code source de ce projet
 [Analyse de programme](https://www.bilibili.com/video/BV1cj411A7VW) | [Plug-in de fonction] Analyse en un clic de la structure d'autres projets Python / C / C ++ / Java / Lua / ...
 Lecture d'articles, [traduction](https://www.bilibili.com/video/BV1KT411x7Wn) d'articles | [Plug-in de fonction] Compréhension instantanée de l'article latex / pdf complet et génération de résumés
 [Traduction](https://www.bilibili.com/video/BV1nk4y1Y7Js/) et [révision](https://www.bilibili.com/video/BV1FT411H7c5/) complets en latex | [Plug-in de fonction] traduction ou révision en un clic d'articles en latex
 Génération de commentaires en masse | [Plug-in de fonction] Génération en un clic de commentaires de fonction en masse
-Traduction [chinois-anglais](https://www.bilibili.com/video/BV1yo4y157jV/) en Markdown | [Plug-in de fonction] avez-vous vu la [README](https://github.com/binary-husky/chatgpt_academic/blob/master/docs/README_EN.md) pour les 5 langues ci-dessus?
+Traduction [chinois-anglais](https://www.bilibili.com/video/BV1yo4y157jV/) en Markdown | [Plug-in de fonction] avez-vous vu la [README](https://github.com/binary-husky/gpt_academic/blob/master/docs/README_EN.md) pour les 5 langues ci-dessus?
 Génération de rapports d'analyse de chat | [Plug-in de fonction] Génère automatiquement un rapport de résumé après l'exécution
 [Traduction intégrale en pdf](https://www.bilibili.com/video/BV1KT411x7Wn) | [Plug-in de fonction] Extraction de titre et de résumé de l'article pdf + traduction intégrale (multi-thread)
 [Aide à arxiv](https://www.bilibili.com/video/BV1LM4y1279X) | [Plug-in de fonction] Entrer l'url de l'article arxiv pour traduire et télécharger le résumé en un clic
@@ -84,8 +84,8 @@ Plus de nouvelles fonctionnalités (génération d'images, etc.) ... | Voir la f
 
 1. Télécharger le projet
 ```sh
-git clone https://github.com/binary-husky/chatgpt_academic.git
-cd chatgpt_academic
+git clone https://github.com/binary-husky/gpt_academic.git
+cd gpt_academic
 ```
 
 2. Configuration de la clé API
@@ -141,8 +141,8 @@ python main.py
 1. ChatGPT uniquement (recommandé pour la plupart des gens)
 
 ``` sh
-git clone https://github.com/binary-husky/chatgpt_academic.git  # Télécharger le projet
-cd chatgpt_academic                                 # Accéder au chemin
+git clone https://github.com/binary-husky/gpt_academic.git  # Télécharger le projet
+cd gpt_academic                                 # Accéder au chemin
 nano config.py                                      # Editez config.py avec n'importe quel éditeur de texte en configurant "Proxy", "API_KEY" et "WEB_PORT" (p. ex. 50923)
 docker build -t gpt-academic .                      # Installer
 
@@ -172,10 +172,10 @@ docker-compose up
 Configurez simplement API_URL_REDIRECT selon les instructions de config.py.
 
 2. Déploiement distant sur un serveur cloud (connaissance et expérience des serveurs cloud requises)
-Veuillez consulter [Wiki de déploiement-1] (https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97).
+Veuillez consulter [Wiki de déploiement-1] (https://github.com/binary-husky/gpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97).
 
 3. Utilisation de WSL2 (sous-système Windows pour Linux)
-Veuillez consulter [Wiki de déploiement-2] (https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2).
+Veuillez consulter [Wiki de déploiement-2] (https://github.com/binary-husky/gpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2).
 
 4. Comment exécuter sous un sous-répertoire (tel que `http://localhost/subpath`)
 Veuillez consulter les [instructions d'exécution de FastAPI] (docs/WithFastapi.md).
@@ -206,7 +206,7 @@ Par exemple
 
 Écrivez des plugins de fonctions puissants pour effectuer toutes les tâches que vous souhaitez ou que vous ne pouvez pas imaginer.
 Les plugins de ce projet ont une difficulté de programmation et de débogage très faible. Si vous avez des connaissances de base en Python, vous pouvez simuler la fonctionnalité de votre propre plugin en suivant le modèle que nous avons fourni.
-Veuillez consulter le [Guide du plugin de fonction] (https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97) pour plus de détails.
+Veuillez consulter le [Guide du plugin de fonction] (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) pour plus de détails.
 
 ---
 # Latest Update

docs/README_JP.md

@@ -16,7 +16,7 @@ GPTを使った任意の言語にこのプロジェクトを翻訳するには
 >
 > 1. **赤色**で表示された関数プラグイン(ボタン)のみ、ファイルの読み取りをサポートしています。一部のプラグインは、プラグインエリアの**ドロップダウンメニュー**内にあります。また、私たちはどんな新しいプラグインのPRでも、**最優先**で歓迎し、処理します！
 >
-> 2. このプロジェクトの各ファイルの機能は、自己解析の詳細説明書である[`self_analysis.md`](https://github.com/binary-husky/chatgpt_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/chatgpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98)にまとめられています。[インストール方法](#installation)。
+> 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キーを共存することができ、設定ファイルに`API_KEY="openai-key1,openai-key2,api2d-key3"`のように記入することができます。`API_KEY`を一時的に変更する場合は、入力エリアに一時的な`API_KEY`を入力してEnterキーを押せば、それが有効になります。
 
@@ -29,13 +29,13 @@ GPTを使った任意の言語にこのプロジェクトを翻訳するには
 一键中英翻訳 | 一键で中英翻訳可能
 一键コード解説 | コードを表示し、解説し、生成し、コードに注釈をつけることができる
 [自分でカスタマイズ可能なショートカットキー](https://www.bilibili.com/video/BV14s4y1E7jN) | 自分でカスタマイズ可能なショートカットキーをサポートする
-モジュール化された設計 | カスタマイズ可能な[強力な関数プラグイン](https://github.com/binary-husky/chatgpt_academic/tree/master/crazy_functions)をサポートし、プラグインは[ホットアップデート](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97)に対応している
-[自己プログラム解析](https://www.bilibili.com/video/BV1cj411A7VW) | [関数プラグイン] [一键読解](https://github.com/binary-husky/chatgpt_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)このプロジェクトのソースコード
+モジュール化された設計 | カスタマイズ可能な[強力な関数プラグイン](https://github.com/binary-husky/gpt_academic/tree/master/crazy_functions)をサポートし、プラグインは[ホットアップデート](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)に対応している
+[自己プログラム解析](https://www.bilibili.com/video/BV1cj411A7VW) | [関数プラグイン] [一键読解](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)このプロジェクトのソースコード
 プログラム解析 | [関数プラグイン] 一鍵で他のPython/C/C++/Java/Lua/...プロジェクトを分析できる
 論文の読み、[翻訳](https://www.bilibili.com/video/BV1KT411x7Wn) | [関数プラグイン] LaTex/ PDF論文の全文を一鍵で読み解き、要約を生成することができる
 LaTex全文[翻訳](https://www.bilibili.com/video/BV1nk4y1Y7Js/)、[校正](https://www.bilibili.com/video/BV1FT411H7c5/) | [関数プラグイン] LaTex論文の翻訳または校正を一鍵で行うことができる
 一括で注釈を生成 | [関数プラグイン] 一鍵で関数に注釈をつけることができる
-Markdown[中英翻訳](https://www.bilibili.com/video/BV1yo4y157jV/) | [関数プラグイン] 上記の5種類の言語の[README](https://github.com/binary-husky/chatgpt_academic/blob/master/docs/README_EN.md)を見たことがありますか？
+Markdown[中英翻訳](https://www.bilibili.com/video/BV1yo4y157jV/) | [関数プラグイン] 上記の5種類の言語の[README](https://github.com/binary-husky/gpt_academic/blob/master/docs/README_EN.md)を見たことがありますか？
 チャット分析レポート生成 | [関数プラグイン] 実行後、自動的に概要報告書を生成する
 [PDF論文全文翻訳機能](https://www.bilibili.com/video/BV1KT411x7Wn) | [関数プラグイン] PDF論文からタイトルと要約を抽出し、全文を翻訳する（マルチスレッド）
 [Arxivアシスタント](https://www.bilibili.com/video/BV1LM4y1279X) | [関数プラグイン] arxiv記事のURLを入力するだけで、要約を一鍵翻訳し、PDFをダウンロードできる
@@ -43,7 +43,7 @@ Markdown[中英翻訳](https://www.bilibili.com/video/BV1yo4y157jV/) | [関数
 インターネット情報収集＋GPT | [関数プラグイン] まずGPTに[インターネットから情報を収集](https://www.bilibili.com/video/BV1om4y127ck)してから質問に回答させ、情報が常に最新であるようにする
 数式/画像/表表示 | 数式の[tex形式とレンダリング形式](https://user-images.githubusercontent.com/96192199/230598842-1d7fcddd-815d-40ee-af60-baf488a199df.png)を同時に表示し、数式、コードハイライトをサポートしている
 マルチスレッド関数プラグインがサポートされている | chatgptをマルチスレッドで呼び出し、[大量のテキスト](https://www.bilibili.com/video/BV1FT411H7c5/)またはプログラムを一鍵で処理できる
-ダークグラジオ[テーマの起動](https://github.com/binary-husky/chatgpt_academic/issues/173) | ブラウザのURLの後ろに```/?__theme=dark```を追加すると、ダークテーマを切り替えることができます。
+ダークグラジオ[テーマの起動](https://github.com/binary-husky/gpt_academic/issues/173) | ブラウザのURLの後ろに```/?__theme=dark```を追加すると、ダークテーマを切り替えることができます。
 [多数のLLMモデル](https://www.bilibili.com/video/BV1wT411p7yf)がサポートされ、[API2D](https://api2d.com/)がサポートされている | 同時に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インターフェイス（Newbing）、清華大学の[Jittorllm](https://github.com/Jittor/JittorLLMs)のサポート[LLaMA](https://github.com/facebookresearch/llama), [RWKV](https://github.com/BlinkDL/ChatRWKV)と[盘古α](https://openi.org.cn/pangu/)
 さらに多くの新機能（画像生成など）を紹介する... | この文書の最後に示す... 
@@ -92,8 +92,8 @@ Markdown[中英翻訳](https://www.bilibili.com/video/BV1yo4y157jV/) | [関数
 1. Download the project.
 
 ```sh
-git clone https://github.com/binary-husky/chatgpt_academic.git
-cd chatgpt_academic
+git clone https://github.com/binary-husky/gpt_academic.git
+cd gpt_academic
 ```
 
 2. Configure the API_KEY.
@@ -151,8 +151,8 @@ python main.py
 1. Only ChatGPT (recommended for most people)
 
  ``` sh
-git clone https://github.com/binary-husky/chatgpt_academic.git  # Download project
-cd chatgpt_academic                                 # Enter path
+git clone https://github.com/binary-husky/gpt_academic.git  # Download project
+cd gpt_academic                                 # Enter path
 nano config.py                                      # Edit config.py with any text editor ‑ configure "Proxy," "API_KEY," "WEB_PORT" (e.g., 50923) and more
 docker build -t gpt-academic .                      # installation
 
@@ -182,10 +182,10 @@ docker-compose up
 Configure API_URL_REDIRECT according to the instructions in `config.py`.
 
 2. Remote Cloud Server Deployment (requires cloud server knowledge and experience)
-Please visit [Deployment Wiki-1](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
+Please visit [Deployment Wiki-1](https://github.com/binary-husky/gpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
 
 3. Using WSL2 (Windows Subsystem for Linux Subsystem)
-Please visit [Deployment Wiki-2](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
+Please visit [Deployment Wiki-2](https://github.com/binary-husky/gpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
 
 4. How to run on a secondary URL (such as `http://localhost/subpath`)
 Please visit [FastAPI Running Instructions](docs/WithFastapi.md)
@@ -216,7 +216,7 @@ example:
 
 Write powerful function plugins to perform any task you can and cannot think of.
 The difficulty of writing and debugging plugins in this project is low, and as long as you have a certain amount of python basic knowledge, you can follow the template provided by us to achieve your own plugin functions.
-For details, please refer to the [Function Plugin Guide](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97).
+For details, please refer to the [Function Plugin Guide](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

docs/README_RS.md

@@ -11,7 +11,7 @@
 > 
 > 1. Обратите внимание, что только функциональные плагины (кнопки), помеченные **красным цветом**, поддерживают чтение файлов, некоторые плагины находятся в **выпадающем меню** в области плагинов. Кроме того, мы с наивысшим приоритетом рады и обрабатываем pull requests для любых новых плагинов!
 > 
-> 2. В каждом файле проекта функциональность описана в документе самоанализа [`self_analysis.md`](https://github.com/binary-husky/chatgpt_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/chatgpt_academic/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98). [Метод установки](#installation).
+> 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` в области ввода и нажмите клавишу Enter, чтобы он вступил в силу. 
 
@@ -33,13 +33,13 @@
 Однокнопочный перевод на английский и китайский | Однокнопочный перевод на английский и китайский
 Однокнопочное объяснение кода | Показ кода, объяснение его, генерация кода, комментирование кода
 [Настройка быстрых клавиш](https://www.bilibili.com/video/BV14s4y1E7jN) | Поддержка настройки быстрых клавиш
-Модульный дизайн | Поддержка пользовательских функциональных плагинов мощных [функциональных плагинов](https://github.com/binary-husky/chatgpt_academic/tree/master/crazy_functions), плагины поддерживают [горячую замену](https://github.com/binary-husky/chatgpt_academic/wiki/Function-Plug-in-Guide)
-[Анализ своей программы](https://www.bilibili.com/video/BV1cj411A7VW) | [Функциональный плагин] [Однокнопочный просмотр](https://github.com/binary-husky/chatgpt_academic/wiki/chatgpt-academicProject-Self-analysis-Report) исходного кода этого проекта
+Модульный дизайн | Поддержка пользовательских функциональных плагинов мощных [функциональных плагинов](https://github.com/binary-husky/gpt_academic/tree/master/crazy_functions), плагины поддерживают [горячую замену](https://github.com/binary-husky/gpt_academic/wiki/Function-Plug-in-Guide)
+[Анализ своей программы](https://www.bilibili.com/video/BV1cj411A7VW) | [Функциональный плагин] [Однокнопочный просмотр](https://github.com/binary-husky/gpt_academic/wiki/chatgpt-academicProject-Self-analysis-Report) исходного кода этого проекта
 [Анализ программы](https://www.bilibili.com/video/BV1cj411A7VW) | [Функциональный плагин] Однокнопочный анализ дерева других проектов Python/C/C++/Java/Lua/...
 Чтение статей, [перевод](https://www.bilibili.com/video/BV1KT411x7Wn) статей | [Функциональный плагин] Однокнопочное чтение полного текста научных статей и генерация резюме
 Полный перевод [LaTeX](https://www.bilibili.com/video/BV1nk4y1Y7Js/) и совершенствование | [Функциональный плагин] Однокнопочный перевод или совершенствование LaTeX статьи
 Автоматическое комментирование | [Функциональный плагин] Однокнопочное автоматическое генерирование комментариев функций
-[Перевод](https://www.bilibili.com/video/BV1yo4y157jV/) Markdown на английский и китайский | [Функциональный плагин] Вы видели обе версии файлов [README](https://github.com/binary-husky/chatgpt_academic/blob/master/docs/README_EN.md) для этих 5 языков?
+[Перевод](https://www.bilibili.com/video/BV1yo4y157jV/) Markdown на английский и китайский | [Функциональный плагин] Вы видели обе версии файлов [README](https://github.com/binary-husky/gpt_academic/blob/master/docs/README_EN.md) для этих 5 языков?
 Отчет о чат-анализе | [Функциональный плагин] После запуска будет автоматически сгенерировано сводное извещение
 Функция перевода полного текста [PDF-статьи](https://www.bilibili.com/video/BV1KT411x7Wn) | [Функциональный плагин] Извлечение заголовка и резюме [PDF-статьи](https://www.bilibili.com/video/BV1KT411x7Wn) и перевод всего документа (многопоточность)
 [Arxiv Helper](https://www.bilibili.com/video/BV1LM4y1279X) | [Функциональный плагин] Введите URL статьи на arxiv и одним щелчком мыши переведите резюме и загрузите PDF
@@ -81,8 +81,8 @@
 
 1. Download the project
 ```sh
-git clone https://github.com/binary-husky/chatgpt_academic.git
-cd chatgpt_academic
+git clone https://github.com/binary-husky/gpt_academic.git
+cd gpt_academic
 ```
 
 2. Configure API_KEY
@@ -138,8 +138,8 @@ python main.py
 1. ChatGPT only (recommended for most people)
 
 ``` sh
-git clone https://github.com/binary-husky/chatgpt_academic.git  # download the project
-cd chatgpt_academic                                 # enter the path
+git clone https://github.com/binary-husky/gpt_academic.git  # download the project
+cd gpt_academic                                 # enter the path
 nano config.py                                      # edit config.py with any text editor to configure "Proxy", "API_KEY", and "WEB_PORT" (eg 50923)
 docker build -t gpt-academic .                      # install
 
@@ -169,10 +169,10 @@ docker-compose up
 Configure API_URL_REDIRECT according to the instructions in `config.py`.
 
 2. Remote Cloud Server Deployment (Requires Knowledge and Experience of Cloud Servers)
-Please visit [Deployment Wiki-1](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
+Please visit [Deployment Wiki-1](https://github.com/binary-husky/gpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
 
 3. Using WSL2 (Windows Subsystem for Linux subsystem)
-Please visit [Deployment Wiki-2](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
+Please visit [Deployment Wiki-2](https://github.com/binary-husky/gpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
 
 4. How to run at the secondary URL (such as `http://localhost/subpath`)
 Please visit [FastAPI Operation Instructions](docs/WithFastapi.md)
@@ -204,7 +204,7 @@ For example:
 
 Write powerful function plugins to perform any task you can and can't imagine.
 The difficulty of debugging and writing plugins in this project is very low. As long as you have a certain knowledge of python, you can implement your own plugin function by imitating the template we provide.
-Please refer to the [Function Plugin Guide](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97) for details.
+Please refer to the [Function Plugin Guide](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) for details.
 
 ---
 # Latest Update

docs/translate_english.json

@@ -2085,5 +2085,81 @@
     "欢迎使用 MOSS 人工智能助手！输入内容即可进行对话": "Welcome to use MOSS AI assistant! Enter the content to start the conversation.",
     "记住当前的label": "Remember the current label.",
     "不能正常加载ChatGLMFT的参数！": "Cannot load ChatGLMFT parameters normally!",
-    "建议直接在API_KEY处填写": "It is recommended to fill in directly at API_KEY."
+    "建议直接在API_KEY处填写": "It is recommended to fill in directly at API_KEY.",
+    "创建request": "Create request",
+    "默认 secondary": "Default secondary",
+    "会被加在你的输入之前": "Will be added before your input",
+    "缺少": "Missing",
+    "前者是API2D的结束条件": "The former is the termination condition of API2D",
+    "无需填写": "No need to fill in",
+    "后缀": "Suffix",
+    "扭转的范围": "Range of twisting",
+    "是否在触发时清除历史": "Whether to clear history when triggered",
+    "⭐多线程方法": "⭐Multi-threaded method",
+    "消耗大量的内存": "Consumes a large amount of memory",
+    "重组": "Reorganize",
+    "高危设置! 常规情况下不要修改! 通过修改此设置": "High-risk setting! Do not modify under normal circumstances! Modify this setting",
+    "检查USE_PROXY": "Check USE_PROXY",
+    "标注节点的行数范围": "Range of line numbers for annotated nodes",
+    "即不处理之前的对话历史": "That is, do not process previous conversation history",
+    "即将编译PDF": "Compiling PDF",
+    "没有设置ANTHROPIC_API_KEY选项": "ANTHROPIC_API_KEY option is not set",
+    "非Openai官方接口返回了错误": "Non-Openai official interface returned an error",
+    "您的 API_KEY 不满足任何一种已知的密钥格式": "Your API_KEY does not meet any known key format",
+    "格式": "Format",
+    "不能正常加载": "Cannot load properly",
+    "🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行": "🏃‍♂️🏃‍♂️🏃‍♂️ Subprocess execution",
+    "前缀": "Prefix",
+    "创建AcsClient实例": "Create AcsClient instance",
+    "⭐主进程执行": "⭐Main process execution",
+    "增强稳健性": "Enhance robustness",
+    "用来描述你的要求": "Used to describe your requirements",
+    "举例": "For example",
+    "⭐单线程方法": "⭐Single-threaded method",
+    "后者是OPENAI的结束条件": "The latter is the termination condition of OPENAI",
+    "防止proxies单独起作用": "Prevent proxies from working alone",
+    "将两个PDF拼接": "Concatenate two PDFs",
+    "最后一步处理": "The last step processing",
+    "正在从github下载资源": "Downloading resources from github",
+    "失败时": "When failed",
+    "尚未加载": "Not loaded yet",
+    "配合前缀可以把你的输入内容用引号圈起来": "With the prefix, you can enclose your input content in quotation marks",
+    "我好！": "I'm good!",
+    "默认 False": "Default False",
+    "的依赖": "Dependencies of",
+    "并设置参数": "and set parameters",
+    "会被加在你的输入之后": "Will be added after your input",
+    "安装": "Installation",
+    "一个单实例装饰器": "Single instance decorator",
+    "自定义API KEY格式": "Customize API KEY format",
+    "的参数": "Parameters of",
+    "api2d等请求源": "api2d and other request sources",
+    "逆转出错的段落": "Reverse the wrong paragraph",
+    "没有设置ANTHROPIC_API_KEY": "ANTHROPIC_API_KEY is not set",
+    "默认 True": "Default True",
+    "本项目现已支持OpenAI和Azure的api-key": "This project now supports OpenAI and Azure's api-key",
+    "即可见": "Visible immediately",
+    "请问什么是质子": "What is a proton?",
+    "按钮是否可见": "Is the button visible?",
+    "调用": "Call",
+    "如果要使用": "If you want to use",
+    "的参数！": "parameters!",
+    "例如翻译、解释代码、润色等等": "such as translation, code interpretation, polishing, etc.",
+    "响应异常": "Response exception",
+    "响应中": "Responding",
+    "请尝试英文Prompt": "Try English Prompt",
+    "在运行过程中动态地修改多个配置": "Dynamically modify multiple configurations during runtime",
+    "无法调用相关功能": "Unable to invoke related functions",
+    "接驳虚空终端": "Connect to Void Terminal",
+    "虚空终端插件的功能": "Functionality of Void Terminal plugin",
+    "执行任意插件的命令": "Execute commands of any plugin",
+    "修改调用函数": "Modify calling function",
+    "获取简单聊天的默认参数": "Get default parameters for simple chat",
+    "根据自然语言的描述": "Based on natural language description",
+    "获取插件的句柄": "Get handle of plugin",
+    "第四部分": "Part Four",
+    "在运行过程中动态地修改配置": "Dynamically modify configurations during runtime",
+    "请先把模型切换至gpt-*或者api2d-*": "Please switch the model to gpt-* or api2d-* first",
+    "获取简单聊天的句柄": "Get handle of simple chat",
+    "获取插件的默认参数": "Get default parameters of plugin"
 }

docs/translate_japanese.json

@@ -939,7 +939,6 @@
     "以下は学術論文の基本情報です": "以下は学術論文の基本情報です",
     "出力が不完全になる原因となる": "出力が不完全になる原因となる",
     "ハイフンを使って": "ハイフンを使って",
-    "シングルスレッド": "シングルスレッド",
     "请先把模型切换至gpt-xxxx或者api2d-xxxx": "Please switch the model to gpt-xxxx or api2d-xxxx first.",
     "路径或网址": "Path or URL",
     "*代表通配符": "* represents a wildcard",
@@ -1484,5 +1483,632 @@
     "请提交新问题": "新しい問題を提出してください",
     "您正在调用一个": "あなたは呼び出しています",
     "请编辑以下文本": "以下のテキストを編集してください",
-    "常见协议无非socks5h/http": "一般的なプロトコルはsocks5h/http以外ありません"
+    "常见协议无非socks5h/http": "一般的なプロトコルはsocks5h/http以外ありません",
+    "Latex英文纠错": "LatexEnglishErrorCorrection",
+    "连接bing搜索回答问题": "ConnectBingSearchAnswerQuestion",
+    "联网的ChatGPT_bing版": "OnlineChatGPT_BingVersion",
+    "总结音视频": "SummarizeAudioVideo",
+    "动画生成": "GenerateAnimation",
+    "数学动画生成manim": "GenerateMathematicalAnimationManim",
+    "Markdown翻译指定语言": "TranslateMarkdownSpecifiedLanguage",
+    "知识库问答": "KnowledgeBaseQuestionAnswer",
+    "Langchain知识库": "LangchainKnowledgeBase",
+    "读取知识库作答": "ReadKnowledgeBaseAnswer",
+    "交互功能模板函数": "InteractiveFunctionTemplateFunction",
+    "交互功能函数模板": "InteractiveFunctionFunctionTemplate",
+    "Latex英文纠错加PDF对比": "LatexEnglishErrorCorrectionWithPDFComparison",
+    "Latex输出PDF结果": "LatexOutputPDFResult",
+    "Latex翻译中文并重新编译PDF": "TranslateChineseAndRecompilePDF",
+    "语音助手": "VoiceAssistant",
+    "微调数据集生成": "FineTuneDatasetGeneration",
+    "chatglm微调工具": "ChatGLMFineTuningTool",
+    "启动微调": "StartFineTuning",
+    "sprint亮靛": "SprintAzureIndigo",
+    "专业词汇声明": "ProfessionalVocabularyDeclaration",
+    "Latex精细分解与转化": "LatexDetailedDecompositionAndConversion",
+    "编译Latex": "CompileLatex",
+    "将代码转为动画": "コードをアニメーションに変換する",
+    "解析arxiv网址失败": "arxivのURLの解析に失敗しました",
+    "其他模型转化效果未知": "他のモデルの変換効果は不明です",
+    "把文件复制过去": "ファイルをコピーする",
+    "！！！如果需要运行量化版本": "！！！量子化バージョンを実行する必要がある場合",
+    "报错信息如下. 如果是与网络相关的问题": "エラーメッセージは次のとおりです。ネットワークに関連する問題の場合",
+    "请检查ALIYUN_TOKEN和ALIYUN_APPKEY是否过期": "ALIYUN_TOKENとALIYUN_APPKEYの有効期限を確認してください",
+    "编译结束": "コンパイル終了",
+    "只读": "読み取り専用",
+    "模型选择是": "モデルの選択は",
+    "正在从github下载资源": "GitHubからリソースをダウンロードしています",
+    "同时分解长句": "同時に長い文を分解する",
+    "寻找主tex文件": "メインのtexファイルを検索する",
+    "例如您可以将以下命令复制到下方": "たとえば、以下のコマンドを下にコピーできます",
+    "使用中文总结音频“": "中国語で音声を要約する",
+    "此处填API密钥": "ここにAPIキーを入力してください",
+    "裁剪输入": "入力をトリミングする",
+    "当前语言模型温度设定": "現在の言語モデルの温度設定",
+    "history 是之前的对话列表": "historyは以前の対話リストです",
+    "对输入的word文档进行摘要生成": "入力されたWord文書の要約を生成する",
+    "输入问题后点击该插件": "質問を入力した後、このプラグインをクリックします",
+    "仅在Windows系统进行了测试": "Windowsシステムでのみテストされています",
+    "reverse 操作必须放在最后": "reverse操作は最後に配置する必要があります",
+    "即将编译PDF": "PDFをコンパイルする予定です",
+    "执行错误": "エラーが発生しました",
+    "段音频完成了吗": "セグメントのオーディオは完了しましたか",
+    "然后重启程序": "それからプログラムを再起動してください",
+    "是所有LLM的通用接口": "これはすべてのLLMの共通インターフェースです",
+    "当前报错的latex代码处于第": "現在のエラーのあるLaTeXコードは第",
+    "🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行": "🏃‍♂️🏃‍♂️🏃‍♂️ サブプロセスの実行",
+    "用来描述你的要求": "要求を説明するために使用されます",
+    "原始PDF编译是否成功": "元のPDFのコンパイルは成功しましたか",
+    "本地Latex论文精细翻译": "ローカルのLaTeX論文の詳細な翻訳",
+    "设置OpenAI密钥和模型": "OpenAIキーとモデルの設定",
+    "如果使用ChatGLM2微调模型": "ChatGLM2ファインチューニングモデルを使用する場合",
+    "项目Github地址 \\url{https": "プロジェクトのGithubアドレス \\url{https",
+    "将前后断行符脱离": "前後の改行文字を削除します",
+    "该项目的Latex主文件是": "このプロジェクトのLaTeXメインファイルは",
+    "编译已经开始": "コンパイルが開始されました",
+    "*{\\scriptsize\\textbf{警告": "*{\\scriptsize\\textbf{警告",
+    "从一批文件": "一連のファイルから",
+    "等待用户的再次调用": "ユーザーの再呼び出しを待っています",
+    "目前仅支持GPT3.5/GPT4": "現在、GPT3.5/GPT4のみをサポートしています",
+    "如果一句话小于7个字": "1つの文が7文字未満の場合",
+    "目前对机器学习类文献转化效果最好": "現在、機械学習の文献変換効果が最も良いです",
+    "寻找主文件": "メインファイルを検索中",
+    "解除插件状态": "プラグインの状態を解除します",
+    "默认为Chinese": "デフォルトはChineseです",
+    "依赖不足": "不足の依存関係",
+    "编译文献交叉引用": "文献の相互参照をコンパイルする",
+    "对不同latex源文件扣分": "異なるLaTeXソースファイルに罰則を課す",
+    "再列出用户可能提出的三个问题": "ユーザーが提出する可能性のある3つの問題を再リスト化する",
+    "建议排查": "トラブルシューティングの提案",
+    "生成时间戳": "タイムスタンプの生成",
+    "检查config中的AVAIL_LLM_MODELS选项": "configのAVAIL_LLM_MODELSオプションを確認する",
+    "chatglmft 没有 sys_prompt 接口": "chatglmftにはsys_promptインターフェースがありません",
+    "在一个异步线程中采集音频": "非同期スレッドでオーディオを収集する",
+    "初始化插件状态": "プラグインの状態を初期化する",
+    "内含已经翻译的Tex文档": "翻訳済みのTexドキュメントが含まれています",
+    "请注意自我隐私保护哦！": "プライバシー保護に注意してください！",
+    "使用正则表达式查找半行注释": "正規表現を使用して半行コメントを検索する",
+    "不能正常加载ChatGLMFT的参数！": "ChatGLMFTのパラメータを正常にロードできません！",
+    "首先你在中文语境下通读整篇论文": "まず、中国語の文脈で論文全体を読んでください",
+    "如 绿帽子*深蓝色衬衫*黑色运动裤": "例えば、緑の帽子*濃い青のシャツ*黒のスポーツパンツ",
+    "默认为default": "デフォルトはdefaultです",
+    "将": "置き換える",
+    "使用 Unsplash API": "Unsplash APIを使用する",
+    "会被加在你的输入之前": "あなたの入力の前に追加されます",
+    "还需要填写组织": "組織を入力する必要があります",
+    "test_LangchainKnowledgeBase读取": "test_LangchainKnowledgeBaseの読み込み",
+    "目前不支持历史消息查询": "現在、過去のメッセージのクエリはサポートされていません",
+    "临时存储用于调试": "デバッグ用の一時的なストレージ",
+    "提取总结": "テキストの翻訳",
+    "每秒采样数量": "テキストの翻訳",
+    "但通常不会出现在正文": "テキストの翻訳",
+    "通过调用conversations_open方法打开一个频道": "テキストの翻訳",
+    "导致输出不完整": "テキストの翻訳",
+    "获取已打开频道的最新消息并返回消息列表": "テキストの翻訳",
+    "Tex源文件缺失！": "テキストの翻訳",
+    "如果需要使用Slack Claude": "テキストの翻訳",
+    "扭转的范围": "テキストの翻訳",
+    "使用latexdiff生成论文转化前后对比": "テキストの翻訳",
+    "--读取文件": "テキストの翻訳",
+    "调用openai api 使用whisper-1模型": "テキストの翻訳",
+    "避免遗忘导致死锁": "テキストの翻訳",
+    "在多Tex文档中": "テキストの翻訳",
+    "失败时": "テキストの翻訳",
+    "然后转移到指定的另一个路径中": "テキストの翻訳",
+    "使用Newbing": "テキストの翻訳",
+    "的参数": "テキストの翻訳",
+    "后者是OPENAI的结束条件": "テキストの翻訳",
+    "构建知识库": "テキストの翻訳",
+    "吸收匿名公式": "テキストの翻訳",
+    "前缀": "テキストの翻訳",
+    "会直接转到该函数": "テキストの翻訳",
+    "Claude失败": "テキストの翻訳",
+    "P.S. 但愿没人把latex模板放在里面传进来": "P.S. 但愿没人把latex模板放在里面传进来",
+    "临时地启动代理网络": "临时地启动代理网络",
+    "读取文件内容到内存": "読み込んだファイルの内容をメモリに保存する",
+    "总结音频": "音声をまとめる",
+    "没有找到任何可读取文件": "読み込み可能なファイルが見つかりません",
+    "获取Slack消息失败": "Slackメッセージの取得に失敗しました",
+    "用黑色标注转换区": "黒い注釈で変換エリアをマークする",
+    "此插件处于开发阶段": "このプラグインは開発中です",
+    "其他操作系统表现未知": "他のオペレーティングシステムの動作は不明です",
+    "返回找到的第一个": "最初に見つかったものを返す",
+    "发现已经存在翻译好的PDF文档": "翻訳済みのPDFドキュメントが既に存在することがわかりました",
+    "不包含任何可用于": "使用できるものは含まれていません",
+    "发送到openai音频解析终端": "openai音声解析端に送信する",
+    "========================================= 插件主程序2 =====================================================": "========================================= プラグインメインプログラム2 =====================================================",
+    "正在重试": "再試行中",
+    "从而更全面地理解项目的整体功能": "プロジェクトの全体的な機能をより理解するために",
+    "正在等您说完问题": "質問が完了するのをお待ちしています",
+    "使用教程详情见 request_llm/README.md": "使用方法の詳細については、request_llm/README.mdを参照してください",
+    "6.25 加入判定latex模板的代码": "6.25 テンプレートの判定コードを追加",
+    "找不到任何音频或视频文件": "音声またはビデオファイルが見つかりません",
+    "请求GPT模型的": "GPTモデルのリクエスト",
+    "行": "行",
+    "分析上述回答": "上記の回答を分析する",
+    "如果要使用ChatGLMFT": "ChatGLMFTを使用する場合",
+    "上传Latex项目": "Latexプロジェクトをアップロードする",
+    "如参考文献、脚注、图注等": "参考文献、脚注、図のキャプションなど",
+    "未配置": "設定されていません",
+    "请在此处给出自定义翻译命令": "カスタム翻訳コマンドをここに入力してください",
+    "第二部分": "第2部分",
+    "解压失败! 需要安装pip install py7zr来解压7z文件": "解凍に失敗しました！7zファイルを解凍するにはpip install py7zrをインストールする必要があります",
+    "吸收在42行以内的begin-end组合": "42行以内のbegin-endの組み合わせを取り込む",
+    "Latex文件融合完成": "Latexファイルの統合が完了しました",
+    "输出html调试文件": "HTMLデバッグファイルの出力",
+    "论文概况": "論文の概要",
+    "修复括号": "括弧の修復",
+    "赋予插件状态": "プラグインの状態を付与する",
+    "标注节点的行数范围": "ノードの行数範囲を注釈する",
+    "MOSS can understand and communicate fluently in the language chosen by the user such as English and 中文. MOSS can perform any language-based tasks.": "MOSSは、ユーザーが選択した言語（英語や中文など）でスムーズに理解し、コミュニケーションすることができます。MOSSは、言語に基づくさまざまなタスクを実行できます。",
+    "LLM_MODEL是默认选中的模型": "LLM_MODELはデフォルトで選択されたモデルです",
+    "配合前缀可以把你的输入内容用引号圈起来": "接頭辞と組み合わせて、入力内容を引用符で囲むことができます",
+    "获取关键词": "キーワードの取得",
+    "本项目现已支持OpenAI和Azure的api-key": "このプロジェクトは、OpenAIおよびAzureのAPIキーをサポートしています",
+    "欢迎使用 MOSS 人工智能助手！": "MOSS AIアシスタントをご利用いただきありがとうございます！",
+    "在执行完成之后": "実行が完了した後",
+    "正在听您讲话": "お話をお聞きしています",
+    "Claude回复的片段": "Claudeの返信の一部",
+    "返回": "戻る",
+    "期望格式例如": "期待される形式の例",
+    "gpt 多线程请求": "GPTマルチスレッドリクエスト",
+    "当前工作路径为": "現在の作業パスは",
+    "该PDF由GPT-Academic开源项目调用大语言模型+Latex翻译插件一键生成": "このPDFはGPT-Academicオープンソースプロジェクトによって大規模言語モデル+Latex翻訳プラグインを使用して一括生成されました",
+    "解决插件锁定时的界面显示问题": "プラグインのロック時のインターフェース表示の問題を解決する",
+    "默认 secondary": "デフォルトのセカンダリ",
+    "会把列表拆解": "リストを分解します",
+    "暂时不支持历史消息": "一時的に歴史メッセージはサポートされていません",
+    "或者重启之后再度尝试": "または再起動後に再試行してください",
+    "吸收其他杂项": "他の雑項を吸収する",
+    "双手离开鼠标键盘吧": "両手をマウスとキーボードから離してください",
+    "建议更换代理协议": "プロキシプロトコルの変更をお勧めします",
+    "音频助手": "オーディオアシスタント",
+    "请耐心等待": "お待ちください",
+    "翻译结果": "翻訳結果",
+    "请在此处追加更细致的矫错指令": "ここにより詳細なエラー修正命令を追加してください",
+    "编译原始PDF": "元のPDFをコンパイルする",
+    "-构建知识库": "-ナレッジベースの構築",
+    "删除中间文件夹": "中間フォルダを削除する",
+    "这段代码定义了一个名为TempProxy的空上下文管理器": "このコードはTempProxyという名前の空のコンテキストマネージャを定義しています",
+    "参数说明": "パラメータの説明",
+    "正在预热文本向量化模组": "テキストベクトル化モジュールのプリヒート中",
+    "函数插件": "関数プラグイン",
+    "右下角更换模型菜单中可切换openai": "右下のモデルメニューでopenaiを切り替えることができます",
+    "先上传数据集": "まずデータセットをアップロードしてください",
+    "LatexEnglishErrorCorrection+高亮修正位置": "テキストの翻訳",
+    "正在构建知识库": "テキストの翻訳",
+    "用红色标注处保留区": "テキストの翻訳",
+    "安装Claude的依赖": "テキストの翻訳",
+    "已禁用": "テキストの翻訳",
+    "是否在提交时自动清空输入框": "テキストの翻訳",
+    "GPT 学术优化": "テキストの翻訳",
+    "需要特殊依赖": "テキストの翻訳",
+    "test_联网回答问题": "テキストの翻訳",
+    "除非您是论文的原作者": "テキストの翻訳",
+    "即可见": "テキストの翻訳",
+    "解析为简体中文": "テキストの翻訳",
+    "解析整个Python项目": "テキストの翻訳",
+    "========================================= 插件主程序1 =====================================================": "テキストの翻訳",
+    "当前参数": "テキストの翻訳",
+    "处理个别特殊插件的锁定状态": "テキストの翻訳",
+    "已知某些代码的局部作用是": "テキストの翻訳",
+    "请务必用 pip install -r requirements.txt 指令安装依赖": "テキストの翻訳",
+    "安装": "テキストの翻訳",
+    "请登录OpenAI查看详情 https": "テキストの翻訳",
+    "必须包含documentclass": "テキストの翻訳",
+    "极少数情况下": "テキストの翻訳",
+    "并将返回的频道ID保存在属性CHANNEL_ID中": "テキストの翻訳",
+    "您的 API_KEY 不满足任何一种已知的密钥格式": "テキストの翻訳",
+    "-预热文本向量化模组": "テキストの翻訳",
+    "什么都没有": "テキストの翻訳",
+    "等待GPT响应": "テキストの翻訳",
+    "请尝试把以下指令复制到高级参数区": "テキストの翻訳",
+    "模型参数": "テキストの翻訳",
+    "先删除": "テキストの翻訳",
+    "响应中": "テキストの翻訳",
+    "开始接收chatglmft的回复": "テキストの翻訳",
+    "手动指定语言": "テキストの翻訳",
+    "获取线程锁": "テキストの翻訳",
+    "当前大语言模型": "テキストの翻訳",
+    "段音频的第": "テキストの翻訳",
+    "正在编译对比PDF": "テキストの翻訳",
+    "根据需要切换prompt": "テキストの翻訳",
+    "取评分最高者返回": "テキストの翻訳",
+    "如果您是论文原作者": "テキストの翻訳",
+    "段音频的主要内容": "テキストの翻訳",
+    "为啥chatgpt会把cite里面的逗号换成中文逗号呀": "テキストの翻訳",
+    "为每一位访问的用户赋予一个独一无二的uuid编码": "テキストの翻訳",
+    "将每次对话记录写入Markdown格式的文件中": "テキストの翻訳",
+    "ChatGLMFT尚未加载": "テキストの翻訳",
+    "切割音频文件": "テキストの翻訳",
+    "例如 f37f30e0f9934c34a992f6f64f7eba4f": "テキストの翻訳",
+    "work_folder = Latex预处理": "テキストの翻訳",
+    "出问题了": "問題が発生しました",
+    "等待Claude响应中": "Claudeの応答を待っています",
+    "增强稳健性": "信頼性を向上させる",
+    "赋予插件锁定 锁定插件回调路径": "プラグインにコールバックパスをロックする",
+    "将多文件tex工程融合为一个巨型tex": "複数のファイルのtexプロジェクトを1つの巨大なtexに統合する",
+    "参考文献转Bib": "参考文献をBibに変換する",
+    "由于提问含不合规内容被Azure过滤": "質問が規則に違反しているため、Azureによってフィルタリングされました",
+    "读取优先级": "優先度を読み取る",
+    "格式如org-xxxxxxxxxxxxxxxxxxxxxxxx": "形式はorg-xxxxxxxxxxxxxxxxxxxxxxxxのようです",
+    "辅助gpt生成代码": "GPTのコード生成を補助する",
+    "读取音频文件": "音声ファイルを読み取る",
+    "输入arxivID": "arxivIDを入力する",
+    "转化PDF编译是否成功": "PDFのコンパイルが成功したかどうかを変換する",
+    "Call ChatGLMFT fail 不能正常加载ChatGLMFT的参数": "ChatGLMFTのパラメータを正常にロードできませんでした",
+    "创建AcsClient实例": "AcsClientのインスタンスを作成する",
+    "将 chatglm 直接对齐到 chatglm2": "chatglmをchatglm2に直接整列させる",
+    "要求": "要求",
+    "子任务失败时的重试次数": "サブタスクが失敗した場合のリトライ回数",
+    "请求子进程": "サブプロセスを要求する",
+    "按钮是否可见": "ボタンが表示可能かどうか",
+    "将 \\include 命令转换为 \\input 命令": "\\includeコマンドを\\inputコマンドに変換する",
+    "用户填3": "ユーザーが3を入力する",
+    "后面是英文逗号": "後ろに英語のカンマがあります",
+    "吸收iffalse注释": "iffalseコメントを吸収する",
+    "请稍候": "お待ちください",
+    "摘要生成后的文档路径": "要約生成後のドキュメントのパス",
+    "主程序即将开始": "メインプログラムがすぐに開始されます",
+    "处理历史信息": "履歴情報の処理",
+    "根据给定的切割时长将音频文件切割成多个片段": "指定された分割時間に基づいてオーディオファイルを複数のセグメントに分割する",
+    "解决部分词汇翻译不准确的问题": "一部の用語の翻訳の不正確さを解決する",
+    "即将退出": "すぐに終了します",
+    "用于给一小段代码上代理": "一部のコードにプロキシを適用するために使用されます",
+    "提取文件扩展名": "ファイルの拡張子を抽出する",
+    "目前支持的格式": "現在サポートされている形式",
+    "第一次调用": "最初の呼び出し",
+    "异步方法": "非同期メソッド",
+    "P.S. 顺便把Latex的注释去除": "P.S. LaTeXのコメントを削除する",
+    "构建完成": "ビルドが完了しました",
+    "缺少": "不足しています",
+    "建议暂时不要使用": "一時的に使用しないことをお勧めします",
+    "对比PDF编译是否成功": "PDFのコンパイルが成功したかどうかを比較する",
+    "填入azure openai api的密钥": "Azure OpenAI APIのキーを入力してください",
+    "功能尚不稳定": "機能はまだ安定していません",
+    "则跳过GPT请求环节": "GPTリクエストのスキップ",
+    "即不处理之前的对话历史": "以前の対話履歴を処理しない",
+    "非Openai官方接口返回了错误": "非公式のOpenAI APIがエラーを返しました",
+    "其他类型文献转化效果未知": "他のタイプの文献の変換効果は不明です",
+    "给出一些判定模板文档的词作为扣分项": "テンプレートドキュメントの単語を減点項目として提供する",
+    "找 API_ORG 设置项": "API_ORGの設定項目を検索します",
+    "调用函数": "関数を呼び出します",
+    "需要手动安装新增的依赖库": "新しい依存ライブラリを手動でインストールする必要があります",
+    "或者使用此插件继续上传更多文件": "または、このプラグインを使用してさらにファイルをアップロードします",
+    "640个字节为一组": "640バイトごとにグループ化します",
+    "逆转出错的段落": "エラーのあるパラグラフを逆転させます",
+    "对话助手函数插件": "対話アシスタント関数プラグイン",
+    "前者是API2D的结束条件": "前者はAPI2Dの終了条件です",
+    "终端": "ターミナル",
+    "仅调试": "デバッグのみ",
+    "论文": "論文",
+    "想象一个穿着者": "着用者を想像してください",
+    "音频内容是": "音声の内容は",
+    "如果需要使用AZURE 详情请见额外文档 docs\\use_azure.md": "AZUREを使用する必要がある場合は、詳細については別のドキュメント docs\\use_azure.md を参照してください",
+    "请先将.doc文档转换为.docx文档": ".docドキュメントを.docxドキュメントに変換してください",
+    "请查看终端的输出或耐心等待": "ターミナルの出力を確認するか、お待ちください",
+    "初始化音频采集线程": "オーディオキャプチャスレッドを初期化します",
+    "用该压缩包+ConversationHistoryArchive进行反馈": "この圧縮ファイル+ConversationHistoryArchiveを使用してフィードバックします",
+    "阿里云实时语音识别 配置难度较高 仅建议高手用户使用 参考 https": "阿里云リアルタイム音声認識の設定は難しいため、上級ユーザーのみに推奨されます 参考 https",
+    "多线程翻译开始": "マルチスレッド翻訳が開始されました",
+    "只有GenerateImage和生成图像相关": "GenerateImageと関連する画像の生成のみ",
+    "代理数据解析失败": "プロキシデータの解析に失敗しました",
+    "建议使用英文单词": "英単語の使用をお勧めします",
+    "功能描述": "機能の説明",
+    "读 docs\\use_azure.md": "ドキュメントを読む",
+    "将消耗较长时间下载中文向量化模型": "中国語のベクトル化モデルをダウンロードするのに時間がかかります",
+    "表示频道ID": "チャネルIDを表示する",
+    "未知指令": "不明なコマンド",
+    "包含documentclass关键字": "documentclassキーワードを含む",
+    "中读取数据构建知识库": "データを読み取って知識ベースを構築する",
+    "远程云服务器部署": "リモートクラウドサーバーにデプロイする",
+    "输入部分太自由": "入力が自由すぎる",
+    "读取pdf文件": "PDFファイルを読み込む",
+    "将两个PDF拼接": "2つのPDFを結合する",
+    "默认值为1000": "デフォルト値は1000です",
+    "写出文件": "ファイルに書き出す",
+    "生成的视频文件路径": "生成されたビデオファイルのパス",
+    "Arixv论文精细翻译": "Arixv論文の詳細な翻訳",
+    "用latex编译为PDF对修正处做高亮": "LaTeXでコンパイルしてPDFに修正をハイライトする",
+    "点击“停止”键可终止程序": "「停止」ボタンをクリックしてプログラムを終了できます",
+    "否则将导致每个人的Claude问询历史互相渗透": "さもないと、各人のClaudeの問い合わせ履歴が相互に侵入します",
+    "音频文件名": "オーディオファイル名",
+    "的参数！": "のパラメータ！",
+    "对话历史": "対話履歴",
+    "当下一次用户提交时": "次のユーザーの提出時に",
+    "数学GenerateAnimation": "数学GenerateAnimation",
+    "如果要使用Claude": "Claudeを使用する場合は",
+    "请向下翻": "下にスクロールしてください",
+    "报告已经添加到右侧“文件上传区”": "報告は右側の「ファイルアップロードエリア」に追加されました",
+    "删除整行的空注释": "空のコメントを含む行を削除する",
+    "建议直接在API_KEY处填写": "API_KEYの場所に直接入力することをお勧めします",
+    "暗色模式 / 亮色模式": "ダークモード/ライトモード",
+    "做一些外观色彩上的调整": "外観の色調整を行う",
+    "请切换至“KnowledgeBaseQuestionAnswer”插件进行知识库访问": "ナレッジベースのアクセスには「KnowledgeBaseQuestionAnswer」プラグインに切り替えてください",
+    "它*必须*被包含在AVAIL_LLM_MODELS列表中": "それはAVAIL_LLM_MODELSリストに含まれている必要があります",
+    "并设置参数": "パラメータを設定する",
+    "待处理的word文档路径": "処理待ちのWord文書のパス",
+    "调用缓存": "キャッシュを呼び出す",
+    "片段": "フラグメント",
+    "否则结束循环": "それ以外の場合はループを終了する",
+    "请对下面的音频片段做概述": "以下のオーディオフラグメントについて概要を作成してください",
+    "高危设置! 常规情况下不要修改! 通过修改此设置": "高リスクの設定！通常は変更しないでください！この設定を変更することで",
+    "插件锁定中": "プラグインがロックされています",
+    "开始": "開始",
+    "但请查收结果": "結果を確認してください",
+    "刷新Gradio前端界面": "Gradioフロントエンドインターフェースをリフレッシュする",
+    "批量SummarizeAudioVideo": "オーディオビデオを一括要約する",
+    "一个单实例装饰器": "単一のインスタンスデコレータ",
+    "Claude响应异常": "Claudeの応答が異常です",
+    "但内部用stream的方法避免中途网线被掐": "ただし、途中でネットワーク接続が切断されることを避けるために、内部ではストリームを使用しています",
+    "检查USE_PROXY": "USE_PROXYを確認する",
+    "永远给定None": "常にNoneを指定する",
+    "报告如何远程获取": "報告のリモート取得方法",
+    "您可以到Github Issue区": "GithubのIssueエリアにアクセスできます",
+    "如果只询问1个大语言模型": "1つの大規模言語モデルにのみ質問する場合",
+    "为了防止大语言模型的意外谬误产生扩散影响": "大規模言語モデルの誤った結果が広がるのを防ぐために",
+    "编译BibTex": "BibTexのコンパイル",
+    "⭐多线程方法": "マルチスレッドの方法",
+    "推荐http": "httpをおすすめします",
+    "如果要使用": "使用する場合",
+    "的单词": "の単語",
+    "如果本地使用不建议加这个": "ローカルで使用する場合はお勧めしません",
+    "避免线程阻塞": "スレッドのブロックを回避する",
+    "吸收title与作者以上的部分": "タイトルと著者以上の部分を吸収する",
+    "作者": "著者",
+    "5刀": "5ドル",
+    "ChatGLMFT响应异常": "ChatGLMFTの応答異常",
+    "才能继续下面的步骤": "次の手順に進むために",
+    "对这个人外貌、身处的环境、内心世界、过去经历进行描写": "この人の外見、環境、内面世界、過去の経験について描写する",
+    "找不到微调模型检查点": "ファインチューニングモデルのチェックポイントが見つかりません",
+    "请仔细鉴别并以原文为准": "注意深く確認し、元のテキストを参照してください",
+    "计算文件总时长和切割点": "ファイルの総時間とカットポイントを計算する",
+    "我将为您查找相关壁纸": "関連する壁紙を検索します",
+    "此插件Windows支持最佳": "このプラグインはWindowsに最適です",
+    "请输入关键词": "キーワードを入力してください",
+    "以下所有配置也都支持利用环境变量覆写": "以下のすべての設定は環境変数を使用して上書きすることもサポートしています",
+    "尝试第": "第#",
+    "开始生成动画": "アニメーションの生成を開始します",
+    "免费": "無料",
+    "我好！": "私は元気です！",
+    "str类型": "strタイプ",
+    "生成数学动画": "数学アニメーションの生成",
+    "GPT结果已输出": "GPTの結果が出力されました",
+    "PDF文件所在的路径": "PDFファイルのパス",
+    "源码自译解": "ソースコードの自動翻訳解析",
+    "格式如org-123456789abcdefghijklmno的": "org-123456789abcdefghijklmnoの形式",
+    "请对这部分内容进行语法矫正": "この部分の内容に文法修正を行ってください",
+    "调用whisper模型音频转文字": "whisperモデルを使用して音声をテキストに変換する",
+    "编译转化后的PDF": "変換されたPDFをコンパイルする",
+    "将音频解析为简体中文": "音声を簡体字中国語に解析する",
+    "删除或修改歧义文件": "曖昧なファイルを削除または修正する",
+    "ChatGLMFT消耗大量的内存": "ChatGLMFTは大量のメモリを消費します",
+    "图像生成所用到的提示文本": "画像生成に使用されるヒントテキスト",
+    "如果已经存在": "既に存在する場合",
+    "以下是一篇学术论文的基础信息": "以下は学術論文の基本情報です",
+    "解压失败! 需要安装pip install rarfile来解压rar文件": "解凍に失敗しました！rarファイルを解凍するにはpip install rarfileをインストールする必要があります",
+    "一般是文本过长": "通常、テキストが長すぎます",
+    "单线程": "シングルスレッド",
+    "Linux下必须使用Docker安装": "LinuxではDockerを使用してインストールする必要があります",
+    "请先上传文件素材": "まずファイル素材をアップロードしてください",
+    "如果分析错误": "もし解析エラーがある場合",
+    "快捷的调试函数": "便利なデバッグ関数",
+    "欢迎使用 MOSS 人工智能助手！输入内容即可进行对话": "MOSS AIアシスタントをご利用いただきありがとうございます！入力内容を入力すると、対話ができます",
+    "json等": "jsonなど",
+    "--读取参数": "--パラメータの読み込み",
+    "⭐单线程方法": "⭐シングルスレッドメソッド",
+    "请用一句话概括这些文件的整体功能": "これらのファイルの全体的な機能を一文で要約してください",
+    "用于灵活调整复杂功能的各种参数": "複雑な機能を柔軟に調整するためのさまざまなパラメータ",
+    "默认 False": "デフォルトはFalseです",
+    "生成中文PDF": "中国語のPDFを生成する",
+    "正在处理": "処理中",
+    "需要被切割的音频文件名": "分割する必要のある音声ファイル名",
+    "根据文本使用GPT模型生成相应的图像": "テキストに基づいてGPTモデルを使用して対応する画像を生成する",
+    "可选": "オプション",
+    "Aliyun音频服务异常": "Aliyunオーディオサービスの異常",
+    "尝试下载": "ダウンロードを試みる",
+    "需Latex": "LaTeXが必要です",
+    "拆分过长的Markdown文件": "長すぎるMarkdownファイルを分割する",
+    "当前支持的格式包括": "現在サポートされている形式には",
+    "=================================== 工具函数 ===============================================": "=================================== ユーティリティ関数 ===============================================",
+    "所有音频都总结完成了吗": "すべてのオーディオが要約されましたか",
+    "没有设置ANTHROPIC_API_KEY": "ANTHROPIC_API_KEYが設定されていません",
+    "详见项目主README.md": "詳細はプロジェクトのメインREADME.mdを参照してください",
+    "使用": "使用する",
+    "P.S. 其他可用的模型还包括": "P.S. 其他可用的模型还包括",
+    "保证括号正确": "保证括号正确",
+    "或代理节点": "或代理节点",
+    "整理结果为压缩包": "整理结果为压缩包",
+    "实时音频采集": "实时音频采集",
+    "获取回复": "获取回复",
+    "插件可读取“输入区”文本/路径作为参数": "插件可读取“输入区”文本/路径作为参数",
+    "请讲话": "请讲话",
+    "将文件复制一份到下载区": "将文件复制一份到下载区",
+    "from crazy_functions.虚空终端 import 终端": "from crazy_functions.虚空终端 import 终端",
+    "这个paper有个input命令文件名大小写错误！": "这个paper有个input命令文件名大小写错误！",
+    "解除插件锁定": "解除插件锁定",
+    "不能加载Claude组件": "不能加载Claude组件",
+    "如果有必要": "如果有必要",
+    "禁止移除或修改此警告": "禁止移除或修改此警告",
+    "然后进行问答": "然后进行问答",
+    "响应异常": "响应异常",
+    "使用英文": "使用英文",
+    "add gpt task 创建子线程请求gpt": "add gpt task 创建子线程请求gpt",
+    "实际得到格式": "实际得到格式",
+    "请继续分析其他源代码": "请继续分析其他源代码",
+    "”的主要内容": "”的主要内容",
+    "防止proxies单独起作用": "防止proxies单独起作用",
+    "临时地激活代理网络": "临时地激活代理网络",
+    "屏蔽空行和太短的句子": "屏蔽空行和太短的句子",
+    "把某个路径下所有文件压缩": "把某个路径下所有文件压缩",
+    "您需要首先调用构建知识库": "您需要首先调用构建知识库",
+    "翻译-": "翻译-",
+    "Newbing 请求失败": "Newbing 请求失败",
+    "次编译": "次编译",
+    "后缀": "后缀",
+    "文本碎片重组为完整的tex片段": "文本碎片重组为完整的tex片段",
+    "待注入的知识库名称id": "待注入的知识库名称id",
+    "消耗时间的函数": "消耗时间的函数",
+    "You are associated with a deactivated account. OpenAI以账户失效为由": "You are associated with a deactivated account. OpenAI以账户失效为由",
+    "成功啦": "成功啦",
+    "音频文件的路径": "音频文件的路径",
+    "英文Latex项目全文纠错": "英文Latex项目全文纠错",
+    "将子线程的gpt结果写入chatbot": "将子线程的gpt结果写入chatbot",
+    "开始最终总结": "开始最终总结",
+    "调用": "调用",
+    "正在锁定插件": "正在锁定插件",
+    "记住当前的label": "记住当前的label",
+    "根据自然语言执行插件命令": "根据自然语言执行插件命令",
+    "response中会携带traceback报错信息": "response中会携带traceback报错信息",
+    "避免多用户干扰": "避免多用户干扰",
+    "顺利完成": "顺利完成",
+    "详情见https": "详情见https",
+    "清空label": "ラベルをクリアする",
+    "这需要一段时间计算": "これには時間がかかります",
+    "找不到": "見つかりません",
+    "消耗大量的内存": "大量のメモリを消費する",
+    "安装方法https": "インストール方法https",
+    "为发送请求做准备": "リクエストの準備をする",
+    "第1次尝试": "1回目の試み",
+    "检查结果": "結果をチェックする",
+    "精细切分latex文件": "LaTeXファイルを細かく分割する",
+    "api2d等请求源": "api2dなどのリクエストソース",
+    "填入你亲手写的部署名": "あなたが手書きしたデプロイ名を入力してください",
+    "给出指令": "指示を与える",
+    "请问什么是质子": "プロトンとは何ですか",
+    "请直接去该路径下取回翻译结果": "直接そのパスに移動して翻訳結果を取得してください",
+    "等待Claude回复的片段": "Claudeの返信を待っているフラグメント",
+    "Latex没有安装": "LaTeXがインストールされていません",
+    "文档越长耗时越长": "ドキュメントが長いほど時間がかかります",
+    "没有阿里云语音识别APPKEY和TOKEN": "阿里雲の音声認識のAPPKEYとTOKENがありません",
+    "分析结果": "結果を分析する",
+    "请立即终止程序": "プログラムを即座に終了してください",
+    "正在尝试自动安装": "自動インストールを試みています",
+    "请直接提交即可": "直接提出してください",
+    "将指定目录下的PDF文件从英文翻译成中文": "指定されたディレクトリ内のPDFファイルを英語から中国語に翻訳する",
+    "请查收结果": "結果を確認してください",
+    "上下布局": "上下布局",
+    "此处可以输入解析提示": "此处可以输入解析提示",
+    "前面是中文逗号": "前面是中文逗号",
+    "的依赖": "的依赖",
+    "材料如下": "材料如下",
+    "欢迎加REAME中的QQ联系开发者": "欢迎加REAME中的QQ联系开发者",
+    "开始下载": "開始ダウンロード",
+    "100字以内": "100文字以内",
+    "创建request": "リクエストの作成",
+    "创建存储切割音频的文件夹": "切り取られた音声を保存するフォルダの作成",
+    "⭐主进程执行": "⭐メインプロセスの実行",
+    "音频解析结果": "音声解析結果",
+    "Your account is not active. OpenAI以账户失效为由": "アカウントがアクティブではありません。OpenAIはアカウントの無効化を理由にしています",
+    "虽然PDF生成失败了": "PDFの生成に失敗しました",
+    "如果这里报错": "ここでエラーが発生した場合",
+    "前面是中文冒号": "前面は中国語のコロンです",
+    "SummarizeAudioVideo内容": "SummarizeAudioVideoの内容",
+    "openai的官方KEY需要伴随组织编码": "openaiの公式KEYは組織コードと一緒に必要です",
+    "是本次输入": "これは今回の入力です",
+    "色彩主体": "色彩の主体",
+    "Markdown翻译": "Markdownの翻訳",
+    "会被加在你的输入之后": "あなたの入力の後に追加されます",
+    "失败啦": "失敗しました",
+    "每个切割音频片段的时长": "各切り取り音声の長さ",
+    "拆分过长的latex片段": "原始文本",
+    "待提取的知识库名称id": "原始文本",
+    "在这里放一些网上搜集的demo": "原始文本",
+    "环境变量配置格式见docker-compose.yml": "原始文本",
+    "Claude组件初始化成功": "原始文本",
+    "尚未加载": "原始文本",
+    "等待Claude响应": "原始文本",
+    "重组": "原始文本",
+    "将文件添加到chatbot cookie中": "原始文本",
+    "回答完问题后": "原始文本",
+    "将根据报错信息修正tex源文件并重试": "原始文本",
+    "是否在触发时清除历史": "原始文本",
+    "尝试执行Latex指令失败": "原始文本",
+    "默认 True": "原始文本",
+    "文本碎片重组为完整的tex文件": "原始文本",
+    "注意事项": "原始文本",
+    "您接下来不能再使用其他插件了": "原始文本",
+    "属性": "原始文本",
+    "正在编译PDF文档": "原始文本",
+    "提取视频中的音频": "原始文本",
+    "正在同时咨询ChatGPT和ChatGLM……": "原始文本",
+    "Chuanhu-Small-and-Beautiful主题": "原始文本",
+    "版权归原文作者所有": "原始文本",
+    "如果程序停顿5分钟以上": "原始文本",
+    "请输入要翻译成哪种语言": "日本語",
+    "以秒为单位": "秒単位で",
+    "请以以下方式load模型！！！": "以下の方法でモデルをロードしてください！！！",
+    "使用时": "使用時",
+    "对这个人外貌、身处的环境、内心世界、人设进行描写": "この人の外見、環境、内面世界、キャラクターを描写する",
+    "例如翻译、解释代码、润色等等": "例えば翻訳、コードの説明、修正など",
+    "多线程Demo": "マルチスレッドデモ",
+    "不能正常加载": "正常にロードできません",
+    "还原部分原文": "一部の元のテキストを復元する",
+    "可以将自身的状态存储到cookie中": "自身の状態をcookieに保存することができます",
+    "释放线程锁": "スレッドロックを解放する",
+    "当前知识库内的有效文件": "現在のナレッジベース内の有効なファイル",
+    "也是可读的": "読み取り可能です",
+    "等待ChatGLMFT响应中": "ChatGLMFTの応答を待っています",
+    "输入 stop 以终止对话": "stopを入力して対話を終了します",
+    "对整个Latex项目进行纠错": "全体のLatexプロジェクトを修正する",
+    "报错信息": "エラーメッセージ",
+    "下载pdf文件未成功": "PDFファイルのダウンロードに失敗しました",
+    "正在加载Claude组件": "Claudeコンポーネントを読み込んでいます",
+    "格式": "フォーマット",
+    "Claude响应缓慢": "Claudeの応答が遅い",
+    "该选项即将被弃用": "このオプションはまもなく廃止されます",
+    "正常状态": "正常な状態",
+    "中文Bing版": "中国語Bing版",
+    "代理网络配置": "プロキシネットワークの設定",
+    "Openai 限制免费用户每分钟20次请求": "Openaiは無料ユーザーに対して1分間に20回のリクエスト制限を設けています",
+    "gpt写的": "gptで書かれた",
+    "向已打开的频道发送一条文本消息": "既に開いているチャンネルにテキストメッセージを送信する",
+    "缺少ChatGLMFT的依赖": "ChatGLMFTの依存関係が不足しています",
+    "注意目前不能多人同时调用Claude接口": "現在、複数の人が同時にClaudeインターフェースを呼び出すことはできません",
+    "或者不在环境变量PATH中": "または環境変数PATHに存在しません",
+    "提问吧! 但注意": "質問してください！ただし注意してください",
+    "因此选择GenerateImage函数": "したがって、GenerateImage関数を選択します",
+    "无法找到一个主Tex文件": "メインのTexファイルが見つかりません",
+    "转化PDF编译已经成功": "PDF変換コンパイルが成功しました",
+    "因为在同一个频道里存在多人使用时历史消息渗透问题": "同じチャンネルで複数の人が使用する場合、過去のメッセージが漏洩する問題があります",
+    "SlackClient类用于与Slack API进行交互": "SlackClientクラスはSlack APIとのインタラクションに使用されます",
+    "如果存在调试缓存文件": "デバッグキャッシュファイルが存在する場合",
+    "举例": "例を挙げる",
+    "无需填写": "記入する必要はありません",
+    "配置教程&视频教程": "設定チュートリアル＆ビデオチュートリアル",
+    "最后一步处理": "最後のステップの処理",
+    "定位主Latex文件": "メインのLatexファイルを特定する",
+    "暂不提交": "一時的に提出しない",
+    "由于最为关键的转化PDF编译失败": "最も重要なPDF変換コンパイルが失敗したため",
+    "用第二人称": "第二人称を使用する",
+    "例如 RoPlZrM88DnAFkZK": "例えば RoPlZrM88DnAFkZK",
+    "没有设置ANTHROPIC_API_KEY选项": "ANTHROPIC_API_KEYオプションが設定されていません",
+    "找不到任何.tex文件": "テキストの翻訳",
+    "请您不要删除或修改这行警告": "テキストの翻訳",
+    "只有第二步成功": "テキストの翻訳",
+    "调用Claude时": "テキストの翻訳",
+    "输入 clear 以清空对话历史": "テキストの翻訳",
+    "= 2 通过一些Latex模板中常见": "テキストの翻訳",
+    "没给定指令": "テキストの翻訳",
+    "还原原文": "テキストの翻訳",
+    "自定义API KEY格式": "テキストの翻訳",
+    "防止丢失最后一条消息": "テキストの翻訳",
+    "方法": "テキストの翻訳",
+    "压缩包": "テキストの翻訳",
+    "对各个llm模型进行单元测试": "テキストの翻訳",
+    "导入依赖失败": "テキストの翻訳",
+    "详情信息见requirements.txt": "テキストの翻訳",
+    "翻译内容可靠性无保障": "テキストの翻訳",
+    "刷新页面即可以退出KnowledgeBaseQuestionAnswer模式": "テキストの翻訳",
+    "上传本地文件/压缩包供函数插件调用": "テキストの翻訳",
+    "循环监听已打开频道的消息": "テキストの翻訳",
+    "一个包含所有切割音频片段文件路径的列表": "テキストの翻訳",
+    "检测到arxiv文档连接": "テキストの翻訳",
+    "P.S. 顺便把CTEX塞进去以支持中文": "テキストの翻訳",
+    "后面是英文冒号": "テキストの翻訳",
+    "上传文件自动修正路径": "テキストの翻訳",
+    "实现消息发送、接收等功能": "メッセージの送受信などの機能を実現する",
+    "改变输入参数的顺序与结构": "入力パラメータの順序と構造を変更する",
+    "正在精细切分latex文件": "LaTeXファイルを細かく分割しています",
+    "读取文件": "ファイルを読み込んでいます"
 }

docs/translate_std.json

@@ -0,0 +1,87 @@
+{
+    "解析JupyterNotebook": "ParsingJupyterNotebook",
+    "Latex翻译中文并重新编译PDF": "TranslateChineseToEnglishInLatexAndRecompilePDF",
+    "联网的ChatGPT_bing版": "OnlineChatGPT_BingEdition",
+    "理解PDF文档内容标准文件输入": "UnderstandPdfDocumentContentStandardFileInput",
+    "Latex英文纠错加PDF对比": "CorrectEnglishInLatexWithPDFComparison",
+    "下载arxiv论文并翻译摘要": "DownloadArxivPaperAndTranslateAbstract",
+    "Markdown翻译指定语言": "TranslateMarkdownToSpecifiedLanguage",
+    "批量翻译PDF文档_多线程": "BatchTranslatePDFDocuments_MultiThreaded",
+    "下载arxiv论文翻译摘要": "DownloadArxivPaperTranslateAbstract",
+    "解析一个Python项目": "ParsePythonProject",
+    "解析一个Golang项目": "ParseGolangProject",
+    "代码重写为全英文_多线程": "RewriteCodeToEnglish_MultiThreaded",
+    "解析一个CSharp项目": "ParsingCSharpProject",
+    "删除所有本地对话历史记录": "DeleteAllLocalConversationHistoryRecords",
+    "批量Markdown翻译": "BatchTranslateMarkdown",
+    "连接bing搜索回答问题": "ConnectBingSearchAnswerQuestion",
+    "Langchain知识库": "LangchainKnowledgeBase",
+    "Latex输出PDF结果": "OutputPDFFromLatex",
+    "把字符太少的块清除为回车": "ClearBlocksWithTooFewCharactersToNewline",
+    "Latex精细分解与转化": "DecomposeAndConvertLatex",
+    "解析一个C项目的头文件": "ParseCProjectHeaderFiles",
+    "Markdown英译中": "TranslateMarkdownFromEnglishToChinese",
+    "Markdown中译英": "MarkdownChineseToEnglish",
+    "数学动画生成manim": "MathematicalAnimationGenerationManim",
+    "chatglm微调工具": "ChatGLMFineTuningTool",
+    "解析一个Rust项目": "ParseRustProject",
+    "解析一个Java项目": "ParseJavaProject",
+    "联网的ChatGPT": "ChatGPTConnectedToNetwork",
+    "解析任意code项目": "ParseAnyCodeProject",
+    "合并小写开头的段落块": "MergeLowercaseStartingParagraphBlocks",
+    "Latex英文润色": "EnglishProofreadingForLatex",
+    "Latex全文润色": "FullTextProofreadingForLatex",
+    "询问多个大语言模型": "InquiryMultipleLargeLanguageModels",
+    "解析一个Lua项目": "ParsingLuaProject",
+    "解析ipynb文件": "ParsingIpynbFiles",
+    "批量总结PDF文档": "BatchSummarizePDFDocuments",
+    "批量翻译PDF文档": "BatchTranslatePDFDocuments",
+    "理解PDF文档内容": "UnderstandPdfDocumentContent",
+    "Latex中文润色": "LatexChineseProofreading",
+    "Latex英文纠错": "LatexEnglishCorrection",
+    "Latex全文翻译": "LatexFullTextTranslation",
+    "同时问询_指定模型": "InquireSimultaneously_SpecifiedModel",
+    "批量生成函数注释": "BatchGenerateFunctionComments",
+    "解析一个前端项目": "ParseFrontendProject",
+    "高阶功能模板函数": "HighOrderFunctionTemplateFunctions",
+    "高级功能函数模板": "AdvancedFunctionTemplate",
+    "总结word文档": "SummarizingWordDocuments",
+    "载入对话历史存档": "LoadConversationHistoryArchive",
+    "Latex中译英": "LatexChineseToEnglish",
+    "Latex英译中": "LatexEnglishToChinese",
+    "连接网络回答问题": "ConnectToNetworkToAnswerQuestions",
+    "交互功能模板函数": "InteractiveFunctionTemplateFunction",
+    "交互功能函数模板": "InteractiveFunctionFunctionTemplate",
+    "sprint亮靛": "SprintIndigo",
+    "print亮黄": "PrintBrightYellow",
+    "print亮绿": "PrintBrightGreen",
+    "print亮红": "PrintBrightRed",
+    "解析项目源代码": "ParseProjectSourceCode",
+    "解析一个C项目": "ParseCProject",
+    "全项目切换英文": "SwitchToEnglishForTheWholeProject",
+    "谷歌检索小助手": "GoogleSearchAssistant",
+    "读取知识库作答": "ReadKnowledgeArchiveAnswerQuestions",
+    "print亮蓝": "PrintBrightBlue",
+    "微调数据集生成": "FineTuneDatasetGeneration",
+    "清理多余的空行": "CleanUpExcessBlankLines",
+    "编译Latex": "CompileLatex",
+    "解析Paper": "ParsePaper",
+    "ipynb解释": "IpynbExplanation",
+    "读文章写摘要": "ReadArticleWriteSummary",
+    "生成函数注释": "GenerateFunctionComments",
+    "解析项目本身": "ParseProjectItself",
+    "对话历史存档": "ConversationHistoryArchive",
+    "专业词汇声明": "ProfessionalTerminologyDeclaration",
+    "解析docx": "ParseDocx",
+    "解析源代码新": "ParsingSourceCodeNew",
+    "总结音视频": "SummaryAudioVideo",
+    "知识库问答": "UpdateKnowledgeArchive",
+    "多文件润色": "ProofreadMultipleFiles",
+    "多文件翻译": "TranslateMultipleFiles",
+    "解析PDF": "ParsePDF",
+    "同时问询": "SimultaneousInquiry",
+    "图片生成": "ImageGeneration",
+    "动画生成": "AnimationGeneration",
+    "语音助手": "VoiceAssistant",
+    "启动微调": "StartFineTuning"
+}

docs/translate_traditionalchinese.json

@@ -2213,5 +2213,66 @@
     "“喂狗”": "“喂狗”",
     "第4步": "第4步",
     "退出": "退出",
-    "使用 Unsplash API": "使用 Unsplash API"
+    "使用 Unsplash API": "使用 Unsplash API",
+    "非Openai官方接口返回了错误": "非Openai官方接口返回了错误",
+    "用来描述你的要求": "用來描述你的要求",
+    "自定义API KEY格式": "自定義API KEY格式",
+    "前缀": "前綴",
+    "会被加在你的输入之前": "會被加在你的輸入之前",
+    "api2d等请求源": "api2d等請求源",
+    "高危设置! 常规情况下不要修改! 通过修改此设置": "高危設置！常規情況下不要修改！通過修改此設置",
+    "即将编译PDF": "即將編譯PDF",
+    "默认 secondary": "默認 secondary",
+    "正在从github下载资源": "正在從github下載資源",
+    "响应异常": "響應異常",
+    "我好！": "我好！",
+    "无需填写": "無需填寫",
+    "缺少": "缺少",
+    "请问什么是质子": "請問什麼是質子",
+    "如果要使用": "如果要使用",
+    "重组": "重組",
+    "一个单实例装饰器": "一個單實例裝飾器",
+    "的参数！": "的參數！",
+    "🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行": "🏃‍♂️🏃‍♂️🏃‍♂️ 子進程執行",
+    "失败时": "失敗時",
+    "没有设置ANTHROPIC_API_KEY选项": "沒有設置ANTHROPIC_API_KEY選項",
+    "并设置参数": "並設置參數",
+    "格式": "格式",
+    "按钮是否可见": "按鈕是否可見",
+    "即可见": "即可見",
+    "创建request": "創建request",
+    "的依赖": "的依賴",
+    "⭐主进程执行": "⭐主進程執行",
+    "最后一步处理": "最後一步處理",
+    "没有设置ANTHROPIC_API_KEY": "沒有設置ANTHROPIC_API_KEY",
+    "的参数": "的參數",
+    "逆转出错的段落": "逆轉出錯的段落",
+    "本项目现已支持OpenAI和Azure的api-key": "本項目現已支持OpenAI和Azure的api-key",
+    "前者是API2D的结束条件": "前者是API2D的結束條件",
+    "增强稳健性": "增強穩健性",
+    "消耗大量的内存": "消耗大量的內存",
+    "您的 API_KEY 不满足任何一种已知的密钥格式": "您的API_KEY不滿足任何一種已知的密鑰格式",
+    "⭐单线程方法": "⭐單線程方法",
+    "是否在触发时清除历史": "是否在觸發時清除歷史",
+    "⭐多线程方法": "多線程方法",
+    "不能正常加载": "無法正常加載",
+    "举例": "舉例",
+    "即不处理之前的对话历史": "即不處理之前的對話歷史",
+    "尚未加载": "尚未加載",
+    "防止proxies单独起作用": "防止proxies單獨起作用",
+    "默认 False": "默認 False",
+    "检查USE_PROXY": "檢查USE_PROXY",
+    "响应中": "響應中",
+    "扭转的范围": "扭轉的範圍",
+    "后缀": "後綴",
+    "调用": "調用",
+    "创建AcsClient实例": "創建AcsClient實例",
+    "安装": "安裝",
+    "会被加在你的输入之后": "會被加在你的輸入之後",
+    "配合前缀可以把你的输入内容用引号圈起来": "配合前綴可以把你的輸入內容用引號圈起來",
+    "例如翻译、解释代码、润色等等": "例如翻譯、解釋代碼、潤色等等",
+    "后者是OPENAI的结束条件": "後者是OPENAI的結束條件",
+    "标注节点的行数范围": "標註節點的行數範圍",
+    "默认 True": "默認 True",
+    "将两个PDF拼接": "將兩個PDF拼接"
 }

docs/use_audio.md

@@ -28,6 +28,16 @@ ALIYUN_APPKEY = "RoPlZrM88DnAFkZK"   # 此appkey已经失效
 参考 https://help.aliyun.com/document_detail/450255.html
 先有阿里云开发者账号，登录之后，需要开通 智能语音交互 的功能，可以免费获得一个token，然后在 全部项目 中，创建一个项目，可以获得一个appkey.
 
+- 进阶功能
+进一步填写ALIYUN_ACCESSKEY和ALIYUN_SECRET实现自动获取ALIYUN_TOKEN
+```
+ALIYUN_APPKEY = "RoP1ZrM84DnAFkZK"
+ALIYUN_TOKEN = ""
+ALIYUN_ACCESSKEY = "LTAI5q6BrFUzoRXVGUWnekh1"
+ALIYUN_SECRET = "eHmI20AVWIaQZ0CiTD2bGQVsaP9i68"
+```
+
+
 ## 3.启动
 
 启动gpt-academic `python main.py`
@@ -48,7 +58,7 @@ III `[把特殊软件（如腾讯会议）的外放声音用VoiceMeeter截留]`
 
 VI 两种音频监听模式切换时，需要刷新页面才有效。
 
+VII 非localhost运行+非https情况下无法打开录音功能的坑：https://blog.csdn.net/weixin_39461487/article/details/109594434
+
 ## 5.点击函数插件区“实时音频采集” 或者其他音频交互功能
 
-
-

main.py

@@ -6,18 +6,18 @@ 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, load_chat_cookies, DummyWith
     # 建议您复制一个config_private.py放自己的秘密, 如API和代理网址, 避免不小心传github被别人看到
-    proxies, WEB_PORT, LLM_MODEL, CONCURRENT_COUNT, AUTHENTICATION, CHATBOT_HEIGHT, LAYOUT, AVAIL_LLM_MODELS, AUTO_CLEAR_TXT = \
-        get_conf('proxies', 'WEB_PORT', 'LLM_MODEL', 'CONCURRENT_COUNT', 'AUTHENTICATION', 'CHATBOT_HEIGHT', 'LAYOUT', 'AVAIL_LLM_MODELS', 'AUTO_CLEAR_TXT')
+    proxies, WEB_PORT, LLM_MODEL, CONCURRENT_COUNT, AUTHENTICATION = get_conf('proxies', 'WEB_PORT', 'LLM_MODEL', 'CONCURRENT_COUNT', 'AUTHENTICATION')
+    CHATBOT_HEIGHT, LAYOUT, AVAIL_LLM_MODELS, AUTO_CLEAR_TXT = get_conf('CHATBOT_HEIGHT', 'LAYOUT', 'AVAIL_LLM_MODELS', 'AUTO_CLEAR_TXT')
     ENABLE_AUDIO, AUTO_CLEAR_TXT = get_conf('ENABLE_AUDIO', 'AUTO_CLEAR_TXT')
+
     # 如果WEB_PORT是-1, 则随机选取WEB端口
     PORT = find_free_port() if WEB_PORT <= 0 else WEB_PORT
-    if not AUTHENTICATION: AUTHENTICATION = None
-
     from check_proxy import get_current_version
     from themes.theme import adjust_theme, advanced_css, theme_declaration
     initial_prompt = "Serve me as a writing and programming assistant."
     title_html = f"<h1 align=\"center\">GPT 学术优化 {get_current_version()}</h1>{theme_declaration}"
-    description =  """代码开源和更新[地址🚀](https://github.com/binary-husky/chatgpt_academic)，感谢热情的[开发者们❤️](https://github.com/binary-husky/chatgpt_academic/graphs/contributors)"""
+    description =  "代码开源和更新[地址🚀](https://github.com/binary-husky/gpt_academic)，"
+    description += "感谢热情的[开发者们❤️](https://github.com/binary-husky/gpt_academic/graphs/contributors)"
 
     # 问询记录, python 版本建议3.9+（越新越好）
     import logging, uuid
@@ -34,7 +34,10 @@ def main():
 
     # 高级函数插件
     from crazy_functional import get_crazy_functions
-    crazy_fns = get_crazy_functions()
+    DEFAULT_FN_GROUPS, = get_conf('DEFAULT_FN_GROUPS')
+    plugins = get_crazy_functions()
+    all_plugin_groups = list(set([g for _, plugin in plugins.items() for g in plugin['Group'].split('|')]))
+    match_group = lambda tags, groups: any([g in groups for g in tags.split('|')])
 
     # 处理markdown文本格式的转变
     gr.Chatbot.postprocess = format_io
@@ -83,25 +86,33 @@ def main():
                             if ("Visible" in functional[k]) and (not functional[k]["Visible"]): continue
                             variant = functional[k]["Color"] if "Color" in functional[k] else "secondary"
                             functional[k]["Button"] = gr.Button(k, variant=variant)
+                            functional[k]["Button"].style(size="sm")
                 with gr.Accordion("函数插件区", open=True, elem_id="plugin-panel") as area_crazy_fn:
                     with gr.Row():
                         gr.Markdown("插件可读取“输入区”文本/路径作为参数（上传文件自动修正路径）")
+                    with gr.Row(elem_id="input-plugin-group"):
+                        plugin_group_sel = gr.Dropdown(choices=all_plugin_groups, label='', show_label=False, value=DEFAULT_FN_GROUPS, 
+                                                      multiselect=True, interactive=True, elem_classes='normal_mut_select').style(container=False)
                     with gr.Row():
-                        for k in crazy_fns:
-                            if not crazy_fns[k].get("AsButton", True): continue
-                            variant = crazy_fns[k]["Color"] if "Color" in crazy_fns[k] else "secondary"
-                            crazy_fns[k]["Button"] = gr.Button(k, variant=variant)
-                            crazy_fns[k]["Button"].style(size="sm")
+                        for k, plugin in plugins.items():
+                            if not plugin.get("AsButton", True): continue
+                            visible = True if match_group(plugin['Group'], DEFAULT_FN_GROUPS) else False
+                            variant = plugins[k]["Color"] if "Color" in plugin else "secondary"
+                            plugin['Button'] = plugins[k]['Button'] = gr.Button(k, variant=variant, visible=visible).style(size="sm")
                     with gr.Row():
                         with gr.Accordion("更多函数插件", open=True):
-                            dropdown_fn_list = [k for k in crazy_fns.keys() if not crazy_fns[k].get("AsButton", True)]
+                            dropdown_fn_list = []
+                            for k, plugin in plugins.items():
+                                if not match_group(plugin['Group'], DEFAULT_FN_GROUPS): continue
+                                if not plugin.get("AsButton", True): dropdown_fn_list.append(k)     # 排除已经是按钮的插件
+                                elif plugin.get('AdvancedArgs', False): dropdown_fn_list.append(k)  # 对于需要高级参数的插件，亦在下拉菜单中显示
                             with gr.Row():
                                 dropdown = gr.Dropdown(dropdown_fn_list, value=r"打开插件列表", label="", show_label=False).style(container=False)
                             with gr.Row():
                                 plugin_advanced_arg = gr.Textbox(show_label=True, label="高级参数输入区", visible=False, 
                                                                  placeholder="这里是特殊函数插件的高级参数输入区").style(container=False)
                             with gr.Row():
-                                switchy_bt = gr.Button(r"请先从插件列表中选择", variant="secondary")
+                                switchy_bt = gr.Button(r"请先从插件列表中选择", variant="secondary").style(size="sm")
                     with gr.Row():
                         with gr.Accordion("点击展开“文件上传区”。上传本地文件/压缩包供函数插件调用。", open=False) as area_file_up:
                             file_upload = gr.Files(label="任何文件, 但推荐上传压缩文件(zip, tar)", file_count="multiple")
@@ -112,7 +123,6 @@ def main():
                     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)
-
                     gr.Markdown(description)
                 with gr.Accordion("备选输入区", open=True, visible=False, elem_id="input-panel2") as area_input_secondary:
                     with gr.Row():
@@ -123,6 +133,7 @@ def main():
                         resetBtn2 = gr.Button("重置", variant="secondary"); resetBtn2.style(size="sm")
                         stopBtn2 = gr.Button("停止", variant="secondary"); stopBtn2.style(size="sm")
                         clearBtn2 = gr.Button("清除", variant="secondary", visible=False); clearBtn2.style(size="sm")
+
         # 功能区显示开关与功能区的互动
         def fn_area_visibility(a):
             ret = {}
@@ -160,19 +171,19 @@ def main():
             click_handle = functional[k]["Button"].click(fn=ArgsGeneralWrapper(predict), inputs=[*input_combo, gr.State(True), gr.State(k)], outputs=output_combo)
             cancel_handles.append(click_handle)
         # 文件上传区，接收文件后与chatbot的互动
-        file_upload.upload(on_file_uploaded, [file_upload, chatbot, txt, txt2, checkboxes], [chatbot, txt, txt2])
+        file_upload.upload(on_file_uploaded, [file_upload, chatbot, txt, txt2, checkboxes, cookies], [chatbot, txt, txt2, cookies])
         # 函数插件-固定按钮区
-        for k in crazy_fns:
-            if not crazy_fns[k].get("AsButton", True): continue
-            click_handle = crazy_fns[k]["Button"].click(ArgsGeneralWrapper(crazy_fns[k]["Function"]), [*input_combo, gr.State(PORT)], output_combo)
+        for k in plugins:
+            if not plugins[k].get("AsButton", True): continue
+            click_handle = plugins[k]["Button"].click(ArgsGeneralWrapper(plugins[k]["Function"]), [*input_combo, gr.State(PORT)], output_combo)
             click_handle.then(on_report_generated, [cookies, file_upload, chatbot], [cookies, file_upload, chatbot])
             cancel_handles.append(click_handle)
         # 函数插件-下拉菜单与随变按钮的互动
         def on_dropdown_changed(k):
-            variant = crazy_fns[k]["Color"] if "Color" in crazy_fns[k] else "secondary"
+            variant = plugins[k]["Color"] if "Color" in plugins[k] else "secondary"
             ret = {switchy_bt: gr.update(value=k, variant=variant)}
-            if crazy_fns[k].get("AdvancedArgs", False): # 是否唤起高级插件参数区
-                ret.update({plugin_advanced_arg: gr.update(visible=True,  label=f"插件[{k}]的高级参数说明：" + crazy_fns[k].get("ArgsReminder", [f"没有提供高级参数功能说明"]))})
+            if plugins[k].get("AdvancedArgs", False): # 是否唤起高级插件参数区
+                ret.update({plugin_advanced_arg: gr.update(visible=True,  label=f"插件[{k}]的高级参数说明：" + plugins[k].get("ArgsReminder", [f"没有提供高级参数功能说明"]))})
             else:
                 ret.update({plugin_advanced_arg: gr.update(visible=False, label=f"插件[{k}]不需要高级参数。")})
             return ret
@@ -183,13 +194,26 @@ def main():
         # 随变按钮的回调函数注册
         def route(request: gr.Request, k, *args, **kwargs):
             if k in [r"打开插件列表", r"请先从插件列表中选择"]: return
-            yield from ArgsGeneralWrapper(crazy_fns[k]["Function"])(request, *args, **kwargs)
+            yield from ArgsGeneralWrapper(plugins[k]["Function"])(request, *args, **kwargs)
         click_handle = switchy_bt.click(route,[switchy_bt, *input_combo, gr.State(PORT)], output_combo)
         click_handle.then(on_report_generated, [cookies, file_upload, chatbot], [cookies, file_upload, chatbot])
         cancel_handles.append(click_handle)
         # 终止按钮的回调函数注册
         stopBtn.click(fn=None, inputs=None, outputs=None, cancels=cancel_handles)
         stopBtn2.click(fn=None, inputs=None, outputs=None, cancels=cancel_handles)
+        plugins_as_btn = {name:plugin for name, plugin in plugins.items() if plugin.get('Button', None)}
+        def on_group_change(group_list):
+            btn_list = []
+            fns_list = []
+            if not group_list: # 处理特殊情况：没有选择任何插件组
+                return [*[plugin['Button'].update(visible=False) for _, plugin in plugins_as_btn.items()], gr.Dropdown.update(choices=[])]
+            for k, plugin in plugins.items():
+                if plugin.get("AsButton", True): 
+                    btn_list.append(plugin['Button'].update(visible=match_group(plugin['Group'], group_list))) # 刷新按钮
+                    if plugin.get('AdvancedArgs', False): dropdown_fn_list.append(k) # 对于需要高级参数的插件，亦在下拉菜单中显示
+                elif match_group(plugin['Group'], group_list): fns_list.append(k) # 刷新下拉列表
+            return [*btn_list, gr.Dropdown.update(choices=fns_list)]
+        plugin_group_sel.select(fn=on_group_change, inputs=[plugin_group_sel], outputs=[*[plugin['Button'] for name, plugin in plugins_as_btn.items()], dropdown])
         if ENABLE_AUDIO: 
             from crazy_functions.live_audio.audio_io import RealtimeAudioDistribution
             rad = RealtimeAudioDistribution()
@@ -221,8 +245,10 @@ def main():
 
     auto_opentab_delay()
     demo.queue(concurrency_count=CONCURRENT_COUNT).launch(
-        server_name="0.0.0.0", server_port=PORT,
-        favicon_path="docs/logo.png", auth=AUTHENTICATION,
+        server_name="0.0.0.0", 
+        server_port=PORT,
+        favicon_path="docs/logo.png", 
+        auth=AUTHENTICATION if len(AUTHENTICATION) != 0 else None,
         blocked_paths=["config.py","config_private.py","docker-compose.yml","Dockerfile"])
 
     # 如果需要在二级路径下运行

multi_language.py

@@ -3,16 +3,18 @@
     
     
     Usage:
-        1. modify LANG
+        1. modify config.py, set your LLM_MODEL and API_KEY(s) to provide access to OPENAI (or any other LLM model provider)
+
+        2. modify LANG (below ↓)
             LANG = "English"
 
-        2. modify TransPrompt
+        3. modify TransPrompt (below ↓)
             TransPrompt = f"Replace each json value `#` with translated results in English, e.g., \"原始文本\":\"TranslatedText\". Keep Json format. Do not answer #."
 
-        3. Run `python multi_language.py`. 
+        4. Run `python multi_language.py`. 
             Note: You need to run it multiple times to increase translation coverage because GPT makes mistakes sometimes.
 
-        4. Find the translated program in `multi-language\English\*`
+        5. Find the translated program in `multi-language\English\*`
    
     P.S.
     
@@ -286,6 +288,7 @@ def trans_json(word_to_translate, language, special=False):
 
 
 def step_1_core_key_translate():
+    LANG_STD = 'std'
     def extract_chinese_characters(file_path):
         syntax = []
         with open(file_path, 'r', encoding='utf-8') as f:
@@ -325,15 +328,15 @@ def step_1_core_key_translate():
     for d in chinese_core_keys:
         if d not in chinese_core_keys_norepeat: chinese_core_keys_norepeat.append(d)
     need_translate = []
-    cached_translation = read_map_from_json(language=LANG)
+    cached_translation = read_map_from_json(language=LANG_STD)
     cached_translation_keys = list(cached_translation.keys())
     for d in chinese_core_keys_norepeat:
         if d not in cached_translation_keys: 
             need_translate.append(d)
 
-    need_translate_mapping = trans(need_translate, language=LANG, special=True)
-    map_to_json(need_translate_mapping, language=LANG)
-    cached_translation = read_map_from_json(language=LANG)
+    need_translate_mapping = trans(need_translate, language=LANG_STD, special=True)
+    map_to_json(need_translate_mapping, language=LANG_STD)
+    cached_translation = read_map_from_json(language=LANG_STD)
     cached_translation = dict(sorted(cached_translation.items(), key=lambda x: -len(x[0])))
 
     chinese_core_keys_norepeat_mapping = {}

request_llm/bridge_all.py

@@ -19,8 +19,11 @@ from .bridge_chatgpt import predict as chatgpt_ui
 from .bridge_chatglm import predict_no_ui_long_connection as chatglm_noui
 from .bridge_chatglm import predict as chatglm_ui
 
-# from .bridge_tgui import predict_no_ui_long_connection as tgui_noui
-# from .bridge_tgui import predict as tgui_ui
+from .bridge_chatglm import predict_no_ui_long_connection as chatglm_noui
+from .bridge_chatglm import predict as chatglm_ui
+
+from .bridge_qianfan import predict_no_ui_long_connection as qianfan_noui
+from .bridge_qianfan import predict as qianfan_ui
 
 colors = ['#FF00FF', '#00FFFF', '#FF0000', '#990099', '#009999', '#990044']
 
@@ -71,6 +74,10 @@ get_token_num_gpt35 = lambda txt: len(tokenizer_gpt35.encode(txt, disallowed_spe
 get_token_num_gpt4 = lambda txt: len(tokenizer_gpt4.encode(txt, disallowed_special=()))
 
 
+# 开始初始化模型
+AVAIL_LLM_MODELS, LLM_MODEL = get_conf("AVAIL_LLM_MODELS", "LLM_MODEL")
+AVAIL_LLM_MODELS = AVAIL_LLM_MODELS + [LLM_MODEL]
+# -=-=-=-=-=-=- 以下这部分是最早加入的最稳定的模型 -=-=-=-=-=-=-
 model_info = {
     # openai
     "gpt-3.5-turbo": {
@@ -164,12 +171,17 @@ model_info = {
         "tokenizer": tokenizer_gpt35,
         "token_cnt": get_token_num_gpt35,
     },
-
+    "qianfan": {
+        "fn_with_ui": qianfan_ui,
+        "fn_without_ui": qianfan_noui,
+        "endpoint": None,
+        "max_token": 2000,
+        "tokenizer": tokenizer_gpt35,
+        "token_cnt": get_token_num_gpt35,
+    },
 }
 
-
-AVAIL_LLM_MODELS, LLM_MODEL = get_conf("AVAIL_LLM_MODELS", "LLM_MODEL")
-AVAIL_LLM_MODELS = AVAIL_LLM_MODELS + [LLM_MODEL]
+# -=-=-=-=-=-=- 以下部分是新加入的模型，可能附带额外依赖 -=-=-=-=-=-=-
 if "claude-1-100k" in AVAIL_LLM_MODELS or "claude-2" in AVAIL_LLM_MODELS:
     from .bridge_claude import predict_no_ui_long_connection as claude_noui
     from .bridge_claude import predict as claude_ui
@@ -322,6 +334,104 @@ if "internlm" in AVAIL_LLM_MODELS:
         })
     except:
         print(trimmed_format_exc())
+if "chatglm_onnx" in AVAIL_LLM_MODELS:
+    try:
+        from .bridge_chatglmonnx import predict_no_ui_long_connection as chatglm_onnx_noui
+        from .bridge_chatglmonnx import predict as chatglm_onnx_ui
+        model_info.update({
+            "chatglm_onnx": {
+                "fn_with_ui": chatglm_onnx_ui,
+                "fn_without_ui": chatglm_onnx_noui,
+                "endpoint": None,
+                "max_token": 4096,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+            }
+        })
+    except:
+        print(trimmed_format_exc())
+if "qwen" in AVAIL_LLM_MODELS:
+    try:
+        from .bridge_qwen import predict_no_ui_long_connection as qwen_noui
+        from .bridge_qwen import predict as qwen_ui
+        model_info.update({
+            "qwen": {
+                "fn_with_ui": qwen_ui,
+                "fn_without_ui": qwen_noui,
+                "endpoint": None,
+                "max_token": 4096,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+            }
+        })
+    except:
+        print(trimmed_format_exc())
+if "chatgpt_website" in AVAIL_LLM_MODELS:   # 接入一些逆向工程https://github.com/acheong08/ChatGPT-to-API/
+    try:
+        from .bridge_chatgpt_website import predict_no_ui_long_connection as chatgpt_website_noui
+        from .bridge_chatgpt_website import predict as chatgpt_website_ui
+        model_info.update({
+            "chatgpt_website": {
+                "fn_with_ui": chatgpt_website_ui,
+                "fn_without_ui": chatgpt_website_noui,
+                "endpoint": openai_endpoint,
+                "max_token": 4096,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+            }
+        })
+    except:
+        print(trimmed_format_exc())
+if "spark" in AVAIL_LLM_MODELS:   # 讯飞星火认知大模型
+    try:
+        from .bridge_spark import predict_no_ui_long_connection as spark_noui
+        from .bridge_spark import predict as spark_ui
+        model_info.update({
+            "spark": {
+                "fn_with_ui": spark_ui,
+                "fn_without_ui": spark_noui,
+                "endpoint": None,
+                "max_token": 4096,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+            }
+        })
+    except:
+        print(trimmed_format_exc())
+if "sparkv2" in AVAIL_LLM_MODELS:   # 讯飞星火认知大模型
+    try:
+        from .bridge_spark import predict_no_ui_long_connection as spark_noui
+        from .bridge_spark import predict as spark_ui
+        model_info.update({
+            "sparkv2": {
+                "fn_with_ui": spark_ui,
+                "fn_without_ui": spark_noui,
+                "endpoint": None,
+                "max_token": 4096,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+            }
+        })
+    except:
+        print(trimmed_format_exc())
+if "llama2" in AVAIL_LLM_MODELS:   # llama2
+    try:
+        from .bridge_llama2 import predict_no_ui_long_connection as llama2_noui
+        from .bridge_llama2 import predict as llama2_ui
+        model_info.update({
+            "llama2": {
+                "fn_with_ui": llama2_ui,
+                "fn_without_ui": llama2_noui,
+                "endpoint": None,
+                "max_token": 4096,
+                "tokenizer": tokenizer_gpt35,
+                "token_cnt": get_token_num_gpt35,
+            }
+        })
+    except:
+        print(trimmed_format_exc())
+
+
 
 def LLM_CATCH_EXCEPTION(f):
     """
@@ -362,7 +472,8 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history, sys_prompt, obser
         method = model_info[model]["fn_without_ui"]
         return method(inputs, llm_kwargs, history, sys_prompt, observe_window, console_slience)
     else:
-        # 如果同时询问多个大语言模型：
+
+        # 如果同时询问多个大语言模型，这个稍微啰嗦一点，但思路相同，您不必读这个else分支
         executor = ThreadPoolExecutor(max_workers=4)
         models = model.split('&')
         n_model = len(models)

request_llm/bridge_chatglm.py

@@ -144,11 +144,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
             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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     # 处理历史信息
     history_feedin = []

request_llm/bridge_chatglmft.py

@@ -63,9 +63,9 @@ class GetGLMFTHandle(Process):
                     # if not os.path.exists(conf): raise RuntimeError('找不到微调模型信息')
                     # with open(conf, 'r', encoding='utf8') as f:
                     #     model_args = json.loads(f.read())
-                    ChatGLM_PTUNING_CHECKPOINT, = get_conf('ChatGLM_PTUNING_CHECKPOINT')
-                    assert os.path.exists(ChatGLM_PTUNING_CHECKPOINT), "找不到微调模型检查点"
-                    conf = os.path.join(ChatGLM_PTUNING_CHECKPOINT, "config.json")
+                    CHATGLM_PTUNING_CHECKPOINT, = get_conf('CHATGLM_PTUNING_CHECKPOINT')
+                    assert os.path.exists(CHATGLM_PTUNING_CHECKPOINT), "找不到微调模型检查点"
+                    conf = os.path.join(CHATGLM_PTUNING_CHECKPOINT, "config.json")
                     with open(conf, 'r', encoding='utf8') as f:
                         model_args = json.loads(f.read())
                     if 'model_name_or_path' not in model_args:
@@ -78,9 +78,9 @@ class GetGLMFTHandle(Process):
                     config.pre_seq_len = model_args['pre_seq_len']
                     config.prefix_projection = model_args['prefix_projection']
 
-                    print(f"Loading prefix_encoder weight from {ChatGLM_PTUNING_CHECKPOINT}")
+                    print(f"Loading prefix_encoder weight from {CHATGLM_PTUNING_CHECKPOINT}")
                     model = AutoModel.from_pretrained(model_args['model_name_or_path'], config=config, trust_remote_code=True)
-                    prefix_state_dict = torch.load(os.path.join(ChatGLM_PTUNING_CHECKPOINT, "pytorch_model.bin"))
+                    prefix_state_dict = torch.load(os.path.join(CHATGLM_PTUNING_CHECKPOINT, "pytorch_model.bin"))
                     new_prefix_state_dict = {}
                     for k, v in prefix_state_dict.items():
                         if k.startswith("transformer.prefix_encoder."):
@@ -185,11 +185,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
             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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     # 处理历史信息
     history_feedin = []

request_llm/bridge_chatglmonnx.py

@@ -0,0 +1,73 @@
+model_name = "ChatGLM-ONNX"
+cmd_to_install = "`pip install -r request_llm/requirements_chatglm_onnx.txt`"
+
+
+from transformers import AutoModel, AutoTokenizer
+import time
+import threading
+import importlib
+from toolbox import update_ui, get_conf
+from multiprocessing import Process, Pipe
+from .local_llm_class import LocalLLMHandle, get_local_llm_predict_fns, SingletonLocalLLM
+
+from .chatglmoonx import ChatGLMModel, chat_template
+
+
+
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 Local Model
+# ------------------------------------------------------------------------------------------------------------------------
+@SingletonLocalLLM
+class GetONNXGLMHandle(LocalLLMHandle):
+
+    def load_model_info(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        self.model_name = model_name
+        self.cmd_to_install = cmd_to_install
+
+    def load_model_and_tokenizer(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        import os, glob
+        if not len(glob.glob("./request_llm/ChatGLM-6b-onnx-u8s8/chatglm-6b-int8-onnx-merged/*.bin")) >= 7: # 该模型有七个 bin 文件
+            from huggingface_hub import snapshot_download
+            snapshot_download(repo_id="K024/ChatGLM-6b-onnx-u8s8", local_dir="./request_llm/ChatGLM-6b-onnx-u8s8")
+        def create_model():
+            return ChatGLMModel(
+                tokenizer_path = "./request_llm/ChatGLM-6b-onnx-u8s8/chatglm-6b-int8-onnx-merged/sentencepiece.model",
+                onnx_model_path = "./request_llm/ChatGLM-6b-onnx-u8s8/chatglm-6b-int8-onnx-merged/chatglm-6b-int8.onnx"
+            )
+        self._model = create_model()
+        return self._model, None
+
+    def llm_stream_generator(self, **kwargs):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        def adaptor(kwargs):
+            query = kwargs['query']
+            max_length = kwargs['max_length']
+            top_p = kwargs['top_p']
+            temperature = kwargs['temperature']
+            history = kwargs['history']
+            return query, max_length, top_p, temperature, history
+
+        query, max_length, top_p, temperature, history = adaptor(kwargs)
+
+        prompt = chat_template(history, query)
+        for answer in self._model.generate_iterate(
+            prompt,
+            max_generated_tokens=max_length,
+            top_k=1,
+            top_p=top_p,
+            temperature=temperature,
+        ):
+            yield answer
+        
+    def try_to_import_special_deps(self, **kwargs):
+        # import something that will raise error if the user does not install requirement_*.txt
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        pass
+
+
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 GPT-Academic Interface
+# ------------------------------------------------------------------------------------------------------------------------
+predict_no_ui_long_connection, predict = get_local_llm_predict_fns(GetONNXGLMHandle, model_name)

request_llm/bridge_chatgpt.py

@@ -129,17 +129,20 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
         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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     raw_input = inputs
     logging.info(f'[raw_input] {raw_input}')
     chatbot.append((inputs, ""))
     yield from update_ui(chatbot=chatbot, history=history, msg="等待响应") # 刷新界面
 
+    # check mis-behavior
+    if raw_input.startswith('private_upload/') and len(raw_input) == 34:
+        chatbot[-1] = (inputs, f"[Local Message] 检测到操作错误！当您上传文档之后，需要点击“函数插件区”按钮进行处理，而不是点击“提交”按钮。")
+        yield from update_ui(chatbot=chatbot, history=history, msg="正常") # 刷新界面
+        time.sleep(2)
+
     try:
         headers, payload = generate_payload(inputs, llm_kwargs, history, system_prompt, stream)
     except RuntimeError as e:
@@ -180,14 +183,13 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                 yield from update_ui(chatbot=chatbot, history=history, msg="非Openai官方接口返回了错误:" + chunk.decode()) # 刷新界面
                 return
             
-            # print(chunk.decode()[6:])
-            if is_head_of_the_stream and (r'"object":"error"' not in chunk.decode()):
+            chunk_decoded = chunk.decode()
+            if is_head_of_the_stream and (r'"object":"error"' not in chunk_decoded) and (r"content" not in chunk_decoded):
                 # 数据流的第一帧不携带content
                 is_head_of_the_stream = False; continue
             
             if chunk:
                 try:
-                    chunk_decoded = chunk.decode()
                     # 前者是API2D的结束条件，后者是OPENAI的结束条件
                     if ('data: [DONE]' in chunk_decoded) or (len(json.loads(chunk_decoded[6:])['choices'][0]["delta"]) == 0):
                         # 判定为数据流的结束，gpt_replying_buffer也写完了
@@ -195,7 +197,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                         break
                     # 处理数据流的主体
                     chunkjson = json.loads(chunk_decoded[6:])
-                    status_text = f"finish_reason: {chunkjson['choices'][0]['finish_reason']}"
+                    status_text = f"finish_reason: {chunkjson['choices'][0].get('finish_reason', 'null')}"
                     # 如果这里抛出异常，一般是文本过长，详情见get_full_error的输出
                     gpt_replying_buffer = gpt_replying_buffer + json.loads(chunk_decoded[6:])['choices'][0]["delta"]["content"]
                     history[-1] = gpt_replying_buffer
@@ -219,7 +221,6 @@ def handle_error(inputs, llm_kwargs, chatbot, history, chunk_decoded, error_msg)
         history = clip_history(inputs=inputs, history=history, tokenizer=model_info[llm_kwargs['llm_model']]['tokenizer'], 
                                                max_token_limit=(model_info[llm_kwargs['llm_model']]['max_token'])) # history至少释放二分之一
         chatbot[-1] = (chatbot[-1][0], "[Local Message] Reduce the length. 本次输入过长, 或历史数据过长. 历史缓存数据已部分释放, 您可以请再次尝试. (若再次失败则更可能是因为输入过长.)")
-                        # history = []    # 清除历史
     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:

request_llm/bridge_chatgpt_website.py

@@ -0,0 +1,282 @@
+# 借鉴了 https://github.com/GaiZhenbiao/ChuanhuChatGPT 项目
+
+"""
+    该文件中主要包含三个函数
+
+    不具备多线程能力的函数：
+    1. predict: 正常对话时使用，具备完备的交互功能，不可多线程
+
+    具备多线程调用能力的函数
+    2. predict_no_ui：高级实验性功能模块调用，不会实时显示在界面上，参数简单，可以多线程并行，方便实现复杂的功能逻辑
+    3. predict_no_ui_long_connection：在实验过程中发现调用predict_no_ui处理长文档时，和openai的连接容易断掉，这个函数用stream的方式解决这个问题，同样支持多线程
+"""
+
+import json
+import time
+import gradio as gr
+import logging
+import traceback
+import requests
+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, TIMEOUT_SECONDS, MAX_RETRY, API_ORG = \
+    get_conf('proxies', 'TIMEOUT_SECONDS', 'MAX_RETRY', 'API_ORG')
+
+timeout_bot_msg = '[Local Message] Request timeout. Network error. Please check proxy settings in config.py.' + \
+                  '网络错误，检查代理服务器是否可用，以及代理设置的格式是否正确，格式须是[协议]://[地址]:[端口]，缺一不可。'
+
+def get_full_error(chunk, stream_response):
+    """
+        获取完整的从Openai返回的报错
+    """
+    while True:
+        try:
+            chunk += next(stream_response)
+        except:
+            break
+    return chunk
+
+
+def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=None, console_slience=False):
+    """
+    发送至chatGPT，等待回复，一次性完成，不显示中间过程。但内部用stream的方法避免中途网线被掐。
+    inputs：
+        是本次问询的输入
+    sys_prompt:
+        系统静默prompt
+    llm_kwargs：
+        chatGPT的内部调优参数
+    history：
+        是之前的对话列表
+    observe_window = None：
+        用于负责跨越线程传递已经输出的部分，大部分时候仅仅为了fancy的视觉效果，留空即可。observe_window[0]：观测窗。observe_window[1]：看门狗
+    """
+    watch_dog_patience = 5 # 看门狗的耐心, 设置5秒即可
+    headers, payload = generate_payload(inputs, llm_kwargs, history, system_prompt=sys_prompt, stream=True)
+    retry = 0
+    while True:
+        try:
+            # make a POST request to the API endpoint, stream=False
+            from .bridge_all import model_info
+            endpoint = model_info[llm_kwargs['llm_model']]['endpoint']
+            response = requests.post(endpoint, headers=headers, proxies=proxies,
+                                    json=payload, stream=True, timeout=TIMEOUT_SECONDS); break
+        except requests.exceptions.ReadTimeout as e:
+            retry += 1
+            traceback.print_exc()
+            if retry > MAX_RETRY: raise TimeoutError
+            if MAX_RETRY!=0: print(f'请求超时，正在重试 ({retry}/{MAX_RETRY}) ……')
+
+    stream_response =  response.iter_lines()
+    result = ''
+    while True:
+        try: chunk = next(stream_response).decode()
+        except StopIteration: 
+            break
+        except requests.exceptions.ConnectionError:
+            chunk = next(stream_response).decode() # 失败了，重试一次？再失败就没办法了。
+        if len(chunk)==0: continue
+        if not chunk.startswith('data:'): 
+            error_msg = get_full_error(chunk.encode('utf8'), stream_response).decode()
+            if "reduce the length" in error_msg:
+                raise ConnectionAbortedError("OpenAI拒绝了请求:" + error_msg)
+            else:
+                raise RuntimeError("OpenAI拒绝了请求：" + error_msg)
+        if ('data: [DONE]' in chunk): break # api2d 正常完成
+        json_data = json.loads(chunk.lstrip('data:'))['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='')
+            if observe_window is not None: 
+                # 观测窗，把已经获取的数据显示出去
+                if len(observe_window) >= 1: observe_window[0] += delta["content"]
+                # 看门狗，如果超过期限没有喂狗，则终止
+                if len(observe_window) >= 2:  
+                    if (time.time()-observe_window[1]) > watch_dog_patience:
+                        raise RuntimeError("用户取消了程序。")
+        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
+
+
+def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream = True, additional_fn=None):
+    """
+    发送至chatGPT，流式获取输出。
+    用于基础的对话功能。
+    inputs 是本次问询的输入
+    top_p, temperature是chatGPT的内部调优参数
+    history 是之前的对话列表（注意无论是inputs还是history，内容太长了都会触发token数量溢出的错误）
+    chatbot 为WebUI中显示的对话列表，修改它，然后yeild出去，可以直接修改对话界面内容
+    additional_fn代表点击的哪个按钮，按钮见functional.py
+    """
+    if additional_fn is not None:
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
+    raw_input = inputs
+    logging.info(f'[raw_input] {raw_input}')
+    chatbot.append((inputs, ""))
+    yield from update_ui(chatbot=chatbot, history=history, msg="等待响应") # 刷新界面
+
+    try:
+        headers, payload = generate_payload(inputs, llm_kwargs, history, system_prompt, stream)
+    except RuntimeError as e:
+        chatbot[-1] = (inputs, f"您提供的api-key不满足要求，不包含任何可用于{llm_kwargs['llm_model']}的api-key。您可能选择了错误的模型或请求源。")
+        yield from update_ui(chatbot=chatbot, history=history, msg="api-key不满足要求") # 刷新界面
+        return
+        
+    history.append(inputs); history.append("")
+
+    retry = 0
+    while True:
+        try:
+            # make a POST request to the API endpoint, stream=True
+            from .bridge_all import model_info
+            endpoint = model_info[llm_kwargs['llm_model']]['endpoint']
+            response = requests.post(endpoint, headers=headers, proxies=proxies,
+                                    json=payload, stream=True, timeout=TIMEOUT_SECONDS);break
+        except:
+            retry += 1
+            chatbot[-1] = ((chatbot[-1][0], timeout_bot_msg))
+            retry_msg = f"，正在重试 ({retry}/{MAX_RETRY}) ……" if MAX_RETRY > 0 else ""
+            yield from update_ui(chatbot=chatbot, history=history, msg="请求超时"+retry_msg) # 刷新界面
+            if retry > MAX_RETRY: raise TimeoutError
+
+    gpt_replying_buffer = ""
+    
+    is_head_of_the_stream = True
+    if stream:
+        stream_response =  response.iter_lines()
+        while True:
+            try:
+                chunk = next(stream_response)
+            except StopIteration:
+                # 非OpenAI官方接口的出现这样的报错，OpenAI和API2D不会走这里
+                chunk_decoded = chunk.decode()
+                error_msg = chunk_decoded
+                chatbot, history = handle_error(inputs, llm_kwargs, chatbot, history, chunk_decoded, error_msg)
+                yield from update_ui(chatbot=chatbot, history=history, msg="非Openai官方接口返回了错误:" + chunk.decode()) # 刷新界面
+                return
+            
+            # print(chunk.decode()[6:])
+            if is_head_of_the_stream and (r'"object":"error"' not in chunk.decode()):
+                # 数据流的第一帧不携带content
+                is_head_of_the_stream = False; continue
+            
+            if chunk:
+                try:
+                    chunk_decoded = chunk.decode()
+                    # 前者是API2D的结束条件，后者是OPENAI的结束条件
+                    if 'data: [DONE]' in chunk_decoded:
+                        # 判定为数据流的结束，gpt_replying_buffer也写完了
+                        logging.info(f'[response] {gpt_replying_buffer}')
+                        break
+                    # 处理数据流的主体
+                    chunkjson = json.loads(chunk_decoded[6:])
+                    status_text = f"finish_reason: {chunkjson['choices'][0]['finish_reason']}"
+                    delta = chunkjson['choices'][0]["delta"]
+                    if "content" in delta:
+                        gpt_replying_buffer = gpt_replying_buffer + delta["content"]
+                    history[-1] = gpt_replying_buffer
+                    chatbot[-1] = (history[-2], history[-1])
+                    yield from update_ui(chatbot=chatbot, history=history, msg=status_text) # 刷新界面
+                except Exception as e:
+                    yield from update_ui(chatbot=chatbot, history=history, msg="Json解析不合常规") # 刷新界面
+                    chunk = get_full_error(chunk, stream_response)
+                    chunk_decoded = chunk.decode()
+                    error_msg = chunk_decoded
+                    chatbot, history = handle_error(inputs, llm_kwargs, chatbot, history, chunk_decoded, error_msg)
+                    yield from update_ui(chatbot=chatbot, history=history, msg="Json异常" + error_msg) # 刷新界面
+                    print(error_msg)
+                    return
+
+def handle_error(inputs, llm_kwargs, chatbot, history, chunk_decoded, error_msg):
+    from .bridge_all import model_info
+    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'], 
+                                               max_token_limit=(model_info[llm_kwargs['llm_model']]['max_token'])) # history至少释放二分之一
+        chatbot[-1] = (chatbot[-1][0], "[Local Message] Reduce the length. 本次输入过长, 或历史数据过长. 历史缓存数据已部分释放, 您可以请再次尝试. (若再次失败则更可能是因为输入过长.)")
+                        # history = []    # 清除历史
+    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为由, 拒绝服务. " + openai_website)
+    elif "exceeded your current quota" in error_msg:
+        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:
+        chatbot[-1] = (chatbot[-1][0], "[Local Message] Not enough point. API2D账户点数不足.")
+    else:
+        from toolbox import regular_txt_to_markdown
+        tb_str = '```\n' + trimmed_format_exc() + '```'
+        chatbot[-1] = (chatbot[-1][0], f"[Local Message] 异常 \n\n{tb_str} \n\n{regular_txt_to_markdown(chunk_decoded)}")
+    return chatbot, history
+
+def generate_payload(inputs, llm_kwargs, history, system_prompt, stream):
+    """
+    整合所有信息，选择LLM模型，生成http请求，为发送请求做准备
+    """
+    if not is_any_api_key(llm_kwargs['api_key']):
+        raise AssertionError("你提供了错误的API_KEY。\n\n1. 临时解决方案：直接在输入区键入api_key，然后回车提交。\n\n2. 长效解决方案：在config.py中配置。")
+
+    headers = {
+        "Content-Type": "application/json",
+    }
+
+    conversation_cnt = len(history) // 2
+
+    messages = [{"role": "system", "content": system_prompt}]
+    if conversation_cnt:
+        for index in range(0, 2*conversation_cnt, 2):
+            what_i_have_asked = {}
+            what_i_have_asked["role"] = "user"
+            what_i_have_asked["content"] = history[index]
+            what_gpt_answer = {}
+            what_gpt_answer["role"] = "assistant"
+            what_gpt_answer["content"] = history[index+1]
+            if what_i_have_asked["content"] != "":
+                if what_gpt_answer["content"] == "": continue
+                if what_gpt_answer["content"] == timeout_bot_msg: continue
+                messages.append(what_i_have_asked)
+                messages.append(what_gpt_answer)
+            else:
+                messages[-1]['content'] = what_gpt_answer['content']
+
+    what_i_ask_now = {}
+    what_i_ask_now["role"] = "user"
+    what_i_ask_now["content"] = inputs
+    messages.append(what_i_ask_now)
+
+    payload = {
+        "model": llm_kwargs['llm_model'].strip('api2d-'),
+        "messages": messages, 
+        "temperature": llm_kwargs['temperature'],  # 1.0,
+        "top_p": llm_kwargs['top_p'],  # 1.0,
+        "n": 1,
+        "stream": stream,
+        "presence_penalty": 0,
+        "frequency_penalty": 0,
+    }
+    try:
+        print(f" {llm_kwargs['llm_model']} : {conversation_cnt} : {inputs[:100]} ..........")
+    except:
+        print('输入中可能存在乱码。')
+    return headers,payload
+
+

request_llm/bridge_claude.py

@@ -116,11 +116,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
         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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     raw_input = inputs
     logging.info(f'[raw_input] {raw_input}')

request_llm/bridge_internlm.py

@@ -1,23 +1,25 @@
+model_name = "InternLM"
+cmd_to_install = "`pip install -r request_llm/requirements_chatglm.txt`"
 
 from transformers import AutoModel, AutoTokenizer
 import time
 import threading
 import importlib
-from toolbox import update_ui, get_conf, Singleton
+from toolbox import update_ui, get_conf
 from multiprocessing import Process, Pipe
+from .local_llm_class import LocalLLMHandle, get_local_llm_predict_fns, SingletonLocalLLM
 
-model_name = "InternLM"
-cmd_to_install = "`pip install ???`"
-load_message = f"{model_name}尚未加载，加载需要一段时间。注意，取决于`config.py`的配置，{model_name}消耗大量的内存（CPU）或显存（GPU），也许会导致低配计算机卡死 ……"
+
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 Local Model Utils
+# ------------------------------------------------------------------------------------------------------------------------
 def try_to_import_special_deps():
     import sentencepiece
 
-user_prompt = "<|User|>:{user}<eoh>\n"
-robot_prompt = "<|Bot|>:{robot}<eoa>\n"
-cur_query_prompt = "<|User|>:{user}<eoh>\n<|Bot|>:"
-
-
 def combine_history(prompt, hist):
+    user_prompt = "<|User|>:{user}<eoh>\n"
+    robot_prompt = "<|Bot|>:{robot}<eoa>\n"
+    cur_query_prompt = "<|User|>:{user}<eoh>\n<|Bot|>:"
     messages = hist
     total_prompt = ""
     for message in messages:
@@ -29,24 +31,22 @@ def combine_history(prompt, hist):
     total_prompt = total_prompt + cur_query_prompt.replace("{user}", prompt)
     return total_prompt
 
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 Local Model
+# ------------------------------------------------------------------------------------------------------------------------
+@SingletonLocalLLM
+class GetInternlmHandle(LocalLLMHandle):
 
-@Singleton
-class GetInternlmHandle(Process):
-    def __init__(self):
-        # ⭐主进程执行
-        super().__init__(daemon=True)
-        self.parent, self.child = Pipe()
-        self._model = None
-        self._tokenizer = None
-        self.info = ""
-        self.success = True
-        self.check_dependency()
-        self.start()
-        self.threadLock = threading.Lock()
+    def load_model_info(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        self.model_name = model_name
+        self.cmd_to_install = cmd_to_install
 
-    def ready(self):
-        # ⭐主进程执行
-        return self._model is not None
+    def try_to_import_special_deps(self, **kwargs):
+        """
+        import something that will raise error if the user does not install requirement_*.txt
+        """
+        import sentencepiece
 
     def load_model_and_tokenizer(self):
         # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
@@ -195,121 +195,8 @@ class GetInternlmHandle(Process):
             if unfinished_sequences.max() == 0 or stopping_criteria(input_ids, scores):
                 return
 
-
-
-    def check_dependency(self):
-        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
-        try:
-            try_to_import_special_deps()
-            self.info = "依赖检测通过"
-            self.success = True
-        except:
-            self.info = f"缺少{model_name}的依赖，如果要使用{model_name}，除了基础的pip依赖以外，您还需要运行{cmd_to_install}安装{model_name}的依赖。"
-            self.success = False
-
-    def run(self):
-        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
-        # 第一次运行，加载参数
-        try:
-            self._model, self._tokenizer = self.load_model_and_tokenizer()
-        except:
-            from toolbox import trimmed_format_exc
-            self.child.send(f'[Local Message] 不能正常加载{model_name}的参数.' + '\n```\n' + trimmed_format_exc() + '\n```\n')
-            raise RuntimeError(f"不能正常加载{model_name}的参数！")
-
-        while True:
-            # 进入任务等待状态
-            kwargs = self.child.recv()
-            # 收到消息，开始请求
-            try:
-                for response_full in self.llm_stream_generator(**kwargs):
-                    self.child.send(response_full)
-            except:
-                from toolbox import trimmed_format_exc
-                self.child.send(f'[Local Message] 调用{model_name}失败.' + '\n```\n' + trimmed_format_exc() + '\n```\n')
-            # 请求处理结束，开始下一个循环
-            self.child.send('[Finish]')
-
-    def stream_chat(self, **kwargs):
-        # ⭐主进程执行
-        self.threadLock.acquire()
-        self.parent.send(kwargs)
-        while True:
-            res = self.parent.recv()
-            if res != '[Finish]':
-                yield res
-            else:
-                break
-        self.threadLock.release()
-    
     
 # ------------------------------------------------------------------------------------------------------------------------
-# 🔌💻 GPT-Academic
+# 🔌💻 GPT-Academic Interface
 # ------------------------------------------------------------------------------------------------------------------------
-def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=[], console_slience=False):
-    """
-        ⭐多线程方法
-        函数的说明请见 request_llm/bridge_all.py
-    """
-    _llm_handle = GetInternlmHandle()
-    if len(observe_window) >= 1: observe_window[0] = load_message + "\n\n" + _llm_handle.info
-    if not _llm_handle.success: 
-        error = _llm_handle.info
-        _llm_handle = None
-        raise RuntimeError(error)
-
-    # chatglm 没有 sys_prompt 接口，因此把prompt加入 history
-    history_feedin = []
-    history_feedin.append(["What can I do?", sys_prompt])
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]] )
-
-    watch_dog_patience = 5 # 看门狗 (watchdog) 的耐心, 设置5秒即可
-    response = ""
-    for response in _llm_handle.stream_chat(query=inputs, history=history_feedin, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
-        if len(observe_window) >= 1:  observe_window[0] = response
-        if len(observe_window) >= 2:  
-            if (time.time()-observe_window[1]) > watch_dog_patience:
-                raise RuntimeError("程序终止。")
-    return 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, ""))
-
-    _llm_handle = GetInternlmHandle()
-    chatbot[-1] = (inputs, load_message + "\n\n" + _llm_handle.info)
-    yield from update_ui(chatbot=chatbot, history=[])
-    if not _llm_handle.success: 
-        _llm_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 = []
-    history_feedin.append(["What can I do?", system_prompt] )
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]] )
-
-    # 开始接收chatglm的回复
-    response = f"[Local Message]: 等待{model_name}响应中 ..."
-    for response in _llm_handle.stream_chat(query=inputs, history=history_feedin, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
-        chatbot[-1] = (inputs, response)
-        yield from update_ui(chatbot=chatbot, history=history)
-
-    # 总结输出
-    if response == f"[Local Message]: 等待{model_name}响应中 ...":
-        response = f"[Local Message]: {model_name}响应异常 ..."
-    history.extend([inputs, response])
-    yield from update_ui(chatbot=chatbot, history=history)
+predict_no_ui_long_connection, predict = get_local_llm_predict_fns(GetInternlmHandle, model_name)

request_llm/bridge_jittorllms_llama.py

@@ -154,11 +154,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
             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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     # 处理历史信息
     history_feedin = []

request_llm/bridge_jittorllms_pangualpha.py

@@ -154,11 +154,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
             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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     # 处理历史信息
     history_feedin = []

request_llm/bridge_jittorllms_rwkv.py

@@ -154,11 +154,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
             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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     # 处理历史信息
     history_feedin = []

request_llm/bridge_llama2.py

@@ -0,0 +1,91 @@
+model_name = "LLaMA"
+cmd_to_install = "`pip install -r request_llm/requirements_chatglm.txt`"
+
+
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+from toolbox import update_ui, get_conf, ProxyNetworkActivate
+from multiprocessing import Process, Pipe
+from .local_llm_class import LocalLLMHandle, get_local_llm_predict_fns, SingletonLocalLLM
+from threading import Thread
+
+
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 Local Model
+# ------------------------------------------------------------------------------------------------------------------------
+@SingletonLocalLLM
+class GetONNXGLMHandle(LocalLLMHandle):
+
+    def load_model_info(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        self.model_name = model_name
+        self.cmd_to_install = cmd_to_install
+
+    def load_model_and_tokenizer(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        import os, glob
+        import os
+        import platform
+        huggingface_token, device = get_conf('HUGGINGFACE_ACCESS_TOKEN', 'LOCAL_MODEL_DEVICE')
+        assert len(huggingface_token) != 0, "没有填写 HUGGINGFACE_ACCESS_TOKEN"
+        with open(os.path.expanduser('~/.cache/huggingface/token'), 'w') as f:
+            f.write(huggingface_token)
+        model_id = 'meta-llama/Llama-2-7b-chat-hf'
+        with ProxyNetworkActivate():
+            self._tokenizer = AutoTokenizer.from_pretrained(model_id, use_auth_token=huggingface_token)
+            # use fp16
+            model = AutoModelForCausalLM.from_pretrained(model_id, use_auth_token=huggingface_token).eval()
+            if device.startswith('cuda'): model = model.half().to(device)
+            self._model = model
+
+            return self._model, self._tokenizer
+
+    def llm_stream_generator(self, **kwargs):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        def adaptor(kwargs):
+            query = kwargs['query']
+            max_length = kwargs['max_length']
+            top_p = kwargs['top_p']
+            temperature = kwargs['temperature']
+            history = kwargs['history']
+            console_slience = kwargs.get('console_slience', True)
+            return query, max_length, top_p, temperature, history, console_slience
+        
+        def convert_messages_to_prompt(query, history):
+            prompt = ""
+            for a, b in history:
+                prompt += f"\n[INST]{a}[/INST]"
+                prompt += "\n{b}" + b
+            prompt += f"\n[INST]{query}[/INST]"
+            return prompt
+        
+        query, max_length, top_p, temperature, history, console_slience = adaptor(kwargs)
+        prompt = convert_messages_to_prompt(query, history)
+        # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-
+        # code from transformers.llama
+        streamer = TextIteratorStreamer(self._tokenizer)
+        # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way.
+        inputs = self._tokenizer([prompt], return_tensors="pt")
+        prompt_tk_back = self._tokenizer.batch_decode(inputs['input_ids'])[0]
+
+        generation_kwargs = dict(inputs.to(self._model.device), streamer=streamer, max_new_tokens=max_length)
+        thread = Thread(target=self._model.generate, kwargs=generation_kwargs)
+        thread.start()
+        generated_text = ""
+        for new_text in streamer: 
+            generated_text += new_text
+            if not console_slience: print(new_text, end='')
+            yield generated_text.lstrip(prompt_tk_back).rstrip("</s>")
+        if not console_slience: print()
+        # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-
+        
+    def try_to_import_special_deps(self, **kwargs):
+        # import something that will raise error if the user does not install requirement_*.txt
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 主进程执行
+        import importlib
+        importlib.import_module('transformers')
+
+
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 GPT-Academic Interface
+# ------------------------------------------------------------------------------------------------------------------------
+predict_no_ui_long_connection, predict = get_local_llm_predict_fns(GetONNXGLMHandle, model_name)

request_llm/bridge_moss.py

@@ -224,11 +224,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
         yield from update_ui(chatbot=chatbot, history=history)
 
     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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     # 处理历史信息
     history_feedin = []

request_llm/bridge_newbingfree.py

@@ -224,11 +224,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
             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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     history_feedin = []
     for i in range(len(history)//2):

request_llm/bridge_qianfan.py

@@ -0,0 +1,165 @@
+
+import time, requests, json
+from multiprocessing import Process, Pipe
+from functools import wraps
+from datetime import datetime, timedelta
+from toolbox import get_conf, update_ui, is_any_api_key, select_api_key, what_keys, clip_history, trimmed_format_exc, get_conf
+
+model_name = '千帆大模型平台'
+timeout_bot_msg = '[Local Message] Request timeout. Network error.'
+
+def cache_decorator(timeout):
+    cache = {}
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            key = (func.__name__, args, frozenset(kwargs.items()))
+            # Check if result is already cached and not expired
+            if key in cache:
+                result, timestamp = cache[key]
+                if datetime.now() - timestamp < timedelta(seconds=timeout):
+                    return result
+
+            # Call the function and cache the result
+            result = func(*args, **kwargs)
+            cache[key] = (result, datetime.now())
+            return result
+        return wrapper
+    return decorator
+
+@cache_decorator(timeout=3600)
+def get_access_token():
+    """
+    使用 AK，SK 生成鉴权签名（Access Token）
+    :return: access_token，或是None(如果错误)
+    """
+    # if (access_token_cache is None) or (time.time() - last_access_token_obtain_time > 3600):
+    BAIDU_CLOUD_API_KEY, BAIDU_CLOUD_SECRET_KEY = get_conf('BAIDU_CLOUD_API_KEY', 'BAIDU_CLOUD_SECRET_KEY')
+
+    if len(BAIDU_CLOUD_SECRET_KEY) == 0: raise RuntimeError("没有配置BAIDU_CLOUD_SECRET_KEY")
+    if len(BAIDU_CLOUD_API_KEY) == 0: raise RuntimeError("没有配置BAIDU_CLOUD_API_KEY")
+
+    url = "https://aip.baidubce.com/oauth/2.0/token"
+    params = {"grant_type": "client_credentials", "client_id": BAIDU_CLOUD_API_KEY, "client_secret": BAIDU_CLOUD_SECRET_KEY}
+    access_token_cache = str(requests.post(url, params=params).json().get("access_token"))
+    return access_token_cache
+    # else:
+    #     return access_token_cache
+
+
+def generate_message_payload(inputs, llm_kwargs, history, system_prompt):
+    conversation_cnt = len(history) // 2
+    if system_prompt == "": system_prompt = "Hello"
+    messages = [{"role": "user", "content": system_prompt}]
+    messages.append({"role": "assistant", "content": 'Certainly!'})
+    if conversation_cnt:
+        for index in range(0, 2*conversation_cnt, 2):
+            what_i_have_asked = {}
+            what_i_have_asked["role"] = "user"
+            what_i_have_asked["content"] = history[index] if history[index]!="" else "Hello"
+            what_gpt_answer = {}
+            what_gpt_answer["role"] = "assistant"
+            what_gpt_answer["content"] = history[index+1] if history[index]!="" else "Hello"
+            if what_i_have_asked["content"] != "":
+                if what_gpt_answer["content"] == "": continue
+                if what_gpt_answer["content"] == timeout_bot_msg: continue
+                messages.append(what_i_have_asked)
+                messages.append(what_gpt_answer)
+            else:
+                messages[-1]['content'] = what_gpt_answer['content']
+    what_i_ask_now = {}
+    what_i_ask_now["role"] = "user"
+    what_i_ask_now["content"] = inputs
+    messages.append(what_i_ask_now)
+    return messages
+
+
+def generate_from_baidu_qianfan(inputs, llm_kwargs, history, system_prompt):
+    BAIDU_CLOUD_QIANFAN_MODEL,  = get_conf('BAIDU_CLOUD_QIANFAN_MODEL')
+
+    url_lib = {
+        "ERNIE-Bot":            "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions" ,
+        "ERNIE-Bot-turbo":      "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/eb-instant"  ,
+        "BLOOMZ-7B":            "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/bloomz_7b1",
+
+        "Llama-2-70B-Chat":     "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/llama_2_70b",
+        "Llama-2-13B-Chat":     "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/llama_2_13b",
+        "Llama-2-7B-Chat":      "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/llama_2_7b",
+    }
+
+    url = url_lib[BAIDU_CLOUD_QIANFAN_MODEL]
+
+    url += "?access_token=" + get_access_token()
+
+
+    payload = json.dumps({
+        "messages": generate_message_payload(inputs, llm_kwargs, history, system_prompt),
+        "stream": True
+    })
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    response = requests.request("POST", url, headers=headers, data=payload, stream=True)
+    buffer = ""
+    for line in response.iter_lines():
+        if len(line) == 0: continue
+        try:
+            dec = line.decode().lstrip('data:')
+            dec = json.loads(dec)
+            incoming = dec['result']
+            buffer += incoming
+            yield buffer
+        except:
+            if ('error_code' in dec) and ("max length" in dec['error_msg']):
+                raise ConnectionAbortedError(dec['error_msg'])  # 上下文太长导致 token 溢出
+            elif ('error_code' in dec):
+                raise RuntimeError(dec['error_msg'])
+
+
+def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=[], console_slience=False):
+    """
+        ⭐多线程方法
+        函数的说明请见 request_llm/bridge_all.py
+    """
+    watch_dog_patience = 5
+    response = ""
+
+    for response in generate_from_baidu_qianfan(inputs, llm_kwargs, history, sys_prompt):
+        if len(observe_window) >= 1:
+            observe_window[0] = response
+        if len(observe_window) >= 2:
+            if (time.time()-observe_window[1]) > watch_dog_patience: raise RuntimeError("程序终止。")
+    return 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, ""))
+
+    if additional_fn is not None:
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
+    yield from update_ui(chatbot=chatbot, history=history)
+    # 开始接收回复
+    try:
+        for response in generate_from_baidu_qianfan(inputs, llm_kwargs, history, system_prompt):
+            chatbot[-1] = (inputs, response)
+            yield from update_ui(chatbot=chatbot, history=history)
+    except ConnectionAbortedError as e:
+        from .bridge_all import model_info
+        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'], 
+                    max_token_limit=(model_info[llm_kwargs['llm_model']]['max_token'])) # history至少释放二分之一
+        chatbot[-1] = (chatbot[-1][0], "[Local Message] Reduce the length. 本次输入过长, 或历史数据过长. 历史缓存数据已部分释放, 您可以请再次尝试. (若再次失败则更可能是因为输入过长.)")
+        yield from update_ui(chatbot=chatbot, history=history, msg="异常") # 刷新界面
+        return
+    
+    # 总结输出
+    response = f"[Local Message]: {model_name}响应异常 ..."
+    if response == f"[Local Message]: 等待{model_name}响应中 ...":
+        response = f"[Local Message]: {model_name}响应异常 ..."
+    history.extend([inputs, response])
+    yield from update_ui(chatbot=chatbot, history=history)

request_llm/bridge_qwen.py

@@ -0,0 +1,68 @@
+model_name = "Qwen"
+cmd_to_install = "`pip install -r request_llm/requirements_qwen.txt`"
+
+
+from transformers import AutoModel, AutoTokenizer
+import time
+import threading
+import importlib
+from toolbox import update_ui, get_conf
+from multiprocessing import Process, Pipe
+from .local_llm_class import LocalLLMHandle, get_local_llm_predict_fns, SingletonLocalLLM
+
+
+
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 Local Model
+# ------------------------------------------------------------------------------------------------------------------------
+@SingletonLocalLLM
+class GetONNXGLMHandle(LocalLLMHandle):
+
+    def load_model_info(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        self.model_name = model_name
+        self.cmd_to_install = cmd_to_install
+
+    def load_model_and_tokenizer(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        import os, glob
+        import os
+        import platform
+        from modelscope import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
+
+        model_id = 'qwen/Qwen-7B-Chat'
+        revision = 'v1.0.1'
+        self._tokenizer = AutoTokenizer.from_pretrained(model_id, revision=revision, trust_remote_code=True)
+        # use fp16
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto", revision=revision, trust_remote_code=True, fp16=True).eval()
+        model.generation_config = GenerationConfig.from_pretrained(model_id, trust_remote_code=True)  # 可指定不同的生成长度、top_p等相关超参
+        self._model = model
+
+        return self._model, self._tokenizer
+
+    def llm_stream_generator(self, **kwargs):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        def adaptor(kwargs):
+            query = kwargs['query']
+            max_length = kwargs['max_length']
+            top_p = kwargs['top_p']
+            temperature = kwargs['temperature']
+            history = kwargs['history']
+            return query, max_length, top_p, temperature, history
+
+        query, max_length, top_p, temperature, history = adaptor(kwargs)
+
+        for response in self._model.chat(self._tokenizer, query, history=history, stream=True):
+            yield response
+        
+    def try_to_import_special_deps(self, **kwargs):
+        # import something that will raise error if the user does not install requirement_*.txt
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 主进程执行
+        import importlib
+        importlib.import_module('modelscope')
+
+
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 GPT-Academic Interface
+# ------------------------------------------------------------------------------------------------------------------------
+predict_no_ui_long_connection, predict = get_local_llm_predict_fns(GetONNXGLMHandle, model_name)

request_llm/bridge_spark.py

@@ -0,0 +1,50 @@
+
+import time
+import threading
+import importlib
+from toolbox import update_ui, get_conf
+from multiprocessing import Process, Pipe
+
+model_name = '星火认知大模型'
+
+def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=[], console_slience=False):
+    """
+        ⭐多线程方法
+        函数的说明请见 request_llm/bridge_all.py
+    """
+    watch_dog_patience = 5
+    response = ""
+
+    from .com_sparkapi import SparkRequestInstance
+    sri = SparkRequestInstance()
+    for response in sri.generate(inputs, llm_kwargs, history, sys_prompt):
+        if len(observe_window) >= 1:
+            observe_window[0] = response
+        if len(observe_window) >= 2:
+            if (time.time()-observe_window[1]) > watch_dog_patience: raise RuntimeError("程序终止。")
+    return 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, ""))
+    yield from update_ui(chatbot=chatbot, history=history)
+
+    if additional_fn is not None:
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
+    # 开始接收回复    
+    from .com_sparkapi import SparkRequestInstance
+    sri = SparkRequestInstance()
+    for response in sri.generate(inputs, llm_kwargs, history, system_prompt):
+        chatbot[-1] = (inputs, response)
+        yield from update_ui(chatbot=chatbot, history=history)
+
+    # 总结输出
+    if response == f"[Local Message]: 等待{model_name}响应中 ...":
+        response = f"[Local Message]: {model_name}响应异常 ..."
+    history.extend([inputs, response])
+    yield from update_ui(chatbot=chatbot, history=history)

request_llm/bridge_stackclaude.py

@@ -248,14 +248,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
             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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     history_feedin = []
     for i in range(len(history)//2):

request_llm/bridge_tgui.py

@@ -96,11 +96,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
         additional_fn代表点击的哪个按钮，按钮见functional.py
     """
     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"]
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
 
     raw_input = "What I would like to say is the following: " + inputs
     history.extend([inputs, ""])

request_llm/chatglmoonx.py

@@ -0,0 +1,229 @@
+
+
+
+
+
+
+
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 Source Code From https://huggingface.co/K024/ChatGLM-6b-onnx-u8s8/blob/main/model.py
+# ------------------------------------------------------------------------------------------------------------------------
+import re
+import numpy as np
+# import torch
+from onnxruntime import InferenceSession, SessionOptions
+
+
+# Currently `MatMulInteger` and `DynamicQuantizeLinear` are only supported on CPU,
+# although they are documented as supported on CUDA.
+providers = ["CPUExecutionProvider"]
+
+# if torch.cuda.is_available():
+#     providers = ["CUDAExecutionProvider"] + providers
+
+
+# Default paths
+tokenizer_path = "chatglm-6b-int8-onnx-merged/sentencepiece.model"
+onnx_model_path = "chatglm-6b-int8-onnx-merged/chatglm-6b-int8.onnx"
+
+
+# input & output names
+past_names = [f"past_{name}_{i}" for i in range(28) for name in ["key", "value"]]
+present_names = [f"present_{name}_{i}" for i in range(28) for name in ["key", "value"]]
+output_names = ["logits"] + present_names
+
+
+# default kv_cache for first inference
+default_past_key_values = {
+    k: np.zeros((1, 0, 32, 128), dtype=np.float32) for k in past_names
+}
+
+
+def chat_template(history: list[tuple[str, str]], current: str):
+    prompt = ""
+    chat_round = 0
+    for question, answer in history:
+        prompt += f"[Round {chat_round}]\n问：{question}\n答：{answer}\n"
+        chat_round += 1
+    prompt += f"[Round {chat_round}]\n问：{current}\n答："
+    return prompt
+
+
+def process_response(response: str):
+    response = response.strip()
+    response = response.replace("[[训练时间]]", "2023年")
+    punkts = [
+        [",", "，"],
+        ["!", "！"],
+        [":", "："],
+        [";", "；"],
+        ["\?", "？"],
+    ]
+    for item in punkts:
+        response = re.sub(r"([\u4e00-\u9fff])%s" % item[0], r"\1%s" % item[1], response)
+        response = re.sub(r"%s([\u4e00-\u9fff])" % item[0], r"%s\1" % item[1], response)
+    return response
+
+
+class ChatGLMModel():
+
+    def __init__(self, onnx_model_path=onnx_model_path, tokenizer_path=tokenizer_path, profile=False) -> None:
+        self.tokenizer = ChatGLMTokenizer(tokenizer_path)
+        options = SessionOptions()
+        options.enable_profiling = profile
+        self.session = InferenceSession(onnx_model_path, options, providers=providers)
+        self.eop_token_id = self.tokenizer["<eop>"]
+
+
+    def prepare_input(self, prompt: str):
+        input_ids, prefix_mask = self.tokenizer.encode(prompt)
+
+        input_ids = np.array([input_ids], dtype=np.longlong)
+        prefix_mask = np.array([prefix_mask], dtype=np.longlong)
+
+        return input_ids, prefix_mask, default_past_key_values
+
+
+    def sample_next_token(self, logits: np.ndarray, top_k=50, top_p=0.7, temperature=1):
+        # softmax with temperature
+        exp_logits = np.exp(logits / temperature)
+        probs = exp_logits / np.sum(exp_logits)
+
+        # top k
+        top_k_idx = np.argsort(-probs)[:top_k]
+        top_k_probs = probs[top_k_idx]
+
+        # top p
+        cumsum_probs = np.cumsum(top_k_probs)
+        top_k_probs[(cumsum_probs - top_k_probs) > top_p] = 0.0
+        top_k_probs = top_k_probs / np.sum(top_k_probs)
+
+        # sample
+        next_token = np.random.choice(top_k_idx, size=1, p=top_k_probs)
+        return next_token[0].item()
+
+
+    def generate_iterate(self, prompt: str, max_generated_tokens=100, top_k=50, top_p=0.7, temperature=1):
+        input_ids, prefix_mask, past_key_values = self.prepare_input(prompt)
+        output_tokens = []
+
+        while True:
+            inputs = {
+                "input_ids": input_ids,
+                "prefix_mask": prefix_mask,
+                "use_past": np.array(len(output_tokens) > 0),
+            }
+            inputs.update(past_key_values)
+
+            logits, *past_key_values = self.session.run(output_names, inputs)
+            past_key_values = { k: v for k, v in zip(past_names, past_key_values) }
+
+            next_token = self.sample_next_token(logits[0, -1], top_k=top_k, top_p=top_p, temperature=temperature)
+            
+            output_tokens += [next_token]
+
+            if next_token == self.eop_token_id or len(output_tokens) > max_generated_tokens:
+                break
+
+            input_ids = np.array([[next_token]], dtype=np.longlong)
+            prefix_mask = np.concatenate([prefix_mask, np.array([[0]], dtype=np.longlong)], axis=1)
+
+            yield process_response(self.tokenizer.decode(output_tokens))
+
+        return process_response(self.tokenizer.decode(output_tokens))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# ------------------------------------------------------------------------------------------------------------------------
+# 🔌💻 Source Code From https://huggingface.co/K024/ChatGLM-6b-onnx-u8s8/blob/main/tokenizer.py
+# ------------------------------------------------------------------------------------------------------------------------
+
+import re
+from sentencepiece import SentencePieceProcessor
+
+
+def replace_spaces_with_blank(match: re.Match[str]):
+    return f"<|blank_{len(match.group())}|>"
+
+
+def replace_blank_with_spaces(match: re.Match[str]):
+    return " " * int(match.group(1))
+
+
+class ChatGLMTokenizer:
+    def __init__(self, vocab_file):
+        assert vocab_file is not None
+        self.vocab_file = vocab_file
+        self.special_tokens = ["[MASK]", "[gMASK]", "[sMASK]", "<unused_0>", "<sop>", "<eop>", "<ENC>", "<dBLOCK>"]
+        self.text_tokenizer = SentencePieceProcessor(str(vocab_file))
+
+    def __len__(self):
+        return len(self.text_tokenizer)
+
+    def __getitem__(self, key: str):
+        return self.text_tokenizer[key]
+
+
+    def preprocess(self, text: str, linebreak=True, whitespaces=True):
+        if linebreak:
+            text = text.replace("\n", "<n>")
+        if whitespaces:
+            text = text.replace("\t", "<|tab|>")
+            text = re.sub(r" {2,80}", replace_spaces_with_blank, text)
+        return text
+
+
+    def encode(
+        self, text: str, text_pair: str = None,
+        linebreak=True, whitespaces=True,
+        add_dummy_prefix=True, special_tokens=True,
+    ) -> tuple[list[int], list[int]]:
+        """
+        text: Text to encode. Bidirectional part with a [gMASK] and an <sop> for causal LM.
+        text_pair: causal LM part.
+        linebreak: Whether to encode newline (\n) in text.
+        whitespaces: Whether to encode multiple whitespaces or tab in text, useful for source code encoding.
+        special_tokens: Whether to encode special token ([MASK], [gMASK], etc.) in text.
+        add_dummy_prefix: Whether to add dummy blank space in the beginning.
+        """
+        text = self.preprocess(text, linebreak, whitespaces)
+        if not add_dummy_prefix:
+            text = "<n>" + text
+
+        tokens = self.text_tokenizer.encode(text)
+        prefix_mask = [1] * len(tokens)
+        if special_tokens:
+            tokens += [self.text_tokenizer["[gMASK]"], self.text_tokenizer["<sop>"]]
+            prefix_mask += [1, 0]
+
+        if text_pair is not None:
+            text_pair = self.preprocess(text_pair, linebreak, whitespaces)
+            pair_tokens = self.text_tokenizer.encode(text_pair)
+            tokens += pair_tokens
+            prefix_mask += [0] * len(pair_tokens)
+            if special_tokens:
+                tokens += [self.text_tokenizer["<eop>"]]
+                prefix_mask += [0]
+
+        return (tokens if add_dummy_prefix else tokens[2:]), prefix_mask
+
+
+    def decode(self, text_ids: list[int]) -> str:
+        text = self.text_tokenizer.decode(text_ids)
+        text = text.replace("<n>", "\n")
+        text = text.replace("<|tab|>", "\t")
+        text = re.sub(r"<\|blank_(\d\d?)\|>", replace_blank_with_spaces, text)
+        return text
+
+

request_llm/com_sparkapi.py

@@ -0,0 +1,191 @@
+from toolbox import get_conf
+import base64
+import datetime
+import hashlib
+import hmac
+import json
+from urllib.parse import urlparse
+import ssl
+from datetime import datetime
+from time import mktime
+from urllib.parse import urlencode
+from wsgiref.handlers import format_date_time
+import websocket
+import threading, time
+
+timeout_bot_msg = '[Local Message] Request timeout. Network error.'
+
+class Ws_Param(object):
+    # 初始化
+    def __init__(self, APPID, APIKey, APISecret, gpt_url):
+        self.APPID = APPID
+        self.APIKey = APIKey
+        self.APISecret = APISecret
+        self.host = urlparse(gpt_url).netloc
+        self.path = urlparse(gpt_url).path
+        self.gpt_url = gpt_url
+
+    # 生成url
+    def create_url(self):
+        # 生成RFC1123格式的时间戳
+        now = datetime.now()
+        date = format_date_time(mktime(now.timetuple()))
+
+        # 拼接字符串
+        signature_origin = "host: " + self.host + "\n"
+        signature_origin += "date: " + date + "\n"
+        signature_origin += "GET " + self.path + " HTTP/1.1"
+
+        # 进行hmac-sha256进行加密
+        signature_sha = hmac.new(self.APISecret.encode('utf-8'), signature_origin.encode('utf-8'), digestmod=hashlib.sha256).digest()
+        signature_sha_base64 = base64.b64encode(signature_sha).decode(encoding='utf-8')
+        authorization_origin = f'api_key="{self.APIKey}", algorithm="hmac-sha256", headers="host date request-line", signature="{signature_sha_base64}"'
+        authorization = base64.b64encode(authorization_origin.encode('utf-8')).decode(encoding='utf-8')
+
+        # 将请求的鉴权参数组合为字典
+        v = {
+            "authorization": authorization,
+            "date": date,
+            "host": self.host
+        }
+        # 拼接鉴权参数，生成url
+        url = self.gpt_url + '?' + urlencode(v)
+        # 此处打印出建立连接时候的url,参考本demo的时候可取消上方打印的注释，比对相同参数时生成的url与自己代码生成的url是否一致
+        return url
+
+
+
+class SparkRequestInstance():
+    def __init__(self):
+        XFYUN_APPID, XFYUN_API_SECRET, XFYUN_API_KEY = get_conf('XFYUN_APPID', 'XFYUN_API_SECRET', 'XFYUN_API_KEY')
+
+        self.appid = XFYUN_APPID
+        self.api_secret = XFYUN_API_SECRET
+        self.api_key = XFYUN_API_KEY
+        self.gpt_url = "ws://spark-api.xf-yun.com/v1.1/chat"
+        self.gpt_url_v2 = "ws://spark-api.xf-yun.com/v2.1/chat"
+
+        self.time_to_yield_event = threading.Event()
+        self.time_to_exit_event = threading.Event()
+
+        self.result_buf = ""
+
+    def generate(self, inputs, llm_kwargs, history, system_prompt):
+        llm_kwargs = llm_kwargs
+        history = history
+        system_prompt = system_prompt
+        import _thread as thread
+        thread.start_new_thread(self.create_blocking_request, (inputs, llm_kwargs, history, system_prompt))
+        while True:
+            self.time_to_yield_event.wait(timeout=1)
+            if self.time_to_yield_event.is_set():
+                yield self.result_buf
+            if self.time_to_exit_event.is_set():
+                return self.result_buf
+
+
+    def create_blocking_request(self, inputs, llm_kwargs, history, system_prompt):
+        if llm_kwargs['llm_model'] == 'sparkv2':
+            gpt_url = self.gpt_url_v2
+        else:
+            gpt_url = self.gpt_url
+
+        wsParam = Ws_Param(self.appid, self.api_key, self.api_secret, gpt_url)
+        websocket.enableTrace(False)
+        wsUrl = wsParam.create_url()
+
+        # 收到websocket连接建立的处理
+        def on_open(ws):
+            import _thread as thread
+            thread.start_new_thread(run, (ws,))
+
+        def run(ws, *args):
+            data = json.dumps(gen_params(ws.appid, *ws.all_args))
+            ws.send(data)
+
+        # 收到websocket消息的处理
+        def on_message(ws, message):
+            data = json.loads(message)
+            code = data['header']['code']
+            if code != 0:
+                print(f'请求错误: {code}, {data}')
+                ws.close()
+                self.time_to_exit_event.set()
+            else:
+                choices = data["payload"]["choices"]
+                status = choices["status"]
+                content = choices["text"][0]["content"]
+                ws.content += content
+                self.result_buf += content
+                if status == 2:
+                    ws.close()
+                    self.time_to_exit_event.set()
+            self.time_to_yield_event.set()
+
+        # 收到websocket错误的处理
+        def on_error(ws, error):
+            print("error:", error)
+            self.time_to_exit_event.set()
+
+        # 收到websocket关闭的处理
+        def on_close(ws, *args):
+            self.time_to_exit_event.set()
+
+        # websocket
+        ws = websocket.WebSocketApp(wsUrl, on_message=on_message, on_error=on_error, on_close=on_close, on_open=on_open)
+        ws.appid = self.appid
+        ws.content = ""
+        ws.all_args = (inputs, llm_kwargs, history, system_prompt)
+        ws.run_forever(sslopt={"cert_reqs": ssl.CERT_NONE})
+
+def generate_message_payload(inputs, llm_kwargs, history, system_prompt):
+    conversation_cnt = len(history) // 2
+    messages = [{"role": "system", "content": system_prompt}]
+    if conversation_cnt:
+        for index in range(0, 2*conversation_cnt, 2):
+            what_i_have_asked = {}
+            what_i_have_asked["role"] = "user"
+            what_i_have_asked["content"] = history[index]
+            what_gpt_answer = {}
+            what_gpt_answer["role"] = "assistant"
+            what_gpt_answer["content"] = history[index+1]
+            if what_i_have_asked["content"] != "":
+                if what_gpt_answer["content"] == "": continue
+                if what_gpt_answer["content"] == timeout_bot_msg: continue
+                messages.append(what_i_have_asked)
+                messages.append(what_gpt_answer)
+            else:
+                messages[-1]['content'] = what_gpt_answer['content']
+    what_i_ask_now = {}
+    what_i_ask_now["role"] = "user"
+    what_i_ask_now["content"] = inputs
+    messages.append(what_i_ask_now)
+    return messages
+
+
+def gen_params(appid, inputs, llm_kwargs, history, system_prompt):
+    """
+    通过appid和用户的提问来生成请参数
+    """
+    data = {
+        "header": {
+            "app_id": appid,
+            "uid": "1234"
+        },
+        "parameter": {
+            "chat": {
+                "domain": "generalv2" if llm_kwargs['llm_model'] == 'sparkv2' else "general",
+                "temperature": llm_kwargs["temperature"],
+                "random_threshold": 0.5,
+                "max_tokens": 4096,
+                "auditing": "default"
+            }
+        },
+        "payload": {
+            "message": {
+                "text": generate_message_payload(inputs, llm_kwargs, history, system_prompt)
+            }
+        }
+    }
+    return data
+

request_llm/local_llm_class.py

@@ -0,0 +1,180 @@
+from transformers import AutoModel, AutoTokenizer
+import time
+import threading
+import importlib
+from toolbox import update_ui, get_conf, Singleton
+from multiprocessing import Process, Pipe
+
+def SingletonLocalLLM(cls):
+    """
+    一个单实例装饰器
+    """
+    _instance = {}
+    def _singleton(*args, **kargs):
+        if cls not in _instance:
+            _instance[cls] = cls(*args, **kargs)
+            return _instance[cls]
+        elif _instance[cls].corrupted:
+            _instance[cls] = cls(*args, **kargs)
+            return _instance[cls]
+        else:
+            return _instance[cls]
+    return _singleton
+
+class LocalLLMHandle(Process):
+    def __init__(self):
+        # ⭐主进程执行
+        super().__init__(daemon=True)
+        self.corrupted = False
+        self.load_model_info()
+        self.parent, self.child = Pipe()
+        self.running = True
+        self._model = None
+        self._tokenizer = None
+        self.info = ""
+        self.check_dependency()
+        self.start()
+        self.threadLock = threading.Lock()
+
+    def load_model_info(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        raise NotImplementedError("Method not implemented yet")
+        self.model_name = ""
+        self.cmd_to_install = ""
+
+    def load_model_and_tokenizer(self):
+        """
+        This function should return the model and the tokenizer
+        """
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        raise NotImplementedError("Method not implemented yet")
+
+    def llm_stream_generator(self, **kwargs):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        raise NotImplementedError("Method not implemented yet")
+        
+    def try_to_import_special_deps(self, **kwargs):
+        """
+        import something that will raise error if the user does not install requirement_*.txt
+        """
+        # ⭐主进程执行
+        raise NotImplementedError("Method not implemented yet")
+
+    def check_dependency(self):
+        # ⭐主进程执行
+        try:
+            self.try_to_import_special_deps()
+            self.info = "依赖检测通过"
+            self.running = True
+        except:
+            self.info = f"缺少{self.model_name}的依赖，如果要使用{self.model_name}，除了基础的pip依赖以外，您还需要运行{self.cmd_to_install}安装{self.model_name}的依赖。"
+            self.running = False
+
+    def run(self):
+        # 🏃‍♂️🏃‍♂️🏃‍♂️ 子进程执行
+        # 第一次运行，加载参数
+        try:
+            self._model, self._tokenizer = self.load_model_and_tokenizer()
+        except:
+            self.running = False
+            from toolbox import trimmed_format_exc
+            self.child.send(f'[Local Message] 不能正常加载{self.model_name}的参数.' + '\n```\n' + trimmed_format_exc() + '\n```\n')
+            self.child.send('[FinishBad]')
+            raise RuntimeError(f"不能正常加载{self.model_name}的参数！")
+
+        while True:
+            # 进入任务等待状态
+            kwargs = self.child.recv()
+            # 收到消息，开始请求
+            try:
+                for response_full in self.llm_stream_generator(**kwargs):
+                    self.child.send(response_full)
+                self.child.send('[Finish]')
+                # 请求处理结束，开始下一个循环
+            except:
+                from toolbox import trimmed_format_exc
+                self.child.send(f'[Local Message] 调用{self.model_name}失败.' + '\n```\n' + trimmed_format_exc() + '\n```\n')
+                self.child.send('[Finish]')
+
+    def stream_chat(self, **kwargs):
+        # ⭐主进程执行
+        self.threadLock.acquire()
+        self.parent.send(kwargs)
+        while True:
+            res = self.parent.recv()
+            if res == '[Finish]': 
+                break
+            if res == '[FinishBad]': 
+                self.running = False
+                self.corrupted = True
+                break
+            else: 
+                yield res
+        self.threadLock.release()
+    
+
+
+def get_local_llm_predict_fns(LLMSingletonClass, model_name):
+    load_message = f"{model_name}尚未加载，加载需要一段时间。注意，取决于`config.py`的配置，{model_name}消耗大量的内存（CPU）或显存（GPU），也许会导致低配计算机卡死 ……"
+
+    def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=[], console_slience=False):
+        """
+            ⭐多线程方法
+            函数的说明请见 request_llm/bridge_all.py
+        """
+        _llm_handle = LLMSingletonClass()
+        if len(observe_window) >= 1: observe_window[0] = load_message + "\n\n" + _llm_handle.info
+        if not _llm_handle.running: raise RuntimeError(_llm_handle.info)
+
+        # chatglm 没有 sys_prompt 接口，因此把prompt加入 history
+        history_feedin = []
+        history_feedin.append([sys_prompt, "Certainly!"])
+        for i in range(len(history)//2):
+            history_feedin.append([history[2*i], history[2*i+1]] )
+
+        watch_dog_patience = 5 # 看门狗 (watchdog) 的耐心, 设置5秒即可
+        response = ""
+        for response in _llm_handle.stream_chat(query=inputs, history=history_feedin, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
+            if len(observe_window) >= 1:
+                observe_window[0] = response
+            if len(observe_window) >= 2:  
+                if (time.time()-observe_window[1]) > watch_dog_patience: raise RuntimeError("程序终止。")
+        return 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, ""))
+
+        _llm_handle = LLMSingletonClass()
+        chatbot[-1] = (inputs, load_message + "\n\n" + _llm_handle.info)
+        yield from update_ui(chatbot=chatbot, history=[])
+        if not _llm_handle.running: raise RuntimeError(_llm_handle.info)
+
+        if additional_fn is not None:
+            from core_functional import handle_core_functionality
+            inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
+        # 处理历史信息
+        history_feedin = []
+        history_feedin.append([system_prompt, "Certainly!"])
+        for i in range(len(history)//2):
+            history_feedin.append([history[2*i], history[2*i+1]] )
+
+        # 开始接收回复
+        response = f"[Local Message]: 等待{model_name}响应中 ..."
+        for response in _llm_handle.stream_chat(query=inputs, history=history_feedin, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
+            chatbot[-1] = (inputs, response)
+            yield from update_ui(chatbot=chatbot, history=history)
+
+        # 总结输出
+        if response == f"[Local Message]: 等待{model_name}响应中 ...":
+            response = f"[Local Message]: {model_name}响应异常 ..."
+        history.extend([inputs, response])
+        yield from update_ui(chatbot=chatbot, history=history)
+
+    return predict_no_ui_long_connection, predict

request_llm/requirements_chatglm.txt

@@ -1,5 +1,5 @@
 protobuf
-transformers==4.27.1
+transformers>=4.27.1
 cpm_kernels
 torch>=1.10
 mdtex2html

request_llm/requirements_chatglm_onnx.txt

@@ -0,0 +1,11 @@
+protobuf
+transformers>=4.27.1
+cpm_kernels
+torch>=1.10
+mdtex2html
+sentencepiece
+numpy
+onnxruntime
+sentencepiece
+streamlit
+streamlit-chat

request_llm/requirements_qwen.txt

@@ -0,0 +1,2 @@
+modelscope
+transformers_stream_generator

requirements.txt

@@ -19,3 +19,5 @@ numpy
 arxiv
 rich
 pypdf2==2.12.1
+websocket-client
+scipdf_parser==0.3