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

easyrip/easyrip_command.py

@@ -1,16 +1,48 @@
 import enum
+import itertools
 import textwrap
+from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import Self
+from typing import Final, Self, final
+
+from prompt_toolkit.completion import (
+    Completer,
+    DeduplicateCompleter,
+    FuzzyCompleter,
+    FuzzyWordCompleter,
+    NestedCompleter,
+    WordCompleter,
+    merge_completers,
+)
+from prompt_toolkit.completion.base import CompleteEvent, Completion
+from prompt_toolkit.document import Document
 
 from . import global_val
+from .easyrip_config.config_key import Config_key
+from .ripper.param import Audio_codec, Preset_name
 
 
+@final
 @dataclass(slots=True, init=False, eq=False)
 class Cmd_type_val:
-    name: str
-    opt_str: str
+    names: tuple[str, ...]
+    _param: str
     _description: str
+    childs: tuple["Cmd_type_val", ...]
+
+    @property
+    def param(self) -> str:
+        try:
+            from .easyrip_mlang import gettext
+
+            return gettext(self._param, is_format=False)
+
+        except ImportError:  # 启动时，原字符串导入翻译文件
+            return self._param
+
+    @param.setter
+    def param(self, val: str) -> None:
+        self._param = val
 
     @property
     def description(self) -> str:
@@ -23,56 +55,58 @@ class Cmd_type_val:
             return self._description
 
     @description.setter
-    def description(self, val: str):
+    def description(self, val: str) -> None:
         self._description = val
 
     def __init__(
         self,
-        name: str,
+        names: tuple[str, ...],
         *,
-        opt_str: str,
+        param: str = "",
         description: str = "",
+        childs: tuple["Cmd_type_val", ...] = (),
     ) -> None:
-        self.name = name
-        self.opt_str = opt_str
+        self.names = names
+        self.param = param
         self.description = description
+        self.childs = childs
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Cmd_type_val):
-            return self.name == other.name
+            return self.names == other.names
         return False
 
     def __hash__(self) -> int:
-        return hash(self.name)
+        return hash(self.names)
 
     def to_doc(self) -> str:
-        return (
-            f"{self.opt_str}\n{textwrap.indent(self.description, ' │', lambda _: True)}"
-        )
+        return f"{' / '.join(self.names)} {self.param}\n{textwrap.indent(self.description, ' │ ', lambda _: True)}"
 
 
 class Cmd_type(enum.Enum):
     help = h = Cmd_type_val(
-        "help",
-        opt_str="h / help [<cmd>]",
-        description="Show full help or show the <cmd> help",
+        ("h", "help"),
+        param="[<cmd> [<cmd param>]]",
+        description=(
+            "Show full help or show the <cmd> help.\n"
+            "e.g. help list\n"  # .
+            "e.g. h -p x265slow"
+        ),
     )
     version = v = ver = Cmd_type_val(
-        "version",
-        opt_str="v / ver / version",
+        ("v", "ver", "version"),
         description="Show version info",
     )
     init = Cmd_type_val(
-        "init",
-        opt_str="init",
+        ("init",),
         description=(
             "Execute initialization function\n"
             "e.g. you can execute it after modifying the dynamic translation file"
         ),
     )
     log = Cmd_type_val(
-        "log",
-        opt_str="log [<LogLevel>] <string>",
+        ("log",),
+        param="[<LogLevel>] <string>",
         description=(
             "Output custom log\n"
             "log level:\n"
@@ -83,10 +117,17 @@ class Cmd_type(enum.Enum):
             "  debug\n"
             "  Default: info"
         ),
+        childs=(
+            Cmd_type_val(("info",)),
+            Cmd_type_val(("warning", "warn")),
+            Cmd_type_val(("error", "err")),
+            Cmd_type_val(("send",)),
+            Cmd_type_val(("debug",)),
+        ),
     )
     _run_any = Cmd_type_val(
-        "$",
-        opt_str="$ <code>",
+        ("$",),
+        param="<code>",
         description=(
             "Run code directly from the internal environment.\n"
             "Execute the code string directly after the '$'.\n"
@@ -94,33 +135,35 @@ class Cmd_type(enum.Enum):
         ),
     )
     exit = Cmd_type_val(
-        "exit",
-        opt_str="exit",
+        ("exit",),
+        param="exit",
         description="Exit this program",
     )
     cd = Cmd_type_val(
-        "cd",
-        opt_str="cd <string>",
+        ("cd",),
+        param="<<path> | 'fd' | 'cfd'>",
         description="Change current working directory",
+        childs=(
+            Cmd_type_val(("fd",)),
+            Cmd_type_val(("cfd",)),
+        ),
     )
