Upload 204 files

group_tags/.gitignore

@@ -0,0 +1,3 @@
+custom.yaml
+prepend.yaml
+append.yaml

install.py

@@ -0,0 +1,28 @@
+import launch
+
+packages = {
+    "chardet": "chardet",
+    "fastapi": "fastapi",
+    "execjs": "PyExecJS",
+    "lxml": "lxml",
+    "tqdm": "tqdm",
+    "pathos": "pathos",
+    "cryptography": "cryptography",
+
+    # The following packages are required for translation service. If you do not need translation service, you can remove them.
+    # 以下是翻译所需的包，如果不需要翻译服务，可以删除掉它们。
+    "openai": "openai",
+    "boto3": "boto3",
+    "aliyunsdkcore": "aliyun-python-sdk-core",
+    "aliyunsdkalimt": "aliyun-python-sdk-alimt",
+}
+
+if __name__ == "__main__":
+    for package_name in packages:
+        package = packages[package_name]
+        try:
+            if not launch.is_installed(package_name):
+                launch.run_pip(f"install {package}", f"sd-webui-prompt-all-in-one: {package_name}")
+        except Exception as e:
+            print(e)
+            print(f'Warning: Failed to install {package}, some preprocessors may not work.')

models/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

scripts/on_app_started.py

@@ -0,0 +1,388 @@
+import gradio as gr
+import os
+import sys
+from pathlib import Path
+from modules import script_callbacks, extra_networks, prompt_parser
+from fastapi import FastAPI, Body, Request, Response
+from fastapi.responses import FileResponse
+from scripts.physton_prompt.storage import Storage
+from scripts.physton_prompt.get_extensions import get_extensions
+from scripts.physton_prompt.get_token_counter import get_token_counter
+from scripts.physton_prompt.get_i18n import get_i18n
+from scripts.physton_prompt.get_translate_apis import get_translate_apis, privacy_translate_api_config, unprotected_translate_api_config
+from scripts.physton_prompt.translate import translate
+from scripts.physton_prompt.history import History
+from scripts.physton_prompt.csv import get_csvs, get_csv
+from scripts.physton_prompt.styles import get_style_full_path, get_extension_css_list
+from scripts.physton_prompt.get_extra_networks import get_extra_networks
+from scripts.physton_prompt.packages import get_packages_state, install_package
+from scripts.physton_prompt.gen_openai import gen_openai
+from scripts.physton_prompt.get_lang import get_lang
+from scripts.physton_prompt.get_version import get_git_commit_version, get_git_remote_versions, get_latest_version
+from scripts.physton_prompt.mbart50 import initialize as mbart50_initialize, translate as mbart50_translate
+from scripts.physton_prompt.get_group_tags import get_group_tags
+
+try:
+    from modules.shared import cmd_opts
+
+    if cmd_opts.data_dir:
+        extension_dir = os.path.dirname(os.path.abspath(__file__)) + '/../'
+        extension_dir = os.path.normpath(extension_dir) + os.path.sep
+        data_dir = os.path.normpath(cmd_opts.data_dir) + os.path.sep
+        webui_dir = os.path.normpath(Path().absolute()) + os.path.sep
+        if not extension_dir.startswith(webui_dir):
+            find = False
+            if cmd_opts.gradio_allowed_path:
+                for path in cmd_opts.gradio_allowed_path:
+                    path = os.path.normpath(path) + os.path.sep
+                    if path == extension_dir:
+                        find = path
+                        break
+                    elif extension_dir.startswith(path):
+                        find = path
+                        break
+                    else:
+                        pass
+            if not find:
+                message = f'''
+\033[1;31m[sd-webui-prompt-all-in-one]
+As you have set the --data-dir parameter and have not added the extension path to the --gradio-allowed-path parameter, the extension may not function properly. Please add the following startup parameter:
+由于你设置了 --data-dir 参数，并且没有将本扩展路径加入到 --gradio-allowed-path 参数中，所以本扩展可能无法正常运行。请添加启动参数：
+\033[1;32m--gradio-allowed-path="{extension_dir}"
+\033[0m
+                '''
+                print(message)
+except Exception as e:
+    pass
+
+
+def on_app_started(_: gr.Blocks, app: FastAPI):
+    st = Storage()
+    hi = History()
+
+    @app.get("/physton_prompt/get_version")
+    async def _get_version():
+        return {
+            'version': get_git_commit_version(),
+            'latest_version': get_latest_version(),
+        }
+
+    @app.get("/physton_prompt/get_remote_versions")
+    async def _get_remote_versions(page: int = 1, per_page: int = 100):
+        return {
+            'versions': get_git_remote_versions(page, per_page),
+        }
+
+    @app.get("/physton_prompt/get_config")
+    async def _get_config():
+        return {
+            'i18n': get_i18n(True),
+            'translate_apis': get_translate_apis(True),
+            'packages_state': get_packages_state(),
+            'python': sys.executable,
+        }
+
+    @app.post("/physton_prompt/install_package")
+    async def _install_package(request: Request):
+        data = await request.json()
+        if 'name' not in data:
+            return {"result": get_lang('is_required', {'0': 'name'})}
+        if 'package' not in data:
+            return {"result": get_lang('is_required', {'0': 'package'})}
+        return {"result": install_package(data['name'], data['package'])}
+
+    @app.get("/physton_prompt/get_extensions")
+    async def _get_extensions():
+        return {"extends": get_extensions()}
+
+    @app.post("/physton_prompt/token_counter")
+    async def _token_counter(request: Request):
+        data = await request.json()
+        if 'text' not in data:
+            return {"result": get_lang('is_required', {'0': 'text'})}
+        if 'steps' not in data:
+            return {"result": get_lang('is_required', {'0': 'steps'})}
+        return get_token_counter(data['text'], data['steps'])
+
+    @app.get("/physton_prompt/get_data")
+    async def _get_data(key: str):
+        data = st.get(key)
+        data = privacy_translate_api_config(key, data)
+        return {"data": data}
+
+    @app.get("/physton_prompt/get_datas")
+    async def _get_datas(keys: str):
+        keys = keys.split(',')
+        datas = {}
+        for key in keys:
+            datas[key] = st.get(key)
+            datas[key] = privacy_translate_api_config(key, datas[key])
+        return {"datas": datas}
+
+    @app.post("/physton_prompt/set_data")
+    async def _set_data(request: Request):
+        data = await request.json()
+        if 'key' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'key'})}
+        if 'data' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'data'})}
+        data['data'] = unprotected_translate_api_config(data['key'], data['data'])
+        st.set(data['key'], data['data'])
+        return {"success": True}
+
+    @app.post("/physton_prompt/set_datas")
+    async def _set_datas(request: Request):
+        data = await request.json()
+        if not isinstance(data, dict):
+            return {"success": False, "message": get_lang('is_not_dict', {'0': 'data'})}
+        for key in data:
+            data[key] = unprotected_translate_api_config(key, data[key])
+            st.set(key, data[key])
+        return {"success": True}
+
+    @app.get("/physton_prompt/get_data_list_item")
+    async def _get_data_list_item(key: str, index: int):
+        return {"item": st.list_get(key, index)}
+
+    @app.post("/physton_prompt/push_data_list")
+    async def _push_data_list(request: Request):
+        data = await request.json()
+        if 'key' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'key'})}
+        if 'item' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'item'})}
+        st.list_push(data['key'], data['item'])
+        return {"success": True}
+
+    @app.post("/physton_prompt/pop_data_list")
+    async def _pop_data_list(request: Request):
+        data = await request.json()
+        if 'key' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'key'})}
+        return {"success": True, 'item': st.list_pop(data['key'])}
+
+    @app.post("/physton_prompt/shift_data_list")
+    async def _shift_data_list(request: Request):
+        data = await request.json()
+        if 'key' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'key'})}
+        return {"success": True, 'item': st.list_shift(data['key'])}
+
+    @app.post("/physton_prompt/remove_data_list")
+    async def _remove_data_list(request: Request):
+        data = await request.json()
+        if 'key' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'key'})}
+        if 'index' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'index'})}
+        st.list_remove(data['key'], data['index'])
+        return {"success": True}
+
+    @app.post("/physton_prompt/clear_data_list")
+    async def _clear_data_list(request: Request):
+        data = await request.json()
+        if 'key' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'key'})}
+        st.list_clear(data['key'])
+        return {"success": True}
+
+    @app.get("/physton_prompt/get_histories")
+    async def _get_histories(type: str):
+        return {"histories": hi.get_histories(type)}
+
+    @app.get("/physton_prompt/get_favorites")
+    async def _get_favorites(type: str):
+        return {"favorites": hi.get_favorites(type)}
+
+    @app.post("/physton_prompt/push_history")
+    async def _push_history(request: Request):
+        data = await request.json()
+        if 'type' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'type'})}
+        if 'tags' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'tags'})}
+        if 'prompt' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'prompt'})}
+        hi.push_history(data['type'], data['tags'], data['prompt'], data.get('name', ''))
+        return {"success": True}
+
+    @app.post("/physton_prompt/push_favorite")
+    async def _push_favorite(request: Request):
+        data = await request.json()
+        if 'type' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'type'})}
+        if 'tags' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'tags'})}
+        if 'prompt' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'prompt'})}
+        hi.push_favorite(data['type'], data['tags'], data['prompt'], data.get('name', ''))
+        return {"success": True}
+
+    @app.get("/physton_prompt/get_latest_history")
+    async def _get_latest_history(type: str):
+        return {"history": hi.get_latest_history(type)}
+
+    @app.post("/physton_prompt/set_history")
+    async def _set_history(request: Request):
+        data = await request.json()
+        if 'type' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'type'})}
+        if 'id' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'id'})}
+        if 'tags' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'tags'})}
+        if 'prompt' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'prompt'})}
+        if 'name' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'name'})}
+        return {"success": hi.set_history(data['type'], data['id'], data['tags'], data['prompt'], data['name'])}
+
+    @app.post("/physton_prompt/set_history_name")
+    async def _set_history_name(request: Request):
+        data = await request.json()
+        if 'type' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'type'})}
+        if 'id' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'id'})}
+        if 'name' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'name'})}
+        return {"success": hi.set_history_name(data['type'], data['id'], data['name'])}
+
+    @app.post("/physton_prompt/set_favorite_name")
+    async def _set_favorite_name(request: Request):
+        data = await request.json()
+        if 'type' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'type'})}
+        if 'id' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'id'})}
+        if 'name' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'name'})}
+        return {"success": hi.set_favorite_name(data['type'], data['id'], data['name'])}
+
+    @app.post("/physton_prompt/dofavorite")
+    async def _dofavorite(request: Request):
+        data = await request.json()
+        if 'type' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'type'})}
+        if 'id' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'id'})}
+        return {"success": hi.dofavorite(data['type'], data['id'])}
+
+    @app.post("/physton_prompt/unfavorite")
+    async def _unfavorite(request: Request):
+        data = await request.json()
+        if 'type' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'type'})}
+        if 'id' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'id'})}
+        return {"success": hi.unfavorite(data['type'], data['id'])}
+
+    @app.post("/physton_prompt/delete_history")
+    async def _delete_history(request: Request):
+        data = await request.json()
+        if 'type' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'type'})}
+        if 'id' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'id'})}
+        return {"success": hi.remove_history(data['type'], data['id'])}
+
+    @app.post("/physton_prompt/delete_histories")
+    async def _delete_histories(request: Request):
+        data = await request.json()
+        if 'type' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'type'})}
+        return {"success": hi.remove_histories(data['type'])}
+
+    @app.post("/physton_prompt/translate")
+    async def _translate(request: Request):
+        data = await request.json()
+        if 'text' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'text'})}
+        if 'from_lang' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'from_lang'})}
+        if 'to_lang' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'to_lang'})}
+        if 'api' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'api'})}
+        if 'api_config' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'api_config'})}
+        return translate(data['text'], data['from_lang'], data['to_lang'], data['api'], data['api_config'])
+
+    @app.post("/physton_prompt/translates")
+    async def _translates(request: Request):
+        data = await request.json()
+        if 'texts' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'texts'})}
+        if 'from_lang' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'from_lang'})}
+        if 'to_lang' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'to_lang'})}
+        if 'api' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'api'})}
+        if 'api_config' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'api_config'})}
+        return translate(data['texts'], data['from_lang'], data['to_lang'], data['api'], data['api_config'])
+
+    @app.get("/physton_prompt/get_csvs")
+    async def _get_csvs():
+        return {"csvs": get_csvs()}
+
+    @app.get("/physton_prompt/get_csv")
+    async def _get_csv(key: str):
+        file = get_csv(key)
+        if not file:
+            return Response(status_code=404)
+        return FileResponse(file, media_type='text/csv', filename=os.path.basename(file))
+
+    @app.get("/physton_prompt/styles")
+    async def _styles(file: str):
+        file_path = get_style_full_path(file)
+        if not os.path.exists(file_path):
+            return Response(status_code=404)
+        return FileResponse(file_path, filename=os.path.basename(file_path))
+
+    @app.get("/physton_prompt/get_extension_css_list")
+    async def _get_extension_css_list():
+        return {"css_list": get_extension_css_list()}
+
+    @app.get("/physton_prompt/get_extra_networks")
+    async def _get_extra_networks():
+        return {"extra_networks": get_extra_networks()}
+
+    @app.post("/physton_prompt/gen_openai")
+    async def _gen_openai(request: Request):
+        data = await request.json()
+        if 'messages' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'messages'})}
+        if 'api_config' not in data:
+            return {"success": False, "message": get_lang('is_required', {'0': 'api_config'})}
+        try:
+            return {"success": True, 'result': gen_openai(data['messages'], data['api_config'])}
+        except Exception as e:
+            return {"success": False, 'message': str(e)}
+
+    @app.post("/physton_prompt/mbart50_initialize")
+    async def _mbart50_initialize(request: Request):
+        try:
+            mbart50_initialize(True)
+            return {"success": True}
+        except Exception as e:
+            return {"success": False, 'message': str(e)}
+
+    @app.get("/physton_prompt/get_group_tags")
+    async def _get_group_tags(lang: str):
+        return {"tags": get_group_tags(lang)}
+
+    try:
+        translate_api = st.get('translateApi')
+        if translate_api == 'mbart50':
+            mbart50_initialize()
+    except Exception:
+        pass
+
+
+try:
+    script_callbacks.on_app_started(on_app_started)
+    print('sd-webui-prompt-all-in-one background API service started successfully.')
+except Exception as e:
+    print(f'sd-webui-prompt-all-in-one background API service failed to start: {e}')

