sync ms

.gitignore

@@ -1,2 +1,3 @@
+*.gif
+test.*
 *__pycache__*
-test.*

app.py

@@ -1,42 +1,64 @@
-import gradio as gr
-from data import data_converter
-from exif import clexif
-from gif import video2gif
-from github import github_release_creator
-from qr import qrcode
-from rct import rct_generator
-from smtp import smtp_tester
-from trans import translator
-from url import url_shortner
-
-if __name__ == "__main__":
-    with gr.Blocks() as demo:
-        gr.Markdown("# Online Tools Collection")
-        with gr.Tab("Data Converter"):
-            data_converter()
-
-        with gr.Tab("Image EXIF Cleaner"):
-            clexif()
-
-        with gr.Tab("Video to GIF"):
-            video2gif()
-
-        with gr.Tab("GitHub Releaser"):
-            github_release_creator()
-
-        with gr.Tab("QR Code"):
-            qrcode()
-
-        with gr.Tab("RCT Generator"):
-            rct_generator()
-
-        with gr.Tab("SMTP Test"):
-            smtp_tester()
-
-        with gr.Tab("Translator"):
-            translator()
-
-        with gr.Tab("URL Shortner"):
-            url_shortner()
-
-    demo.launch()
+import gradio as gr
+from modules.data import data_converter
+from modules.exif import clexif
+from modules.gif import video2gif
+from modules.github import github_release_creator
+from modules.qr import qrcode
+from modules.rct import rct_generator
+from modules.smtp import smtp_tester
+from modules.trans import translator
+from modules.url import url_shortner
+from utils import LANG
+
+ZH2EN = {
+    "# 在线工具合集": "# Online Tools Collection",
+    "数据文件转换": "Data Converter",
+    "图片 EXIF 清理": "Image EXIF Cleaner",
+    "视频转 GIF 动图": "Video to GIF",
+    "GitHub 发布工具": "GitHub Releaser",
+    "二维码生成": "QR Code",
+    "随机对照试验生成": "RCT Generator",
+    "SMTP 测试": "SMTP Test",
+    "翻译器": "Translator",
+    "短链接生成": "URL Shortner",
+}
+
+
+def _L(zh_txt: str):
+    if LANG:
+        return ZH2EN[zh_txt]
+    else:
+        return zh_txt
+
+
+if __name__ == "__main__":
+    with gr.Blocks() as demo:
+        gr.Markdown(_L("# 在线工具合集"))
+        with gr.Tab(_L("数据文件转换")):
+            data_converter()
+
+        with gr.Tab(_L("图片 EXIF 清理")):
+            clexif()
+
+        with gr.Tab(_L("视频转 GIF 动图")):
+            video2gif()
+
+        with gr.Tab(_L("GitHub 发布工具")):
+            github_release_creator()
+
+        with gr.Tab(_L("二维码生成")):
+            qrcode()
+
+        with gr.Tab(_L("随机对照试验生成")):
+            rct_generator()
+
+        with gr.Tab(_L("SMTP 测试")):
+            smtp_tester()
+
+        with gr.Tab(_L("翻译器")):
+            translator()
+
+        with gr.Tab(_L("短链接生成")):
+            url_shortner()
+
+    demo.launch()

config.py

@@ -1,13 +0,0 @@
-import os
-
-TMP_DIR = "./__pycache__"
-
-TAB_CONFIG = ["jsonl ⇆ csv", "json ⇆ csv", "json ⇆ jsonl"]
-MODE = {"from": "jsonl", "to": "csv"}
-HEADER = {
-    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 Edg/132.0.0.0",
-}
-
-API_SMTP = os.getenv("api_smtp")
-API_TRANS = os.getenv("api_caiyun")
-KEY_TRANS = os.getenv("apikey_caiyun")

data.py → modules/data.py

@@ -1,18 +1,29 @@
-import os
 import csv
 import json
-import shutil
 import gradio as gr
 import pandas as pd
-from config import TMP_DIR, TAB_CONFIG, MODE
-
-
-def clean_cache(dir_path=TMP_DIR):
-    if os.path.exists(dir_path):
-        shutil.rmtree(dir_path)
-
-    if not os.path.exists(dir_path):
-        os.makedirs(dir_path)
+from utils import clean_dir, TMP_DIR, LANG
+
+
+MODE = {"from": "jsonl", "to": "csv"}
+ZH2EN = {
+    "模式": "Mode",
+    "上传原数据": "Upload input file",
+    "转换": "Convert",
+    "下载转换数据": "Download output file",
+    "数据预览": "Data viewer",
+    "支持的 JSON 格式": "Supported JSON format",
+    "支持的 JSON Lines 格式": "Supported jsonl format",
+    "支持的 CSV 格式": "Supported CSV format",
+    "状态栏": "Status",
+}
+
+
+def _L(zh_txt: str):
+    if LANG:
+        return ZH2EN[zh_txt]
+    else:
+        return zh_txt
 
 
 def encoder_json(file_path: str):
@@ -26,6 +37,7 @@ def encoder_jsonl(file_path: str):
     data_list = []
     with open(file_path, "r", encoding="utf-8") as file:
         for line in file:
+            # 加载每一行的 JSON 数据
             json_data = json.loads(line.strip())
             data_list.append(json_data)
 
@@ -34,45 +46,55 @@ def encoder_jsonl(file_path: str):
 
 def encoder_csv(file_path: str):
     data_list = []
-    with open(file_path, "r", encoding="utf-8") as file:
-        csv_reader = csv.DictReader(file)
-        for row in csv_reader:
-            data_list.append(dict(row))
+    try:
+        with open(file_path, "r", encoding="utf-8") as file:
+            csv_reader = csv.DictReader(file)
+            for row in csv_reader:
+                data_list.append(dict(row))
+
+    except UnicodeDecodeError:
+        with open(file_path, "r", encoding="GBK") as file:
+            csv_reader = csv.DictReader(file)
+            for row in csv_reader:
+                data_list.append(dict(row))
 
     return data_list
 
 
-def decoder_json(data_list: list, file_path=f"{TMP_DIR}/output.json"):
+def decoder_json(data_list: list, file_path: str):
     if data_list:
         with open(file_path, "w", encoding="utf-8") as file:
+            # 将整个列表转换成 JSON 格式并写入文件
             json.dump(data_list, file, ensure_ascii=False, indent=4)
 
     return file_path
 
 
-def decoder_csv(data_list: list, file_path=f"{TMP_DIR}/output.csv"):
-    if data_list:
+def decoder_csv(data_list: list, file_path: str):
+    if data_list:  # 提取第一个字典的键作为表头
         header = list(data_list[0].keys())
         with open(file_path, "w", newline="", encoding="utf-8") as file:
-            csv_writer = csv.writer(file)
-            csv_writer.writerow(header)
+            csv_writer = csv.writer(file)  # 写入表头
+            csv_writer.writerow(header)  # 逐项写入字典的值
             for item in data_list:
                 csv_writer.writerow([item[key] for key in header])
 
     return file_path
 
 
-def decoder_jsonl(data_list: list, file_path=f"{TMP_DIR}/output.jsonl"):
+def decoder_jsonl(data_list: list, file_path: str):
     if data_list:
         with open(file_path, "w", encoding="utf-8") as file:
             for data in data_list:
+                # 将每个 JSON 对象转换成字符串并写入文件，每行一个对象
                 json_line = json.dumps(data, ensure_ascii=False)
-                file.write(json_line + "\n")
+                file.write(f"{json_line}\n")
 
     return file_path
 
 
 def change_mode(input: str):
+    global MODE
     affix = input.split(" ")
     if affix[1] == "→":
         MODE["from"] = affix[0]
@@ -83,20 +105,27 @@ def change_mode(input: str):
         MODE["to"] = affix[0]
 
 
-def infer(input_file: str):
-    clean_cache()
+# outer func
+def infer(input_file: str, cache=f"{TMP_DIR}/data"):
+    status = "Success"
+    output_file = previews = None
     try:
-        data_list = eval(f'encoder_{MODE["from"]}')(input_file)
-        output_file = eval(f'decoder_{MODE["to"]}')(data_list)
-        return output_file, pd.DataFrame(data_list)
+        clean_dir(cache)
+        src_fmt = MODE["from"]
+        dst_fmt = MODE["to"]
+        data_list = eval(f"encoder_{src_fmt}")(input_file)
+        output_file = eval(f"decoder_{dst_fmt}")(data_list, f"{cache}/output.{dst_fmt}")
+        previews = pd.DataFrame(data_list)
 
     except Exception as e:
-        return None, pd.DataFrame([{"Please upload a standard data file": f"{e}"}])
+        status = f"{e}"
+
+    return status, output_file, previews
 
 
-def data_converter():
+def data_converter(tab_cfgs=["jsonl ⇆ csv", "json ⇆ csv", "json ⇆ jsonl"]):
     with gr.Blocks() as data:
-        for item in TAB_CONFIG:
+        for item in tab_cfgs:
             types = item.split(" ⇆ ")
             with gr.Tab(item) as tab:
                 with gr.Row():
@@ -106,55 +135,57 @@ def data_converter():
                                 f"{types[0]} → {types[1]}",
                                 f"{types[0]} ← {types[1]}",
                             ],
-                            label="Mode",
+                            label=_L("模式"),
                             value=f"{types[0]} → {types[1]}",
                         )
