UP

解析项目源代码（手动指定和筛选源代码文件类型）

.gitignore

@@ -145,3 +145,4 @@ cradle*
 debug*
 private*
 crazy_functions/test_project/pdf_and_word
+crazy_functions/test_samples

README.md

@@ -30,6 +30,7 @@ If you like this project, please give it a Star. If you've come up with more use
 Latex全文翻译、润色 | [函数插件] 一键翻译或润色latex论文
 批量注释生成 | [函数插件] 一键批量生成函数注释
 chat分析报告生成 | [函数插件] 运行后自动生成总结汇报
+Markdown中英互译 | [函数插件] 看到上面5种语言的[README](https://github.com/binary-husky/chatgpt_academic/blob/master/docs/README_EN.md)了吗？
 [arxiv小助手](https://www.bilibili.com/video/BV1LM4y1279X) | [函数插件] 输入arxiv文章url即可一键翻译摘要+下载PDF
 [PDF论文全文翻译功能](https://www.bilibili.com/video/BV1KT411x7Wn) | [函数插件] PDF论文提取题目&摘要+翻译全文（多线程）
 [谷歌学术统合小助手](https://www.bilibili.com/video/BV19L411U7ia) | [函数插件] 给定任意谷歌学术搜索页面URL，让gpt帮你选择有趣的文章
@@ -43,7 +44,7 @@ huggingface免科学上网[在线体验](https://huggingface.co/spaces/qingxu98/
 </div>
 
 
-- 新界面（修改config.py中的LAYOUT选项即可实现“左右布局”和“上下布局”的切换）
+- 新界面（修改`config.py`中的LAYOUT选项即可实现“左右布局”和“上下布局”的切换）
 <div align="center">
 <img src="https://user-images.githubusercontent.com/96192199/230361456-61078362-a966-4eb5-b49e-3c62ef18b860.gif" width="700" >
 </div>
@@ -91,9 +92,8 @@ cd chatgpt_academic
 
 在`config.py`中，配置 海外Proxy 和 OpenAI API KEY，说明如下
 ```
-1. 如果你在国内，需要设置海外代理才能够顺利使用 OpenAI API，设置方法请仔细阅读config.py（1.修改其中的USE_PROXY为True; 2.按照说明修改其中的proxies）。
-2. 配置 OpenAI API KEY。你需要在 OpenAI 官网上注册并获取 API KEY。一旦你拿到了 API KEY，在 config.py 文件里配置好即可。
-3. 支持任意数量的OpenAI的密钥和API2D的密钥共存/负载均衡，多个KEY用英文逗号分隔即可，例如输入 API_KEY="OpenAI密钥1,API2D密钥2,OpenAI密钥3,OpenAI密钥4"
+1. 如果你在国内，需要设置海外代理才能够顺利使用OpenAI API，设置方法请仔细阅读config.py（1.修改其中的USE_PROXY为True; 2.按照说明修改其中的proxies）。
+2. 配置 OpenAI API KEY。支持任意数量的OpenAI的密钥和API2D的密钥共存/负载均衡，多个KEY用英文逗号分隔即可，例如输入 API_KEY="OpenAI密钥1,API2D密钥2,OpenAI密钥3,OpenAI密钥4"
 3. 与代理网络有关的issue（网络超时、代理不起作用）汇总到 https://github.com/binary-husky/chatgpt_academic/issues/1
 ```
 （P.S. 程序运行时会优先检查是否存在名为`config_private.py`的私密配置文件，并用其中的配置覆盖`config.py`的同名配置。因此，如果您能理解我们的配置读取逻辑，我们强烈建议您在`config.py`旁边创建一个名为`config_private.py`的新配置文件，并把`config.py`中的配置转移（复制）到`config_private.py`中。`config_private.py`不受git管控，可以让您的隐私信息更加安全。）
@@ -101,19 +101,17 @@ cd chatgpt_academic
 
 3. 安装依赖
 ```sh
-# （选择一）推荐
-python -m pip install -r requirements.txt   
+# （选择I: 如熟悉python）推荐
+python -m pip install -r requirements.txt
+# 备注：使用官方pip源或者阿里pip源，其他pip源（如一些大学的pip）有可能出问题，临时换源方法：python -m pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/
 
-# （选择二）如果您使用anaconda，步骤也是类似的：
-# （选择二.1）conda create -n gptac_venv python=3.11
-# （选择二.2）conda activate gptac_venv
-# （选择二.3）python -m pip install -r requirements.txt
-
-# 备注：使用官方pip源或者阿里pip源，其他pip源（如一些大学的pip）有可能出问题，临时换源方法： 
-# python -m pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/
+# （选择II: 如不熟悉python）使用anaconda，步骤也是类似的：
+# （II-1）conda create -n gptac_venv python=3.11
+# （II-2）conda activate gptac_venv
+# （II-3）python -m pip install -r requirements.txt
 ```
 
-如果需要支持清华ChatGLM，需要额外安装更多依赖（不熟悉python者、电脑配置不佳者，建议不要尝试）：
+如果需要支持清华ChatGLM后端，需要额外安装更多依赖（前提条件：熟悉python + 电脑配置够强）：
 ```sh
 python -m pip install -r request_llm/requirements_chatglm.txt
 ```
@@ -126,54 +124,48 @@ python main.py
 5. 测试函数插件
 ```
 - 测试Python项目分析
-    input区域 输入 `./crazy_functions/test_project/python/dqn` ， 然后点击 "解析整个Python项目"
-- 测试自我代码解读
+    （选择1）input区域 输入 `./crazy_functions/test_project/python/dqn` ， 然后点击 "解析整个Python项目"
+    （选择2）展开文件上传区，将python文件/包含python文件的压缩包拖拽进去，在出现反馈提示后， 然后点击 "解析整个Python项目"
+- 测试自我代码解读（本项目自译解）
     点击 "[多线程Demo] 解析此项目本身（源码自译解）"
-- 测试实验功能模板函数（要求gpt回答历史上的今天发生了什么），您可以根据此函数为模板，实现更复杂的功能
+- 测试函数插件模板函数（要求gpt回答历史上的今天发生了什么），您可以根据此函数为模板，实现更复杂的功能
     点击 "[函数插件模板Demo] 历史上的今天"
 - 函数插件区下拉菜单中有更多功能可供选择
 ```
 
-## 安装-方法2：使用docker (Linux)
+## 安装-方法2：使用Docker
 
 1. 仅ChatGPT（推荐大多数人选择）
+
 ``` sh
 # 下载项目
 git clone https://github.com/binary-husky/chatgpt_academic.git
 cd chatgpt_academic
-# 配置 海外Proxy 和 OpenAI API KEY
+# 配置 “海外Proxy”， “API_KEY” 以及 “WEB_PORT” (例如50923) 等
 用任意文本编辑器编辑 config.py
 # 安装
 docker build -t gpt-academic .
-# 运行
+#（最后一步-选择1）在Linux环境下，用`--net=host`更方便快捷
 docker run --rm -it --net=host gpt-academic
-
-# 测试函数插件
-## 测试函数插件模板函数（要求gpt回答历史上的今天发生了什么），您可以根据此函数为模板，实现更复杂的功能
-点击 "[函数插件模板Demo] 历史上的今天"
-## 测试给Latex项目写摘要
-input区域 输入 ./crazy_functions/test_project/latex/attention ， 然后点击 "读Tex论文写摘要"
-## 测试Python项目分析
-input区域 输入 ./crazy_functions/test_project/python/dqn ， 然后点击 "解析整个Python项目"
-
-函数插件区下拉菜单中有更多功能可供选择
+#（最后一步-选择2）在macOS/windows环境下，只能用-p选项将容器上的端口(例如50923)暴露给主机上的端口
+docker run --rm -it -p 50923:50923 gpt-academic
 ```
 
-2. ChatGPT+ChatGLM（需要对docker非常熟悉 + 电脑配置足够强）
+2. ChatGPT+ChatGLM（需要对Docker熟悉 + 读懂Dockerfile + 电脑配置够强）
 
 ``` sh
-# 修改dockerfile
+# 修改Dockerfile
 cd docs && nano Dockerfile+ChatGLM
-# How to build | 如何构建 （Dockerfile+ChatGLM在docs路径下，请先cd docs）
+# 构建 （Dockerfile+ChatGLM在docs路径下，请先cd docs）
 docker build -t gpt-academic --network=host -f Dockerfile+ChatGLM .
-# How to run | 如何运行 (1) 直接运行: 
+# 运行 (1) 直接运行: 
 docker run --rm -it --net=host --gpus=all gpt-academic
-# How to run | 如何运行 (2) 我想运行之前进容器做一些调整: 
+# 运行 (2) 我想运行之前进容器做一些调整: 
 docker run --rm -it --net=host --gpus=all gpt-academic bash
 ```
 
 
-## 安装-方法3：其他部署方式
+## 安装-方法3：其他部署方式（需要云服务器知识与经验）
 
 1. 远程云服务器部署
 请访问[部署wiki-1](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8%E8%BF%9C%E7%A8%8B%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97)
@@ -181,6 +173,8 @@ docker run --rm -it --net=host --gpus=all gpt-academic bash
 2. 使用WSL2（Windows Subsystem for Linux 子系统）
 请访问[部署wiki-2](https://github.com/binary-husky/chatgpt_academic/wiki/%E4%BD%BF%E7%94%A8WSL2%EF%BC%88Windows-Subsystem-for-Linux-%E5%AD%90%E7%B3%BB%E7%BB%9F%EF%BC%89%E9%83%A8%E7%BD%B2)
 
+3. 如何在二级网址（如`http://localhost/subpath`）下运行
+请访问[FastAPI运行说明](docs/WithFastapi.md)
 
 ## 安装-代理配置
 1. 常规方法
@@ -192,7 +186,9 @@ docker run --rm -it --net=host --gpus=all gpt-academic bash
 
 ---
 
-## 自定义新的便捷按钮（学术快捷键自定义）
+## 自定义新的便捷按钮 / 自定义函数插件
+
+1. 自定义新的便捷按钮（学术快捷键）
 任意文本编辑器打开`core_functional.py`，添加条目如下，然后重启程序即可。（如果按钮已经添加成功并可见，那么前缀、后缀都支持热修改，无需重启程序即可生效。）
 例如
 ```
@@ -208,19 +204,25 @@ docker run --rm -it --net=host --gpus=all gpt-academic bash
 <img src="https://user-images.githubusercontent.com/96192199/226899272-477c2134-ed71-4326-810c-29891fe4a508.png" width="500" >
 </div>
 
+2. 自定义函数插件
+
+编写强大的函数插件来执行任何你想得到的和想不到的任务。
+本项目的插件编写、调试难度很低，只要您具备一定的python基础知识，就可以仿照我们提供的模板实现自己的插件功能。
+详情请参考[函数插件指南](https://github.com/binary-husky/chatgpt_academic/wiki/%E5%87%BD%E6%95%B0%E6%8F%92%E4%BB%B6%E6%8C%87%E5%8D%97)。
+
+
 ---
 
 
 ## 部分功能展示
 
-### 图片显示：
+1. 图片显示：
 
 <div align="center">
 <img src="https://user-images.githubusercontent.com/96192199/228737599-bf0a9d9c-1808-4f43-ae15-dfcc7af0f295.png" width="800" >
 </div>
 
-
-### 如果一个程序能够读懂并剖析自己：
+2. 本项目的代码自译解（如果一个程序能够读懂并剖析自己）：
 
 <div align="center">
 <img src="https://user-images.githubusercontent.com/96192199/226936850-c77d7183-0749-4c1c-9875-fd4891842d0c.png" width="800" >
@@ -230,7 +232,7 @@ docker run --rm -it --net=host --gpus=all gpt-academic bash
 <img src="https://user-images.githubusercontent.com/96192199/226936618-9b487e4b-ab5b-4b6e-84c6-16942102e917.png" width="800" >
 </div>
 
-### 其他任意Python/Cpp项目剖析：
+3. 其他任意Python/Cpp/Java/Go/Rect/...项目剖析：
 <div align="center">
 <img src="https://user-images.githubusercontent.com/96192199/226935232-6b6a73ce-8900-4aee-93f9-733c7e6fef53.png" width="800" >
 </div>
@@ -239,31 +241,41 @@ docker run --rm -it --net=host --gpus=all gpt-academic bash
 <img src="https://user-images.githubusercontent.com/96192199/226969067-968a27c1-1b9c-486b-8b81-ab2de8d3f88a.png" width="800" >
 </div>
 
-### Latex论文一键阅读理解与摘要生成
+4. Latex论文一键阅读理解与摘要生成
 <div align="center">
 <img src="https://user-images.githubusercontent.com/96192199/227504406-86ab97cd-f208-41c3-8e4a-7000e51cf980.png" width="800" >
 </div>
 
-### 自动报告生成
+5. 自动报告生成
 <div align="center">
 <img src="https://user-images.githubusercontent.com/96192199/227503770-fe29ce2c-53fd-47b0-b0ff-93805f0c2ff4.png" height="300" >
 <img src="https://user-images.githubusercontent.com/96192199/227504617-7a497bb3-0a2a-4b50-9a8a-95ae60ea7afd.png" height="300" >
 <img src="https://user-images.githubusercontent.com/96192199/227504005-efeaefe0-b687-49d0-bf95-2d7b7e66c348.png" height="300" >
 </div>
 
-### 模块化功能设计
+6. 模块化功能设计
 <div align="center">
 <img src="https://user-images.githubusercontent.com/96192199/229288270-093643c1-0018-487a-81e6-1d7809b6e90f.png" height="400" >
 <img src="https://user-images.githubusercontent.com/96192199/227504931-19955f78-45cd-4d1c-adac-e71e50957915.png" height="400" >
 </div>
 
 
-### 源代码转译英文
+7. 源代码转译英文
 
 <div align="center">
 <img src="https://user-images.githubusercontent.com/96192199/229720562-fe6c3508-6142-4635-a83d-21eb3669baee.png" height="400" >
 </div>
 
+8. 互联网在线信息综合
+
+<div align="center">
+<img src="https://user-images.githubusercontent.com/96192199/233575247-fb00819e-6d1b-4bb7-bd54-1d7528f03dd9.png" width="800" >
+<img src="https://user-images.githubusercontent.com/96192199/233779501-5ce826f0-6cca-4d59-9e5f-b4eacb8cc15f.png" width="800" >
+
+</div>
+
+
+
 ## Todo 与 版本规划:
 - version 3.2+ (todo): 函数插件支持更多参数接口
 - version 3.1: 支持同时问询多个gpt模型！支持api2d，支持多个apikey负载均衡

config.py

@@ -56,3 +56,10 @@ CONCURRENT_COUNT = 100
 # 设置用户名和密码（不需要修改）（相关功能不稳定，与gradio版本和网络都相关，如果本地使用不建议加这个）
 # [("username", "password"), ("username2", "password2"), ...]
 AUTHENTICATION = []
+
+# 重新URL重新定向，实现更换API_URL的作用（常规情况下，不要修改!!）
+# 格式 {"https://api.openai.com/v1/chat/completions": "重定向的URL"}
+API_URL_REDIRECT = {}
+
+# 如果需要在二级路径下运行（常规情况下，不要修改!!）（需要配合修改main.py才能生效!）
+CUSTOM_PATH = "/"

crazy_functional.py

@@ -19,12 +19,23 @@ def get_crazy_functions():
     from crazy_functions.解析项目源代码 import 解析一个Lua项目
     from crazy_functions.解析项目源代码 import 解析一个CSharp项目
     from crazy_functions.总结word文档 import 总结word文档
+    from crazy_functions.解析JupyterNotebook import 解析ipynb文件
+    from crazy_functions.对话历史存档 import 对话历史存档
     function_plugins = {
 
         "解析整个Python项目": {
             "Color": "stop",    # 按钮颜色
             "Function": HotReload(解析一个Python项目)
         },
+        "保存当前的对话": {
+            "AsButton":False,
+            "Function": HotReload(对话历史存档)
+        },
+        "[测试功能] 解析Jupyter Notebook文件": {
+            "Color": "stop",
+            "AsButton":False,
+            "Function": HotReload(解析ipynb文件),
+        },
         "批量总结Word文档": {
             "Color": "stop",
             "Function": HotReload(总结word文档)
@@ -168,25 +179,48 @@ def get_crazy_functions():
             "AsButton": False,  # 加入下拉菜单中
             "Function": HotReload(Markdown英译中)
         },
-        
+
     })
 
     ###################### 第三组插件 ###########################
     # [第三组插件]: 尚未充分测试的函数插件，放在这里
-    try:
-        from crazy_functions.下载arxiv论文翻译摘要 import 下载arxiv论文并翻译摘要
-        function_plugins.update({
-            "一键下载arxiv论文并翻译摘要（先在input输入编号，如1812.10695）": {
-                "Color": "stop",
-                "AsButton": False,  # 加入下拉菜单中
-                "Function": HotReload(下载arxiv论文并翻译摘要)
-            }
-        })
-
-    except Exception as err:
-        print(f'[下载arxiv论文并翻译摘要] 插件导入失败 {str(err)}')
-        
+    from crazy_functions.下载arxiv论文翻译摘要 import 下载arxiv论文并翻译摘要
+    function_plugins.update({
+        "一键下载arxiv论文并翻译摘要（先在input输入编号，如1812.10695）": {
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Function": HotReload(下载arxiv论文并翻译摘要)
+        }
+    })
 
+    from crazy_functions.联网的ChatGPT import 连接网络回答问题
+    function_plugins.update({
+        "连接网络回答问题（先输入问题，再点击按钮，需要访问谷歌）": {
+            "Color": "stop",
+            "AsButton": False,  # 加入下拉菜单中
+            "Function": HotReload(连接网络回答问题)
+        }
+    })
 
+    from crazy_functions.解析项目源代码 import 解析任意code项目
+    function_plugins.update({
+        "解析项目源代码（手动指定和筛选源代码文件类型）": {
+            "Color": "stop",
+            "AsButton": False,
+            "AdvancedArgs": True, # 调用时，唤起高级参数输入区（默认False）
+            "ArgsReminder": "输入时用逗号隔开, *代表通配符, 加了^代表不匹配; 不输入代表全部匹配。例如: \"*.c, ^*.cpp, config.toml, ^*.toml\"", # 高级参数输入区的显示提示
+            "Function": HotReload(解析任意code项目)
+        },
+    })
+    from crazy_functions.询问多个大语言模型 import 同时问询_指定模型
+    function_plugins.update({
+        "询问多个GPT模型（手动指定询问哪些模型）": {
+            "Color": "stop",
+            "AsButton": False,
+            "AdvancedArgs": True, # 调用时，唤起高级参数输入区（默认False）
+            "ArgsReminder": "支持任意数量的llm接口，用&符号分隔。例如chatglm&gpt-3.5-turbo&api2d-gpt-4", # 高级参数输入区的显示提示
+            "Function": HotReload(同时问询_指定模型)
+        },
+    })
     ###################### 第n组插件 ###########################
     return function_plugins

crazy_functions/crazy_functions_test.py

@@ -12,7 +12,7 @@ def validate_path():
     sys.path.append(root_dir_assume)
     
 validate_path() # validate path so you can run from base directory
-
+from colorful import *
 from toolbox import get_conf, ChatBotWithCookies
 proxies, WEB_PORT, LLM_MODEL, CONCURRENT_COUNT, AUTHENTICATION, CHATBOT_HEIGHT, LAYOUT, API_KEY = \
     get_conf('proxies', 'WEB_PORT', 'LLM_MODEL', 'CONCURRENT_COUNT', 'AUTHENTICATION', 'CHATBOT_HEIGHT', 'LAYOUT', 'API_KEY')
@@ -79,14 +79,52 @@ def test_下载arxiv论文并翻译摘要():
     for cookies, cb, hist, msg in 下载arxiv论文并翻译摘要(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
         print(cb)
 
-test_解析一个Python项目()
-test_Latex英文润色()
-test_Markdown中译英()
-test_批量翻译PDF文档()
-test_谷歌检索小助手()
-test_总结word文档()
-test_下载arxiv论文并翻译摘要()
-test_解析一个Cpp项目()
+def test_联网回答问题():
+    from crazy_functions.联网的ChatGPT import 连接网络回答问题
+    # txt = "“我们称之为高效”是什么梗？"
+    # >>        从第0份、第1份、第2份搜索结果可以看出，“我们称之为高效”是指在游戏社区中，用户们用来形容一些游戏策略或行为非常高效且能够带来好的效果的用语。这个用语最初可能是在群星（Stellaris）这个游戏里面流行起来的，后来也传播到了其他游戏中，比如巨像（Titan）等游戏。其中第1份搜索结果中的一篇文章也指出，“我们称之为高效”这 一用语来源于群星（Stellaris）游戏中的一个情节。
+    # txt = "为什么说枪毙P社玩家没有一个冤枉的？"
+    # >>        它们都是关于一个知乎用户所发的帖子，引用了一群游戏玩家对于需要对P社玩家进行枪毙的讨论，这个话题的本质是玩家们对于P 社游戏中的政治与历史元素的不同看法，以及其中不少玩家以极端立场宣扬的想法和言论，因此有人就以枪毙这些玩家来回应此类言论。但是这个话题本身并没有实质内容，只是一个玩笑或者恶搞，并不应该被当做真实的态度或者观点，因此这种说法没有实际意义。
+    # txt = "谁是应急食品？"
+    # >>        '根据以上搜索结果可以得知，应急食品是“原神”游戏中的角色派蒙的外号。'
+    # txt = "道路千万条，安全第一条。后面两句是？"
+    # >>        '行车不规范，亲人两行泪。'
+    # txt = "What is in the canister?"
+    # >>        Rainbow Six Siege 游戏中 Smoke 的 Canister 中装有何种物质相关的官方信息。
+    # txt = "失败的man是什么?"
+    # >>        根据第1份搜索结果，可以得知失败的man是指一位在B站购买了蜘蛛侠COS服后穿上后被网友嘲笑的UP主，而“失败的man”是蜘蛛侠英文名“spiderman”的谐音梗，并且网友们还 给这位UP主起了“苍蝇侠”的外号。因此，失败的man是指这位UP主在穿上蜘蛛侠COS服后被网友嘲笑的情况。
+    # txt = "老六是什么，起源于哪里？"
+    # >>        老六是网络流行语，最初起源于游戏《CSGO》，指游戏中玩家中独来独往、游离于队伍之外的“自由人”或玩得比较菜或者玩得比较阴险的人 ，后来逐渐演变成指玩得比较阴险的玩家。
+    # txt = "罗小黑战记因为什么经常被吐槽？"
+    # >>        3. 更新速度。罗小黑战记的更新时间不定，时而快时而慢，给观众留下了等待的时间过长的印象。
+    # txt = "沙特、伊朗最近的关系如何？"
+    # >>        最近在中国的斡旋下，沙特和伊朗于3月10日达成了恢复两国外交关系的协议，这表明两国关系已经重新回到正常化状态。
+    # txt = "You should have gone for the head. What does that mean?"
+    # >>        The phrase "You should have gone for the head" is a quote from the Marvel movies, Avengers: Infinity War and Avengers: Endgame. It was spoken by the character Thanos in Infinity War and by Thor in Endgame.
+    txt = "AutoGPT是什么？"
+    # >>        AutoGPT是一个基于GPT-4语言模型的开源应用程序。它可以根据用户需求自主执行任务，包括事件分析、营销方案撰写、代码编程、数学运算等等，并完全不需要用户插手。它可以自己思考，给出实现的步骤和实现细节，甚至可以自问自答执 行任务。最近它在GitHub上爆火，成为了业内最热门的项目之一。
+    # txt = "钟离带什么圣遗物？"
+    for cookies, cb, hist, msg in 连接网络回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port): 
+        print("当前问答：", cb[-1][-1].replace("\n"," "))
+    for i, it in enumerate(cb): print亮蓝(it[0]); print亮黄(it[1])
+
+def test_解析ipynb文件():
+    from crazy_functions.解析JupyterNotebook import 解析ipynb文件
+    txt = "crazy_functions/test_samples"
+    for cookies, cb, hist, msg in 解析ipynb文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+        print(cb)
+
+
+# test_解析一个Python项目()
+# test_Latex英文润色()
+# test_Markdown中译英()
+# test_批量翻译PDF文档()
+# test_谷歌检索小助手()
+# test_总结word文档()
+# test_下载arxiv论文并翻译摘要()
+# test_解析一个Cpp项目()
+# test_联网回答问题()
+test_解析ipynb文件()
 
 input("程序完成，回车退出。")
 print("退出。")

crazy_functions/对话历史存档.py

@@ -0,0 +1,42 @@
+from toolbox import CatchException, update_ui
+from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive
+
+def write_chat_to_file(chatbot, file_name=None):
+    """
+    将对话记录history以Markdown格式写入文件中。如果没有指定文件名，则使用当前时间生成文件名。
+    """
+    import os
+    import time
+    if file_name is None:
+        file_name = 'chatGPT对话历史' + time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime()) + '.html'
+    os.makedirs('./gpt_log/', exist_ok=True)
+    with open(f'./gpt_log/{file_name}', 'w', encoding='utf8') as f:
+        for i, contents in enumerate(chatbot):
+            for content in contents:
+                try:    # 这个bug没找到触发条件，暂时先这样顶一下
+                    if type(content) != str: content = str(content)
+                except:
+                    continue
+                f.write(content)
+                f.write('\n\n')
+            f.write('<hr color="red"> \n\n')
+
+    res = '对话历史写入：' + os.path.abspath(f'./gpt_log/{file_name}')
+    print(res)
+    return res
+
+@CatchException
+def 对话历史存档(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    """
+    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
+    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
+    plugin_kwargs   插件模型的参数，暂时没有用武之地
+    chatbot         聊天显示框的句柄，用于显示给用户
+    history         聊天历史，前情提要
+    system_prompt   给gpt的静默提醒
+    web_port        当前软件运行的端口号
+    """
+
+    chatbot.append(("保存当前对话", f"[Local Message] {write_chat_to_file(chatbot)}"))
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
+

crazy_functions/联网的ChatGPT.py

@@ -0,0 +1,102 @@
+from toolbox import CatchException, update_ui
+from .crazy_utils import request_gpt_model_in_new_thread_with_ui_alive, input_clipping
+import requests
+from bs4 import BeautifulSoup
+from request_llm.bridge_all import model_info
+
+def google(query, proxies):
+    query = query # 在此处替换您要搜索的关键词
+    url = f"https://www.google.com/search?q={query}"
+    headers = {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36'}
+    response = requests.get(url, headers=headers, proxies=proxies)
+    soup = BeautifulSoup(response.content, 'html.parser')
+    results = []
+    for g in soup.find_all('div', class_='g'):
+        anchors = g.find_all('a')
+        if anchors:
+            link = anchors[0]['href']
+            if link.startswith('/url?q='):
+                link = link[7:]
+            if not link.startswith('http'):
+                continue
+            title = g.find('h3').text
+            item = {'title': title, 'link': link}
+            results.append(item)
+
+    for r in results:
+        print(r['link'])
+    return results
+
+def scrape_text(url, proxies) -> str:
+    """Scrape text from a webpage
+
+    Args:
+        url (str): The URL to scrape text from
+
+    Returns:
+        str: The scraped text
+    """
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36',
+        'Content-Type': 'text/plain',
+    }
+    try: 
+        response = requests.get(url, headers=headers, proxies=proxies, timeout=8)
+        if response.encoding == "ISO-8859-1": response.encoding = response.apparent_encoding
+    except: 
+        return "无法连接到该网页"
+    soup = BeautifulSoup(response.text, "html.parser")
+    for script in soup(["script", "style"]):
+        script.extract()
+    text = soup.get_text()
+    lines = (line.strip() for line in text.splitlines())
+    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+    text = "\n".join(chunk for chunk in chunks if chunk)
+    return text
+
+@CatchException
+def 连接网络回答问题(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    """
+    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
+    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
+    plugin_kwargs   插件模型的参数，暂时没有用武之地
+    chatbot         聊天显示框的句柄，用于显示给用户
+    history         聊天历史，前情提要
+    system_prompt   给gpt的静默提醒
+    web_port        当前软件运行的端口号
+    """
+    history = []    # 清空历史，以免输入溢出
+    chatbot.append((f"请结合互联网信息回答以下问题：{txt}", 
+                    "[Local Message] 请注意，您正在调用一个[函数插件]的模板，该模板可以实现ChatGPT联网信息综合。该函数面向希望实现更多有趣功能的开发者，它可以作为创建新功能函数的模板。您若希望分享新的功能模组，请不吝PR！"))
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
+
+    # ------------- < 第1步：爬取搜索引擎的结果 > -------------
+    from toolbox import get_conf
+    proxies, = get_conf('proxies')
+    urls = google(txt, proxies)
+    history = []
+
+    # ------------- < 第2步：依次访问网页 > -------------
+    max_search_result = 5   # 最多收纳多少个网页的结果
+    for index, url in enumerate(urls[:max_search_result]):
+        res = scrape_text(url['link'], proxies)
+        history.extend([f"第{index}份搜索结果：", res])
+        chatbot.append([f"第{index}份搜索结果：", res[:500]+"......"])
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
+
+    # ------------- < 第3步：ChatGPT综合 > -------------
+    i_say = f"从以上搜索结果中抽取信息，然后回答问题：{txt}"
+    i_say, history = input_clipping(    # 裁剪输入，从最长的条目开始裁剪，防止爆token
+        inputs=i_say, 
+        history=history, 
+        max_token_limit=model_info[llm_kwargs['llm_model']]['max_token']*3//4
+    )
+    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+        inputs=i_say, inputs_show_user=i_say, 
+        llm_kwargs=llm_kwargs, chatbot=chatbot, history=history, 
+        sys_prompt="请从给定的若干条搜索结果中抽取信息，对最相关的两个搜索结果进行总结，然后回答问题。"
+    )
+    chatbot[-1] = (i_say, gpt_say)
+    history.append(i_say);history.append(gpt_say)
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+

crazy_functions/解析JupyterNotebook.py

@@ -0,0 +1,140 @@
+from toolbox import update_ui
+from toolbox import CatchException, report_execption, write_results_to_file
+fast_debug = True
+
+
+class PaperFileGroup():
+    def __init__(self):
+        self.file_paths = []
+        self.file_contents = []
+        self.sp_file_contents = []
+        self.sp_file_index = []
+        self.sp_file_tag = []
+
+        # count_token
+        from request_llm.bridge_all import model_info
+        enc = model_info["gpt-3.5-turbo"]['tokenizer']
+        def get_token_num(txt): return len(
+            enc.encode(txt, disallowed_special=()))
+        self.get_token_num = get_token_num
+
+    def run_file_split(self, max_token_limit=1900):
+        """
+        将长文本分离开来
+        """
+        for index, file_content in enumerate(self.file_contents):
+            if self.get_token_num(file_content) < max_token_limit:
+                self.sp_file_contents.append(file_content)
+                self.sp_file_index.append(index)
+                self.sp_file_tag.append(self.file_paths[index])
+            else:
+                from .crazy_utils import breakdown_txt_to_satisfy_token_limit_for_pdf
+                segments = breakdown_txt_to_satisfy_token_limit_for_pdf(
+                    file_content, self.get_token_num, max_token_limit)
+                for j, segment in enumerate(segments):
+                    self.sp_file_contents.append(segment)
+                    self.sp_file_index.append(index)
+                    self.sp_file_tag.append(
+                        self.file_paths[index] + f".part-{j}.txt")
+
+
+
+def parseNotebook(filename, enable_markdown=1):
+    import json
+
+    CodeBlocks = []
+    with open(filename, 'r', encoding='utf-8', errors='replace') as f:
+        notebook = json.load(f)
+    for cell in notebook['cells']:
+        if cell['cell_type'] == 'code' and cell['source']:
+            # remove blank lines
+            cell['source'] = [line for line in cell['source'] if line.strip()
+                              != '']
+            CodeBlocks.append("".join(cell['source']))
+        elif enable_markdown and cell['cell_type'] == 'markdown' and cell['source']:
+            cell['source'] = [line for line in cell['source'] if line.strip()
+                              != '']
+            CodeBlocks.append("Markdown:"+"".join(cell['source']))
+
+    Code = ""
+    for idx, code in enumerate(CodeBlocks):
+        Code += f"This is {idx+1}th code block: \n"
+        Code += code+"\n"
+
+    return Code 
+
+
+def ipynb解释(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt):
+    from .crazy_utils import request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency
+
+    pfg = PaperFileGroup()
+
+    print(file_manifest)
+    for fp in file_manifest:
+        file_content = parseNotebook(fp, enable_markdown=1)
+        pfg.file_paths.append(fp)
+        pfg.file_contents.append(file_content)
+
+    #  <-------- 拆分过长的IPynb文件 ---------->
+    pfg.run_file_split(max_token_limit=1024)
+    n_split = len(pfg.sp_file_contents)
+
+    inputs_array = [r"This is a Jupyter Notebook file, tell me about Each Block in Chinese. Focus Just On Code." +
+                    r"If a block starts with `Markdown` which means it's a markdown block in ipynbipynb. " +
+                    r"Start a new line for a block and block num use Chinese." +
+                    f"\n\n{frag}" for frag in pfg.sp_file_contents]
+    inputs_show_user_array = [f"{f}的分析如下" for f in pfg.sp_file_tag]
+    sys_prompt_array = ["You are a professional programmer."] * n_split
+
+    gpt_response_collection = yield from request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
+        inputs_array=inputs_array,
+        inputs_show_user_array=inputs_show_user_array,
+        llm_kwargs=llm_kwargs,
+        chatbot=chatbot,
+        history_array=[[""] for _ in range(n_split)],
+        sys_prompt_array=sys_prompt_array,
+        # max_workers=5,  # OpenAI所允许的最大并行过载
+        scroller_max_len=80
+    )
+
+    #  <-------- 整理结果，退出 ---------->
+    block_result = "  \n".join(gpt_response_collection)
+    chatbot.append(("解析的结果如下", block_result))
+    history.extend(["解析的结果如下", block_result])
+    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+
+    #  <-------- 写入文件，退出 ---------->
+    res = write_results_to_file(history)
+    chatbot.append(("完成了吗？", res))
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+
+@CatchException
+def 解析ipynb文件(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    chatbot.append([
+        "函数插件功能？",
+        "对IPynb文件进行解析。Contributor: codycjy."])
+    yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+
+    history = []    # 清空历史
+    import glob
+    import os
+    if os.path.exists(txt):
+        project_folder = txt
+    else:
+        if txt == "":
+            txt = '空空如也的输入栏'
+        report_execption(chatbot, history,
+                         a=f"解析项目: {txt}", b=f"找不到本地项目或无权访问: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+    if txt.endswith('.ipynb'):
+        file_manifest = [txt]
+    else:
+        file_manifest = [f for f in glob.glob(
+            f'{project_folder}/**/*.ipynb', recursive=True)]
+    if len(file_manifest) == 0:
+        report_execption(chatbot, history,
+                         a=f"解析项目: {txt}", b=f"找不到任何.ipynb文件: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history)  # 刷新界面
+        return
+    yield from ipynb解释(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, )

crazy_functions/解析项目源代码.py

@@ -11,7 +11,7 @@ def 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs,
     history_array = []
     sys_prompt_array = []
     report_part_1 = []
-    
+
     assert len(file_manifest) <= 512, "源文件太多（超过512个）, 请缩减输入文件的数量。或者，您也可以选择删除此行警告，并修改代码拆分file_manifest列表，从而实现分批次处理。"
     ############################## <第一步，逐个文件分析，多线程> ##################################
     for index, fp in enumerate(file_manifest):
@@ -63,10 +63,10 @@ def 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs,
         current_iteration_focus = ', '.join([os.path.relpath(fp, project_folder) for index, fp in enumerate(this_iteration_file_manifest)])
         i_say = f'根据以上分析，对程序的整体功能和构架重新做出概括。然后用一张markdown表格整理每个文件的功能（包括{previous_iteration_files_string}）。'
         inputs_show_user = f'根据以上分析，对程序的整体功能和构架重新做出概括，由于输入长度限制，可能需要分组处理，本组文件为 {current_iteration_focus} + 已经汇总的文件组。'
-        this_iteration_history = copy.deepcopy(this_iteration_gpt_response_collection) 
+        this_iteration_history = copy.deepcopy(this_iteration_gpt_response_collection)
         this_iteration_history.append(last_iteration_result)
         result = yield from request_gpt_model_in_new_thread_with_ui_alive(
-            inputs=i_say, inputs_show_user=inputs_show_user, llm_kwargs=llm_kwargs, chatbot=chatbot, 
+            inputs=i_say, inputs_show_user=inputs_show_user, llm_kwargs=llm_kwargs, chatbot=chatbot,
             history=this_iteration_history,   # 迭代之前的分析
             sys_prompt="你是一个程序架构分析师，正在分析一个项目的源代码。")
         report_part_2.extend([i_say, result])
@@ -222,8 +222,8 @@ def 解析一个Golang项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
         yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
         return
     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):
     history = []    # 清空历史，以免输入溢出
@@ -243,9 +243,9 @@ def 解析一个Lua项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, syst
         report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到任何lua文件: {txt}")
         yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
         return
-    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)    
-    
-        
+    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)
+
+
 @CatchException
 def 解析一个CSharp项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
     history = []    # 清空历史，以免输入溢出
@@ -263,4 +263,45 @@ def 解析一个CSharp项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, s
         report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到任何CSharp文件: {txt}")
         yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
         return
-    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)    
+    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)
+
+
+@CatchException
+def 解析任意code项目(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    txt_pattern = plugin_kwargs.get("advanced_arg")
+    txt_pattern = txt_pattern.replace("，", ",")
+    # 将要匹配的模式(例如: *.c, *.cpp, *.py, config.toml)
+    pattern_include = [_.lstrip(" ,").rstrip(" ,") for _ in txt_pattern.split(",") if _ != "" and not _.strip().startswith("^")]
+    if not pattern_include: pattern_include = ["*"] # 不输入即全部匹配
+    # 将要忽略匹配的文件后缀(例如: ^*.c, ^*.cpp, ^*.py)
+    pattern_except_suffix = [_.lstrip(" ^*.,").rstrip(" ,") for _ in txt_pattern.split(" ") if _ != "" and _.strip().startswith("^*.")]
+    pattern_except_suffix += ['zip', 'rar', '7z', 'tar', 'gz'] # 避免解析压缩文件
+    # 将要忽略匹配的文件名(例如: ^README.md)
+    pattern_except_name = [_.lstrip(" ^*,").rstrip(" ,").replace(".", "\.") for _ in txt_pattern.split(" ") if _ != "" and _.strip().startswith("^") and not _.strip().startswith("^*.")]
+    # 生成正则表达式
+    pattern_except = '/[^/]+\.(' + "|".join(pattern_except_suffix) + ')$'
+    pattern_except += '|/(' + "|".join(pattern_except_name) + ')$' if pattern_except_name != [] else ''
+
+    history.clear()
+    import glob, os, re
+    if os.path.exists(txt):
+        project_folder = txt
+    else:
+        if txt == "": txt = '空空如也的输入栏'
+        report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到本地项目或无权访问: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+        return
+    # 若上传压缩文件, 先寻找到解压的文件夹路径, 从而避免解析压缩文件
+    maybe_dir = [f for f in glob.glob(f'{project_folder}/*') if os.path.isdir(f)]
+    if len(maybe_dir)>0 and maybe_dir[0].endswith('.extract'):
+        extract_folder_path = maybe_dir[0]
+    else:
+        extract_folder_path = project_folder
+    # 按输入的匹配模式寻找上传的非压缩文件和已解压的文件
+    file_manifest = [f for pattern in pattern_include for f in glob.glob(f'{extract_folder_path}/**/{pattern}', recursive=True) if "" != extract_folder_path and \
+                      os.path.isfile(f) and (not re.search(pattern_except, f) or pattern.endswith('.' + re.search(pattern_except, f).group().split('.')[-1]))]
+    if len(file_manifest) == 0:
+        report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到任何文件: {txt}")
+        yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
+        return
+    yield from 解析源代码新(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt)

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

@@ -25,6 +25,35 @@ def 同时问询(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt
         retry_times_at_unknown_error=0
     )
 
+    history.append(txt)
+    history.append(gpt_say)
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新
+
+
+@CatchException
+def 同时问询_指定模型(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
+    """
+    txt             输入栏用户输入的文本，例如需要翻译的一段话，再例如一个包含了待处理文件的路径
+    llm_kwargs      gpt模型参数，如温度和top_p等，一般原样传递下去就行
+    plugin_kwargs   插件模型的参数，如温度和top_p等，一般原样传递下去就行
+    chatbot         聊天显示框的句柄，用于显示给用户
+    history         聊天历史，前情提要
+    system_prompt   给gpt的静默提醒
+    web_port        当前软件运行的端口号
+    """
+    history = []    # 清空历史，以免输入溢出
+    chatbot.append((txt, "正在同时咨询ChatGPT和ChatGLM……"))
+    yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 由于请求gpt需要一段时间，我们先及时地做一次界面更新
+
+    # llm_kwargs['llm_model'] = 'chatglm&gpt-3.5-turbo&api2d-gpt-3.5-turbo' # 支持任意数量的llm接口，用&符号分隔
+    llm_kwargs['llm_model'] = plugin_kwargs.get("advanced_arg", 'chatglm&gpt-3.5-turbo') # 'chatglm&gpt-3.5-turbo' # 支持任意数量的llm接口，用&符号分隔
+    gpt_say = yield from request_gpt_model_in_new_thread_with_ui_alive(
+        inputs=txt, inputs_show_user=txt, 
+        llm_kwargs=llm_kwargs, chatbot=chatbot, history=history, 
+        sys_prompt=system_prompt,
+        retry_times_at_unknown_error=0
+    )
+
     history.append(txt)
     history.append(gpt_say)
     yield from update_ui(chatbot=chatbot, history=history) # 刷新界面 # 界面更新

docs/WithFastapi.md

@@ -0,0 +1,43 @@
+# Running with fastapi
+
+We currently support fastapi in order to solve sub-path deploy issue.
+
+1. change CUSTOM_PATH setting in `config.py`
+
+``` sh
+nano config.py
+```
+
+2. Edit main.py
+
+```diff
+    auto_opentab_delay()
+    - demo.queue(concurrency_count=CONCURRENT_COUNT).launch(server_name="0.0.0.0", server_port=PORT, auth=AUTHENTICATION, favicon_path="docs/logo.png")
+    + demo.queue(concurrency_count=CONCURRENT_COUNT)
+
+    - # 如果需要在二级路径下运行
+    - # CUSTOM_PATH, = get_conf('CUSTOM_PATH')
+    - # if CUSTOM_PATH != "/": 
+    - #     from toolbox import run_gradio_in_subpath
+    - #     run_gradio_in_subpath(demo, auth=AUTHENTICATION, port=PORT, custom_path=CUSTOM_PATH)
+    - # else: 
+    - #     demo.launch(server_name="0.0.0.0", server_port=PORT, auth=AUTHENTICATION, favicon_path="docs/logo.png")
+
+    + 如果需要在二级路径下运行
+    + CUSTOM_PATH, = get_conf('CUSTOM_PATH')
+    + if CUSTOM_PATH != "/": 
+    +     from toolbox import run_gradio_in_subpath
+    +     run_gradio_in_subpath(demo, auth=AUTHENTICATION, port=PORT, custom_path=CUSTOM_PATH)
+    + else: 
+    +     demo.launch(server_name="0.0.0.0", server_port=PORT, auth=AUTHENTICATION, favicon_path="docs/logo.png")
+
+if __name__ == "__main__":
+    main()
+```
+
+
+3. Go!
+
+``` sh
+python main.py
+```

main.py

@@ -45,7 +45,7 @@ def main():
 
     gr_L1 = lambda: gr.Row().style()
     gr_L2 = lambda scale: gr.Column(scale=scale)
-    if LAYOUT == "TOP-DOWN": 
+    if LAYOUT == "TOP-DOWN":
         gr_L1 = lambda: DummyWith()
         gr_L2 = lambda scale: gr.Row()
         CHATBOT_HEIGHT /= 2
@@ -88,9 +88,12 @@ def main():
                     with gr.Row():
                         with gr.Accordion("更多函数插件", open=True):
                             dropdown_fn_list = [k for k in crazy_fns.keys() if not crazy_fns[k].get("AsButton", True)]
-                            with gr.Column(scale=1):
+                            with gr.Row():
                                 dropdown = gr.Dropdown(dropdown_fn_list, value=r"打开插件列表", label="").style(container=False)
-                            with gr.Column(scale=1):
+                            with gr.Row():
+                                plugin_advanced_arg = gr.Textbox(show_label=True, label="高级参数输入区", visible=False, 
+                                                                 placeholder="这里是特殊函数插件的高级参数输入区").style(container=False)
+                            with gr.Row():
                                 switchy_bt = gr.Button(r"请先从插件列表中选择", variant="secondary")
                     with gr.Row():
                         with gr.Accordion("点击展开“文件上传区”。上传本地文件可供红色函数插件调用。", open=False) as area_file_up:
@@ -100,7 +103,7 @@ def main():
                     top_p = gr.Slider(minimum=-0, maximum=1.0, value=1.0, step=0.01,interactive=True, label="Top-p (nucleus sampling)",)
                     temperature = gr.Slider(minimum=-0, maximum=2.0, value=1.0, step=0.01, interactive=True, label="Temperature",)
                     max_length_sl = gr.Slider(minimum=256, maximum=4096, value=512, step=1, interactive=True, label="Local LLM MaxLength",)
-                    checkboxes = gr.CheckboxGroup(["基础功能区", "函数插件区", "底部输入区", "输入清除键"], value=["基础功能区", "函数插件区"], label="显示/隐藏功能区")
+                    checkboxes = gr.CheckboxGroup(["基础功能区", "函数插件区", "底部输入区", "输入清除键", "插件参数区"], value=["基础功能区", "函数插件区"], label="显示/隐藏功能区")
                     md_dropdown = gr.Dropdown(AVAIL_LLM_MODELS, value=LLM_MODEL, label="更换LLM模型/请求源").style(container=False)
 
                     gr.Markdown(description)
@@ -112,7 +115,7 @@ def main():
                     with gr.Row():
                         resetBtn2 = gr.Button("重置", variant="secondary"); resetBtn2.style(size="sm")
                         stopBtn2 = gr.Button("停止", variant="secondary"); stopBtn2.style(size="sm")
-                        clearBtn2 = gr.Button("清除", variant="secondary", visible=False); clearBtn.style(size="sm")
+                        clearBtn2 = gr.Button("清除", variant="secondary", visible=False); clearBtn2.style(size="sm")
         # 功能区显示开关与功能区的互动
         def fn_area_visibility(a):
             ret = {}
@@ -122,11 +125,12 @@ def main():
             ret.update({area_input_secondary: gr.update(visible=("底部输入区" in a))})
             ret.update({clearBtn: gr.update(visible=("输入清除键" in a))})
             ret.update({clearBtn2: gr.update(visible=("输入清除键" in a))})
+            ret.update({plugin_advanced_arg: gr.update(visible=("插件参数区" in a))})
             if "底部输入区" in a: ret.update({txt: gr.update(value="")})
             return ret
-        checkboxes.select(fn_area_visibility, [checkboxes], [area_basic_fn, area_crazy_fn, area_input_primary, area_input_secondary, txt, txt2, clearBtn, clearBtn2] )
+        checkboxes.select(fn_area_visibility, [checkboxes], [area_basic_fn, area_crazy_fn, area_input_primary, area_input_secondary, txt, txt2, clearBtn, clearBtn2, plugin_advanced_arg] )
         # 整理反复出现的控件句柄组合
-        input_combo = [cookies, max_length_sl, md_dropdown, txt, txt2, top_p, temperature, chatbot, history, system_prompt]
+        input_combo = [cookies, max_length_sl, md_dropdown, txt, txt2, top_p, temperature, chatbot, history, system_prompt, plugin_advanced_arg]
         output_combo = [cookies, chatbot, history, status]
         predict_args = dict(fn=ArgsGeneralWrapper(predict), inputs=input_combo, outputs=output_combo)
         # 提交按钮、重置按钮
@@ -153,14 +157,19 @@ def main():
         # 函数插件-下拉菜单与随变按钮的互动
         def on_dropdown_changed(k):
             variant = crazy_fns[k]["Color"] if "Color" in crazy_fns[k] else "secondary"
-            return {switchy_bt: gr.update(value=k, variant=variant)}
-        dropdown.select(on_dropdown_changed, [dropdown], [switchy_bt] )
+            ret = {switchy_bt: gr.update(value=k, variant=variant)}
+            if crazy_fns[k].get("AdvancedArgs", False): # 是否唤起高级插件参数区
+                ret.update({plugin_advanced_arg: gr.update(visible=True,  label=f"插件[{k}]的高级参数说明：" + crazy_fns[k].get("ArgsReminder", [f"没有提供高级参数功能说明"]))})
+            else:
+                ret.update({plugin_advanced_arg: gr.update(visible=False, label=f"插件[{k}]不需要高级参数。")})
+            return ret
+        dropdown.select(on_dropdown_changed, [dropdown], [switchy_bt, plugin_advanced_arg] )
         def on_md_dropdown_changed(k):
             return {chatbot: gr.update(label="当前模型："+k)}
         md_dropdown.select(on_md_dropdown_changed, [md_dropdown], [chatbot] )
         # 随变按钮的回调函数注册
         def route(k, *args, **kwargs):
-            if k in [r"打开插件列表", r"请先从插件列表中选择"]: return 
+            if k in [r"打开插件列表", r"请先从插件列表中选择"]: return
             yield from ArgsGeneralWrapper(crazy_fns[k]["Function"])(*args, **kwargs)
         click_handle = switchy_bt.click(route,[switchy_bt, *input_combo, gr.State(PORT)], output_combo)
         click_handle.then(on_report_generated, [file_upload, chatbot], [file_upload, chatbot])
@@ -178,7 +187,7 @@ def main():
         print(f"如果浏览器没有自动打开，请复制并转到以下URL：")
         print(f"\t（亮色主题）: http://localhost:{PORT}")
         print(f"\t（暗色主题）: http://localhost:{PORT}/?__dark-theme=true")
-        def open(): 
+        def open():
             time.sleep(2)       # 打开浏览器
             webbrowser.open_new_tab(f"http://localhost:{PORT}/?__dark-theme=true")
         threading.Thread(target=open, name="open-browser", daemon=True).start()
@@ -188,5 +197,13 @@ def main():
     auto_opentab_delay()
     demo.queue(concurrency_count=CONCURRENT_COUNT).launch(server_name="0.0.0.0", server_port=PORT, auth=AUTHENTICATION, favicon_path="docs/logo.png")
 
+    # 如果需要在二级路径下运行
+    # CUSTOM_PATH, = get_conf('CUSTOM_PATH')
+    # if CUSTOM_PATH != "/": 
+    #     from toolbox import run_gradio_in_subpath
+    #     run_gradio_in_subpath(demo, auth=AUTHENTICATION, port=PORT, custom_path=CUSTOM_PATH)
+    # else: 
+    #     demo.launch(server_name="0.0.0.0", server_port=PORT, auth=AUTHENTICATION, favicon_path="docs/logo.png")
+
 if __name__ == "__main__":
-    main()
+    main()

request_llm/README.md

@@ -1,4 +1,4 @@
-# 如何使用其他大语言模型（v3.0分支测试中）
+# 如何使用其他大语言模型
 
 ## ChatGLM
 
@@ -15,7 +15,7 @@ LLM_MODEL = "chatglm"
 
 
 ---
-## Text-Generation-UI (TGUI)
+## Text-Generation-UI (TGUI，调试中，暂不可用)
 
 ### 1. 部署TGUI
 ``` sh

request_llm/bridge_all.py

@@ -1,16 +1,17 @@
 
 """
-    该文件中主要包含2个函数
+    该文件中主要包含2个函数，是所有LLM的通用接口，它们会继续向下调用更底层的LLM模型，处理多模型并行等细节
 
-    不具备多线程能力的函数：
-    1. predict: 正常对话时使用，具备完备的交互功能，不可多线程
+    不具备多线程能力的函数：正常对话时使用，具备完备的交互功能，不可多线程
+    1. predict(...)
 
-    具备多线程调用能力的函数
-    2. predict_no_ui_long_connection：在实验过程中发现调用predict_no_ui处理长文档时，和openai的连接容易断掉，这个函数用stream的方式解决这个问题，同样支持多线程
+    具备多线程调用能力的函数：在函数插件中被调用，灵活而简洁
+    2. predict_no_ui_long_connection(...)
 """
 import tiktoken
-from functools import wraps, lru_cache
+from functools import lru_cache
 from concurrent.futures import ThreadPoolExecutor
+from toolbox import get_conf
 
 from .bridge_chatgpt import predict_no_ui_long_connection as chatgpt_noui
 from .bridge_chatgpt import predict as chatgpt_ui
@@ -42,18 +43,37 @@ class LazyloadTiktoken(object):
     def decode(self, *args, **kwargs):
         encoder = self.get_encoder(self.model) 
         return encoder.decode(*args, **kwargs)
-    
+
+# Endpoint 重定向
+API_URL_REDIRECT, = get_conf("API_URL_REDIRECT")
+openai_endpoint = "https://api.openai.com/v1/chat/completions"
+api2d_endpoint = "https://openai.api2d.net/v1/chat/completions"
+# 兼容旧版的配置
+try:
+    API_URL, = get_conf("API_URL")
+    if API_URL != "https://api.openai.com/v1/chat/completions": 
+        openai_endpoint = API_URL
+        print("警告！API_URL配置选项将被弃用，请更换为API_URL_REDIRECT配置")
+except:
+    pass
+# 新版配置
+if openai_endpoint in API_URL_REDIRECT: openai_endpoint = API_URL_REDIRECT[openai_endpoint]
+if api2d_endpoint in API_URL_REDIRECT: api2d_endpoint = API_URL_REDIRECT[api2d_endpoint]
+
+
+# 获取tokenizer
 tokenizer_gpt35 = LazyloadTiktoken("gpt-3.5-turbo")
 tokenizer_gpt4 = LazyloadTiktoken("gpt-4")
 get_token_num_gpt35 = lambda txt: len(tokenizer_gpt35.encode(txt, disallowed_special=()))
 get_token_num_gpt4 = lambda txt: len(tokenizer_gpt4.encode(txt, disallowed_special=()))
 
+
 model_info = {
     # openai
     "gpt-3.5-turbo": {
         "fn_with_ui": chatgpt_ui,
         "fn_without_ui": chatgpt_noui,
-        "endpoint": "https://api.openai.com/v1/chat/completions",
+        "endpoint": openai_endpoint,
         "max_token": 4096,
         "tokenizer": tokenizer_gpt35,
         "token_cnt": get_token_num_gpt35,
@@ -62,7 +82,7 @@ model_info = {
     "gpt-4": {
         "fn_with_ui": chatgpt_ui,
         "fn_without_ui": chatgpt_noui,
-        "endpoint": "https://api.openai.com/v1/chat/completions",
+        "endpoint": openai_endpoint,
         "max_token": 8192,
         "tokenizer": tokenizer_gpt4,
         "token_cnt": get_token_num_gpt4,
@@ -72,7 +92,7 @@ model_info = {
     "api2d-gpt-3.5-turbo": {
         "fn_with_ui": chatgpt_ui,
         "fn_without_ui": chatgpt_noui,
-        "endpoint": "https://openai.api2d.net/v1/chat/completions",
+        "endpoint": api2d_endpoint,
         "max_token": 4096,
         "tokenizer": tokenizer_gpt35,
         "token_cnt": get_token_num_gpt35,
@@ -81,7 +101,7 @@ model_info = {
     "api2d-gpt-4": {
         "fn_with_ui": chatgpt_ui,
         "fn_without_ui": chatgpt_noui,
-        "endpoint": "https://openai.api2d.net/v1/chat/completions",
+        "endpoint": api2d_endpoint,
         "max_token": 8192,
         "tokenizer": tokenizer_gpt4,
         "token_cnt": get_token_num_gpt4,
@@ -190,7 +210,7 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history, sys_prompt, obser
             return_string_collect.append( f"【{str(models[i])} 说】: <font color=\"{colors[i]}\"> {future.result()} </font>" )
 
         window_mutex[-1] = False # stop mutex thread
-        res = '<br/>\n\n---\n\n'.join(return_string_collect)
+        res = '<br/><br/>\n\n---\n\n'.join(return_string_collect)
         return res
 
 

request_llm/bridge_chatglm.py

@@ -92,8 +92,8 @@ def predict_no_ui_long_connection(inputs, llm_kwargs, history=[], sys_prompt="",
 
     # chatglm 没有 sys_prompt 接口，因此把prompt加入 history
     history_feedin = []
+    history_feedin.append(["What can I do?", sys_prompt])
     for i in range(len(history)//2):
-        history_feedin.append(["What can I do?", sys_prompt] )
         history_feedin.append([history[2*i], history[2*i+1]] )
 
     watch_dog_patience = 5 # 看门狗 (watchdog) 的耐心, 设置5秒即可
@@ -131,10 +131,13 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
         inputs = core_functional[additional_fn]["Prefix"] + inputs + core_functional[additional_fn]["Suffix"]
 
     history_feedin = []
+    history_feedin.append(["What can I do?", system_prompt] )
     for i in range(len(history)//2):
-        history_feedin.append(["What can I do?", system_prompt] )
         history_feedin.append([history[2*i], history[2*i+1]] )
 
     for response in glm_handle.stream_chat(query=inputs, history=history_feedin, max_length=llm_kwargs['max_length'], top_p=llm_kwargs['top_p'], temperature=llm_kwargs['temperature']):
         chatbot[-1] = (inputs, response)
-        yield from update_ui(chatbot=chatbot, history=history)
+        yield from update_ui(chatbot=chatbot, history=history)
+
+    history.extend([inputs, response])
+    yield from update_ui(chatbot=chatbot, history=history)

request_llm/bridge_chatgpt.py

@@ -21,7 +21,7 @@ import importlib
 
 # config_private.py放自己的秘密如API和代理网址
 # 读取时首先看是否存在私密的config_private配置文件（不受git管控），如果有，则覆盖原config文件
-from toolbox import get_conf, update_ui, is_any_api_key, select_api_key
+from toolbox import get_conf, update_ui, is_any_api_key, select_api_key, what_keys
 proxies, API_KEY, TIMEOUT_SECONDS, MAX_RETRY = \
     get_conf('proxies', 'API_KEY', 'TIMEOUT_SECONDS', 'MAX_RETRY')
 
@@ -118,7 +118,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
     """
     if is_any_api_key(inputs):
         chatbot._cookies['api_key'] = inputs
-        chatbot.append(("输入已识别为openai的api_key", "api_key已导入"))
+        chatbot.append(("输入已识别为openai的api_key", what_keys(inputs)))
         yield from update_ui(chatbot=chatbot, history=history, msg="api_key已导入") # 刷新界面
         return
     elif not is_any_api_key(chatbot._cookies['api_key']):
@@ -141,7 +141,7 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
     try:
         headers, payload = generate_payload(inputs, llm_kwargs, history, system_prompt, stream)
     except RuntimeError as e:
-        chatbot[-1] = (inputs, f"您提供的api-key不满足要求，不包含任何可用于{llm_kwargs['llm_model']}的api-key。")
+        chatbot[-1] = (inputs, f"您提供的api-key不满足要求，不包含任何可用于{llm_kwargs['llm_model']}的api-key。您可能选择了错误的模型或请求源。")
         yield from update_ui(chatbot=chatbot, history=history, msg="api-key不满足要求") # 刷新界面
         return
         
@@ -208,6 +208,8 @@ def predict(inputs, llm_kwargs, plugin_kwargs, chatbot, history=[], system_promp
                         chatbot[-1] = (chatbot[-1][0], "[Local Message] You exceeded your current quota. OpenAI以账户额度不足为由，拒绝服务.")
                     elif "bad forward key" in error_msg:
                         chatbot[-1] = (chatbot[-1][0], "[Local Message] Bad forward key. API2D账户额度不足.")
+                    elif "Not enough point" in error_msg:
+                        chatbot[-1] = (chatbot[-1][0], "[Local Message] Not enough point. API2D账户点数不足.")
                     else:
                         from toolbox import regular_txt_to_markdown
                         tb_str = '```\n' + traceback.format_exc() + '```'

toolbox.py

@@ -24,23 +24,23 @@ def ArgsGeneralWrapper(f):
     """
     装饰器函数，用于重组输入参数，改变输入参数的顺序与结构。
     """
-    def decorated(cookies, max_length, llm_model, txt, txt2, top_p, temperature, chatbot, history, system_prompt, *args):
+    def decorated(cookies, max_length, llm_model, txt, txt2, top_p, temperature, chatbot, history, system_prompt, plugin_advanced_arg, *args):
         txt_passon = txt
         if txt == "" and txt2 != "": txt_passon = txt2
         # 引入一个有cookie的chatbot
         cookies.update({
-            'top_p':top_p, 
+            'top_p':top_p,
             'temperature':temperature,
         })
         llm_kwargs = {
             'api_key': cookies['api_key'],
             'llm_model': llm_model,
-            'top_p':top_p, 
+            'top_p':top_p,
             'max_length': max_length,
             'temperature':temperature,
         }
         plugin_kwargs = {
-            # 目前还没有
+            "advanced_arg": plugin_advanced_arg,
         }
         chatbot_with_cookie = ChatBotWithCookies(cookies)
         chatbot_with_cookie.write_list(chatbot)
@@ -219,7 +219,7 @@ def markdown_convertion(txt):
             return content
         else:
             return tex2mathml_catch_exception(content)
-        
+
     def markdown_bug_hunt(content):
         """
         解决一个mdx_math的bug（单$包裹begin命令时多余<script>）
@@ -227,7 +227,7 @@ def markdown_convertion(txt):
         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
-    
+
 
     if ('$' in txt) and ('```' not in txt):  # 有$标识的公式符号，且没有代码段```的标识
         # convert everything to html format
@@ -248,7 +248,7 @@ def markdown_convertion(txt):
 def close_up_code_segment_during_stream(gpt_reply):
     """
     在gpt输出代码的中途（输出了前面的```，但还没输出完后面的```），补上后面的```
-    
+
     Args:
         gpt_reply (str): GPT模型返回的回复字符串。
 
@@ -432,6 +432,19 @@ def is_any_api_key(key):
     else:
         return is_openai_api_key(key) or is_api2d_key(key)
 
+def what_keys(keys):
+    avail_key_list = {'OpenAI 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
+
+    return f"检测到： OpenAI Key {avail_key_list['OpenAI Key']} 个，API2D Key {avail_key_list['API2D Key']} 个"
 
 def select_api_key(keys, llm_model):
     import random
@@ -447,7 +460,7 @@ def select_api_key(keys, llm_model):
             if is_api2d_key(k): avail_key_list.append(k)
 
     if len(avail_key_list) == 0:
-        raise RuntimeError(f"您提供的api-key不满足要求，不包含任何可用于{llm_model}的api-key。")
+        raise RuntimeError(f"您提供的api-key不满足要求，不包含任何可用于{llm_model}的api-key。您可能选择了错误的模型或请求源。")
 
     api_key = random.choice(avail_key_list) # 随机负载均衡
     return api_key
@@ -498,7 +511,7 @@ class DummyWith():
     它的作用是……额……没用，即在代码结构不变得情况下取代其他的上下文管理器。
     上下文管理器是一种Python对象，用于与with语句一起使用，
     以确保一些资源在代码块执行期间得到正确的初始化和清理。
-    上下文管理器必须实现两个方法，分别为 __enter__()和 __exit__()。 
+    上下文管理器必须实现两个方法，分别为 __enter__()和 __exit__()。
     在上下文执行开始的情况下，__enter__()方法会在代码块被执行前被调用，
     而在上下文执行结束时，__exit__()方法则会被调用。
     """
@@ -507,3 +520,34 @@ class DummyWith():
 
     def __exit__(self, exc_type, exc_value, traceback):
         return
+
+def run_gradio_in_subpath(demo, auth, port, custom_path):
+    def is_path_legal(path: str)->bool:
+        '''
+        check path for sub url
+        path: path to check
+        return value: do sub url wrap
+        '''
+        if path == "/": return True
+        if len(path) == 0:
+            print("ilegal custom path: {}\npath must not be empty\ndeploy on root url".format(path))
+            return False
+        if path[0] == '/':
+            if path[1] != '/':
+                print("deploy on sub-path {}".format(path))
+                return True
+            return False
+        print("ilegal custom path: {}\npath should begin with \'/\'\ndeploy on root url".format(path))
+        return False
+
+    if not is_path_legal(custom_path): raise RuntimeError('Ilegal custom path')
+    import uvicorn
+    import gradio as gr
+    from fastapi import FastAPI
+    app = FastAPI()
+    if custom_path != "/":
+        @app.get("/")
+        def read_main(): 
+            return {"message": f"Gradio is running at: {custom_path}"}
+    app = gr.mount_gradio_app(app, demo, path=custom_path)
+    uvicorn.run(app, host="0.0.0.0", port=port) # , auth=auth

version

@@ -1,5 +1,5 @@
 {
-  "version": 3.1,
+  "version": 3.2,
   "show_feature": true,
-  "new_feature": "添加支持清华ChatGLM和GPT-4 <-> 改进架构，支持与多个LLM模型同时对话 <-> 添加支持API2D（国内，可支持gpt4）<-> 支持多API-KEY负载均衡（并列填写，逗号分割） <-> 添加输入区文本清除按键"
+  "new_feature": "保存对话功能 <-> 解读任意语言代码+同时询问任意的LLM组合 <-> 添加联网（Google）回答问题插件 <-> 修复ChatGLM上下文BUG <-> 添加支持清华ChatGLM和GPT-4 <-> 改进架构，支持与多个LLM模型同时对话 <-> 添加支持API2D（国内，可支持gpt4）"
 }