scripts/physton_prompt/csv.py

@@ -0,0 +1,37 @@
+import os
+from pathlib import Path
+
+base_dir = str(Path().absolute())
+dirs = [
+    os.path.join(base_dir, 'extensions', 'sd-webui-prompt-all-in-one', 'tags'),
+    os.path.join(base_dir, 'extensions', 'a1111-sd-webui-tagcomplete', 'tags'),
+]
+
+
+def get_csvs():
+    global base_dir
+    csvs = []
+    for dir in dirs:
+        if not os.path.exists(dir):
+            continue
+        for file in os.listdir(dir):
+            if file.endswith('.csv'):
+                path = os.path.join(dir, file)
+                name = os.path.basename(file)
+                size = os.path.getsize(path)
+                # 去除 base_dir 后的路径
+                key = path.replace(base_dir, '')
+                csvs.append({
+                    'key': key,
+                    'name': name,
+                    'size': size,
+                    'path': path
+                })
+    return csvs
+
+
+def get_csv(key):
+    path = base_dir + key
+    if not os.path.exists(path):
+        return None
+    return path

scripts/physton_prompt/gen_openai.py

@@ -0,0 +1,19 @@
+from scripts.physton_prompt.get_lang import get_lang
+from scripts.physton_prompt.get_translate_apis import unprotected_translate_api_config
+
+
+def gen_openai(messages, api_config):
+    import openai
+    api_config = unprotected_translate_api_config('chatgpt_key', api_config)
+    openai.api_base = api_config.get('api_base', 'https://api.openai.com/v1')
+    openai.api_key = api_config.get('api_key', '')
+    model = api_config.get('model', 'gpt-3.5-turbo')
+    if not openai.api_key:
+        raise Exception(get_lang('is_required', {'0': 'API Key'}))
+    if not messages or len(messages) == 0:
+        raise Exception(get_lang('is_required', {'0': 'messages'}))
+    completion = openai.ChatCompletion.create(model=model, messages=messages, timeout=60)
+    if len(completion.choices) == 0:
+        raise Exception(get_lang('no_response_from', {'0': 'OpenAI'}))
+    content = completion.choices[0].message.content
+    return content

scripts/physton_prompt/get_extensions.py

@@ -0,0 +1,12 @@
+import os
+from pathlib import Path
+
+
+def get_extensions():
+    extends_dir = os.path.join(Path().absolute(), 'extensions')
+    extends = []
+    for name in os.listdir(extends_dir):
+        path = os.path.join(extends_dir, name)
+        if os.path.isdir(path):
+            extends.append(name)
+    return extends

scripts/physton_prompt/get_extra_networks.py

@@ -0,0 +1,67 @@
+# -*- coding: UTF-8 -*-
+
+from modules import script_callbacks, extra_networks, prompt_parser, shared, ui_extra_networks
+import json
+import os
+
+filters = [
+    'filename',
+    'description',
+    'search_term',
+    'local_preview',
+    'metadata',
+]
+
+
+def get_extra_networks():
+    result = []
+    try:
+        for extra_page in ui_extra_networks.extra_pages:
+            result_item = {
+                'name': extra_page.name,
+                'title': extra_page.title,
+                'items': []
+            }
+            for item in extra_page.list_items():
+                # 解析metadata
+                output_name = None
+                try:
+                    if 'metadata' in item and item['metadata']:
+                        metadata = json.loads(item['metadata'])
+                        if metadata and 'ss_output_name' in metadata:
+                            output_name = metadata['ss_output_name']
+                except Exception as e:
+                    pass
+                item['output_name'] = output_name
+
+                # 获取civitai.info
+                item['civitai_info'] = {}
+                try:
+                    if 'filename' in item and item['filename']:
+                        if extra_page.name == 'textual inversion':
+                            base, ext = os.path.splitext(item['filename'])
+                            info_file = base + '.civitai.info'
+                        else:
+                            info_file = item['filename'] + '.civitai.info'
+                        if os.path.isfile(info_file):
+                            with open(info_file, 'r') as f:
+                                info = json.load(f)
+                                info = {
+                                    'name': info.get('name', ''),
+                                    'model': info.get('model', {}),
+                                }
+                                item['civitai_info'] = info
+                except Exception as e:
+                    pass
+
+                # 过滤掉不需要的字段
+                for filter in filters:
+                    if filter in item:
+                        del item[filter]
+
+                result_item['items'].append(item)
+
+            result.append(result_item)
+    except Exception as e:
+        pass
+    return result

scripts/physton_prompt/get_group_tags.py

@@ -0,0 +1,43 @@
+import os
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+
+def _get_tags_filename(name):
+    file = os.path.join(current_dir, '../../group_tags/', name + '.yaml')
+    return file
+
+def get_group_tags(lang):
+    tags_file = _get_tags_filename('custom')
+    if not os.path.exists(tags_file):
+        tags_file = _get_tags_filename(lang)
+        if not os.path.exists(tags_file):
+            tags_file = _get_tags_filename('default')
+    if not os.path.exists(tags_file):
+        return ''
+
+    tags = ''
+
+    try:
+        prepend_file = _get_tags_filename('prepend')
+        with open(prepend_file, 'r', encoding='utf8') as f:
+            prepend = f.read()
+        tags += prepend + "\n\n"
+    except:
+        pass
+
+    try:
+        with open(tags_file, 'r', encoding='utf8') as f:
+            data = f.read()
+        tags += data + "\n\n"
+    except:
+        pass
+
+    try:
+        append_file = _get_tags_filename('append')
+        with open(append_file, 'r', encoding='utf8') as f:
+            append = f.read()
+        tags += append + "\n\n"
+    except:
+        pass
+
+    return tags

scripts/physton_prompt/get_i18n.py

@@ -0,0 +1,16 @@
+import os
+import json
+
+i18n = {}
+
+
+def get_i18n(reload=False):
+    global i18n
+    if reload or not i18n:
+        i18n = {}
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        config_file = os.path.join(current_dir, '../../i18n.json')
+        config_file = os.path.normpath(config_file)
+        with open(config_file, 'r', encoding='utf8') as f:
+            i18n = json.load(f)
+    return i18n

scripts/physton_prompt/get_lang.py

