easyrip 3.13.2__py3-none-any.whl → 4.9.1__py3-none-any.whl

easyrip/easyrip_main.py

@@ -1,3 +1,4 @@
+import ast
 import ctypes
 import itertools
 import json
@@ -7,19 +8,23 @@ import shlex
 import shutil
 import subprocess
 import sys
+import textwrap
+import threading
 import tkinter as tk
+import tomllib
+from collections.abc import Callable, Iterable
+from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from multiprocessing import shared_memory
 from pathlib import Path
 from threading import Thread
 from time import sleep
 from tkinter import filedialog
-
-import tomllib
+from typing import Final, Literal
 
 from . import easyrip_mlang, easyrip_web, global_val
 from .easyrip_command import Cmd_type, Opt_type, get_help_doc
-from .easyrip_config import config
+from .easyrip_config.config import Config_key, config
 from .easyrip_log import Event as LogEvent
 from .easyrip_log import log
 from .easyrip_mlang import (
@@ -30,7 +35,11 @@ from .easyrip_mlang import (
     gettext,
     translate_subtitles,
 )
-from .ripper import Media_info, Ripper
+from .easyrip_prompt import easyrip_prompt
+from .ripper.media_info import Media_info
+from .ripper.param import DEFAULT_PRESET_PARAMS, PRESET_OPT_NAME
+from .ripper.ripper import Ripper
+from .ripper.sub_and_font import load_fonts
 from .utils import change_title, check_ver, read_text
 
 __all__ = ["init", "run_command"]
@@ -42,40 +51,44 @@ PROJECT_TITLE = global_val.PROJECT_TITLE
 PROJECT_URL = global_val.PROJECT_URL
 
 
-def log_new_ver(new_ver: str | None, old_ver: str, program_name: str, dl_url: str):
+def log_new_ver(
+    new_ver: str | None, old_ver: str, program_name: str, dl_url: str
+) -> None:
     if new_ver is None:
         return
     try:
         if check_ver(new_ver, old_ver):
-            print()
             log.info(
-                "{} has new version {}. You can download it: {}",
-                program_name,
-                new_ver,
-                dl_url,
+                "\n"
+                + gettext(
+                    "{} has new version ({} -> {}). Suggest upgrading it: {}",
+                    program_name,
+                    old_ver,
+                    new_ver,
+                    dl_url,
+                )
             )
-            print(get_input_prompt(True), end="")
     except Exception as e:
-        print()
-        log.warning(e, deep=True)
-        print(get_input_prompt(True), end="")
+        log.warning(f"\n{e}", is_format=False, deep=True)
 
 
-def check_env():
+def check_env() -> None:
     try:
         change_title(f"{gettext('Check env...')} {PROJECT_TITLE}")
 
-        if config.get_user_profile("check_dependent"):
+        if config.get_user_profile(Config_key.check_dependent):
             _url = "https://ffmpeg.org/download.html"
             for _name in ("FFmpeg", "FFprobe"):
                 if not shutil.which(_name):
-                    print()
                     log.error(
-                        "{} not found, download it: {}",
-                        _name,
-                        f"(full build ver) {_url}",
+                        "\n"
+                        + gettext(
+                            "{} not found, download it: {}",
+                            _name,
+                            f"(full build ver) {_url}",
+                        )
                     )
-                    print(get_input_prompt(True), end="")
+                    log.print(get_input_prompt(True), end="")
                 else:
                     _new_ver = (
                         subprocess.run(
@@ -86,19 +99,21 @@ def check_env():
                     )
 
                     if "." in _new_ver:
-                        log_new_ver("8.0", _new_ver.split("-")[0], _name, _url)
+                        log_new_ver("8.0.1", _new_ver.split("-")[0], _name, _url)
                     else:
                         log_new_ver(
-                            "2025.08.22", ".".join(_new_ver.split("-")[:3]), _name, _url
+                            "2025.11.20", ".".join(_new_ver.split("-")[:3]), _name, _url
                         )
 
             _name, _url = "flac", "https://github.com/xiph/flac/releases"
             if not shutil.which(_name):
-                print()
                 log.warning(
-                    "{} not found, download it: {}", _name, f"(ver >= 1.5.0) {_url}"
+                    "\n"
+                    + gettext(
+                        "{} not found, download it: {}", _name, f"(ver >= 1.5.0) {_url}"
+                    )
                 )
-                print(get_input_prompt(True), end="")
+                log.print(get_input_prompt(True), end="")
 
             elif check_ver(
                 "1.5.0",
@@ -112,7 +127,7 @@ def check_env():
 
             else:
                 log_new_ver(
-                    easyrip_web.github.get_release_ver(
+                    easyrip_web.github.get_latest_release_ver(
                         "https://api.github.com/repos/xiph/flac/releases/latest"
                     ),
                     old_ver_str,
@@ -122,12 +137,13 @@ def check_env():
 
             _name, _url = "mp4fpsmod", "https://github.com/nu774/mp4fpsmod/releases"
             if not shutil.which(_name):
-                print()
-                log.warning("{} not found, download it: {}", _name, _url)
-                print(get_input_prompt(True), end="")
+                log.warning(
+                    "\n" + gettext("{} not found, download it: {}", _name, _url)
+                )
+                log.print(get_input_prompt(True), end="")
             else:
                 log_new_ver(
-                    easyrip_web.github.get_release_ver(
+                    easyrip_web.github.get_latest_release_ver(
                         "https://api.github.com/repos/nu774/mp4fpsmod/releases/latest"
                     ),
                     subprocess.run(_name, capture_output=True, text=True).stderr.split(
@@ -139,9 +155,10 @@ def check_env():
 
             _name, _url = "MP4Box", "https://gpac.io/downloads/gpac-nightly-builds/"
             if not shutil.which(_name):
-                print()
-                log.warning("{} not found, download it: {}", _name, _url)
-                print(get_input_prompt(True), end="")
+                log.warning(
+                    "\n" + gettext("{} not found, download it: {}", _name, _url)
+                )
+                log.print(get_input_prompt(True), end="")
             else:
                 log_new_ver(
                     "2.5",
@@ -156,12 +173,13 @@ def check_env():
             _url = "https://mkvtoolnix.download/downloads.html"
             for _name in ("mkvpropedit", "mkvmerge"):
                 if not shutil.which(_name):
-                    print()
-                    log.warning("{} not found, download it: {}", _name, _url)
-                    print(get_input_prompt(True), end="")
+                    log.warning(
+                        "\n" + gettext("{} not found, download it: {}", _name, _url)
+                    )
+                    log.print(get_input_prompt(True), end="")
                 else:
                     log_new_ver(
-                        "95",
+                        easyrip_web.mkvtoolnix.get_latest_release_ver(),
                         subprocess.run(
                             f"{_name} --version", capture_output=True, text=True
                         ).stdout.split(maxsplit=2)[1],
@@ -169,28 +187,29 @@ def check_env():
                         _url,
                     )
 
-            # _name, _url = 'MediaInfo', 'https://mediaarea.net/en/MediaInfo/Download'
-            # if not shutil.which(_name):
-            #     print()
-            #     log.warning('{} not found, download it: {}', _name, f'(CLI ver) {_url}')
-            #     print(get_input_prompt(), end='')
-            # elif not subprocess.run('mediainfo --version', capture_output=True, text=True).stdout:
-            #     log.error("The MediaInfo must be CLI ver")
-
-        if config.get_user_profile("check_update"):
+        if config.get_user_profile(Config_key.check_update):
             log_new_ver(
-                easyrip_web.github.get_release_ver(global_val.PROJECT_RELEASE_API),
+                easyrip_web.github.get_latest_release_ver(
+                    global_val.PROJECT_RELEASE_API
+                ),
                 PROJECT_VERSION,
                 PROJECT_NAME,
-                f"{global_val.PROJECT_URL} {gettext("or run '{}' when you use pip", 'pip install -U easyrip')}",
+                f"{global_val.PROJECT_URL}\n{
+                    gettext(
+                        'Suggest running the following command to upgrade using pip: {}',
+                        f'{f'"{sys.executable}" -m ' if sys.executable.lower().endswith("python.exe") else ""}pip install -U easyrip',
+                    )
+                }",
             )
 
-        sys.stdout.flush()
-        sys.stderr.flush()
         change_title(PROJECT_TITLE)
 
     except Exception as e:
-        log.error(f"The def check_env error: {e!r} {e}", deep=True)
+        log.error(
+            f"The function {check_env.__name__} error: {e!r} {e}",
+            is_format=False,
+            deep=True,
+        )
 
 
 def get_input_prompt(is_color: bool = False) -> str:
@@ -209,17 +228,29 @@ if os.name == "nt":
         log.warning("Windows DPI Aware failed")
 
 
-def file_dialog(initialdir=None):
+def file_dialog(
+    *,
+    is_askdir: bool = False,
+    initialdir=None,
+) -> tuple[str, ...]:
     tkRoot = tk.Tk()
+
     tkRoot.withdraw()
-    file_paths = filedialog.askopenfilenames(initialdir=initialdir)
+    if is_askdir:
+        file_paths = (filedialog.askdirectory(initialdir=initialdir),)
+    else:
+        file_paths = filedialog.askopenfilenames(initialdir=initialdir)
+
     tkRoot.destroy()
-    return file_paths
+    return file_paths if file_paths else ()
 
 
 def run_ripper_list(
-    is_exit_when_run_finished: bool = False, shutdow_sec_str: str | None = None
-):
+    *,
+    is_exit_when_run_finished: bool = False,
+    shutdow_sec_str: str | None = None,
+    enable_multithreading: bool = False,
+) -> None:
     shutdown_sec: int | None = None
     if shutdow_sec_str is not None:
         try:
@@ -236,8 +267,10 @@ def run_ripper_list(
             create=True,
             size=_size,
         )
+        assert path_lock_shm.buf is not None
     except FileExistsError:
         _shm = shared_memory.SharedMemory(name=_name)
+        assert _shm.buf is not None
         _res: dict = json.loads(
             bytes(_shm.buf[: len(_shm.buf)]).decode("utf-8").rstrip("\0")
         )
@@ -258,27 +291,55 @@ def run_ripper_list(
         ).encode("utf-8")
         path_lock_shm.buf[: len(_data)] = _data
 
-    total = len(Ripper.ripper_list)
-    warning_num = log.warning_num
-    error_num = log.error_num
-    for i, ripper in enumerate(Ripper.ripper_list, 1):
-        progress = f"{i} / {total} - {PROJECT_TITLE}"
-        log.info(progress)
-        change_title(progress)
-        try:
-            if ripper.run() is False:
-                log.error("Run {} failed", "Ripper")
-        except Exception as e:
-            log.error(e, deep=True)
-            log.warning("Stop run Ripper")
-        sleep(1)
+    total: Final[int] = len(Ripper.ripper_list)
+    warning_num: Final[int] = log.warning_num
+    error_num: Final[int] = log.error_num
+
+    if enable_multithreading:
+        threading_lock = threading.Lock()
+        progress_num: int = 0
+
+        def _executor_submit_ripper_run(ripper: Ripper) -> None:
+            nonlocal progress_num
+            with threading_lock:
+                progress_num += 1
+
+            progress = f"{progress_num} / {total} - {PROJECT_TITLE}"
+            log.info(progress)
+            change_title(progress)
+
+            try:
+                if ripper.run() is False:
+                    log.error("Run {} failed", "Ripper")
+            except Exception as e:
+                log.error(e, deep=True)
+                log.warning("Stop run Ripper")
+
+        with ThreadPoolExecutor() as executor:
+            for ripper in Ripper.ripper_list:
+                executor.submit(_executor_submit_ripper_run, ripper)
+                sleep(0.1)
+
+    else:
+        for i, ripper in enumerate(Ripper.ripper_list, 1):
+            progress = f"{i} / {total} - {PROJECT_TITLE}"
+            log.info(progress)
+            change_title(progress)
+            try:
+                if ripper.run() is False:
+                    log.error("Run {} failed", "Ripper")
+            except Exception as e:
+                log.error(e, deep=True)
+                log.warning("Stop run Ripper")
+            sleep(0.5)
+
     if log.warning_num > warning_num:
         log.warning(
             "There are {} {} during run", log.warning_num - warning_num, "warning"
         )
     if log.error_num > error_num:
         log.error("There are {} {} during run", log.error_num - error_num, "error")
-    Ripper.ripper_list = []
+    Ripper.ripper_list.clear()
     path_lock_shm.close()
 
     if shutdown_sec:
@@ -293,25 +354,52 @@ def run_ripper_list(
         os.system(_cmd[0])
 
     if is_exit_when_run_finished:
-        sys.exit()
+        sys.exit(0)
 
     change_title(f"End - {PROJECT_TITLE}")
     log.info("Run completed")
 
 
-def run_command(command: list[str] | str) -> bool:
-    if isinstance(command, list):
-        cmd_list = command
+def get_web_server_params(
+    opt: str,
+) -> Literal[False] | tuple[str, int, str | None]:
+    """[<address>]:[<port>]@[<password>]"""
+    if easyrip_web.http_server.Event.is_run_command:
+        log.error("Can not start multiple services")
+        return False
 
-    else:
-        try:
-            cmd_list = [
-                cmd.strip('"').strip("'").replace("\\\\", "\\")
-                for cmd in shlex.split(command, posix=False)
-            ]
-        except ValueError as e:
-            log.error(e)
-            return False
+    if ":" not in opt:
+        log.error("{} param illegal", f"':' not in '{opt}':")
+        return False
+
+    opt_list: list[str] = opt.split(":")
+    opt_list = [opt_list[0], *opt_list[1].split("@")]
+
+    if len(opt_list) != 3:
+        log.error("{} param illegal", f"len('{opt}') != 3:")
+        return False
+
+    host, port, password = opt_list
+
+    port = port or "0"
+
+    if not port.isdigit():
+        log.error("{} param illegal", f"The port in '{opt}' not a digit:")
+        return False
+
+    return (host or "", int(port), password)
+
+
+def run_command(command: Iterable[str] | str) -> bool:
+    try:
+        cmd_list: list[str] = (
+            shlex.split(command.replace("\\", "\\\\") if os.name == "nt" else command)
+            if isinstance(command, str)
+            else list(command)
+        )
+    except ValueError as e:
+        log.error(e)
+        return False
 
     if len(cmd_list) == 0:
         return True
@@ -321,7 +409,7 @@ def run_command(command: list[str] | str) -> bool:
     cmd_list.append("")
 
     cmd_type: Cmd_type | None = None
-    if cmd_list[0] in Cmd_type._member_map_.keys():
+    if cmd_list[0] in Cmd_type._member_map_:
         cmd_type = Cmd_type[cmd_list[0]]
     elif len(cmd_list[0]) > 0 and cmd_list[0].startswith("$"):
         cmd_type = Cmd_type._run_any
@@ -332,10 +420,54 @@ def run_command(command: list[str] | str) -> bool:
                 _want_doc_cmd_type: Cmd_type | Opt_type | None = Cmd_type.from_str(
                     cmd_list[1]
                 ) or Opt_type.from_str(cmd_list[1])
-                if _want_doc_cmd_type is None:
-                    log.error("'{}' does not exist", cmd_list[1])
-                else:
-                    log.send(_want_doc_cmd_type.value.to_doc(), is_format=False)
+                match _want_doc_cmd_type:
+                    case Opt_type._preset:
+                        if not cmd_list[2]:
+                            log.send(_want_doc_cmd_type.value.to_doc(), is_format=False)
+                        elif cmd_list[2] in Ripper.Preset_name._value2member_map_:
+                            _preset = Ripper.Preset_name(cmd_list[2])
+                            if (
+                                _preset in DEFAULT_PRESET_PARAMS
+                                or _preset in PRESET_OPT_NAME
+                            ):
+                                if _preset in PRESET_OPT_NAME:
+                                    log.send(
+                                        "Params that can be directly used:\n{}",
+                                        textwrap.indent(
+                                            "\n".join(
+                                                f"-{n}"
+                                                for n in PRESET_OPT_NAME[_preset]
+                                            ),
+                                            prefix="  ",
+                                        ),
+                                    )
+                                if _preset in DEFAULT_PRESET_PARAMS:
+                                    _default_params = DEFAULT_PRESET_PARAMS[_preset]
+                                    max_name_len = (
+                                        max(len(str(n)) for n in _default_params) + 1
+                                    )
+                                    log.send(
+                                        "Default val:\n{}",
+                                        textwrap.indent(
+                                            "\n".join(
+                                                f"{f'-{n}':>{max_name_len}}  {v}"
+                                                for n, v in _default_params.items()
+                                            ),
+                                            prefix="  ",
+                                        ),
+                                    )
+                            else:
+                                log.send(
+                                    "The preset '{}' has no separate help", cmd_list[2]
+                                )
+                        else:
+                            log.error("'{}' is not a member of preset", cmd_list[2])
+
+                    case None:
+                        log.error("'{}' does not exist", cmd_list[1])
+
+                    case _:
+                        log.send(_want_doc_cmd_type.value.to_doc(), is_format=False)
             else:
                 log.send(get_help_doc(), is_format=False)
 
@@ -368,35 +500,52 @@ def run_command(command: list[str] | str) -> bool:
                 log.error("Your input command has error:\n{}", e)
 
         case Cmd_type.exit:
-            sys.exit()
+            sys.exit(0)
 
-        case Cmd_type.cd | Cmd_type.mediainfo:
-            _path = None
+        case Cmd_type.cd | Cmd_type.mediainfo | Cmd_type.fontinfo:
+            _path_tuple: tuple[str, ...] | None = None
 
-            if isinstance(command, str):
-                _path = command.split(" ", maxsplit=1)
-                if len(_path) <= 1:
-                    _path = None
-                else:
-                    _path = _path[1].strip('"').strip("'")
+            match cmd_list[1]:
+                case "fd" | "cfd" as fd_param:
+                    if easyrip_web.http_server.Event.is_run_command:
+                        log.error("Disable the use of '{}' on the web", fd_param)
+                        return False
+                    _path_tuple = file_dialog(
+                        is_askdir=cmd_type is Cmd_type.cd,
+                        initialdir=os.getcwd() if fd_param == "cfd" else None,
+                    )
+                case _:
+                    if isinstance(command, str):
+                        _path = command.split(None, maxsplit=1)
+                        _path_tuple = (
+                            None
+                            if len(_path) <= 1
+                            else tuple(_path[1].strip('"').strip("'").split("?"))
+                        )
 
-            if _path is None:
-                _path = cmd_list[1]
+                    if _path_tuple is None:
+                        _path_tuple = tuple(cmd_list[1].split("?"))
 
             match cmd_type:
                 case Cmd_type.cd:
                     try:
-                        os.chdir(_path)
+                        os.chdir(_path_tuple[0])
                     except OSError as e:
                         log.error(e)
                 case Cmd_type.mediainfo:
-                    mediainfo = Media_info.from_path(_path)
-                    log.send(mediainfo)
+                    for _path in _path_tuple:
+                        log.send(f"{_path}: {Media_info.from_path(_path)}")
+                case Cmd_type.fontinfo:
+                    for _font in itertools.chain.from_iterable(
+                        load_fonts(_path) for _path in _path_tuple
+                    ):
+                        log.send(
+                            f"{_font.pathname}: {_font.familys} / {_font.font_type.name}"
+                        )
 
         case Cmd_type.dir:
             files = os.listdir(os.getcwd())
-            for f_and_s in files:
-                print(f_and_s)
+            log.print("\n".join(files))
             log.send(" | ".join(files))
 
         case Cmd_type.mkdir:
@@ -407,11 +556,12 @@ def run_command(command: list[str] | str) -> bool:
 
         case Cmd_type.cls:
             os.system("cls") if os.name == "nt" else os.system("clear")
+            easyrip_web.http_server.Event.log_queue.clear()
 
         case Cmd_type.list:
             match cmd_list[1]:
                 case "clear" | "clean":
-                    Ripper.ripper_list = []
+                    Ripper.ripper_list.clear()
                 case "del" | "pop":
                     try:
                         del Ripper.ripper_list[int(cmd_list[2]) - 1]
@@ -437,15 +587,14 @@ def run_command(command: list[str] | str) -> bool:
                             reverse=reverse,
                         )
                 case "":
-                    msg = f"Ripper list ({len(Ripper.ripper_list)}):"
-                    if Ripper.ripper_list:
-                        msg += "\n" + f"\n  {log.hr}\n".join(
-                            [
-                                f"  {i}.\n  {ripper}"
-                                for i, ripper in enumerate(Ripper.ripper_list, 1)
-                            ]
-                        )
-                    log.send(msg, is_format=False)
+                    log.send(
+                        f"Ripper list ({len(Ripper.ripper_list)}):"
+                        + f"\n {'─' * (shutil.get_terminal_size().columns - 2)}".join(
+                            f"\n  {i}.\n  {ripper}"
+                            for i, ripper in enumerate(Ripper.ripper_list, 1)
+                        ),
+                        is_format=False,
+                    )
                 case _:
                     try:
                         i1, i2 = int(cmd_list[1]), int(cmd_list[2])
@@ -457,109 +606,138 @@ def run_command(command: list[str] | str) -> bool:
                             Ripper.ripper_list[i2],
                             Ripper.ripper_list[i1],
                         )
-                    except Exception as e:
-                        log.error(f"{e!r} {e}", deep=True)
+                    except ValueError:
+                        log.error("2 int must be inputed")
+                    except IndexError:
+                        log.error("list index out of range")
 
         case Cmd_type.run:
-            is_run_exit = False
-            match cmd_list[1]:
-                case "":
-                    pass
-                case "exit":
-                    is_run_exit = True
-                case "shutdown":
-                    if _shutdown_sec_str := cmd_list[2] or "60":
-                        log.info(
-                            "Will shutdown in {}s after run finished", _shutdown_sec_str
-                        )
-                case _ as param:
-                    log.error("Unsupported param: {}", param)
-                    return False
+            is_run_exit: bool = False
 
-            run_ripper_list(is_run_exit)
+            _web_server_params = None
 
-        case Cmd_type.server:
-            if easyrip_web.http_server.Event.is_run_command:
-                log.error("Can not start multiple services")
-                return False
+            _enable_multithreading: bool = False
 
-            address, password = None, None
+            _shutdown_sec_str: str | None = None
 
-            for i in range(1, len(cmd_list)):
-                match cmd_list[i]:
-                    case "-a" | "-address":
-                        address = cmd_list[i + 1]
-                    case "-p" | "-password":
-                        password = cmd_list[i + 1]
-                    case _:
-                        if address is None:
-                            address = cmd_list[i]
-                        elif password is None:
-                            password = cmd_list[i]
-            if address:
-                res = re.match(
-                    r"^([a-zA-Z0-9.-]+)(:(\d+))?$",
-                    address,
+            _skip_run_param: int = 0
+
+            for i, cmd in enumerate(cmd_list[1:]):
+                if _skip_run_param:
+                    _skip_run_param -= 1
+                    continue
+
+                match cmd:
+                    case "":
+                        pass
+
+                    case "exit":
+                        is_run_exit = True
+
+                    case "shutdown":
+                        _skip_run_param += 1
+                        if i + 1 < len(cmd_list[1:]):
+                            _shutdown_sec_str = cmd_list[i + 1] or "60"
+                            log.info(
+                                "Will shutdown in {}s after run finished",
+                                _shutdown_sec_str,
+                            )
+                        else:
+                            log.error("{} need param", cmd)
+                            return False
+
+                    case "server":
+                        _skip_run_param += 1
+                        if (
+                            _web_server_params := get_web_server_params(cmd_list[2])
+                        ) is False:
+                            return False
+
+                    case "-multithreading":
+                        _skip_run_param += 1
+                        if i + 1 < len(cmd_list[1:]):
+                            _enable_multithreading = cmd_list[i + 1] != "0"
+                        else:
+                            log.error("{} need param", cmd)
+                            return False
+
+                    case _ as param:
+                        log.error("Unsupported param: {}", param)
+                        return False
+
+            if _web_server_params is None:
+                run_ripper_list(
+                    is_exit_when_run_finished=is_run_exit,
+                    shutdow_sec_str=_shutdown_sec_str,
+                    enable_multithreading=_enable_multithreading,
                 )
-                if res:
-                    host = res.group(1)
-                    port = res.group(2)
-                    if port:
-                        port = int(port.lstrip(":"))
-                    elif host.isdigit():
-                        port = int(host)
-                        host = None
-                    else:
-                        port = None
-                        host = None
-                else:
-                    host, port = "localhost", 0
             else:
-                host, port = "localhost", 0
+                easyrip_web.run_server(
+                    *_web_server_params,
+                    after_start_server_hook=lambda: run_ripper_list(
+                        is_exit_when_run_finished=is_run_exit,
+                        shutdow_sec_str=_shutdown_sec_str,
+                        enable_multithreading=_enable_multithreading,
+                    ),
+                )
 
-            easyrip_web.run_server(host=host or "", port=port or 0, password=password)
+        case Cmd_type.server:
+            if (_params := get_web_server_params(cmd_list[1])) is False:
+                return False
+            easyrip_web.run_server(*_params)
 
         case Cmd_type.config:
             match cmd_list[1]:
-                case "clear" | "clean" | "reset" | "regenerate":
+                case "list" | "":
+                    config.show_config_list()
+                case "regenerate" | "clear" | "clean":
                     config.regenerate_config()
                     init()
                 case "open":
                     config.open_config_dir()
                 case "set":
+                    _key = cmd_list[2]
                     _val = cmd_list[3]
+
+                    if (_old_val := config.get_user_profile(_key)) is None:
+                        return False
+
                     try:
-                        _val = int(_val)
-                    except ValueError:
+                        _val = ast.literal_eval(_val)
+                    except (ValueError, SyntaxError):
                         pass
-                    try:
-                        _val = float(_val)
-                    except ValueError:
-                        pass
-                    match _val:
-                        case "true" | "True":
-                            _val = True
-                        case "false" | "False":
-                            _val = False
 
-                    if (_old_val := config.get_user_profile(cmd_list[2])) == _val:
+                    if _old_val == _val:
                         log.info(
                             "The new value is the same as the old value, cancel the modification",
                         )
-                    elif config.set_user_profile(cmd_list[2], _val):
+                    elif config.set_user_profile(_key, _val):
                         init()
                         log.info(
-                            "'config set {}' successful: {} -> {}",
-                            cmd_list[2],
-                            _old_val,
-                            _val,
+                            "'{}' successfully: {}",
+                            f"config set {_key}",
+                            f"{f'"{_old_val}"' if isinstance(_old_val, str) else _old_val} -> {f'"{_val}"' if isinstance(_val, str) else _val}"
+                            + (
+                                ""
+                                if type(_old_val) is type(_val)
+                                else f" ({type(_old_val).__name__} -> {type(_val).__name__})"
+                            ),
                         )
-                case "list":
-                    config.show_config_list()
                 case _ as param:
                     log.error("Unsupported param: {}", param)
                     return False
 
+        case Cmd_type.prompt:
+            match cmd_list[1]:
+                case "history":
+                    with easyrip_prompt.PROMPT_HISTORY_FILE.open(
+                        "rt", encoding="utf-8"
+                    ) as f:
+                        for line in f.read().splitlines():
+                            log.send(line, is_format=False)
+                case "clear" | "clean":
+                    easyrip_prompt.clear()
+
         case Cmd_type.translate:
             if not (_infix := cmd_list[1]):
                 log.error("Need target infix")
@@ -604,22 +782,32 @@ def run_command(command: list[str] | str) -> bool:
             return True
 
         case _:
+            if shutil.which(cmd_list[0]):
+                if easyrip_web.http_server.Event.is_run_command:
+                    log.error("Disable the use of '{}' on the web", cmd_list[0])
+                    return False
+
+                os.system(command if isinstance(command, str) else " ".join(command))
+                return True
+
             input_pathname_org_list: list[str] = []
-            output_basename = None
-            output_dir = None
-            preset_name = None
+            output_basename: str | None = None
+            output_dir: str | None = None
+            preset_name: str | Ripper.Preset_name | None = None
             option_map: dict[str, str] = {}
-            is_run = False
-            is_exit_when_run_finished = False
+            is_run: bool = False
+            web_server_params = None
+            is_exit_when_run_finished: bool = False
             shutdown_sec_str: str | None = None
+            enable_multithreading: bool = False
 
-            _skip: bool = False
+            _skip: int = 0
             for i in range(len(cmd_list)):
                 if _skip:
-                    _skip = False
+                    _skip -= 1
                     continue
 
-                _skip = True
+                _skip += 1
 
                 match cmd_list[i]:
                     case "-i":
@@ -631,7 +819,9 @@ def run_command(command: list[str] | str) -> bool:
                                     )
                                     return False
                                 input_pathname_org_list += file_dialog(
-                                    os.getcwd() if fd_param == "cfd" else None
+                                    initialdir=(
+                                        os.getcwd() if fd_param == "cfd" else None
+                                    )
                                 )
                             case _:
                                 input_pathname_org_list += [
@@ -674,18 +864,51 @@ def run_command(command: list[str] | str) -> bool:
                                 is_exit_when_run_finished = True
                             case "shutdown":
                                 shutdown_sec_str = cmd_list[i + 2] or "60"
+                                _skip += 1
+                            case "server":
+                                web_server_params = get_web_server_params(
+                                    cmd_list[i + 2]
+                                )
+                                if web_server_params is False:
+                                    return False
+                                _skip += 1
+                            case _:
+                                _skip -= 1
+
+                    case "-multithreading":
+                        match cmd_list[i + 1]:
+                            case "0":
+                                enable_multithreading = False
+                            case "1":
+                                enable_multithreading = True
                             case _:
-                                _skip = False
+                                log.error("Unsupported param: {}", cmd_list[i + 1])
+                                return False
 
                     case str() as s if len(s) > 1 and s.startswith("-"):
                         option_map[s[1:]] = cmd_list[i + 1]
 
                     case _:
-                        _skip = False
+                        _skip -= 1
 
             if not preset_name:
                 log.warning("Missing '-preset' option, set to default value 'custom'")
                 preset_name = "custom"
+            if preset_name not in Ripper.Preset_name._value2member_map_:
+                log.error("'{}' is not a member of preset", preset_name)
+                return False
+
+            preset_name = Ripper.Preset_name(preset_name)
+
+            if (
+                preset_name is Ripper.Preset_name.custom
+                and easyrip_web.http_server.Event.is_run_command
+            ):
+                log.error(
+                    "Disable the use of '{}' on the web",
+                    f"-preset {Ripper.Preset_name.custom}",
+                )
+                return False
 
             try:
                 if len(input_pathname_org_list) == 0:
@@ -695,17 +918,21 @@ def run_command(command: list[str] | str) -> bool:
                 for i, input_pathname in enumerate(input_pathname_org_list):
                     new_option_map = option_map.copy()
 
-                    def _iterator_fmt_replace(match: re.Match[str]):
-                        s = match.group(1)
-                        match s:
-                            case str() as s if s.startswith("time:"):
-                                try:
-                                    return _time.strftime(s[5:])
-                                except Exception as e:
-                                    log.error(f"{e!r} {e}", deep=True)
-                                    return ""
-                            case _:
-                                try:
+                    fmt_time = datetime.now()
+
+                    def _create_iterator_fmt_replace(
+                        time: datetime, num: int
+                    ) -> Callable[[re.Match[str]], str]:
+                        def _iterator_fmt_replace(match: re.Match[str]) -> str:
+                            s = match.group(1)
+                            match s:
+                                case str() as s if s.startswith("time:"):
+                                    try:
+                                        return time.strftime(s[5:])
+                                    except Exception as e:
+                                        log.error(f"{e!r} {e}", deep=True)
+                                        return ""
+                                case _:
                                     d = {
                                         k: v
                                         for s1 in s.split(",")
@@ -714,35 +941,38 @@ def run_command(command: list[str] | str) -> bool:
                                     start = int(d.get("start", 0))
                                     padding = int(d.get("padding", 0))
                                     increment = int(d.get("increment", 1))
-                                    return str(start + i * increment).zfill(padding)
-                                except Exception as e:
-                                    log.error(f"{e!r} {e}", deep=True)
-                                    return ""
+                                    return str(start + num * increment).zfill(padding)
 
-                    if output_basename is None:
-                        new_output_basename = None
-                    else:
-                        _time = datetime.now()
+                        return _iterator_fmt_replace
 
-                        new_output_basename = re.sub(
-                            r"\?\{([^}]*)\}",
-                            _iterator_fmt_replace,
-                            output_basename,
-                        )
-
-                    if chapters := option_map.get("chapters"):
-                        chapters = re.sub(
-                            r"\?\{([^}]*)\}",
-                            _iterator_fmt_replace,
-                            chapters,
+                    try:
+                        new_output_basename = (
+                            None
+                            if output_basename is None
+                            else re.sub(
+                                r"\?\{([^}]*)\}",
+                                _create_iterator_fmt_replace(fmt_time, i),
+                                output_basename,
+                            )
                         )
 
-                        if not Path(chapters).is_file():
-                            log.warning(
-                                "The '-chapters' file {} does not exist", chapters
+                        if chapters := option_map.get("chapters"):
+                            chapters = re.sub(
+                                r"\?\{([^}]*)\}",
+                                _create_iterator_fmt_replace(fmt_time, i),
+                                chapters,
                             )
 
-                        new_option_map["chapters"] = chapters
+                            if not Path(chapters).is_file():
+                                log.warning(
+                                    "The '-chapters' file {} does not exist", chapters
+                                )
+
+                            new_option_map["chapters"] = chapters
+
+                    except ValueError as e:
+                        log.error("Unsupported param: {}", e)
+                        return False
 
                     input_pathname_list: list[str] = input_pathname.split("?")
                     for path in input_pathname_list:
@@ -801,7 +1031,7 @@ def run_command(command: list[str] | str) -> bool:
                                         f"{new_output_basename or _input_basename[0]}{_output_base_suffix_name}"
                                     ],
                                     output_dir,
-                                    Ripper.PresetName(preset_name),
+                                    preset_name,
                                     new_option_map,
                                 )
 
@@ -818,7 +1048,7 @@ def run_command(command: list[str] | str) -> bool:
                                 input_pathname_list,
                                 [new_output_basename],
                                 output_dir,
-                                Ripper.PresetName(preset_name),
+                                preset_name,
                                 new_option_map,
                             )
 
@@ -827,7 +1057,7 @@ def run_command(command: list[str] | str) -> bool:
                             input_pathname_list,
                             [new_output_basename],
                             output_dir,
-                            Ripper.PresetName(preset_name),
+                            preset_name,
                             new_option_map,
                         )
 
@@ -836,38 +1066,56 @@ def run_command(command: list[str] | str) -> bool:
                 return False
 
             if is_run:
-                run_ripper_list(is_exit_when_run_finished, shutdown_sec_str)
+                if web_server_params is None:
+                    run_ripper_list(
+                        is_exit_when_run_finished=is_exit_when_run_finished,
+                        shutdow_sec_str=shutdown_sec_str,
+                        enable_multithreading=enable_multithreading,
+                    )
+                else:
+                    easyrip_web.run_server(
+                        *web_server_params,
+                        after_start_server_hook=lambda: run_ripper_list(
+                            is_exit_when_run_finished=is_exit_when_run_finished,
+                            shutdow_sec_str=shutdown_sec_str,
+                            enable_multithreading=enable_multithreading,
+                        ),
+                    )
 
     return True
 
 
-def init(is_first_run: bool = False):
+def init(is_first_run: bool = False) -> None:
     if is_first_run:
         # 当前路径添加到环境变量
         new_path = os.path.realpath(os.getcwd())
-        if os.pathsep in (current_path := os.environ.get("PATH", "")):
-            if new_path not in current_path.split(os.pathsep):
-                updated_path = f"{new_path}{os.pathsep}{current_path}"
-                os.environ["PATH"] = updated_path
+        if os.pathsep in (
+            current_path := os.environ.get("PATH", "")
+        ) and new_path not in current_path.split(os.pathsep):
+            updated_path = f"{new_path}{os.pathsep}{current_path}"
+            os.environ["PATH"] = updated_path
 
     # 设置语言
     _sys_lang = get_system_language()
     Global_lang_val.gettext_target_lang = _sys_lang
-    if (_lang_config := config.get_user_profile("language")) not in {"auto", None}:
+    if (_lang_config := config.get_user_profile(Config_key.language)) not in {
+        "auto",
+        None,
+    }:
         Global_lang_val.gettext_target_lang = Lang_tag.from_str(str(_lang_config))
 
     # 设置日志文件路径名
-    log.html_filename = gettext("encoding_log.html")
-    if _path := str(config.get_user_profile("force_log_file_path") or ""):
+    log.html_filename = gettext(log.html_filename)
+    if _path := str(config.get_user_profile(Config_key.force_log_file_path) or ""):
         log.html_filename = os.path.join(_path, log.html_filename)
 
     # 设置日志级别
     try:
         log.print_level = getattr(
-            log.LogLevel, str(config.get_user_profile("log_print_level"))
+            log.LogLevel, str(config.get_user_profile(Config_key.log_print_level))
         )
         log.write_level = getattr(
-            log.LogLevel, str(config.get_user_profile("log_write_level"))
+            log.LogLevel, str(config.get_user_profile(Config_key.log_write_level))
         )
     except Exception as e:
         log.error(f"{e!r} {e}", deep=True)
@@ -875,8 +1123,18 @@ def init(is_first_run: bool = False):
     if is_first_run:
         # 设置启动目录
         try:
-            if _path := str(config.get_user_profile("startup_directory")):
-                os.chdir(_path)
+            if _startup_dir := config.get_user_profile(Config_key.startup_dir):
+                if _startup_dir_blacklist := config.get_user_profile(
+                    Config_key.startup_dir_blacklist
+                ):
+                    if any(
+                        Path.cwd().samefile(d)
+                        for d in map(Path, _startup_dir_blacklist)
+                        if d.is_dir()
+                    ):
+                        os.chdir(_startup_dir)
+                else:
+                    os.chdir(_startup_dir)
         except Exception as e:
             log.error(f"{e!r} {e}", deep=True)
 
@@ -900,9 +1158,7 @@ def init(is_first_run: bool = False):
         if (
             lang_tag := Lang_tag.from_str(file.stem[5:])
         ).language is not Lang_tag_language.Unknown:
-            easyrip_mlang.all_supported_lang_map[lang_tag] = {
-                k: v for k, v in lang_map.items()
-            }
+            easyrip_mlang.all_supported_lang_map[lang_tag] = lang_map
 
             log.debug("Loading \"{}\" as '{}' language successfully", file, lang_tag)
 
@@ -911,11 +1167,5 @@ def init(is_first_run: bool = False):
         Thread(target=check_env, daemon=True).start()
 
         LogEvent.append_http_server_log_queue = (
-            lambda message: easyrip_web.http_server.Event.log_queue.append(message)
+            easyrip_web.http_server.Event.log_queue.append
         )
-
-        def _post_run_event(cmd: str):
-            run_command(cmd)
-            easyrip_web.http_server.Event.is_run_command = False
-
-        easyrip_web.http_server.Event.post_run_event = _post_run_event