replace

README.md

@@ -1,5 +1,5 @@
 ---
-title: Online Tools
+title: QR Code Generator
 emoji: 🛠️
 colorFrom: green
 colorTo: indigo
@@ -8,5 +8,5 @@ sdk_version: 5.22.0
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: Online tool collection
+short_description: Convert text to QR code
 ---

app.py

@@ -1,22 +1,12 @@
 import gradio as gr
-from modules.data import data_converter
-from modules.exif import clexif
-from modules.gif import video2gif
-from modules.cmd import cmd_inject
-from modules.rct import rct_generator
-from modules.splitter import str_splitter
-from modules.tools import webtools
-from utils import EN_US
+from utils import download_file, EN_US, API_QR, TMP_DIR
 
 ZH2EN = {
-    "# 在线工具合集": "# Online Tools Collection",
-    "数据文件转换": "Data Converter",
-    "图片 EXIF 清理": "Image EXIF Cleaner",
-    "视频转 GIF 动图": "Video to GIF",
-    "命令注入测试": "CMD Injector",
-    "随机对照试验生成": "RCT Generator",
-    "字符串分割": "String Splitter",
-    "在线编程辅助工具": "Web Tools",
+    "二维码输出尺寸": "Image size",
+    "输入文本": "Input text",
+    "输出二维码": "QR code",
+    "输入文字在线生成二维码": "Enter text to generate a QR code.",
+    "状态栏": "Status",
 }
 
 
@@ -24,28 +14,34 @@ def _L(zh_txt: str):
     return ZH2EN[zh_txt] if EN_US else zh_txt
 
 
-if __name__ == "__main__":
-    with gr.Blocks() as demo:
-        gr.Markdown(_L("# 在线工具合集"))
-        with gr.Tab(_L("图片 EXIF 清理")):
-            clexif()
-
-        with gr.Tab(_L("数据文件转换")):
-            data_converter()
+def infer(img_size: int, input_txt: str):
+    status = "Success"
+    img = None
+    try:
+        if (not input_txt) or input_txt == "0":
+            raise ValueError("Please input valid text!")
 
-        with gr.Tab(_L("视频转 GIF 动图")):
-            video2gif()
+        img = download_file(
+            f"{API_QR}/?size={img_size}x{img_size}&data={input_txt}",
+            f"{TMP_DIR}/qrcode.jpg",
+        )
 
-        with gr.Tab(_L("命令注入测试")):
-            cmd_inject()
+    except Exception as e:
+        status = f"{e}"
 
-        with gr.Tab(_L("随机对照试验生成")):
-            rct_generator()
+    return status, img
 
-        with gr.Tab(_L("字符串分割")):
-            str_splitter()
 
-        with gr.Tab(_L("在线编程辅助工具")):
-            webtools()
-
-    demo.launch()
+if __name__ == "__main__":
+    gr.Interface(
+        fn=infer,
+        inputs=[
+            gr.Slider(35, 1000, 217, label=_L("二维码输出尺寸")),
+            gr.Textbox(label=_L("输入文本"), placeholder=_L("输入文字在线生成二维码")),
+        ],
+        outputs=[
+            gr.Textbox(label=_L("状态栏"), show_copy_button=True),
+            gr.Image(label=_L("输出二维码"), show_share_button=False),
+        ],
+        flagging_mode="never",
+    ).launch()

modules/cmd.py