@@ -0,0 +1,47 @@
+from scripts.physton_prompt.storage import Storage
+
+storage = Storage()
+from scripts.physton_prompt.get_i18n import get_i18n
+
+
+def replace_vars(text, vars):
+    for key, value in vars.items():
+        text = text.replace("{" + key + "}", value)
+    return text
+
+
+def get_lang(key, vars={}):
+    i18n = get_i18n()
+    code = storage.get('languageCode')
+
+    def find_lang(code):
+        for item in i18n['languages']:
+            if item['code'] == code:
+                return True
+        return False
+
+    if not find_lang(code):
+        code = i18n['default']
+
+    if not find_lang(code):
+        code = 'en_US'
+
+    def find_key(key, code):
+        for item in i18n['languages']:
+            if item['code'] == code:
+                if key in item['lang']:
+                    if vars == {}:
+                        return item['lang'][key]
+                    else:
+                        return replace_vars(item['lang'][key], vars)
+        return False
+
+    find = find_key(key, code)
+    if find:
+        return find
+
+    find = find_key(key, 'en_US')
+    if find:
+        return find
+
+    return replace_vars(key, vars)

scripts/physton_prompt/get_token_counter.py

@@ -0,0 +1,23 @@
+from modules import script_callbacks, extra_networks, prompt_parser
+from modules.sd_hijack import model_hijack
+from functools import partial, reduce
+
+
+def get_token_counter(text, steps):
+    # copy from modules.ui.py
+    try:
+        text, _ = extra_networks.parse_prompt(text)
+
+        _, prompt_flat_list, _ = prompt_parser.get_multicond_prompt_list([text])
+        prompt_schedules = prompt_parser.get_learned_conditioning_prompt_schedules(prompt_flat_list, steps)
+
+    except Exception:
+        # a parsing error can happen here during typing, and we don't want to bother the user with
+        # messages related to it in console
+        prompt_schedules = [[[steps, text]]]
+
+    flat_prompts = reduce(lambda list1, list2: list1 + list2, prompt_schedules)
+    prompts = [prompt_text for step, prompt_text in flat_prompts]
+    token_count, max_length = max([model_hijack.get_prompt_lengths(prompt) for prompt in prompts],
+                                  key=lambda args: args[0])
+    return {"token_count": token_count, "max_length": max_length}

scripts/physton_prompt/get_translate_apis.py

@@ -0,0 +1,123 @@
+import os
+import json
+import re
+from scripts.physton_prompt.storage import Storage
+st = Storage()
+
+# from scripts.physton_prompt.storage import Storage
+
+translate_apis = {}
+
+
+# st = Storage()
+def get_translate_apis(reload=False):
+    global translate_apis
+    global st
+    if reload or not translate_apis:
+        translate_apis = {}
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        config_file = os.path.join(current_dir, '../../translate_apis.json')
+        config_file = os.path.normpath(config_file)
+        with open(config_file, 'r', encoding='utf8') as f:
+            translate_apis = json.load(f)
+
+        # for group in translate_apis['apis']:
+        #     for item in group['children']:
+        #         if 'config' not in item:
+        #             continue
+        #         config_name = 'translate_api.' + item['key']
+        #         config = st.get(config_name)
+        #         if not config:
+        #             config = {}
+        #         for config_item in item['config']:
+        #             if config_item['key'] in config:
+        #                 config_item['value'] = config[config_item['key']]
+        #             else:
+        #                 if 'default' in config_item:
+        #                     config_item['value'] = config_item['default']
+        #                 else:
+        #                     config_item['value'] = ''
+
+    return translate_apis
+
+
+def privacy_translate_api_config(data_key, data):
+    # 如果 data 为空或者不是 dict
+    if not data or not isinstance(data, dict):
+        return data
+    # 如果 data_key 是 translate_api. 开头
+    api = None
+    if data_key == 'chatgpt_key':
+        api = 'openai'
+    else:
+        start = 'translate_api.'
+        if not data_key.startswith(start):
+            return data
+        api = data_key[len(start):]
+    apis = get_translate_apis()
+    find = False
+    for group in apis['apis']:
+        for item in group['children']:
+            if item['key'] == api:
+                find = item
+                break
+    if not find:
+        return data
+    api_item = find
+    if 'config' not in api_item or not api_item['config']:
+        return data
+
+    for config in api_item['config']:
+        # 如果有 privacy 的属性并且为 True
+        if 'privacy' in config and config['privacy'] and config['type'] == 'input':
+            if config['key'] in data:
+                # 前面6个字符可见，后面的字符用 * 替换
+                value = data[config['key']]
+                if len(value) > 6:
+                    value = value[:6] + '*' * (len(value) - 6)
+                data[config['key']] = value
+
+    return data
+
+def unprotected_translate_api_config(data_key, data):
+    api = None
+    if data_key == 'chatgpt_key':
+        api = 'openai'
+    else:
+        start = 'translate_api.'
+        if not data_key.startswith(start):
+            return data
+        api = data_key[len(start):]
+
+    apis = get_translate_apis()
+    find = False
+    for group in apis['apis']:
+        for item in group['children']:
+            if item['key'] == api:
+                find = item
+                break
+    if not find:
+        return data
+    api_item = find
+    if 'config' not in api_item or not api_item['config']:
+        return data
+
+    storage_data = st.get(data_key)
+
+    for config in api_item['config']:
+        # 如果有 privacy 的属性并且为 True
+        if 'privacy' in config and config['privacy'] and config['type'] == 'input':
+            if storage_data and config['key'] in storage_data:
+                if config['key'] in data:
+                    value = data[config['key']]
+                    # 如果包含 * 号，并且前面6个字符等于 storage_data 的前面6个字符
+                    if '*' in value and value[:6] == storage_data[config['key']][:6]:
+                        data[config['key']] = storage_data[config['key']]
+
+                    # 多个 * 替换成一个 *
+                    # value = re.sub(r'\*+', '*', value)
+                    # if value == '*' and storage_data and config['key'] in storage_data:
+                        # value = storage_data[config['key']]
+                        # data[config['key']] = value
+
+    return data

scripts/physton_prompt/get_version.py

@@ -0,0 +1,88 @@
+import os
+import re
+import requests
+import subprocess
+import hashlib
+
+
+def get_git_commit_version():
+    extension_dir = os.path.dirname(os.path.abspath(__file__)) + '/../../'
+    extension_dir = os.path.normpath(extension_dir)
+    git_path = os.path.join(extension_dir, '.git')
+    if os.path.exists(git_path):
+        try:
+            git = os.environ.get('GIT', "git")
+            if not git:
+                git = "git"
+            cmd = [git, 'rev-parse', 'HEAD']
+            commit_version = subprocess.check_output(cmd, cwd=extension_dir).decode('utf-8').strip()
+            if re.match(r'^[0-9a-f]{40}$', commit_version):
+                return commit_version
+        except Exception as e:
+            pass
+
+        try:
+            ref_path = os.path.join(git_path, 'refs', 'heads', 'main')
+            with open(ref_path, 'r') as f:
+                commit_version = f.read().strip()
+                if re.match(r'^[0-9a-f]{40}$', commit_version):
+                    return commit_version
+        except Exception as e:
+            pass
+
+    return ''
+
+
+def _handle_versions(response, filter_update_readme=False):
+    try:
+        if response.status_code != 200:
+            return []
+        result = response.json()
+        if not result:
+            return []
+        versions = []
+        for item in result:
+            message = item['commit']['message']
+            is_update_readme = False
+            if message.lower().strip() == 'update readme.md':
+                if filter_update_readme:
+                    continue
+                is_update_readme = True
+            versions.append({
+                'version': item['sha'],
+                'message': message,
+                'date': item['commit']['committer']['date'],
+                'is_update_readme': is_update_readme
+            })
+        return versions
+    except Exception as e:
+        return []
+
+
+def get_git_remote_versions(page=1, per_page=100, filter_update_readme=False):
+    api_urls = [
+        'https://api.github.com/repos/physton/sd-webui-prompt-all-in-one/commits',
+        'https://gitee.com/api/v5/repos/physton/sd-webui-prompt-all-in-one/commits'
+    ]
+
+    for api_url in api_urls:
+        try:
+            api_url += f'?page={page}&per_page={per_page}'
+            key = hashlib.md5(api_url.encode('utf-8')).hexdigest()
+            response = requests.get(api_url)
+            versions = _handle_versions(response, filter_update_readme)
+            return versions
+        except Exception as e:
+            pass
+
+    return []
+
+
+def get_latest_version():
+    current_version = get_git_commit_version()
+    # if not current_version:
+    # return current_version
+    versions = get_git_remote_versions(1, 10, False)
+    if len(versions) < 1:
+        return current_version
+    return versions[0]['version']

scripts/physton_prompt/history.py