-                        input_file = gr.components.File(
+                        input_file = gr.File(
                             type="filepath",
-                            label="Upload input file",
+                            label=_L("上传原数据"),
                             file_types=[f".{types[0]}", f".{types[1]}"],
                         )
-                        convert_btn = gr.Button("Convert")
+                        convert_btn = gr.Button(_L("转换"))
 
                     with gr.Column():
-                        output_file = gr.components.File(
-                            type="filepath", label="Download output file"
+                        status_bar = gr.Textbox(
+                            label=_L("状态栏"),
+                            show_copy_button=True,
                         )
-                        data_viewer = gr.Dataframe(label="Data viewer")
+                        output_file = gr.File(type="filepath", label=_L("下载转换数据"))
+                        data_viewer = gr.Dataframe(label=_L("数据预览"))
 
             option.change(change_mode, inputs=option)
             tab.select(change_mode, inputs=option)
             convert_btn.click(
                 infer,
                 inputs=input_file,
-                outputs=[output_file, data_viewer],
+                outputs=[status_bar, output_file, data_viewer],
             )
 
         gr.Markdown(
-            """
-## Supported JSON format
+            f"""
+## {_L('支持的 JSON 格式')}
 ```
 [
-    {
+    {{
         "key1": "val11",
         "key2": "val12",
         ...
-    },
-    {
+    }},
+    {{
         "key1": "val21",
         "key2": "val22",
         ...
-    },
+    }},
     ...
 ]
 ```
-## Supported jsonl format
+## {_L('支持的 JSON Lines 格式')}
 ```
-{"key1": "val11", "key2": "val12", ...}
-{"key1": "val21", "key2": "val22", ...}
+{{"key1": "val11", "key2": "val12", ...}}
+{{"key1": "val21", "key2": "val22", ...}}
 ...
 ```             
-## Supported CSV format
+## {_L('支持的 CSV 格式')}
 ```
 key1, key2, ...
 val11, val12, ...

exif.py → modules/exif.py

@@ -1,16 +1,35 @@
 import os
 import imghdr
-import shutil
 import hashlib
-import zipfile
 import exifread
 import gradio as gr
 import pandas as pd
 from PIL import Image
-from config import TMP_DIR
-
-
-def get_exif_data(origin_file_path):
+from utils import clean_dir, compress, mk_dir, unzip, TMP_DIR, LANG
+
+ZH2EN = {
+    "单图片处理": "Process single picture",
+    "上传图片": "Upload picture",
+    "导出原格式": "Export original format",
+    "下载清理 EXIF 后的图片": "Download cleaned picture",
+    "批量处理": "Batch processor",
+    "上传包含多图片的 zip 压缩包": "Upload pictures zip",
+    "导出原格式": "Export original format",
+    "下载清理 EXIF 后的多图片压缩包": "Download cleaned pictures",
+    "EXIF 列表": "EXIF list",
+    "上传包含多图片的 zip 压缩包时确保上传进度至 100% 后再提交": "When uploading pictures zip, please make sure the zip is completely uploaded before clicking Submit",
+    "状态栏": "Status",
+}
+
+
+def _L(zh_txt: str):
+    if LANG:
+        return ZH2EN[zh_txt]
+    else:
+        return zh_txt
+
+
+def get_exif(origin_file_path):
     with open(origin_file_path, "rb") as image_file:
         tags = exifread.process_file(image_file)
 
@@ -22,112 +41,91 @@ def get_exif_data(origin_file_path):
     return output
 
 
-def clear_exif_data(image_path: str, img_mode=None, outdir=""):
-    save_path = f"{TMP_DIR}/{outdir}output." + image_path.split(".")[-1]
-    try:
-        img = Image.open(image_path)
-        data = list(img.getdata())
-        if img_mode:
-            save_path = (
-                f"{TMP_DIR}/{outdir}{hashlib.md5(image_path.encode()).hexdigest()}.jpg"
-            )
-        else:
-            img_mode = img.mode
-
-        img_without_exif = Image.new(img_mode, img.size)
-        img_without_exif.putdata(data)
-        img_without_exif.save(save_path)
-
-    except Exception as e:
-        print(f"\n{image_path} Error: {e}")
+def clear_exif(img_path: str, cache: str, img_mode=None, outdir=""):
+    save_path = f"{cache}/{outdir}output." + img_path.split(".")[-1]
+    img = Image.open(img_path)
+    data = list(img.getdata())
+    if img_mode:
+        save_path = f"{cache}/{outdir}{hashlib.md5(img_path.encode()).hexdigest()}.jpg"
+    else:
+        img_mode = img.mode
 
+    img_without_exif = Image.new(img_mode, img.size)
+    img_without_exif.putdata(data)
+    img_without_exif.save(save_path)
     return save_path
 
 
-def unzip_file(zip_path: str, extract_to=f"{TMP_DIR}/inputs"):
-    if not os.path.exists(extract_to):
-        os.makedirs(extract_to)
-
-    # 打开ZIP文件
-    with zipfile.ZipFile(zip_path, "r") as zip_ref:
-        # 解压文件
-        zip_ref.extractall(extract_to)
-
-    return extract_to
-
-
-def find_files(directory: str):
-    found_files = []
-    for root, _, files in os.walk(directory):
+def find_images(dir_path: str):
+    found_images = []
+    for root, _, files in os.walk(dir_path):
         for file in files:
             fpath = os.path.join(root, file).replace("\\", "/")
             if imghdr.what(fpath) != None:
-                found_files.append(fpath)
-
-    return found_files
-
-
-def compress(folder_path=f"{TMP_DIR}/outputs", zip_file_path=f"{TMP_DIR}/outputs.zip"):
-    if not os.path.exists(folder_path):
-        print(f"Error: Folder '{folder_path}' does not exist.")
-        return
-
-    with zipfile.ZipFile(zip_file_path, "w", zipfile.ZIP_DEFLATED) as zipf:
-        for root, _, files in os.walk(folder_path):
-            for file in files:
-                file_path = os.path.join(root, file)
-                relative_path = os.path.relpath(file_path, folder_path)
-                zipf.write(
-                    file_path,
-                    arcname=os.path.join(os.path.basename(folder_path), relative_path),
-                )
+                found_images.append(fpath)
 
-    return zip_file_path
+    return found_images
 
 
-def infer(image_path: str, original_ext: bool):
-    if not image_path or imghdr.what(image_path) == None:
-        return None, "Please input a picture!"
-
-    if os.path.exists(TMP_DIR):
-        shutil.rmtree(TMP_DIR)
+# outer func
+def infer(img_path: str, keep_ext: bool, cache=f"{TMP_DIR}/exif"):
+    status = "Success"
+    out_img = out_exif = None
+    try:
+        if not img_path or imghdr.what(img_path) == None:
+            raise ValueError("请输入图片！")
 
-    os.makedirs(TMP_DIR, exist_ok=True)
-    return clear_exif_data(
-        image_path, img_mode="RGB" if not original_ext else None
-    ), get_exif_data(image_path)
+        clean_dir(cache)
+        img_mode = "RGB" if not keep_ext else None
+        out_img = clear_exif(img_path, cache, img_mode)
+        out_exif = get_exif(img_path)
 
+    except Exception as e:
+        status = f"{e}"
 
-def batch_infer(imgs_zip: str, original_ext: bool):
-    if not imgs_zip:
-        return None, pd.DataFrame([{"Warning": "Please upload pictures zip!"}])
+    return status, out_img, out_exif
 
-    if os.path.exists(TMP_DIR):
-        shutil.rmtree(TMP_DIR)
 
-    os.makedirs(f"{TMP_DIR}/outputs", exist_ok=True)
-    extract_to = unzip_file(imgs_zip)
-    imgs = find_files(extract_to)
-    mode = "RGB" if not original_ext else None
-    exifs = []
-    for img in imgs:
-        clear_exif_data(img, img_mode=mode, outdir="outputs/")
-        exifs.append({"filename": os.path.basename(img), "exif": get_exif_data(img)})
+# outer func
+def batch_infer(imgs_zip: str, keep_ext: bool, cache=f"{TMP_DIR}/exif"):
+    status = "Success"
+    out_images = out_exifs = None
+    try:
+        if not imgs_zip:
+            raise ValueError("Please upload pictures zip!")
+
+        clean_dir(cache)
+        mk_dir(f"{cache}/outputs")
+        extract_to = f"{cache}/inputs"
+        unzip(imgs_zip, extract_to)
+        imgs = find_images(extract_to)
+        img_mode = "RGB" if not keep_ext else None
+        exifs = []
+        for img in imgs:
+            clear_exif(img, cache, img_mode, "outputs/")
+            exifs.append({"filename": os.path.basename(img), "exif": get_exif(img)})
+
+        if not exifs:
+            raise ValueError("No picture in the zip")
+
+        out_images = f"{cache}/outputs.zip"
+        compress(f"{cache}/outputs", out_images)
+        out_exifs = pd.DataFrame(exifs)
 
-    if not exifs:
-        exifs = [{"Warning": "No picture in the zip"}]
+    except Exception as e:
+        status = f"{e}"
 
-    return compress(), pd.DataFrame(exifs)
+    return status, out_images, out_exifs
 
 
 def clexif():
     with gr.Blocks() as iface:
-        with gr.Tab("Process single picture"):
+        with gr.Tab(_L("单图片处理")):
             gr.Interface(
                 fn=infer,
                 inputs=[
                     gr.File(
-                        label="Upload picture",
+                        label=_L("上传图片"),
                         file_types=[
                             ".jpg",
                             ".jpeg",
@@ -141,43 +139,47 @@ def clexif():
                         ],
                     ),
                     gr.Checkbox(
-                        label="Export original format",
+                        label=_L("导出原格式"),
                         value=False,
                     ),
                 ],
                 outputs=[
+                    gr.Textbox(label=_L("状态栏"), show_copy_button=True),
                     gr.Image(
-                        label="Download cleaned picture",
+                        label=_L("下载清理 EXIF 后的图片"),
                         type="filepath",
                         show_share_button=False,
                     ),
                     gr.Textbox(label="EXIF", show_copy_button=True),
                 ],
-                allow_flagging="never",
+                flagging_mode="never",
             )
 
-        with gr.Tab("Batch processor"):
+        with gr.Tab(_L("批量处理")):
             gr.Interface(
                 fn=batch_infer,
                 inputs=[
                     gr.File(
-                        label="Upload pictures zip",
+                        label=_L("上传包含多图片的 zip 压缩包"),
                         file_types=[".zip"],
                     ),
                     gr.Checkbox(
-                        label="Export original format",
+                        label=_L("导出原格式"),
                         value=False,
                     ),
                 ],
                 outputs=[
+                    gr.Textbox(label=_L("状态栏"), show_copy_button=True),
                     gr.File(
-                        label="Download cleaned pictures",
+                        label=_L("下载清理 EXIF 后的多图片压缩包"),
                         type="filepath",
                     ),
-                    gr.Dataframe(label="EXIF list"),
+                    gr.Dataframe(label=_L("EXIF 列表")),
                 ],
-                description="When uploading pictures zip, please make sure the zip is completely uploaded before clicking Submit",
-                allow_flagging="never",
+                description=_L(
+                    "上传包含多图片的 zip 压缩包时确保上传进度至 100% 后再提交"
+                ),
+                flagging_mode="never",
             )
 
     return iface

gif.py → modules/gif.py

@@ -1,45 +1,44 @@
 import os
 import math
-import shutil
 import gradio as gr
 from PIL import Image, ImageSequence
 from moviepy.editor import VideoFileClip
-from config import TMP_DIR
+from utils import clean_dir, TMP_DIR, LANG
 
 
-def clean_cache(tmp_dir=TMP_DIR):
-    if os.path.exists(tmp_dir):
-        shutil.rmtree(tmp_dir)
+ZH2EN = {
+    "上传视频": "Upload video",
+    "倍速": "Speed",
+    "状态栏": "Status",
+    "文件名": "Filename",
+    "下载动图": "Download GIF",
+    "请确保视频上传完整后再点击提交，若时长大于五秒可先在线裁剪": "Please make sure the video is completely uploaded before clicking Submit, you can crop it online first if the video size is >5s",
+}
 
-    os.mkdir(tmp_dir)
-    return f"{tmp_dir}/input.gif"
 
+def _L(zh_txt: str):
+    if LANG:
+        return ZH2EN[zh_txt]
+    else:
+        return zh_txt
 
-def get_frame_duration(gif: Image):
-    duration = gif.info.get("duration", 100)
-    return [
-        frame.info.get("duration", duration) for frame in ImageSequence.Iterator(gif)
-    ]
 
+def get_frame_dur(gif: Image):
+    # 获取 GIF 图像中第一帧的 duration
+    dur = gif.info.get("duration", 100)
+    # 返回每一帧的 duration
+    return [frame.info.get("duration", dur) for frame in ImageSequence.Iterator(gif)]
 
-def resize_gif(
-    target_width: int,
-    target_height: int,
-    input_path=f"{TMP_DIR}/input.gif",
-    output_path=f"{TMP_DIR}/output.gif",
-):
-    # Open the GIF image
+
+def resize_gif(target_width: int, target_height: int, input_path, output_path):
     gif = Image.open(input_path)
-    # Create a list to hold the modified frames
     modified_frames = []
-    # Loop through each frame of the GIF
     for frame in ImageSequence.Iterator(gif):
-        # Resize the frame
         resized_frame = frame.resize((target_width, target_height), Image.LANCZOS)
-        # Append the resized frame to the list
         modified_frames.append(resized_frame)
 
-    frame_durations = get_frame_duration(gif)
+    frame_durations = get_frame_dur(gif)
+    # 将修改后的帧作为新的 GIF 保存
     modified_frames[0].save(
         output_path,
         format="GIF",
@@ -49,45 +48,50 @@ def resize_gif(
         loop=0,
     )
 
-    return output_path
-
 
-def infer(video_path: str, speed: float):
-    target_w = 640
-    gif_path = clean_cache()
+# outer func
+def infer(video_path: str, speed: float, target_w=640, cache=f"{TMP_DIR}/gif"):
+    status = "Success"
+    gif_name = out_gif = None
     try:
+        clean_dir(cache)
         with VideoFileClip(video_path, audio_fps=16000) as clip:
             if clip.duration > 5:
-                raise ValueError("The uploaded video is too long")
+                raise ValueError("上传的视频过长")
 
-            # clip.write_gif(gif_path, fps=12, progress_bar=True)
-            clip.speedx(speed).to_gif(gif_path, fps=12)
+            clip.speedx(speed).to_gif(f"{cache}/input.gif", fps=12)
             w, h = clip.size
 
+        in_gif = f"{cache}/input.gif"
+        out_gif = f"{cache}/output.gif"
         target_h = math.ceil(target_w * h / w)
-        return os.path.basename(video_path), resize_gif(target_w, target_h)
+        gif_name = os.path.basename(video_path)
+        resize_gif(target_w, target_h, in_gif, out_gif)
 
     except Exception as e:
-        return f"{e}", None
+        status = f"{e}"
+
+    return status, gif_name, out_gif
 
 
 def video2gif():
     return gr.Interface(
         fn=infer,
         inputs=[
-            gr.Video(label="Upload video"),
-            gr.Slider(
-                label="Speed",
-                minimum=0.5,
-                maximum=2.0,
-                step=0.25,
-                value=1.0,
-            ),
+            gr.Video(label=_L("上传视频")),
+            gr.Slider(label=_L("倍速"), minimum=0.5, maximum=2.0, step=0.25, value=1.0),
         ],
         outputs=[
-            gr.Textbox(label="Filename", show_copy_button=True),
-            gr.Image(label="Download GIF", type="filepath", show_share_button=False),
+            gr.Textbox(label=_L("状态栏"), show_copy_button=True),
+            gr.Textbox(label=_L("文件名"), show_copy_button=True),
+            gr.Image(label=_L("下载动图"), type="filepath", show_share_button=False),
         ],
-        description="Please make sure the video is completely uploaded before clicking Submit, you can crop it online first if the video size is >5s",
+        description=_L("请确保视频上传完整后再点击提交，若时长大于五秒可先在线裁剪"),
         flagging_mode="never",
+        examples=[
+            [
+                "https://www.modelscope.cn/studio/Genius-Society/online_tools/resolve/master/examples/herta.mp4",
+                2,
+            ]
+        ],
     )

github.py → modules/github.py

@@ -1,47 +1,61 @@
 import os
 import requests
 import gradio as gr
+from utils import LANG
 
+ZH2EN = {
+    "仓库拥有者": "Repo owner",
+    "输入用户名或组织名": "Username / organization name",
+    "仓库名": "GitHub repo",
+    "输入仓库名": "Repo name",
+    "输入 personal access token": "Personal access token",
+    "发布标签": "Release tag",
+    "发布名": "Release title",
+    "发布描述": "Describe this release",
+    "上传发布文件(可多选)": "Binary File(s)",
+    "状态栏": "Status",
+    "上传文件创建一个新的 GitHub 发布": "Upload binary file(s) to create a new GitHub release.",
+}
 
-def create_github_release(
-    owner: str,
-    repo: str,
-    token: str,
-    release_tag: str,
-    release_name: str,
-    release_description: str,
-    files: list,
-):
+
+def _L(zh_txt: str):
+    if LANG:
+        return ZH2EN[zh_txt]
+    else:
+        return zh_txt
+
+
+def create_github_release(owner, repo, token, tag, name, description, files):
     try:
         # 创建 Release
-        release_response = requests.post(
+        response = requests.post(
             f"https://api.github.com/repos/{owner}/{repo}/releases",
             headers={
                 "Authorization": f"token {token}",
                 "Accept": "application/vnd.github.v3+json",
             },
             json={
-                "tag_name": release_tag,
-                "name": release_name,
-                "body": release_description,
+                "tag_name": tag,
+                "name": name,
+                "body": description,
                 "draft": False,
                 "prerelease": False,
             },
         )
 
-        if release_response.status_code != 201:
-            return f"Failed to create release: {release_response.status_code}, {release_response.json()}"
+        if response.status_code != 201:
+            raise ConnectionError(f"{response.status_code}: {response.json()}")
 
         # 获取上传 URL
-        release = release_response.json()
+        release = response.json()
         upload_url = release["upload_url"].split("{")[0]
 
         # 上传多个二进制文件
-        results = []
+        results = ""
         for file_path in files:
             file_name = os.path.basename(file_path)
             with open(file_path, "rb") as binary_file:
-                upload_response = requests.post(
+                upl_response = requests.post(
                     f"{upload_url}?name={file_name}",
                     headers={
                         "Authorization": f"token {token}",
@@ -50,42 +64,34 @@ def create_github_release(
                     data=binary_file,
                 )
 
-            if upload_response.status_code == 201:
-                results.append(f"Binary file '{file_name}' uploaded successfully!")
+            if upl_response.status_code == 201:
+                results += f"Upload '{file_name}' success!"
             else:
-                results.append(
-                    f"Failed to upload binary file '{file_name}': {upload_response.status_code}, {upload_response.json()}"
-                )
+                results += f"Failed to upload {file_name}: {upl_response.status_code}, {upl_response.json()}"
 
-        return "\n".join(results)
+        return results
 
     except Exception as e:
-        return f"Release failed: {e}"
+        return f"{e}"
 
 
 def github_release_creator():
     return gr.Interface(
         fn=create_github_release,
         inputs=[
-            gr.Textbox(
-                label="GitHub Owner",
-                placeholder="username / organization name",
-            ),
-            gr.Textbox(label="GitHub Repo", placeholder="repo name"),
+            gr.Textbox(label=_L("仓库拥有者"), placeholder=_L("输入用户名或组织名")),
+            gr.Textbox(label=_L("仓库名"), placeholder=_L("输入仓库名")),
             gr.Textbox(
                 label="GitHub Token",
-                placeholder="personal access token",
+                placeholder=_L("输入 personal access token"),
                 type="password",
             ),
-            gr.Textbox(label="Release Tag", placeholder="v1.0.0"),
-            gr.Textbox(label="Release Name", placeholder="My New Release"),
-            gr.TextArea(
-                label="Describe this release",
-                placeholder="Release with binary file(s) and source code.",
-            ),
-            gr.File(label="Binary File(s)", file_count="multiple"),
+            gr.Textbox(label=_L("发布标签")),
+            gr.Textbox(label=_L("发布名")),
+            gr.TextArea(label=_L("发布描述")),
+            gr.File(label=_L("上传发布文件(可多选)"), file_count="multiple"),
         ],
-        outputs=gr.TextArea(label="Status", show_copy_button=True),
-        description="Upload binary file(s) to create a new GitHub release.",
+        outputs=gr.TextArea(label=_L("状态栏"), show_copy_button=True),
+        description=_L("上传文件创建一个新的 GitHub 发布"),
         flagging_mode="never",
     )

modules/qr.py

@@ -0,0 +1,48 @@
+import gradio as gr
+from utils import LANG
+
+ZH2EN = {
+    "二维码输出尺寸": "Image size",
+    "输入文本": "Input text",
+    "输出二维码": "QR code",
+    "输入文字在线生成二维码": "Enter text to generate a QR code.",
+    "状态栏": "Status",
+}
+
+
+def _L(zh_txt: str):
+    if LANG:
+        return ZH2EN[zh_txt]
+    else:
+        return zh_txt
+
+
+def infer(img_size: int, input_txt: str):
+    status = "Success"
+    url = None
+    try:
+        if not input_txt:
+            raise ValueError("Please input text!")
+
+        url = f"https://api.qrserver.com/v1/create-qr-code/?size={img_size}x{img_size}&data={input_txt}"
+
+    except Exception as e:
+        status = f"{e}"
+
+    return status, url
+
+
+def qrcode():
+    return gr.Interface(
+        fn=infer,
+        inputs=[
+            gr.Slider(35, 1000, 217, label=_L("二维码输出尺寸")),
+            gr.Textbox(label=_L("输入文本")),
+        ],
+        outputs=[
+            gr.Textbox(label=_L("状态栏"), show_copy_button=True),
+            gr.Image(label=_L("输出二维码"), show_share_button=False),
+        ],
+        description=_L("输入文字在线生成二维码"),
+        flagging_mode="never",
+    )

rct.py → modules/rct.py

@@ -1,26 +1,39 @@
-import os
 import csv
 import random
-import shutil
 import pandas as pd
 import gradio as gr
-from config import TMP_DIR
+from utils import clean_dir, TMP_DIR, LANG
+
+ZH2EN = {
+    "输入参与者数量": "Number of participants",
+    "输入分组比率": "Grouping ratio",
+    "状态栏": "Status",
+    "下载随机分组数据 CSV": "Download data CSV",
+    "随机分组数据预览": "Data preview",
+    "输入参与者数量和分组比率，格式为用:隔开的数字，生成随机分组数据。": "Enter the number of participants and the grouping ratio in the format of numbers separated by : to generate randomized controlled trial.",
+}
+
+
+def _L(zh_txt: str):
+    if LANG:
+        return ZH2EN[zh_txt]
+    else:
+        return zh_txt
 
 
 def list_to_csv(list_of_dicts: list, filename: str):
     keys = dict(list_of_dicts[0]).keys()
+    # 将列表中的字典写入 CSV 文件
     with open(filename, "w", newline="", encoding="utf-8") as csvfile:
         writer = csv.DictWriter(csvfile, fieldnames=keys)
         writer.writeheader()
         for data in list_of_dicts:
             writer.writerow(data)
 
-    return filename
-
 
-def random_allocation(participants: int, ratio: list):
-    total = sum(ratio)
+def random_allocate(participants: int, ratio: list, out_csv: str):
     splits = [0]
+    total = sum(ratio)
     for i, r in enumerate(ratio):
         splits.append(splits[i] + int(1.0 * r / total * participants))
 
@@ -36,40 +49,47 @@ def random_allocation(participants: int, ratio: list):
             allocation.append({"id": participant, "group": i + 1})
 
     sorted_data = sorted(allocation, key=lambda x: x["id"])
-    filename = list_to_csv(sorted_data, f"{TMP_DIR}/output.csv")
-    return filename, pd.DataFrame(sorted_data)
+    list_to_csv(sorted_data, out_csv)
+    return pd.DataFrame(sorted_data)
 
 
-def infer(participants: float, ratios: str):
-    if os.path.exists(TMP_DIR):
-        shutil.rmtree(TMP_DIR)
-
-    os.makedirs(TMP_DIR, exist_ok=True)
-    ratio_list = ratios.split(":")
+# outer func
+def infer(participants: float, ratios: str, cache=f"{TMP_DIR}/rct"):
     ratio = []
+    previews = None
+    status = "Success"
+    out_csv = f"{cache}/output.csv"
     try:
+        ratio_list = ratios.split(":")
+        clean_dir(cache)
         for r in ratio_list:
             current_ratio = float(r.strip())
             if current_ratio > 0:
                 ratio.append(current_ratio)
 
-    except Exception:
-        print("Invalid input of ratio!")
+        previews = random_allocate(int(participants), ratio, out_csv)
+
+    except Exception as e:
+        out_csv = None
+        status = f"{e}"
 
-    return random_allocation(int(participants), ratio)
+    return status, out_csv, previews
 
 
 def rct_generator():
     return gr.Interface(
         fn=infer,
         inputs=[
-            gr.Number(label="Number of participants", value=10),
-            gr.Textbox(label="Grouping ratio", value="8:1:1"),
+            gr.Number(label=_L("输入参与者数量"), value=10),
+            gr.Textbox(label=_L("输入分组比率"), value="8:1:1"),
         ],
         outputs=[
-            gr.File(label="Download data CSV"),
-            gr.Dataframe(label="Data preview"),
+            gr.Textbox(label=_L("状态栏"), show_copy_button=True),
+            gr.File(label=_L("下载随机分组数据 CSV")),
+            gr.Dataframe(label=_L("随机分组数据预览")),
         ],
-        description="Enter the number of participants and the grouping ratio in the format of numbers separated by : to generate randomized controlled trial.",
+        description=_L(
+            "输入参与者数量和分组比率，格式为用:隔开的数字，生成随机分组数据。"
+        ),
         flagging_mode="never",
     )

modules/smtp.py

@@ -0,0 +1,69 @@
+import requests
+import gradio as gr
+from utils import API_SMTP, LANG
+
+ZH2EN = {
+    "收信人邮箱": "To email",
+    "标题": "Title",
+    "测试标题": "Test title",
+    "正文": "Content",
+    "测试正文": "Test content",
+    "发信人昵称": "Sender name",
+    "测试昵称": "Test nickname",
+    "发信人邮箱": "From email",
+    "应用密钥": "API key",
+    "SMTP服务器": "SMTP host",
+    "端口": "Port",
+    "发送状态": "Status",
+}
+
+
+def _L(zh_txt: str):
+    if LANG:
+        return ZH2EN[zh_txt]
+    else:
+        return zh_txt
+
+
+def infer(target, title, content, name, email, password, host, port):
+    try:
+        response = requests.get(
+            API_SMTP,
+            params={
+                "host": host,
+                "Port": port,
+                "key": password,  # apikey
+                "email": email,  # from
+                "mail": target,  # to
+                "title": title,  # subject
+                "name": name,  # nickname
+                "text": content,  # content
+            },
+        )
+        if response.status_code == 200:
+            result: dict = response.json()
+            return result.get("status")
+
+        else:
+            raise ConnectionError(f"{response.status_code}")
+
+    except Exception as e:
+        return f"{e}"
+
+
+def smtp_tester():
+    return gr.Interface(
+        fn=infer,
+        inputs=[
+            gr.Textbox(label=_L("收信人邮箱")),
+            gr.Textbox(label=_L("标题"), value=_L("测试标题")),
+            gr.TextArea(label=_L("正文"), value=_L("测试正文")),
+            gr.Textbox(label=_L("发信人昵称"), value=_L("测试昵称")),
+            gr.Textbox(label=_L("发信人邮箱")),
+            gr.Textbox(label=_L("应用密钥")),
+            gr.Textbox(label=_L("SMTP服务器"), value="smtp.163.com"),
+            gr.Slider(label=_L("端口"), minimum=0, maximum=65535, step=1, value=25),
+        ],
+        outputs=gr.TextArea(label=_L("发送状态"), show_copy_button=True),
+        flagging_mode="never",
+    )

trans.py → modules/trans.py

@@ -1,14 +1,27 @@
-import os
 import json
 import requests
 import gradio as gr
-from config import API_TRANS, KEY_TRANS
+from utils import API_TRANS, KEY_TRANS, LANG
 
+ZH2EN = {
+    "输入文本区域": "Input text area",
+    "在这里输入文本...": "Type the text here...",
+    "模式": "Mode",
+    "翻译结果": "Translation results",
+    "状态栏": "Status",
+}
 
-def translate(source, direction):
-    if not source or not direction:
-        return "Please enter valid text and select the mode!"
 
+def _L(zh_txt: str):
+    if LANG:
+        return ZH2EN[zh_txt]
+    else:
+        return zh_txt
+
+
+def infer(source, direction):
+    status = "Success"
+    result = None
     # WARNING, this token is a test token for new developers, and it should be replaced by your token
     payload = {
         "source": source,
@@ -21,6 +34,9 @@ def translate(source, direction):
         "x-authorization": f"token {KEY_TRANS}",
     }
     try:
+        if not source or not direction:
+            raise ValueError("请输入有效文本并选择模式!")
+
         response = requests.request(
             "POST",
             API_TRANS,
@@ -28,24 +44,28 @@ def translate(source, direction):
             headers=headers,
         )
 
-        return json.loads(response.text)["target"]
+        result = json.loads(response.text)["target"]
 
     except Exception as e:
-        return f"{e}"
+        status = f"{e}"
+
+    return status, result
 
 
 def translator():
     return gr.Interface(
-        fn=translate,
+        fn=infer,
         inputs=[
-            gr.TextArea(label="Input text area", placeholder="Type the text here..."),
-            gr.Dropdown(choices=["auto2en", "auto2zh", "auto2ja"], label="Mode"),
+            gr.TextArea(label=_L("输入文本区域"), placeholder=_L("在这里输入文本...")),
+            gr.Dropdown(choices=["auto2en", "auto2zh", "auto2ja"], label=_L("模式")),
+        ],
+        outputs=[
+            gr.Textbox(label=_L("状态栏"), show_copy_button=True),
+            gr.TextArea(label=_L("翻译结果"), show_copy_button=True),
         ],
-        outputs=gr.TextArea(label="Translation results", show_copy_button=True),
         flagging_mode="never",
         examples=[
-            ["彩云小译は最高の翻訳サービスです", "auto2en"],
+            ["彩云小译は最高の翻訳サービスです", "auto2zh"],
             ["Lingocloud is the best translation service.", "auto2zh"],
         ],
-        cache_examples=False,
     )

url.py → modules/url.py

@@ -1,83 +1,90 @@
-import re
 import json
 import requests
 import gradio as gr
-from config import HEADER
+from utils import is_valid_url, HEADER, LANG
 
+ZH2EN = {
+    "输入长 URL": "Input a long URL",
+    "输入待变短的长 URL": "Input a long URL",
+    "选择 API 提供商": "Select an API provider",
+    "输出短 URL": "Output short URL",
+    "将长 URL 转换为短的、易于共享的链接": "Convert long urls into short, easy-to-share links",
+    "状态栏": "Status",
+}
 
-def is_valid_url(url):
-    pattern = re.compile(
-        r"^(https?://)?" r"([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}" r"(:\d+)?" r"(/[^ ]*)?$"
-    )
-    return bool(pattern.match(url))
+
+def _L(zh_txt: str):
+    if LANG:
+        return ZH2EN[zh_txt]
+    else:
+        return zh_txt
 
 
 def noxlink(longUrl: str):
     domain = "https://noxlink.net"
     api = f"{domain}/zh-CN/shorten"
-    payload = {"longUrl": longUrl}
-    try:
-        response = requests.post(api, json=payload, headers=HEADER)
-        if response.status_code == 200:
-            retcode = json.loads(response.text)
-            if retcode["success"]:
-                return f"{domain}/" + retcode["message"]
-
-        return response.text
+    response = requests.post(api, json={"longUrl": longUrl}, headers=HEADER)
+    if response.status_code == 200:
+        retcode = json.loads(response.text)
+        if retcode["success"]:
+            return f"{domain}/" + retcode["message"]
 
-    except Exception as e:
-        return f"{e}"
+    raise ConnectionError(response.text)
 
 
 def monojson(longUrl: str):
-    api = "https://monojson.com/api/short-link"
-    payload = {"url": longUrl}
-    try:
-        response = requests.post(api, json=payload, headers=HEADER)
-        if response.status_code == 200:
-            return json.loads(response.text)["shortUrl"]
-
-        else:
-            return response.text
-
-    except Exception as e:
-        return f"{e}"
+    response = requests.post(
+        "https://monojson.com/api/short-link",
+        json={"url": longUrl},
+        headers=HEADER,
+    )
+    if response.status_code == 200:
+        return json.loads(response.text)["shortUrl"]
+    else:
+        raise ConnectionError(response.text)
 
 
+# outer func
 def infer(longUrl: str, tool: str):
+    status = "Success"
     shortUrl = ""
-    if tool == "monojson":
-        shortUrl = monojson(longUrl)
-    elif tool == "noxlink":
-        shortUrl = noxlink(longUrl)
-    else:
-        shortUrl = "Please select an API provider!"
+    try:
+        if tool == "monojson":
+            shortUrl = monojson(longUrl)
+        elif tool == "noxlink":
+            shortUrl = noxlink(longUrl)
+        else:
+            raise ValueError("请选择一个 API 提供商!")
+
+        if is_valid_url(shortUrl):
+            shortUrl = f'<a href="{shortUrl}" target="_blank">{shortUrl}</a>'
 
-    if is_valid_url(shortUrl):
-        return f'<a href="{shortUrl}" target="_blank">{shortUrl}</a>'
+    except Exception as e:
+        status = f"{e}"
 
-    return shortUrl
+    return status, shortUrl
 
 
 def url_shortner():
     return gr.Interface(
         fn=infer,
         inputs=[
-            gr.Textbox(label="Input a long URL", placeholder="Input a long URL"),
+            gr.Textbox(label=_L("输入长 URL"), placeholder=_L("输入待变短的长 URL")),
             gr.Dropdown(
                 choices=["noxlink", "monojson"],
-                label="Select an API provider",
+                label=_L("选择 API 提供商"),
                 value="noxlink",
             ),
         ],
         outputs=[
+            gr.Textbox(label=_L("状态栏"), show_copy_button=True),
             gr.HTML(
                 container=True,
                 show_label=True,
-                label="Output short URL",
-            )
+                label=_L("输出短 URL"),
+            ),
         ],
-        description="Convert long urls into short, easy-to-share links",
+        description=_L("将长 URL 转换为短的、易于共享的链接"),
         flagging_mode="never",
         examples=[
             ["https://www.bing.com", "noxlink"],

qr.py

@@ -1,21 +0,0 @@
-import gradio as gr
-
-
-def infer(img_size: int, input_txt: str):
-    if not input_txt:
-        return None
-
-    return f"https://api.qrserver.com/v1/create-qr-code/?size={img_size}x{img_size}&data={input_txt}"
-
-
-def qrcode():
-    return gr.Interface(
-        fn=infer,
-        inputs=[
-            gr.Slider(35, 1000, 217, label="Image size"),
-            gr.Textbox(label="Input text"),
-        ],
-        outputs=gr.Image(label="QR code", show_share_button=False),
-        description="Enter text to generate a QR code.",
-        flagging_mode="never",
-    )

smtp.py

@@ -1,53 +0,0 @@
-import requests
-import gradio as gr
-from config import API_SMTP
-
-
-def send_email(
-    target: str,
-    title: str,
-    content: str,
-    name: str,
-    email: str,
-    password: str,
-    host: str,
-    port: int,
-):
-    response = requests.get(
-        API_SMTP,
-        params={
-            "host": host,
-            "Port": port,
-            "key": password,  # apikey
-            "email": email,  # from
-            "mail": target,  # to
-            "title": title,  # subject
-            "name": name,  # nickname
-            "text": content,  # content
-        },
-    )
-    if response.status_code == 200:
-        result: dict = response.json()
-        return result.get("status")
-
-    else:
-        return f"Request failed with status code: {response.status_code}"
-
-
-def smtp_tester():
-    return gr.Interface(
-        fn=send_email,
-        inputs=[
-            gr.Textbox(label="To email"),
-            gr.Textbox(label="Title", value="Test title"),
-            gr.TextArea(label="Content", value="Test content"),
-            gr.Textbox(label="Sender name", value="Test nickname"),
-            gr.Textbox(label="From email"),
-            gr.Textbox(label="API key"),
-            gr.Textbox(label="SMTP host", value="smtp.163.com"),
-            gr.Slider(label="Port", minimum=0, maximum=65535, step=1, value=25),
-        ],
-        outputs=gr.Textbox(label="status", show_copy_button=True),
-        description="SMTP Online Test Tool",
-        flagging_mode="never",
-    )

utils.py

@@ -0,0 +1,71 @@
+import os
+import re
+import shutil
+import zipfile
+
+LANG = os.getenv("language")
+API_SMTP = os.getenv("api_smtp")
+API_TRANS = os.getenv("api_caiyun")
+KEY_TRANS = os.getenv("apikey_caiyun")
+if not (API_SMTP and API_TRANS and KEY_TRANS):
+    print("请检查环境变量")
+    exit()
+
+
+TMP_DIR = "./__pycache__"
+HEADER = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 Edg/132.0.0.0",
+}
+
+
+def mk_dir(dir_path: str):
+    if not os.path.exists(dir_path):
+        os.makedirs(dir_path)
+
+
+def rm_dir(dir_path: str):
+    if os.path.exists(dir_path):
+        shutil.rmtree(dir_path)
+
+
+def clean_dir(dir_path: str):
+    rm_dir(dir_path)
+    os.makedirs(dir_path)
+
+
+def unzip(zip_path: str, extract_to: str):
+    mk_dir(extract_to)
+    # 打开ZIP文件
+    with zipfile.ZipFile(zip_path, "r") as zip_ref:
+        # 解压文件
+        zip_ref.extractall(extract_to)
+
+
+def compress(folder_path: str, zip_file: str):
+    # 确保文件夹存在
+    if not os.path.exists(folder_path):
+        raise ValueError(f"错误: 文件夹 '{folder_path}' 不存在")
+    # 打开 ZIP 文件，使用 'w' 模式表示写入
+    with zipfile.ZipFile(zip_file, "w", zipfile.ZIP_DEFLATED) as zipf:
+        # 遍历文件夹中的文件和子文件夹
+        for root, _, files in os.walk(folder_path):
+            for file in files:
+                file_path = os.path.join(root, file)
+                # 计算相对路径，保留文件夹的根目录
+                relative_path = os.path.relpath(file_path, folder_path)
+                zipf.write(
+                    file_path,
+                    arcname=os.path.join(os.path.basename(folder_path), relative_path),
+                )
+
+
+def is_valid_url(url):
+    # 定义 URL 的正则表达式
+    pattern = re.compile(
+        r"^(https?://)?"  # 协议（http 或 https，可选）
+        r"([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}"  # 域名
+        r"(:\d+)?"  # 端口号（可选）
+        r"(/[^ ]*)?$"  # 路径（可选）
+    )
+    # 使用正则表达式匹配 URL
+    return bool(pattern.match(url))