combine all tools

.gitignore

@@ -0,0 +1,2 @@
+*__pycache__*
+test.*

README.md

@@ -1,12 +1,12 @@
 ---
-title: Translator
+title: Online tools
 emoji: 🈂️🆒🈳
 colorFrom: green
 colorTo: indigo
 sdk: gradio
-sdk_version: 5.23.1
+sdk_version: 5.22.0
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: A simple translator
+short_description: Online tools collection
 ---

app.py

@@ -1,54 +1,42 @@
-import os
-import json
-import requests
 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()
 
-def translate(source, direction):
-    if not source or not direction:
-        return "Please enter valid text and select the mode!"
+        with gr.Tab("Image EXIF Cleaner"):
+            clexif()
 
-    # WARNING, this token is a test token for new developers, and it should be replaced by your token
-    payload = {
-        "source": source,
-        "trans_type": direction,
-        "request_id": "demo",
-        "detect": True,
-    }
-    headers = {
-        "content-type": "application/json",
-        "x-authorization": f"token {os.getenv('apikey_caiyun')}",
-    }
-    try:
-        response = requests.request(
-            "POST",
-            os.getenv("api_caiyun"),
-            data=json.dumps(payload),
-            headers=headers,
-        )
+        with gr.Tab("Video to GIF"):
+            video2gif()
 
-        return json.loads(response.text)["target"]
+        with gr.Tab("GitHub Releaser"):
+            github_release_creator()
 
-    except Exception as e:
-        return f"{e}"
+        with gr.Tab("QR Code"):
+            qrcode()
 
+        with gr.Tab("RCT Generator"):
+            rct_generator()
 
-if __name__ == "__main__":
-    gr.Interface(
-        fn=translate,
-        inputs=[
-            gr.TextArea(
-                label="Input text area",
-                placeholder="Type the text here...",
-                show_copy_button=True,
-            ),
-            gr.Dropdown(choices=["auto2en", "auto2zh", "auto2ja"], label="Mode"),
-        ],
-        outputs=gr.TextArea(label="Translation results", show_copy_button=True),
-        flagging_mode="never",
-        examples=[
-            ["彩云小译は最高の翻訳サービスです", "auto2en"],
-            ["Lingocloud is the best translation service.", "auto2zh"],
-        ],
-        cache_examples=False,
-    ).launch()
+        with gr.Tab("SMTP Test"):
+            smtp_tester()
+
+        with gr.Tab("Translator"):
+            translator()
+
+        with gr.Tab("URL Shortner"):
+            url_shortner()
+
+    demo.launch()

config.py

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,165 @@
+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)
+
+
+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_data = json.loads(line.strip())
+            data_list.append(json_data)
+
+    return data_list
+
+
+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))
+
+    return data_list
+
+
+def decoder_json(data_list: list, file_path=f"{TMP_DIR}/output.json"):
+    if data_list:
+        with open(file_path, "w", encoding="utf-8") as file:
+            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:
+        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=f"{TMP_DIR}/output.jsonl"):
+    if data_list:
+        with open(file_path, "w", encoding="utf-8") as file:
+            for data in data_list:
+                json_line = json.dumps(data, ensure_ascii=False)
+                file.write(json_line + "\n")
+
+    return file_path
+
+
+def change_mode(input: str):
+    affix = input.split(" ")
+    if affix[1] == "→":
+        MODE["from"] = affix[0]
+        MODE["to"] = affix[2]
+
+    else:
+        MODE["from"] = affix[2]
+        MODE["to"] = affix[0]
+
+
+def infer(input_file: str):
+    clean_cache()
+    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)
+
+    except Exception as e:
+        return None, pd.DataFrame([{"Please upload a standard data file": f"{e}"}])
+
+
+def data_converter():
+    with gr.Blocks() as data:
+        for item in TAB_CONFIG:
+            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="Mode",
+                            value=f"{types[0]} → {types[1]}",
+                        )
+                        input_file = gr.components.File(
+                            type="filepath",
+                            label="Upload input file",
+                            file_types=[f".{types[0]}", f".{types[1]}"],
+                        )
+                        convert_btn = gr.Button("Convert")
+
+                    with gr.Column():
+                        output_file = gr.components.File(
+                            type="filepath", label="Download output file"
+                        )
+                        data_viewer = gr.Dataframe(label="Data viewer")
+
+            option.change(change_mode, inputs=option)
+            tab.select(change_mode, inputs=option)
+            convert_btn.click(
+                infer, inputs=input_file, outputs=[output_file, data_viewer]
+            )
+
+        gr.Markdown(
+            """
+## Supported JSON format
+```
+[
+    {
+        "key1": "val11",
+        "key2": "val12",
+        ...
+    },
+    {
+        "key1": "val21",
+        "key2": "val22",
+        ...
+    },
+    ...
+]
+```
+## Supported jsonl format
+```
+{"key1": "val11", "key2": "val12", ...}
+{"key1": "val21", "key2": "val22", ...}
+...
+```             
+## Supported CSV format
+```
+key1, key2, ...
+val11, val12, ...
+val21, val22, ...
+...
+```
+"""
+        )
+
+    return data