@@ -0,0 +1,164 @@
+from scripts.physton_prompt.storage import Storage
+import uuid
+import time
+
+
+class History:
+    histories = {
+        'txt2img': [],
+        'txt2img_neg': [],
+        'img2img': [],
+        'img2img_neg': [],
+    }
+    favorites = {
+        'txt2img': [],
+        'txt2img_neg': [],
+        'img2img': [],
+        'img2img_neg': [],
+    }
+    max = 100
+    storage = Storage()
+
+    def __init__(self):
+        for type in self.histories:
+            self.histories[type] = self.storage.get('history.' + type)
+            if self.histories[type] is None:
+                self.histories[type] = []
+                self.__save_histories(type)
+
+        for type in self.favorites:
+            self.favorites[type] = self.storage.get('favorite.' + type)
+            if self.favorites[type] is None:
+                self.favorites[type] = []
+                self.__save_favorites(type)
+
+    def __save_histories(self, type):
+        self.storage.set('history.' + type, self.histories[type])
+
+    def __save_favorites(self, type):
+        self.storage.set('favorite.' + type, self.favorites[type])
+
+    def get_histories(self, type):
+        histories = self.histories[type]
+        for history in histories:
+            history['is_favorite'] = self.is_favorite(type, history['id'])
+        return histories
+
+    def is_favorite(self, type, id):
+        for favorite in self.favorites[type]:
+            if favorite['id'] == id:
+                return True
+        return False
+
+    def get_favorites(self, type):
+        return self.favorites[type]
+
+    def push_history(self, type, tags, prompt, name=''):
+        if len(self.histories[type]) >= self.max:
+            self.histories[type].pop(0)
+        item = {
+            'id': str(uuid.uuid1()),
+            'time': int(time.time()),
+            'name': name,
+            'tags': tags,
+            'prompt': prompt,
+        }
+        self.histories[type].append(item)
+        self.__save_histories(type)
+        return item
+
+    def push_favorite(self, type, tags, prompt, name=''):
+        item = {
+            'id': str(uuid.uuid1()),
+            'time': int(time.time()),
+            'name': name,
+            'tags': tags,
+            'prompt': prompt,
+        }
+        self.favorites[type].append(item)
+        self.__save_favorites(type)
+        return item
+
+    def get_latest_history(self, type):
+        if len(self.histories[type]) > 0:
+            return self.histories[type][-1]
+        return None
+
+    def set_history(self, type, id, tags, prompt, name):
+        for history in self.histories[type]:
+            if history['id'] == id:
+                history['tags'] = tags
+                history['prompt'] = prompt
+                history['name'] = name
+                self.__save_histories(type)
+                if self.is_favorite(type, id):
+                    self.set_favorite(type, id, tags, prompt, name)
+                return True
+        return False
+
+    def set_favorite(self, type, id, tags, prompt, name):
+        for favorite in self.favorites[type]:
+            if favorite['id'] == id:
+                favorite['tags'] = tags
+                favorite['prompt'] = prompt
+                favorite['name'] = name
+                self.__save_favorites(type)
+                return True
+        return False
+
+    def set_history_name(self, type, id, name):
+        for history in self.histories[type]:
+            if history['id'] == id:
+                history['name'] = name
+                self.__save_histories(type)
+                for favorite in self.favorites[type]:
+                    if favorite['id'] == id:
+                        favorite['name'] = name
+                        self.__save_favorites(type)
+                return True
+        return False
+
+    def set_favorite_name(self, type, id, name):
+        for favorite in self.favorites[type]:
+            if favorite['id'] == id:
+                favorite['name'] = name
+                self.__save_favorites(type)
+                for history in self.histories[type]:
+                    if history['id'] == id:
+                        history['name'] = name
+                        self.__save_histories(type)
+                return True
+        return False
+
+    def dofavorite(self, type, id):
+        if self.is_favorite(type, id):
+            return False
+        for history in self.histories[type]:
+            if history['id'] == id:
+                self.favorites[type].append(history)
+                self.__save_favorites(type)
+                return True
+        return False
+
+    def unfavorite(self, type, id):
+        if not self.is_favorite(type, id):
+            return False
+        for favorite in self.favorites[type]:
+            if favorite['id'] == id:
+                self.favorites[type].remove(favorite)
+                self.__save_favorites(type)
+                return True
+        return False
+
+    def remove_history(self, type, id):
+        for history in self.histories[type]:
+            if history['id'] == id:
+                self.histories[type].remove(history)
+                self.__save_histories(type)
+                return True
+        return False
+
+    def remove_histories(self, type):
+        self.histories[type] = []
+        self.__save_histories(type)
+        return True

scripts/physton_prompt/mbart50.py

@@ -0,0 +1,67 @@
+import os
+import time
+from scripts.physton_prompt.get_lang import get_lang
+
+model = None
+tokenizer = None
+model_name = "facebook/mbart-large-50-many-to-many-mmt"
+cache_dir = os.path.normpath(os.path.dirname(os.path.abspath(__file__)) + '/../../models')
+loading = False
+
+def initialize(reload=False):
+    global model, tokenizer, model_name, cache_dir, loading
+    if loading:
+        while not loading:
+            time.sleep(0.1)
+            pass
+        if model is None or tokenizer is None:
+            raise Exception('error')
+        # raise Exception(get_lang('model_is_loading'))
+        return
+    if not reload and model is not None:
+        return
+    loading = True
+    model = None
+    tokenizer = None
+
+    model_path = os.path.join(cache_dir, "mbart-large-50-many-to-many-mmt")
+    model_file = os.path.join(model_path, "pytorch_model.bin")
+    if os.path.exists(model_path) and os.path.exists(model_file):
+        model_name = model_path
+
+    try:
+        from transformers import MBart50TokenizerFast, MBartForConditionalGeneration
+        print(f'[sd-webui-prompt-all-in-one] Loading model {model_name} from {cache_dir}...')
+        model = MBartForConditionalGeneration.from_pretrained(model_name, cache_dir=cache_dir)
+        tokenizer = MBart50TokenizerFast.from_pretrained(model_name, cache_dir=cache_dir)
+        print(f'[sd-webui-prompt-all-in-one] Model {model_name} loaded.')
+        loading = False
+    except Exception as e:
+        loading = False
+        raise e
+
+def translate(text, src_lang, target_lang):
+    global model, tokenizer
+
+    if not text:
+        if isinstance(text, list):
+            return []
+        else:
+            return ''
+
+    if model is None:
+        raise Exception(get_lang('model_not_initialized'))
+
+    if tokenizer is None:
+        raise Exception(get_lang('model_not_initialized'))
+
+    if src_lang == target_lang:
+        return text
+
+    tokenizer.src_lang = src_lang
+    encoded_input = tokenizer(text, return_tensors="pt", padding=True)
+    generated_tokens = model.generate(
+        **encoded_input, forced_bos_token_id=tokenizer.lang_code_to_id[target_lang],
+        max_new_tokens=500
+    )
+    return tokenizer.batch_decode(generated_tokens, skip_special_tokens=True)

scripts/physton_prompt/packages.py

@@ -0,0 +1,49 @@
+import launch
+from scripts.physton_prompt.get_lang import get_lang
+
+packages = {
+    "chardet": "chardet",
+    "fastapi": "fastapi",
+    "execjs": "PyExecJS",
+    "lxml": "lxml",
+    "tqdm": "tqdm",
+    "pathos": "pathos",
+    "cryptography": "cryptography",
+
+    # The following packages are required for translation service. If you do not need translation service, you can remove them.
+    # 以下是翻译所需的包，如果不需要翻译服务，可以删除掉它们。
+    "openai": "openai",
+    "boto3": "boto3",
+    "aliyunsdkcore": "aliyun-python-sdk-core",
+    "aliyunsdkalimt": "aliyun-python-sdk-alimt",
+}
+
+
+def get_packages_state():
+    states = []
+    for package_name in packages:
+        package = packages[package_name]
+        item = {
+            'name': package_name,
+            'package': package,
+            'state': False
+        }
+        if launch.is_installed(package) or launch.is_installed(package_name):
+            item['state'] = True
+
+        states.append(item)
+
+    return states
+
+
+def install_package(name, package):
+    result = {'state': False, 'message': ''}
+    try:
+        launch.run_pip(f"install {package}", f"sd-webui-prompt-all-in-one: {name}")
+        result['state'] = True
+        result['message'] = get_lang('install_success', {'0': package})
+    except Exception as e:
+        print(e)
+        print(f'Warning: Failed to install {package}, some preprocessors may not work.')
+        result['message'] = get_lang('install_failed', {'0': package}) + '\n' + str(e)
+    return result

scripts/physton_prompt/storage.py

@@ -0,0 +1,177 @@
+import os
+from pathlib import Path
+import json
+import time
+
+
+class Storage:
+    storage_path = ''
+
+    def __init__(self):
+        pass
+
+    def __get_storage_path(self):
+        self.storage_path = os.path.dirname(os.path.abspath(__file__)) + '/../../storage'
+        self.storage_path = os.path.normpath(self.storage_path)
+        if not os.path.exists(self.storage_path):
+            os.makedirs(self.storage_path)
+
+        # old_storage_path = os.path.join(Path().absolute(), 'physton-prompt')
+        # if os.path.exists(old_storage_path):
+        #     # 复制就的存储文件到新的存储文件夹
+        #     for file in os.listdir(old_storage_path):
+        #         old_file_path = os.path.join(old_storage_path, file)
+        #         new_file_path = os.path.join(self.storage_path, file)
+        #         if not os.path.exists(new_file_path):
+        #             os.rename(old_file_path, new_file_path)
+        #     # 删除旧的存储文件夹
+        #     os.rmdir(old_storage_path)
+
+        return self.storage_path
+
+    def __get_data_filename(self, key):
+        return self.__get_storage_path() + '/' + key + '.json'
+
+    def __get_key_lock_filename(self, key):
+        return self.__get_storage_path() + '/' + key + '.lock'
+
+    def __lock(self, key):
+        file_path = self.__get_key_lock_filename(key)
+        with open(file_path, 'w') as f:
+            f.write('1')
+
+    def __unlock(self, key):
+        file_path = self.__get_key_lock_filename(key)
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
+    def __is_locked(self, key):
+        file_path = self.__get_key_lock_filename(key)
+        return os.path.exists(file_path)
+
+    def __get(self, key):
+        filename = self.__get_data_filename(key)
+        if not os.path.exists(filename):
+            return None
+        if os.path.getsize(filename) == 0:
+            return None
+        try:
+            import launch
+            if not launch.is_installed("chardet"):
+                with open(filename, 'r') as f:
+                    data = json.load(f)
+            else:
+                import chardet
+                with open(filename, 'rb') as f:
+                    data = f.read()
+                    encoding = chardet.detect(data).get('encoding')
+                    data = json.loads(data.decode(encoding))
+        except Exception as e:
+            try:
+                with open(filename, 'r') as f:
+                    data = json.load(f)
+            except Exception as e:
+                print(e)
+                return None
+        return data
+
+    def __set(self, key, data):
+        file_path = self.__get_data_filename(key)
+        with open(file_path, 'w') as f:
+            json.dump(data, f, indent=4, ensure_ascii=True)
+
+    def set(self, key, data):
+        while self.__is_locked(key):
+            time.sleep(0.01)
+        self.__lock(key)
+        try:
+            self.__set(key, data)
+            self.__unlock(key)
+        except Exception as e:
+            self.__unlock(key)
+            raise e
+
+    def get(self, key):
+        return self.__get(key)
+
+    def delete(self, key):
+        file_path = self.__get_data_filename(key)
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
+    def __get_list(self, key):
+        data = self.get(key)
+        if not data:
+            data = []
+        return data
+
+    # 向列表中添加元素
+    def list_push(self, key, item):
+        while self.__is_locked(key):
+            time.sleep(0.01)
+        self.__lock(key)
+        try:
+            data = self.__get_list(key)
+            data.append(item)
+            self.__set(key, data)
+            self.__unlock(key)
+        except Exception as e:
+            self.__unlock(key)
+            raise e
+
+    # 从列表中删除和返回最后一个元素
+    def list_pop(self, key):
+        while self.__is_locked(key):
+            time.sleep(0.01)
+        self.__lock(key)
+        try:
+            data = self.__get_list(key)
+            item = data.pop()
+            self.__set(key, data)
+            self.__unlock(key)
+            return item
+        except Exception as e:
+            self.__unlock(key)
+            raise e
+
+    # 从列表中删除和返回第一个元素
+    def list_shift(self, key):
+        while self.__is_locked(key):
+            time.sleep(0.01)
+        self.__lock(key)
+        try:
+            data = self.__get_list(key)
+            item = data.pop(0)
+            self.__set(key, data)
+            self.__unlock(key)
+            return item
+        except Exception as e:
+            self.__unlock(key)
+            raise e
+
+    # 从列表中删除指定元素
+    def list_remove(self, key, index):
+        while self.__is_locked(key):
+            time.sleep(0.01)
+        self.__lock(key)
+        data = self.__get_list(key)
+        data.pop(index)
+        self.__set(key, data)
+        self.__unlock(key)
+
+    # 获取列表中指定位置的元素
+    def list_get(self, key, index):
+        data = self.__get_list(key)
+        return data[index]
+
+    # 清空列表中的所有元素
+    def list_clear(self, key):
+        while self.__is_locked(key):
+            time.sleep(0.01)
+        self.__lock(key)
+        try:
+            self.__set(key, [])
+            self.__unlock(key)
+        except Exception as e:
+            self.__unlock(key)
+            raise e

