Update bridge_all.py

supports gpt-4-turbo-preview

Dockerfile

@@ -18,7 +18,6 @@ WORKDIR /gpt
 
 # 安装大部分依赖，利用Docker缓存加速以后的构建 （以下三行，可以删除）
 COPY requirements.txt ./
-COPY ./docs/gradio-3.32.6-py3-none-any.whl ./docs/gradio-3.32.6-py3-none-any.whl
 RUN pip3 install -r requirements.txt
 
 

README.md

@@ -1,6 +1,6 @@
 > [!IMPORTANT]  
-> 2024.1.16: 恭迎GLM4，全力支持Qwen、GLM、DeepseekCoder等国内中文大语言基座模型！
-> 
+> 2024.1.18: 更新3.70版本，支持Mermaid绘图库（让大模型绘制脑图）  
+> 2024.1.17: 恭迎GLM4，全力支持Qwen、GLM、DeepseekCoder等国内中文大语言基座模型！  
 > 2024.1.17: 某些依赖包尚不兼容python 3.12，推荐python 3.11。  
 > 2024.1.17: 安装依赖时，请选择`requirements.txt`中**指定的版本**。 安装命令：`pip install -r requirements.txt`。本项目完全开源免费，您可通过订阅[在线服务](https://github.com/binary-husky/gpt_academic/wiki/online)的方式鼓励本项目的发展。
 
@@ -55,6 +55,11 @@ Read this in [English](docs/README.English.md) | [日本語](docs/README.Japanes
 功能（⭐= 近期新增功能） | 描述
 --- | ---
 ⭐[接入新模型](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)与文心一言, 通义千问[Qwen](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)，[智谱GLM4](https://open.bigmodel.cn/)，DALLE3, [DeepseekCoder](https://coder.deepseek.com/)
+⭐支持mermaid图像渲染 | 支持让GPT生成[流程图](https://www.bilibili.com/video/BV18c41147H9/)、状态转移图、甘特图、饼状图、GitGraph等等（3.7版本）
+⭐Arxiv论文精细翻译 ([Docker](https://github.com/binary-husky/gpt_academic/pkgs/container/gpt_academic_with_latex)) | [插件] 一键[以超高质量翻译arxiv论文](https://www.bilibili.com/video/BV1dz4y1v77A/)，目前最好的论文翻译工具
+⭐[实时语音对话输入](https://github.com/binary-husky/gpt_academic/blob/master/docs/use_audio.md) | [插件] 异步[监听音频](https://www.bilibili.com/video/BV1AV4y187Uy/)，自动断句，自动寻找回答时机
+⭐AutoGen多智能体插件 | [插件] 借助微软AutoGen，探索多Agent的智能涌现可能！
+⭐虚空终端插件 | [插件] 能够使用自然语言直接调度本项目其他插件
 润色、翻译、代码解释 | 一键润色、翻译、查找论文语法错误、解释代码
 [自定义快捷键](https://www.bilibili.com/video/BV14s4y1E7jN) | 支持自定义快捷键
 模块化设计 | 支持自定义强大的[插件](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)
@@ -63,21 +68,16 @@ Read this in [English](docs/README.English.md) | [日本語](docs/README.Japanes
 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/gpt_academic/blob/master/docs/README_EN.md)了吗？就是出自他的手笔
-⭐支持mermaid图像渲染 | 支持让GPT生成[流程图](https://www.bilibili.com/video/BV18c41147H9/)、状态转移图、甘特图、饼状图、GitGraph等等（3.7版本）
 [PDF论文全文翻译功能](https://www.bilibili.com/video/BV1KT411x7Wn) | [插件] PDF论文提取题目&摘要+翻译全文（多线程）
 [Arxiv小助手](https://www.bilibili.com/video/BV1LM4y1279X) | [插件] 输入arxiv文章url即可一键翻译摘要+下载PDF
 Latex论文一键校对 | [插件] 仿Grammarly对Latex文章进行语法、拼写纠错+输出对照PDF
 [谷歌学术统合小助手](https://www.bilibili.com/video/BV19L411U7ia) | [插件] 给定任意谷歌学术搜索页面URL，让gpt帮你[写relatedworks](https://www.bilibili.com/video/BV1GP411U7Az/)
 互联网信息聚合+GPT | [插件] 一键[让GPT从互联网获取信息](https://www.bilibili.com/video/BV1om4y127ck)回答问题，让信息永不过时
-⭐Arxiv论文精细翻译 ([Docker](https://github.com/binary-husky/gpt_academic/pkgs/container/gpt_academic_with_latex)) | [插件] 一键[以超高质量翻译arxiv论文](https://www.bilibili.com/video/BV1dz4y1v77A/)，目前最好的论文翻译工具
-⭐[实时语音对话输入](https://github.com/binary-husky/gpt_academic/blob/master/docs/use_audio.md) | [插件] 异步[监听音频](https://www.bilibili.com/video/BV1AV4y187Uy/)，自动断句，自动寻找回答时机
 公式/图片/表格显示 | 可以同时显示公式的[tex形式和渲染形式](https://user-images.githubusercontent.com/96192199/230598842-1d7fcddd-815d-40ee-af60-baf488a199df.png)，支持公式、代码高亮
-⭐AutoGen多智能体插件 | [插件] 借助微软AutoGen，探索多Agent的智能涌现可能！
 启动暗色[主题](https://github.com/binary-husky/gpt_academic/issues/173) | 在浏览器url后面添加```/?__theme=dark```可以切换dark主题
 [多LLM模型](https://www.bilibili.com/video/BV1wT411p7yf)支持 | 同时被GPT3.5、GPT4、[清华ChatGLM2](https://github.com/THUDM/ChatGLM2-6B)、[复旦MOSS](https://github.com/OpenLMLab/MOSS)伺候的感觉一定会很不错吧？
 更多LLM模型接入，支持[huggingface部署](https://huggingface.co/spaces/qingxu98/gpt-academic) | 加入Newbing接口(新必应)，引入清华[Jittorllms](https://github.com/Jittor/JittorLLMs)支持[LLaMA](https://github.com/facebookresearch/llama)和[盘古α](https://openi.org.cn/pangu/)
 ⭐[void-terminal](https://github.com/binary-husky/void-terminal) pip包 | 脱离GUI，在Python中直接调用本项目的所有函数插件（开发中）
-⭐虚空终端插件 | [插件] 能够使用自然语言直接调度本项目其他插件
 更多新功能展示 (图像生成等) …… | 见本文档结尾处 ……
 </div>
 
@@ -116,6 +116,25 @@ Latex论文一键校对 | [插件] 仿Grammarly对Latex文章进行语法、拼
 <br><br>
 
 # Installation
+
+```mermaid
+flowchart TD
+    A{"安装方法"} --> W1("I. 🔑直接运行 (Windows, Linux or MacOS)")
+    W1 --> W11["1. Python pip包管理依赖"]
+    W1 --> W12["2. Anaconda包管理依赖（推荐⭐）"]
+
+    A --> W2["II. 🐳使用Docker (Windows, Linux or MacOS)"]
+
+    W2 --> k1["1. 部署项目全部能力的大镜像（推荐⭐）"]
+    W2 --> k2["2. 仅在线模型（GPT, GLM4等）镜像"]
+    W2 --> k3["3. 在线模型 + Latex的大镜像"]
+
+    A --> W4["IV. 🚀其他部署方法"]
+    W4 --> C1["1. Windows/MacOS 一键安装运行脚本（推荐⭐）"]
+    W4 --> C2["2. Huggingface, Sealos远程部署"]
+    W4 --> C4["3. ... 其他 ..."]
+```
+
 ### 安装方法I：直接运行 (Windows, Linux or MacOS)
 
 1. 下载项目
@@ -129,7 +148,7 @@ Latex论文一键校对 | [插件] 仿Grammarly对Latex文章进行语法、拼
 
     在`config.py`中，配置API KEY等变量。[特殊网络环境设置方法](https://github.com/binary-husky/gpt_academic/issues/1)、[Wiki-项目配置说明](https://github.com/binary-husky/gpt_academic/wiki/项目配置说明)。
 
-    「 程序会优先检查是否存在名为`config_private.py`的私密配置文件，并用其中的配置覆盖`config.py`的同名配置。如您能理解以上读取逻辑，我们强烈建议您在`config.py`同路径下创建一个名为`config_private.py`的新配置文件，并使用`config_private.py`配置项目，以确保更新或其他用户无法轻易查看您的私有配置 」。
+    「 程序会优先检查是否存在名为`config_private.py`的私密配置文件，并用其中的配置覆盖`config.py`的同名配置。如您能理解以上读取逻辑，我们强烈建议您在`config.py`同路径下创建一个名为`config_private.py`的新配置文件，并使用`config_private.py`配置项目，从而确保自动更新时不会丢失配置 」。
 
     「 支持通过`环境变量`配置项目，环境变量的书写格式参考`docker-compose.yml`文件或者我们的[Wiki页面](https://github.com/binary-husky/gpt_academic/wiki/项目配置说明)。配置读取优先级: `环境变量` > `config_private.py` > `config.py` 」。
 
@@ -324,8 +343,8 @@ Tip：不指定文件直接点击 `载入对话历史存档` 可以查看历史h
 
 
 ### II：版本:
-
-- version 3.70（todo）: 优化AutoGen插件主题并设计一系列衍生插件
+- version 3.80(TODO): 优化AutoGen插件主题并设计一系列衍生插件
+- version 3.70: 引入Mermaid绘图，实现GPT画脑图等功能   
 - version 3.60: 引入AutoGen作为新一代插件的基石
 - version 3.57: 支持GLM3，星火v3，文心一言v4，修复本地模型的并发BUG
 - version 3.56: 支持动态追加基础功能按钮，新汇报PDF汇总页面
@@ -358,6 +377,32 @@ GPT Academic开发者QQ群：`610599535`
     - 某些浏览器翻译插件干扰此软件前端的运行
     - 官方Gradio目前有很多兼容性问题，请**务必使用`requirement.txt`安装Gradio**
 
+```mermaid
+timeline LR
+    title GPT-Academic项目发展历程
+    section 2.x
+        1.0~2.2: 基础功能: 引入模块化函数插件: 可折叠式布局: 函数插件支持热重载
+        2.3~2.5: 增强多线程交互性: 新增PDF全文翻译功能: 新增输入区切换位置的功能: 自更新
+        2.6: 重构了插件结构: 提高了交互性: 加入更多插件
+    section 3.x
+        3.0~3.1: 对chatglm支持: 对其他小型llm支持: 支持同时问询多个gpt模型: 支持多个apikey负载均衡
+        3.2~3.3: 函数插件支持更多参数接口: 保存对话功能: 解读任意语言代码: 同时询问任意的LLM组合: 互联网信息综合功能
+        3.4: 加入arxiv论文翻译: 加入latex论文批改功能
+        3.44: 正式支持Azure: 优化界面易用性
+        3.46: 自定义ChatGLM2微调模型: 实时语音对话
+        3.49: 支持阿里达摩院通义千问: 上海AI-Lab书生: 讯飞星火: 支持百度千帆平台 & 文心一言
+        3.50: 虚空终端: 支持插件分类: 改进UI: 设计新主题
+        3.53: 动态选择不同界面主题: 提高稳定性: 解决多用户冲突问题
+        3.55: 动态代码解释器: 重构前端界面: 引入悬浮窗口与菜单栏
+        3.56: 动态追加基础功能按钮: 新汇报PDF汇总页面
+        3.57: GLM3, 星火v3: 支持文心一言v4: 修复本地模型的并发BUG
+        3.60: 引入AutoGen
+        3.70: 引入Mermaid绘图: 实现GPT画脑图等功能
+        3.80(TODO): 优化AutoGen插件主题: 设计衍生插件
+
+```
+
+
 ### III：主题
 可以通过修改`THEME`选项（config.py）变更主题
 1. `Chuanhu-Small-and-Beautiful` [网址](https://github.com/GaiZhenbiao/ChuanhuChatGPT/)

config.py

@@ -90,9 +90,9 @@ LLM_MODEL = "gpt-3.5-turbo" # 可选 ↓↓↓
 AVAIL_LLM_MODELS = ["gpt-3.5-turbo-1106","gpt-4-1106-preview","gpt-4-vision-preview",
                     "gpt-3.5-turbo-16k", "gpt-3.5-turbo", "azure-gpt-3.5",
                     "gpt-4", "gpt-4-32k", "azure-gpt-4", "api2d-gpt-4",
-                    "gemini-pro", "chatglm3", "moss", "claude-2"]
+                    "gemini-pro", "chatglm3", "claude-2", "zhipuai"]
 # P.S. 其他可用的模型还包括 [
-# "qwen-turbo", "qwen-plus", "qwen-max"
+# "moss", "qwen-turbo", "qwen-plus", "qwen-max"
 # "zhipuai", "qianfan", "deepseekcoder", "llama2", "qwen-local", "gpt-3.5-turbo-0613", 
 # "gpt-3.5-turbo-16k-0613",  "gpt-3.5-random", "api2d-gpt-3.5-turbo", 'api2d-gpt-3.5-turbo-16k',
 # "spark", "sparkv2", "sparkv3", "chatglm_onnx", "claude-1-100k", "claude-2", "internlm", "jittorllms_pangualpha", "jittorllms_llama"
@@ -198,6 +198,12 @@ ZHIPUAI_API_KEY = ""
 ZHIPUAI_MODEL = "glm-4" # 可选 "glm-3-turbo" "glm-4"
 
 
+# # 火山引擎YUNQUE大模型
+# YUNQUE_SECRET_KEY = ""
+# YUNQUE_ACCESS_KEY = ""
+# YUNQUE_MODEL = ""
+
+
 # Claude API KEY
 ANTHROPIC_API_KEY = ""
 

core_functional.py

@@ -3,30 +3,69 @@
 # 'stop' 颜色对应 theme.py 中的 color_er
 import importlib
 from toolbox import clear_line_break
-
+from toolbox import apply_gpt_academic_string_mask_langbased
+from toolbox import build_gpt_academic_masked_string_langbased
+from textwrap import dedent
 
 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"Firstly, you should provide the polished paragraph. "
-                        r"Secondly, you should list all your modification and explain the reasons to do so in markdown table." + "\n\n",
-            # 后缀，会被加在你的输入之后。例如，配合前缀可以把你的输入内容用引号圈起来
+
+        "学术语料润色": {
+            # [1*] 前缀字符串，会被加在你的输入之前。例如，用来描述你的要求，例如翻译、解释代码、润色等等。
+            #      这里填一个提示词字符串就行了，这里为了区分中英文情景搞复杂了一点
+            "Prefix":   build_gpt_academic_masked_string_langbased(
+                            text_show_english=
+                                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"Firstly, you should provide the polished paragraph. "
+                                r"Secondly, you should list all your modification and explain the reasons to do so in markdown table.",
+                            text_show_chinese=
+                                r"作为一名中文学术论文写作改进助理，你的任务是改进所提供文本的拼写、语法、清晰、简洁和整体可读性，"
+                                r"同时分解长句，减少重复，并提供改进建议。请先提供文本的更正版本，然后在markdown表格中列出修改的内容，并给出修改的理由:"
+                        ) + "\n\n",
+            # [2*] 后缀字符串，会被加在你的输入之后。例如，配合前缀可以把你的输入内容用引号圈起来
             "Suffix":   r"",
-            # 按钮颜色 (默认 secondary)
+            # [3] 按钮颜色 (可选参数，默认 secondary)
             "Color":    r"secondary",
-            # 按钮是否可见 (默认 True，即可见)
+            # [4] 按钮是否可见 (可选参数，默认 True，即可见)
             "Visible": True,
-            # 是否在触发时清除历史 (默认 False，即不处理之前的对话历史)
-            "AutoClearHistory": False
+            # [5] 是否在触发时清除历史 (可选参数，默认 False，即不处理之前的对话历史)
+            "AutoClearHistory": False,
+            # [6] 文本预处理 （可选参数，默认 None，举例：写个函数移除所有的换行符）
+            "PreProcess": None,
         },
-        "中文学术润色": {
-            "Prefix":   r"作为一名中文学术论文写作改进助理，你的任务是改进所提供文本的拼写、语法、清晰、简洁和整体可读性，" +
-                        r"同时分解长句，减少重复，并提供改进建议。请只提供文本的更正版本，避免包括解释。请编辑以下文本" + "\n\n",
-            "Suffix":   r"",
+        
+        
+        "总结绘制脑图": {
+            # 前缀，会被加在你的输入之前。例如，用来描述你的要求，例如翻译、解释代码、润色等等
+            "Prefix":   r"",
+            # 后缀，会被加在你的输入之后。例如，配合前缀可以把你的输入内容用引号圈起来
+            "Suffix":
+                # dedent() 函数用于去除多行字符串的缩进
+                dedent("\n"+r'''
+                    ==============================
+
+                    使用mermaid flowchart对以上文本进行总结，概括上述段落的内容以及内在逻辑关系，例如：
+
+                    以下是对以上文本的总结，以mermaid flowchart的形式展示：
+                    ```mermaid
+                    flowchart LR
+                        A["节点名1"] --> B("节点名2")
+                        B --> C{"节点名3"}
+                        C --> D["节点名4"]
+                        C --> |"箭头名1"| E["节点名5"]
+                        C --> |"箭头名2"| F["节点名6"]
+                    ```
+
+                    警告：
+                    （1）使用中文
+                    （2）节点名字使用引号包裹，如["Laptop"]
+                    （3）`|` 和 `"`之间不要存在空格
+                    （4）根据情况选择flowchart LR（从左到右）或者flowchart TD（从上到下）
+                '''),
         },
+        
+        
         "查找语法错误": {
             "Prefix":   r"Help me ensure that the grammar and the spelling is correct. "
                         r"Do not try to polish the text, if no mistake is found, tell me that this paragraph is good. "
@@ -46,42 +85,61 @@ def get_core_functions():
             "Suffix":   r"",
             "PreProcess": clear_line_break,    # 预处理：清除换行符
         },
+        
+        
         "中译英": {
             "Prefix":   r"Please translate following sentence to English:" + "\n\n",
             "Suffix":   r"",
         },
-        "学术中英互译": {
-            "Prefix":   r"I want you to act as a scientific English-Chinese translator, " +
-                        r"I will provide you with some paragraphs in one language " +
-                        r"and your task is to accurately and academically translate the paragraphs only into the other language. " +
-                        r"Do not repeat the original provided paragraphs after translation. " +
-                        r"You should use artificial intelligence tools, " +
-                        r"such as natural language processing, and rhetorical knowledge " +
-                        r"and experience about effective writing techniques to reply. " +
-                        r"I'll give you my paragraphs as follows, tell me what language it is written in, and then translate:" + "\n\n",
-            "Suffix": "",
-            "Color": "secondary",
+        
+        
+        "学术英中互译": {
+            "Prefix":   build_gpt_academic_masked_string_langbased(
+                            text_show_chinese=
+                                r"I want you to act as a scientific English-Chinese translator, "
+                                r"I will provide you with some paragraphs in one language "
+                                r"and your task is to accurately and academically translate the paragraphs only into the other language. "
+                                r"Do not repeat the original provided paragraphs after translation. "
+                                r"You should use artificial intelligence tools, "
+                                r"such as natural language processing, and rhetorical knowledge "
+                                r"and experience about effective writing techniques to reply. "
+                                r"I'll give you my paragraphs as follows, tell me what language it is written in, and then translate:",
+                            text_show_english=
+                                r"你是经验丰富的翻译，请把以下学术文章段落翻译成中文，"
+                                r"并同时充分考虑中文的语法、清晰、简洁和整体可读性，"
+                                r"必要时，你可以修改整个句子的顺序以确保翻译后的段落符合中文的语言习惯。"
+                                r"你需要翻译的文本如下："
+                        ) + "\n\n",
+            "Suffix":   r"",
         },
+        
+        
         "英译中": {
             "Prefix":   r"翻译成地道的中文：" + "\n\n",
             "Suffix":   r"",
-            "Visible": False,
+            "Visible":  False,
         },
+        
+        
         "找图片": {
-            "Prefix":   r"我需要你找一张网络图片。使用Unsplash API(https://source.unsplash.com/960x640/?<英语关键词>)获取图片URL，" +
+            "Prefix":   r"我需要你找一张网络图片。使用Unsplash API(https://source.unsplash.com/960x640/?<英语关键词>)获取图片URL，"
                         r"然后请使用Markdown格式封装，并且不要有反斜线，不要用代码块。现在，请按以下描述给我发送图片：" + "\n\n",
             "Suffix":   r"",
-            "Visible": False,
+            "Visible":  False,
         },
+        
+        
         "解释代码": {
             "Prefix":   r"请解释以下代码：" + "\n```\n",
             "Suffix":   "\n```\n",
         },
+        
+        
         "参考文献转Bib": {
-            "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,
+            "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:" + "\n\n",
+            "Visible":  False,
             "Suffix":   r"",
         }
     }
@@ -98,8 +156,18 @@ def handle_core_functionality(additional_fn, inputs, history, chatbot):
         return inputs, history
     else:
         # 预制功能
-        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 "PreProcess" in core_functional[additional_fn]:
+            if core_functional[additional_fn]["PreProcess"] is not None:
+                inputs = core_functional[additional_fn]["PreProcess"](inputs)  # 获取预处理函数（如果有的话）
+        # 为字符串加上上面定义的前缀和后缀。
+        inputs = apply_gpt_academic_string_mask_langbased(
+            string = core_functional[additional_fn]["Prefix"] + inputs + core_functional[additional_fn]["Suffix"],
+            lang_reference = inputs,
+        )
         if core_functional[additional_fn].get("AutoClearHistory", False):
             history = []
         return inputs, history
+
+if __name__ == "__main__":
+    t = get_core_functions()["总结绘制脑图"]
+    print(t["Prefix"] + t["Suffix"])

crazy_functional.py

@@ -32,115 +32,122 @@ def get_crazy_functions():
     from crazy_functions.理解PDF文档内容 import 理解PDF文档内容标准文件输入
     from crazy_functions.Latex全文润色 import Latex中文润色
     from crazy_functions.Latex全文润色 import Latex英文纠错
-    from crazy_functions.Latex全文翻译 import Latex中译英
-    from crazy_functions.Latex全文翻译 import Latex英译中
     from crazy_functions.批量Markdown翻译 import Markdown中译英
     from crazy_functions.虚空终端 import 虚空终端
-
+    from crazy_functions.生成多种Mermaid图表 import 生成多种Mermaid图表
 
     function_plugins = {
         "虚空终端": {
             "Group": "对话|编程|学术|智能体",
             "Color": "stop",
             "AsButton": True,
-            "Function": HotReload(虚空终端)
+            "Function": HotReload(虚空终端),
         },
         "解析整个Python项目": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": True,
             "Info": "解析一个Python项目的所有源文件(.py) | 输入参数为路径",
-            "Function": HotReload(解析一个Python项目)
+            "Function": HotReload(解析一个Python项目),
         },
         "载入对话历史存档（先上传存档或输入路径）": {
             "Group": "对话",
             "Color": "stop",
             "AsButton": False,
             "Info": "载入对话历史存档 | 输入参数为路径",
-            "Function": HotReload(载入对话历史存档)
+            "Function": HotReload(载入对话历史存档),
         },
         "删除所有本地对话历史记录（谨慎操作）": {
             "Group": "对话",
             "AsButton": False,
             "Info": "删除所有本地对话历史记录，谨慎操作 | 不需要输入参数",
-            "Function": HotReload(删除所有本地对话历史记录)
+            "Function": HotReload(删除所有本地对话历史记录),
         },
         "清除所有缓存文件（谨慎操作）": {
             "Group": "对话",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "清除所有缓存文件，谨慎操作 | 不需要输入参数",
-            "Function": HotReload(清除缓存)
+            "Function": HotReload(清除缓存),
+        },
+        "生成多种Mermaid图表(从当前对话或文件(.pdf/.md)中生产图表）": {
+            "Group": "对话",
+            "Color": "stop",
+            "AsButton": False,
+            "Info" : "基于当前对话或PDF生成多种Mermaid图表,图表类型由模型判断",
+            "Function": HotReload(生成多种Mermaid图表),
+            "AdvancedArgs": True,
+            "ArgsReminder": "请输入图类型对应的数字,不输入则为模型自行判断:1-流程图,2-序列图,3-类图,4-饼图,5-甘特图,6-状态图,7-实体关系图,8-象限提示图,9-思维导图",
         },
         "批量总结Word文档": {
             "Group": "学术",
             "Color": "stop",
             "AsButton": True,
             "Info": "批量总结word文档 | 输入参数为路径",
-            "Function": HotReload(总结word文档)
+            "Function": HotReload(总结word文档),
         },
         "解析整个Matlab项目": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,
             "Info": "解析一个Matlab项目的所有源文件(.m) | 输入参数为路径",
-            "Function": HotReload(解析一个Matlab项目)
+            "Function": HotReload(解析一个Matlab项目),
         },
         "解析整个C++项目头文件": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "解析一个C++项目的所有头文件(.h/.hpp) | 输入参数为路径",
-            "Function": HotReload(解析一个C项目的头文件)
+            "Function": HotReload(解析一个C项目的头文件),
         },
         "解析整个C++项目（.cpp/.hpp/.c/.h）": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "解析一个C++项目的所有源文件（.cpp/.hpp/.c/.h）| 输入参数为路径",
-            "Function": HotReload(解析一个C项目)
+            "Function": HotReload(解析一个C项目),
         },
         "解析整个Go项目": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "解析一个Go项目的所有源文件 | 输入参数为路径",
-            "Function": HotReload(解析一个Golang项目)
+            "Function": HotReload(解析一个Golang项目),
         },
         "解析整个Rust项目": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "解析一个Rust项目的所有源文件 | 输入参数为路径",
-            "Function": HotReload(解析一个Rust项目)
+            "Function": HotReload(解析一个Rust项目),
         },
         "解析整个Java项目": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "解析一个Java项目的所有源文件 | 输入参数为路径",
-            "Function": HotReload(解析一个Java项目)
+            "Function": HotReload(解析一个Java项目),
         },
         "解析整个前端项目（js,ts,css等）": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "解析一个前端项目的所有源文件（js,ts,css等） | 输入参数为路径",
-            "Function": HotReload(解析一个前端项目)
+            "Function": HotReload(解析一个前端项目),
         },
         "解析整个Lua项目": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "解析一个Lua项目的所有源文件 | 输入参数为路径",
-            "Function": HotReload(解析一个Lua项目)
+            "Function": HotReload(解析一个Lua项目),
         },
         "解析整个CSharp项目": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "解析一个CSharp项目的所有源文件 | 输入参数为路径",
-            "Function": HotReload(解析一个CSharp项目)
+            "Function": HotReload(解析一个CSharp项目),
         },
         "解析Jupyter Notebook文件": {
             "Group": "编程",
@@ -156,103 +163,104 @@ def get_crazy_functions():
             "Color": "stop",
             "AsButton": False,
             "Info": "读取Tex论文并写摘要 | 输入参数为路径",
-            "Function": HotReload(读文章写摘要)
+            "Function": HotReload(读文章写摘要),
         },
         "翻译README或MD": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": True,
             "Info": "将Markdown翻译为中文 | 输入参数为路径或URL",
-            "Function": HotReload(Markdown英译中)
+            "Function": HotReload(Markdown英译中),
         },
         "翻译Markdown或README（支持Github链接）": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,
             "Info": "将Markdown或README翻译为中文 | 输入参数为路径或URL",
-            "Function": HotReload(Markdown英译中)
+            "Function": HotReload(Markdown英译中),
         },
         "批量生成函数注释": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "批量生成函数的注释 | 输入参数为路径",
-            "Function": HotReload(批量生成函数注释)
+            "Function": HotReload(批量生成函数注释),
         },
         "保存当前的对话": {
             "Group": "对话",
             "AsButton": True,
             "Info": "保存当前的对话 | 不需要输入参数",
-            "Function": HotReload(对话历史存档)
+            "Function": HotReload(对话历史存档),
         },
         "[多线程Demo]解析此项目本身（源码自译解）": {
             "Group": "对话|编程",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "多线程解析并翻译此项目的源码 | 不需要输入参数",
-            "Function": HotReload(解析项目本身)
+            "Function": HotReload(解析项目本身),
         },
         "历史上的今天": {
             "Group": "对话",
             "AsButton": True,
             "Info": "查看历史上的今天事件 (这是一个面向开发者的插件Demo) | 不需要输入参数",
-            "Function": HotReload(高阶功能模板函数)
+            "Function": HotReload(高阶功能模板函数),
         },
         "精准翻译PDF论文": {
             "Group": "学术",
             "Color": "stop",
-            "AsButton": True,  
+            "AsButton": True,
             "Info": "精准翻译PDF论文为中文 | 输入参数为路径",
-            "Function": HotReload(批量翻译PDF文档)
+            "Function": HotReload(批量翻译PDF文档),
         },
         "询问多个GPT模型": {
             "Group": "对话",
             "Color": "stop",
             "AsButton": True,
-            "Function": HotReload(同时问询)
+            "Function": HotReload(同时问询),
         },
         "批量总结PDF文档": {
             "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "批量总结PDF文档的内容 | 输入参数为路径",
-            "Function": HotReload(批量总结PDF文档)
+            "Function": HotReload(批量总结PDF文档),
         },
         "谷歌学术检索助手（输入谷歌学术搜索页url）": {
             "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "使用谷歌学术检索助手搜索指定URL的结果 | 输入参数为谷歌学术搜索页的URL",
-            "Function": HotReload(谷歌检索小助手)
+            "Function": HotReload(谷歌检索小助手),
         },
         "理解PDF文档内容 （模仿ChatPDF）": {
             "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "理解PDF文档的内容并进行回答 | 输入参数为路径",
-            "Function": HotReload(理解PDF文档内容标准文件输入)
+            "Function": HotReload(理解PDF文档内容标准文件输入),
         },
         "英文Latex项目全文润色（输入路径或上传压缩包）": {
             "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "对英文Latex项目全文进行润色处理 | 输入参数为路径或上传压缩包",
-            "Function": HotReload(Latex英文润色)
-        },
-        "英文Latex项目全文纠错（输入路径或上传压缩包）": {
-            "Group": "学术",
-            "Color": "stop",
-            "AsButton": False,  # 加入下拉菜单中
-            "Info": "对英文Latex项目全文进行纠错处理 | 输入参数为路径或上传压缩包",
-            "Function": HotReload(Latex英文纠错)
+            "Function": HotReload(Latex英文润色),
         },
+
         "中文Latex项目全文润色（输入路径或上传压缩包）": {
             "Group": "学术",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "对中文Latex项目全文进行润色处理 | 输入参数为路径或上传压缩包",
-            "Function": HotReload(Latex中文润色)
+            "Function": HotReload(Latex中文润色),
         },
-
+        # 已经被新插件取代
+        # "英文Latex项目全文纠错（输入路径或上传压缩包）": {
+        #     "Group": "学术",
+        #     "Color": "stop",
+        #     "AsButton": False,  # 加入下拉菜单中
+        #     "Info": "对英文Latex项目全文进行纠错处理 | 输入参数为路径或上传压缩包",
+        #     "Function": HotReload(Latex英文纠错),
+        # },
         # 已经被新插件取代
         # "Latex项目全文中译英（输入路径或上传压缩包）": {
         #     "Group": "学术",
@@ -261,7 +269,6 @@ def get_crazy_functions():
         #     "Info": "对Latex项目全文进行中译英处理 | 输入参数为路径或上传压缩包",
         #     "Function": HotReload(Latex中译英)
         # },
-
         # 已经被新插件取代
         # "Latex项目全文英译中（输入路径或上传压缩包）": {
         #     "Group": "学术",
@@ -270,339 +277,405 @@ def get_crazy_functions():
         #     "Info": "对Latex项目全文进行英译中处理 | 输入参数为路径或上传压缩包",
         #     "Function": HotReload(Latex英译中)
         # },
-        
         "批量Markdown中译英（输入路径或上传压缩包）": {
             "Group": "编程",
             "Color": "stop",
             "AsButton": False,  # 加入下拉菜单中
             "Info": "批量将Markdown文件中文翻译为英文 | 输入参数为路径或上传压缩包",
-            "Function": HotReload(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论文并翻译摘要)
+
+        function_plugins.update(
+            {
+                "一键下载arxiv论文并翻译摘要（先在input输入编号，如1812.10695）": {
+                    "Group": "学术",
+                    "Color": "stop",
+                    "AsButton": False,  # 加入下拉菜单中
+                    # "Info": "下载arxiv论文并翻译摘要 | 输入参数为arxiv编号如1812.10695",
+                    "Function": HotReload(下载arxiv论文并翻译摘要),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.联网的ChatGPT import 连接网络回答问题
-        function_plugins.update({
-            "连接网络回答问题（输入问题后点击该插件，需要访问谷歌）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,  # 加入下拉菜单中
-                # "Info": "连接网络回答问题（需要访问谷歌）| 输入参数是一个问题",
-                "Function": HotReload(连接网络回答问题)
+
+        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搜索回答问题)
+
+        function_plugins.update(
+            {
+                "连接网络回答问题（中文Bing版，输入问题后点击该插件）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,  # 加入下拉菜单中
+                    "Info": "连接网络回答问题（需要访问中文Bing）| 输入参数是一个问题",
+                    "Function": HotReload(连接bing搜索回答问题),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.解析项目源代码 import 解析任意code项目
-        function_plugins.update({
-            "解析项目源代码（手动指定和筛选源代码文件类型）": {
-                "Group": "编程",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "输入时用逗号隔开, *代表通配符, 加了^代表不匹配; 不输入代表全部匹配。例如: \"*.c, ^*.cpp, config.toml, ^*.toml\"",  # 高级参数输入区的显示提示
-                "Function": HotReload(解析任意code项目)
-            },
-        })
+
+        function_plugins.update(
+            {
+                "解析项目源代码（手动指定和筛选源代码文件类型）": {
+                    "Group": "编程",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                    "ArgsReminder": '输入时用逗号隔开, *代表通配符, 加了^代表不匹配; 不输入代表全部匹配。例如: "*.c, ^*.cpp, config.toml, ^*.toml"',  # 高级参数输入区的显示提示
+                    "Function": HotReload(解析任意code项目),
+                },
+            }
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.询问多个大语言模型 import 同时问询_指定模型
-        function_plugins.update({
-            "询问多个GPT模型（手动指定询问哪些模型）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "支持任意数量的llm接口，用&符号分隔。例如chatglm&gpt-3.5-turbo&gpt-4",  # 高级参数输入区的显示提示
-                "Function": HotReload(同时问询_指定模型)
-            },
-        })
+
+        function_plugins.update(
+            {
+                "询问多个GPT模型（手动指定询问哪些模型）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                    "ArgsReminder": "支持任意数量的llm接口，用&符号分隔。例如chatglm&gpt-3.5-turbo&gpt-4",  # 高级参数输入区的显示提示
+                    "Function": HotReload(同时问询_指定模型),
+                },
+            }
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.图片生成 import 图片生成_DALLE2, 图片生成_DALLE3, 图片修改_DALLE2
-        function_plugins.update({
-            "图片生成_DALLE2 （先切换模型到gpt-*）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "在这里输入分辨率, 如1024x1024（默认），支持 256x256, 512x512, 1024x1024",  # 高级参数输入区的显示提示
-                "Info": "使用DALLE2生成图片 | 输入参数字符串，提供图像的内容",
-                "Function": HotReload(图片生成_DALLE2)
-            },
-        })
-        function_plugins.update({
-            "图片生成_DALLE3 （先切换模型到gpt-*）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
-                "ArgsReminder": "在这里输入自定义参数「分辨率-质量(可选)-风格(可选)」, 参数示例「1024x1024-hd-vivid」 || 分辨率支持 「1024x1024」(默认) /「1792x1024」/「1024x1792」 || 质量支持 「-standard」(默认) /「-hd」 || 风格支持 「-vivid」(默认) /「-natural」", # 高级参数输入区的显示提示
-                "Info": "使用DALLE3生成图片 | 输入参数字符串，提供图像的内容",
-                "Function": HotReload(图片生成_DALLE3)
-            },
-        })
-        function_plugins.update({
-            "图片修改_DALLE2 （先切换模型到gpt-*）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": False,  # 调用时，唤起高级参数输入区（默认False）
-                # "Info": "使用DALLE2修改图片 | 输入参数字符串，提供图像的内容",
-                "Function": HotReload(图片修改_DALLE2)
-            },
-        })
+
+        function_plugins.update(
+            {
+                "图片生成_DALLE2 （先切换模型到gpt-*）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                    "ArgsReminder": "在这里输入分辨率, 如1024x1024（默认），支持 256x256, 512x512, 1024x1024",  # 高级参数输入区的显示提示
+                    "Info": "使用DALLE2生成图片 | 输入参数字符串，提供图像的内容",
+                    "Function": HotReload(图片生成_DALLE2),
+                },
+            }
+        )
+        function_plugins.update(
+            {
+                "图片生成_DALLE3 （先切换模型到gpt-*）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,  # 调用时，唤起高级参数输入区（默认False）
+                    "ArgsReminder": "在这里输入自定义参数「分辨率-质量(可选)-风格(可选)」, 参数示例「1024x1024-hd-vivid」 || 分辨率支持 「1024x1024」(默认) /「1792x1024」/「1024x1792」 || 质量支持 「-standard」(默认) /「-hd」 || 风格支持 「-vivid」(默认) /「-natural」",  # 高级参数输入区的显示提示
+                    "Info": "使用DALLE3生成图片 | 输入参数字符串，提供图像的内容",
+                    "Function": HotReload(图片生成_DALLE3),
+                },
+            }
+        )
+        function_plugins.update(
+            {
+                "图片修改_DALLE2 （先切换模型到gpt-*）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": False,  # 调用时，唤起高级参数输入区（默认False）
+                    # "Info": "使用DALLE2修改图片 | 输入参数字符串，提供图像的内容",
+                    "Function": HotReload(图片修改_DALLE2),
+                },
+            }
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         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(总结音视频)
+
+        function_plugins.update(
+            {
+                "批量总结音视频（输入路径或上传压缩包）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": "调用openai api 使用whisper-1模型, 目前支持的格式:mp4, m4a, wav, mpga, mpeg, mp3。此处可以输入解析提示，例如：解析为简体中文（默认）。",
+                    "Info": "批量总结音频或视频 | 输入参数为路径",
+                    "Function": HotReload(总结音视频),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.数学动画生成manim import 动画生成
-        function_plugins.update({
-            "数学动画生成（Manim）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "Info": "按照自然语言描述生成一个动画 | 输入参数是一段话",
-                "Function": HotReload(动画生成)
+
+        function_plugins.update(
+            {
+                "数学动画生成（Manim）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Info": "按照自然语言描述生成一个动画 | 输入参数是一段话",
+                    "Function": HotReload(动画生成),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.批量Markdown翻译 import Markdown翻译指定语言
-        function_plugins.update({
-            "Markdown翻译（指定翻译成何种语言）": {
-                "Group": "编程",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder": "请输入要翻译成哪种语言，默认为Chinese。",
-                "Function": HotReload(Markdown翻译指定语言)
+
+        function_plugins.update(
+            {
+                "Markdown翻译（指定翻译成何种语言）": {
+                    "Group": "编程",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": "请输入要翻译成哪种语言，默认为Chinese。",
+                    "Function": HotReload(Markdown翻译指定语言),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.知识库问答 import 知识库文件注入
-        function_plugins.update({
-            "构建知识库（先上传文件素材,再运行此插件）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder": "此处待注入的知识库名称id, 默认为default。文件进入知识库后可长期保存。可以通过再次调用本插件的方式，向知识库追加更多文档。",
-                "Function": HotReload(知识库文件注入)
+
+        function_plugins.update(
+            {
+                "构建知识库（先上传文件素材,再运行此插件）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": "此处待注入的知识库名称id, 默认为default。文件进入知识库后可长期保存。可以通过再次调用本插件的方式，向知识库追加更多文档。",
+                    "Function": HotReload(知识库文件注入),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.知识库问答 import 读取知识库作答
-        function_plugins.update({
-            "知识库文件注入（构建知识库后,再运行此插件）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "AdvancedArgs": True,
-                "ArgsReminder": "待提取的知识库名称id, 默认为default, 您需要构建知识库后再运行此插件。",
-                "Function": HotReload(读取知识库作答)
+
+        function_plugins.update(
+            {
+                "知识库文件注入（构建知识库后,再运行此插件）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": "待提取的知识库名称id, 默认为default, 您需要构建知识库后再运行此插件。",
+                    "Function": HotReload(读取知识库作答),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.交互功能函数模板 import 交互功能模板函数
-        function_plugins.update({
-            "交互功能模板Demo函数（查找wallhaven.cc的壁纸）": {
-                "Group": "对话",
-                "Color": "stop",
-                "AsButton": False,
-                "Function": HotReload(交互功能模板函数)
+
+        function_plugins.update(
+            {
+                "交互功能模板Demo函数（查找wallhaven.cc的壁纸）": {
+                    "Group": "对话",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Function": HotReload(交互功能模板函数),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        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({
-            "Arxiv论文精细翻译（输入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]": {
+                    "Group": "学术",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "AdvancedArgs": True,
+                    "ArgsReminder": "如果有必要, 请在此处追加更细致的矫错指令（使用英文）。",
+                    "Function": HotReload(Latex英文纠错加PDF对比),
+                },
+                "Arxiv论文精细翻译（输入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),
+                },
+                "本地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),
+                }
             }
-        })
-        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(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from toolbox import get_conf
-        ENABLE_AUDIO = get_conf('ENABLE_AUDIO')
+
+        ENABLE_AUDIO = get_conf("ENABLE_AUDIO")
         if ENABLE_AUDIO:
             from crazy_functions.语音助手 import 语音助手
-            function_plugins.update({
-                "实时语音对话": {
-                    "Group": "对话",
-                    "Color": "stop",
-                    "AsButton": True,
-                    "Info": "这是一个时刻聆听着的语音对话助手 | 没有输入参数",
-                    "Function": HotReload(语音助手)
+
+            function_plugins.update(
+                {
+                    "实时语音对话": {
+                        "Group": "对话",
+                        "Color": "stop",
+                        "AsButton": True,
+                        "Info": "这是一个时刻聆听着的语音对话助手 | 没有输入参数",
+                        "Function": HotReload(语音助手),
+                    }
                 }
-            })
+            )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.批量翻译PDF文档_NOUGAT import 批量翻译PDF文档
-        function_plugins.update({
-            "精准翻译PDF文档（NOUGAT）": {
-                "Group": "学术",
-                "Color": "stop",
-                "AsButton": False,
-                "Function": HotReload(批量翻译PDF文档)
+
+        function_plugins.update(
+            {
+                "精准翻译PDF文档（NOUGAT）": {
+                    "Group": "学术",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Function": HotReload(批量翻译PDF文档),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.函数动态生成 import 函数动态生成
-        function_plugins.update({
-            "动态代码解释器（CodeInterpreter）": {
-                "Group": "智能体",
-                "Color": "stop",
-                "AsButton": False,
-                "Function": HotReload(函数动态生成)
+
+        function_plugins.update(
+            {
+                "动态代码解释器（CodeInterpreter）": {
+                    "Group": "智能体",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Function": HotReload(函数动态生成),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.多智能体 import 多智能体终端
-        function_plugins.update({
-            "AutoGen多智能体终端（仅供测试）": {
-                "Group": "智能体",
-                "Color": "stop",
-                "AsButton": False,
-                "Function": HotReload(多智能体终端)
+
+        function_plugins.update(
+            {
+                "AutoGen多智能体终端（仅供测试）": {
+                    "Group": "智能体",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Function": HotReload(多智能体终端),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
 
     try:
         from crazy_functions.互动小游戏 import 随机小游戏
-        function_plugins.update({
-            "随机互动小游戏（仅供测试）": {
-                "Group": "智能体",
-                "Color": "stop",
-                "AsButton": False,
-                "Function": HotReload(随机小游戏)
+
+        function_plugins.update(
+            {
+                "随机互动小游戏（仅供测试）": {
+                    "Group": "智能体",
+                    "Color": "stop",
+                    "AsButton": False,
+                    "Function": HotReload(随机小游戏),
+                }
             }
-        })
+        )
     except:
         print(trimmed_format_exc())
-        print('Load function plugin failed')
+        print("Load function plugin failed")
+
+    # try:
+    #     from crazy_functions.高级功能函数模板 import 测试图表渲染
+    #     function_plugins.update({
+    #         "绘制逻辑关系（测试图表渲染）": {
+    #             "Group": "智能体",
+    #             "Color": "stop",
+    #             "AsButton": True,
+    #             "Function": HotReload(测试图表渲染)
+    #         }
+    #     })
+    # except:
+    #     print(trimmed_format_exc())
+    #     print('Load function plugin failed')
 
     # try:
     #     from crazy_functions.chatglm微调工具 import 微调数据集生成
@@ -618,8 +691,6 @@ def get_crazy_functions():
     # except:
     #     print('Load function plugin failed')
 
-
-
     """
     设置默认值:
     - 默认 Group = 对话
@@ -629,12 +700,12 @@ def get_crazy_functions():
     """
     for name, function_meta in function_plugins.items():
         if "Group" not in function_meta:
-            function_plugins[name]["Group"] = '对话'
+            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'
+            function_plugins[name]["Color"] = "secondary"
 
     return function_plugins

crazy_functions/CodeInterpreter.py

@@ -137,7 +137,7 @@ def get_recent_file_prompt_support(chatbot):
     return path
 
 @CatchException
-def 虚空终端CodeInterpreter(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 虚空终端CodeInterpreter(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -145,7 +145,7 @@ def 虚空终端CodeInterpreter(txt, llm_kwargs, plugin_kwargs, chatbot, history
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     raise NotImplementedError
 

crazy_functions/Latex全文润色.py

@@ -135,11 +135,11 @@ def 多文件润色(file_manifest, project_folder, llm_kwargs, plugin_kwargs, ch
 
 
 @CatchException
-def Latex英文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex英文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # 基本信息：功能、贡献者
     chatbot.append([
         "函数插件功能？",
-        "对整个Latex项目进行润色。函数插件贡献者: Binary-Husky。（注意，此插件不调用Latex，如果有Latex环境，请使用“Latex英文纠错+高亮”插件）"])
+        "对整个Latex项目进行润色。函数插件贡献者: Binary-Husky。（注意，此插件不调用Latex，如果有Latex环境，请使用「Latex英文纠错+高亮修正位置(需Latex)插件」"])
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
 
     # 尝试导入依赖，如果缺少依赖，则给出安装建议
@@ -173,7 +173,7 @@ def Latex英文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p
 
 
 @CatchException
-def Latex中文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex中文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # 基本信息：功能、贡献者
     chatbot.append([
         "函数插件功能？",
@@ -209,7 +209,7 @@ def Latex中文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p
 
 
 @CatchException
-def Latex英文纠错(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex英文纠错(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # 基本信息：功能、贡献者
     chatbot.append([
         "函数插件功能？",

crazy_functions/Latex全文翻译.py

@@ -106,7 +106,7 @@ def 多文件翻译(file_manifest, project_folder, llm_kwargs, plugin_kwargs, ch
 
 
 @CatchException
-def Latex英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # 基本信息：功能、贡献者
     chatbot.append([
         "函数插件功能？",
@@ -143,7 +143,7 @@ def Latex英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prom
 
 
 @CatchException
-def Latex中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # 基本信息：功能、贡献者
     chatbot.append([
         "函数插件功能？",

crazy_functions/Latex输出PDF结果.py

@@ -1,11 +1,11 @@
 from toolbox import update_ui, trimmed_format_exc, get_conf, get_log_folder, promote_file_to_downloadzone
 from toolbox import CatchException, report_exception, update_ui_lastest_msg, zip_result, gen_time_str
 from functools import partial
-import glob, os, requests, time
+import glob, os, requests, time, tarfile
 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 "智能体". '
 def switch_prompt(pfg, mode, more_requirement):
     """
@@ -104,7 +104,7 @@ def arxiv_download(chatbot, history, txt, allow_cache=True):
     if ('.' in txt) and ('/' not in txt) and is_float(txt[:10]): # is arxiv ID
         txt = 'https://arxiv.org/abs/' + txt[:10]
     if not txt.startswith('https://arxiv.org'): 
-        return txt, None
+        return txt, None    # 是本地文件，跳过下载
     
     # <-------------- inspect format ------------->
     chatbot.append([f"检测到arxiv文档连接", '尝试下载 ...']) 
@@ -142,11 +142,11 @@ def arxiv_download(chatbot, history, txt, allow_cache=True):
     from toolbox import extract_archive
     extract_archive(file_path=dst, dest_dir=extract_dst)
     return extract_dst, arxiv_id
-# ========================================= 插件主程序1 =====================================================    
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= 插件主程序1 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=    
 
 
 @CatchException
-def Latex英文纠错加PDF对比(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex英文纠错加PDF对比(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # <-------------- information about this plugin ------------->
     chatbot.append([ "函数插件功能？",
         "对整个Latex项目进行纠错, 用latex编译为PDF对修正处做高亮。函数插件贡献者: Binary-Husky。注意事项: 目前仅支持GPT3.5/GPT4，其他模型转化效果未知。目前对机器学习类文献转化效果最好，其他类型文献转化效果未知。仅在Windows系统进行了测试，其他操作系统表现未知。"])
@@ -218,10 +218,10 @@ def Latex英文纠错加PDF对比(txt, llm_kwargs, plugin_kwargs, chatbot, histo
     # <-------------- we are done ------------->
     return success
 
-# ========================================= 插件主程序2 =====================================================    
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= 插件主程序2 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=    
 
 @CatchException
-def Latex翻译中文并重新编译PDF(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Latex翻译中文并重新编译PDF(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # <-------------- information about this plugin ------------->
     chatbot.append([
         "函数插件功能？",
@@ -250,7 +250,14 @@ def Latex翻译中文并重新编译PDF(txt, llm_kwargs, plugin_kwargs, chatbot,
 
     # <-------------- clear history and read input ------------->
     history = []
-    txt, arxiv_id = yield from arxiv_download(chatbot, history, txt, allow_cache)
+    try:
+        txt, arxiv_id = yield from arxiv_download(chatbot, history, txt, allow_cache)
+    except tarfile.ReadError as e:
+        yield from update_ui_lastest_msg(
+            "无法自动下载该论文的Latex源码，请前往arxiv打开此论文下载页面，点other Formats，然后download source手动下载latex源码包。接下来调用本地Latex翻译插件即可。", 
+            chatbot=chatbot, history=history)
+        return
+
     if txt.endswith('.pdf'):
         report_exception(chatbot, history, a = f"解析项目: {txt}", b = f"发现已经存在翻译好的PDF文档")
         yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

crazy_functions/agent_fns/general.py

@@ -35,7 +35,11 @@ def gpt_academic_generate_oai_reply(
 class AutoGenGeneral(PluginMultiprocessManager):
     def gpt_academic_print_override(self, user_proxy, message, sender):
         # ⭐⭐ run in subprocess
-        self.child_conn.send(PipeCom("show", sender.name + "\n\n---\n\n" + message["content"]))
+        try:
+            print_msg = sender.name + "\n\n---\n\n" + message["content"]
+        except:
+            print_msg = sender.name + "\n\n---\n\n" + message
+        self.child_conn.send(PipeCom("show", print_msg))
 
     def gpt_academic_get_human_input(self, user_proxy, message):
         # ⭐⭐ run in subprocess
@@ -62,33 +66,33 @@ class AutoGenGeneral(PluginMultiprocessManager):
     def exe_autogen(self, input):
         # ⭐⭐ run in subprocess
         input = input.content
-        with ProxyNetworkActivate("AutoGen"):
-            code_execution_config = {"work_dir": self.autogen_work_dir, "use_docker": self.use_docker}
-            agents = self.define_agents()
-            user_proxy = None
-            assistant = None
-            for agent_kwargs in agents:
-                agent_cls = agent_kwargs.pop('cls')
-                kwargs = {
-                    'llm_config':self.llm_kwargs,
-                    'code_execution_config':code_execution_config
-                }
-                kwargs.update(agent_kwargs)
-                agent_handle = agent_cls(**kwargs)
-                agent_handle._print_received_message = lambda a,b: self.gpt_academic_print_override(agent_kwargs, a, b)
-                for d in agent_handle._reply_func_list:
-                    if hasattr(d['reply_func'],'__name__') and d['reply_func'].__name__ == 'generate_oai_reply':
-                        d['reply_func'] = gpt_academic_generate_oai_reply
-                if agent_kwargs['name'] == 'user_proxy':
-                    agent_handle.get_human_input = lambda a: self.gpt_academic_get_human_input(user_proxy, a)
-                    user_proxy = agent_handle
-                if agent_kwargs['name'] == 'assistant': assistant = agent_handle
-            try:
-                if user_proxy is None or assistant is None: raise Exception("用户代理或助理代理未定义")
+        code_execution_config = {"work_dir": self.autogen_work_dir, "use_docker": self.use_docker}
+        agents = self.define_agents()
+        user_proxy = None
+        assistant = None
+        for agent_kwargs in agents:
+            agent_cls = agent_kwargs.pop('cls')
+            kwargs = {
+                'llm_config':self.llm_kwargs,
+                'code_execution_config':code_execution_config
+            }
+            kwargs.update(agent_kwargs)
+            agent_handle = agent_cls(**kwargs)
+            agent_handle._print_received_message = lambda a,b: self.gpt_academic_print_override(agent_kwargs, a, b)
+            for d in agent_handle._reply_func_list:
+                if hasattr(d['reply_func'],'__name__') and d['reply_func'].__name__ == 'generate_oai_reply':
+                    d['reply_func'] = gpt_academic_generate_oai_reply
+            if agent_kwargs['name'] == 'user_proxy':
+                agent_handle.get_human_input = lambda a: self.gpt_academic_get_human_input(user_proxy, a)
+                user_proxy = agent_handle
+            if agent_kwargs['name'] == 'assistant': assistant = agent_handle
+        try:
+            if user_proxy is None or assistant is None: raise Exception("用户代理或助理代理未定义")
+            with ProxyNetworkActivate("AutoGen"):
                 user_proxy.initiate_chat(assistant, message=input)
-            except Exception as e:
-                tb_str = '```\n' + trimmed_format_exc() + '```'
-                self.child_conn.send(PipeCom("done", "AutoGen 执行失败: \n\n" + tb_str))
+        except Exception as e:
+            tb_str = '```\n' + trimmed_format_exc() + '```'
+            self.child_conn.send(PipeCom("done", "AutoGen 执行失败: \n\n" + tb_str))
 
     def subprocess_worker(self, child_conn):
         # ⭐⭐ run in subprocess

crazy_functions/agent_fns/pipe.py

@@ -9,7 +9,7 @@ class PipeCom:
 
 
 class PluginMultiprocessManager:
-    def __init__(self, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    def __init__(self, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
         # ⭐ run in main process
         self.autogen_work_dir = os.path.join(get_log_folder("autogen"), gen_time_str())
         self.previous_work_dir_files = {}
@@ -18,7 +18,7 @@ class PluginMultiprocessManager:
         self.chatbot = chatbot
         self.history = history
         self.system_prompt = system_prompt
-        # self.web_port = web_port
+        # self.user_request = user_request
         self.alive = True
         self.use_docker = get_conf("AUTOGEN_USE_DOCKER")
         self.last_user_input = ""

crazy_functions/chatglm微调工具.py

@@ -32,7 +32,7 @@ def string_to_options(arguments):
     return args
 
 @CatchException
-def 微调数据集生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 微调数据集生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -40,7 +40,7 @@ def 微调数据集生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     history = []    # 清空历史，以免输入溢出
     chatbot.append(("这是什么功能？", "[Local Message] 微调数据集生成"))
@@ -80,7 +80,7 @@ def 微调数据集生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
 
 
 @CatchException
-def 启动微调(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 启动微调(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -88,7 +88,7 @@ def 启动微调(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     import subprocess
     history = []    # 清空历史，以免输入溢出

crazy_functions/crazy_utils.py

@@ -284,8 +284,7 @@ def request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
         # 在前端打印些好玩的东西
         for thread_index, _ in enumerate(worker_done):
             print_something_really_funny = "[ ...`"+mutable[thread_index][0][-scroller_max_len:].\
-                replace('\n', '').replace('`', '.').replace(
-                    ' ', '.').replace('<br/>', '.....').replace('$', '.')+"`... ]"
+                replace('\n', '').replace('`', '.').replace(' ', '.').replace('<br/>', '.....').replace('$', '.')+"`... ]"
             observe_win.append(print_something_really_funny)
         # 在前端打印些好玩的东西
         stat_str = ''.join([f'`{mutable[thread_index][2]}`: {obs}\n\n' 

crazy_functions/diagram_fns/file_tree.py

@@ -0,0 +1,122 @@
+import os
+from textwrap import indent
+
+class FileNode:
+    def __init__(self, name):
+        self.name = name
+        self.children = []
+        self.is_leaf = False
+        self.level = 0
+        self.parenting_ship = []
+        self.comment = ""
+        self.comment_maxlen_show = 50
+        
+    @staticmethod
+    def add_linebreaks_at_spaces(string, interval=10):
+        return '\n'.join(string[i:i+interval] for i in range(0, len(string), interval))
+
+    def sanitize_comment(self, comment):
+        if len(comment) > self.comment_maxlen_show: suf = '...'
+        else: suf = ''
+        comment = comment[:self.comment_maxlen_show]
+        comment = comment.replace('\"', '').replace('`', '').replace('\n', '').replace('`', '').replace('$', '')
+        comment = self.add_linebreaks_at_spaces(comment, 10)
+        return '`' + comment + suf + '`'
+
+    def add_file(self, file_path, file_comment):
+        directory_names, file_name = os.path.split(file_path)
+        current_node = self
+        level = 1
+        if directory_names == "":
+            new_node = FileNode(file_name)
+            current_node.children.append(new_node)
+            new_node.is_leaf = True
+            new_node.comment = self.sanitize_comment(file_comment)
+            new_node.level = level
+            current_node = new_node
+        else:
+            dnamesplit = directory_names.split(os.sep)
+            for i, directory_name in enumerate(dnamesplit):
+                found_child = False
+                level += 1
+                for child in current_node.children:
+                    if child.name == directory_name:
+                        current_node = child
+                        found_child = True
+                        break
+                if not found_child:
+                    new_node = FileNode(directory_name)
+                    current_node.children.append(new_node)
+                    new_node.level = level - 1
+                    current_node = new_node
+            term = FileNode(file_name)
+            term.level = level
+            term.comment = self.sanitize_comment(file_comment)
+            term.is_leaf = True
+            current_node.children.append(term)
+
+    def print_files_recursively(self, level=0, code="R0"):
+        print('    '*level + self.name + ' ' + str(self.is_leaf) + ' ' + str(self.level))
+        for j, child in enumerate(self.children):
+            child.print_files_recursively(level=level+1, code=code+str(j))
+            self.parenting_ship.extend(child.parenting_ship)
+            p1 = f"""{code}[\"🗎{self.name}\"]""" if self.is_leaf else f"""{code}[[\"📁{self.name}\"]]"""
+            p2 = """ --> """
+            p3 = f"""{code+str(j)}[\"🗎{child.name}\"]""" if child.is_leaf else f"""{code+str(j)}[[\"📁{child.name}\"]]"""
+            edge_code = p1 + p2 + p3
+            if edge_code in self.parenting_ship:
+                continue
+            self.parenting_ship.append(edge_code)
+        if self.comment != "":
+            pc1 = f"""{code}[\"🗎{self.name}\"]""" if self.is_leaf else f"""{code}[[\"📁{self.name}\"]]"""
+            pc2 = f""" -.-x """
+            pc3 = f"""C{code}[\"{self.comment}\"]:::Comment"""
+            edge_code = pc1 + pc2 + pc3
+            self.parenting_ship.append(edge_code)
+
+
+MERMAID_TEMPLATE = r"""
+```mermaid
+flowchart LR
+    %% <gpt_academic_hide_mermaid_code> 一个特殊标记，用于在生成mermaid图表时隐藏代码块
+    classDef Comment stroke-dasharray: 5 5
+    subgraph {graph_name}
+{relationship}
+    end
+```
+"""
+
+def build_file_tree_mermaid_diagram(file_manifest, file_comments, graph_name):
+    # Create the root node
+    file_tree_struct = FileNode("root")
+    # Build the tree structure
+    for file_path, file_comment in zip(file_manifest, file_comments):
+        file_tree_struct.add_file(file_path, file_comment)
+    file_tree_struct.print_files_recursively()
+    cc = "\n".join(file_tree_struct.parenting_ship)
+    ccc = indent(cc, prefix=" "*8)
+    return MERMAID_TEMPLATE.format(graph_name=graph_name, relationship=ccc)
+
+if __name__ == "__main__":
+    # File manifest
+    file_manifest = [
+        "cradle_void_terminal.ipynb",
+        "tests/test_utils.py",
+        "tests/test_plugins.py",
+        "tests/test_llms.py",
+        "config.py",
+        "build/ChatGLM-6b-onnx-u8s8/chatglm-6b-int8-onnx-merged/model_weights_0.bin",
+        "crazy_functions/latex_fns/latex_actions.py",
+        "crazy_functions/latex_fns/latex_toolbox.py"
+    ]
+    file_comments = [
+        "根据位置和名称，可能是一个模块的初始化文件根据位置和名称，可能是一个模块的初始化文件根据位置和名称，可能是一个模块的初始化文件",
+        "包含一些用于文本处理和模型微调的函数和装饰器包含一些用于文本处理和模型微调的函数和装饰器包含一些用于文本处理和模型微调的函数和装饰器",
+        "用于构建HTML报告的类和方法用于构建HTML报告的类和方法用于构建HTML报告的类和方法",
+        "包含了用于文本切分的函数，以及处理PDF文件的示例代码包含了用于文本切分的函数，以及处理PDF文件的示例代码包含了用于文本切分的函数，以及处理PDF文件的示例代码",
+        "用于解析和翻译PDF文件的功能和相关辅助函数用于解析和翻译PDF文件的功能和相关辅助函数用于解析和翻译PDF文件的功能和相关辅助函数",
+        "是一个包的初始化文件，用于初始化包的属性和导入模块是一个包的初始化文件，用于初始化包的属性和导入模块是一个包的初始化文件，用于初始化包的属性和导入模块",
+        "用于加载和分割文件中的文本的通用文件加载器用于加载和分割文件中的文本的通用文件加载器用于加载和分割文件中的文本的通用文件加载器",
+        "包含了用于构建和管理向量数据库的函数和类包含了用于构建和管理向量数据库的函数和类包含了用于构建和管理向量数据库的函数和类",
+    ]
+    print(build_file_tree_mermaid_diagram(file_manifest, file_comments, "项目文件树"))

crazy_functions/latex_fns/latex_toolbox.py

@@ -1,15 +1,18 @@
 import os, shutil
 import re
 import numpy as np
+
 PRESERVE = 0
 TRANSFORM = 1
 
 pj = os.path.join
 
-class LinkedListNode():
+
+class LinkedListNode:
     """
     Linked List Node
     """
+
     def __init__(self, string, preserve=True) -> None:
         self.string = string
         self.preserve = preserve
@@ -18,41 +21,47 @@ class LinkedListNode():
         # self.begin_line = 0
         # self.begin_char = 0
 
+
 def convert_to_linklist(text, mask):
     root = LinkedListNode("", preserve=True)
     current_node = root
     for c, m, i in zip(text, mask, range(len(text))):
-        if (m==PRESERVE and current_node.preserve) \
-            or (m==TRANSFORM and not current_node.preserve):
+        if (m == PRESERVE and current_node.preserve) or (
+            m == TRANSFORM and not current_node.preserve
+        ):
             # add
             current_node.string += c
         else:
-            current_node.next = LinkedListNode(c, preserve=(m==PRESERVE))
+            current_node.next = LinkedListNode(c, preserve=(m == PRESERVE))
             current_node = current_node.next
     return root
 
+
 def post_process(root):
     # 修复括号
     node = root
     while True:
         string = node.string
-        if node.preserve: 
+        if node.preserve:
             node = node.next
-            if node is None: break
+            if node is None:
+                break
             continue
+
         def break_check(string):
-            str_stack = [""] # (lv, index)
+            str_stack = [""]  # (lv, index)
             for i, c in enumerate(string):
-                if c == '{':
-                    str_stack.append('{')
-                elif c == '}':
+                if c == "{":
+                    str_stack.append("{")
+                elif c == "}":
                     if len(str_stack) == 1:
-                        print('stack fix')
+                        print("stack fix")
                         return i
                     str_stack.pop(-1)
                 else:
                     str_stack[-1] += c
             return -1
+
         bp = break_check(string)
 
         if bp == -1:
@@ -69,51 +78,66 @@ def post_process(root):
             node.next = q
 
         node = node.next
-        if node is None: break
+        if node is None:
+            break
 
     # 屏蔽空行和太短的句子
     node = root
     while True:
-        if len(node.string.strip('\n').strip(''))==0: node.preserve = True
-        if len(node.string.strip('\n').strip(''))<42: node.preserve = True
+        if len(node.string.strip("\n").strip("")) == 0:
+            node.preserve = True
+        if len(node.string.strip("\n").strip("")) < 42:
+            node.preserve = True
         node = node.next
-        if node is None: break
+        if node is None:
+            break
     node = root
     while True:
         if node.next and node.preserve and node.next.preserve:
             node.string += node.next.string
             node.next = node.next.next
         node = node.next
-        if node is None: break
+        if node is None:
+            break
 
     # 将前后断行符脱离
     node = root
     prev_node = None
     while True:
         if not node.preserve:
-            lstriped_ = node.string.lstrip().lstrip('\n')
-            if (prev_node is not None) and (prev_node.preserve) and (len(lstriped_)!=len(node.string)):
-                prev_node.string += node.string[:-len(lstriped_)]
+            lstriped_ = node.string.lstrip().lstrip("\n")
+            if (
+                (prev_node is not None)
+                and (prev_node.preserve)
+                and (len(lstriped_) != len(node.string))
+            ):
+                prev_node.string += node.string[: -len(lstriped_)]
                 node.string = lstriped_
-            rstriped_ = node.string.rstrip().rstrip('\n')
-            if (node.next is not None) and (node.next.preserve) and (len(rstriped_)!=len(node.string)):
-                node.next.string = node.string[len(rstriped_):] + node.next.string
+            rstriped_ = node.string.rstrip().rstrip("\n")
+            if (
+                (node.next is not None)
+                and (node.next.preserve)
+                and (len(rstriped_) != len(node.string))
+            ):
+                node.next.string = node.string[len(rstriped_) :] + node.next.string
                 node.string = rstriped_
-        # =====
+        # =-=-=
         prev_node = node
         node = node.next
-        if node is None: break
+        if node is None:
+            break
 
     # 标注节点的行数范围
     node = root
     n_line = 0
     expansion = 2
     while True:
-        n_l = node.string.count('\n')
-        node.range = [n_line-expansion, n_line+n_l+expansion]   # 失败时，扭转的范围
-        n_line = n_line+n_l
+        n_l = node.string.count("\n")
+        node.range = [n_line - expansion, n_line + n_l + expansion]  # 失败时，扭转的范围
+        n_line = n_line + n_l
         node = node.next
-        if node is None: break
+        if node is None:
+            break
     return root
 
 
@@ -128,97 +152,125 @@ def set_forbidden_text(text, mask, pattern, flags=0):
     """
     Add a preserve text area in this paper
     e.g. with pattern = r"\\begin\{algorithm\}(.*?)\\end\{algorithm\}"
-    you can mask out (mask = PRESERVE so that text become untouchable for GPT) 
+    you can mask out (mask = PRESERVE so that text become untouchable for GPT)
     everything between "\begin{equation}" and "\end{equation}"
     """
-    if isinstance(pattern, list): pattern = '|'.join(pattern)
+    if isinstance(pattern, list):
+        pattern = "|".join(pattern)
     pattern_compile = re.compile(pattern, flags)
     for res in pattern_compile.finditer(text):
-        mask[res.span()[0]:res.span()[1]] = PRESERVE
+        mask[res.span()[0] : res.span()[1]] = PRESERVE
     return text, mask
 
+
 def reverse_forbidden_text(text, mask, pattern, flags=0, forbid_wrapper=True):
     """
     Move area out of preserve area (make text editable for GPT)
-    count the number of the braces so as to catch compelete text area. 
+    count the number of the braces so as to catch compelete text area.
     e.g.
-    \begin{abstract} blablablablablabla. \end{abstract} 
+    \begin{abstract} blablablablablabla. \end{abstract}
     """
-    if isinstance(pattern, list): pattern = '|'.join(pattern)
+    if isinstance(pattern, list):
+        pattern = "|".join(pattern)
     pattern_compile = re.compile(pattern, flags)
     for res in pattern_compile.finditer(text):
         if not forbid_wrapper:
-            mask[res.span()[0]:res.span()[1]] = TRANSFORM
+            mask[res.span()[0] : res.span()[1]] = TRANSFORM
         else:
-            mask[res.regs[0][0]: res.regs[1][0]] = PRESERVE   # '\\begin{abstract}'
-            mask[res.regs[1][0]: res.regs[1][1]] = TRANSFORM   # abstract
-            mask[res.regs[1][1]: res.regs[0][1]] = PRESERVE   # abstract
+            mask[res.regs[0][0] : res.regs[1][0]] = PRESERVE  # '\\begin{abstract}'
+            mask[res.regs[1][0] : res.regs[1][1]] = TRANSFORM  # abstract
+            mask[res.regs[1][1] : res.regs[0][1]] = PRESERVE  # abstract
     return text, mask
 
+
 def set_forbidden_text_careful_brace(text, mask, pattern, flags=0):
     """
     Add a preserve text area in this paper (text become untouchable for GPT).
-    count the number of the braces so as to catch compelete text area. 
+    count the number of the braces so as to catch compelete text area.
     e.g.
-    \caption{blablablablabla\texbf{blablabla}blablabla.} 
+    \caption{blablablablabla\texbf{blablabla}blablabla.}
     """
     pattern_compile = re.compile(pattern, flags)
     for res in pattern_compile.finditer(text):
         brace_level = -1
         p = begin = end = res.regs[0][0]
-        for _ in range(1024*16):
-            if text[p] == '}' and brace_level == 0: break
-            elif text[p] == '}':  brace_level -= 1
-            elif text[p] == '{':  brace_level += 1
+        for _ in range(1024 * 16):
+            if text[p] == "}" and brace_level == 0:
+                break
+            elif text[p] == "}":
+                brace_level -= 1
+            elif text[p] == "{":
+                brace_level += 1
             p += 1
-        end = p+1
+        end = p + 1
         mask[begin:end] = PRESERVE
     return text, mask
 
-def reverse_forbidden_text_careful_brace(text, mask, pattern, flags=0, forbid_wrapper=True):
+
+def reverse_forbidden_text_careful_brace(
+    text, mask, pattern, flags=0, forbid_wrapper=True
+):
     """
     Move area out of preserve area (make text editable for GPT)
-    count the number of the braces so as to catch compelete text area. 
+    count the number of the braces so as to catch compelete text area.
     e.g.
-    \caption{blablablablabla\texbf{blablabla}blablabla.} 
+    \caption{blablablablabla\texbf{blablabla}blablabla.}
     """
     pattern_compile = re.compile(pattern, flags)
     for res in pattern_compile.finditer(text):
         brace_level = 0
         p = begin = end = res.regs[1][0]
-        for _ in range(1024*16):
-            if text[p] == '}' and brace_level == 0: break
-            elif text[p] == '}':  brace_level -= 1
-            elif text[p] == '{':  brace_level += 1
+        for _ in range(1024 * 16):
+            if text[p] == "}" and brace_level == 0:
+                break
+            elif text[p] == "}":
+                brace_level -= 1
+            elif text[p] == "{":
+                brace_level += 1
             p += 1
         end = p
         mask[begin:end] = TRANSFORM
         if forbid_wrapper:
-            mask[res.regs[0][0]:begin] = PRESERVE
-            mask[end:res.regs[0][1]] = PRESERVE
+            mask[res.regs[0][0] : begin] = PRESERVE
+            mask[end : res.regs[0][1]] = PRESERVE
     return text, mask
 
+
 def set_forbidden_text_begin_end(text, mask, pattern, flags=0, limit_n_lines=42):
     """
     Find all \begin{} ... \end{} text block that with less than limit_n_lines lines.
     Add it to preserve area
     """
     pattern_compile = re.compile(pattern, flags)
+
     def search_with_line_limit(text, mask):
         for res in pattern_compile.finditer(text):
             cmd = res.group(1)  # begin{what}
-            this = res.group(2) # content between begin and end
-            this_mask = mask[res.regs[2][0]:res.regs[2][1]]
-            white_list = ['document', 'abstract', 'lemma', 'definition', 'sproof', 
-                          'em', 'emph', 'textit', 'textbf', 'itemize', 'enumerate']
-            if (cmd in white_list) or this.count('\n') >= limit_n_lines: # use a magical number 42
+            this = res.group(2)  # content between begin and end
+            this_mask = mask[res.regs[2][0] : res.regs[2][1]]
+            white_list = [
+                "document",
+                "abstract",
+                "lemma",
+                "definition",
+                "sproof",
+                "em",
+                "emph",
+                "textit",
+                "textbf",
+                "itemize",
+                "enumerate",
+            ]
+            if (cmd in white_list) or this.count(
+                "\n"
+            ) >= limit_n_lines:  # use a magical number 42
                 this, this_mask = search_with_line_limit(this, this_mask)
-                mask[res.regs[2][0]:res.regs[2][1]] = this_mask
+                mask[res.regs[2][0] : res.regs[2][1]] = this_mask
             else:
-                mask[res.regs[0][0]:res.regs[0][1]] = PRESERVE
+                mask[res.regs[0][0] : res.regs[0][1]] = PRESERVE
         return text, mask
-    return search_with_line_limit(text, mask) 
 
+    return search_with_line_limit(text, mask)
 
 
 """
@@ -227,6 +279,7 @@ Latex Merge File
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 """
 
+
 def find_main_tex_file(file_manifest, mode):
     """
     在多Tex文档中，寻找主文件，必须包含documentclass，返回找到的第一个。
@@ -234,27 +287,36 @@ def find_main_tex_file(file_manifest, mode):
     """
     canidates = []
     for texf in file_manifest:
-        if os.path.basename(texf).startswith('merge'):
+        if os.path.basename(texf).startswith("merge"):
             continue
-        with open(texf, 'r', encoding='utf8', errors='ignore') as f:
+        with open(texf, "r", encoding="utf8", errors="ignore") as f:
             file_content = f.read()
-        if r'\documentclass' in file_content:
+        if r"\documentclass" in file_content:
             canidates.append(texf)
         else:
             continue
 
     if len(canidates) == 0:
-        raise RuntimeError('无法找到一个主Tex文件（包含documentclass关键字）')
+        raise RuntimeError("无法找到一个主Tex文件（包含documentclass关键字）")
     elif len(canidates) == 1:
         return canidates[0]
-    else: # if len(canidates) >= 2 通过一些Latex模板中常见（但通常不会出现在正文）的单词，对不同latex源文件扣分，取评分最高者返回
+    else:  # if len(canidates) >= 2 通过一些Latex模板中常见（但通常不会出现在正文）的单词，对不同latex源文件扣分，取评分最高者返回
         canidates_score = []
         # 给出一些判定模板文档的词作为扣分项
-        unexpected_words = ['\\LaTeX', 'manuscript', 'Guidelines', 'font', 'citations', 'rejected', 'blind review', 'reviewers']
-        expected_words = ['\\input', '\\ref', '\\cite']
+        unexpected_words = [
+            "\\LaTeX",
+            "manuscript",
+            "Guidelines",
+            "font",
+            "citations",
+            "rejected",
+            "blind review",
+            "reviewers",
+        ]
+        expected_words = ["\\input", "\\ref", "\\cite"]
         for texf in canidates:
             canidates_score.append(0)
-            with open(texf, 'r', encoding='utf8', errors='ignore') as f:
+            with open(texf, "r", encoding="utf8", errors="ignore") as f:
                 file_content = f.read()
                 file_content = rm_comments(file_content)
             for uw in unexpected_words:
@@ -263,9 +325,10 @@ def find_main_tex_file(file_manifest, mode):
             for uw in expected_words:
                 if uw in file_content:
                     canidates_score[-1] += 1
-        select = np.argmax(canidates_score) # 取评分最高者返回
+        select = np.argmax(canidates_score)  # 取评分最高者返回
         return canidates[select]
-    
+
+
 def rm_comments(main_file):
     new_file_remove_comment_lines = []
     for l in main_file.splitlines():
@@ -274,30 +337,39 @@ def rm_comments(main_file):
             pass
         else:
             new_file_remove_comment_lines.append(l)
-    main_file = '\n'.join(new_file_remove_comment_lines)
+    main_file = "\n".join(new_file_remove_comment_lines)
     # main_file = re.sub(r"\\include{(.*?)}", r"\\input{\1}", main_file)  # 将 \include 命令转换为 \input 命令
-    main_file = re.sub(r'(?<!\\)%.*', '', main_file)  # 使用正则表达式查找半行注释, 并替换为空字符串
+    main_file = re.sub(r"(?<!\\)%.*", "", main_file)  # 使用正则表达式查找半行注释, 并替换为空字符串
     return main_file
 
+
 def find_tex_file_ignore_case(fp):
     dir_name = os.path.dirname(fp)
     base_name = os.path.basename(fp)
     # 如果输入的文件路径是正确的
-    if os.path.isfile(pj(dir_name, base_name)): return pj(dir_name, base_name)
+    if os.path.isfile(pj(dir_name, base_name)):
+        return pj(dir_name, base_name)
     # 如果不正确，试着加上.tex后缀试试
-    if not base_name.endswith('.tex'): base_name+='.tex'
-    if os.path.isfile(pj(dir_name, base_name)): return pj(dir_name, base_name)
+    if not base_name.endswith(".tex"):
+        base_name += ".tex"
+    if os.path.isfile(pj(dir_name, base_name)):
+        return pj(dir_name, base_name)
     # 如果还找不到，解除大小写限制，再试一次
     import glob
-    for f in glob.glob(dir_name+'/*.tex'):
+
+    for f in glob.glob(dir_name + "/*.tex"):
         base_name_s = os.path.basename(fp)
         base_name_f = os.path.basename(f)
-        if base_name_s.lower() == base_name_f.lower(): return f
+        if base_name_s.lower() == base_name_f.lower():
+            return f
         # 试着加上.tex后缀试试
-        if not base_name_s.endswith('.tex'): base_name_s+='.tex'
-        if base_name_s.lower() == base_name_f.lower(): return f
+        if not base_name_s.endswith(".tex"):
+            base_name_s += ".tex"
+        if base_name_s.lower() == base_name_f.lower():
+            return f
     return None
 
+
 def merge_tex_files_(project_foler, main_file, mode):
     """
     Merge Tex project recrusively
@@ -309,18 +381,18 @@ def merge_tex_files_(project_foler, main_file, mode):
         fp_ = find_tex_file_ignore_case(fp)
         if fp_:
             try:
-                with open(fp_, 'r', encoding='utf-8', errors='replace') as fx: c = fx.read()
+                with open(fp_, "r", encoding="utf-8", errors="replace") as fx:
+                    c = fx.read()
             except:
                 c = f"\n\nWarning from GPT-Academic: LaTex source file is missing!\n\n"
         else:
-            raise RuntimeError(f'找不到{fp}，Tex源文件缺失！')
+            raise RuntimeError(f"找不到{fp}，Tex源文件缺失！")
         c = merge_tex_files_(project_foler, c, mode)
-        main_file = main_file[:s.span()[0]] + c + main_file[s.span()[1]:]
+        main_file = main_file[: s.span()[0]] + c + main_file[s.span()[1] :]
     return main_file
 
 
 def find_title_and_abs(main_file):
-
     def extract_abstract_1(text):
         pattern = r"\\abstract\{(.*?)\}"
         match = re.search(pattern, text, re.DOTALL)
@@ -362,21 +434,30 @@ def merge_tex_files(project_foler, main_file, mode):
     main_file = merge_tex_files_(project_foler, main_file, mode)
     main_file = rm_comments(main_file)
 
-    if mode == 'translate_zh':
+    if mode == "translate_zh":
         # find paper documentclass
-        pattern = re.compile(r'\\documentclass.*\n')
+        pattern = re.compile(r"\\documentclass.*\n")
         match = pattern.search(main_file)
         assert match is not None, "Cannot find documentclass statement!"
         position = match.end()
-        add_ctex = '\\usepackage{ctex}\n'
-        add_url = '\\usepackage{url}\n' if '{url}' not in main_file else ''
+        add_ctex = "\\usepackage{ctex}\n"
+        add_url = "\\usepackage{url}\n" if "{url}" not in main_file else ""
         main_file = main_file[:position] + add_ctex + add_url + main_file[position:]
         # fontset=windows
         import platform
-        main_file = re.sub(r"\\documentclass\[(.*?)\]{(.*?)}", r"\\documentclass[\1,fontset=windows,UTF8]{\2}",main_file)
-        main_file = re.sub(r"\\documentclass{(.*?)}", r"\\documentclass[fontset=windows,UTF8]{\1}",main_file)
+
+        main_file = re.sub(
+            r"\\documentclass\[(.*?)\]{(.*?)}",
+            r"\\documentclass[\1,fontset=windows,UTF8]{\2}",
+            main_file,
+        )
+        main_file = re.sub(
+            r"\\documentclass{(.*?)}",
+            r"\\documentclass[fontset=windows,UTF8]{\1}",
+            main_file,
+        )
         # find paper abstract
-        pattern_opt1 = re.compile(r'\\begin\{abstract\}.*\n')
+        pattern_opt1 = re.compile(r"\\begin\{abstract\}.*\n")
         pattern_opt2 = re.compile(r"\\abstract\{(.*?)\}", flags=re.DOTALL)
         match_opt1 = pattern_opt1.search(main_file)
         match_opt2 = pattern_opt2.search(main_file)
@@ -385,7 +466,9 @@ def merge_tex_files(project_foler, main_file, mode):
             main_file = insert_abstract(main_file)
         match_opt1 = pattern_opt1.search(main_file)
         match_opt2 = pattern_opt2.search(main_file)
-        assert (match_opt1 is not None) or (match_opt2 is not None), "Cannot find paper abstract section!"
+        assert (match_opt1 is not None) or (
+            match_opt2 is not None
+        ), "Cannot find paper abstract section!"
     return main_file
 
 
@@ -395,6 +478,7 @@ The GPT-Academic program cannot find abstract section in this paper.
 \end{abstract}
 """
 
+
 def insert_abstract(tex_content):
     if "\\maketitle" in tex_content:
         # find the position of "\maketitle"
@@ -402,7 +486,13 @@ def insert_abstract(tex_content):
         # find the nearest ending line
         end_line_index = tex_content.find("\n", find_index)
         # insert "abs_str" on the next line
-        modified_tex = tex_content[:end_line_index+1] + '\n\n' + insert_missing_abs_str + '\n\n' + tex_content[end_line_index+1:]
+        modified_tex = (
+            tex_content[: end_line_index + 1]
+            + "\n\n"
+            + insert_missing_abs_str
+            + "\n\n"
+            + tex_content[end_line_index + 1 :]
+        )
         return modified_tex
     elif r"\begin{document}" in tex_content:
         # find the position of "\maketitle"
@@ -410,29 +500,39 @@ def insert_abstract(tex_content):
         # find the nearest ending line
         end_line_index = tex_content.find("\n", find_index)
         # insert "abs_str" on the next line
-        modified_tex = tex_content[:end_line_index+1] + '\n\n' + insert_missing_abs_str + '\n\n' + tex_content[end_line_index+1:]
+        modified_tex = (
+            tex_content[: end_line_index + 1]
+            + "\n\n"
+            + insert_missing_abs_str
+            + "\n\n"
+            + tex_content[end_line_index + 1 :]
+        )
         return modified_tex
     else:
         return tex_content
 
+
 """
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 Post process
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 """
+
+
 def mod_inbraket(match):
     """
-    为啥chatgpt会把cite里面的逗号换成中文逗号呀 
+    为啥chatgpt会把cite里面的逗号换成中文逗号呀
     """
     # get the matched string
     cmd = match.group(1)
     str_to_modify = match.group(2)
     # modify the matched string
-    str_to_modify = str_to_modify.replace('：', ':')    # 前面是中文冒号，后面是英文冒号
-    str_to_modify = str_to_modify.replace('，', ',')    # 前面是中文逗号，后面是英文逗号
+    str_to_modify = str_to_modify.replace("：", ":")  # 前面是中文冒号，后面是英文冒号
+    str_to_modify = str_to_modify.replace("，", ",")  # 前面是中文逗号，后面是英文逗号
     # str_to_modify = 'BOOM'
     return "\\" + cmd + "{" + str_to_modify + "}"
 
+
 def fix_content(final_tex, node_string):
     """
     Fix common GPT errors to increase success rate
@@ -443,10 +543,10 @@ def fix_content(final_tex, node_string):
     final_tex = re.sub(r"\\([a-z]{2,10})\{([^\}]*?)\}", mod_inbraket, string=final_tex)
 
     if "Traceback" in final_tex and "[Local Message]" in final_tex:
-        final_tex = node_string # 出问题了，还原原文
-    if node_string.count('\\begin') != final_tex.count('\\begin'):
-        final_tex = node_string # 出问题了，还原原文
-    if node_string.count('\_') > 0 and node_string.count('\_') > final_tex.count('\_'):
+        final_tex = node_string  # 出问题了，还原原文
+    if node_string.count("\\begin") != final_tex.count("\\begin"):
+        final_tex = node_string  # 出问题了，还原原文
+    if node_string.count("\_") > 0 and node_string.count("\_") > final_tex.count("\_"):
         # walk and replace any _ without \
         final_tex = re.sub(r"(?<!\\)_", "\\_", final_tex)
 
@@ -454,24 +554,32 @@ def fix_content(final_tex, node_string):
         # this function count the number of { and }
         brace_level = 0
         for c in string:
-            if c == "{": brace_level += 1
-            elif c == "}": brace_level -= 1
+            if c == "{":
+                brace_level += 1
+            elif c == "}":
+                brace_level -= 1
         return brace_level
+
     def join_most(tex_t, tex_o):
         # this function join translated string and original string when something goes wrong
         p_t = 0
         p_o = 0
+
         def find_next(string, chars, begin):
             p = begin
             while p < len(string):
-                if string[p] in chars: return p, string[p]
+                if string[p] in chars:
+                    return p, string[p]
                 p += 1
             return None, None
+
         while True:
-            res1, char = find_next(tex_o, ['{','}'], p_o)
-            if res1 is None: break
+            res1, char = find_next(tex_o, ["{", "}"], p_o)
+            if res1 is None:
+                break
             res2, char = find_next(tex_t, [char], p_t)
-            if res2 is None: break
+            if res2 is None:
+                break
             p_o = res1 + 1
             p_t = res2 + 1
         return tex_t[:p_t] + tex_o[p_o:]
@@ -480,10 +588,14 @@ def fix_content(final_tex, node_string):
         # 出问题了，还原部分原文，保证括号正确
         final_tex = join_most(final_tex, node_string)
     return final_tex
-    
+
+
 def compile_latex_with_timeout(command, cwd, timeout=60):
     import subprocess
-    process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd)
+
+    process = subprocess.Popen(
+        command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd
+    )
     try:
         stdout, stderr = process.communicate(timeout=timeout)
     except subprocess.TimeoutExpired:
@@ -493,43 +605,52 @@ def compile_latex_with_timeout(command, cwd, timeout=60):
         return False
     return True
 
+
 def run_in_subprocess_wrapper_func(func, args, kwargs, return_dict, exception_dict):
     import sys
+
     try:
         result = func(*args, **kwargs)
-        return_dict['result'] = result
+        return_dict["result"] = result
     except Exception as e:
         exc_info = sys.exc_info()
-        exception_dict['exception'] = exc_info
+        exception_dict["exception"] = exc_info
+
 
 def run_in_subprocess(func):
     import multiprocessing
+
     def wrapper(*args, **kwargs):
         return_dict = multiprocessing.Manager().dict()
         exception_dict = multiprocessing.Manager().dict()
-        process = multiprocessing.Process(target=run_in_subprocess_wrapper_func, 
-                                            args=(func, args, kwargs, return_dict, exception_dict))
+        process = multiprocessing.Process(
+            target=run_in_subprocess_wrapper_func,
+            args=(func, args, kwargs, return_dict, exception_dict),
+        )
         process.start()
         process.join()
         process.close()
-        if 'exception' in exception_dict:
+        if "exception" in exception_dict:
             # ooops, the subprocess ran into an exception
-            exc_info = exception_dict['exception']
+            exc_info = exception_dict["exception"]
             raise exc_info[1].with_traceback(exc_info[2])
-        if 'result' in return_dict.keys():
+        if "result" in return_dict.keys():
             # If the subprocess ran successfully, return the result
-            return return_dict['result']
+            return return_dict["result"]
+
     return wrapper
 
+
 def _merge_pdfs(pdf1_path, pdf2_path, output_path):
-    import PyPDF2   # PyPDF2这个库有严重的内存泄露问题，把它放到子进程中运行，从而方便内存的释放
+    import PyPDF2  # PyPDF2这个库有严重的内存泄露问题，把它放到子进程中运行，从而方便内存的释放
+
     Percent = 0.95
     # raise RuntimeError('PyPDF2 has a serious memory leak problem, please use other tools to merge PDF files.')
     # Open the first PDF file
-    with open(pdf1_path, 'rb') as pdf1_file:
+    with open(pdf1_path, "rb") as pdf1_file:
         pdf1_reader = PyPDF2.PdfFileReader(pdf1_file)
         # Open the second PDF file
-        with open(pdf2_path, 'rb') as pdf2_file:
+        with open(pdf2_path, "rb") as pdf2_file:
             pdf2_reader = PyPDF2.PdfFileReader(pdf2_file)
             # Create a new PDF file to store the merged pages
             output_writer = PyPDF2.PdfFileWriter()
@@ -549,14 +670,25 @@ def _merge_pdfs(pdf1_path, pdf2_path, output_path):
                     page2 = PyPDF2.PageObject.createBlankPage(pdf1_reader)
                 # Create a new empty page with double width
                 new_page = PyPDF2.PageObject.createBlankPage(
-                    width = int(int(page1.mediaBox.getWidth()) + int(page2.mediaBox.getWidth()) * Percent),
-                    height = max(page1.mediaBox.getHeight(), page2.mediaBox.getHeight())
+                    width=int(
+                        int(page1.mediaBox.getWidth())
+                        + int(page2.mediaBox.getWidth()) * Percent
+                    ),
+                    height=max(page1.mediaBox.getHeight(), page2.mediaBox.getHeight()),
                 )
                 new_page.mergeTranslatedPage(page1, 0, 0)
-                new_page.mergeTranslatedPage(page2, int(int(page1.mediaBox.getWidth())-int(page2.mediaBox.getWidth())* (1-Percent)), 0)
+                new_page.mergeTranslatedPage(
+                    page2,
+                    int(
+                        int(page1.mediaBox.getWidth())
+                        - int(page2.mediaBox.getWidth()) * (1 - Percent)
+                    ),
+                    0,
+                )
                 output_writer.addPage(new_page)
             # Save the merged PDF file
-            with open(output_path, 'wb') as output_file:
+            with open(output_path, "wb") as output_file:
                 output_writer.write(output_file)
 
-merge_pdfs = run_in_subprocess(_merge_pdfs) # PyPDF2这个库有严重的内存泄露问题，把它放到子进程中运行，从而方便内存的释放
+
+merge_pdfs = run_in_subprocess(_merge_pdfs)  # PyPDF2这个库有严重的内存泄露问题，把它放到子进程中运行，从而方便内存的释放

crazy_functions/下载arxiv论文翻译摘要.py

@@ -130,7 +130,7 @@ def get_name(_url_):
 
 
 @CatchException
-def 下载arxiv论文并翻译摘要(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 下载arxiv论文并翻译摘要(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
 
     CRAZY_FUNCTION_INFO = "下载arxiv论文并翻译摘要，函数插件作者[binary-husky]。正在提取摘要并下载PDF文档……"
     import glob

crazy_functions/互动小游戏.py

@@ -5,7 +5,7 @@ from request_llms.bridge_all import predict_no_ui_long_connection
 from crazy_functions.game_fns.game_utils import get_code_block, is_same_thing
 
 @CatchException
-def 随机小游戏(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 随机小游戏(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     from crazy_functions.game_fns.game_interactive_story import MiniGame_ResumeStory
     # 清空历史
     history = []
@@ -23,7 +23,7 @@ def 随机小游戏(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_
 
 
 @CatchException
-def 随机小游戏1(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 随机小游戏1(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     from crazy_functions.game_fns.game_ascii_art import MiniGame_ASCII_Art
     # 清空历史
     history = []

crazy_functions/交互功能函数模板.py

@@ -3,7 +3,7 @@ from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
 
 
 @CatchException
-def 交互功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 交互功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数, 如温度和top_p等, 一般原样传递下去就行
@@ -11,7 +11,7 @@ def 交互功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     history = []    # 清空历史，以免输入溢出
     chatbot.append(("这是什么功能？", "交互功能函数模板。在执行完成之后, 可以将自身的状态存储到cookie中, 等待用户的再次调用。"))

crazy_functions/函数动态生成.py

@@ -139,7 +139,7 @@ def get_recent_file_prompt_support(chatbot):
     return path
 
 @CatchException
-def 函数动态生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 函数动态生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -147,7 +147,7 @@ def 函数动态生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
 
     # 清空历史

crazy_functions/命令行助手.py

@@ -4,7 +4,7 @@ from .crazy_utils import input_clipping
 import copy, json
 
 @CatchException
-def 命令行助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 命令行助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本, 例如需要翻译的一段话, 再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数, 如温度和top_p等, 一般原样传递下去就行
@@ -12,7 +12,7 @@ def 命令行助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_pro
     chatbot         聊天显示框的句柄, 用于显示给用户
     history         聊天历史, 前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     # 清空历史, 以免输入溢出
     history = []

crazy_functions/图片生成.py

@@ -93,7 +93,7 @@ def edit_image(llm_kwargs, prompt, image_path, resolution="1024x1024", model="da
 
 
 @CatchException
-def 图片生成_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 图片生成_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本,例如需要翻译的一段话,再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数,如温度和top_p等,一般原样传递下去就行
@@ -101,7 +101,7 @@ def 图片生成_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, sys
     chatbot         聊天显示框的句柄,用于显示给用户
     history         聊天历史,前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     history = []    # 清空历史,以免输入溢出
     if prompt.strip() == "":
@@ -123,7 +123,7 @@ def 图片生成_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, sys
 
 
 @CatchException
-def 图片生成_DALLE3(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 图片生成_DALLE3(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史,以免输入溢出
     if prompt.strip() == "":
         chatbot.append((prompt, "[Local Message] 图像生成提示为空白，请在“输入区”输入图像生成提示。"))
@@ -209,7 +209,7 @@ class ImageEditState(GptAcademicState):
         return all([x['value'] is not None for x in self.req])
 
 @CatchException
-def 图片修改_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 图片修改_DALLE2(prompt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # 尚未完成
     history = []    # 清空历史
     state = ImageEditState.get_state(chatbot, ImageEditState)

crazy_functions/多智能体.py

@@ -21,7 +21,7 @@ def remove_model_prefix(llm):
 
 
 @CatchException
-def 多智能体终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 多智能体终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -29,7 +29,7 @@ def 多智能体终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     # 检查当前的模型是否符合要求
     supported_llms = [
@@ -50,14 +50,7 @@ def 多智能体终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
         return
     if model_info[llm_kwargs['llm_model']]["endpoint"] is not None: # 如果不是本地模型，加载API_KEY
         llm_kwargs['api_key'] = select_api_key(llm_kwargs['api_key'], llm_kwargs['llm_model'])
-    
-    # 检查当前的模型是否符合要求
-    API_URL_REDIRECT = get_conf('API_URL_REDIRECT')
-    if len(API_URL_REDIRECT) > 0:
-        chatbot.append([f"处理任务: {txt}", f"暂不支持中转."])
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        return
-    
+
     # 尝试导入依赖，如果缺少依赖，则给出安装建议
     try:
         import autogen
@@ -96,7 +89,7 @@ def 多智能体终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
         history = []
         chatbot.append(["正在启动: 多智能体终端", "插件动态生成, 执行开始, 作者 Microsoft & Binary-Husky."])
         yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-        executor = AutoGenMath(llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port)
+        executor = AutoGenMath(llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request)
         persistent_class_multi_user_manager.set(persistent_key, executor)
         exit_reason = yield from executor.main_process_ui_control(txt, create_or_resume="create")
 

crazy_functions/对话历史存档.py

@@ -69,7 +69,7 @@ def read_file_to_chat(chatbot, history, file_name):
     return chatbot, history    
 
 @CatchException
-def 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -77,7 +77,7 @@ def 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
 
     chatbot.append(("保存当前对话", 
@@ -91,7 +91,7 @@ def hide_cwd(str):
     return str.replace(current_path, replace_path)
 
 @CatchException
-def 载入对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 载入对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -99,7 +99,7 @@ def 载入对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     from .crazy_utils import get_files_from_everything
     success, file_manifest, _ = get_files_from_everything(txt, type='.html')
@@ -126,7 +126,7 @@ def 载入对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
         return
 
 @CatchException
-def 删除所有本地对话历史记录(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 删除所有本地对话历史记录(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -134,7 +134,7 @@ def 删除所有本地对话历史记录(txt, llm_kwargs, plugin_kwargs, chatbot
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
 
     import glob, os

crazy_functions/总结word文档.py

@@ -79,7 +79,7 @@ def 解析docx(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot
 
 
 @CatchException
-def 总结word文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 总结word文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     import glob, os
 
     # 基本信息：功能、贡献者

crazy_functions/批量Markdown翻译.py

@@ -153,7 +153,7 @@ def get_files_from_everything(txt, preference=''):
 
 
 @CatchException
-def Markdown英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Markdown英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # 基本信息：功能、贡献者
     chatbot.append([
         "函数插件功能？",
@@ -193,7 +193,7 @@ def Markdown英译中(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p
 
 
 @CatchException
-def Markdown中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Markdown中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # 基本信息：功能、贡献者
     chatbot.append([
         "函数插件功能？",
@@ -226,7 +226,7 @@ def Markdown中译英(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_p
 
 
 @CatchException
-def Markdown翻译指定语言(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def Markdown翻译指定语言(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # 基本信息：功能、贡献者
     chatbot.append([
         "函数插件功能？",

crazy_functions/批量总结PDF文档.py

@@ -101,7 +101,7 @@ do not have too much repetitive information, numerical values using the original
 
 
 @CatchException
-def 批量总结PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 批量总结PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     import glob, os
 
     # 基本信息：功能、贡献者

crazy_functions/批量总结PDF文档pdfminer.py

@@ -124,7 +124,7 @@ def 解析Paper(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbo
 
 
 @CatchException
-def 批量总结PDF文档pdfminer(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 批量总结PDF文档pdfminer(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史，以免输入溢出
     import glob, os
 

crazy_functions/批量翻译PDF文档_NOUGAT.py

@@ -48,7 +48,7 @@ def markdown_to_dict(article_content):
 
 
 @CatchException
-def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
 
     disable_auto_promotion(chatbot)
     # 基本信息：功能、贡献者

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

@@ -10,7 +10,7 @@ import os
 
 
 @CatchException
-def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 批量翻译PDF文档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
 
     disable_auto_promotion(chatbot)
     # 基本信息：功能、贡献者

crazy_functions/数学动画生成manim.py

@@ -1,6 +1,7 @@
-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 os
+from toolbox import CatchException, update_ui, gen_time_str, promote_file_to_downloadzone
+from crazy_functions.crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
+from crazy_functions.crazy_utils import input_clipping
 
 def inspect_dependency(chatbot, history):
     # 尝试导入依赖，如果缺少依赖，则给出安装建议
@@ -27,9 +28,10 @@ def eval_manim(code):
     class_name = get_class_name(code)
 
     try: 
+        time_str = gen_time_str()
         subprocess.check_output([sys.executable, '-c', f"from gpt_log.MyAnimation import {class_name}; {class_name}().render()"])
-        shutil.move('media/videos/1080p60/{class_name}.mp4', f'gpt_log/{class_name}-{gen_time_str()}.mp4')
-        return f'gpt_log/{gen_time_str()}.mp4'
+        shutil.move(f'media/videos/1080p60/{class_name}.mp4', f'gpt_log/{class_name}-{time_str}.mp4')
+        return f'gpt_log/{time_str}.mp4'
     except subprocess.CalledProcessError as e:
         output = e.output.decode()
         print(f"Command returned non-zero exit status {e.returncode}: {output}.")
@@ -48,7 +50,7 @@ def get_code_block(reply):
     return matches[0].strip('python') #  code block
 
 @CatchException
-def 动画生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 动画生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -56,7 +58,7 @@ def 动画生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     # 清空历史，以免输入溢出
     history = []    
@@ -94,6 +96,8 @@ def 动画生成(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
     res = eval_manim(code)
 
     chatbot.append(("生成的视频文件路径", res))
+    if os.path.exists(res):
+        promote_file_to_downloadzone(res, chatbot=chatbot)
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
 
 # 在这里放一些网上搜集的demo，辅助gpt生成代码

crazy_functions/理解PDF文档内容.py

@@ -63,7 +63,7 @@ def 解析PDF(file_name, llm_kwargs, plugin_kwargs, chatbot, history, system_pro
 
 
 @CatchException
-def 理解PDF文档内容标准文件输入(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 理解PDF文档内容标准文件输入(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     import glob, os
 
     # 基本信息：功能、贡献者

crazy_functions/生成函数注释.py

@@ -36,7 +36,7 @@ def 生成函数注释(file_manifest, project_folder, llm_kwargs, plugin_kwargs,
 
 
 @CatchException
-def 批量生成函数注释(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 批量生成函数注释(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):

crazy_functions/生成多种Mermaid图表.py

@@ -0,0 +1,302 @@
+from toolbox import CatchException, update_ui, report_exception
+from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
+from .crazy_utils import read_and_clean_pdf_text
+import datetime
+
+#以下是每类图表的PROMPT
+SELECT_PROMPT = """
+“{subject}”
+=============
+以上是从文章中提取的摘要,将会使用这些摘要绘制图表。请你选择一个合适的图表类型:
+1 流程图
+2 序列图
+3 类图
+4 饼图
+5 甘特图
+6 状态图
+7 实体关系图
+8 象限提示图
+不需要解释原因，仅需要输出单个不带任何标点符号的数字。
+"""
+#没有思维导图!!!测试发现模型始终会优先选择思维导图
+#流程图
+PROMPT_1 = """
+请你给出围绕“{subject}”的逻辑关系图，使用mermaid语法，mermaid语法举例：
+```mermaid
+graph TD
+    P(编程) --> L1(Python)
+    P(编程) --> L2(C)
+    P(编程) --> L3(C++)
+    P(编程) --> L4(Javascipt)
+    P(编程) --> L5(PHP)
+```
+"""
+#序列图
+PROMPT_2 = """
+请你给出围绕“{subject}”的序列图，使用mermaid语法，mermaid语法举例：
+```mermaid
+sequenceDiagram
+    participant A as 用户
+    participant B as 系统
+    A->>B: 登录请求
+    B->>A: 登录成功
+    A->>B: 获取数据
+    B->>A: 返回数据
+```
+"""
+#类图
+PROMPT_3 = """
+请你给出围绕“{subject}”的类图，使用mermaid语法，mermaid语法举例：
+```mermaid
+classDiagram
+    Class01 <|-- AveryLongClass : Cool
+    Class03 *-- Class04
+    Class05 o-- Class06
+    Class07 .. Class08
+    Class09 --> C2 : Where am i?
+    Class09 --* C3
+    Class09 --|> Class07
+    Class07 : equals()
+    Class07 : Object[] elementData
+    Class01 : size()
+    Class01 : int chimp
+    Class01 : int gorilla
+    Class08 <--> C2: Cool label
+```
+"""
+#饼图
+PROMPT_4 = """
+请你给出围绕“{subject}”的饼图，使用mermaid语法，mermaid语法举例：
+```mermaid
+pie title Pets adopted by volunteers
+    "狗" : 386
+    "猫" : 85
+    "兔子" : 15
+```
+"""
+#甘特图
+PROMPT_5 = """
+请你给出围绕“{subject}”的甘特图，使用mermaid语法，mermaid语法举例：
+```mermaid
+gantt
+    title 项目开发流程
+    dateFormat  YYYY-MM-DD
+    section 设计
+    需求分析 :done, des1, 2024-01-06,2024-01-08
+    原型设计 :active, des2, 2024-01-09, 3d
+    UI设计 : des3, after des2, 5d
+    section 开发
+    前端开发 :2024-01-20, 10d
+    后端开发 :2024-01-20, 10d
+```
+"""
+#状态图
+PROMPT_6 = """
+请你给出围绕“{subject}”的状态图，使用mermaid语法，mermaid语法举例：
+```mermaid
+stateDiagram-v2
+   [*] --> Still
+    Still --> [*]
+    Still --> Moving
+    Moving --> Still
+    Moving --> Crash
+    Crash --> [*]
+```
+"""
+#实体关系图
+PROMPT_7 = """
+请你给出围绕“{subject}”的实体关系图，使用mermaid语法，mermaid语法举例：
+```mermaid
+erDiagram
+    CUSTOMER ||--o{ ORDER : places
+    ORDER ||--|{ LINE-ITEM : contains
+    CUSTOMER {
+        string name
+        string id
+    }
+    ORDER {
+        string orderNumber
+        date orderDate
+        string customerID
+    }
+    LINE-ITEM {
+        number quantity
+        string productID
+    }
+```
+"""
+#象限提示图
+PROMPT_8 = """
+请你给出围绕“{subject}”的象限图，使用mermaid语法，mermaid语法举例：
+```mermaid
+graph LR
+    A[Hard skill] --> B(Programming)
+    A[Hard skill] --> C(Design)
+    D[Soft skill] --> E(Coordination)
+    D[Soft skill] --> F(Communication)
+```
+"""
+#思维导图
+PROMPT_9 = """
+{subject}
+==========
+请给出上方内容的思维导图，充分考虑其之间的逻辑，使用mermaid语法，mermaid语法举例：
+```mermaid
+mindmap
+  root((mindmap))
+    Origins
+      Long history
+      ::icon(fa fa-book)
+      Popularisation
+        British popular psychology author Tony Buzan
+    Research
+      On effectiveness<br/>and features
+      On Automatic creation
+        Uses
+            Creative techniques
+            Strategic planning
+            Argument mapping
+    Tools
+      Pen and paper
+      Mermaid
+```
+"""
+
+def 解析历史输入(history,llm_kwargs,chatbot,plugin_kwargs):
+    ############################## <第 0 步，切割输入> ##################################
+    # 借用PDF切割中的函数对文本进行切割
+    TOKEN_LIMIT_PER_FRAGMENT = 2500
+    txt = str(history).encode('utf-8', 'ignore').decode()   # avoid reading non-utf8 chars
+    from crazy_functions.pdf_fns.breakdown_txt import breakdown_text_to_satisfy_token_limit
+    txt = breakdown_text_to_satisfy_token_limit(txt=txt, limit=TOKEN_LIMIT_PER_FRAGMENT, llm_model=llm_kwargs['llm_model'])
+    ############################## <第 1 步，迭代地历遍整个文章，提取精炼信息> ##################################
+    i_say_show_user = f'首先你从历史记录或文件中提取摘要。'; gpt_say = "[Local Message] 收到。"   # 用户提示
+    chatbot.append([i_say_show_user, gpt_say]); yield from update_ui(chatbot=chatbot, history=history)    # 更新UI
+    results = []
+    MAX_WORD_TOTAL = 4096
+    n_txt = len(txt)
+    last_iteration_result = "从以下文本中提取摘要。"
+    if n_txt >= 20: print('文章极长，不能达到预期效果')
+    for i in range(n_txt):
+        NUM_OF_WORD = MAX_WORD_TOTAL // n_txt
+        i_say = f"Read this section, recapitulate the content of this section with less than {NUM_OF_WORD} words: {txt[i]}"
+        i_say_show_user = f"[{i+1}/{n_txt}] Read this section, recapitulate the content of this section with less than {NUM_OF_WORD} words: {txt[i][:200]} ...."
+        gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(i_say, i_say_show_user,  # i_say=真正给chatgpt的提问， i_say_show_user=给用户看的提问
+                                                                           llm_kwargs, chatbot, 
+                                                                           history=["The main content of the previous section is?", last_iteration_result], # 迭代上一次的结果
+                                                                           sys_prompt="Extracts the main content from the text section where it is located for graphing purposes, answer me with Chinese."  # 提示
+                                                                        ) 
+        results.append(gpt_say)
+        last_iteration_result = gpt_say
+    ############################## <第 2 步，根据整理的摘要选择图表类型> ##################################
+    if ("advanced_arg" in plugin_kwargs) and (plugin_kwargs["advanced_arg"] == ""): plugin_kwargs.pop("advanced_arg")
+    gpt_say = plugin_kwargs.get("advanced_arg", "")     #将图表类型参数赋值为插件参数  
+    results_txt = '\n'.join(results)    #合并摘要
+    if gpt_say not in ['1','2','3','4','5','6','7','8','9']:    #如插件参数不正确则使用对话模型判断
+        i_say_show_user = f'接下来将判断适合的图表类型,如连续3次判断失败将会使用流程图进行绘制'; gpt_say = "[Local Message] 收到。"   # 用户提示
+        chatbot.append([i_say_show_user, gpt_say]); yield from update_ui(chatbot=chatbot, history=[])    # 更新UI
+        i_say = SELECT_PROMPT.format(subject=results_txt)
+        i_say_show_user = f'请判断适合使用的流程图类型,其中数字对应关系为:1-流程图,2-序列图,3-类图,4-饼图,5-甘特图,6-状态图,7-实体关系图,8-象限提示图。由于不管提供文本是什么,模型大概率认为"思维导图"最合适,因此思维导图仅能通过参数调用。'
+        for i in range(3):
+            gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+                inputs=i_say,
+                inputs_show_user=i_say_show_user,
+                llm_kwargs=llm_kwargs, chatbot=chatbot, history=[], 
+                sys_prompt=""
+            )
+            if gpt_say in ['1','2','3','4','5','6','7','8','9']:     #判断返回是否正确
+                break
+        if gpt_say not in ['1','2','3','4','5','6','7','8','9']:
+            gpt_say = '1'
+    ############################## <第 3 步，根据选择的图表类型绘制图表> ##################################
+    if gpt_say == '1':
+        i_say = PROMPT_1.format(subject=results_txt)
+    elif gpt_say == '2':
+        i_say = PROMPT_2.format(subject=results_txt)
+    elif gpt_say == '3':
+        i_say = PROMPT_3.format(subject=results_txt)
+    elif gpt_say == '4':
+        i_say = PROMPT_4.format(subject=results_txt)
+    elif gpt_say == '5':
+        i_say = PROMPT_5.format(subject=results_txt)
+    elif gpt_say == '6':
+        i_say = PROMPT_6.format(subject=results_txt)
+    elif gpt_say == '7':
+        i_say = PROMPT_7.replace("{subject}", results_txt)      #由于实体关系图用到了{}符号
+    elif gpt_say == '8':
+        i_say = PROMPT_8.format(subject=results_txt)
+    elif gpt_say == '9':
+        i_say = PROMPT_9.format(subject=results_txt)
+    i_say_show_user = f'请根据判断结果绘制相应的图表。如需绘制思维导图请使用参数调用,同时过大的图表可能需要复制到在线编辑器中进行渲染。'
+    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+        inputs=i_say,
+        inputs_show_user=i_say_show_user,
+        llm_kwargs=llm_kwargs, chatbot=chatbot, history=[], 
+        sys_prompt="你精通使用mermaid语法来绘制图表,首先确保语法正确,其次避免在mermaid语法中使用不允许的字符,此外也应当分考虑图表的可读性。"
+    )
+    history.append(gpt_say)
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+
+def 输入区文件处理(txt):
+    if txt == "": return False, txt
+    success = True
+    import glob
+    from .crazy_utils import get_files_from_everything
+    file_pdf,pdf_manifest,folder_pdf = get_files_from_everything(txt, '.pdf')
+    file_md,md_manifest,folder_md = get_files_from_everything(txt, '.md')
+    if len(pdf_manifest) == 0 and len(md_manifest) == 0:
+        return False, txt   #如输入区内容不是文件则直接返回输入区内容
+    
+    final_result = ""
+    if file_pdf:
+        for index, fp in enumerate(pdf_manifest):
+            file_content, page_one = read_and_clean_pdf_text(fp) # （尝试）按照章节切割PDF
+            file_content = file_content.encode('utf-8', 'ignore').decode()   # avoid reading non-utf8 chars
+            final_result += "\n" + file_content
+    if file_md:
+        for index, fp in enumerate(md_manifest):
+            with open(fp, 'r', encoding='utf-8', errors='replace') as f:
+                file_content = f.read()
+            file_content = file_content.encode('utf-8', 'ignore').decode()
+            final_result += "\n" + file_content
+    return True, final_result
+    
+@CatchException
+def 生成多种Mermaid图表(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        当前软件运行的端口号
+    """
+    import os
+
+    # 基本信息：功能、贡献者
+    chatbot.append([
+        "函数插件功能？", 
+        "根据当前聊天历史或文件中(文件内容优先)绘制多种mermaid图表，将会由对话模型首先判断适合的图表类型，随后绘制图表。\
+        \n您也可以使用插件参数指定绘制的图表类型,函数插件贡献者: Menghuan1918"])
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+
+    # 尝试导入依赖，如果缺少依赖，则给出安装建议
+    try:
+        import fitz
+    except:
+        report_exception(chatbot, history, 
+            a = f"解析项目: {txt}", 
+            b = f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade pymupdf```。")
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+        return
+    
+    if os.path.exists(txt):     #如输入区无内容则直接解析历史记录
+        file_exist, txt = 输入区文件处理(txt)
+    else:
+        file_exist = False
+
+    if file_exist : history = []    #如输入区内容为文件则清空历史记录
+    history.append(txt)     #将解析后的txt传递加入到历史中
+    
+    yield from 解析历史输入(history,llm_kwargs,chatbot,plugin_kwargs)  

crazy_functions/知识库问答.py

@@ -13,7 +13,7 @@ install_msg ="""
 """
 
 @CatchException
-def 知识库文件注入(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 知识库文件注入(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数, 如温度和top_p等, 一般原样传递下去就行
@@ -21,7 +21,7 @@ def 知识库文件注入(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     history = []    # 清空历史，以免输入溢出
 
@@ -84,7 +84,7 @@ def 知识库文件注入(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
 
 @CatchException
-def 读取知识库作答(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port=-1):
+def 读取知识库作答(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request=-1):
     # resolve deps
     try:
         # from zh_langchain import construct_vector_store

crazy_functions/联网的ChatGPT.py

@@ -55,7 +55,7 @@ def scrape_text(url, proxies) -> str:
     return text
 
 @CatchException
-def 连接网络回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 连接网络回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -63,7 +63,7 @@ def 连接网络回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     history = []    # 清空历史，以免输入溢出
     chatbot.append((f"请结合互联网信息回答以下问题：{txt}", 

crazy_functions/联网的ChatGPT_bing版.py

@@ -55,7 +55,7 @@ def scrape_text(url, proxies) -> str:
     return text
 
 @CatchException
-def 连接bing搜索回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 连接bing搜索回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -63,7 +63,7 @@ def 连接bing搜索回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, histor
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     history = []    # 清空历史，以免输入溢出
     chatbot.append((f"请结合互联网信息回答以下问题：{txt}",

crazy_functions/虚空终端.py

@@ -104,7 +104,7 @@ def analyze_intention_with_simple_rules(txt):
 
 
 @CatchException
-def 虚空终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 虚空终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     disable_auto_promotion(chatbot=chatbot)
     # 获取当前虚空终端状态
     state = VoidTerminalState.get_state(chatbot)
@@ -121,7 +121,7 @@ def 虚空终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
         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)
+        yield from 虚空终端主路由(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request)
         return
     else:
         # 如果意图模糊，提示
@@ -133,7 +133,7 @@ def 虚空终端(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
 
 
 
-def 虚空终端主路由(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 虚空终端主路由(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []
     chatbot.append(("虚空终端状态: ", f"正在执行任务: {txt}"))
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

crazy_functions/解析JupyterNotebook.py

@@ -109,7 +109,7 @@ def ipynb解释(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbo
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
 
 @CatchException
-def 解析ipynb文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析ipynb文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     chatbot.append([
         "函数插件功能？",
         "对IPynb文件进行解析。Contributor: codycjy."])

crazy_functions/解析项目源代码.py

@@ -83,7 +83,8 @@ def 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs,
             history=this_iteration_history_feed,   # 迭代之前的分析
             sys_prompt="你是一个程序架构分析师，正在分析一个项目的源代码。" + sys_prompt_additional)
         
-        summary = "请用一句话概括这些文件的整体功能"
+        diagram_code = make_diagram(this_iteration_files, result, this_iteration_history_feed)
+        summary = "请用一句话概括这些文件的整体功能。\n\n" + diagram_code
         summary_result = yield from request_gpt_model_in_new_thread_with_ui_alive(
             inputs=summary, 
             inputs_show_user=summary, 
@@ -104,9 +105,12 @@ def 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs,
     chatbot.append(("完成了吗？", res))
     yield from update_ui(chatbot=chatbot, history=history_to_return) # 刷新界面
 
+def make_diagram(this_iteration_files, result, this_iteration_history_feed):
+    from crazy_functions.diagram_fns.file_tree import build_file_tree_mermaid_diagram
+    return build_file_tree_mermaid_diagram(this_iteration_history_feed[0::2], this_iteration_history_feed[1::2], "项目示意图")
 
 @CatchException
-def 解析项目本身(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析项目本身(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史，以免输入溢出
     import glob
     file_manifest = [f for f in glob.glob('./*.py')] + \
@@ -119,7 +123,7 @@ def 解析项目本身(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_
     yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)
 
 @CatchException
-def 解析一个Python项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Python项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):
@@ -137,7 +141,7 @@ def 解析一个Python项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
     yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)
 
 @CatchException
-def 解析一个Matlab项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Matlab项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):
@@ -155,7 +159,7 @@ def 解析一个Matlab项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
     yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)
 
 @CatchException
-def 解析一个C项目的头文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个C项目的头文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):
@@ -175,7 +179,7 @@ def 解析一个C项目的头文件(txt, llm_kwargs, plugin_kwargs, chatbot, his
     yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)
 
 @CatchException
-def 解析一个C项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个C项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):
@@ -197,7 +201,7 @@ def 解析一个C项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system
 
 
 @CatchException
-def 解析一个Java项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Java项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []  # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):
@@ -219,7 +223,7 @@ def 解析一个Java项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, sys
 
 
 @CatchException
-def 解析一个前端项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个前端项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []  # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):
@@ -248,7 +252,7 @@ def 解析一个前端项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
 
 
 @CatchException
-def 解析一个Golang项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Golang项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []  # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):
@@ -269,7 +273,7 @@ def 解析一个Golang项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
     yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)
 
 @CatchException
-def 解析一个Rust项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Rust项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []  # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):
@@ -289,7 +293,7 @@ def 解析一个Rust项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, sys
     yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)
 
 @CatchException
-def 解析一个Lua项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个Lua项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):
@@ -311,7 +315,7 @@ def 解析一个Lua项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
 
 
 @CatchException
-def 解析一个CSharp项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析一个CSharp项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):
@@ -331,7 +335,7 @@ def 解析一个CSharp项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
 
 
 @CatchException
-def 解析任意code项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 解析任意code项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     txt_pattern = plugin_kwargs.get("advanced_arg")
     txt_pattern = txt_pattern.replace("，", ",")
     # 将要匹配的模式(例如: *.c, *.cpp, *.py, config.toml)

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

@@ -2,7 +2,7 @@ from toolbox import CatchException, update_ui, get_conf
 from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
 import datetime
 @CatchException
-def 同时问询(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 同时问询(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -10,7 +10,7 @@ def 同时问询(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     history = []    # 清空历史，以免输入溢出
     MULTI_QUERY_LLM_MODELS = get_conf('MULTI_QUERY_LLM_MODELS')
@@ -32,7 +32,7 @@ def 同时问询(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
 
 
 @CatchException
-def 同时问询_指定模型(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 同时问询_指定模型(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
@@ -40,7 +40,7 @@ def 同时问询_指定模型(txt, llm_kwargs, plugin_kwargs, chatbot, history,
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     history = []    # 清空历史，以免输入溢出
 

crazy_functions/语音助手.py

@@ -166,7 +166,7 @@ class InterviewAssistant(AliyunASR):
 
 
 @CatchException
-def 语音助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 语音助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     # pip install -U openai-whisper
     chatbot.append(["对话助手函数插件：使用时，双手离开鼠标键盘吧", "音频助手, 正在听您讲话（点击“停止”键可终止程序）..."])
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面

crazy_functions/读文章写摘要.py

@@ -44,7 +44,7 @@ def 解析Paper(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbo
 
 
 @CatchException
-def 读文章写摘要(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 读文章写摘要(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     history = []    # 清空历史，以免输入溢出
     import glob, os
     if os.path.exists(txt):

crazy_functions/谷歌检索小助手.py

@@ -132,7 +132,7 @@ def get_meta_information(url, chatbot, history):
     return profile
 
 @CatchException
-def 谷歌检索小助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 谷歌检索小助手(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     disable_auto_promotion(chatbot=chatbot)
     # 基本信息：功能、贡献者
     chatbot.append([

crazy_functions/辅助功能.py

@@ -11,7 +11,7 @@ import os
 
 
 @CatchException
-def 猜你想问(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 猜你想问(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     if txt:
         show_say = txt
         prompt = txt+'\n回答完问题后，再列出用户可能提出的三个问题。'
@@ -32,7 +32,7 @@ def 猜你想问(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
 
 
 @CatchException
-def 清除缓存(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 清除缓存(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     chatbot.append(['清除本地缓存数据', '执行中. 删除数据'])
     yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
 

crazy_functions/高级功能函数模板.py

@@ -1,19 +1,47 @@
 from toolbox import CatchException, update_ui
-from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
+from crazy_functions.crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
 import datetime
+
+高阶功能模板函数示意图 = f"""
+```mermaid
+flowchart TD
+    %% <gpt_academic_hide_mermaid_code> 一个特殊标记，用于在生成mermaid图表时隐藏代码块
+    subgraph 函数调用["函数调用过程"]
+        AA["输入栏用户输入的文本(txt)"] --> BB["gpt模型参数(llm_kwargs)"]
+        BB --> CC["插件模型参数(plugin_kwargs)"]
+        CC --> DD["对话显示框的句柄(chatbot)"]
+        DD --> EE["对话历史(history)"]
+        EE --> FF["系统提示词(system_prompt)"]
+        FF --> GG["当前用户信息(web_port)"]
+
+        A["开始(查询5天历史事件)"]
+        A --> B["获取当前月份和日期"]
+        B --> C["生成历史事件查询提示词"]
+        C --> D["调用大模型"]
+        D --> E["更新界面"]
+        E --> F["记录历史"]
+        F --> |"下一天"| B
+    end
+```
+"""
+
 @CatchException
-def 高阶功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+def 高阶功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
     """
+    # 高阶功能模板函数示意图：https://mermaid.live/edit#pako:eNptk1tvEkEYhv8KmattQpvlvOyFCcdeeaVXuoYssBwie8gyhCIlqVoLhrbbtAWNUpEGUkyMEDW2Fmn_DDOL_8LZHdOwxrnamX3f7_3mmZk6yKhZCfAgV1KrmYKoQ9fDuKC4yChX0nld1Aou1JzjznQ5fWmejh8LYHW6vG2a47YAnlCLNSIRolnenKBXI_zRIBrcuqRT890u7jZx7zMDt-AaMbnW1--5olGiz2sQjwfoQxsZL0hxplSSU0-rop4vrzmKR6O2JxYjHmwcL2Y_HDatVMkXlf86YzHbGY9bO5j8XE7O8Nsbc3iNB3ukL2SMcH-XIQBgWoVOZzxuOxOJOyc63EPGV6ZQLENVrznViYStTiaJ2vw2M2d9bByRnOXkgCnXylCSU5quyto_IcmkbdvctELmJ-j1ASW3uB3g5xOmKqVTmqr_Na3AtuS_dtBFm8H90XJyHkDDT7S9xXWb4HGmRChx64AOL5HRpUm411rM5uh4H78Z4V7fCZzytjZz2seto9XaNPFue07clLaVZF8UNLygJ-VES8lah_n-O-5Ozc7-77NzJ0-K0yr0ZYrmHdqAk50t2RbA4qq9uNohBASw7YpSgaRkLWCCAtxAlnRZLGbJba9bPwUAC5IsCYAnn1kpJ1ZKUACC0iBSsQLVBzUlA3ioVyQ3qGhZEUrxokiehAz4nFgqk1VNVABfB1uAD_g2_AGPl-W8nMcbCvsDblADfNCz4feyobDPy3rYEMtxwYYbPFNVUoHdCPmDHBv2cP4AMfrCbiBli-Q-3afv0X6WdsIjW2-10fgDy1SAig
+
     txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
     llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
     plugin_kwargs   插件模型的参数，用于灵活调整复杂功能的各种参数
     chatbot         聊天显示框的句柄，用于显示给用户
     history         聊天历史，前情提要
     system_prompt   给gpt的静默提醒
-    web_port        当前软件运行的端口号
+    user_request    当前用户的请求信息（IP地址等）
     """
     history = []    # 清空历史，以免输入溢出
-    chatbot.append(("这是什么功能？", "[Local Message] 请注意，您正在调用一个[函数插件]的模板，该函数面向希望实现更多有趣功能的开发者，它可以作为创建新功能函数的模板（该函数只有20多行代码）。此外我们也提供可同步处理大量文件的多线程Demo供您参考。您若希望分享新的功能模组，请不吝PR！"))
+    chatbot.append((
+        "您正在调用插件：历史上的今天", 
+        "[Local Message] 请注意，您正在调用一个[函数插件]的模板，该函数面向希望实现更多有趣功能的开发者，它可以作为创建新功能函数的模板（该函数只有20多行代码）。此外我们也提供可同步处理大量文件的多线程Demo供您参考。您若希望分享新的功能模组，请不吝PR！" + 高阶功能模板函数示意图))
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
     for i in range(5):
         currentMonth = (datetime.date.today() + datetime.timedelta(days=i)).month
@@ -26,4 +54,46 @@ def 高阶功能模板函数(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
         )
         chatbot[-1] = (i_say, gpt_say)
         history.append(i_say);history.append(gpt_say)
-        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+
+
+
+
+PROMPT = """
+请你给出围绕“{subject}”的逻辑关系图，使用mermaid语法，mermaid语法举例：
+```mermaid
+graph TD
+    P(编程) --> L1(Python)
+    P(编程) --> L2(C)
+    P(编程) --> L3(C++)
+    P(编程) --> L4(Javascipt)
+    P(编程) --> L5(PHP)
+```
+"""
+@CatchException
+def 测试图表渲染(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request):
+    """
+    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
+    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
+    plugin_kwargs   插件模型的参数，用于灵活调整复杂功能的各种参数
+    chatbot         聊天显示框的句柄，用于显示给用户
+    history         聊天历史，前情提要
+    system_prompt   给gpt的静默提醒
+    user_request    当前用户的请求信息（IP地址等）
+    """
+    history = []    # 清空历史，以免输入溢出
+    chatbot.append(("这是什么功能？", "一个测试mermaid绘制图表的功能，您可以在输入框中输入一些关键词，然后使用mermaid+llm绘制图表。"))
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
+    
+    if txt == "": txt = "空白的输入栏" # 调皮一下
+    
+    i_say_show_user = f'请绘制有关“{txt}”的逻辑关系图。'
+    i_say = PROMPT.format(subject=txt)
+    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+        inputs=i_say,
+        inputs_show_user=i_say_show_user,
+        llm_kwargs=llm_kwargs, chatbot=chatbot, history=[], 
+        sys_prompt=""
+    )
+    history.append(i_say); history.append(gpt_say)
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新

docs/self_analysis.md

@@ -165,7 +165,7 @@ toolbox.py是一个工具类库，其中主要包含了一些函数装饰器和
 
 3. read_file_to_chat(chatbot, history, file_name)：从传入的文件中读取内容，解析出对话历史记录并更新聊天显示框。
 
-4. 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port)：一个主要函数，用于保存当前对话记录并提醒用户。如果用户希望加载历史记录，则调用read_file_to_chat()来更新聊天显示框。如果用户希望删除历史记录，调用删除所有本地对话历史记录()函数完成删除操作。
+4. 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request)：一个主要函数，用于保存当前对话记录并提醒用户。如果用户希望加载历史记录，则调用read_file_to_chat()来更新聊天显示框。如果用户希望删除历史记录，调用删除所有本地对话历史记录()函数完成删除操作。
 
 ## [19/48] 请对下面的程序文件做一个概述: crazy_functions\总结word文档.py
 

multi_language.py

@@ -352,9 +352,9 @@ def step_1_core_key_translate():
         chinese_core_keys_norepeat_mapping.update({k:cached_translation[k]})
     chinese_core_keys_norepeat_mapping = dict(sorted(chinese_core_keys_norepeat_mapping.items(), key=lambda x: -len(x[0])))
 
-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
     # copy
-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
     def copy_source_code():
 
         from toolbox import get_conf
@@ -367,9 +367,9 @@ def step_1_core_key_translate():
         shutil.copytree('./', backup_dir, ignore=lambda x, y: blacklist)
     copy_source_code()
 
-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
     # primary key replace
-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
     directory_path = f'./multi-language/{LANG}/'
     for root, dirs, files in os.walk(directory_path):
         for file in files:
@@ -389,9 +389,9 @@ def step_1_core_key_translate():
 
 def step_2_core_key_translate():
 
-    # =================================================================================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
     # step2 
-    # =================================================================================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
     def load_string(strings, string_input):
         string_ = string_input.strip().strip(',').strip().strip('.').strip()
@@ -492,9 +492,9 @@ def step_2_core_key_translate():
     cached_translation.update(read_map_from_json(language=LANG_STD))
     cached_translation = dict(sorted(cached_translation.items(), key=lambda x: -len(x[0])))
 
-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
     # literal key replace
-    # ===============================================
+    # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
     directory_path = f'./multi-language/{LANG}/'
     for root, dirs, files in os.walk(directory_path):
         for file in files:

request_llms/bridge_all.py

@@ -11,7 +11,7 @@
 import tiktoken, copy
 from functools import lru_cache
 from concurrent.futures import ThreadPoolExecutor
-from toolbox import get_conf, trimmed_format_exc
+from toolbox import get_conf, trimmed_format_exc, apply_gpt_academic_string_mask
 
 from .bridge_chatgpt import predict_no_ui_long_connection as chatgpt_noui
 from .bridge_chatgpt import predict as chatgpt_ui
@@ -150,6 +150,15 @@ model_info = {
         "token_cnt": get_token_num_gpt4,
     },
 
+    "gpt-4-turbo-preview": {
+        "fn_with_ui": chatgpt_ui,
+        "fn_without_ui": chatgpt_noui,
+        "endpoint": openai_endpoint,
+        "max_token": 128000,
+        "tokenizer": tokenizer_gpt4,
+        "token_cnt": get_token_num_gpt4,
+    },
+
     "gpt-4-1106-preview": {
         "fn_with_ui": chatgpt_ui,
         "fn_without_ui": chatgpt_noui,
@@ -159,6 +168,15 @@ model_info = {
         "token_cnt": get_token_num_gpt4,
     },
 
+    "gpt-4-0125-preview": {
+        "fn_with_ui": chatgpt_ui,
+        "fn_without_ui": chatgpt_noui,
+        "endpoint": openai_endpoint,
+        "max_token": 128000,
+        "tokenizer": tokenizer_gpt4,
+        "token_cnt": get_token_num_gpt4,
+    },
+
     "gpt-3.5-random": {
         "fn_with_ui": chatgpt_ui,
         "fn_without_ui": chatgpt_noui,
@@ -594,6 +612,23 @@ if "deepseekcoder" in AVAIL_LLM_MODELS:   # deepseekcoder
         })
     except:
         print(trimmed_format_exc())
+# if "skylark" in AVAIL_LLM_MODELS:
+#     try:
+#         from .bridge_skylark2 import predict_no_ui_long_connection as skylark_noui
+#         from .bridge_skylark2 import predict as skylark_ui
+#         model_info.update({
+#             "skylark": {
+#                 "fn_with_ui": skylark_ui,
+#                 "fn_without_ui": skylark_noui,
+#                 "endpoint": None,
+#                 "max_token": 4096,
+#                 "tokenizer": tokenizer_gpt35,
+#                 "token_cnt": get_token_num_gpt35,
+#             }
+#         })
+#     except:
+#         print(trimmed_format_exc())
+
 
 # <-- 用于定义和切换多个azure模型 -->
 AZURE_CFG_ARRAY = get_conf("AZURE_CFG_ARRAY")
@@ -651,6 +686,7 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history, sys_prompt, obser
     """
     import threading, time, copy
 
+    inputs = apply_gpt_academic_string_mask(inputs, mode="show_llm")
     model = llm_kwargs['llm_model']
     n_model = 1
     if '&' not in model:
@@ -724,6 +760,7 @@ def predict(inputs, llm_kwargs, *args, **kwargs):
     additional_fn代表点击的哪个按钮，按钮见functional.py
     """
 
+    inputs = apply_gpt_academic_string_mask(inputs, mode="show_llm")
     method = model_info[llm_kwargs['llm_model']]["fn_with_ui"]  # 如果这里报错，检查config中的AVAIL_LLM_MODELS选项
     yield from method(inputs, llm_kwargs, *args, **kwargs)
 

request_llms/bridge_chatgpt.py

@@ -244,6 +244,9 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                     if has_choices and not choice_valid:
                         # 一些垃圾第三方接口的出现这样的错误
                         continue
+                    if ('data: [DONE]' not in chunk_decoded) and len(chunk_decoded) > 0 and (chunkjson is None):
+                        # 传递进来一些奇怪的东西
+                        raise ValueError(f'无法读取以下数据，请检查配置。\n\n{chunk_decoded}')
                     # 前者是API2D的结束条件，后者是OPENAI的结束条件
                     if ('data: [DONE]' in chunk_decoded) or (len(chunkjson['choices'][0]["delta"]) == 0):
                         # 判定为数据流的结束，gpt_replying_buffer也写完了

request_llms/bridge_google_gemini.py

@@ -19,7 +19,7 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",
     # 检查API_KEY
     if get_conf("GEMINI_API_KEY") == "":
         raise ValueError(f"请配置 GEMINI_API_KEY。")
-    
+
     genai = GoogleChatInit()
     watch_dog_patience = 5  # 看门狗的耐心, 设置5秒即可
     gpt_replying_buffer = ''
@@ -50,6 +50,11 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
         yield from update_ui_lastest_msg(f"请配置 GEMINI_API_KEY。", chatbot=chatbot, history=history, delay=0)
         return
 
+    # 适配润色区域
+    if additional_fn is not None:
+        from core_functional import handle_core_functionality
+        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
     if "vision" in llm_kwargs["llm_model"]:
         have_recent_file, image_paths = have_any_recent_upload_image_files(chatbot)
         def make_media_input(inputs, image_paths): 

request_llms/bridge_newbingfree.py

@@ -1,16 +1,17 @@
 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第一部分：来自EdgeGPT.py
 https://github.com/acheong08/EdgeGPT
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 from .edge_gpt_free import Chatbot as NewbingChatbot
+
 load_message = "等待NewBing响应。"
 
 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第二部分：子进程Worker（调用主体）
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 import time
 import json
@@ -22,19 +23,30 @@ import threading
 from toolbox import update_ui, get_conf, trimmed_format_exc
 from multiprocessing import Process, Pipe
 
+
 def preprocess_newbing_out(s):
-    pattern = r'\^(\d+)\^' # 匹配^数字^
-    sub = lambda m: '('+m.group(1)+')' # 将匹配到的数字作为替换值
-    result = re.sub(pattern, sub, s) # 替换操作
-    if '[1]' in result:
-        result += '\n\n```reference\n' + "\n".join([r for r in result.split('\n') if r.startswith('[')]) + '\n```\n'
+    pattern = r"\^(\d+)\^"  # 匹配^数字^
+    sub = lambda m: "(" + m.group(1) + ")"  # 将匹配到的数字作为替换值
+    result = re.sub(pattern, sub, s)  # 替换操作
+    if "[1]" in result:
+        result += (
+            "\n\n```reference\n"
+            + "\n".join([r for r in result.split("\n") if r.startswith("[")])
+            + "\n```\n"
+        )
     return result
 
+
 def preprocess_newbing_out_simple(result):
-    if '[1]' in result:
-        result += '\n\n```reference\n' + "\n".join([r for r in result.split('\n') if r.startswith('[')]) + '\n```\n'
+    if "[1]" in result:
+        result += (
+            "\n\n```reference\n"
+            + "\n".join([r for r in result.split("\n") if r.startswith("[")])
+            + "\n```\n"
+        )
     return result
 
+
 class NewBingHandle(Process):
     def __init__(self):
         super().__init__(daemon=True)
@@ -46,11 +58,12 @@ class NewBingHandle(Process):
         self.check_dependency()
         self.start()
         self.threadLock = threading.Lock()
-        
+
     def check_dependency(self):
         try:
             self.success = False
             import certifi, httpx, rich
+
             self.info = "依赖检测通过，等待NewBing响应。注意目前不能多人同时调用NewBing接口（有线程锁），否则将导致每个人的NewBing问询历史互相渗透。调用NewBing时，会自动使用已配置的代理。"
             self.success = True
         except:
@@ -62,18 +75,19 @@ class NewBingHandle(Process):
 
     async def async_run(self):
         # 读取配置
-        NEWBING_STYLE = get_conf('NEWBING_STYLE')
+        NEWBING_STYLE = get_conf("NEWBING_STYLE")
         from request_llms.bridge_all import model_info
-        endpoint = model_info['newbing']['endpoint']
+
+        endpoint = model_info["newbing"]["endpoint"]
         while True:
             # 等待
             kwargs = self.child.recv()
-            question=kwargs['query']
-            history=kwargs['history']
-            system_prompt=kwargs['system_prompt']
+            question = kwargs["query"]
+            history = kwargs["history"]
+            system_prompt = kwargs["system_prompt"]
 
             # 是否重置
-            if len(self.local_history) > 0 and len(history)==0:
+            if len(self.local_history) > 0 and len(history) == 0:
                 await self.newbing_model.reset()
                 self.local_history = []
 
@@ -81,34 +95,33 @@ class NewBingHandle(Process):
             prompt = ""
             if system_prompt not in self.local_history:
                 self.local_history.append(system_prompt)
-                prompt += system_prompt + '\n'
+                prompt += system_prompt + "\n"
 
             # 追加历史
             for ab in history:
                 a, b = ab
                 if a not in self.local_history:
                     self.local_history.append(a)
-                    prompt += a + '\n'
+                    prompt += a + "\n"
 
             # 问题
             prompt += question
             self.local_history.append(question)
-            print('question:', prompt)
+            print("question:", prompt)
             # 提交
             async for final, response in self.newbing_model.ask_stream(
                 prompt=question,
-                conversation_style=NEWBING_STYLE,     # ["creative", "balanced", "precise"]
-                wss_link=endpoint,                    # "wss://sydney.bing.com/sydney/ChatHub"
+                conversation_style=NEWBING_STYLE,  # ["creative", "balanced", "precise"]
+                wss_link=endpoint,  # "wss://sydney.bing.com/sydney/ChatHub"
             ):
                 if not final:
                     print(response)
                     self.child.send(str(response))
                 else:
-                    print('-------- receive final ---------')
-                    self.child.send('[Finish]')
+                    print("-------- receive final ---------")
+                    self.child.send("[Finish]")
                     # self.local_history.append(response)
 
-    
     def run(self):
         """
         这个函数运行在子进程
@@ -118,32 +131,37 @@ class NewBingHandle(Process):
         self.local_history = []
         if (self.newbing_model is None) or (not self.success):
             # 代理设置
-            proxies, NEWBING_COOKIES = get_conf('proxies', 'NEWBING_COOKIES')
-            if proxies is None: 
+            proxies, NEWBING_COOKIES = get_conf("proxies", "NEWBING_COOKIES")
+            if proxies is None:
                 self.proxies_https = None
-            else: 
-                self.proxies_https = proxies['https']
+            else:
+                self.proxies_https = proxies["https"]
 
             if (NEWBING_COOKIES is not None) and len(NEWBING_COOKIES) > 100:
                 try:
                     cookies = json.loads(NEWBING_COOKIES)
                 except:
                     self.success = False
-                    tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-                    self.child.send(f'[Local Message] NEWBING_COOKIES未填写或有格式错误。')
-                    self.child.send('[Fail]'); self.child.send('[Finish]')
+                    tb_str = "\n```\n" + trimmed_format_exc() + "\n```\n"
+                    self.child.send(f"[Local Message] NEWBING_COOKIES未填写或有格式错误。")
+                    self.child.send("[Fail]")
+                    self.child.send("[Finish]")
                     raise RuntimeError(f"NEWBING_COOKIES未填写或有格式错误。")
             else:
                 cookies = None
 
             try:
-                self.newbing_model = NewbingChatbot(proxy=self.proxies_https, cookies=cookies)
+                self.newbing_model = NewbingChatbot(
+                    proxy=self.proxies_https, cookies=cookies
+                )
             except:
                 self.success = False
-                tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-                self.child.send(f'[Local Message] 不能加载Newbing组件，请注意Newbing组件已不再维护。{tb_str}')
-                self.child.send('[Fail]')
-                self.child.send('[Finish]')
+                tb_str = "\n```\n" + trimmed_format_exc() + "\n```\n"
+                self.child.send(
+                    f"[Local Message] 不能加载Newbing组件，请注意Newbing组件已不再维护。{tb_str}"
+                )
+                self.child.send("[Fail]")
+                self.child.send("[Finish]")
                 raise RuntimeError(f"不能加载Newbing组件，请注意Newbing组件已不再维护。")
 
         self.success = True
@@ -151,66 +169,100 @@ class NewBingHandle(Process):
             # 进入任务等待状态
             asyncio.run(self.async_run())
         except Exception:
-            tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-            self.child.send(f'[Local Message] Newbing 请求失败，报错信息如下. 如果是与网络相关的问题，建议更换代理协议（推荐http）或代理节点 {tb_str}.')
-            self.child.send('[Fail]')
-            self.child.send('[Finish]')
-        
+            tb_str = "\n```\n" + trimmed_format_exc() + "\n```\n"
+            self.child.send(
+                f"[Local Message] Newbing 请求失败，报错信息如下. 如果是与网络相关的问题，建议更换代理协议（推荐http）或代理节点 {tb_str}."
+            )
+            self.child.send("[Fail]")
+            self.child.send("[Finish]")
+
     def stream_chat(self, **kwargs):
         """
         这个函数运行在主进程
         """
-        self.threadLock.acquire()   # 获取线程锁
-        self.parent.send(kwargs)    # 请求子进程
+        self.threadLock.acquire()  # 获取线程锁
+        self.parent.send(kwargs)  # 请求子进程
         while True:
-            res = self.parent.recv()                            # 等待newbing回复的片段
-            if res == '[Finish]': break                         # 结束
-            elif res == '[Fail]': self.success = False; break   # 失败
-            else: yield res                                     # newbing回复的片段
-        self.threadLock.release()   # 释放线程锁
+            res = self.parent.recv()  # 等待newbing回复的片段
+            if res == "[Finish]":
+                break  # 结束
+            elif res == "[Fail]":
+                self.success = False
+                break  # 失败
+            else:
+                yield res  # newbing回复的片段
+        self.threadLock.release()  # 释放线程锁
 
 
 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第三部分：主进程统一调用函数接口
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 global newbingfree_handle
 newbingfree_handle = None
 
-def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=[], console_slience=False):
+
+def predict_no_ui_long_connection(
+    inputs,
+    llm_kwargs,
+    history=[],
+    sys_prompt="",
+    observe_window=[],
+    console_slience=False,
+):
     """
-        多线程方法
-        函数的说明请见 request_llms/bridge_all.py
+    多线程方法
+    函数的说明请见 request_llms/bridge_all.py
     """
     global newbingfree_handle
     if (newbingfree_handle is None) or (not newbingfree_handle.success):
         newbingfree_handle = NewBingHandle()
-        if len(observe_window) >= 1: observe_window[0] = load_message + "\n\n" + newbingfree_handle.info
-        if not newbingfree_handle.success: 
+        if len(observe_window) >= 1:
+            observe_window[0] = load_message + "\n\n" + newbingfree_handle.info
+        if not newbingfree_handle.success:
             error = newbingfree_handle.info
             newbingfree_handle = None
             raise RuntimeError(error)
 
     # 没有 sys_prompt 接口，因此把prompt加入 history
     history_feedin = []
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]] )
+    for i in range(len(history) // 2):
+        history_feedin.append([history[2 * i], history[2 * i + 1]])
 
-    watch_dog_patience = 5 # 看门狗 (watchdog) 的耐心, 设置5秒即可
+    watch_dog_patience = 5  # 看门狗 (watchdog) 的耐心, 设置5秒即可
     response = ""
-    if len(observe_window) >= 1: observe_window[0] = "[Local Message] 等待NewBing响应中 ..."
-    for response in newbingfree_handle.stream_chat(query=inputs, history=history_feedin, system_prompt=sys_prompt, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
-        if len(observe_window) >= 1:  observe_window[0] = preprocess_newbing_out_simple(response)
-        if len(observe_window) >= 2:  
-            if (time.time()-observe_window[1]) > watch_dog_patience:
+    if len(observe_window) >= 1:
+        observe_window[0] = "[Local Message] 等待NewBing响应中 ..."
+    for response in newbingfree_handle.stream_chat(
+        query=inputs,
+        history=history_feedin,
+        system_prompt=sys_prompt,
+        max_length=llm_kwargs["max_length"],
+        top_p=llm_kwargs["top_p"],
+        temperature=llm_kwargs["temperature"],
+    ):
+        if len(observe_window) >= 1:
+            observe_window[0] = preprocess_newbing_out_simple(response)
+        if len(observe_window) >= 2:
+            if (time.time() - observe_window[1]) > watch_dog_patience:
                 raise RuntimeError("程序终止。")
     return preprocess_newbing_out_simple(response)
 
-def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream = True, additional_fn=None):
+
+def predict(
+    inputs,
+    llm_kwargs,
+    plugin_kwargs,
+    chatbot,
+    history=[],
+    system_prompt="",
+    stream=True,
+    additional_fn=None,
+):
     """
-        单线程方法
-        函数的说明请见 request_llms/bridge_all.py
+    单线程方法
+    函数的说明请见 request_llms/bridge_all.py
     """
     chatbot.append((inputs, "[Local Message] 等待NewBing响应中 ..."))
 
@@ -219,27 +271,41 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
         newbingfree_handle = NewBingHandle()
         chatbot[-1] = (inputs, load_message + "\n\n" + newbingfree_handle.info)
         yield from update_ui(chatbot=chatbot, history=[])
-        if not newbingfree_handle.success: 
+        if not newbingfree_handle.success:
             newbingfree_handle = None
             return
 
     if additional_fn is not None:
         from core_functional import handle_core_functionality
-        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
+        inputs, history = handle_core_functionality(
+            additional_fn, inputs, history, chatbot
+        )
 
     history_feedin = []
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]] )
+    for i in range(len(history) // 2):
+        history_feedin.append([history[2 * i], history[2 * i + 1]])
 
     chatbot[-1] = (inputs, "[Local Message] 等待NewBing响应中 ...")
     response = "[Local Message] 等待NewBing响应中 ..."
-    yield from update_ui(chatbot=chatbot, history=history, msg="NewBing响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。")
-    for response in newbingfree_handle.stream_chat(query=inputs, history=history_feedin, system_prompt=system_prompt, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
+    yield from update_ui(
+        chatbot=chatbot, history=history, msg="NewBing响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。"
+    )
+    for response in newbingfree_handle.stream_chat(
+        query=inputs,
+        history=history_feedin,
+        system_prompt=system_prompt,
+        max_length=llm_kwargs["max_length"],
+        top_p=llm_kwargs["top_p"],
+        temperature=llm_kwargs["temperature"],
+    ):
         chatbot[-1] = (inputs, preprocess_newbing_out(response))
-        yield from update_ui(chatbot=chatbot, history=history, msg="NewBing响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。")
-    if response == "[Local Message] 等待NewBing响应中 ...": response = "[Local Message] NewBing响应异常，请刷新界面重试 ..."
+        yield from update_ui(
+            chatbot=chatbot, history=history, msg="NewBing响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。"
+        )
+    if response == "[Local Message] 等待NewBing响应中 ...":
+        response = "[Local Message] NewBing响应异常，请刷新界面重试 ..."
     history.extend([inputs, response])
-    logging.info(f'[raw_input] {inputs}')
-    logging.info(f'[response] {response}')
+    logging.info(f"[raw_input] {inputs}")
+    logging.info(f"[response] {response}")
     yield from update_ui(chatbot=chatbot, history=history, msg="完成全部响应，请提交新问题。")
-

request_llms/bridge_skylark2.py

@@ -0,0 +1,67 @@
+import time
+from toolbox import update_ui, get_conf, update_ui_lastest_msg
+from toolbox import check_packages, report_exception
+
+model_name = '云雀大模型'
+
+def validate_key():
+    YUNQUE_SECRET_KEY = get_conf("YUNQUE_SECRET_KEY")
+    if YUNQUE_SECRET_KEY == '': return False
+    return True
+
+def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=[], console_slience=False):
+    """
+        ⭐ 多线程方法
+        函数的说明请见 request_llms/bridge_all.py
+    """
+    watch_dog_patience = 5
+    response = ""
+
+    if validate_key() is False:
+        raise RuntimeError('请配置YUNQUE_SECRET_KEY')
+
+    from .com_skylark2api import YUNQUERequestInstance
+    sri = YUNQUERequestInstance()
+    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_llms/bridge_all.py
+    """
+    chatbot.append((inputs, ""))
+    yield from update_ui(chatbot=chatbot, history=history)
+
+    # 尝试导入依赖，如果缺少依赖，则给出安装建议
+    try:
+        check_packages(["zhipuai"])
+    except:
+        yield from update_ui_lastest_msg(f"导入软件依赖失败。使用该模型需要额外依赖，安装方法```pip install --upgrade zhipuai```。",
+                                         chatbot=chatbot, history=history, delay=0)
+        return
+
+    if validate_key() is False:
+        yield from update_ui_lastest_msg(lastmsg="[Local Message] 请配置HUOSHAN_API_KEY", chatbot=chatbot, history=history, delay=0)
+        return
+
+    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_skylark2api import YUNQUERequestInstance
+    sri = YUNQUERequestInstance()
+    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_llms/bridge_stackclaude.py

@@ -7,14 +7,15 @@ import logging
 import time
 from toolbox import get_conf
 import asyncio
+
 load_message = "正在加载Claude组件，请稍候..."
 
 try:
     """
-    ========================================================================
+    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
     第一部分：Slack API Client
     https://github.com/yokonsan/claude-in-slack-api
-    ========================================================================
+    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
     """
 
     from slack_sdk.errors import SlackApiError
@@ -23,20 +24,23 @@ try:
     class SlackClient(AsyncWebClient):
         """SlackClient类用于与Slack API进行交互，实现消息发送、接收等功能。
 
-            属性：
-            - CHANNEL_ID：str类型，表示频道ID。
+        属性：
+        - CHANNEL_ID：str类型，表示频道ID。
 
-            方法：
-            - open_channel()：异步方法。通过调用conversations_open方法打开一个频道，并将返回的频道ID保存在属性CHANNEL_ID中。
-            - chat(text: str)：异步方法。向已打开的频道发送一条文本消息。
-            - get_slack_messages()：异步方法。获取已打开频道的最新消息并返回消息列表，目前不支持历史消息查询。
-            - get_reply()：异步方法。循环监听已打开频道的消息，如果收到"Typing…_"结尾的消息说明Claude还在继续输出，否则结束循环。
+        方法：
+        - open_channel()：异步方法。通过调用conversations_open方法打开一个频道，并将返回的频道ID保存在属性CHANNEL_ID中。
+        - chat(text: str)：异步方法。向已打开的频道发送一条文本消息。
+        - get_slack_messages()：异步方法。获取已打开频道的最新消息并返回消息列表，目前不支持历史消息查询。
+        - get_reply()：异步方法。循环监听已打开频道的消息，如果收到"Typing…_"结尾的消息说明Claude还在继续输出，否则结束循环。
 
         """
+
         CHANNEL_ID = None
 
         async def open_channel(self):
-            response = await self.conversations_open(users=get_conf('SLACK_CLAUDE_BOT_ID'))
+            response = await self.conversations_open(
+                users=get_conf("SLACK_CLAUDE_BOT_ID")
+            )
             self.CHANNEL_ID = response["channel"]["id"]
 
         async def chat(self, text):
@@ -49,33 +53,39 @@ try:
         async def get_slack_messages(self):
             try:
                 # TODO：暂时不支持历史消息，因为在同一个频道里存在多人使用时历史消息渗透问题
-                resp = await self.conversations_history(channel=self.CHANNEL_ID, oldest=self.LAST_TS, limit=1)
-                msg = [msg for msg in resp["messages"]
-                    if msg.get("user") == get_conf('SLACK_CLAUDE_BOT_ID')]
+                resp = await self.conversations_history(
+                    channel=self.CHANNEL_ID, oldest=self.LAST_TS, limit=1
+                )
+                msg = [
+                    msg
+                    for msg in resp["messages"]
+                    if msg.get("user") == get_conf("SLACK_CLAUDE_BOT_ID")
+                ]
                 return msg
             except (SlackApiError, KeyError) as e:
                 raise RuntimeError(f"获取Slack消息失败。")
-        
+
         async def get_reply(self):
             while True:
                 slack_msgs = await self.get_slack_messages()
                 if len(slack_msgs) == 0:
                     await asyncio.sleep(0.5)
                     continue
-                
+
                 msg = slack_msgs[-1]
                 if msg["text"].endswith("Typing…_"):
                     yield False, msg["text"]
                 else:
                     yield True, msg["text"]
                     break
+
 except:
     pass
 
 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第二部分：子进程Worker（调用主体）
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 
 
@@ -88,7 +98,7 @@ class ClaudeHandle(Process):
         self.success = True
         self.local_history = []
         self.check_dependency()
-        if self.success: 
+        if self.success:
             self.start()
             self.threadLock = threading.Lock()
 
@@ -96,6 +106,7 @@ class ClaudeHandle(Process):
         try:
             self.success = False
             import slack_sdk
+
             self.info = "依赖检测通过，等待Claude响应。注意目前不能多人同时调用Claude接口（有线程锁），否则将导致每个人的Claude问询历史互相渗透。调用Claude时，会自动使用已配置的代理。"
             self.success = True
         except:
@@ -103,40 +114,44 @@ class ClaudeHandle(Process):
             self.success = False
 
     def ready(self):
-        return self.claude_model is not None    
-    
+        return self.claude_model is not None
+
     async def async_run(self):
         await self.claude_model.open_channel()
         while True:
             # 等待
             kwargs = self.child.recv()
-            question = kwargs['query']
-            history = kwargs['history']
+            question = kwargs["query"]
+            history = kwargs["history"]
 
             # 开始问问题
             prompt = ""
 
             # 问题
             prompt += question
-            print('question:', prompt)
+            print("question:", prompt)
 
             # 提交
             await self.claude_model.chat(prompt)
-            
+
             # 获取回复
-            async for final, response in self.claude_model.get_reply():                
+            async for final, response in self.claude_model.get_reply():
                 if not final:
                     print(response)
                     self.child.send(str(response))
                 else:
                     # 防止丢失最后一条消息
                     slack_msgs = await self.claude_model.get_slack_messages()
-                    last_msg = slack_msgs[-1]["text"] if slack_msgs and len(slack_msgs) > 0 else ""
+                    last_msg = (
+                        slack_msgs[-1]["text"]
+                        if slack_msgs and len(slack_msgs) > 0
+                        else ""
+                    )
                     if last_msg:
                         self.child.send(last_msg)
-                    print('-------- receive final ---------')
-                    self.child.send('[Finish]')
-                    
+                    print("-------- receive final ---------")
+                    self.child.send("[Finish]")
+
     def run(self):
         """
         这个函数运行在子进程
@@ -146,22 +161,24 @@ class ClaudeHandle(Process):
         self.local_history = []
         if (self.claude_model is None) or (not self.success):
             # 代理设置
-            proxies = get_conf('proxies')
+            proxies = get_conf("proxies")
             if proxies is None:
                 self.proxies_https = None
             else:
-                self.proxies_https = proxies['https']
+                self.proxies_https = proxies["https"]
 
             try:
-                SLACK_CLAUDE_USER_TOKEN = get_conf('SLACK_CLAUDE_USER_TOKEN')
-                self.claude_model = SlackClient(token=SLACK_CLAUDE_USER_TOKEN, proxy=self.proxies_https)
-                print('Claude组件初始化成功。')
+                SLACK_CLAUDE_USER_TOKEN = get_conf("SLACK_CLAUDE_USER_TOKEN")
+                self.claude_model = SlackClient(
+                    token=SLACK_CLAUDE_USER_TOKEN, proxy=self.proxies_https
+                )
+                print("Claude组件初始化成功。")
             except:
                 self.success = False
-                tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-                self.child.send(f'[Local Message] 不能加载Claude组件。{tb_str}')
-                self.child.send('[Fail]')
-                self.child.send('[Finish]')
+                tb_str = "\n```\n" + trimmed_format_exc() + "\n```\n"
+                self.child.send(f"[Local Message] 不能加载Claude组件。{tb_str}")
+                self.child.send("[Fail]")
+                self.child.send("[Finish]")
                 raise RuntimeError(f"不能加载Claude组件。")
 
         self.success = True
@@ -169,42 +186,49 @@ class ClaudeHandle(Process):
             # 进入任务等待状态
             asyncio.run(self.async_run())
         except Exception:
-            tb_str = '\n```\n' + trimmed_format_exc() + '\n```\n'
-            self.child.send(f'[Local Message] Claude失败 {tb_str}.')
-            self.child.send('[Fail]')
-            self.child.send('[Finish]')
+            tb_str = "\n```\n" + trimmed_format_exc() + "\n```\n"
+            self.child.send(f"[Local Message] Claude失败 {tb_str}.")
+            self.child.send("[Fail]")
+            self.child.send("[Finish]")
 
     def stream_chat(self, **kwargs):
         """
         这个函数运行在主进程
         """
         self.threadLock.acquire()
-        self.parent.send(kwargs)    # 发送请求到子进程
+        self.parent.send(kwargs)  # 发送请求到子进程
         while True:
-            res = self.parent.recv()    # 等待Claude回复的片段
-            if res == '[Finish]':
-                break       # 结束
-            elif res == '[Fail]':
+            res = self.parent.recv()  # 等待Claude回复的片段
+            if res == "[Finish]":
+                break  # 结束
+            elif res == "[Fail]":
                 self.success = False
                 break
             else:
-                yield res   # Claude回复的片段
+                yield res  # Claude回复的片段
         self.threadLock.release()
 
 
 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第三部分：主进程统一调用函数接口
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 global claude_handle
 claude_handle = None
 
 
-def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="", observe_window=None, console_slience=False):
+def predict_no_ui_long_connection(
+    inputs,
+    llm_kwargs,
+    history=[],
+    sys_prompt="",
+    observe_window=None,
+    console_slience=False,
+):
     """
-        多线程方法
-        函数的说明请见 request_llms/bridge_all.py
+    多线程方法
+    函数的说明请见 request_llms/bridge_all.py
     """
     global claude_handle
     if (claude_handle is None) or (not claude_handle.success):
@@ -217,24 +241,40 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",
 
     # 没有 sys_prompt 接口，因此把prompt加入 history
     history_feedin = []
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]])
+    for i in range(len(history) // 2):
+        history_feedin.append([history[2 * i], history[2 * i + 1]])
 
     watch_dog_patience = 5  # 看门狗 (watchdog) 的耐心, 设置5秒即可
     response = ""
     observe_window[0] = "[Local Message] 等待Claude响应中 ..."
-    for response in claude_handle.stream_chat(query=inputs, history=history_feedin, system_prompt=sys_prompt, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
+    for response in claude_handle.stream_chat(
+        query=inputs,
+        history=history_feedin,
+        system_prompt=sys_prompt,
+        max_length=llm_kwargs["max_length"],
+        top_p=llm_kwargs["top_p"],
+        temperature=llm_kwargs["temperature"],
+    ):
         observe_window[0] = preprocess_newbing_out_simple(response)
         if len(observe_window) >= 2:
-            if (time.time()-observe_window[1]) > watch_dog_patience:
+            if (time.time() - observe_window[1]) > watch_dog_patience:
                 raise RuntimeError("程序终止。")
     return preprocess_newbing_out_simple(response)
 
 
-def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_prompt='', stream=True, additional_fn=None):
+def predict(
+    inputs,
+    llm_kwargs,
+    plugin_kwargs,
+    chatbot,
+    history=[],
+    system_prompt="",
+    stream=True,
+    additional_fn=None,
+):
     """
-        单线程方法
-        函数的说明请见 request_llms/bridge_all.py
+    单线程方法
+    函数的说明请见 request_llms/bridge_all.py
     """
     chatbot.append((inputs, "[Local Message] 等待Claude响应中 ..."))
 
@@ -249,21 +289,30 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
 
     if additional_fn is not None:
         from core_functional import handle_core_functionality
-        inputs, history = handle_core_functionality(additional_fn, inputs, history, chatbot)
+
+        inputs, history = handle_core_functionality(
+            additional_fn, inputs, history, chatbot
+        )
 
     history_feedin = []
-    for i in range(len(history)//2):
-        history_feedin.append([history[2*i], history[2*i+1]])
+    for i in range(len(history) // 2):
+        history_feedin.append([history[2 * i], history[2 * i + 1]])
 
     chatbot[-1] = (inputs, "[Local Message] 等待Claude响应中 ...")
     response = "[Local Message] 等待Claude响应中 ..."
-    yield from update_ui(chatbot=chatbot, history=history, msg="Claude响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。")
-    for response in claude_handle.stream_chat(query=inputs, history=history_feedin, system_prompt=system_prompt):
+    yield from update_ui(
+        chatbot=chatbot, history=history, msg="Claude响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。"
+    )
+    for response in claude_handle.stream_chat(
+        query=inputs, history=history_feedin, system_prompt=system_prompt
+    ):
         chatbot[-1] = (inputs, preprocess_newbing_out(response))
-        yield from update_ui(chatbot=chatbot, history=history, msg="Claude响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。")
+        yield from update_ui(
+            chatbot=chatbot, history=history, msg="Claude响应缓慢，尚未完成全部响应，请耐心完成后再提交新问题。"
+        )
     if response == "[Local Message] 等待Claude响应中 ...":
         response = "[Local Message] Claude响应异常，请刷新界面重试 ..."
     history.extend([inputs, response])
-    logging.info(f'[raw_input] {inputs}')
-    logging.info(f'[response] {response}')
+    logging.info(f"[raw_input] {inputs}")
+    logging.info(f"[response] {response}")
     yield from update_ui(chatbot=chatbot, history=history, msg="完成全部响应，请提交新问题。")

request_llms/bridge_zhipu.py

@@ -42,7 +42,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
     try:
         check_packages(["zhipuai"])
     except:
-        yield from update_ui_lastest_msg(f"导入软件依赖失败。使用该模型需要额外依赖，安装方法```pip install --upgrade zhipuai```。",
+        yield from update_ui_lastest_msg(f"导入软件依赖失败。使用该模型需要额外依赖，安装方法```pip install zhipuai==1.0.7```。",
                                          chatbot=chatbot, history=history, delay=0)
         return
     

request_llms/com_google.py

@@ -12,7 +12,7 @@ from toolbox import get_conf, encode_image, get_pictures_list
 proxies, TIMEOUT_SECONDS = get_conf("proxies", "TIMEOUT_SECONDS")
 
 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第五部分 一些文件处理方法
 files_filter_handler 根据type过滤文件
 input_encode_handler 提取input中的文件，并解析
@@ -21,6 +21,7 @@ link_mtime_to_md 文件增加本地时间参数，避免下载到缓存文件
 html_view_blank 超链接
 html_local_file 本地文件取相对路径
 to_markdown_tabs 文件list 转换为 md tab
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 
 

request_llms/com_skylark2api.py

@@ -0,0 +1,95 @@
+from toolbox import get_conf
+import threading
+import logging
+import os
+
+timeout_bot_msg = '[Local Message] Request timeout. Network error.'
+#os.environ['VOLC_ACCESSKEY'] = ''
+#os.environ['VOLC_SECRETKEY'] = ''
+
+class YUNQUERequestInstance():
+    def __init__(self):
+
+        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):
+        # import _thread as thread
+        from volcengine.maas import MaasService, MaasException
+
+        maas = MaasService('maas-api.ml-platform-cn-beijing.volces.com', 'cn-beijing')
+
+        YUNQUE_SECRET_KEY, YUNQUE_ACCESS_KEY,YUNQUE_MODEL = get_conf("YUNQUE_SECRET_KEY", "YUNQUE_ACCESS_KEY","YUNQUE_MODEL")
+        maas.set_ak(YUNQUE_ACCESS_KEY) #填写 VOLC_ACCESSKEY
+        maas.set_sk(YUNQUE_SECRET_KEY) #填写 'VOLC_SECRETKEY'
+
+        self.result_buf = ""
+
+        req = {
+        "model": {
+            "name": YUNQUE_MODEL,
+            "version": "1.0", # use default version if not specified.
+        },
+        "parameters": {
+            "max_new_tokens": 4000,  # 输出文本的最大tokens限制
+            "min_new_tokens": 1,  # 输出文本的最小tokens限制
+            "temperature": llm_kwargs['temperature'],  # 用于控制生成文本的随机性和创造性，Temperature值越大随机性越大，取值范围0~1
+            "top_p": llm_kwargs['top_p'],  # 用于控制输出tokens的多样性，TopP值越大输出的tokens类型越丰富，取值范围0~1
+            "top_k": 0,  # 选择预测值最大的k个token进行采样，取值范围0-1000，0表示不生效
+            "max_prompt_tokens": 4000,  # 最大输入 token 数，如果给出的 prompt 的 token 长度超过此限制，取最后 max_prompt_tokens 个 token 输入模型。
+        },
+            "messages": self.generate_message_payload(inputs, llm_kwargs, history, system_prompt)
+        }
+
+        response = maas.stream_chat(req)
+
+        for resp in response:
+            self.result_buf += resp.choice.message.content
+            yield self.result_buf
+        '''
+        for event in response.events():
+            if event.event == "add":
+                self.result_buf += event.data
+                yield self.result_buf
+            elif event.event == "error" or event.event == "interrupted":
+                raise RuntimeError("Unknown error:" + event.data)
+            elif event.event == "finish":
+                yield self.result_buf
+                break
+            else:
+                raise RuntimeError("Unknown error:" + str(event))
+
+        logging.info(f'[raw_input] {inputs}')
+        logging.info(f'[response] {self.result_buf}')
+        '''
+        return self.result_buf
+
+    def generate_message_payload(inputs, llm_kwargs, history, system_prompt):
+        from volcengine.maas import ChatRole
+        conversation_cnt = len(history) // 2
+        messages = [{"role": ChatRole.USER, "content": system_prompt},
+                    {"role": ChatRole.ASSISTANT, "content": "Certainly!"}]
+        if conversation_cnt:
+            for index in range(0, 2 * conversation_cnt, 2):
+                what_i_have_asked = {}
+                what_i_have_asked["role"] = ChatRole.USER
+                what_i_have_asked["content"] = history[index]
+                what_gpt_answer = {}
+                what_gpt_answer["role"] = ChatRole.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"] = ChatRole.USER
+        what_i_ask_now["content"] = inputs
+        messages.append(what_i_ask_now)
+        return messages

request_llms/com_zhipuapi.py

@@ -21,8 +21,8 @@ class ZhipuRequestInstance():
         response = zhipuai.model_api.sse_invoke(
             model=ZHIPUAI_MODEL,
             prompt=generate_message_payload(inputs, llm_kwargs, history, system_prompt),
-            top_p=llm_kwargs['top_p'],
-            temperature=llm_kwargs['temperature'],
+            top_p=llm_kwargs['top_p']*0.7,              # 智谱的API抽风，手动*0.7给做个线性变换
+            temperature=llm_kwargs['temperature']*0.95, # 智谱的API抽风，手动*0.7给做个线性变换
         )
         for event in response.events():
             if event.event == "add":
@@ -37,7 +37,8 @@ class ZhipuRequestInstance():
                 break
             else:
                 raise RuntimeError("Unknown error:" + str(event))
-            
+        if self.result_buf == "":
+            yield "智谱没有返回任何数据, 请检查ZHIPUAI_API_KEY和ZHIPUAI_MODEL是否填写正确."
         logging.info(f'[raw_input] {inputs}')
         logging.info(f'[response] {self.result_buf}')
         return self.result_buf

request_llms/edge_gpt_free.py

@@ -1,8 +1,8 @@
 """
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 第一部分：来自EdgeGPT.py
 https://github.com/acheong08/EdgeGPT
-========================================================================
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 """
 """
 Main.py
@@ -196,9 +196,9 @@ class _ChatHubRequest:
         self,
         prompt: str,
         conversation_style: CONVERSATION_STYLE_TYPE,
-        options = None,
-        webpage_context = None,
-        search_result = False,
+        options=None,
+        webpage_context=None,
+        search_result=False,
     ) -> None:
         """
         Updates request object
@@ -294,9 +294,9 @@ class _Conversation:
 
     def __init__(
         self,
-        proxy = None,
-        async_mode = False,
-        cookies = None,
+        proxy=None,
+        async_mode=False,
+        cookies=None,
     ) -> None:
         if async_mode:
             return
@@ -350,8 +350,8 @@ class _Conversation:
 
     @staticmethod
     async def create(
-        proxy = None,
-        cookies = None,
+        proxy=None,
+        cookies=None,
     ):
         self = _Conversation(async_mode=True)
         self.struct = {
@@ -418,8 +418,8 @@ class _ChatHub:
     def __init__(
         self,
         conversation: _Conversation,
-        proxy = None,
-        cookies = None,
+        proxy=None,
+        cookies=None,
     ) -> None:
         self.session = None
         self.wss = None
@@ -441,7 +441,7 @@ class _ChatHub:
         conversation_style: CONVERSATION_STYLE_TYPE = None,
         raw: bool = False,
         options: dict = None,
-        webpage_context = None,
+        webpage_context=None,
         search_result: bool = False,
     ) -> Generator[str, None, None]:
         """
@@ -452,10 +452,12 @@ class _ChatHub:
             ws_cookies = []
             for cookie in self.cookies:
                 ws_cookies.append(f"{cookie['name']}={cookie['value']}")
-            req_header.update({
-                'Cookie': ';'.join(ws_cookies),
-            })
-            
+            req_header.update(
+                {
+                    "Cookie": ";".join(ws_cookies),
+                }
+            )
+
         timeout = aiohttp.ClientTimeout(total=30)
         self.session = aiohttp.ClientSession(timeout=timeout)
 
@@ -521,9 +523,9 @@ class _ChatHub:
             msg = await self.wss.receive()
             try:
                 objects = msg.data.split(DELIMITER)
-            except :
+            except:
                 continue
-            
+
             for obj in objects:
                 if obj is None or not obj:
                     continue
@@ -624,8 +626,8 @@ class Chatbot:
 
     def __init__(
         self,
-        proxy = None,
-        cookies = None,
+        proxy=None,
+        cookies=None,
     ) -> None:
         self.proxy = proxy
         self.chat_hub: _ChatHub = _ChatHub(
@@ -636,8 +638,8 @@ class Chatbot:
 
     @staticmethod
     async def create(
-        proxy = None,
-        cookies = None,
+        proxy=None,
+        cookies=None,
     ):
         self = Chatbot.__new__(Chatbot)
         self.proxy = proxy
@@ -654,7 +656,7 @@ class Chatbot:
         wss_link: str = "wss://sydney.bing.com/sydney/ChatHub",
         conversation_style: CONVERSATION_STYLE_TYPE = None,
         options: dict = None,
-        webpage_context = None,
+        webpage_context=None,
         search_result: bool = False,
     ) -> dict:
         """
@@ -680,7 +682,7 @@ class Chatbot:
         conversation_style: CONVERSATION_STYLE_TYPE = None,
         raw: bool = False,
         options: dict = None,
-        webpage_context = None,
+        webpage_context=None,
         search_result: bool = False,
     ) -> Generator[str, None, None]:
         """

requirements.txt

@@ -1,4 +1,4 @@
-./docs/gradio-3.32.6-py3-none-any.whl
+https://fastly.jsdelivr.net/gh/binary-husky/gradio-fix@gpt-academic/release/gradio-3.32.7-py3-none-any.whl
 pypdf2==2.12.1
 zhipuai<2
 tiktoken>=0.3.3
@@ -8,6 +8,7 @@ protobuf==3.18
 transformers>=4.27.1
 scipdf_parser>=0.52
 python-markdown-math
+pymdown-extensions
 websocket-client
 beautifulsoup4
 prompt_toolkit

shared_utils/advanced_markdown_format.py

@@ -0,0 +1,361 @@
+import markdown
+import re
+import os
+import math
+from textwrap import dedent
+from functools import lru_cache
+from pymdownx.superfences import fence_code_format
+from latex2mathml.converter import convert as tex2mathml
+from shared_utils.config_loader import get_conf as get_conf
+from shared_utils.text_mask import apply_gpt_academic_string_mask
+
+markdown_extension_configs = {
+    "mdx_math": {
+        "enable_dollar_delimiter": True,
+        "use_gitlab_delimiters": False,
+    },
+}
+
+code_highlight_configs = {
+    "pymdownx.superfences": {
+        "css_class": "codehilite",
+        "custom_fences": [
+            {"name": "mermaid", "class": "mermaid", "format": fence_code_format}
+        ],
+    },
+    "pymdownx.highlight": {
+        "css_class": "codehilite",
+        "guess_lang": True,
+        # 'auto_title': True,
+        # 'linenums': True
+    },
+}
+
+code_highlight_configs_block_mermaid = {
+    "pymdownx.superfences": {
+        "css_class": "codehilite",
+        # "custom_fences": [
+        #     {"name": "mermaid", "class": "mermaid", "format": fence_code_format}
+        # ],
+    },
+    "pymdownx.highlight": {
+        "css_class": "codehilite",
+        "guess_lang": True,
+        # 'auto_title': True,
+        # 'linenums': True
+    },
+}
+
+def tex2mathml_catch_exception(content, *args, **kwargs):
+    try:
+        content = tex2mathml(content, *args, **kwargs)
+    except:
+        content = content
+    return content
+
+
+def replace_math_no_render(match):
+    content = match.group(1)
+    if "mode=display" in match.group(0):
+        content = content.replace("\n", "</br>")
+        return f'<font color="#00FF00">$$</font><font color="#FF00FF">{content}</font><font color="#00FF00">$$</font>'
+    else:
+        return f'<font color="#00FF00">$</font><font color="#FF00FF">{content}</font><font color="#00FF00">$</font>'
+
+
+def replace_math_render(match):
+    content = match.group(1)
+    if "mode=display" in match.group(0):
+        if "\\begin{aligned}" in content:
+            content = content.replace("\\begin{aligned}", "\\begin{array}")
+            content = content.replace("\\end{aligned}", "\\end{array}")
+            content = content.replace("&", " ")
+        content = tex2mathml_catch_exception(content, display="block")
+        return content
+    else:
+        return tex2mathml_catch_exception(content)
+
+
+def markdown_bug_hunt(content):
+    """
+    解决一个mdx_math的bug（单$包裹begin命令时多余<script>）
+    """
+    content = content.replace(
+        '<script type="math/tex">\n<script type="math/tex; mode=display">',
+        '<script type="math/tex; mode=display">',
+    )
+    content = content.replace("</script>\n</script>", "</script>")
+    return content
+
+
+def is_equation(txt):
+    """
+    判定是否为公式 | 测试1 写出洛伦兹定律，使用tex格式公式 测试2 给出柯西不等式，使用latex格式 测试3 写出麦克斯韦方程组
+    """
+    if "```" in txt and "```reference" not in txt:
+        return False
+    if "$" not in txt and "\\[" not in txt:
+        return False
+    mathpatterns = {
+        r"(?<!\\|\$)(\$)([^\$]+)(\$)": {"allow_multi_lines": False},  #  $...$
+        r"(?<!\\)(\$\$)([^\$]+)(\$\$)": {"allow_multi_lines": True},  # $$...$$
+        r"(?<!\\)(\\\[)(.+?)(\\\])": {"allow_multi_lines": False},  # \[...\]
+        # r'(?<!\\)(\\\()(.+?)(\\\))': {'allow_multi_lines': False},                       # \(...\)
+        # r'(?<!\\)(\\begin{([a-z]+?\*?)})(.+?)(\\end{\2})': {'allow_multi_lines': True},  # \begin...\end
+        # r'(?<!\\)(\$`)([^`]+)(`\$)': {'allow_multi_lines': False},                       # $`...`$
+    }
+    matches = []
+    for pattern, property in mathpatterns.items():
+        flags = re.ASCII | re.DOTALL if property["allow_multi_lines"] else re.ASCII
+        matches.extend(re.findall(pattern, txt, flags))
+    if len(matches) == 0:
+        return False
+    contain_any_eq = False
+    illegal_pattern = re.compile(r"[^\x00-\x7F]|echo")
+    for match in matches:
+        if len(match) != 3:
+            return False
+        eq_canidate = match[1]
+        if illegal_pattern.search(eq_canidate):
+            return False
+        else:
+            contain_any_eq = True
+    return contain_any_eq
+
+
+def fix_markdown_indent(txt):
+    # fix markdown indent
+    if (" - " not in txt) or (". " not in txt):
+        # do not need to fix, fast escape
+        return txt
+    # walk through the lines and fix non-standard indentation
+    lines = txt.split("\n")
+    pattern = re.compile(r"^\s+-")
+    activated = False
+    for i, line in enumerate(lines):
+        if line.startswith("- ") or line.startswith("1. "):
+            activated = True
+        if activated and pattern.match(line):
+            stripped_string = line.lstrip()
+            num_spaces = len(line) - len(stripped_string)
+            if (num_spaces % 4) == 3:
+                num_spaces_should_be = math.ceil(num_spaces / 4) * 4
+                lines[i] = " " * num_spaces_should_be + stripped_string
+    return "\n".join(lines)
+
+
+FENCED_BLOCK_RE = re.compile(
+    dedent(
+        r"""
+        (?P<fence>^[ \t]*(?:~{3,}|`{3,}))[ ]*                      # opening fence
+        ((\{(?P<attrs>[^\}\n]*)\})|                              # (optional {attrs} or
+        (\.?(?P<lang>[\w#.+-]*)[ ]*)?                            # optional (.)lang
+        (hl_lines=(?P<quot>"|')(?P<hl_lines>.*?)(?P=quot)[ ]*)?) # optional hl_lines)
+        \n                                                       # newline (end of opening fence)
+        (?P<code>.*?)(?<=\n)                                     # the code block
+        (?P=fence)[ ]*$                                          # closing fence
+    """
+    ),
+    re.MULTILINE | re.DOTALL | re.VERBOSE,
+)
+
+
+def get_line_range(re_match_obj, txt):
+    start_pos, end_pos = re_match_obj.regs[0]
+    num_newlines_before = txt[: start_pos + 1].count("\n")
+    line_start = num_newlines_before
+    line_end = num_newlines_before + txt[start_pos:end_pos].count("\n") + 1
+    return line_start, line_end
+
+
+def fix_code_segment_indent(txt):
+    lines = []
+    change_any = False
+    txt_tmp = txt
+    while True:
+        re_match_obj = FENCED_BLOCK_RE.search(txt_tmp)
+        if not re_match_obj:
+            break
+        if len(lines) == 0:
+            lines = txt.split("\n")
+
+        # 清空 txt_tmp 对应的位置方便下次搜索
+        start_pos, end_pos = re_match_obj.regs[0]
+        txt_tmp = txt_tmp[:start_pos] + " " * (end_pos - start_pos) + txt_tmp[end_pos:]
+        line_start, line_end = get_line_range(re_match_obj, txt)
+
+        # 获取公共缩进
+        shared_indent_cnt = 1e5
+        for i in range(line_start, line_end):
+            stripped_string = lines[i].lstrip()
+            num_spaces = len(lines[i]) - len(stripped_string)
+            if num_spaces < shared_indent_cnt:
+                shared_indent_cnt = num_spaces
+
+        # 修复缩进
+        if (shared_indent_cnt < 1e5) and (shared_indent_cnt % 4) == 3:
+            num_spaces_should_be = math.ceil(shared_indent_cnt / 4) * 4
+            for i in range(line_start, line_end):
+                add_n = num_spaces_should_be - shared_indent_cnt
+                lines[i] = " " * add_n + lines[i]
+            if not change_any:  # 遇到第一个
+                change_any = True
+
+    if change_any:
+        return "\n".join(lines)
+    else:
+        return txt
+
+
+@lru_cache(maxsize=128)  # 使用 lru缓存 加快转换速度
+def markdown_convertion(txt):
+    """
+    将Markdown格式的文本转换为HTML格式。如果包含数学公式，则先将公式转换为HTML格式。
+    """
+    pre = '<div class="markdown-body">'
+    suf = "</div>"
+    if txt.startswith(pre) and txt.endswith(suf):
+        # print('警告，输入了已经经过转化的字符串，二次转化可能出问题')
+        return txt  # 已经被转化过，不需要再次转化
+
+    find_equation_pattern = r'<script type="math/tex(?:.*?)>(.*?)</script>'
+
+    txt = fix_markdown_indent(txt)
+    # txt = fix_code_segment_indent(txt)
+    if is_equation(txt):  # 有$标识的公式符号，且没有代码段```的标识
+        # convert everything to html format
+        split = markdown.markdown(text="---")
+        convert_stage_1 = markdown.markdown(
+            text=txt,
+            extensions=[
+                "sane_lists",
+                "tables",
+                "mdx_math",
+                "pymdownx.superfences",
+                "pymdownx.highlight",
+            ],
+            extension_configs={**markdown_extension_configs, **code_highlight_configs},
+        )
+        convert_stage_1 = markdown_bug_hunt(convert_stage_1)
+        # 1. convert to easy-to-copy tex (do not render math)
+        convert_stage_2_1, n = re.subn(
+            find_equation_pattern,
+            replace_math_no_render,
+            convert_stage_1,
+            flags=re.DOTALL,
+        )
+        # 2. convert to rendered equation
+        convert_stage_2_2, n = re.subn(
+            find_equation_pattern, replace_math_render, convert_stage_1, flags=re.DOTALL
+        )
+        # cat them together
+        return pre + convert_stage_2_1 + f"{split}" + convert_stage_2_2 + suf
+    else:
+        return (
+            pre
+            + markdown.markdown(
+                txt,
+                extensions=[
+                    "sane_lists",
+                    "tables",
+                    "pymdownx.superfences",
+                    "pymdownx.highlight",
+                ],
+                extension_configs=code_highlight_configs,
+            )
+            + suf
+        )
+
+
+def close_up_code_segment_during_stream(gpt_reply):
+    """
+    在gpt输出代码的中途（输出了前面的```，但还没输出完后面的```），补上后面的```
+
+    Args:
+        gpt_reply (str): GPT模型返回的回复字符串。
+
+    Returns:
+        str: 返回一个新的字符串，将输出代码片段的“后面的```”补上。
+
+    """
+    if "```" not in gpt_reply:
+        return gpt_reply
+    if gpt_reply.endswith("```"):
+        return gpt_reply
+
+    # 排除了以上两个情况，我们
+    segments = gpt_reply.split("```")
+    n_mark = len(segments) - 1
+    if n_mark % 2 == 1:
+        return gpt_reply + "\n```"  # 输出代码片段中！
+    else:
+        return gpt_reply
+
+
+def special_render_issues_for_mermaid(text):
+    # 用不太优雅的方式处理一个core_functional.py中出现的mermaid渲染特例：
+    # 我不希望"总结绘制脑图"prompt中的mermaid渲染出来
+    @lru_cache(maxsize=1)
+    def get_special_case():
+        from core_functional import get_core_functions
+        special_case = get_core_functions()["总结绘制脑图"]["Suffix"]
+        return special_case
+    if text.endswith(get_special_case()): text = text.replace("```mermaid", "```")
+    return text
+
+
+def compat_non_markdown_input(text):
+    """
+    改善非markdown输入的显示效果，例如将空格转换为&nbsp;，将换行符转换为</br>等。
+    """
+    if "```" in text:
+        # careful input：markdown输入
+        text = special_render_issues_for_mermaid(text)  # 处理特殊的渲染问题
+        return text
+    elif "</div>" in text:
+        # careful input：html输入
+        return text
+    else:
+        # whatever input：非markdown输入
+        lines = text.split("\n")
+        for i, line in enumerate(lines):
+            lines[i] = lines[i].replace(" ", "&nbsp;")  # 空格转换为&nbsp;
+        text = "</br>".join(lines)  # 换行符转换为</br>
+        return text
+
+
+@lru_cache(maxsize=128)  # 使用lru缓存
+def simple_markdown_convertion(text):
+    pre = '<div class="markdown-body">'
+    suf = "</div>"
+    if text.startswith(pre) and text.endswith(suf):
+        return text  # 已经被转化过，不需要再次转化
+    text = compat_non_markdown_input(text)    # 兼容非markdown输入
+    text = markdown.markdown(
+        text,
+        extensions=["pymdownx.superfences", "tables", "pymdownx.highlight"],
+        extension_configs=code_highlight_configs,
+    )
+    return pre + text + suf
+
+
+def format_io(self, y):
+    """
+    将输入和输出解析为HTML格式。将y中最后一项的输入部分段落化，并将输出部分的Markdown和数学公式转换为HTML格式。
+    """
+    if y is None or y == []:
+        return []
+    i_ask, gpt_reply = y[-1]
+    i_ask = apply_gpt_academic_string_mask(i_ask, mode="show_render")
+    gpt_reply = apply_gpt_academic_string_mask(gpt_reply, mode="show_render")
+    # 当代码输出半截的时候，试着补上后个```
+    if gpt_reply is not None:
+        gpt_reply = close_up_code_segment_during_stream(gpt_reply)
+    # 处理提问与输出
+    y[-1] = (
+        # 输入部分
+        None if i_ask is None else simple_markdown_convertion(i_ask),
+        # 输出部分
+        None if gpt_reply is None else markdown_convertion(gpt_reply),
+    )
+    return y

shared_utils/config_loader.py

@@ -0,0 +1,131 @@
+import importlib
+import time
+import os
+from functools import lru_cache
+from colorful import print亮红, print亮绿, print亮蓝
+
+pj = os.path.join
+default_user_name = 'default_user'
+
+def read_env_variable(arg, default_value):
+    """
+    环境变量可以是 `GPT_ACADEMIC_CONFIG`(优先)，也可以直接是`CONFIG`
+    例如在windows cmd中，既可以写：
+        set USE_PROXY=True
+        set API_KEY=sk-j7caBpkRoxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+        set proxies={"http":"http://127.0.0.1:10085", "https":"http://127.0.0.1:10085",}
+        set AVAIL_LLM_MODELS=["gpt-3.5-turbo", "chatglm"]
+        set AUTHENTICATION=[("username", "password"), ("username2", "password2")]
+    也可以写：
+        set GPT_ACADEMIC_USE_PROXY=True
+        set GPT_ACADEMIC_API_KEY=sk-j7caBpkRoxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+        set GPT_ACADEMIC_proxies={"http":"http://127.0.0.1:10085", "https":"http://127.0.0.1:10085",}
+        set GPT_ACADEMIC_AVAIL_LLM_MODELS=["gpt-3.5-turbo", "chatglm"]
+        set GPT_ACADEMIC_AUTHENTICATION=[("username", "password"), ("username2", "password2")]
+    """
+    arg_with_prefix = "GPT_ACADEMIC_" + arg
+    if arg_with_prefix in os.environ:
+        env_arg = os.environ[arg_with_prefix]
+    elif arg in os.environ:
+        env_arg = os.environ[arg]
+    else:
+        raise KeyError
+    print(f"[ENV_VAR] 尝试加载{arg}，默认值：{default_value} --> 修正值：{env_arg}")
+    try:
+        if isinstance(default_value, bool):
+            env_arg = env_arg.strip()
+            if env_arg == 'True': r = True
+            elif env_arg == 'False': r = False
+            else: print('Enter True or False, but have:', env_arg); r = default_value
+        elif isinstance(default_value, int):
+            r = int(env_arg)
+        elif isinstance(default_value, float):
+            r = float(env_arg)
+        elif isinstance(default_value, str):
+            r = env_arg.strip()
+        elif isinstance(default_value, dict):
+            r = eval(env_arg)
+        elif isinstance(default_value, list):
+            r = eval(env_arg)
+        elif default_value is None:
+            assert arg == "proxies"
+            r = eval(env_arg)
+        else:
+            print亮红(f"[ENV_VAR] 环境变量{arg}不支持通过环境变量设置! ")
+            raise KeyError
+    except:
+        print亮红(f"[ENV_VAR] 环境变量{arg}加载失败! ")
+        raise KeyError(f"[ENV_VAR] 环境变量{arg}加载失败! ")
+
+    print亮绿(f"[ENV_VAR] 成功读取环境变量{arg}")
+    return r
+
+
+@lru_cache(maxsize=128)
+def read_single_conf_with_lru_cache(arg):
+    from shared_utils.key_pattern_manager import is_any_api_key
+    try:
+        # 优先级1. 获取环境变量作为配置
+        default_ref = getattr(importlib.import_module('config'), arg) # 读取默认值作为数据类型转换的参考
+        r = read_env_variable(arg, default_ref)
+    except:
+        try:
+            # 优先级2. 获取config_private中的配置
+            r = getattr(importlib.import_module('config_private'), arg)
+        except:
+            # 优先级3. 获取config中的配置
+            r = getattr(importlib.import_module('config'), arg)
+
+    # 在读取API_KEY时，检查一下是不是忘了改config
+    if arg == 'API_URL_REDIRECT':
+        oai_rd = r.get("https://api.openai.com/v1/chat/completions", None) # API_URL_REDIRECT填写格式是错误的，请阅读`https://github.com/binary-husky/gpt_academic/wiki/项目配置说明`
+        if oai_rd and not oai_rd.endswith('/completions'):
+            print亮红("\n\n[API_URL_REDIRECT] API_URL_REDIRECT填错了。请阅读`https://github.com/binary-husky/gpt_academic/wiki/项目配置说明`。如果您确信自己没填错，无视此消息即可。")
+            time.sleep(5)
+    if arg == 'API_KEY':
+        print亮蓝(f"[API_KEY] 本项目现已支持OpenAI和Azure的api-key。也支持同时填写多个api-key，如API_KEY=\"openai-key1,openai-key2,azure-key3\"")
+        print亮蓝(f"[API_KEY] 您既可以在config.py中修改api-key(s)，也可以在问题输入区输入临时的api-key(s)，然后回车键提交后即可生效。")
+        if is_any_api_key(r):
+            print亮绿(f"[API_KEY] 您的 API_KEY 是: {r[:15]}*** API_KEY 导入成功")
+        else:
+            print亮红("[API_KEY] 您的 API_KEY 不满足任何一种已知的密钥格式，请在config文件中修改API密钥之后再运行。")
+    if arg == 'proxies':
+        if not read_single_conf_with_lru_cache('USE_PROXY'): r = None # 检查USE_PROXY，防止proxies单独起作用
+        if r is None:
+            print亮红('[PROXY] 网络代理状态：未配置。无代理状态下很可能无法访问OpenAI家族的模型。建议：检查USE_PROXY选项是否修改。')
+        else:
+            print亮绿('[PROXY] 网络代理状态：已配置。配置信息如下：', r)
+            assert isinstance(r, dict), 'proxies格式错误，请注意proxies选项的格式，不要遗漏括号。'
+    return r
+
+
+@lru_cache(maxsize=128)
+def get_conf(*args):
+    """
+    本项目的所有配置都集中在config.py中。 修改配置有三种方法，您只需要选择其中一种即可：
+        - 直接修改config.py
+        - 创建并修改config_private.py
+        - 修改环境变量（修改docker-compose.yml等价于修改容器内部的环境变量）
+
+    注意：如果您使用docker-compose部署，请修改docker-compose（等价于修改容器内部的环境变量）
+    """
+    res = []
+    for arg in args:
+        r = read_single_conf_with_lru_cache(arg)
+        res.append(r)
+    if len(res) == 1: return res[0]
+    return res
+
+
+def set_conf(key, value):
+    from toolbox import read_single_conf_with_lru_cache
+    read_single_conf_with_lru_cache.cache_clear()
+    get_conf.cache_clear()
+    os.environ[key] = str(value)
+    altered = get_conf(key)
+    return altered
+
+
+def set_multi_conf(dic):
+    for k, v in dic.items(): set_conf(k, v)
+    return

shared_utils/connect_void_terminal.py

@@ -0,0 +1,91 @@
+import os
+
+"""
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+接驳void-terminal:
+    - set_conf:                     在运行过程中动态地修改配置
+    - set_multi_conf:               在运行过程中动态地修改多个配置
+    - get_plugin_handle:            获取插件的句柄
+    - get_plugin_default_kwargs:    获取插件的默认参数
+    - get_chat_handle:              获取简单聊天的句柄
+    - get_chat_default_kwargs:      获取简单聊天的默认参数
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+"""
+
+
+def get_plugin_handle(plugin_name):
+    """
+    e.g. plugin_name = 'crazy_functions.批量Markdown翻译->Markdown翻译指定语言'
+    """
+    import importlib
+
+    assert (
+        "->" in plugin_name
+    ), "Example of plugin_name: crazy_functions.批量Markdown翻译->Markdown翻译指定语言"
+    module, fn_name = plugin_name.split("->")
+    f_hot_reload = getattr(importlib.import_module(module, fn_name), fn_name)
+    return f_hot_reload
+
+
+def get_chat_handle():
+    """
+    Get chat function
+    """
+    from request_llms.bridge_all import predict_no_ui_long_connection
+
+    return predict_no_ui_long_connection
+
+
+def get_plugin_default_kwargs():
+    """
+    Get Plugin Default Arguments
+    """
+    from toolbox import ChatBotWithCookies, load_chat_cookies
+
+    cookies = load_chat_cookies()
+    llm_kwargs = {
+        "api_key": cookies["api_key"],
+        "llm_model": cookies["llm_model"],
+        "top_p": 1.0,
+        "max_length": None,
+        "temperature": 1.0,
+    }
+    chatbot = ChatBotWithCookies(llm_kwargs)
+
+    # txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, user_request
+    DEFAULT_FN_GROUPS_kwargs = {
+        "main_input": "./README.md",
+        "llm_kwargs": llm_kwargs,
+        "plugin_kwargs": {},
+        "chatbot_with_cookie": chatbot,
+        "history": [],
+        "system_prompt": "You are a good AI.",
+        "user_request": None,
+    }
+    return DEFAULT_FN_GROUPS_kwargs
+
+
+def get_chat_default_kwargs():
+    """
+    Get Chat Default Arguments
+    """
+    from toolbox import load_chat_cookies
+
+    cookies = load_chat_cookies()
+    llm_kwargs = {
+        "api_key": cookies["api_key"],
+        "llm_model": cookies["llm_model"],
+        "top_p": 1.0,
+        "max_length": None,
+        "temperature": 1.0,
+    }
+    default_chat_kwargs = {
+        "inputs": "Hello there, are you ready?",
+        "llm_kwargs": llm_kwargs,
+        "history": [],
+        "sys_prompt": "You are AI assistant",
+        "observe_window": None,
+        "console_slience": False,
+    }
+
+    return default_chat_kwargs

shared_utils/key_pattern_manager.py

@@ -0,0 +1,81 @@
+import re
+import os
+from functools import wraps, lru_cache
+from shared_utils.advanced_markdown_format import format_io
+from shared_utils.config_loader import get_conf as get_conf
+
+
+pj = os.path.join
+default_user_name = 'default_user'
+
+
+def is_openai_api_key(key):
+    CUSTOM_API_KEY_PATTERN = get_conf('CUSTOM_API_KEY_PATTERN')
+    if len(CUSTOM_API_KEY_PATTERN) != 0:
+        API_MATCH_ORIGINAL = re.match(CUSTOM_API_KEY_PATTERN, key)
+    else:
+        API_MATCH_ORIGINAL = re.match(r"sk-[a-zA-Z0-9]{48}$", key)
+    return bool(API_MATCH_ORIGINAL)
+
+
+def is_azure_api_key(key):
+    API_MATCH_AZURE = re.match(r"[a-zA-Z0-9]{32}$", key)
+    return bool(API_MATCH_AZURE)
+
+
+def is_api2d_key(key):
+    API_MATCH_API2D = re.match(r"fk[a-zA-Z0-9]{6}-[a-zA-Z0-9]{32}$", key)
+    return bool(API_MATCH_API2D)
+
+
+def is_any_api_key(key):
+    if ',' in key:
+        keys = key.split(',')
+        for k in keys:
+            if is_any_api_key(k): return True
+        return False
+    else:
+        return is_openai_api_key(key) or is_api2d_key(key) or is_azure_api_key(key)
+
+
+def what_keys(keys):
+    avail_key_list = {'OpenAI Key': 0, "Azure Key": 0, "API2D Key": 0}
+    key_list = keys.split(',')
+
+    for k in key_list:
+        if is_openai_api_key(k):
+            avail_key_list['OpenAI Key'] += 1
+
+    for k in key_list:
+        if is_api2d_key(k):
+            avail_key_list['API2D Key'] += 1
+
+    for k in key_list:
+        if is_azure_api_key(k):
+            avail_key_list['Azure Key'] += 1
+
+    return f"检测到： OpenAI Key {avail_key_list['OpenAI Key']} 个, Azure Key {avail_key_list['Azure Key']} 个, API2D Key {avail_key_list['API2D Key']} 个"
+
+
+def select_api_key(keys, llm_model):
+    import random
+    avail_key_list = []
+    key_list = keys.split(',')
+
+    if llm_model.startswith('gpt-'):
+        for k in key_list:
+            if is_openai_api_key(k): avail_key_list.append(k)
+
+    if llm_model.startswith('api2d-'):
+        for k in key_list:
+            if is_api2d_key(k): avail_key_list.append(k)
+
+    if llm_model.startswith('azure-'):
+        for k in key_list:
+            if is_azure_api_key(k): avail_key_list.append(k)
+
+    if len(avail_key_list) == 0:
+        raise RuntimeError(f"您提供的api-key不满足要求，不包含任何可用于{llm_model}的api-key。您可能选择了错误的模型或请求源（右下角更换模型菜单中可切换openai,azure,claude,api2d等请求源）。")
+
+    api_key = random.choice(avail_key_list) # 随机负载均衡
+    return api_key

shared_utils/text_mask.py

@@ -0,0 +1,107 @@
+import re
+from functools import lru_cache
+
+# 这段代码是使用Python编程语言中的re模块，即正则表达式库，来定义了一个正则表达式模式。
+# 这个模式被编译成一个正则表达式对象，存储在名为const_extract_exp的变量中，以便于后续快速的匹配和查找操作。
+# 这里解释一下正则表达式中的几个特殊字符：
+# - . 表示任意单一字符。
+# - * 表示前一个字符可以出现0次或多次。
+# - ? 在这里用作非贪婪匹配，也就是说它会匹配尽可能少的字符。在(.*?)中，它确保我们匹配的任意文本是尽可能短的，也就是说，它会在</show_llm>和</show_render>标签之前停止匹配。
+# - () 括号在正则表达式中表示捕获组。
+# - 在这个例子中，(.*?)表示捕获任意长度的文本，直到遇到括号外部最近的限定符，即</show_llm>和</show_render>。
+
+# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=/1=-=-=-=-=-=-=-=-=-=-=-=-=-=/2-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+const_extract_re = re.compile(
+    r"<gpt_academic_string_mask><show_llm>(.*?)</show_llm><show_render>(.*?)</show_render></gpt_academic_string_mask>"
+)
+# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=-=-=/1=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-/2-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+const_extract_langbased_re = re.compile(
+    r"<gpt_academic_string_mask><lang_english>(.*?)</lang_english><lang_chinese>(.*?)</lang_chinese></gpt_academic_string_mask>",
+    flags=re.DOTALL,
+)
+
+@lru_cache(maxsize=128)
+def apply_gpt_academic_string_mask(string, mode="show_all"):
+    """
+    当字符串中有掩码tag时（<gpt_academic_string_mask><show_...>），根据字符串要给谁看（大模型，还是web渲染），对字符串进行处理，返回处理后的字符串
+    示意图：https://mermaid.live/edit#pako:eNqlkUtLw0AUhf9KuOta0iaTplkIPlpduFJwoZEwJGNbzItpita2O6tF8QGKogXFtwu7cSHiq3-mk_oznFR8IYLgrGbuOd9hDrcCpmcR0GDW9ubNPKaBMDauuwI_A9M6YN-3y0bODwxsYos4BdMoBrTg5gwHF-d0mBH6-vqFQe58ed5m9XPW2uteX3Tubrj0ljLYcwxxR3h1zB43WeMs3G19yEM9uapDMe_NG9i2dagKw1Fee4c1D9nGEbtc-5n6HbNtJ8IyHOs8tbs7V2HrlDX2w2Y7XD_5haHEtQiNsOwfMVa_7TzsvrWIuJGo02qTrdwLk9gukQylHv3Afv1ML270s-HZUndrmW1tdA-WfvbM_jMFYuAQ6uCCxVdciTJ1CPLEITpo_GphypeouzXuw6XAmyi7JmgBLZEYlHwLB2S4gHMUO-9DH7tTnvf1CVoFFkBLSOk4QmlRTqpIlaWUHINyNFXjaQWpCYRURUKiWovBYo8X4ymEJFlECQUpqaQkJmuvWygPpg
+    """
+    if "<gpt_academic_string_mask>" not in string: # No need to process
+        return string
+
+    if mode == "show_all":
+        return string
+    if mode == "show_llm":
+        string = const_extract_re.sub(r"\1", string)
+    elif mode == "show_render":
+        string = const_extract_re.sub(r"\2", string)
+    else:
+        raise ValueError("Invalid mode")
+    return string
+
+
+@lru_cache(maxsize=128)
+def build_gpt_academic_masked_string(text_show_llm="", text_show_render=""):
+    """
+    根据字符串要给谁看（大模型，还是web渲染），生成带掩码tag的字符串
+    """
+    return f"<gpt_academic_string_mask><show_llm>{text_show_llm}</show_llm><show_render>{text_show_render}</show_render></gpt_academic_string_mask>"
+
+
+@lru_cache(maxsize=128)
+def apply_gpt_academic_string_mask_langbased(string, lang_reference):
+    """
+    当字符串中有掩码tag时（<gpt_academic_string_mask><lang_...>），根据语言，选择提示词，对字符串进行处理，返回处理后的字符串
+    例如，如果lang_reference是英文，那么就只显示英文提示词，中文提示词就不显示了
+    举例：
+        输入1
+            string = "注意，lang_reference这段文字是：<gpt_academic_string_mask><lang_english>英语</lang_english><lang_chinese>中文</lang_chinese></gpt_academic_string_mask>"
+            lang_reference = "hello world"
+        输出1
+            "注意，lang_reference这段文字是：英语"
+            
+        输入2
+            string = "注意，lang_reference这段文字是中文"   # 注意这里没有掩码tag，所以不会被处理
+            lang_reference = "hello world"
+        输出2
+            "注意，lang_reference这段文字是中文"            # 原样返回
+    """
+
+    if "<gpt_academic_string_mask>" not in string: # No need to process
+        return string
+
+    def contains_chinese(string):
+        chinese_regex = re.compile(u'[\u4e00-\u9fff]+')
+        return chinese_regex.search(string) is not None
+
+    mode = "english" if not contains_chinese(lang_reference) else "chinese"
+    if mode == "english":
+        string = const_extract_langbased_re.sub(r"\1", string)
+    elif mode == "chinese":
+        string = const_extract_langbased_re.sub(r"\2", string)
+    else:
+        raise ValueError("Invalid mode")
+    return string
+
+
+@lru_cache(maxsize=128)
+def build_gpt_academic_masked_string_langbased(text_show_english="", text_show_chinese=""):
+    """
+    根据语言，选择提示词，对字符串进行处理，返回处理后的字符串
+    """
+    return f"<gpt_academic_string_mask><lang_english>{text_show_english}</lang_english><lang_chinese>{text_show_chinese}</lang_chinese></gpt_academic_string_mask>"
+
+
+if __name__ == "__main__":
+    # Test
+    input_string = (
+        "你好\n"
+        + build_gpt_academic_masked_string(text_show_llm="mermaid", text_show_render="")
+        + "你好\n"
+    )
+    print(
+        apply_gpt_academic_string_mask(input_string, "show_llm")
+    )  # Should print the strings with 'abc' in place of the academic mask tags
+    print(
+        apply_gpt_academic_string_mask(input_string, "show_render")
+    )  # Should print the strings with 'xyz' in place of the academic mask tags

tests/test_markdown.py

@@ -1,35 +1,37 @@
 md = """
-作为您的写作和编程助手，我可以为您提供以下服务：
+You can use the following Python script to rename files matching the pattern '* - 副本.tex' to '* - wushiguang.tex' in a directory:
 
-1. 写作：
-    - 帮助您撰写文章、报告、散文、故事等。
-    - 提供写作建议和技巧。
-    - 协助您进行文案策划和内容创作。
+```python
+import os
 
-2. 编程：
-    - 帮助您解决编程问题，提供编程思路和建议。
-    - 协助您编写代码，包括但不限于 Python、Java、C++ 等。
-    - 为您解释复杂的技术概念，让您更容易理解。
+# Directory containing the files
+directory = 'Tex/'
 
-3. 项目支持：
-    - 协助您规划项目进度和任务分配。
-    - 提供项目管理和协作建议。
-    - 在项目实施过程中提供支持，确保项目顺利进行。
+for filename in os.listdir(directory):
+    if filename.endswith(' - 副本.tex'):
+        new_filename = filename.replace(' - 副本.tex', ' - wushiguang.tex')
+        os.rename(os.path.join(directory, filename), os.path.join(directory, new_filename))
+```
 
-4. 学习辅导：
-    - 帮助您巩固编程基础，提高编程能力。
-    - 提供计算机科学、数据科学、人工智能等相关领域的学习资源和建议。
-    - 解答您在学习过程中遇到的问题，让您更好地掌握知识。
-
-5. 行业动态和趋势分析：
-    - 为您提供业界最新的新闻和技术趋势。
-    - 分析行业动态，帮助您了解市场发展和竞争态势。
-    - 为您制定技术战略提供参考和建议。
-
-请随时告诉我您的需求，我会尽力提供帮助。如果您有任何问题或需要解答的议题，请随时提问。
+Replace 'Tex/' with the actual directory path where your files are located before running the script.
 """
 
 
+md = """
+Following code including wrapper
+
+```mermaid
+graph TD
+    A[Enter Chart Definition] --> B(Preview)
+    B --> C{decide}
+    C --> D[Keep]
+    C --> E[Edit Definition]
+    E --> B
+    D --> F[Save Image and Code]
+    F --> B
+```
+
+"""
 def validate_path():
     import os, sys
 
@@ -43,6 +45,9 @@ validate_path()  # validate path so you can run from base directory
 from toolbox import markdown_convertion
 
 html = markdown_convertion(md)
-print(html)
+# print(html)
 with open("test.html", "w", encoding="utf-8") as f:
     f.write(html)
+
+
+# TODO: 列出10个经典名著

themes/base64.mjs

@@ -0,0 +1,296 @@
+/**
+ *  base64.ts
+ *
+ *  Licensed under the BSD 3-Clause License.
+ *    http://opensource.org/licenses/BSD-3-Clause
+ *
+ *  References:
+ *    http://en.wikipedia.org/wiki/Base64
+ *
+ * @author Dan Kogai (https://github.com/dankogai)
+ */
+const version = '3.7.2';
+/**
+ * @deprecated use lowercase `version`.
+ */
+const VERSION = version;
+const _hasatob = typeof atob === 'function';
+const _hasbtoa = typeof btoa === 'function';
+const _hasBuffer = typeof Buffer === 'function';
+const _TD = typeof TextDecoder === 'function' ? new TextDecoder() : undefined;
+const _TE = typeof TextEncoder === 'function' ? new TextEncoder() : undefined;
+const b64ch = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+const b64chs = Array.prototype.slice.call(b64ch);
+const b64tab = ((a) => {
+    let tab = {};
+    a.forEach((c, i) => tab[c] = i);
+    return tab;
+})(b64chs);
+const b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+const _fromCC = String.fromCharCode.bind(String);
+const _U8Afrom = typeof Uint8Array.from === 'function'
+    ? Uint8Array.from.bind(Uint8Array)
+    : (it, fn = (x) => x) => new Uint8Array(Array.prototype.slice.call(it, 0).map(fn));
+const _mkUriSafe = (src) => src
+    .replace(/=/g, '').replace(/[+\/]/g, (m0) => m0 == '+' ? '-' : '_');
+const _tidyB64 = (s) => s.replace(/[^A-Za-z0-9\+\/]/g, '');
+/**
+ * polyfill version of `btoa`
+ */
+const btoaPolyfill = (bin) => {
+    // console.log('polyfilled');
+    let u32, c0, c1, c2, asc = '';
+    const pad = bin.length % 3;
+    for (let i = 0; i < bin.length;) {
+        if ((c0 = bin.charCodeAt(i++)) > 255 ||
+            (c1 = bin.charCodeAt(i++)) > 255 ||
+            (c2 = bin.charCodeAt(i++)) > 255)
+            throw new TypeError('invalid character found');
+        u32 = (c0 << 16) | (c1 << 8) | c2;
+        asc += b64chs[u32 >> 18 & 63]
+            + b64chs[u32 >> 12 & 63]
+            + b64chs[u32 >> 6 & 63]
+            + b64chs[u32 & 63];
+    }
+    return pad ? asc.slice(0, pad - 3) + "===".substring(pad) : asc;
+};
+/**
+ * does what `window.btoa` of web browsers do.
+ * @param {String} bin binary string
+ * @returns {string} Base64-encoded string
+ */
+const _btoa = _hasbtoa ? (bin) => btoa(bin)
+    : _hasBuffer ? (bin) => Buffer.from(bin, 'binary').toString('base64')
+        : btoaPolyfill;
+const _fromUint8Array = _hasBuffer
+    ? (u8a) => Buffer.from(u8a).toString('base64')
+    : (u8a) => {
+        // cf. https://stackoverflow.com/questions/12710001/how-to-convert-uint8-array-to-base64-encoded-string/12713326#12713326
+        const maxargs = 0x1000;
+        let strs = [];
+        for (let i = 0, l = u8a.length; i < l; i += maxargs) {
+            strs.push(_fromCC.apply(null, u8a.subarray(i, i + maxargs)));
+        }
+        return _btoa(strs.join(''));
+    };
+/**
+ * converts a Uint8Array to a Base64 string.
+ * @param {boolean} [urlsafe] URL-and-filename-safe a la RFC4648 §5
+ * @returns {string} Base64 string
+ */
+const fromUint8Array = (u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a);
+// This trick is found broken https://github.com/dankogai/js-base64/issues/130
+// const utob = (src: string) => unescape(encodeURIComponent(src));
+// reverting good old fationed regexp
+const cb_utob = (c) => {
+    if (c.length < 2) {
+        var cc = c.charCodeAt(0);
+        return cc < 0x80 ? c
+            : cc < 0x800 ? (_fromCC(0xc0 | (cc >>> 6))
+                + _fromCC(0x80 | (cc & 0x3f)))
+                : (_fromCC(0xe0 | ((cc >>> 12) & 0x0f))
+                    + _fromCC(0x80 | ((cc >>> 6) & 0x3f))
+                    + _fromCC(0x80 | (cc & 0x3f)));
+    }
+    else {
+        var cc = 0x10000
+            + (c.charCodeAt(0) - 0xD800) * 0x400
+            + (c.charCodeAt(1) - 0xDC00);
+        return (_fromCC(0xf0 | ((cc >>> 18) & 0x07))
+            + _fromCC(0x80 | ((cc >>> 12) & 0x3f))
+            + _fromCC(0x80 | ((cc >>> 6) & 0x3f))
+            + _fromCC(0x80 | (cc & 0x3f)));
+    }
+};
+const re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
+/**
+ * @deprecated should have been internal use only.
+ * @param {string} src UTF-8 string
+ * @returns {string} UTF-16 string
+ */
+const utob = (u) => u.replace(re_utob, cb_utob);
+//
+const _encode = _hasBuffer
+    ? (s) => Buffer.from(s, 'utf8').toString('base64')
+    : _TE
+        ? (s) => _fromUint8Array(_TE.encode(s))
+        : (s) => _btoa(utob(s));
+/**
+ * converts a UTF-8-encoded string to a Base64 string.
+ * @param {boolean} [urlsafe] if `true` make the result URL-safe
+ * @returns {string} Base64 string
+ */
+const encode = (src, urlsafe = false) => urlsafe
+    ? _mkUriSafe(_encode(src))
+    : _encode(src);
+/**
+ * converts a UTF-8-encoded string to URL-safe Base64 RFC4648 §5.
+ * @returns {string} Base64 string
+ */
+const encodeURI = (src) => encode(src, true);
+// This trick is found broken https://github.com/dankogai/js-base64/issues/130
+// const btou = (src: string) => decodeURIComponent(escape(src));
+// reverting good old fationed regexp
+const re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
+const cb_btou = (cccc) => {
+    switch (cccc.length) {
+        case 4:
+            var cp = ((0x07 & cccc.charCodeAt(0)) << 18)
+                | ((0x3f & cccc.charCodeAt(1)) << 12)
+                | ((0x3f & cccc.charCodeAt(2)) << 6)
+                | (0x3f & cccc.charCodeAt(3)), offset = cp - 0x10000;
+            return (_fromCC((offset >>> 10) + 0xD800)
+                + _fromCC((offset & 0x3FF) + 0xDC00));
+        case 3:
+            return _fromCC(((0x0f & cccc.charCodeAt(0)) << 12)
+                | ((0x3f & cccc.charCodeAt(1)) << 6)
+                | (0x3f & cccc.charCodeAt(2)));
+        default:
+            return _fromCC(((0x1f & cccc.charCodeAt(0)) << 6)
+                | (0x3f & cccc.charCodeAt(1)));
+    }
+};
+/**
+ * @deprecated should have been internal use only.
+ * @param {string} src UTF-16 string
+ * @returns {string} UTF-8 string
+ */
+const btou = (b) => b.replace(re_btou, cb_btou);
+/**
+ * polyfill version of `atob`
+ */
+const atobPolyfill = (asc) => {
+    // console.log('polyfilled');
+    asc = asc.replace(/\s+/g, '');
+    if (!b64re.test(asc))
+        throw new TypeError('malformed base64.');
+    asc += '=='.slice(2 - (asc.length & 3));
+    let u24, bin = '', r1, r2;
+    for (let i = 0; i < asc.length;) {
+        u24 = b64tab[asc.charAt(i++)] << 18
+            | b64tab[asc.charAt(i++)] << 12
+            | (r1 = b64tab[asc.charAt(i++)]) << 6
+            | (r2 = b64tab[asc.charAt(i++)]);
+        bin += r1 === 64 ? _fromCC(u24 >> 16 & 255)
+            : r2 === 64 ? _fromCC(u24 >> 16 & 255, u24 >> 8 & 255)
+                : _fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255);
+    }
+    return bin;
+};
+/**
+ * does what `window.atob` of web browsers do.
+ * @param {String} asc Base64-encoded string
+ * @returns {string} binary string
+ */
+const _atob = _hasatob ? (asc) => atob(_tidyB64(asc))
+    : _hasBuffer ? (asc) => Buffer.from(asc, 'base64').toString('binary')
+        : atobPolyfill;
+//
+const _toUint8Array = _hasBuffer
+    ? (a) => _U8Afrom(Buffer.from(a, 'base64'))
+    : (a) => _U8Afrom(_atob(a), c => c.charCodeAt(0));
+/**
+ * converts a Base64 string to a Uint8Array.
+ */
+const toUint8Array = (a) => _toUint8Array(_unURI(a));
+//
+const _decode = _hasBuffer
+    ? (a) => Buffer.from(a, 'base64').toString('utf8')
+    : _TD
+        ? (a) => _TD.decode(_toUint8Array(a))
+        : (a) => btou(_atob(a));
+const _unURI = (a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == '-' ? '+' : '/'));
+/**
+ * converts a Base64 string to a UTF-8 string.
+ * @param {String} src Base64 string.  Both normal and URL-safe are supported
+ * @returns {string} UTF-8 string
+ */
+const decode = (src) => _decode(_unURI(src));
+/**
+ * check if a value is a valid Base64 string
+ * @param {String} src a value to check
+  */
+const isValid = (src) => {
+    if (typeof src !== 'string')
+        return false;
+    const s = src.replace(/\s+/g, '').replace(/={0,2}$/, '');
+    return !/[^\s0-9a-zA-Z\+/]/.test(s) || !/[^\s0-9a-zA-Z\-_]/.test(s);
+};
+//
+const _noEnum = (v) => {
+    return {
+        value: v, enumerable: false, writable: true, configurable: true
+    };
+};
+/**
+ * extend String.prototype with relevant methods
+ */
+const extendString = function () {
+    const _add = (name, body) => Object.defineProperty(String.prototype, name, _noEnum(body));
+    _add('fromBase64', function () { return decode(this); });
+    _add('toBase64', function (urlsafe) { return encode(this, urlsafe); });
+    _add('toBase64URI', function () { return encode(this, true); });
+    _add('toBase64URL', function () { return encode(this, true); });
+    _add('toUint8Array', function () { return toUint8Array(this); });
+};
+/**
+ * extend Uint8Array.prototype with relevant methods
+ */
+const extendUint8Array = function () {
+    const _add = (name, body) => Object.defineProperty(Uint8Array.prototype, name, _noEnum(body));
+    _add('toBase64', function (urlsafe) { return fromUint8Array(this, urlsafe); });
+    _add('toBase64URI', function () { return fromUint8Array(this, true); });
+    _add('toBase64URL', function () { return fromUint8Array(this, true); });
+};
+/**
+ * extend Builtin prototypes with relevant methods
+ */
+const extendBuiltins = () => {
+    extendString();
+    extendUint8Array();
+};
+const gBase64 = {
+    version: version,
+    VERSION: VERSION,
+    atob: _atob,
+    atobPolyfill: atobPolyfill,
+    btoa: _btoa,
+    btoaPolyfill: btoaPolyfill,
+    fromBase64: decode,
+    toBase64: encode,
+    encode: encode,
+    encodeURI: encodeURI,
+    encodeURL: encodeURI,
+    utob: utob,
+    btou: btou,
+    decode: decode,
+    isValid: isValid,
+    fromUint8Array: fromUint8Array,
+    toUint8Array: toUint8Array,
+    extendString: extendString,
+    extendUint8Array: extendUint8Array,
+    extendBuiltins: extendBuiltins,
+};
+// makecjs:CUT //
+export { version };
+export { VERSION };
+export { _atob as atob };
+export { atobPolyfill };
+export { _btoa as btoa };
+export { btoaPolyfill };
+export { decode as fromBase64 };
+export { encode as toBase64 };
+export { utob };
+export { encode };
+export { encodeURI };
+export { encodeURI as encodeURL };
+export { btou };
+export { decode };
+export { isValid };
+export { fromUint8Array };
+export { toUint8Array };
+export { extendString };
+export { extendUint8Array };
+export { extendBuiltins };
+// and finally,
+export { gBase64 as Base64 };

themes/common.js

@@ -109,7 +109,7 @@ function begin_loading_status() {
     C1.style.borderRadius = "50%";
     C1.style.margin = "-40px 0 0 -40px";
     C1.style.animation = "spinAndPulse 2s linear infinite";
-    
+
     C2.style.position = "fixed";
     C2.style.top = "50%";
     C2.style.left = "50%";
@@ -229,6 +229,33 @@ function addCopyButton(botElement) {
     botElement.appendChild(messageBtnColumn);
 }
 
+
+let timeoutID = null;
+let lastInvocationTime = 0;
+let lastArgs = null;
+function do_something_but_not_too_frequently(min_interval, func) {
+    return function(...args) {
+        lastArgs = args;
+        const now = Date.now();
+        if (!lastInvocationTime || (now - lastInvocationTime) >= min_interval) {
+            lastInvocationTime = now;
+            // 现在就执行
+            setTimeout(() => {
+                func.apply(this, lastArgs);
+            }, 0);   
+        } else if (!timeoutID) {
+            // 等一会执行
+            timeoutID = setTimeout(() => {
+                timeoutID = null;
+                lastInvocationTime = Date.now();
+                func.apply(this, lastArgs);
+            }, min_interval - (now - lastInvocationTime));      
+        } else {
+            // 压根不执行
+        }
+    }
+}
+
 function chatbotContentChanged(attempt = 1, force = false) {
     // https://github.com/GaiZhenbiao/ChuanhuChatGPT/tree/main/web_assets/javascript
     for (var i = 0; i < attempt; i++) {
@@ -236,6 +263,13 @@ function chatbotContentChanged(attempt = 1, force = false) {
             gradioApp().querySelectorAll('#gpt-chatbot .message-wrap .message.bot').forEach(addCopyButton);
         }, i === 0 ? 0 : 200);
     }
+
+    const run_mermaid_render = do_something_but_not_too_frequently(1000, function () {
+        const blocks = document.querySelectorAll(`pre.mermaid, diagram-div`);
+        if (blocks.length == 0) { return; }
+        uml("mermaid");
+    });
+    run_mermaid_render();
 }
 
 
@@ -270,8 +304,8 @@ function chatbotAutoHeight() {
     }
     monitoring_input_box()
     update_height();
-    window.addEventListener('resize', function() { update_height(); });
-    window.addEventListener('scroll', function() { update_height_slow(); });
+    window.addEventListener('resize', function () { update_height(); });
+    window.addEventListener('scroll', function () { update_height_slow(); });
     setInterval(function () { update_height_slow() }, 50); // 每50毫秒执行一次
 }
 
@@ -290,8 +324,8 @@ function swap_input_area() {
     // Swap the elements
     parent.insertBefore(element2, element1);
     parent.insertBefore(element1, nextSibling);
-    if (swapped) {swapped = false;}
-    else {swapped = true;}
+    if (swapped) { swapped = false; }
+    else { swapped = true; }
 }
 
 function get_elements(consider_state_panel = false) {
@@ -314,18 +348,18 @@ function get_elements(consider_state_panel = false) {
     var height_target = parseInt(height_target);
     var chatbot_height = chatbot.style.height;
     // 交换输入区位置，使得输入区始终可用
-    if (!swapped){
-        if (panel1.top!=0 && (panel1.bottom + panel1.top)/2 < 0){ swap_input_area(); }
+    if (!swapped) {
+        if (panel1.top != 0 && (panel1.bottom + panel1.top) / 2 < 0) { swap_input_area(); }
     }
-    else if (swapped){
-        if (panel2.top!=0 && panel2.top > 0){ swap_input_area(); }
+    else if (swapped) {
+        if (panel2.top != 0 && panel2.top > 0) { swap_input_area(); }
     }
     // 调整高度
     const err_tor = 5;
-    if (Math.abs(panel1.left - chatbot.getBoundingClientRect().left) < err_tor){
+    if (Math.abs(panel1.left - chatbot.getBoundingClientRect().left) < err_tor) {
         // 是否处于窄屏模式
         height_target = window.innerHeight * 0.6;
-    }else{
+    } else {
         // 调整高度
         const chatbot_height_exceed = 15;
         const chatbot_height_exceed_m = 10;
@@ -356,7 +390,7 @@ var elem_upload_component_float = null;
 var elem_upload_component = null;
 var exist_file_msg = '⚠️请先删除上传区（左上方）中的历史文件，再尝试上传。'
 
-function locate_upload_elems(){
+function locate_upload_elems() {
     elem_upload = document.getElementById('elem_upload')
     elem_upload_float = document.getElementById('elem_upload_float')
     elem_input_main = document.getElementById('user_input_main')
@@ -386,7 +420,6 @@ async function upload_files(files) {
             Object.defineProperty(elem_upload_component_float, "files", { value: files, enumerable: true });
             elem_upload_component_float.dispatchEvent(event);
         } else {
-            console.log(exist_file_msg);
             toast_push(exist_file_msg, 3000);
         }
     }
@@ -500,7 +533,7 @@ function register_upload_event() {
             toast_push('正在上传中，请稍等。', 2000);
             begin_loading_status();
         });
-    }else{
+    } else {
         toast_push("oppps", 3000);
     }
 }
@@ -583,16 +616,16 @@ function minor_ui_adjustment() {
     function auto_hide_toolbar() {
         var qq = document.getElementById('tooltip');
         var tab_nav = qq.getElementsByClassName('tab-nav');
-        if (tab_nav.length == 0){ return; }
+        if (tab_nav.length == 0) { return; }
         var btn_list = tab_nav[0].getElementsByTagName('button')
-        if (btn_list.length == 0){ return; }
+        if (btn_list.length == 0) { return; }
         // 获取页面宽度
         var page_width = document.documentElement.clientWidth;
         // 总是保留的按钮数量
         const always_preserve = 2;
         // 获取最后一个按钮的右侧位置
-        var cur_right = btn_list[always_preserve-1].getBoundingClientRect().right;
-        if (bar_btn_width.length == 0){
+        var cur_right = btn_list[always_preserve - 1].getBoundingClientRect().right;
+        if (bar_btn_width.length == 0) {
             // 首次运行，记录每个按钮的宽度
             for (var i = 0; i < btn_list.length; i++) {
                 bar_btn_width.push(btn_list[i].getBoundingClientRect().width);
@@ -602,14 +635,13 @@ function minor_ui_adjustment() {
         for (var i = always_preserve; i < btn_list.length; i++) {
             var element = btn_list[i];
             var element_right = element.getBoundingClientRect().right;
-            if (element_right!=0){ cur_right = element_right; }
+            if (element_right != 0) { cur_right = element_right; }
             if (element.style.display === 'none') {
                 if ((cur_right + bar_btn_width[i]) < (page_width * 0.37)) {
                     // 恢复显示当前按钮
                     element.style.display = 'block';
-                    // console.log('show');
                     return;
-                }else{
+                } else {
                     return;
                 }
             } else {
@@ -620,7 +652,6 @@ function minor_ui_adjustment() {
                             btn_list[j].style.display = 'none';
                         }
                     }
-                    // console.log('show');
                     return;
                 }
             }
@@ -632,8 +663,41 @@ function minor_ui_adjustment() {
     }, 200); // 每50毫秒执行一次
 }
 
+
 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-//  第 6 部分: JS初始化函数
+//  第 6 部分: 避免滑动
+// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+let prevented_offset = 0;
+function limit_scroll_position() {
+    let scrollableDiv = document.querySelector('#gpt-chatbot > div.wrap');
+    scrollableDiv.addEventListener('wheel', function (e) {
+        let preventScroll = false;
+        if (e.deltaX != 0) { prevented_offset = 0; return;}
+        if (this.scrollHeight == this.clientHeight) { prevented_offset = 0; return;}
+        if (e.deltaY < 0) { prevented_offset = 0; return;}
+        if (e.deltaY > 0 && this.scrollHeight - this.clientHeight - this.scrollTop <= 1) { preventScroll = true; }
+
+        if (preventScroll) {
+            prevented_offset += e.deltaY;
+            if (Math.abs(prevented_offset) > 499) {
+                if (prevented_offset > 500) { prevented_offset = 500; }
+                if (prevented_offset < -500) { prevented_offset = -500; }
+                preventScroll = false;
+            }
+        } else {
+            prevented_offset = 0;
+        }
+        if (preventScroll) {
+            e.preventDefault();
+            return;
+        }
+    }, { passive: false }); // Passive event listener option should be false
+}
+
+
+
+// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+//  第 7 部分: JS初始化函数
 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 function GptAcademicJavaScriptInit(LAYOUT = "LEFT-RIGHT") {
@@ -645,4 +709,7 @@ function GptAcademicJavaScriptInit(LAYOUT = "LEFT-RIGHT") {
     });
     chatbotObserver.observe(chatbotIndicator, { attributes: true, childList: true, subtree: true });
     if (LAYOUT === "LEFT-RIGHT") { chatbotAutoHeight(); }
+    if (LAYOUT === "LEFT-RIGHT") { limit_scroll_position(); }
+    // setInterval(function () { uml("mermaid") }, 5000); // 每50毫秒执行一次
+
 }

themes/common.py

@@ -0,0 +1,21 @@
+from toolbox import get_conf
+CODE_HIGHLIGHT, ADD_WAIFU, LAYOUT = get_conf("CODE_HIGHLIGHT", "ADD_WAIFU", "LAYOUT")
+
+def get_common_html_javascript_code():
+    js = "\n"
+    for jsf in [
+        "file=themes/common.js",
+        "file=themes/mermaid.min.js",
+        "file=themes/mermaid_loader.js",
+    ]:
+        js += f"""<script src="{jsf}"></script>\n"""
+
+    # 添加Live2D
+    if ADD_WAIFU:
+        for jsf in [
+            "file=docs/waifu_plugin/jquery.min.js",
+            "file=docs/waifu_plugin/jquery-ui.min.js",
+            "file=docs/waifu_plugin/autoload.js",
+        ]:
+            js += f"""<script src="{jsf}"></script>\n"""
+    return js

themes/contrast.py

@@ -67,16 +67,9 @@ def adjust_theme():
             button_cancel_text_color_dark="white",
         )
 
-        with open(os.path.join(theme_dir, "common.js"), "r", encoding="utf8") as f:
-            js = f"<script>{f.read()}</script>"
-
-        # 添加一个萌萌的看板娘
-        if ADD_WAIFU:
-            js += """
-                <script src="file=docs/waifu_plugin/jquery.min.js"></script>
-                <script src="file=docs/waifu_plugin/jquery-ui.min.js"></script>
-                <script src="file=docs/waifu_plugin/autoload.js"></script>
-            """
+        from themes.common import get_common_html_javascript_code
+        js = get_common_html_javascript_code()
+        
         if not hasattr(gr, "RawTemplateResponse"):
             gr.RawTemplateResponse = gr.routes.templates.TemplateResponse
         gradio_original_template_fn = gr.RawTemplateResponse

themes/default.py

@@ -67,16 +67,8 @@ def adjust_theme():
             button_cancel_text_color_dark="white",
         )
 
-        with open(os.path.join(theme_dir, "common.js"), "r", encoding="utf8") as f:
-            js = f"<script>{f.read()}</script>"
-
-        # 添加一个萌萌的看板娘
-        if ADD_WAIFU:
-            js += """
-                <script src="file=docs/waifu_plugin/jquery.min.js"></script>
-                <script src="file=docs/waifu_plugin/jquery-ui.min.js"></script>
-                <script src="file=docs/waifu_plugin/autoload.js"></script>
-            """
+        from themes.common import get_common_html_javascript_code
+        js = get_common_html_javascript_code()
         if not hasattr(gr, "RawTemplateResponse"):
             gr.RawTemplateResponse = gr.routes.templates.TemplateResponse
         gradio_original_template_fn = gr.RawTemplateResponse

themes/gradios.py

@@ -31,16 +31,9 @@ def adjust_theme():
                 THEME = THEME.lstrip("huggingface-")
             set_theme = set_theme.from_hub(THEME.lower())
 
-        with open(os.path.join(theme_dir, "common.js"), "r", encoding="utf8") as f:
-            js = f"<script>{f.read()}</script>"
-
-        # 添加一个萌萌的看板娘
-        if ADD_WAIFU:
-            js += """
-                <script src="file=docs/waifu_plugin/jquery.min.js"></script>
-                <script src="file=docs/waifu_plugin/jquery-ui.min.js"></script>
-                <script src="file=docs/waifu_plugin/autoload.js"></script>
-            """
+        from themes.common import get_common_html_javascript_code
+        js = get_common_html_javascript_code()
+        
         if not hasattr(gr, "RawTemplateResponse"):
             gr.RawTemplateResponse = gr.routes.templates.TemplateResponse
         gradio_original_template_fn = gr.RawTemplateResponse

themes/green.py

@@ -76,16 +76,8 @@ def adjust_theme():
             chatbot_code_background_color_dark="*neutral_950",
         )
 
-        with open(os.path.join(theme_dir, "common.js"), "r", encoding="utf8") as f:
-            js = f"<script>{f.read()}</script>"
-
-        # 添加一个萌萌的看板娘
-        if ADD_WAIFU:
-            js += """
-                <script src="file=docs/waifu_plugin/jquery.min.js"></script>
-                <script src="file=docs/waifu_plugin/jquery-ui.min.js"></script>
-                <script src="file=docs/waifu_plugin/autoload.js"></script>
-            """
+        from themes.common import get_common_html_javascript_code
+        js = get_common_html_javascript_code()
 
         with open(os.path.join(theme_dir, "green.js"), "r", encoding="utf8") as f:
             js += f"<script>{f.read()}</script>"

themes/mermaid_editor.js

@@ -0,0 +1,55 @@
+import { deflate, inflate } from '/file=themes/pako.esm.mjs';
+import { toUint8Array, fromUint8Array, toBase64, fromBase64 } from '/file=themes/base64.mjs';
+
+const base64Serde = {
+    serialize: (state) => {
+        return toBase64(state, true);
+    },
+    deserialize: (state) => {
+        return fromBase64(state);
+    }
+};
+
+const pakoSerde = {
+    serialize: (state) => {
+        const data = new TextEncoder().encode(state);
+        const compressed = deflate(data, { level: 9 });
+        return fromUint8Array(compressed, true);
+    },
+    deserialize: (state) => {
+        const data = toUint8Array(state);
+        return inflate(data, { to: 'string' });
+    }
+};
+
+const serdes = {
+    base64: base64Serde,
+    pako: pakoSerde
+};
+
+export const serializeState = (state, serde = 'pako') => {
+    if (!(serde in serdes)) {
+        throw new Error(`Unknown serde type: ${serde}`);
+    }
+    const json = JSON.stringify(state);
+    const serialized = serdes[serde].serialize(json);
+    return `${serde}:${serialized}`;
+};
+
+const deserializeState = (state) => {
+    let type, serialized;
+    if (state.includes(':')) {
+        let tempType;
+        [tempType, serialized] = state.split(':');
+        if (tempType in serdes) {
+            type = tempType;
+        } else {
+            throw new Error(`Unknown serde type: ${tempType}`);
+        }
+    } else {
+        type = 'base64';
+        serialized = state;
+    }
+    const json = serdes[type].deserialize(serialized);
+    return JSON.parse(json);
+};

themes/mermaid_loader.js

@@ -0,0 +1,197 @@
+const uml = async className => {
+
+    // Custom element to encapsulate Mermaid content.
+    class MermaidDiv extends HTMLElement {
+
+        /**
+        * Creates a special Mermaid div shadow DOM.
+        * Works around issues of shared IDs.
+        * @return {void}
+        */
+        constructor() {
+            super()
+
+            // Create the Shadow DOM and attach style
+            const shadow = this.attachShadow({ mode: "open" })
+            const style = document.createElement("style")
+            style.textContent = `
+        :host {
+          display: block;
+          line-height: initial;
+          font-size: 16px;
+        }
+        div.diagram {
+          margin: 0;
+          overflow: visible;
+        }`
+            shadow.appendChild(style)
+        }
+    }
+
+    if (typeof customElements.get("diagram-div") === "undefined") {
+        customElements.define("diagram-div", MermaidDiv)
+    }
+
+    const getFromCode = parent => {
+        // Handles <pre><code> text extraction.
+        let text = ""
+        for (let j = 0; j < parent.childNodes.length; j++) {
+            const subEl = parent.childNodes[j]
+            if (subEl.tagName.toLowerCase() === "code") {
+                for (let k = 0; k < subEl.childNodes.length; k++) {
+                    const child = subEl.childNodes[k]
+                    const whitespace = /^\s*$/
+                    if (child.nodeName === "#text" && !(whitespace.test(child.nodeValue))) {
+                        text = child.nodeValue
+                        break
+                    }
+                }
+            }
+        }
+        return text
+    }
+
+    function createOrUpdateHyperlink(parentElement, linkText, linkHref) {
+        // Search for an existing anchor element within the parentElement
+        let existingAnchor = parentElement.querySelector("a");
+
+        // Check if an anchor element already exists
+        if (existingAnchor) {
+            // Update the hyperlink reference if it's different from the current one
+            if (existingAnchor.href !== linkHref) {
+                existingAnchor.href = linkHref;
+            }
+            // Update the target attribute to ensure it opens in a new tab
+            existingAnchor.target = '_blank';
+
+            // If the text must be dynamic, uncomment and use the following line:
+            // existingAnchor.textContent = linkText;
+        } else {
+            // If no anchor exists, create one and append it to the parentElement
+            let anchorElement = document.createElement("a");
+            anchorElement.href = linkHref; // Set hyperlink reference
+            anchorElement.textContent = linkText; // Set text displayed
+            anchorElement.target = '_blank'; // Ensure it opens in a new tab
+            parentElement.appendChild(anchorElement); // Append the new anchor element to the parent
+        }
+    }
+
+    function removeLastLine(str) {
+        // 将字符串按换行符分割成数组
+        var lines = str.split('\n');
+        lines.pop();
+        // 将数组重新连接成字符串，并按换行符连接
+        var result = lines.join('\n');
+        return result;
+    }
+
+    // 给出配置 Provide a default config in case one is not specified
+    const defaultConfig = {
+        startOnLoad: false,
+        theme: "default",
+        flowchart: {
+            htmlLabels: false
+        },
+        er: {
+            useMaxWidth: false
+        },
+        sequence: {
+            useMaxWidth: false,
+            noteFontWeight: "14px",
+            actorFontSize: "14px",
+            messageFontSize: "16px"
+        }
+    }
+    if (document.body.classList.contains("dark")) {
+        defaultConfig.theme = "dark"
+    }
+    
+    const Module = await import('/file=themes/mermaid_editor.js');
+
+    function do_render(block, code, codeContent, cnt) {
+        var rendered_content = mermaid.render(`_diagram_${cnt}`, code);
+        ////////////////////////////// 记录有哪些代码已经被渲染了 ///////////////////////////////////
+        let codeFinishRenderElement = block.querySelector("code_finish_render"); // 如果block下已存在code_already_rendered元素，则获取它
+        if (codeFinishRenderElement) {                                             // 如果block下已存在code_already_rendered元素
+            codeFinishRenderElement.style.display = "none";
+        } else {
+            // 如果不存在code_finish_render元素，则将code元素中的内容添加到新创建的code_finish_render元素中
+            let codeFinishRenderElementNew = document.createElement("code_finish_render"); // 创建一个新的code_already_rendered元素
+            codeFinishRenderElementNew.style.display = "none";
+            codeFinishRenderElementNew.textContent = "";
+            block.appendChild(codeFinishRenderElementNew); // 将新创建的code_already_rendered元素添加到block中
+            codeFinishRenderElement = codeFinishRenderElementNew;
+        }
+
+        ////////////////////////////// 创建一个用于渲染的容器 ///////////////////////////////////
+        let mermaidRender = block.querySelector(".mermaid_render"); // 尝试获取已存在的<div class='mermaid_render'>
+        if (!mermaidRender) {
+            mermaidRender = document.createElement("div");  // 不存在，创建新的<div class='mermaid_render'>
+            mermaidRender.classList.add("mermaid_render");
+            block.appendChild(mermaidRender);               // 将新创建的元素附加到block
+        }
+        mermaidRender.innerHTML = rendered_content
+        codeFinishRenderElement.textContent = code  // 标记已经渲染的部分
+
+        ////////////////////////////// 创建一个“点击这里编辑脑图” ///////////////////////////////
+        let pako_encode = Module.serializeState({
+            "code": codeContent,
+            "mermaid": "{\n  \"theme\": \"default\"\n}",
+            "autoSync": true,
+            "updateDiagram": false
+        });
+        createOrUpdateHyperlink(block, "点击这里编辑脑图", "https://mermaid.live/edit#" + pako_encode)
+    }
+
+    // 加载配置 Load up the config
+    mermaid.mermaidAPI.globalReset() // 全局复位
+    const config = (typeof mermaidConfig === "undefined") ? defaultConfig : mermaidConfig
+    mermaid.initialize(config)
+    // 查找需要渲染的元素 Find all of our Mermaid sources and render them.
+    const blocks = document.querySelectorAll(`pre.mermaid`);
+
+    for (let i = 0; i < blocks.length; i++) {
+        var block = blocks[i]
+        ////////////////////////////// 如果代码没有发生变化，就不渲染了 ///////////////////////////////////
+        var code = getFromCode(block);
+        let code_elem = block.querySelector("code");
+        let codeContent = code_elem.textContent; // 获取code元素中的文本内容
+
+        // 判断codeContent是否包含'<gpt_academic_hide_mermaid_code>'，如果是，则使code_elem隐藏
+        if (codeContent.indexOf('<gpt_academic_hide_mermaid_code>') !== -1) {
+            code_elem.style.display = "none";
+        }
+
+        // 如果block下已存在code_already_rendered元素，则获取它
+        let codePendingRenderElement = block.querySelector("code_pending_render");
+        if (codePendingRenderElement) {                               // 如果block下已存在code_pending_render元素
+            codePendingRenderElement.style.display = "none";
+            if (codePendingRenderElement.textContent !== codeContent) {
+                codePendingRenderElement.textContent = codeContent; // 如果现有的code_pending_render元素中的内容与code元素中的内容不同，更新code_pending_render元素中的内容
+            }
+            else {
+                continue; // 如果相同，就不处理了
+            }
+        } else { // 如果不存在code_pending_render元素，则将code元素中的内容添加到新创建的code_pending_render元素中
+            let codePendingRenderElementNew = document.createElement("code_pending_render"); // 创建一个新的code_already_rendered元素
+            codePendingRenderElementNew.style.display = "none";
+            codePendingRenderElementNew.textContent = codeContent;
+            block.appendChild(codePendingRenderElementNew); // 将新创建的code_pending_render元素添加到block中
+            codePendingRenderElement = codePendingRenderElementNew;
+        }
+
+        ////////////////////////////// 在这里才真正开始渲染 ///////////////////////////////////
+        try {
+            do_render(block, code, codeContent, i);
+            // console.log("渲染", codeContent);
+        } catch (err) {
+            try {
+                var lines = code.split('\n'); if (lines.length < 2) { continue; }
+                do_render(block, removeLastLine(code), codeContent, i);
+                // console.log("渲染", codeContent);
+            } catch (err) {
+                console.log("以下代码不能渲染", code, removeLastLine(code), err);
+            }
+        }
+    }
+}

themes/theme.py

@@ -111,6 +111,7 @@ js_code_for_toggle_darkmode = """() => {
     } else {
         document.querySelector('body').classList.add('dark');
     }
+    document.querySelectorAll('code_pending_render').forEach(code => {code.remove();})
 }"""
 
 

version

@@ -1,5 +1,5 @@
 {
-  "version": 3.65,
+  "version": 3.71,
   "show_feature": true,
-  "new_feature": "支持Gemini-pro <-> 支持直接拖拽文件到上传区 <-> 支持将图片粘贴到输入区 <-> 修复若干隐蔽的内存BUG <-> 修复多用户冲突问题 <-> 接入Deepseek Coder <-> AutoGen多智能体插件测试版"
+  "new_feature": "用绘图功能增强部分插件 <-> 基础功能区支持自动切换中英提示词 <-> 支持Mermaid绘图库（让大模型绘制脑图） <-> 支持Gemini-pro <-> 支持直接拖拽文件到上传区 <-> 支持将图片粘贴到输入区"
 }