|
import markdown |
|
import importlib |
|
import traceback |
|
import inspect |
|
import re |
|
import os |
|
from latex2mathml.converter import convert as tex2mathml |
|
from functools import wraps, lru_cache |
|
|
|
""" |
|
======================================================================== |
|
第一部分 |
|
函数插件输入输出接驳区 |
|
- ChatBotWithCookies: 带Cookies的Chatbot类，为实现更多强大的功能做基础 |
|
- ArgsGeneralWrapper: 装饰器函数，用于重组输入参数，改变输入参数的顺序与结构 |
|
- update_ui: 刷新界面用 yield from update_ui(chatbot, history) |
|
- CatchException: 将插件中出的所有问题显示在界面上 |
|
- HotReload: 实现插件的热更新 |
|
- trimmed_format_exc: 打印traceback，为了安全而隐藏绝对地址 |
|
======================================================================== |
|
""" |
|
|
|
class ChatBotWithCookies(list): |
|
def __init__(self, cookie): |
|
self._cookies = cookie |
|
|
|
def write_list(self, list): |
|
for t in list: |
|
self.append(t) |
|
|
|
def get_list(self): |
|
return [t for t in self] |
|
|
|
def get_cookies(self): |
|
return self._cookies |
|
|
|
|
|
def ArgsGeneralWrapper(f): |
|
""" |
|
装饰器函数，用于重组输入参数，改变输入参数的顺序与结构。 |
|
""" |
|
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 |
|
|
|
cookies.update({ |
|
'top_p':top_p, |
|
'temperature':temperature, |
|
}) |
|
llm_kwargs = { |
|
'api_key': cookies['api_key'], |
|
'llm_model': llm_model, |
|
'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) |
|
yield from f(txt_passon, llm_kwargs, plugin_kwargs, chatbot_with_cookie, history, system_prompt, *args) |
|
return decorated |
|
|
|
|
|
def update_ui(chatbot, history, msg='正常', **kwargs): |
|
""" |
|
刷新用户界面 |
|
""" |
|
assert isinstance(chatbot, ChatBotWithCookies), "在传递chatbot的过程中不要将其丢弃。必要时，可用clear将其清空，然后用for+append循环重新赋值。" |
|
yield chatbot.get_cookies(), chatbot, history, msg |
|
|
|
def trimmed_format_exc(): |
|
import os, traceback |
|
str = traceback.format_exc() |
|
current_path = os.getcwd() |
|
replace_path = "." |
|
return str.replace(current_path, replace_path) |
|
|
|
def CatchException(f): |
|
""" |
|
装饰器函数，捕捉函数f中的异常并封装到一个生成器中返回，并显示到聊天当中。 |
|
""" |
|
|
|
@wraps(f) |
|
def decorated(txt, top_p, temperature, chatbot, history, systemPromptTxt, WEB_PORT): |
|
try: |
|
yield from f(txt, top_p, temperature, chatbot, history, systemPromptTxt, WEB_PORT) |
|
except Exception as e: |
|
from check_proxy import check_proxy |
|
from toolbox import get_conf |
|
proxies, = get_conf('proxies') |
|
tb_str = '```\n' + trimmed_format_exc() + '```' |
|
if len(chatbot) == 0: |
|
chatbot.clear() |
|
chatbot.append(["插件调度异常", "异常原因"]) |
|
chatbot[-1] = (chatbot[-1][0], |
|
f"[Local Message] 实验性函数调用出错: \n\n{tb_str} \n\n当前代理可用性: \n\n{check_proxy(proxies)}") |
|
yield from update_ui(chatbot=chatbot, history=history, msg=f'异常 {e}') |
|
return decorated |
|
|
|
|
|
def HotReload(f): |
|
""" |
|
HotReload的装饰器函数，用于实现Python函数插件的热更新。 |
|
函数热更新是指在不停止程序运行的情况下，更新函数代码，从而达到实时更新功能。 |
|
在装饰器内部，使用wraps(f)来保留函数的元信息，并定义了一个名为decorated的内部函数。 |
|
内部函数通过使用importlib模块的reload函数和inspect模块的getmodule函数来重新加载并获取函数模块， |
|
然后通过getattr函数获取函数名，并在新模块中重新加载函数。 |
|
最后，使用yield from语句返回重新加载过的函数，并在被装饰的函数上执行。 |
|
最终，装饰器函数返回内部函数。这个内部函数可以将函数的原始定义更新为最新版本，并执行函数的新版本。 |
|
""" |
|
@wraps(f) |
|
def decorated(*args, **kwargs): |
|
fn_name = f.__name__ |
|
f_hot_reload = getattr(importlib.reload(inspect.getmodule(f)), fn_name) |
|
yield from f_hot_reload(*args, **kwargs) |
|
return decorated |
|
|
|
|
|
""" |
|
======================================================================== |
|
第二部分 |
|
其他小工具: |
|
- write_results_to_file: 将结果写入markdown文件中 |
|
- regular_txt_to_markdown: 将普通文本转换为Markdown格式的文本。 |
|
- report_execption: 向chatbot中添加简单的意外错误信息 |
|
- text_divide_paragraph: 将文本按照段落分隔符分割开，生成带有段落标签的HTML代码。 |
|
- markdown_convertion: 用多种方式组合，将markdown转化为好看的html |
|
- format_io: 接管gradio默认的markdown处理方式 |
|
- on_file_uploaded: 处理文件的上传（自动解压） |
|
- on_report_generated: 将生成的报告自动投射到文件上传区 |
|
- clip_history: 当历史上下文过长时，自动截断 |
|
- get_conf: 获取设置 |
|
- select_api_key: 根据当前的模型类别，抽取可用的api-key |
|
======================================================================== |
|
""" |
|
|
|
def get_reduce_token_percent(text): |
|
""" |
|
* 此函数未来将被弃用 |
|
""" |
|
try: |
|
|
|
pattern = r"(\d+)\s+tokens\b" |
|
match = re.findall(pattern, text) |
|
EXCEED_ALLO = 500 |
|
max_limit = float(match[0]) - EXCEED_ALLO |
|
current_tokens = float(match[1]) |
|
ratio = max_limit/current_tokens |
|
assert ratio > 0 and ratio < 1 |
|
return ratio, str(int(current_tokens-max_limit)) |
|
except: |
|
return 0.5, '不详' |
|
|
|
|
|
def write_results_to_file(history, 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()) + '.md' |
|
os.makedirs('./gpt_log/', exist_ok=True) |
|
with open(f'./gpt_log/{file_name}', 'w', encoding='utf8') as f: |
|
f.write('# chatGPT 分析报告\n') |
|
for i, content in enumerate(history): |
|
try: |
|
if type(content) != str: content = str(content) |
|
except: |
|
continue |
|
if i % 2 == 0: |
|
f.write('## ') |
|
try: |
|
f.write(content) |
|
except: |
|
|
|
f.write(content.encode('utf-8', 'ignore').decode()) |
|
f.write('\n\n') |
|
res = '以上材料已经被写入' + os.path.abspath(f'./gpt_log/{file_name}') |
|
print(res) |
|
return res |
|
|
|
|
|
def regular_txt_to_markdown(text): |
|
""" |
|
将普通文本转换为Markdown格式的文本。 |
|
""" |
|
text = text.replace('\n', '\n\n') |
|
text = text.replace('\n\n\n', '\n\n') |
|
text = text.replace('\n\n\n', '\n\n') |
|
return text |
|
|
|
|
|
|
|
|
|
def report_execption(chatbot, history, a, b): |
|
""" |
|
向chatbot中添加错误信息 |
|
""" |
|
chatbot.append((a, b)) |
|
history.append(a) |
|
history.append(b) |
|
|
|
|
|
def text_divide_paragraph(text): |
|
""" |
|
将文本按照段落分隔符分割开，生成带有段落标签的HTML代码。 |
|
""" |
|
if '```' in text: |
|
|
|
return text |
|
else: |
|
|
|
lines = text.split("\n") |
|
for i, line in enumerate(lines): |
|
lines[i] = lines[i].replace(" ", " ") |
|
text = "</br>".join(lines) |
|
return text |
|
|
|
@lru_cache(maxsize=128) |
|
def markdown_convertion(txt): |
|
""" |
|
将Markdown格式的文本转换为HTML格式。如果包含数学公式，则先将公式转换为HTML格式。 |
|
""" |
|
pre = '<div class="markdown-body">' |
|
suf = '</div>' |
|
if txt.startswith(pre) and txt.endswith(suf): |
|
|
|
return txt |
|
|
|
markdown_extension_configs = { |
|
'mdx_math': { |
|
'enable_dollar_delimiter': True, |
|
'use_gitlab_delimiters': False, |
|
}, |
|
} |
|
find_equation_pattern = r'<script type="math/tex(?:.*?)>(.*?)</script>' |
|
|
|
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 no_code(txt): |
|
if '```' not in txt: |
|
return True |
|
else: |
|
if '```reference' in txt: return True |
|
else: return False |
|
|
|
if ('$' in txt) and no_code(txt): |
|
|
|
split = markdown.markdown(text='---') |
|
convert_stage_1 = markdown.markdown(text=txt, extensions=['mdx_math', 'fenced_code', 'tables', 'sane_lists'], extension_configs=markdown_extension_configs) |
|
convert_stage_1 = markdown_bug_hunt(convert_stage_1) |
|
|
|
|
|
convert_stage_2_1, n = re.subn(find_equation_pattern, replace_math_no_render, convert_stage_1, flags=re.DOTALL) |
|
|
|
convert_stage_2_2, n = re.subn(find_equation_pattern, replace_math_render, convert_stage_1, flags=re.DOTALL) |
|
|
|
return pre + convert_stage_2_1 + f'{split}' + convert_stage_2_2 + suf |
|
else: |
|
return pre + markdown.markdown(txt, extensions=['fenced_code', 'codehilite', 'tables', 'sane_lists']) + 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 format_io(self, y): |
|
""" |
|
将输入和输出解析为HTML格式。将y中最后一项的输入部分段落化，并将输出部分的Markdown和数学公式转换为HTML格式。 |
|
""" |
|
if y is None or y == []: |
|
return [] |
|
i_ask, gpt_reply = y[-1] |
|
i_ask = text_divide_paragraph(i_ask) |
|
gpt_reply = close_up_code_segment_during_stream(gpt_reply) |
|
y[-1] = ( |
|
None if i_ask is None else markdown.markdown(i_ask, extensions=['fenced_code', 'tables']), |
|
None if gpt_reply is None else markdown_convertion(gpt_reply) |
|
) |
|
return y |
|
|
|
|
|
def find_free_port(): |
|
""" |
|
返回当前系统中可用的未使用端口。 |
|
""" |
|
import socket |
|
from contextlib import closing |
|
with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s: |
|
s.bind(('', 0)) |
|
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) |
|
return s.getsockname()[1] |
|
|
|
|
|
def extract_archive(file_path, dest_dir): |
|
import zipfile |
|
import tarfile |
|
import os |
|
|
|
file_extension = os.path.splitext(file_path)[1] |
|
|
|
|
|
if file_extension == '.zip': |
|
with zipfile.ZipFile(file_path, 'r') as zipobj: |
|
zipobj.extractall(path=dest_dir) |
|
print("Successfully extracted zip archive to {}".format(dest_dir)) |
|
|
|
elif file_extension in ['.tar', '.gz', '.bz2']: |
|
with tarfile.open(file_path, 'r:*') as tarobj: |
|
tarobj.extractall(path=dest_dir) |
|
print("Successfully extracted tar archive to {}".format(dest_dir)) |
|
|
|
|
|
|
|
elif file_extension == '.rar': |
|
try: |
|
import rarfile |
|
with rarfile.RarFile(file_path) as rf: |
|
rf.extractall(path=dest_dir) |
|
print("Successfully extracted rar archive to {}".format(dest_dir)) |
|
except: |
|
print("Rar format requires additional dependencies to install") |
|
return '\n\n需要安装pip install rarfile来解压rar文件' |
|
|
|
|
|
elif file_extension == '.7z': |
|
try: |
|
import py7zr |
|
with py7zr.SevenZipFile(file_path, mode='r') as f: |
|
f.extractall(path=dest_dir) |
|
print("Successfully extracted 7z archive to {}".format(dest_dir)) |
|
except: |
|
print("7z format requires additional dependencies to install") |
|
return '\n\n需要安装pip install py7zr来解压7z文件' |
|
else: |
|
return '' |
|
return '' |
|
|
|
|
|
def find_recent_files(directory): |
|
""" |
|
me: find files that is created with in one minutes under a directory with python, write a function |
|
gpt: here it is! |
|
""" |
|
import os |
|
import time |
|
current_time = time.time() |
|
one_minute_ago = current_time - 60 |
|
recent_files = [] |
|
|
|
for filename in os.listdir(directory): |
|
file_path = os.path.join(directory, filename) |
|
if file_path.endswith('.log'): |
|
continue |
|
created_time = os.path.getmtime(file_path) |
|
if created_time >= one_minute_ago: |
|
if os.path.isdir(file_path): |
|
continue |
|
recent_files.append(file_path) |
|
|
|
return recent_files |
|
|
|
|
|
def on_file_uploaded(files, chatbot, txt, txt2, checkboxes): |
|
""" |
|
当文件被上传时的回调函数 |
|
""" |
|
if len(files) == 0: |
|
return chatbot, txt |
|
import shutil |
|
import os |
|
import time |
|
import glob |
|
from toolbox import extract_archive |
|
try: |
|
shutil.rmtree('./private_upload/') |
|
except: |
|
pass |
|
time_tag = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime()) |
|
os.makedirs(f'private_upload/{time_tag}', exist_ok=True) |
|
err_msg = '' |
|
for file in files: |
|
file_origin_name = os.path.basename(file.orig_name) |
|
shutil.copy(file.name, f'private_upload/{time_tag}/{file_origin_name}') |
|
err_msg += extract_archive(f'private_upload/{time_tag}/{file_origin_name}', |
|
dest_dir=f'private_upload/{time_tag}/{file_origin_name}.extract') |
|
moved_files = [fp for fp in glob.glob('private_upload/**/*', recursive=True)] |
|
if "底部输入区" in checkboxes: |
|
txt = "" |
|
txt2 = f'private_upload/{time_tag}' |
|
else: |
|
txt = f'private_upload/{time_tag}' |
|
txt2 = "" |
|
moved_files_str = '\t\n\n'.join(moved_files) |
|
chatbot.append(['我上传了文件，请查收', |
|
f'[Local Message] 收到以下文件: \n\n{moved_files_str}' + |
|
f'\n\n调用路径参数已自动修正到: \n\n{txt}' + |
|
f'\n\n现在您点击任意“红颜色”标识的函数插件时，以上文件将被作为输入参数'+err_msg]) |
|
return chatbot, txt, txt2 |
|
|
|
|
|
def on_report_generated(files, chatbot): |
|
from toolbox import find_recent_files |
|
report_files = find_recent_files('gpt_log') |
|
if len(report_files) == 0: |
|
return None, chatbot |
|
|
|
chatbot.append(['汇总报告如何远程获取？', '汇总报告已经添加到右侧“文件上传区”（可能处于折叠状态），请查收。']) |
|
return report_files, chatbot |
|
|
|
def is_openai_api_key(key): |
|
API_MATCH_ORIGINAL = re.match(r"sk-[a-zA-Z0-9]{48}$", key) |
|
API_MATCH_AZURE = re.match(r"[a-zA-Z0-9]{32}$", key) |
|
return bool(API_MATCH_ORIGINAL) or bool(API_MATCH_AZURE) |
|
|
|
def is_api2d_key(key): |
|
if key.startswith('fk') and len(key) == 41: |
|
return True |
|
else: |
|
return False |
|
|
|
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) |
|
|
|
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 |
|
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 len(avail_key_list) == 0: |
|
raise RuntimeError(f"您提供的api-key不满足要求，不包含任何可用于{llm_model}的api-key。您可能选择了错误的模型或请求源。") |
|
|
|
api_key = random.choice(avail_key_list) |
|
return api_key |
|
|
|
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")] |
|
""" |
|
from colorful import print亮红, print亮绿 |
|
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 colorful import print亮红, print亮绿, print亮蓝 |
|
try: |
|
|
|
default_ref = getattr(importlib.import_module('config'), arg) |
|
r = read_env_variable(arg, default_ref) |
|
except: |
|
try: |
|
|
|
r = getattr(importlib.import_module('config_private'), arg) |
|
except: |
|
|
|
r = getattr(importlib.import_module('config'), arg) |
|
|
|
|
|
if arg == 'API_KEY': |
|
print亮蓝(f"[API_KEY] 本项目现已支持OpenAI和API2D的api-key。也支持同时填写多个api-key，如API_KEY=\"openai-key1,openai-key2,api2d-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 是'sk'开头的51位密钥（OpenAI），或者 'fk'开头的41位密钥，请在config文件中修改API密钥之后再运行。") |
|
if arg == 'proxies': |
|
if r is None: |
|
print亮红('[PROXY] 网络代理状态：未配置。无代理状态下很可能无法访问OpenAI家族的模型。建议：检查USE_PROXY选项是否修改。') |
|
else: |
|
print亮绿('[PROXY] 网络代理状态：已配置。配置信息如下：', r) |
|
assert isinstance(r, dict), 'proxies格式错误，请注意proxies选项的格式，不要遗漏括号。' |
|
return r |
|
|
|
|
|
def get_conf(*args): |
|
|
|
res = [] |
|
for arg in args: |
|
r = read_single_conf_with_lru_cache(arg) |
|
res.append(r) |
|
return res |
|
|
|
|
|
def clear_line_break(txt): |
|
txt = txt.replace('\n', ' ') |
|
txt = txt.replace(' ', ' ') |
|
txt = txt.replace(' ', ' ') |
|
return txt |
|
|
|
|
|
class DummyWith(): |
|
""" |
|
这段代码定义了一个名为DummyWith的空上下文管理器， |
|
它的作用是……额……就是不起作用，即在代码结构不变得情况下取代其他的上下文管理器。 |
|
上下文管理器是一种Python对象，用于与with语句一起使用， |
|
以确保一些资源在代码块执行期间得到正确的初始化和清理。 |
|
上下文管理器必须实现两个方法，分别为 __enter__()和 __exit__()。 |
|
在上下文执行开始的情况下，__enter__()方法会在代码块被执行前被调用， |
|
而在上下文执行结束时，__exit__()方法则会被调用。 |
|
""" |
|
def __enter__(self): |
|
return self |
|
|
|
def __exit__(self, exc_type, exc_value, traceback): |
|
return |
|
|
|
def run_gradio_in_subpath(demo, auth, port, custom_path): |
|
""" |
|
把gradio的运行地址更改到指定的二次路径上 |
|
""" |
|
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) |
|
|
|
|
|
def clip_history(inputs, history, tokenizer, max_token_limit): |
|
""" |
|
reduce the length of history by clipping. |
|
this function search for the longest entries to clip, little by little, |
|
until the number of token of history is reduced under threshold. |
|
通过裁剪来缩短历史记录的长度。 |
|
此函数逐渐地搜索最长的条目进行剪辑， |
|
直到历史记录的标记数量降低到阈值以下。 |
|
""" |
|
import numpy as np |
|
from request_llm.bridge_all import model_info |
|
def get_token_num(txt): |
|
return len(tokenizer.encode(txt, disallowed_special=())) |
|
input_token_num = get_token_num(inputs) |
|
if input_token_num < max_token_limit * 3 / 4: |
|
|
|
|
|
max_token_limit = max_token_limit - input_token_num |
|
|
|
max_token_limit = max_token_limit - 128 |
|
|
|
if max_token_limit < 128: |
|
history = [] |
|
return history |
|
else: |
|
|
|
history = [] |
|
return history |
|
|
|
everything = [''] |
|
everything.extend(history) |
|
n_token = get_token_num('\n'.join(everything)) |
|
everything_token = [get_token_num(e) for e in everything] |
|
|
|
|
|
delta = max(everything_token) // 16 |
|
|
|
while n_token > max_token_limit: |
|
where = np.argmax(everything_token) |
|
encoded = tokenizer.encode(everything[where], disallowed_special=()) |
|
clipped_encoded = encoded[:len(encoded)-delta] |
|
everything[where] = tokenizer.decode(clipped_encoded)[:-1] |
|
everything_token[where] = get_token_num(everything[where]) |
|
n_token = get_token_num('\n'.join(everything)) |
|
|
|
history = everything[1:] |
|
return history |
|
|