-    dir = Cmd_type_val(
-        "dir",
-        opt_str="dir",
+    dir = ls = Cmd_type_val(
+        ("dir", "ls"),
         description="Print files and folders' name in the current working directory",
     )
     mkdir = makedir = Cmd_type_val(
-        "mkdir",
-        opt_str="mkdir / makedir <string>",
+        ("mkdir", "makedir"),
+        param="<string>",
         description="Create a new path",
     )
     cls = clear = Cmd_type_val(
-        "cls",
-        opt_str="cls / clear",
+        ("cls", "clear"),
         description="Clear screen",
     )
     list = Cmd_type_val(
-        "list",
-        opt_str="list <list option>",
+        ("list",),
+        param="<list option>",
         description=(
             "Operate Ripper list\n"
             " \n"
@@ -141,27 +184,40 @@ class Cmd_type(enum.Enum):
             "<int> <int>:\n"
             "  Exchange specified index"
         ),
+        childs=(
+            Cmd_type_val(("clear", "clean")),
+            Cmd_type_val(("del", "pop")),
+            Cmd_type_val(("sort",), childs=(Cmd_type_val(("n", "r", "nr")),)),
+        ),
     )
     run = Cmd_type_val(
-        "run",
-        opt_str="run [<run option>]",
+        ("run",),
+        param="[<run option>] [-multithreading <0 | 1>]",
         description=(
             "Run the Ripper in the Ripper list\n"
-            " \n"
+            "\n"
             "Default:\n"
             "  Only run\n"
-            " \n"
+            "\n"
             "exit:\n"
             "  Close program when run finished\n"
-            " \n"
+            "\n"
             "shutdown [<sec>]:\n"
             "  Shutdown when run finished\n"
-            "  Default: 60"
+            "  Default: 60\n"
+            "\n"
+            "server [<address>]:[<port>]@[<password>]:\n"
+            "  See the corresponding help for details"
+        ),
+        childs=(
+            Cmd_type_val(("exit",)),
+            Cmd_type_val(("shutdown",)),
+            Cmd_type_val(("server",)),
         ),
     )
     server = Cmd_type_val(
-        "server",
-        opt_str="server [[-a | -address] <address>[:<port>] [[-p | -password] <password>]]",
+        ("server",),
+        param="[<address>]:[<port>]@[<password>]",
         description=(
             "Boot web service\n"
             "Default: server localhost:0\n"
@@ -169,10 +225,10 @@ class Cmd_type(enum.Enum):
         ),
     )
     config = Cmd_type_val(
-        "config",
-        opt_str="config <config option>",
+        ("config",),
+        param="<config option>",
         description=(
-            "regenerate | clear | clean | reset\n"
+            "regenerate | clear | clean\n"
             "  Regenerate config file\n"
             "open\n"
             "  Open the directory where the config file is located\n"
@@ -182,23 +238,60 @@ class Cmd_type(enum.Enum):
             "  Set config\n"
             "  e.g. config set language zh"
         ),
+        childs=(
+            Cmd_type_val(("regenerate", "clear", "clean")),
+            Cmd_type_val(("open",)),
+            Cmd_type_val(("list",)),
+            Cmd_type_val(
+                ("set",),
+                childs=tuple(Cmd_type_val((k,)) for k in Config_key._member_map_),
+            ),
+        ),
+    )
+    prompt = Cmd_type_val(
+        ("prompt",),
+        param="<prompt option>",
+        description=(
+            "history\n"  # .
+            "  Show prompt history\n"
+            "clear | clean\n"
+            "  Delete history file"
+        ),
+        childs=(
+            Cmd_type_val(("history",)),
+            Cmd_type_val(("clear", "clean")),
+        ),
     )
     translate = Cmd_type_val(
-        "translate",
-        opt_str="translate <files' infix> <target lang tag> [-overwrite]",
+        ("translate",),
+        param="<files' infix> <target lang tag> [-overwrite]",
         description=(
             "Translate subtitle files\n"
             "e.g. 'translate zh-Hans zh-Hant' will translate all '*.zh-Hans.ass' files into zh-Hant"
         ),
+        childs=(Cmd_type_val(("-overwrite",)),),
     )
     mediainfo = Cmd_type_val(
-        "mediainfo",
-        opt_str="mediainfo <path>",
+        ("mediainfo",),
+        param="<<path> | 'fd' | 'cfd'>",
         description="Get the media info by the Media_info class",
+        childs=(
+            Cmd_type_val(("fd",)),
+            Cmd_type_val(("cfd",)),
+        ),
+    )
+    fontinfo = Cmd_type_val(
+        ("fontinfo",),
+        param="<<path> | 'fd' | 'cfd'>",
+        description="Get the font info by the Font class",
+        childs=(
+            Cmd_type_val(("fd",)),
+            Cmd_type_val(("cfd",)),
+        ),
     )
     Option = Cmd_type_val(
-        "Option",
-        opt_str="<Option> ...",
+        ("Option",),
+        param="...",
         description=(
             "-i <input> -p <preset name> [-o <output>] [-o:dir <dir>] [-pipe <vpy pathname> -crf <val> -psy-rd <val> ...] [-sub <subtitle pathname>] [-c:a <audio encoder> -b:a <audio bitrate>] [-muxer <muxer> [-r <fps>]] [-run [<run option>]] [...]\n"
             " \n"
@@ -209,7 +302,7 @@ class Cmd_type(enum.Enum):
     @classmethod
     def from_str(cls, s: str) -> Self | None:
         guess_str = s.replace("-", "_").replace(":", "_")
-        if guess_str in cls._member_map_.keys():
+        if guess_str in cls._member_map_:
             return cls[guess_str]
         return None
 
@@ -220,21 +313,25 @@ class Cmd_type(enum.Enum):
 
 class Opt_type(enum.Enum):
     _i = Cmd_type_val(
-        "-i",
-        opt_str="-i <string[::string[?string...]...] | 'fd' | 'cfd'>",
+        ("-i",),
+        param="<<path>[::<path>[?<path>...]...] | 'fd' | 'cfd'>",
         description=(
             "Input files' pathname or enter 'fd' to use file dialog, 'cfd' to open from the current directory\n"
             "In some cases, it is allowed to use '?' as a delimiter to input multiple into a Ripper, for example, 'preset subset' allows multiple ASS inputs"
         ),
+        childs=(
+            Cmd_type_val(("fd",)),
+            Cmd_type_val(("cfd",)),
+        ),
     )
     _o_dir = Cmd_type_val(
-        "-o:dir",
-        opt_str="-o:dir <string>",
+        ("-o:dir",),
+        param="<path>",
         description="Destination directory of the output file",
     )
     _o = Cmd_type_val(
-        "-o",
-        opt_str="-o <string>",
+        ("-o",),
+        param="<path>",
         description=(
             "Output file basename's prefix\n"
             "Allow iterators and time formatting for multiple inputs\n"
@@ -242,58 +339,52 @@ class Opt_type(enum.Enum):
         ),
     )
     _auto_infix = Cmd_type_val(
-        "-auto-infix",
-        opt_str="-auto-infix <0 | 1>",
+        ("-auto-infix",),
+        param="<0 | 1>",
         description=(
             "If enable, output file name will add auto infix:\n"
             "  no audio: '.v'\n"
             "  with audio: '.va'\n"
             "Default: 1"
         ),
+        childs=(Cmd_type_val(("0", "1")),),
     )
     _preset = _p = Cmd_type_val(
-        "-preset",
-        opt_str="-p / -preset <string>",
+        ("-p", "-preset"),
+        param="<string>",
         description=(
             "Setting preset\n"
-            "Preset name:\n"
-            "  custom\n"
-            "  subset\n"
-            "  copy\n"
-            "  flac\n"
-            "  x264fast x264slow\n"
-            "  x265fast4 x265fast3 x265fast2 x265fast x265slow x265full\n"
-            "  h264_amf h264_nvenc h264_qsv\n"
-            "  hevc_amf hevc_nvenc hevc_qsv\n"
-            "  av1_amf av1_nvenc av1_qsv"
+            "Preset name:\n"  # .
+            f"{Preset_name.to_help_string('  ')}"
         ),
+        childs=(Cmd_type_val(tuple(Preset_name._value2member_map_)),),
     )
     _pipe = Cmd_type_val(
-        "-pipe",
-        opt_str="-pipe <string>",
+        ("-pipe",),
+        param="<string>",
         description=(
             "Select a vpy file as pipe to input, this vpy must have input global val\n"
             "The input in vspipe: vspipe -a input=<input> filter.vpy"
         ),
     )
     _pipe_gvar = Cmd_type_val(
-        "-pipe",
-        opt_str="-pipe:gvar <key>=<val>[:...]",
+        ("-pipe:gvar",),
+        param="<key>=<val>[:...]",
         description=(
             "Customize the global variables passed to vspipe, and use ':' intervals for multiple variables\n"
             '  e.g. -pipe:gvar "a=1 2 3:b=abc" -> vspipe -a "a=1 2 3" -a "b=abc"'
         ),
     )
     _vf = Cmd_type_val(
-        "-vf",
-        opt_str="-vf <string>",
+        ("-vf",),
+        param="<string>",
         description=(
             "Customize FFmpeg's -vf\nUsing it together with -sub is undefined behavior"
         ),
     )
     _sub = Cmd_type_val(
-        "-sub",
-        opt_str="-sub <string | 'auto' | 'auto:...'>",
+        ("-sub",),
+        param="<<path> | 'auto' | 'auto:...'>",
         description=(
             "It use libass to make hard subtitle, input a subtitle pathname when you need hard subtitle\n"
             'It can add multiple subtitles by "::"\n'
@@ -302,44 +393,51 @@ class Opt_type(enum.Enum):
             "'auto:...' can only select which match infix.\n"
             "  e.g. 'auto:zh-Hans:zh-Hant'"
         ),
+        childs=(Cmd_type_val(("auto",)),),
     )
     _only_mux_sub_path = Cmd_type_val(
-        "-only-mux-sub-path",
-        opt_str="-only-mux-sub-path <string>",
+        ("-only-mux-sub-path",),
+        param="<path>",
         description="All subtitles and fonts in this path will be muxed",
     )
     _soft_sub = Cmd_type_val(
-        "-soft-sub",
-        opt_str="-soft-sub <string[?string...] | 'auto' | 'auto:...'>",
-        description="Mux ASS subtitles in MKV with subset",
+        ("-soft-sub",),
+        param="<<path>[?<path>...] | 'auto' | 'auto:...'>",
+        description=(
+            "Mux ASS subtitles in MKV with subset\n"  # .
+            "The usage of 'auto' is detailed in '-sub'"
+        ),
+        childs=(Cmd_type_val(("auto",)),),
     )
     _subset_font_dir = Cmd_type_val(
-        "-subset-font-dir",
-        opt_str="-subset-font-dir <string[?string...]>",
+        ("-subset-font-dir",),
+        param="<<path>[?<path>...]>",
         description=(
             "The fonts directory when subset\n"
             'Default: Prioritize the current directory, followed by folders containing "font" (case-insensitive) within the current directory'
         ),
     )
     _subset_font_in_sub = Cmd_type_val(
-        "-subset-font-in-sub",
-        opt_str="-subset-font-in-sub <0 | 1>",
+        ("-subset-font-in-sub",),
+        param="<0 | 1>",
         description=(
             "Encode fonts into ASS file instead of standalone files\n"  # .
             "Default: 0"
         ),
+        childs=(Cmd_type_val(("0", "1")),),
     )
     _subset_use_win_font = Cmd_type_val(
-        "-subset-use-win-font",
-        opt_str="-subset-use-win-font <0 | 1>",
+        ("-subset-use-win-font",),
+        param="<0 | 1>",
         description=(
             "Use Windows fonts when can not find font in subset-font-dir\n"  # .
             "Default: 0"
         ),
+        childs=(Cmd_type_val(("0", "1")),),
     )
     _subset_use_libass_spec = Cmd_type_val(
-        "-subset-use-libass-spec",
-        opt_str="-subset-use-libass-spec <0 | 1>",
+        ("-subset-use-libass-spec",),
+        param="<0 | 1>",
         description=(
             "Use libass specification when subset\n"
             'e.g. "11\\{22}33" ->\n'
@@ -347,59 +445,61 @@ class Opt_type(enum.Enum):
             '  "11{22}33" (libass)\n'
             "Default: 0"
         ),
+        childs=(Cmd_type_val(("0", "1")),),
     )
     _subset_drop_non_render = Cmd_type_val(
-        "-subset-drop-non-render",
-        opt_str="-subset-use-libass-spec <0 | 1>",
+        ("-subset-drop-non-render",),
+        param="<0 | 1>",
         description=(
             "Drop non rendered content such as Comment lines, Name, Effect, etc. in ASS\n"
             "Default: 1"
         ),
+        childs=(Cmd_type_val(("0", "1")),),
     )
     _subset_drop_unkow_data = Cmd_type_val(
-        "-subset-drop-unkow-data",
-        opt_str="-subset-drop-unkow-data <0 | 1>",
+        ("-subset-drop-unkow-data",),
+        param="<0 | 1>",
         description=(
             "Drop lines that are not in {[Script Info], [V4+ Styles], [Events]} in ASS\n"
             "Default: 1"
         ),
+        childs=(Cmd_type_val(("0", "1")),),
     )
     _subset_strict = Cmd_type_val(
-        "-subset-strict",
-        opt_str="-subset-strict <0 | 1>",
+        ("-subset-strict",),
+        param="<0 | 1>",
         description=(
             "Some error will interrupt subset\n"  # .
             "Default: 0"
         ),
+        childs=(Cmd_type_val(("0", "1")),),
     )
     _translate_sub = Cmd_type_val(
-        "-translate-sub",
-        opt_str="-translate-sub <infix>:<language-tag>",
+        ("-translate-sub",),
+        param="<infix>:<language-tag>",
         description=(
             "Temporary generation of subtitle translation files\n"
             "e.g. 'zh-Hans:zh-Hant' will temporary generation of Traditional Chinese subtitles"
         ),
     )
     _c_a = Cmd_type_val(
-        "-c:a",
-        opt_str="-c:a <string>",
+        ("-c:a",),
+        param="<string>",
         description=(
             "Setting audio encoder\n"
-            " \n"  # .
-            "Audio encoder:\n"
-            "  copy\n"
-            "  libopus\n"
-            "  flac"
+            "Audio encoder:\n"  # .
+            f"{Audio_codec.to_help_string('  ')}"
         ),
+        childs=(Cmd_type_val(tuple(Audio_codec._value2member_map_)),),
     )
     _b_a = Cmd_type_val(
-        "-b:a",
-        opt_str="-b:a <string>",
+        ("-b:a",),
+        param="<string>",
         description="Setting audio bitrate. Default '160k'",
     )
     _muxer = Cmd_type_val(
-        "-muxer",
-        opt_str="-muxer <string>",
+        ("-muxer",),
+        param="<string>",
         description=(
             "Setting muxer\n"
             " \n"  # .
@@ -409,24 +509,25 @@ class Opt_type(enum.Enum):
         ),
     )
     _r = _fps = Cmd_type_val(
-        "-r",
-        opt_str="-r / -fps <string | 'auto'>",
+        ("-r", "-fps"),
+        param="<string | 'auto'>",
         description=(
             "Setting FPS when muxing\n"
             "When using auto, the frame rate is automatically obtained from the input video and adsorbed to the nearest preset point"
         ),
+        childs=(Cmd_type_val(("auto",)),),
     )
     _chapters = Cmd_type_val(
-        "-chapters",
-        opt_str="-chapters <string>",
+        ("-chapters",),
+        param="<path>",
         description=(
             "Specify the chapters file to add\n"
             "Supports the same iteration syntax as '-o'"
         ),
     )
     _custom_template = _custom = _custom_format = Cmd_type_val(
-        "-custom:format",
-        opt_str="-custom / -custom:format / -custom:template <string>",
+        ("-custom", "-custom:format", "-custom:tempate"),
+        param="<string>",
         description=(
             "When -preset custom, this option will run\n"
             "String escape: \\34/ -> \", \\39/ -> ', '' -> \"\n"
@@ -434,89 +535,106 @@ class Opt_type(enum.Enum):
         ),
     )
     _custom_suffix = Cmd_type_val(
-        "-custom:suffix",
-        opt_str="-custom:suffix <string>",
+        ("-custom:suffix",),
+        param="<string>",
         description=(
             "When -preset custom, this option will be used as a suffix for the output file\n"
             'Default: ""'
         ),
     )
     _run = Cmd_type_val(
-        "-run",
-        opt_str="-run [<string>]",
+        ("-run",),
+        param="[<string>]",
         description=(
             "Run the Ripper from the Ripper list\n"
-            " \n"
+            "\n"
             "Default:\n"
             "  Only run\n"
-            " \n"
+            "\n"
             "exit:\n"
             "  Close program when run finished\n"
-            " \n"
+            "\n"
             "shutdown [<sec>]:\n"
             "  Shutdown when run finished\n"
             "  Default: 60\n"
+            "\n"
+            "server [<address>]:[<port>]@[<password>]:\n"
+            "  See the corresponding help for details"
+        ),
+        childs=(
+            Cmd_type_val(("exit",)),
+            Cmd_type_val(("shutdown",)),
+            Cmd_type_val(("server",)),
         ),
     )
     _ff_params_ff = _ff_params = Cmd_type_val(
-        "-ff-params:ff",
-        opt_str="-ff-params / -ff-params:ff <string>",
+        ("-ff-params", "-ff-params:ff"),
+        param="<string>",
         description=(
             "Set FFmpeg global options\n"  # .
             "Same as ffmpeg <option> ... -i ..."
         ),
     )
     _ff_params_in = Cmd_type_val(
-        "-ff-params:in",
-        opt_str="-ff-params:in <string>",
+        ("-ff-params:in",),
+        param="<string>",
         description=(
             "Set FFmpeg input options\n"  # .
             "Same as ffmpeg ... <option> -i ..."
         ),
     )
     _ff_params_out = Cmd_type_val(
-        "-ff-params:out",
-        opt_str="-ff-params:out <string>",
+        ("-ff-params:out",),
+        param="<string>",
         description=(
             "Set FFmpeg output options\n"  # .
             "Same as ffmpeg -i ... <option> ..."
         ),
     )
     _hwaccel = Cmd_type_val(
-        "-hwaccel",
-        opt_str="-hwaccel <string>",
+        ("-hwaccel",),
+        param="<string>",
         description="Use FFmpeg hwaccel (See 'ffmpeg -hwaccels' for details)",
     )
     _ss = Cmd_type_val(
-        "-ss",
-        opt_str="-ss <time>",
+        ("-ss",),
+        param="<time>",
         description=(
             "Set FFmpeg input file start time\n"  # .
             "Same as ffmpeg -ss <time> -i ..."
         ),
     )
     _t = Cmd_type_val(
-        "-t",
-        opt_str="-t <time>",
+        ("-t",),
+        param="<time>",
         description=(
             "Set FFmpeg output file duration\n"  # .
             "Same as ffmpeg -i ... -t <time> ..."
         ),
     )
     _hevc_strict = Cmd_type_val(
-        "-hevc-strict",
-        opt_str="-hevc-strict <0 | 1>",
+        ("-hevc-strict",),
+        param="<0 | 1>",
         description=(
-            "Auto reduce the --ref\n"  # .
-            "When the resolution >= 4k, close HME\n"
+            "When the resolution >= 4K, close HME, and auto reduce the -ref\n"  # .
             "Default: 1"
         ),
+        childs=(Cmd_type_val(("0", "1")),),
+    )
+    _multithreading = Cmd_type_val(
+        ("-multithreading",),
+        param="<0 | 1>",
+        description=(
+            "Use multi-threading to run Ripper list, suitable for situations with low performance occupancy\n"
+            "e.g. -p subset or -p copy"
+        ),
+        childs=(Cmd_type_val(("0", "1")),),
     )
 
     @classmethod
     def from_str(cls, s: str) -> Self | None:
         guess_str = s.replace("-", "_").replace(":", "_")
-        if guess_str in cls._member_map_.keys():
+        if guess_str in cls._member_map_:
             return cls[guess_str]
         return None
 
@@ -525,6 +643,11 @@ class Opt_type(enum.Enum):
         return "\n\n".join(ct.value.to_doc() for ct in cls)
 
 
+Cmd_type.help.value.childs = tuple(
+    ct.value for ct in itertools.chain(Cmd_type, Opt_type) if ct is not Cmd_type.help
+)
+
+
 def get_help_doc() -> str:
     from .easyrip_mlang import gettext
 
@@ -534,15 +657,201 @@ def get_help_doc() -> str:
         "\n"
         f"{gettext('Help')}:\n"
         "\n"
-        f"  {gettext('You can input command or use command-line arguments to run.')}\n"
+        f"{textwrap.indent(gettext("Enter '<cmd> [<param> ...]' to execute Easy Rip commands or any commands that exist in environment.\nOr enter '<option> <param> [<option> <param> ...]' to add Ripper."), '  ')}\n"
         "\n"
         "\n"
-        f"{gettext('Commands')}:\n"
+        f"{gettext('Easy Rip Commands')}:\n"
         "\n"
-        f"{textwrap.indent(Cmd_type.to_doc(), '  ')}"
+        f"{textwrap.indent(Cmd_type.to_doc(), '  ')}\n"
         "\n"
         "\n"
         f"{gettext('Ripper options')}:\n"
         "\n"
         f"{textwrap.indent(Opt_type.to_doc(), '  ')}"
     )
+
+
+type nested_dict = dict[str, "nested_dict | Completer"]
+META_DICT_OPT_TYPE = {
+    name: lambda opt=opt: opt.value.param
+    for opt in Opt_type
+    for name in opt.value.names
+}
+META_DICT_CMD_TYPE = {
+    name: lambda opt=opt: opt.value.param
+    for opt in Cmd_type
+    for name in opt.value.names
+}
+
+
+def _nested_dict_to_nc(n_dict: nested_dict) -> NestedCompleter:
+    return NestedCompleter(
+        {
+            k: (v if isinstance(v, Completer) else _nested_dict_to_nc(v) if v else None)
+            for k, v in n_dict.items()
+        }
+    )
+
+
+class CmdCompleter(NestedCompleter):
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        # Split document.
+        text = document.text_before_cursor.lstrip()
+        words = text.split()
+        stripped_len = len(document.text_before_cursor) - len(text)
+
+        # If there is a space, check for the first term, and use a
+        # subcompleter.
+        if " " in text:
+            first_term = text.split()[0]
+            completer = self.options.get(first_term)
+
+            # If we have a sub completer, use this for the completions.
+            if completer is not None:
+                remaining_text = text[len(first_term) :].lstrip()
+                move_cursor = len(text) - len(remaining_text) + stripped_len
+
+                new_document = Document(
+                    remaining_text,
+                    cursor_position=document.cursor_position - move_cursor,
+                )
+
+                yield from completer.get_completions(new_document, complete_event)
+
+        elif words and (_cmd := Cmd_type.from_str(words[-1])) is not None:
+            yield from (
+                Completion(
+                    text=words[-1],
+                    start_position=-len(words[-1]),
+                    display_meta=META_DICT_CMD_TYPE.get(words[-1], ""),
+                ),
+                Completion(
+                    text="",
+                    display="✔",
+                    display_meta=(
+                        f"{_desc_list[0]}..."
+                        if len(_desc_list := _cmd.value.description.split("\n")) > 1
+                        else _desc_list[0]
+                    ),
+                ),
+            )
+
+        # No space in the input: behave exactly like `WordCompleter`.
+        else:
+            # custom
+            completer = FuzzyWordCompleter(
+                tuple(self.options),
+                meta_dict=META_DICT_CMD_TYPE,  # pyright: ignore[reportArgumentType]
+                WORD=True,
+            )
+            yield from completer.get_completions(document, complete_event)
+
+
+class OptCompleter(Completer):
+    def __init__(self, *, opt_tree: nested_dict) -> None:
+        self.opt_tree: Final[nested_dict] = opt_tree
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        text = document.text_before_cursor.lstrip()
+
+        words = text.split()
+
+        if len(words) >= 1 and not text.startswith("-"):
+            return
+
+        opt_tree_pos_list: list[nested_dict | Completer] = [self.opt_tree]
+
+        for word in words:
+            if isinstance(opt_tree_pos_list[-1], Completer):
+                opt_tree_pos_list.append(self.opt_tree.get(word, self.opt_tree))
+            else:
+                opt_tree_pos_list.append(
+                    opt_tree_pos_list[-1].get(
+                        word, self.opt_tree.get(word, self.opt_tree)
+                    )
+                )
+
+        if opt_tree_pos_list[-1] is not self.opt_tree and not text.endswith(" "):
+            yield from (
+                Completion(
+                    text=words[-1],
+                    start_position=-len(words[-1]),
+                    display_meta=META_DICT_OPT_TYPE.get(words[-1], ""),
+                ),
+                Completion(
+                    text="",
+                    display="✔",
+                    display_meta=(
+                        ""
+                        if (_opt := Opt_type.from_str(text)) is None
+                        else f"{_desc_list[0]}..."
+                        if len(_desc_list := _opt.value.description.split("\n")) > 1
+                        else _desc_list[0]
+                    ),
+                ),
+            )
+
+        elif isinstance(opt_tree_pos_list[-1], Completer):
+            # 直接使用 PathCompleter 会因为上下文问题失效，所以将上文套进 NestedCompleter
+            new_nd: nested_dict = {}
+            new_nd_pos: nested_dict = new_nd
+            for word in words[:-1]:
+                new_nd_pos[word] = new_nd_pos = {}
+            new_nd_pos[words[-1]] = opt_tree_pos_list[-1]
+
+            yield from _nested_dict_to_nc(new_nd).get_completions(
+                document=document, complete_event=complete_event
+            )
+
+        elif len(words) >= 2 and isinstance(opt_tree_pos_list[-2], Completer):
+            new_nd: nested_dict = {}
+            new_nd_pos: nested_dict = new_nd
+            for word in words[:-2]:
+                new_nd_pos[word] = new_nd_pos = {}
+            new_nd_pos[words[-2]] = opt_tree_pos_list[-2]
+
+            yield from merge_completers(
+                (
+                    DeduplicateCompleter(
+                        merge_completers(
+                            (
+                                _nested_dict_to_nc(new_nd),
+                                FuzzyCompleter(_nested_dict_to_nc(new_nd), WORD=True),
+                            )
+                        )
+                    ),
+                    FuzzyCompleter(
+                        WordCompleter(
+                            words=tuple(opt_tree_pos_list[-1]),
+                            meta_dict=META_DICT_OPT_TYPE,
+                            WORD=True,  # 匹配标点
+                            match_middle=True,
+                        ),
+                        WORD=False,
+                    ),
+                )
+            ).get_completions(document=document, complete_event=complete_event)
+
+        else:
+            yield from FuzzyCompleter(
+                WordCompleter(
+                    words=tuple(
+                        opt_tree_pos_list[-1]
+                        | (
+                            {}
+                            if text.endswith(" ")
+                            or len(words) <= 1
+                            or isinstance(opt_tree_pos_list[-2], Completer)
+                            else opt_tree_pos_list[-2]
+                        )
+                    ),
+                    meta_dict=META_DICT_OPT_TYPE,
+                    WORD=True,  # 匹配标点
+                    match_middle=True,
+                ),
+                WORD=not text.endswith(" "),
+            ).get_completions(document=document, complete_event=complete_event)