@@ -1,86 +0,0 @@
-import os
-import time
-import threading
-import subprocess
-import gradio as gr
-from utils import EN_US
-
-ZH2EN = {
-    "状态栏": "Status",
-    "执行结果": "Command output",
-    "命令执行测试工具": "Command executor",
-    "输入一个命令, 点击查看其执行结果": "Enter a command, and click to see its result",
-    "执行超时时间": "Execution timeout",
-}
-
-
-def _L(zh_txt: str):
-    return ZH2EN[zh_txt] if EN_US else zh_txt
-
-
-class Inject:
-    def __init__(self):
-        self.output = ""
-        self.status = "Success"
-        self.thread: threading.Thread = None
-        self.timeout = 10
-        self.delay = 0.1
-
-    def run(self, cmd: str):
-        try:
-            self.output = subprocess.check_output(
-                cmd,
-                shell=True,
-                stderr=subprocess.STDOUT,
-                text=True,
-            )
-
-        except Exception as e:
-            self.status = f" {e} "
-            self.output = ""
-
-    def infer(self, cmd: str):
-        self.status = "Success"
-        self.output = ""
-        try:
-            if self.thread and self.thread.is_alive():
-                self.thread.join(timeout=0)
-
-            self.thread = threading.Thread(
-                target=self.run,
-                args=(cmd,),
-                daemon=True,
-            )
-            self.thread.start()
-            delay = 0
-            while self.thread and self.thread.is_alive():
-                delay += self.delay
-                time.sleep(self.delay)
-                if delay > self.timeout:
-                    self.thread.join(timeout=0)
-                    self.status = "Killed"
-                    self.output = _L("执行超时时间") + f": {self.timeout}s"
-                    break
-
-        except Exception as e:
-            self.status = f" {e} "
-            self.output = ""
-
-        return self.status, self.output
-
-
-def cmd_inject():
-    inject = Inject()
-    return gr.Interface(
-        fn=inject.infer,
-        inputs=gr.Textbox(
-            label=_L("命令执行测试工具"),
-            value="dir" if os.name == "nt" else "ls /",
-            placeholder=_L("输入一个命令, 点击查看其执行结果"),
-        ),
-        outputs=[
-            gr.Textbox(label=_L("状态栏"), show_copy_button=True),
-            gr.TextArea(label=_L("执行结果"), show_copy_button=True),
-        ],
-        flagging_mode="never",
-    )

modules/data.py

@@ -1,202 +0,0 @@
-import csv
-import json
-import gradio as gr
-import pandas as pd
-from utils import clean_dir, TMP_DIR, EN_US
-
-
-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):
-    return ZH2EN[zh_txt] if EN_US else zh_txt
-
-
-def encoder_json(file_path: str):
-    with open(file_path, "r", encoding="utf-8") as file:
-        data_list = list(json.load(file))
-
-    return data_list
-
-
-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)
-
-    return data_list
-
-
-def encoder_csv(file_path: str):
-    data_list = []
-    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: 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: 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)  # 逐项写入字典的值
-            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: 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(f"{json_line}\n")
-
-    return file_path
-
-
-def change_mode(input: str):
-    global MODE
-    affix = input.split(" ")
-    if affix[1] == "→":
-        MODE["from"] = affix[0]
-        MODE["to"] = affix[2]
-
-    else:
-        MODE["from"] = affix[2]
-        MODE["to"] = affix[0]
-
-
-# outer func
-def infer(input_file: str, cache=f"{TMP_DIR}/data"):
-    status = "Success"
-    output_file = previews = None
-    try:
-        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:
-        status = f"{e}"
-
-    return status, output_file, previews
-
-
-def data_converter(tab_cfgs=["jsonl ⇆ csv", "json ⇆ csv", "json ⇆ jsonl"]):
-    with gr.Blocks() as data:
-        for item in tab_cfgs:
-            types = item.split(" ⇆ ")
-            with gr.Tab(item) as tab:
-                with gr.Row():
-                    with gr.Column():
-                        option = gr.Dropdown(
-                            choices=[
-                                f"{types[0]} → {types[1]}",
-                                f"{types[0]} ← {types[1]}",
-                            ],
-                            label=_L("模式"),
-                            value=f"{types[0]} → {types[1]}",
-                        )
-                        input_file = gr.File(
-                            type="filepath",
-                            label=_L("上传原数据"),
-                            file_types=[f".{types[0]}", f".{types[1]}"],
-                        )
-                        convert_btn = gr.Button(_L("转换"))
-
-                    with gr.Column():
-                        status_bar = gr.Textbox(
-                            label=_L("状态栏"),
-                            show_copy_button=True,
-                        )
-                        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=[status_bar, output_file, data_viewer],
-            )
-
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown(
-                    f"""
-                    ## {_L('支持的 JSON Lines 格式')}
-                    ```
-                    {{"key1": "val11", "key2": "val12", ...}}
-                    {{"key1": "val21", "key2": "val22", ...}}
-                    ...
-                    ```    
-                    ## {_L('支持的 CSV 格式')}
-                    ```
-                    key1, key2, ...
-                    val11, val12, ...
-                    val21, val22, ...
-                    ...
-                    ```
-                    """
-                )
-
-            with gr.Column():
-                gr.Markdown(
-                    f"""
-                    ## {_L('支持的 JSON 格式')}
-                    ```
-                    [
-                        {{
-                            "key1": "val11",
-                            "key2": "val12",
-                            ...
-                        }},
-                        {{
-                            "key1": "val21",
-                            "key2": "val22",
-                            ...
-                        }},
-                        ...
-                    ]
-                    ```"""
-                )
-
-    return data