exif.py

@@ -0,0 +1,183 @@
+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):
+    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_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}")
+
+    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):
+        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),
+                )
+
+    return zip_file_path
+
+
+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)
+
+    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)
+
+
+def batch_infer(imgs_zip: str, original_ext: bool):
+    if not imgs_zip:
+        return None, pd.DataFrame([{"Warning": "Please upload pictures zip!"}])
+
+    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)})
+
+    if not exifs:
+        exifs = [{"Warning": "No picture in the zip"}]
+
+    return compress(), pd.DataFrame(exifs)
+
+
+def clexif():
+    with gr.Blocks() as iface:
+        with gr.Tab("Process single picture"):
+            gr.Interface(
+                fn=infer,
+                inputs=[
+                    gr.File(
+                        label="Upload picture",
+                        file_types=[
+                            ".jpg",
+                            ".jpeg",
+                            ".tiff",
+                            ".cr2",
+                            ".nef",
+                            ".orf",
+                            ".sr2",
+                            ".heic",
+                            ".avif",
+                        ],
+                    ),
+                    gr.Checkbox(
+                        label="Export original format",
+                        value=False,
+                    ),
+                ],
+                outputs=[
+                    gr.Image(
+                        label="Download cleaned picture",
+                        type="filepath",
+                        show_share_button=False,
+                    ),
+                    gr.Textbox(label="EXIF", show_copy_button=True),
+                ],
+                allow_flagging="never",
+            )
+
+        with gr.Tab("Batch processor"):
+            gr.Interface(
+                fn=batch_infer,
+                inputs=[
+                    gr.File(
+                        label="Upload pictures zip",
+                        file_types=[".zip"],
+                    ),
+                    gr.Checkbox(
+                        label="Export original format",
+                        value=False,
+                    ),
+                ],
+                outputs=[
+                    gr.File(
+                        label="Download cleaned pictures",
+                        type="filepath",
+                    ),
+                    gr.Dataframe(label="EXIF list"),
+                ],
+                description="When uploading pictures zip, please make sure the zip is completely uploaded before clicking Submit",
+                allow_flagging="never",
+            )
+
+    return iface

gif.py

@@ -0,0 +1,93 @@
+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
+
+
+def clean_cache(tmp_dir=TMP_DIR):
+    if os.path.exists(tmp_dir):
+        shutil.rmtree(tmp_dir)
+
+    os.mkdir(tmp_dir)
+    return f"{tmp_dir}/input.gif"
+
+
+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 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
+    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)
+    modified_frames[0].save(
+        output_path,
+        format="GIF",
+        append_images=modified_frames[1:],
+        save_all=True,
+        duration=frame_durations,
+        loop=0,
+    )
+
+    return output_path
+
+
+def infer(video_path: str, speed: float):
+    target_w = 640
+    gif_path = clean_cache()
+    try:
+        with VideoFileClip(video_path, audio_fps=16000) as clip:
+            if clip.duration > 5:
+                raise ValueError("The uploaded video is too long")
+
+            # clip.write_gif(gif_path, fps=12, progress_bar=True)
+            clip.speedx(speed).to_gif(gif_path, fps=12)
+            w, h = clip.size
+
+        target_h = math.ceil(target_w * h / w)
+        return os.path.basename(video_path), resize_gif(target_w, target_h)
+
+    except Exception as e:
+        return f"{e}", None
+
+
+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,
+            ),
+        ],
+        outputs=[
+            gr.Textbox(label="Filename", show_copy_button=True),
+            gr.Image(label="Download GIF", 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",
+        flagging_mode="never",
+    )

github.py

@@ -0,0 +1,91 @@
+import os
+import requests
+import gradio as gr
+
+
+def create_github_release(
+    owner: str,
+    repo: str,
+    token: str,
+    release_tag: str,
+    release_name: str,
+    release_description: str,
+    files: list,
+):
+    try:
+        # 创建 Release
+        release_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,
+                "draft": False,
+                "prerelease": False,
+            },
+        )
+
+        if release_response.status_code != 201:
+            return f"Failed to create release: {release_response.status_code}, {release_response.json()}"
+
+        # 获取上传 URL
+        release = release_response.json()
+        upload_url = release["upload_url"].split("{")[0]
+
+        # 上传多个二进制文件
+        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(
+                    f"{upload_url}?name={file_name}",
+                    headers={
+                        "Authorization": f"token {token}",
+                        "Content-Type": "application/octet-stream",
+                    },
+                    data=binary_file,
+                )
+
+            if upload_response.status_code == 201:
+                results.append(f"Binary file '{file_name}' uploaded successfully!")
+            else:
+                results.append(
+                    f"Failed to upload binary file '{file_name}': {upload_response.status_code}, {upload_response.json()}"
+                )
+
+        return "\n".join(results)
+
+    except Exception as e:
+        return f"Release failed: {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="GitHub Token",
+                placeholder="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"),
+        ],
+        outputs=gr.TextArea(label="Status", show_copy_button=True),
+        description="Upload binary file(s) to create a new GitHub release.",
+        flagging_mode="never",
+    )