scripts/physton_prompt/styles.py

@@ -0,0 +1,57 @@
+import os
+from scripts.physton_prompt.storage import Storage
+
+storage = Storage()
+
+styles_path = os.path.dirname(os.path.abspath(__file__)) + '/../../styles'
+styles_path = os.path.normpath(styles_path)
+
+
+def get_style_full_path(file):
+    global styles_path
+    return os.path.join(styles_path, file)
+
+
+def get_extension_css_list():
+    global styles_path
+    extension_path = os.path.join(styles_path, 'extensions')
+    if not os.path.exists(extension_path):
+        return []
+    css_list = []
+    # 扫描下面的每个文件夹
+    for dir in os.listdir(extension_path):
+        dir_path = os.path.join(extension_path, dir)
+        if not os.path.isdir(dir_path):
+            continue
+
+        # 是否有 manifest.json 文件
+        manifest_path = os.path.join(dir_path, 'manifest.json')
+        if not os.path.exists(manifest_path):
+            continue
+
+        # 是否有 style.min.css 文件
+        style_path = os.path.join(dir_path, 'style.min.css')
+        if not os.path.exists(style_path):
+            continue
+
+        manifest = None
+        try:
+            with open(manifest_path, 'r', encoding='utf8', errors='ignore') as f:
+                manifest = f.read()
+        except Exception as e:
+            print(f'读取 {manifest_path} 失败：{e}')
+            pass
+        if not manifest:
+            continue
+
+        css_item = {
+            'dir': dir,
+            'dataName': 'extensionSelect.' + dir,
+            'selected': False,
+            'manifest': manifest,
+            'style': f'extensions/{dir}/style.min.css',
+        }
+        css_item['selected'] = storage.get(css_item['dataName'])
+        css_list.append(css_item)
+
+    return css_list

scripts/physton_prompt/translate.py

@@ -0,0 +1,150 @@
+import json
+import hashlib
+from scripts.physton_prompt.get_lang import get_lang
+from scripts.physton_prompt.get_translate_apis import get_translate_apis, unprotected_translate_api_config
+from scripts.physton_prompt.translator.alibaba_translator import AlibabaTranslator
+from scripts.physton_prompt.translator.amazon_translator import AmazonTranslator
+from scripts.physton_prompt.translator.baidu_translator import BaiduTranslator
+from scripts.physton_prompt.translator.deepl_translator import DeeplTranslator
+from scripts.physton_prompt.translator.google_tanslator import GoogleTranslator
+from scripts.physton_prompt.translator.microsoft_translator import MicrosoftTranslator
+from scripts.physton_prompt.translator.openai_translator import OpenaiTranslator
+from scripts.physton_prompt.translator.tencent_translator import TencentTranslator
+from scripts.physton_prompt.translator.translators_translator import TranslatorsTranslator
+from scripts.physton_prompt.translator.yandex_translator import YandexTranslator
+from scripts.physton_prompt.translator.youdao_translator import YoudaoTranslator
+from scripts.physton_prompt.translator.mymemory_translator import MyMemoryTranslator
+from scripts.physton_prompt.translator.niutrans_translator import NiutransTranslator
+from scripts.physton_prompt.translator.caiyun_translator import CaiyunTranslator
+from scripts.physton_prompt.translator.volcengine_translator import VolcengineTranslator
+from scripts.physton_prompt.translator.iflytekV1_translator import IflytekV1Translator
+from scripts.physton_prompt.translator.iflytekV2_translator import IflytekV2Translator
+from scripts.physton_prompt.translator.mbart50_translator import MBart50Translator
+
+caches = {}
+
+
+def translate(text, from_lang, to_lang, api, api_config=None):
+    if api_config is None:
+        api_config = {}
+    global caches
+
+    def _translate_result(success, message, translated_text):
+        return {
+            "success": success,
+            "message": message,
+            "text": text,
+            "translated_text": translated_text,
+            "from_lang": from_lang,
+            "to_lang": to_lang,
+            "api": api
+        }
+
+    def _cache_name(text):
+        cache_name = f'{api}.{from_lang}.{to_lang}.{text}.' + json.dumps(api_config)
+        cache_name = hashlib.md5(cache_name.encode('utf-8')).hexdigest()
+        return cache_name
+
+    apis = get_translate_apis()
+    find = False
+    for group in apis['apis']:
+        for item in group['children']:
+            if item['key'] == api:
+                find = item
+                break
+    if not find:
+        return _translate_result(False, get_lang('translate_api_not_found'), '')
+
+    try:
+        texts = []
+        if isinstance(text, list):
+            if len(text) < 1:
+                return _translate_result(False, get_lang('translate_text_is_empty'), '')
+            for item in text:
+                texts.append(None)
+            for index in range(len(text)):
+                item = text[index]
+                item = item.strip()
+                if item == '':
+                    texts[index] = ''
+                    continue
+                cache_name = _cache_name(item)
+                if cache_name in caches:
+                    texts[index] = caches[cache_name]
+                else:
+                    texts[index] = None
+        else:
+            text = text.strip()
+            if text == '':
+                return _translate_result(False, get_lang('translate_text_is_empty'), '')
+            cache_name = _cache_name(text)
+            if cache_name in caches:
+                return _translate_result(True, '', caches[cache_name])
+
+        if api == 'google':
+            translator = GoogleTranslator()
+        elif api == 'microsoft':
+            translator = MicrosoftTranslator()
+        elif api == 'openai':
+            translator = OpenaiTranslator()
+        elif api == 'amazon':
+            translator = AmazonTranslator()
+        elif api == 'deepl':
+            translator = DeeplTranslator()
+        elif api == 'baidu':
+            translator = BaiduTranslator()
+        elif api == 'alibaba':
+            translator = AlibabaTranslator()
+        elif api == 'yandex':
+            translator = YandexTranslator()
+        elif api == 'youdao':
+            translator = YoudaoTranslator()
+        elif api == 'tencent':
+            translator = TencentTranslator()
+        elif api == 'myMemory_free' or api == 'myMemory':
+            translator = MyMemoryTranslator()
+        elif api == 'niutrans':
+            translator = NiutransTranslator()
+        elif api == 'caiyun':
+            translator = CaiyunTranslator()
+        elif api == 'volcengine':
+            translator = VolcengineTranslator()
+        elif api == 'iflytekV1':
+            translator = IflytekV1Translator()
+        elif api == 'iflytekV2':
+            translator = IflytekV2Translator()
+        elif api == 'mbart50':
+            translator = MBart50Translator()
+        elif 'type' in find and find['type'] == 'translators':
+            translator = TranslatorsTranslator(api)
+            translator.set_translator(find['translator'])
+        else:
+            return _translate_result(False, get_lang('translate_api_not_support'), '')
+
+        translator.set_from_lang(from_lang)
+        translator.set_to_lang(to_lang)
+        translator.set_api_config(unprotected_translate_api_config('translate_api.' + api, api_config))
+
+        if isinstance(text, list):
+            translate_texts = []
+            translate_indexes = []
+            for index in range(len(texts)):
+                item = texts[index]
+                if item is None:
+                    translate_indexes.append(index)
+                    translate_texts.append(text[index])
+            if len(translate_texts) < 1:
+                return _translate_result(True, '', texts)
+            result = translator.translate_batch(translate_texts)
+            for index in range(len(result)):
+                item = result[index]
+                texts[translate_indexes[index]] = item
+                caches[_cache_name(translate_texts[index])] = item
+            return _translate_result(True, '', texts)
+        else:
+            translated_text = translator.translate(text).strip()
+            caches[_cache_name(text)] = translated_text
+            return _translate_result(True, '', translated_text)
+    except Exception as e:
+        # print(e)
+        return _translate_result(False, str(e), '')

scripts/physton_prompt/translator/alibaba_translator.py