modules/exif.py

@@ -1,170 +0,0 @@
-import os
-import imghdr
-import hashlib
-import exifread
-import gradio as gr
-import pandas as pd
-from PIL import Image
-from utils import clean_dir, compress, mk_dir, unzip, TMP_DIR, EN_US
-
-ZH2EN = {
-    "单图片处理": "Process single picture",
-    "上传图片": "Upload picture",
-    "导出原格式": "Export original format",
-    "下载清理 EXIF 后的图片": "Download cleaned picture",
-    "批量处理": "Batch processor",
-    "上传包含多图片的 zip 压缩包 (确保上传进度至 100% 后再提交)": "Upload pictures zip (please ensure the zip is completely uploaded before clicking submit)",
-    "导出原格式": "Export original format",
-    "下载清理 EXIF 后的多图片压缩包": "Download cleaned pictures",
-    "EXIF 列表": "EXIF list",
-    "状态栏": "Status",
-}
-
-
-def _L(zh_txt: str):
-    return ZH2EN[zh_txt] if EN_US else zh_txt
-
-
-def get_exif(origin_file_path):
-    with open(origin_file_path, "rb") as image_file:
-        tags = exifread.process_file(image_file)
-
-    output = ""
-    for key in tags.keys():
-        value = str(tags[key])
-        output += "{0}:{1}\n".format(key, value)
-
-    return output
-
-
-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 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_images.append(fpath)
-
-    return found_images
-
-
-# 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("请输入图片！")
-
-        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}"
-
-    return status, out_img, out_exif
-
-
-# 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)
-
-    except Exception as e:
-        status = f"{e}"
-
-    return status, out_images, out_exifs
-
-
-def clexif():
-    with gr.Blocks() as iface:
-        with gr.Tab(_L("单图片处理")):
-            gr.Interface(
-                fn=infer,
-                inputs=[
-                    gr.File(
-                        label=_L("上传图片"),
-                        file_types=["image"],
-                    ),
-                    gr.Checkbox(
-                        label=_L("导出原格式"),
-                        value=False,
-                    ),
-                ],
-                outputs=[
-                    gr.Textbox(label=_L("状态栏"), show_copy_button=True),
-                    gr.Image(
-                        label=_L("下载清理 EXIF 后的图片"),
-                        type="filepath",
-                        show_share_button=False,
-                    ),
-                    gr.Textbox(label="EXIF", show_copy_button=True),
-                ],
-                flagging_mode="never",
-            )
-
-        with gr.Tab(_L("批量处理")):
-            gr.Interface(
-                fn=batch_infer,
-                inputs=[
-                    gr.File(
-                        label=_L(
-                            "上传包含多图片的 zip 压缩包 (确保上传进度至 100% 后再提交)"
-                        ),
-                        file_types=[".zip"],
-                    ),
-                    gr.Checkbox(
-                        label=_L("导出原格式"),
-                        value=False,
-                    ),
-                ],
-                outputs=[
-                    gr.Textbox(label=_L("状态栏"), show_copy_button=True),
-                    gr.File(
-                        label=_L("下载清理 EXIF 后的多图片压缩包"),
-                        type="filepath",
-                    ),
-                    gr.Dataframe(label=_L("EXIF 列表")),
-                ],
-                flagging_mode="never",
-            )
-
-    return iface