qr.py

@@ -0,0 +1,21 @@
+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",
+    )

rct.py

@@ -0,0 +1,75 @@
+import os
+import csv
+import random
+import shutil
+import pandas as pd
+import gradio as gr
+from config import TMP_DIR
+
+
+def list_to_csv(list_of_dicts: list, filename: str):
+    keys = dict(list_of_dicts[0]).keys()
+    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)
+    splits = [0]
+    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"])
+    filename = list_to_csv(sorted_data, f"{TMP_DIR}/output.csv")
+    return filename, 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(":")
+    ratio = []
+    try:
+        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!")
+
+    return random_allocation(int(participants), ratio)
+
+
+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"),
+        ],
+        outputs=[
+            gr.File(label="Download data CSV"),
+            gr.Dataframe(label="Data preview"),
+        ],
+        description="Enter the number of participants and the grouping ratio in the format of numbers separated by : to generate randomized controlled trial.",
+        flagging_mode="never",
+    )

requirements.txt

@@ -0,0 +1,5 @@
+tqdm
+Pillow
+exifread
+requests
+moviepy==1.0.3

smtp.py

@@ -0,0 +1,53 @@
+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",
+    )

trans.py

@@ -0,0 +1,51 @@
+import os
+import json
+import requests
+import gradio as gr
+from config import API_TRANS, KEY_TRANS
+
+
+def translate(source, direction):
+    if not source or not direction:
+        return "Please enter valid text and select the mode!"
+
+    # WARNING, this token is a test token for new developers, and it should be replaced by your token
+    payload = {
+        "source": source,
+        "trans_type": direction,
+        "request_id": "demo",
+        "detect": True,
+    }
+    headers = {
+        "content-type": "application/json",
+        "x-authorization": f"token {KEY_TRANS}",
+    }
+    try:
+        response = requests.request(
+            "POST",
+            API_TRANS,
+            data=json.dumps(payload),
+            headers=headers,
+        )
+
+        return json.loads(response.text)["target"]
+
+    except Exception as e:
+        return f"{e}"
+
+
+def translator():
+    return gr.Interface(
+        fn=translate,
+        inputs=[
+            gr.TextArea(label="Input text area", placeholder="Type the text here..."),
+            gr.Dropdown(choices=["auto2en", "auto2zh", "auto2ja"], label="Mode"),
+        ],
+        outputs=gr.TextArea(label="Translation results", show_copy_button=True),
+        flagging_mode="never",
+        examples=[
+            ["彩云小译は最高の翻訳サービスです", "auto2en"],
+            ["Lingocloud is the best translation service.", "auto2zh"],
+        ],
+        cache_examples=False,
+    )

url.py

@@ -0,0 +1,87 @@
+import re
+import json
+import requests
+import gradio as gr
+from config import HEADER
+
+
+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 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
+
+    except Exception as e:
+        return f"{e}"
+
+
+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}"
+
+
+def infer(longUrl: str, tool: str):
+    shortUrl = ""
+    if tool == "monojson":
+        shortUrl = monojson(longUrl)
+    elif tool == "noxlink":
+        shortUrl = noxlink(longUrl)
+    else:
+        shortUrl = "Please select an API provider!"
+
+    if is_valid_url(shortUrl):
+        return f'<a href="{shortUrl}" target="_blank">{shortUrl}</a>'
+
+    return shortUrl
+
+
+def url_shortner():
+    return gr.Interface(
+        fn=infer,
+        inputs=[
+            gr.Textbox(label="Input a long URL", placeholder="Input a long URL"),
+            gr.Dropdown(
+                choices=["noxlink", "monojson"],
+                label="Select an API provider",
+                value="noxlink",
+            ),
+        ],
+        outputs=[
+            gr.HTML(
+                container=True,
+                show_label=True,
+                label="Output short URL",
+            )
+        ],
+        description="Convert long urls into short, easy-to-share links",
+        flagging_mode="never",
+        examples=[
+            ["https://www.bing.com", "noxlink"],
+            ["https://www.baidu.com", "monojson"],
+        ],
+        cache_examples=False,
+    )