@@ -0,0 +1,95 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+import json
+from math import ceil
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class AlibabaTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('alibaba')
+
+    def _get_config(self):
+        access_key_id = self.api_config.get('access_key_id', '')
+        access_key_secret = self.api_config.get('access_key_secret', '')
+        region = self.api_config.get('region', 'cn-shanghai')
+        if not access_key_id:
+            raise Exception(get_lang('is_required', {'0': 'Access Key ID'}))
+        if not access_key_secret:
+            raise Exception(get_lang('is_required', {'0': 'Access Key Secret'}))
+        if not region:
+            raise Exception(get_lang('is_required', {'0': 'Region ID'}))
+        return access_key_id, access_key_secret, region
+
+    def translate(self, text):
+        if not text:
+            return ''
+        access_key_id, access_key_secret, region = self._get_config()
+        from aliyunsdkcore.client import AcsClient
+        from aliyunsdkalimt.request.v20181012 import TranslateRequest
+
+        client = AcsClient(access_key_id, access_key_secret, region)
+        request = TranslateRequest.TranslateRequest()
+        request.set_SourceLanguage(self.from_lang)
+        request.set_Scene("general")
+        request.set_SourceText(text)
+        request.set_FormatType("text")  # 翻译文本的格式
+        request.set_TargetLanguage(self.to_lang)
+        request.set_method("POST")
+        response = client.do_action_with_exception(request)
+        result = json.loads(response)
+        if 'Code' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'Alibaba'}))
+        if result['Code'] != '200':
+            raise Exception(result['Message'])
+        if 'Translated' not in result['Data']:
+            raise Exception(get_lang('no_response_from', {'0': 'Alibaba'}))
+        return result['Data']['Translated']
+
+    def translate_batch(self, texts):
+        if not texts:
+            return []
+        access_key_id, access_key_secret, region = self._get_config()
+        from aliyunsdkcore.client import AcsClient
+        from aliyunsdkalimt.request.v20181012 import GetBatchTranslateRequest
+
+        results = []
+
+        concurrent = self.get_concurrent()
+        texts_len = len(texts)
+        group_num = ceil(texts_len / concurrent)
+        for i in range(group_num):
+            start = i * concurrent
+            end = (i + 1) * concurrent
+            if end > texts_len:
+                end = texts_len
+            group_texts = texts[start:end]
+            source_texts = {}
+            dist_texts = {}
+            for i in range(len(group_texts)):
+                source_texts[str(i)] = group_texts[i]
+                dist_texts[str(i)] = ''
+
+            client = AcsClient(access_key_id, access_key_secret, region)
+            request = GetBatchTranslateRequest.GetBatchTranslateRequest()
+            request.set_SourceLanguage(self.from_lang)
+            request.set_Scene("general")
+            request.set_SourceText(source_texts)
+            request.set_FormatType("text")
+            request.set_TargetLanguage(self.to_lang)
+            request.set_ApiType("translate_standard")
+            request.set_method("POST")
+            response = client.do_action_with_exception(request)
+            result = json.loads(response)
+            if 'Code' not in result:
+                raise Exception(get_lang('no_response_from', {'0': 'Alibaba'}))
+            if result['Code'] != '200':
+                raise Exception(result['Message'])
+            for item in result['TranslatedList']:
+                index = item['index']
+                if item['code'] == '200':
+                    dist_texts[index] = item['translated']
+
+            for i in range(len(group_texts)):
+                results.append(dist_texts[str(i)])
+
+        return results

scripts/physton_prompt/translator/amazon_translator.py

@@ -0,0 +1,28 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class AmazonTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('amazon')
+
+    def translate(self, text):
+        if not text:
+            return ''
+        api_key_id = self.api_config.get('api_key_id', '')
+        api_key_secret = self.api_config.get('api_key_secret', '')
+        region = self.api_config.get('region', '')
+        if not api_key_id:
+            raise Exception(get_lang('is_required', {'0': 'API Key ID'}))
+        if not api_key_secret:
+            raise Exception(get_lang('is_required', {'0': 'API Key Secret'}))
+        if not region:
+            raise Exception(get_lang('is_required', {'0': 'Region'}))
+
+        import boto3
+        translate = boto3.client(service_name='translate', region_name=region, use_ssl=True,
+                                 aws_access_key_id=api_key_id, aws_secret_access_key=api_key_secret)
+        result = translate.translate_text(Text=text, SourceLanguageCode=self.from_lang, TargetLanguageCode=self.to_lang)
+        if 'TranslatedText' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'Amazon'}))
+        return result['TranslatedText']

scripts/physton_prompt/translator/baidu_translator.py

@@ -0,0 +1,55 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+import requests
+import hashlib
+import random
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class BaiduTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('baidu')
+
+    def translate(self, text):
+        if not text:
+            return ''
+        url = "https://fanyi-api.baidu.com/api/trans/vip/translate"
+        app_id = self.api_config.get('app_id', '')
+        app_secret = self.api_config.get('app_secret', '')
+        if not app_id:
+            raise Exception(get_lang('is_required', {'0': 'APP ID'}))
+        if not app_secret:
+            raise Exception(get_lang('is_required', {'0': 'APP Secret'}))
+        salt = random.randint(32768, 65536)
+        send_text = text
+        if isinstance(text, list):
+            send_text = '\n'.join(send_text)
+        sign = app_id + send_text + str(salt) + app_secret
+        sign = hashlib.md5(sign.encode()).hexdigest()
+        params = {
+            'q': send_text,
+            'from': self.from_lang,
+            'to': self.to_lang,
+            'appid': app_id,
+            'salt': salt,
+            'sign': sign
+        }
+        response = requests.get(url, params=params, timeout=10)
+        result = response.json()
+        if 'error_code' in result:
+            raise Exception(result['error_msg'])
+        if 'trans_result' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'Baidu'}))
+        translated_text = []
+        for item in result['trans_result']:
+            translated_text.append(item['dst'])
+        if isinstance(text, list):
+            return translated_text
+        else:
+            return '\n'.join(translated_text)
+
+    def translate_batch(self, texts):
+        if not texts:
+            return []
+        for text in texts:
+            text = text.replace('\n', ' ')
+        return self.translate(texts)

scripts/physton_prompt/translator/base_tanslator.py

@@ -0,0 +1,87 @@
+import time
+from abc import ABC, abstractmethod
+from concurrent.futures import ThreadPoolExecutor
+from math import ceil
+
+from scripts.physton_prompt.get_lang import get_lang
+from scripts.physton_prompt.get_translate_apis import get_translate_apis
+
+
+class BaseTranslator(ABC):
+    from_lang = None
+    to_lang = None
+    api = None
+    api_config = {}
+    api_item = {}
+
+    def __init__(self, api):
+        self.api = api
+        apis = get_translate_apis()
+        find = False
+        for group in apis['apis']:
+            for item in group['children']:
+                if item['key'] == api:
+                    find = item
+                    break
+        if not find:
+            raise Exception(get_lang('translate_api_not_support'))
+        self.api_item = find
+
+    def set_from_lang(self, from_lang):
+        from_lang = self.api_item['support'].get(from_lang, False)
+        if not from_lang:
+            raise Exception(get_lang('translate_language_not_support'))
+        self.from_lang = from_lang
+        return self
+
+    def set_to_lang(self, to_lang):
+        to_lang = self.api_item['support'].get(to_lang, False)
+        if not to_lang:
+            raise Exception(get_lang('translate_language_not_support'))
+        self.to_lang = to_lang
+        return self
+
+    def set_api_config(self, api_config):
+        self.api_config = api_config
+        return self
+
+    def get_concurrent(self):
+        concurrent = 1
+        if self.api_item.get('concurrent', False):
+            concurrent = self.api_item['concurrent']
+        return concurrent
+
+    @abstractmethod
+    def translate(self, text):
+        pass
+
+    def translate_batch(self, texts):
+        concurrent = self.get_concurrent()
+        texts_len = len(texts)
+        group_num = ceil(texts_len / concurrent)
+
+        # 分组并发翻译，每组完成后等待1秒，然后再进行下一组
+        results = []
+        with ThreadPoolExecutor(max_workers=concurrent) as executor:
+            for i in range(group_num):
+                group_texts = texts[i * concurrent: (i + 1) * concurrent]
+                texts_dict = {}
+                futures = []
+                for i in range(len(group_texts)):
+                    text = group_texts[i]
+                    texts_dict[str(i)] = ''
+                    future = executor.submit(self.translate, text)
+                    futures.append(future)
+
+                for i in range(len(futures)):
+                    future = futures[i]
+                    text_dict = texts_dict
+                    future.result()
+                    text_dict[str(i)] = future.result()
+
+                for i in range(len(texts_dict)):
+                    results.append(texts_dict[str(i)])
+
+                time.sleep(1)
+
+        return results

scripts/physton_prompt/translator/caiyun_translator.py

@@ -0,0 +1,40 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+import uuid
+import requests
+import json
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class CaiyunTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('caiyun')
+
+    def translate(self, text):
+        if not text:
+            return ''
+        url = 'http://api.interpreter.caiyunai.com/v1/translator'
+        token = self.api_config.get('token', '')
+        if not token:
+            raise Exception(get_lang('is_required', {'0': 'Token'}))
+
+        payload = {
+            "source": text,
+            "trans_type": f'{self.from_lang}2{self.to_lang}',
+            "request_id": str(uuid.uuid4()),
+            "detect": True,
+        }
+
+        headers = {
+            "content-type": "application/json",
+            "x-authorization": "token " + token,
+        }
+
+        response = requests.post(url, data=json.dumps(payload), headers=headers)
+        if not response.text:
+            raise Exception(get_lang('response_is_empty', {'0': 'caiyun'}))
+        result = response.json()
+        if 'message' in result:
+            raise Exception(result['message'])
+        if 'target' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'caiyun'}))
+        return result['target']

scripts/physton_prompt/translator/deepl_translator.py

@@ -0,0 +1,46 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+import requests
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class DeeplTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('deepl')
+
+    def translate(self, text):
+        if not text:
+            if isinstance(text, list):
+                return []
+            else:
+                return ''
+        url = 'https://api-free.deepl.com/v2/translate'
+        api_key = self.api_config.get('api_key', '')
+        if not api_key:
+            raise Exception(get_lang('is_required', {'0': 'API Key'}))
+        headers = {"Authorization": f"DeepL-Auth-Key {api_key}"}
+        data = {
+            'text': text,
+            'source_lang': self.from_lang,
+            'target_lang': self.to_lang
+        }
+
+        response = requests.post(url, headers=headers, data=data, timeout=10)
+        if response.status_code != 200:
+            raise Exception(get_lang('request_error', {'0': 'DeepL'}))
+        if not response.text:
+            raise Exception(get_lang('response_is_empty', {'0': 'DeepL'}))
+        result = response.json()
+        if 'message' in result:
+            raise Exception(result['message'])
+        if 'translations' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'DeepL'}))
+        if isinstance(text, list):
+            results = []
+            for item in result['translations']:
+                results.append(item['text'])
+            return results
+        else:
+            return result['translations'][0]['text']
+
+    def translate_batch(self, texts):
+        return self.translate(texts)

scripts/physton_prompt/translator/google_tanslator.py

@@ -0,0 +1,32 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+import requests
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class GoogleTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('google')
+
+    def translate(self, text):
+        if not text:
+            return ''
+        url = 'https://translation.googleapis.com/language/translate/v2/'
+        api_key = self.api_config.get('api_key', '')
+        if not api_key:
+            raise Exception(get_lang('is_required', {'0': 'API Key'}))
+        params = {
+            'key': api_key,
+            'q': text,
+            'source': self.from_lang,
+            'target': self.to_lang,
+            'format': 'text'
+        }
+        response = requests.get(url, params=params, timeout=10)
+        result = response.json()
+        if 'error' in result:
+            raise Exception(result['error']['message'])
+        if 'data' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'Google'}))
+        if 'translations' not in result['data']:
+            raise Exception(get_lang('no_response_from', {'0': 'Google'}))
+        return result['data']['translations'][0]['translatedText']