modules/gif.py

@@ -1,97 +0,0 @@
-import os
-import math
-import gradio as gr
-from PIL import Image, ImageSequence
-from moviepy.editor import VideoFileClip
-from utils import clean_dir, TMP_DIR, EN_US
-
-ZH2EN = {
-    "上传视频 (请确保上传完整后再点击提交，若时长大于五秒可先在线裁剪)": "Upload video (please ensure the video is completely uploaded before clicking submit, you can crop it online to less than 5s)",
-    "倍速": "Speed",
-    "状态栏": "Status",
-    "文件名": "Filename",
-    "下载动图": "Download GIF",
-}
-
-
-def _L(zh_txt: str):
-    return ZH2EN[zh_txt] if EN_US else zh_txt
-
-
-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_gif, output_gif):
-    gif = Image.open(input_gif)
-    modified_frames = []
-    for frame in ImageSequence.Iterator(gif):
-        resized_frame = frame.resize((target_width, target_height), Image.LANCZOS)
-        modified_frames.append(resized_frame)
-
-    frame_durations = get_frame_dur(gif)
-    # 将修改后的帧作为新的 GIF 保存
-    modified_frames[0].save(
-        output_gif,
-        format="GIF",
-        append_images=modified_frames[1:],
-        save_all=True,
-        duration=frame_durations,
-        loop=0,
-    )
-
-    return output_gif
-
-
-# outer func
-def infer(video_path: str, speed: float, target_w=640, cache=f"{TMP_DIR}/gif"):
-    status = "Success"
-    gif_name = gif_out = None
-    try:
-        clean_dir(cache)
-        with VideoFileClip(video_path, audio_fps=16000) as clip:
-            if clip.duration > 5:
-                raise ValueError("上传的视频过长")
-
-            clip.speedx(speed).to_gif(f"{cache}/input.gif", fps=12)
-            w, h = clip.size
-
-        gif_in = f"{cache}/input.gif"
-        target_h = math.ceil(target_w * h / w)
-        gif_name = os.path.basename(video_path)
-        gif_out = resize_gif(target_w, target_h, gif_in, f"{cache}/output.gif")
-
-    except Exception as e:
-        status = f"{e}"
-
-    return status, gif_name, gif_out
-
-
-def video2gif():
-    example = (
-        "https://www.modelscope.cn/studio/Genius-Society/online_tools/resolve/master"
-        if EN_US
-        else "."
-    )
-    return gr.Interface(
-        fn=infer,
-        inputs=[
-            gr.Video(
-                label=_L(
-                    "上传视频 (请确保上传完整后再点击提交，若时长大于五秒可先在线裁剪)"
-                )
-            ),
-            gr.Slider(label=_L("倍速"), minimum=0.5, maximum=2.0, step=0.25, value=1.0),
-        ],
-        outputs=[
-            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),
-        ],
-        flagging_mode="never",
-        examples=[[f"{example}/examples/herta.mp4", 2]],
-        cache_examples=False,
-    )

modules/rct.py

@@ -1,91 +0,0 @@
-import csv
-import random
-import pandas as pd
-import gradio as gr
-from utils import clean_dir, TMP_DIR, EN_US
-
-ZH2EN = {
-    "输入参与者数量": "Number of participants",
-    "输入分组比率 (格式为用:隔开的数字，生成随机分组数据)": "Grouping ratio (numbers separated by : to generate randomized controlled trial)",
-    "状态栏": "Status",
-    "下载随机分组数据 CSV": "Download data CSV",
-    "随机分组数据预览": "Data preview",
-}
-
-
-def _L(zh_txt: str):
-    return ZH2EN[zh_txt] if EN_US else 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)
-
-
-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))
-
-    splits[-1] = participants
-    partist = list(range(1, participants + 1))
-    random.shuffle(partist)
-    allocation = []
-    groups = len(ratio)
-    for i in range(groups):
-        start = splits[i]
-        end = splits[i + 1]
-        for participant in partist[start:end]:
-            allocation.append({"id": participant, "group": i + 1})
-
-    sorted_data = sorted(allocation, key=lambda x: x["id"])
-    list_to_csv(sorted_data, out_csv)
-    return out_csv, pd.DataFrame(sorted_data)
-
-
-# outer func
-def infer(participants: float, ratios: str, cache=f"{TMP_DIR}/rct"):
-    ratio = []
-    status = "Success"
-    out_csv = previews = None
-    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)
-
-        out_csv, previews = random_allocate(
-            int(participants), ratio, f"{cache}/output.csv"
-        )
-
-    except Exception as e:
-        status = f"{e}"
-
-    return status, out_csv, previews
-
-
-def rct_generator():
-    return gr.Interface(
-        fn=infer,
-        inputs=[
-            gr.Number(label=_L("输入参与者数量"), value=10),
-            gr.Textbox(
-                label=_L("输入分组比率 (格式为用:隔开的数字，生成随机分组数据)"),
-                value="8:1:1",
-            ),
-        ],
-        outputs=[
-            gr.Textbox(label=_L("状态栏"), show_copy_button=True),
-            gr.File(label=_L("下载随机分组数据 CSV")),
-            gr.Dataframe(label=_L("随机分组数据预览")),
-        ],
-        flagging_mode="never",
-    )

modules/splitter.py

@@ -1,59 +0,0 @@
-import math
-import gradio as gr
-from utils import EN_US
-
-ZH2EN = {
-    "待分割字符串": "String to be split",
-    "分割步长": "Split step",
-    "状态栏": "Status",
-    "分割结果": "Split result",
-}
-
-
-def _L(zh_txt: str):
-    return ZH2EN[zh_txt] if EN_US else zh_txt
-
-
-def infer(cookie: str, step: int):
-    status = "Success"
-    output = ""
-    try:
-        cookie = cookie.strip()
-        if not cookie:
-            raise ValueError("请输入 cookie !")
-
-        size = len(cookie)
-        count = math.ceil(size / step)
-        for i in range(count):
-            output += f"""	
-            ## {i + 1}	
-            ```txt	
-            {cookie[i * step : min((i + 1) * step, size)]}	
-            ```	
-            """
-
-    except Exception as e:
-        status = f"{e}"
-
-    return status, output
-
-
-def str_splitter():
-    return gr.Interface(
-        fn=infer,
-        inputs=[
-            gr.TextArea(label=_L("待分割字符串")),
-            gr.Slider(
-                label=_L("分割步长"),
-                minimum=1,
-                maximum=255959,
-                step=1,
-                value=1024,
-            ),
-        ],
-        outputs=[
-            gr.Textbox(label=_L("状态栏"), show_copy_button=True),
-            gr.Markdown(label=_L("分割结果"), container=True, show_copy_button=True),
-        ],
-        flagging_mode="never",
-    )

modules/tools.py

@@ -1,9 +0,0 @@
-import gradio as gr
-from utils import EN_US
-
-
-def webtools():
-    domain = "static.hf.space" if EN_US else "ms.show"
-    return gr.HTML(
-        f"<iframe src='https://genius-society-web-tools.{domain}' width='100%' style='aspect-ratio: 16 / 9;'></iframe>"
-    )

utils.py

@@ -1,17 +1,15 @@
 import os
 import shutil
-import zipfile
+import requests
 
 EN_US = os.getenv("LANG") != "zh_CN.UTF-8"
-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",
-}
+API_QR = os.getenv("api_qr")
+if not API_QR:
+    print("请检查环境变量")
+    exit()
 
 
-def mk_dir(dir_path: str):
-    if not os.path.exists(dir_path):
-        os.makedirs(dir_path)
+TMP_DIR = "./__pycache__"
 
 
 def clean_dir(dir_path: str):
@@ -21,27 +19,12 @@ def clean_dir(dir_path: str):
     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 download_file(url, local_filename):
+    clean_dir(os.path.dirname(local_filename))
+    response = requests.get(url, stream=True)
+    response.raise_for_status()
+    with open(local_filename, "wb") as f:
+        for chunk in response.iter_content(chunk_size=8192):
+            f.write(chunk)
+
+    return local_filename