scripts/physton_prompt/translator/iflytekV1_translator.py

@@ -0,0 +1,113 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+import requests
+import datetime
+import hashlib
+import base64
+import hmac
+import json
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class IflytekV1Translator(BaseTranslator):
+    def __init__(self):
+        super().__init__('iflytekV1')
+
+    def translate(self, text):
+        if not text:
+            return ''
+        app_id = self.api_config.get('app_id', '')
+        if not app_id:
+            raise Exception(get_lang('is_required', {'0': 'APP ID'}))
+        api_secret = self.api_config.get('api_secret', '')
+        if not api_secret:
+            raise Exception(get_lang('is_required', {'0': 'API Secret'}))
+        api_key = self.api_config.get('api_key', '')
+        if not api_key:
+            raise Exception(get_lang('is_required', {'0': 'API Key'}))
+
+        response = translate(text, From=self.from_lang, To=self.to_lang, APPID=app_id, Secret=api_secret, APIKey=api_key)
+        if response.status_code != 200:
+            raise Exception(get_lang('request_error', {'0': 'iflytekV1'}))
+        if not response.text:
+            raise Exception(get_lang('response_is_empty', {'0': 'iflytekV1'}))
+        result = response.json()
+        if 'code' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'iflytekV1'}))
+        if result['code'] != 0:
+            raise Exception(result['message'])
+        return result['data']['result']['trans_result']['dst']
+
+
+def hashlib_256(res):
+    m = hashlib.sha256(bytes(res.encode(encoding='utf-8'))).digest()
+    result = "SHA-256=" + base64.b64encode(m).decode(encoding='utf-8')
+    return result
+
+def httpdate(dt):
+    """
+    Return a string representation of a date according to RFC 1123
+    (HTTP/1.1).
+
+    The supplied date must be in UTC.
+
+    """
+    weekday = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"][dt.weekday()]
+    month = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
+                "Oct", "Nov", "Dec"][dt.month - 1]
+    return "%s, %02d %s %04d %02d:%02d:%02d GMT" % (weekday, dt.day, month,
+                                                    dt.year, dt.hour, dt.minute, dt.second)
+
+def translate(Text, From, To, APPID, Secret, APIKey, Host="itrans.xfyun.cn"):
+    RequestUri = "/v2/its"
+    url="https://"+Host+RequestUri
+    HttpMethod = "POST"
+    Algorithm = "hmac-sha256"
+    HttpProto = "HTTP/1.1"
+
+    # 设置当前时间
+    curTime_utc = datetime.datetime.utcnow()
+    Date = httpdate(curTime_utc)
+    # 设置业务参数
+    # 语种列表参数值请参照接口文档：https://www.xfyun.cn/doc/nlp/xftrans/API.html
+    BusinessArgs={
+        "from":From,
+        "to": To,
+    }
+
+    content = str(base64.b64encode(Text.encode('utf-8')), 'utf-8')
+    postdata = {
+        "common": {"app_id": APPID},
+        "business": BusinessArgs,
+        "data": {
+            "text": content,
+        }
+    }
+    body = json.dumps(postdata)
+
+    digest = hashlib_256(body)
+    signatureStr = "host: " + Host + "\n"
+    signatureStr += "date: " + Date + "\n"
+    signatureStr += HttpMethod + " " + RequestUri \
+                    + " " + HttpProto + "\n"
+    signatureStr += "digest: " + digest
+    signature = hmac.new(bytes(Secret.encode(encoding='utf-8')),
+                            bytes(signatureStr.encode(encoding='utf-8')),
+                            digestmod=hashlib.sha256).digest()
+    sign = base64.b64encode(signature).decode(encoding='utf-8')
+
+    authHeader = 'api_key="%s", algorithm="%s", ' \
+                    'headers="host date request-line digest", ' \
+                    'signature="%s"' \
+                    % (APIKey, Algorithm, sign)
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "Method": "POST",
+        "Host": Host,
+        "Date": Date,
+        "Digest": digest,
+        "Authorization": authHeader
+    }
+
+    response = requests.post(url, data=body, headers=headers,timeout=60)
+    return response

scripts/physton_prompt/translator/iflytekV2_translator.py

@@ -0,0 +1,128 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+from datetime import datetime
+from wsgiref.handlers import format_date_time
+from time import mktime
+import hashlib
+import base64
+import hmac
+from urllib.parse import urlencode
+import json
+import requests
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class IflytekV2Translator(BaseTranslator):
+    def __init__(self):
+        super().__init__('iflytekV2')
+
+    def translate(self, text):
+        if not text:
+            return ''
+        app_id = self.api_config.get('app_id', '')
+        if not app_id:
+            raise Exception(get_lang('is_required', {'0': 'APP ID'}))
+        api_secret = self.api_config.get('api_secret', '')
+        if not api_secret:
+            raise Exception(get_lang('is_required', {'0': 'API Secret'}))
+        api_key = self.api_config.get('api_key', '')
+        if not api_key:
+            raise Exception(get_lang('is_required', {'0': 'API Key'}))
+
+        response = translate(text, From=self.from_lang, To=self.to_lang, APPId=app_id, APISecret=api_secret, APIKey=api_key)
+        if response.status_code != 200:
+            raise Exception(get_lang('request_error', {'0': 'iflytekV1'}))
+        if not response.text:
+            raise Exception(get_lang('response_is_empty', {'0': 'iflytekV1'}))
+        result = json.loads(response.content.decode())
+        if 'header' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'iflytekV1'}))
+        result = json.loads(response.content.decode())
+        if 'code' not in result['header']:
+            raise Exception(get_lang('no_response_from', {'0': 'iflytekV1'}))
+        if result['header']['code'] != 0:
+            raise Exception(result['header']['message'])
+        restul_decode = base64.b64decode(result['payload']['result']['text']).decode()
+        result_json = json.loads(restul_decode)
+        if 'trans_result' not in result_json:
+            raise Exception(get_lang('no_response_from', {'0': 'iflytekV1'}))
+        return result_json['trans_result']['dst']
+
+class Url:
+    def __init__(self, host, path, schema):
+        self.host = host
+        self.path = path
+        self.schema = schema
+        pass
+
+# calculate sha256 and encode to base64
+def sha256base64(data):
+    sha256 = hashlib.sha256()
+    sha256.update(data)
+    digest = base64.b64encode(sha256.digest()).decode(encoding='utf-8')
+    return digest
+
+def parse_url(requset_url):
+    stidx = requset_url.index("://")
+    host = requset_url[stidx + 3:]
+    schema = requset_url[:stidx + 3]
+    edidx = host.index("/")
+    if edidx <= 0:
+        raise Exception("invalid request url:" + requset_url)
+    path = host[edidx:]
+    host = host[:edidx]
+    u = Url(host, path, schema)
+    return u
+
+# build websocket auth request url
+def assemble_ws_auth_url(requset_url, method="POST", api_key="", api_secret=""):
+    u = parse_url(requset_url)
+    host = u.host
+    path = u.path
+    now = datetime.now()
+    date = format_date_time(mktime(now.timetuple()))
+    signature_origin = "host: {}\ndate: {}\n{} {} HTTP/1.1".format(host, date, method, path)
+    signature_sha = hmac.new(api_secret.encode('utf-8'), signature_origin.encode('utf-8'),
+                             digestmod=hashlib.sha256).digest()
+    signature_sha = base64.b64encode(signature_sha).decode(encoding='utf-8')
+    authorization_origin = "api_key=\"%s\", algorithm=\"%s\", headers=\"%s\", signature=\"%s\"" % (
+        api_key, "hmac-sha256", "host date request-line", signature_sha)
+    authorization = base64.b64encode(authorization_origin.encode('utf-8')).decode(encoding='utf-8')
+    values = {
+        "host": host,
+        "date": date,
+        "authorization": authorization
+    }
+
+    return requset_url + "?" + urlencode(values)
+
+def translate(Text, From, To, APPId, APISecret, APIKey, Host="itrans.xf-yun.com"):
+    RequestUri = "/v1/its"
+    url="https://"+Host+RequestUri
+
+    body = {
+        "header": {
+            "app_id": APPId,
+            "status": 3,
+        },
+        "parameter": {
+            "its": {
+                "from": From,
+                "to": To,
+                "result": {}
+            }
+        },
+        "payload": {
+            "input_data": {
+                "encoding": "utf8",
+                "status": 3,
+                "text": base64.b64encode(Text.encode("utf-8")).decode('utf-8')
+            }
+        }
+    }
+
+    request_url = assemble_ws_auth_url(url, "POST", APIKey, APISecret)
+
+    headers = {'content-type': "application/json", 'host': 'itrans.xf-yun.com', 'app_id': APPId}
+    # print(request_url)
+    response = requests.post(request_url, data=json.dumps(body), headers=headers)
+    return response

scripts/physton_prompt/translator/mbart50_translator.py

@@ -0,0 +1,27 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+from scripts.physton_prompt.get_lang import get_lang
+from scripts.physton_prompt.mbart50 import initialize as mbart50_initialize, translate as mbart50_translate
+
+
+class MBart50Translator(BaseTranslator):
+    def __init__(self):
+        super().__init__('mbart50')
+
+    def translate(self, text):
+        if not text:
+            if isinstance(text, list):
+                return []
+            else:
+                return ''
+
+        result = mbart50_translate(text=text, src_lang=self.from_lang, target_lang=self.to_lang)
+        if not result:
+            raise Exception(get_lang('response_is_empty', {'0': 'mbart50'}))
+
+        if isinstance(text, list):
+            return result
+        else:
+            return result[0]
+
+    def translate_batch(self, texts):
+        return self.translate(texts)

scripts/physton_prompt/translator/microsoft_translator.py

@@ -0,0 +1,56 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+import uuid
+import requests
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class MicrosoftTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('microsoft')
+
+    def translate(self, text):
+        if not text:
+            if isinstance(text, list):
+                return []
+            else:
+                return ''
+        url = 'https://api.cognitive.microsofttranslator.com/translate'
+        api_key = self.api_config.get('api_key', '')
+        region = self.api_config.get('region', '')
+        if not api_key:
+            raise Exception(get_lang('is_required', {'0': 'API Key'}))
+        if not region:
+            raise Exception(get_lang('is_required', {'0': 'Region'}))
+        params = {
+            'api-version': '3.0',
+            'from': self.from_lang,
+            'to': self.to_lang
+        }
+        headers = {
+            'Ocp-Apim-Subscription-Key': api_key,
+            'Ocp-Apim-Subscription-Region': region,
+            'Content-type': 'application/json',
+            'X-ClientTraceId': str(uuid.uuid4())
+        }
+
+        body = []
+        if isinstance(text, list):
+            for item in text:
+                body.append({'text': item})
+        else:
+            body.append({'text': text})
+
+        response = requests.post(url, params=params, headers=headers, json=body, timeout=10)
+        result = response.json()
+        if 'error' in result:
+            raise Exception(result['error']['message'])
+        if len(result) == 0:
+            raise Exception(get_lang('no_response_from', {'0': 'Microsoft'}))
+
+        if isinstance(text, list):
+            return [item['translations'][0]['text'] for item in result]
+        else:
+            return result[0]['translations'][0]['text']
+
+    def translate_batch(self, texts):
+        return self.translate(texts)

scripts/physton_prompt/translator/mymemory_translator.py

@@ -0,0 +1,37 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+import uuid
+import requests
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class MyMemoryTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('myMemory_free')
+
+    def translate(self, text):
+        if not text:
+            return ''
+        url = 'https://api.mymemory.translated.net/get'
+        api_key = self.api_config.get('api_key', '')
+        params = {
+            'q': text,
+            'langpair': f'{self.from_lang}|{self.to_lang}',
+        }
+        if api_key:
+            params['key'] = api_key
+
+        response = requests.get(url, params=params)
+        if response.status_code != 200:
+            raise Exception(get_lang('request_error', {'0': 'myMemory'}))
+        if not response.text:
+            raise Exception(get_lang('response_is_empty', {'0': 'myMemory'}))
+        result = response.json()
+        if 'responseStatus' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'myMemory'}))
+        if result['responseStatus'] != 200:
+            raise Exception(result['responseDetails'])
+        if 'responseData' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'myMemory'}))
+        if 'translatedText' not in result['responseData']:
+            raise Exception(get_lang('no_response_from', {'0': 'myMemory'}))
+        return result['responseData']['translatedText']

scripts/physton_prompt/translator/niutrans_translator.py

@@ -0,0 +1,35 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+import uuid
+import requests
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class NiutransTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('niutrans')
+
+    def translate(self, text):
+        if not text:
+            return ''
+        url = 'https://api.niutrans.com/NiuTransServer/translation'
+        api_key = self.api_config.get('api_key', '')
+        if not api_key:
+            raise Exception(get_lang('is_required', {'0': 'API Key'}))
+        data = {
+            'from': self.from_lang,
+            'to': self.to_lang,
+            'apikey': api_key,
+            'src_text': text,
+        }
+
+        response = requests.post(url, data=data)
+        if response.status_code != 200:
+            raise Exception(get_lang('request_error', {'0': 'niutrans'}))
+        if not response.text:
+            raise Exception(get_lang('response_is_empty', {'0': 'niutrans'}))
+        result = response.json()
+        if 'error_msg' in result:
+            raise Exception(result['error_msg'])
+        if 'tgt_text' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'niutrans'}))
+        return result['tgt_text']

scripts/physton_prompt/translator/openai_translator.py

@@ -0,0 +1,60 @@
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+import json
+from scripts.physton_prompt.get_lang import get_lang
+
+
+class OpenaiTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('openai')
+
+    def translate(self, text):
+        if not text:
+            if isinstance(text, list):
+                return []
+            else:
+                return ''
+        import openai
+        openai.api_base = self.api_config.get('api_base', 'https://api.openai.com/v1')
+        openai.api_key = self.api_config.get('api_key', '')
+        model = self.api_config.get('model', 'gpt-3.5-turbo')
+        if not openai.api_key:
+            raise Exception(get_lang('is_required', {'0': 'API Key'}))
+
+        body = []
+        if isinstance(text, list):
+            for item in text:
+                body.append({'text': item})
+        else:
+            body.append({'text': text})
+
+        body_str = json.dumps(body, ensure_ascii=False)
+
+        messages = [
+            {"role": "system", "content": "You are a translator assistant."},
+            {
+                "role": "user",
+                "content": f"You are a translator assistant. Please translate the following JSON data {self.to_lang}. Preserve the original format. Only return the translation result, without any additional content or annotations. If the prompt word is in the target language, please send it to me unchanged:\n{body_str}"
+            },
+        ]
+        completion = openai.ChatCompletion.create(model=model, messages=messages, timeout=60)
+        if len(completion.choices) == 0:
+            raise Exception(get_lang('no_response_from', {'0': 'OpenAI'}))
+        content = completion.choices[0].message.content
+        try:
+            # 找到第一个[，然后找到最后一个]，截取中间的内容
+            start = content.index('[')
+            end = content.rindex(']')
+            if start == -1 or end == -1:
+                raise Exception(get_lang('response_error', {'0': 'OpenAI'}))
+            result_json = '[' + content[start + 1:end] + ']'
+            # 解析json
+            result = json.loads(result_json)
+            if isinstance(text, list):
+                return [item['text'] for item in result]
+            else:
+                return result[0]['text']
+        except Exception as e:
+            raise Exception(get_lang('response_error', {'0': 'OpenAI'}))
+
+    def translate_batch(self, texts):
+        return self.translate(texts)

scripts/physton_prompt/translator/tencent_translator.py

@@ -0,0 +1,128 @@
+import hashlib
+import hmac
+import json
+import time
+from datetime import datetime
+
+import requests
+
+from scripts.physton_prompt.get_lang import get_lang
+from scripts.physton_prompt.translator.base_tanslator import BaseTranslator
+
+
+class TencentTranslator(BaseTranslator):
+    def __init__(self):
+        super().__init__('tencent')
+
+    def _get_config(self):
+        secret_id = self.api_config.get('secret_id', '')
+        secret_key = self.api_config.get('secret_key', '')
+        region = self.api_config.get('region', 'ap-shanghai')
+        if not secret_id:
+            raise Exception(get_lang('is_required', {'0': 'Secret ID'}))
+        if not secret_key:
+            raise Exception(get_lang('is_required', {'0': 'Secret Key'}))
+        if not region:
+            raise Exception(get_lang('is_required', {'0': 'Region'}))
+        return secret_id, secret_key, region
+
+    def translate(self, text):
+        if not text:
+            return ''
+        secret_id, secret_key, region = self._get_config()
+        params = {
+            'SourceText': text,
+            'Source': self.from_lang,
+            'Target': self.to_lang,
+            'ProjectId': 0
+        }
+        res = sign_tencent(secret_id, secret_key, region, params)
+        response = requests.post(res['url'], json=params, timeout=10, headers=res['headers'])
+        result = response.json()
+        if 'Response' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'Tencent'}))
+        if 'TargetText' not in result['Response']:
+            raise Exception(get_lang('no_response_from', {'0': 'Tencent'}))
+        return result['Response']['TargetText']
+
+    def translate_batch(self, texts):
+        if not texts:
+            return []
+        secret_id, secret_key, region = self._get_config()
+        params = {
+            'SourceTextList': texts,
+            'Source': self.from_lang,
+            'Target': self.to_lang,
+            'ProjectId': 0
+        }
+        res = sign_tencent(secret_id, secret_key, region, params, 'TextTranslateBatch')
+        response = requests.post(res['url'], json=params, timeout=10, headers=res['headers'])
+        result = response.json()
+        if 'Response' not in result:
+            raise Exception(get_lang('no_response_from', {'0': 'Tencent'}))
+        if 'TargetTextList' not in result['Response']:
+            raise Exception(get_lang('no_response_from', {'0': 'Tencent'}))
+        return result['Response']['TargetTextList']
+
+
+def sign_tencent(secret_id, secret_key, regin, params, action="TextTranslate", version="2018-03-21"):
+    host = 'tmt.tencentcloudapi.com'
+    endpoint = "https://" + host
+
+    service = "tmt"
+    algorithm = "TC3-HMAC-SHA256"
+    timestamp = int(time.time())
+    date = datetime.utcfromtimestamp(timestamp).strftime("%Y-%m-%d")
+
+    # ************* 步骤 1：拼接规范请求串 *************
+    http_request_method = "POST"
+    canonical_uri = "/"
+    canonical_querystring = ""
+    ct = "application/json; charset=utf-8"
+    payload = json.dumps(params)
+    canonical_headers = "content-type:%s\nhost:%s\nx-tc-action:%s\n" % (ct, host, action.lower())
+    signed_headers = "content-type;host;x-tc-action"
+    hashed_request_payload = hashlib.sha256(payload.encode("utf-8")).hexdigest()
+    canonical_request = (http_request_method + "\n" +
+                         canonical_uri + "\n" +
+                         canonical_querystring + "\n" +
+                         canonical_headers + "\n" +
+                         signed_headers + "\n" +
+                         hashed_request_payload)
+
+    # ************* 步骤 2：拼接待签名字符串 *************
+    credential_scope = date + "/" + service + "/" + "tc3_request"
+    hashed_canonical_request = hashlib.sha256(canonical_request.encode("utf-8")).hexdigest()
+    string_to_sign = (algorithm + "\n" +
+                      str(timestamp) + "\n" +
+                      credential_scope + "\n" +
+                      hashed_canonical_request)
+
+    # ************* 步骤 3：计算签名 *************
+    # 计算签名摘要函数
+    def sign(key, msg):
+        return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()
+
+    secret_date = sign(("TC3" + secret_key).encode("utf-8"), date)
+    secret_service = sign(secret_date, service)
+    secret_signing = sign(secret_service, "tc3_request")
+    signature = hmac.new(secret_signing, string_to_sign.encode("utf-8"), hashlib.sha256).hexdigest()
+
+    # ************* 步骤 4：拼接 Authorization *************
+    authorization = (algorithm + " " +
+                     "Credential=" + secret_id + "/" + credential_scope + ", " +
+                     "SignedHeaders=" + signed_headers + ", " +
+                     "Signature=" + signature)
+
+    return {
+        "url": endpoint,
+        "headers": {
+            "Authorization": authorization,
+            "Content-Type": ct,
+            "Host": host,
+            "X-TC-Action": action,
+            "X-TC-Timestamp": str(timestamp),
+            "X-TC-Version": version,
+            "X-TC-Region": regin,
+        },
+    }