xulbux 1.7.2__py3-none-any.whl → 1.8.0__py3-none-any.whl

xulbux/{xx_console.py → console.py}

@@ -2,22 +2,23 @@
 Functions for logging and other small actions within the console.\n
 ----------------------------------------------------------------------------------------------------------
 You can also use special formatting codes directly inside the log message to change their appearance.
-For more detailed information about formatting codes, see the the `xx_format_codes` module documentation.
+For more detailed information about formatting codes, see the the `format_codes` module documentation.
 """
 
-from ._consts_ import COLOR, CHARS
-from .xx_format_codes import FormatCodes, _COMPILED
-from .xx_string import String
-from .xx_color import Color, Rgba, Hexa
-
-from prompt_toolkit.key_binding.key_bindings import KeyBindings
-from typing import Optional, Literal, Mapping, Any, cast
-import prompt_toolkit as _prompt_toolkit
-import pyperclip as _pyperclip
+from .base.consts import COLOR, CHARS
+from .format_codes import FormatCodes, _COMPILED
+from .string import String
+from .color import Color, Rgba, Hexa
+
+from typing import Callable, Optional, Literal, Mapping, Any, cast
+from prompt_toolkit.key_binding import KeyPressEvent, KeyBindings
+from prompt_toolkit.validation import ValidationError, Validator
+from prompt_toolkit.styles import Style
+from prompt_toolkit.keys import Keys
+import prompt_toolkit as _pt
 import keyboard as _keyboard
 import getpass as _getpass
 import shutil as _shutil
-import mouse as _mouse
 import sys as _sys
 import os as _os
 
@@ -63,7 +64,7 @@ class ArgResult:
     --------------------------------------------------------------------------------------------------------
     When the `ArgResult` instance is accessed as a boolean it will correspond to the `exists` attribute."""
 
-    def __init__(self, exists: bool, value: Any):
+    def __init__(self, exists: bool, value: Any | list[Any]):
         self.exists: bool = exists
         self.value: Any = value
 
@@ -76,12 +77,11 @@ class Args:
     For example, if an argument `foo` was parsed, it can be accessed via `args.foo`.
     Each such attribute (e.g. `args.foo`) is an instance of `ArgResult`."""
 
-    def __init__(self, **kwargs: dict[str, Any]):
+    def __init__(self, **kwargs: dict[str, Any | list[Any]]):
         for alias_name, data_dict in kwargs.items():
             if not alias_name.isidentifier():
                 raise TypeError(f"Argument alias '{alias_name}' is invalid. It must be a valid Python variable name.")
-            arg_result_instance = ArgResult(exists=data_dict["exists"], value=data_dict["value"])
-            setattr(self, alias_name, arg_result_instance)
+            setattr(self, alias_name, ArgResult(exists=cast(bool, data_dict["exists"]), value=data_dict["value"]))
 
     def __len__(self):
         return len(vars(self))
@@ -132,7 +132,8 @@ class Console:
 
     @staticmethod
     def get_args(
-        find_args: Mapping[str, list[str] | tuple[str, ...] | dict[str, list[str] | tuple[str, ...] | Any]],
+        find_args: Mapping[str, list[str] | tuple[str, ...] | dict[str, list[str] | tuple[str, ...] | Any]
+                           | Literal["before", "after"]],
         allow_spaces: bool = False
     ) -> Args:
         """Will search for the specified arguments in the command line
@@ -150,24 +151,31 @@ class Console:
                "default": "some_value"  # Optional
            }
            ```
+        3. Positional argument collection (string value):
+           ```python
+           "alias_name": "before"  # Collects non-flagged args before first flag
+           "alias_name": "after"   # Collects non-flagged args after last flag
+           ```
         Example `find_args`:
         ```python
         find_args={
-            "arg1": { # With default
+            "text": "before",           # Positional args before flags
+            "arg1": {                   # With default
                 "flags": ["-a1", "--arg1"],
                 "default": "default_val"
             },
-            "arg2": ("-a2", "--arg2"), # Without default (original format)
-            "arg3": ["-a3"],          # Without default (list format)
-            "arg4": { # Flag with default True
+            "arg2": ("-a2", "--arg2"),  # Without default (original format)
+            "arg3": ["-a3"],            # Without default (list format)
+            "arg4": {                   # Flag with default True
                 "flags": ["-f"],
                 "default": True
             }
         }
         ```
         If the script is called via the command line:\n
-        `python script.py -a1 "value1" --arg2 -f`\n
+        `python script.py Hello World -a1 "value1" --arg2 -f`\n
         ...it would return an `Args` object where:
+        - `args.text.exists` is `True`, `args.text.value` is `["Hello", "World"]`
         - `args.arg1.exists` is `True`, `args.arg1.value` is `"value1"`
         - `args.arg2.exists` is `True`, `args.arg2.value` is `True` (flag present without value)
         - `args.arg3.exists` is `False`, `args.arg3.value` is `None` (not present, no default)
@@ -176,19 +184,46 @@ class Console:
             - `exists` will be `False`
             - `value` will be the specified `default` value, or `None` if no default was specified.\n
         ----------------------------------------------------------------
+        For positional arguments:
+        - `"before"`: Collects all non-flagged arguments that appear before the first flag
+        - `"after"`: Collects all non-flagged arguments that appear after the last flag's value
+        ----------------------------------------------------------------
         Normally if `allow_spaces` is false, it will take a space as
         the end of an args value. If it is true, it will take spaces as
-        part of the value until the next arg is found.
+        part of the value up until the next arg-flag is found.
         (Multiple spaces will become one space in the value.)"""
         args = _sys.argv[1:]
         args_len = len(args)
         arg_lookup = {}
         results = {}
+        positional_configs = {}
+        before_count = 0
+        after_count = 0
+
+        # PARSE "find_args" CONFIGURATION
         for alias, config in find_args.items():
             flags = None
             default_value = None
-            if isinstance(config, (list, tuple)):
+
+            if isinstance(config, str):
+                # HANDLE POSITIONAL ARGUMENT COLLECTION
+                if config not in ("before", "after"):
+                    raise ValueError(
+                        f"Invalid positional argument type '{config}' for alias '{alias}'. Must be 'before' or 'after'."
+                    )
+                if config == "before":
+                    before_count += 1
+                    if before_count > 1:
+                        raise ValueError("Only one alias can have the value 'before' for positional argument collection.")
+                elif config == "after":
+                    after_count += 1
+                    if after_count > 1:
+                        raise ValueError("Only one alias can have the value 'after' for positional argument collection.")
+                positional_configs[alias] = config
+                results[alias] = {"exists": False, "value": []}
+            elif isinstance(config, (list, tuple)):
                 flags = config
+                results[alias] = {"exists": False, "value": default_value}
             elif isinstance(config, dict):
                 if "flags" not in config:
                     raise ValueError(f"Invalid configuration for alias '{alias}'. Dictionary must contain a 'flags' key.")
@@ -196,15 +231,54 @@ class Console:
                 default_value = config.get("default")
                 if not isinstance(flags, (list, tuple)):
                     raise ValueError(f"Invalid 'flags' for alias '{alias}'. Must be a list or tuple.")
+                results[alias] = {"exists": False, "value": default_value}
             else:
-                raise TypeError(f"Invalid configuration type for alias '{alias}'. Must be a list, tuple, or dict.")
-            results[alias] = {"exists": False, "value": default_value}
-            for flag in flags:
-                if flag in arg_lookup:
-                    raise ValueError(
-                        f"Duplicate flag '{flag}' found. It's assigned to both '{arg_lookup[flag]}' and '{alias}'."
-                    )
-                arg_lookup[flag] = alias
+                raise TypeError(
+                    f"Invalid configuration type for alias '{alias}'. Must be a list, tuple, dict or literal 'before' / 'after'."
+                )
+
+            # BUILD FLAG LOOKUP FOR NON-POSITIONAL ARGUMENTS
+            if flags is not None:
+                for flag in flags:
+                    if flag in arg_lookup:
+                        raise ValueError(
+                            f"Duplicate flag '{flag}' found. It's assigned to both '{arg_lookup[flag]}' and '{alias}'."
+                        )
+                    arg_lookup[flag] = alias
+
+        # FIND POSITIONS OF FIRST AND LAST FLAGS FOR POSITIONAL ARGUMENT COLLECTION
+        first_flag_pos = None
+        last_flag_with_value_pos = None
+
+        for i, arg in enumerate(args):
+            if arg in arg_lookup:
+                if first_flag_pos is None:
+                    first_flag_pos = i
+                # CHECK IF THIS FLAG HAS A VALUE FOLLOWING IT
+                flag_has_value = (i + 1 < args_len and not args[i + 1].startswith("-") and args[i + 1] not in arg_lookup)
+                if flag_has_value:
+                    if not allow_spaces:
+                        last_flag_with_value_pos = i + 1
+                    else:
+                        # FIND THE END OF THE MULTI-WORD VALUE
+                        j = i + 1
+                        while j < args_len and not args[j].startswith("-") and args[j] not in arg_lookup:
+                            j += 1
+                        last_flag_with_value_pos = j - 1
+
+        # COLLECT "before" POSITIONAL ARGUMENTS
+        for alias, pos_type in positional_configs.items():
+            if pos_type == "before":
+                before_args = []
+                end_pos = first_flag_pos if first_flag_pos is not None else args_len
+                for i in range(end_pos):
+                    if not args[i].startswith("-"):
+                        before_args.append(String.to_type(args[i]))
+                if before_args:
+                    results[alias]["value"] = before_args
+                    results[alias]["exists"] = len(before_args) > 0
+
+        # PROCESS FLAGGED ARGUMENTS
         i = 0
         while i < args_len:
             arg = args[i]
@@ -230,19 +304,43 @@ class Console:
                 if not value_found_after_flag:
                     results[alias]["value"] = True
             i += 1
+
+        # COLLECT "after" POSITIONAL ARGUMENTS
+        for alias, pos_type in positional_configs.items():
+            if pos_type == "after":
+                after_args = []
+                start_pos = (last_flag_with_value_pos + 1) if last_flag_with_value_pos is not None else 0
+                # IF NO FLAGS WERE FOUND WITH VALUES, START AFTER THE LAST FLAG
+                if last_flag_with_value_pos is None and first_flag_pos is not None:
+                    # FIND THE LAST FLAG POSITION
+                    last_flag_pos = None
+                    for i, arg in enumerate(args):
+                        if arg in arg_lookup:
+                            last_flag_pos = i
+                    if last_flag_pos is not None:
+                        start_pos = last_flag_pos + 1
+
+                for i in range(start_pos, args_len):
+                    if not args[i].startswith("-") and args[i] not in arg_lookup:
+                        after_args.append(String.to_type(args[i]))
+
+                if after_args:
+                    results[alias]["value"] = after_args
+                    results[alias]["exists"] = len(after_args) > 0
+
         return Args(**results)
 
     @staticmethod
     def pause_exit(
-        pause: bool = False,
+        pause: bool = True,
         exit: bool = False,
         prompt: object = "",
         exit_code: int = 0,
         reset_ansi: bool = False,
     ) -> None:
-        """Will print the `prompt` and then pause the program if `pause` is set
-        to `True` and after the pause, exit the program if `exit` is set to `True`."""
-        print(prompt, end="", flush=True)
+        """Will print the `prompt` and then pause the program if `pause` is
+        true and after the pause, exit the program if `exit` is set true."""
+        FormatCodes.print(prompt, end="", flush=True)
         if reset_ansi:
             FormatCodes.print("[_]", end="")
         if pause:
@@ -281,7 +379,7 @@ class Console:
         - `_console_tabsize` -⠀the tab size of the console (default is 8)\n
         -----------------------------------------------------------------------------------
         The log message can be formatted with special formatting codes. For more detailed
-        information about formatting codes, see `xx_format_codes` module documentation."""
+        information about formatting codes, see `format_codes` module documentation."""
         title = "" if title is None else title.strip().upper()
         title_len, tab_len = len(title) + 4, _console_tabsize - ((len(title) + 4) % _console_tabsize)
         if title_bg_color is not None and Color.is_valid(title_bg_color):
@@ -342,7 +440,7 @@ class Console:
             i = find_string_part(pos)
             adjusted_pos = (pos - cumulative_pos[i]) + offset_adjusts[i]
             parts = [result[i][:adjusted_pos], removal, result[i][adjusted_pos:]]
-            result[i] = ''.join(parts)
+            result[i] = "".join(parts)
             offset_adjusts[i] += len(removal)
         return result
 
@@ -353,8 +451,7 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Optional[Rgba | Hexa] = COLOR.yellow,
-        default_color: Optional[Rgba | Hexa] = COLOR.text,
+        default_color: Optional[Rgba | Hexa] = None,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
@@ -362,7 +459,7 @@ class Console:
         at the message and exit the program after the message was printed.
         If `active` is false, no debug message will be printed."""
         if active:
-            Console.log("DEBUG", prompt, format_linebreaks, start, end, title_bg_color, default_color)
+            Console.log("DEBUG", prompt, format_linebreaks, start, end, COLOR.YELLOW, default_color)
             Console.pause_exit(pause, exit)
 
     @staticmethod
@@ -371,14 +468,13 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Optional[Rgba | Hexa] = COLOR.blue,
-        default_color: Optional[Rgba | Hexa] = COLOR.text,
+        default_color: Optional[Rgba | Hexa] = None,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
         """A preset for `log()`: `INFO` log message with the options to pause
         at the message and exit the program after the message was printed."""
-        Console.log("INFO", prompt, format_linebreaks, start, end, title_bg_color, default_color)
+        Console.log("INFO", prompt, format_linebreaks, start, end, COLOR.BLUE, default_color)
         Console.pause_exit(pause, exit)
 
     @staticmethod
@@ -387,14 +483,13 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Optional[Rgba | Hexa] = COLOR.teal,
-        default_color: Optional[Rgba | Hexa] = COLOR.text,
+        default_color: Optional[Rgba | Hexa] = None,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
         """A preset for `log()`: `DONE` log message with the options to pause
         at the message and exit the program after the message was printed."""
-        Console.log("DONE", prompt, format_linebreaks, start, end, title_bg_color, default_color)
+        Console.log("DONE", prompt, format_linebreaks, start, end, COLOR.TEAL, default_color)
         Console.pause_exit(pause, exit)
 
     @staticmethod
@@ -403,14 +498,13 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Optional[Rgba | Hexa] = COLOR.orange,
-        default_color: Optional[Rgba | Hexa] = COLOR.text,
+        default_color: Optional[Rgba | Hexa] = None,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
         """A preset for `log()`: `WARN` log message with the options to pause
         at the message and exit the program after the message was printed."""
-        Console.log("WARN", prompt, format_linebreaks, start, end, title_bg_color, default_color)
+        Console.log("WARN", prompt, format_linebreaks, start, end, COLOR.ORANGE, default_color)
         Console.pause_exit(pause, exit)
 
     @staticmethod
@@ -419,15 +513,14 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Optional[Rgba | Hexa] = COLOR.red,
-        default_color: Optional[Rgba | Hexa] = COLOR.text,
+        default_color: Optional[Rgba | Hexa] = None,
         pause: bool = False,
         exit: bool = True,
         reset_ansi: bool = True,
     ) -> None:
         """A preset for `log()`: `FAIL` log message with the options to pause
         at the message and exit the program after the message was printed."""
-        Console.log("FAIL", prompt, format_linebreaks, start, end, title_bg_color, default_color)
+        Console.log("FAIL", prompt, format_linebreaks, start, end, COLOR.RED, default_color)
         Console.pause_exit(pause, exit, reset_ansi=reset_ansi)
 
     @staticmethod
@@ -436,15 +529,14 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Optional[Rgba | Hexa] = COLOR.magenta,
-        default_color: Optional[Rgba | Hexa] = COLOR.text,
+        default_color: Optional[Rgba | Hexa] = None,
         pause: bool = False,
         exit: bool = True,
         reset_ansi: bool = True,
     ) -> None:
         """A preset for `log()`: `EXIT` log message with the options to pause
         at the message and exit the program after the message was printed."""
-        Console.log("EXIT", prompt, format_linebreaks, start, end, title_bg_color, default_color)
+        Console.log("EXIT", prompt, format_linebreaks, start, end, COLOR.MAGENTA, default_color)
         Console.pause_exit(pause, exit, reset_ansi=reset_ansi)
 
     @staticmethod
@@ -456,6 +548,7 @@ class Console:
         default_color: Optional[Rgba | Hexa] = None,
         w_padding: int = 2,
         w_full: bool = False,
+        indent: int = 0,
     ) -> None:
         """Will print a box with a colored background, containing a formatted log message:
         - `*values` -⠀the box content (each value is on a new line)
@@ -464,23 +557,25 @@ class Console:
         - `box_bg_color` -⠀the background color of the box
         - `default_color` -⠀the default text color of the `*values`
         - `w_padding` -⠀the horizontal padding (in chars) to the box content
-        - `w_full` -⠀whether to make the box be the full console width or not\n
+        - `w_full` -⠀whether to make the box be the full console width or not
+        - `indent` -⠀the indentation of the box (in chars)\n
         -----------------------------------------------------------------------------------
         The box content can be formatted with special formatting codes. For more detailed
-        information about formatting codes, see `xx_format_codes` module documentation."""
+        information about formatting codes, see `format_codes` module documentation."""
         lines, unfmt_lines, max_line_len = Console.__prepare_log_box(values, default_color)
         pad_w_full = (Console.w - (max_line_len + (2 * w_padding))) if w_full else 0
         if box_bg_color is not None and Color.is_valid(box_bg_color):
             box_bg_color = Color.to_hexa(box_bg_color)
+        spaces_l = " " * indent
         lines = [
-            f"[bg:{box_bg_color}]{' ' * w_padding}{line}" + " " *
-            ((w_padding + max_line_len - len(unfmt)) + pad_w_full) + "[*]" for line, unfmt in zip(lines, unfmt_lines)
+            f"{spaces_l}[bg:{box_bg_color}]{' ' * w_padding}"
+            + _COMPILED["formatting"].sub(lambda m: f"{m.group(0)}[bg:{box_bg_color}]", line) +
+            (" " * ((w_padding + max_line_len - len(unfmt)) + pad_w_full)) + "[*]" for line, unfmt in zip(lines, unfmt_lines)
         ]
         pady = " " * (Console.w if w_full else max_line_len + (2 * w_padding))
         FormatCodes.print(
-            f"{start}[bg:{box_bg_color}]{pady}[*]\n"
-            + _COMPILED["formatting"].sub(lambda m: f"{m.group(0)}[bg:{box_bg_color}]", "\n".join(lines))
-            + f"\n[bg:{box_bg_color}]{pady}[_]",
+            f"{start}{spaces_l}[bg:{box_bg_color}]{pady}[*]\n" + "\n".join(lines)
+            + f"\n{spaces_l}[bg:{box_bg_color}]{pady}[_]",
             default_color=default_color or "#000",
             sep="\n",
             end=end,
@@ -492,10 +587,11 @@ class Console:
         start: str = "",
         end: str = "\n",
         border_type: Literal["standard", "rounded", "strong", "double"] = "rounded",
-        border_style: str | Rgba | Hexa = f"dim|{COLOR.gray}",
+        border_style: str | Rgba | Hexa = f"dim|{COLOR.GRAY}",
         default_color: Optional[Rgba | Hexa] = None,
         w_padding: int = 1,
         w_full: bool = False,
+        indent: int = 0,
         _border_chars: Optional[tuple[str, str, str, str, str, str, str, str]] = None,
     ) -> None:
         """Will print a bordered box, containing a formatted log message:
@@ -507,10 +603,11 @@ class Console:
         - `default_color` -⠀the default text color of the `*values`
         - `w_padding` -⠀the horizontal padding (in chars) to the box content
         - `w_full` -⠀whether to make the box be the full console width or not
+        - `indent` -⠀the indentation of the box (in chars)
         - `_border_chars` -⠀define your own border characters set (overwrites `border_type`)\n
         ---------------------------------------------------------------------------------------
         The box content can be formatted with special formatting codes. For more detailed
-        information about formatting codes, see `xx_format_codes` module documentation.\n
+        information about formatting codes, see `format_codes` module documentation.\n
         ---------------------------------------------------------------------------------------
         The `border_type` can be one of the following:
         - `"standard" = ('┌', '─', '┐', '│', '┘', '─', '└', '│')`
@@ -534,18 +631,18 @@ class Console:
         }
         border_chars = borders.get(border_type, borders["standard"]) if _border_chars is None else _border_chars
         lines, unfmt_lines, max_line_len = Console.__prepare_log_box(values, default_color)
-        print(unfmt_lines)
         pad_w_full = (Console.w - (max_line_len + (2 * w_padding)) - (len(border_chars[1] * 2))) if w_full else 0
         if border_style is not None and Color.is_valid(border_style):
             border_style = Color.to_hexa(border_style)
+        spaces_l = " " * indent
         border_l = f"[{border_style}]{border_chars[7]}[*]"
         border_r = f"[{border_style}]{border_chars[3]}[_]"
         lines = [
-            f"{border_l}{' ' * w_padding}{line}[_]" + " " * ((w_padding + max_line_len - len(unfmt)) + pad_w_full) + border_r
-            for line, unfmt in zip(lines, unfmt_lines)
+            f"{spaces_l}{border_l}{' ' * w_padding}{line}[_]" + " " *
+            ((w_padding + max_line_len - len(unfmt)) + pad_w_full) + border_r for line, unfmt in zip(lines, unfmt_lines)
         ]
-        border_t = f"[{border_style}]{border_chars[0]}{border_chars[1] * (Console.w - (len(border_chars[1] * 2)) if w_full else max_line_len + (2 * w_padding))}{border_chars[2]}[_]"
-        border_b = f"[{border_style}]{border_chars[6]}{border_chars[5] * (Console.w - (len(border_chars[1] * 2)) if w_full else max_line_len + (2 * w_padding))}{border_chars[4]}[_]"
+        border_t = f"{spaces_l}[{border_style}]{border_chars[0]}{border_chars[1] * (Console.w - (len(border_chars[1] * 2)) if w_full else max_line_len + (2 * w_padding))}{border_chars[2]}[_]"
+        border_b = f"{spaces_l}[{border_style}]{border_chars[6]}{border_chars[5] * (Console.w - (len(border_chars[1] * 2)) if w_full else max_line_len + (2 * w_padding))}{border_chars[4]}[_]"
         FormatCodes.print(
             f"{start}{border_t}[_]\n" + "\n".join(lines) + f"\n{border_b}[_]",
             default_color=default_color,
@@ -568,22 +665,28 @@ class Console:
     def confirm(
         prompt: object = "Do you want to continue?",
         start="",
-        end="\n",
-        default_color: Optional[Rgba | Hexa] = COLOR.cyan,
+        end="",
+        default_color: Optional[Rgba | Hexa] = None,
         default_is_yes: bool = True,
     ) -> bool:
         """Ask a yes/no question.\n
         ---------------------------------------------------------------------------------------
+        - `prompt` -⠀the input prompt
+        - `start` -⠀something to print before the input
+        - `end` -⠀something to print after the input (e.g. `\\n`)
+        - `default_color` -⠀the default text color of the `prompt`
+        - `default_is_yes` -⠀the default answer if the user just presses enter
+        ---------------------------------------------------------------------------------------
         The prompt can be formatted with special formatting codes. For more detailed
-        information about formatting codes, see the `xx_format_codes` module documentation."""
+        information about formatting codes, see the `format_codes` module documentation."""
         confirmed = input(
             FormatCodes.to_ansi(
-                f'{start}  {str(prompt)} [_|dim](({"Y" if default_is_yes else "y"}/{"n" if default_is_yes else "N"}):  )',
+                f'{start}{str(prompt)} [_|dim](({"Y" if default_is_yes else "y"}/{"n" if default_is_yes else "N"}): )',
                 default_color=default_color,
             )
         ).strip().lower() in (("", "y", "yes") if default_is_yes else ("y", "yes"))
         if end:
-            Console.log("", end, end="")
+            FormatCodes.print(end, end="")
         return confirmed
 
     @staticmethod
@@ -591,13 +694,13 @@ class Console:
         prompt: object = "",
         start="",
         end="\n",
-        default_color: Optional[Rgba | Hexa] = COLOR.cyan,
+        default_color: Optional[Rgba | Hexa] = None,
         show_keybindings=True,
         input_prefix=" ⮡ ",
         reset_ansi=True,
     ) -> str:
-        """An input where users can input (and paste) text over multiple lines.\n
-        -----------------------------------------------------------------------------------
+        """An input where users can write (and paste) text over multiple lines.\n
+        ---------------------------------------------------------------------------------------
         - `prompt` -⠀the input prompt
         - `start` -⠀something to print before the input
         - `end` -⠀something to print after the input (e.g. `\\n`)
@@ -605,9 +708,9 @@ class Console:
         - `show_keybindings` -⠀whether to show the special keybindings or not
         - `input_prefix` -⠀the prefix of the input line
         - `reset_ansi` -⠀whether to reset the ANSI codes after the input or not
-        -----------------------------------------------------------------------------------
+        ---------------------------------------------------------------------------------------
         The input prompt can be formatted with special formatting codes. For more detailed
-        information about formatting codes, see `xx_format_codes` module documentation."""
+        information about formatting codes, see the `format_codes` module documentation."""
         kb = KeyBindings()
 
         @kb.add("c-d", eager=True)  # CTRL+D
@@ -617,135 +720,184 @@ class Console:
         FormatCodes.print(start + str(prompt), default_color=default_color)
         if show_keybindings:
             FormatCodes.print("[dim][[b](CTRL+D)[dim] : end of input][_dim]")
-        input_string = _prompt_toolkit.prompt(input_prefix, multiline=True, wrap_lines=True, key_bindings=kb)
+        input_string = _pt.prompt(input_prefix, multiline=True, wrap_lines=True, key_bindings=kb)
         FormatCodes.print("[_]" if reset_ansi else "", end=end[1:] if end.startswith("\n") else end)
         return input_string
 
     @staticmethod
-    def restricted_input(
+    def input(
         prompt: object = "",
         start="",
-        end="\n",
-        default_color: Optional[Rgba | Hexa] = COLOR.cyan,
-        allowed_chars: str = CHARS.all,  # type: ignore[assignment]
+        end="",
+        default_color: Optional[Rgba | Hexa] = None,
+        placeholder: Optional[str] = None,
+        mask_char: Optional[str] = None,
         min_len: Optional[int] = None,
         max_len: Optional[int] = None,
-        mask_char: Optional[str] = None,
-        reset_ansi: bool = True,
-    ) -> Optional[str]:
-        """Acts like a standard Python `input()` with the advantage, that you can specify:
-        - what text characters the user is allowed to type and
-        - the minimum and/or maximum length of the users input
-        - optional mask character (hide user input, e.g. for passwords)
-        - reset the ANSI formatting codes after the user continues\n
-        ---------------------------------------------------------------------------------------
-        The input can be formatted with special formatting codes. For more detailed
-        information about formatting codes, see the `xx_format_codes` module documentation."""
-        FormatCodes.print(start + str(prompt), default_color=default_color, end="")
-        result = ""
-        select_all = False
-        last_line_count = 1
-        last_console_width = 0
-
-        def update_display(console_width: int) -> None:
-            nonlocal last_line_count, last_console_width
-            lines = String.split_count(str(prompt) + (mask_char * len(result) if mask_char else result), console_width)
-            line_count = len(lines)
-            if (line_count > 1 or line_count < last_line_count) and not last_line_count == 1:
-                if last_console_width > console_width:
-                    line_count *= 2
-                for _ in range(line_count if line_count < last_line_count and not line_count > last_line_count else (
-                        line_count - 2 if line_count > last_line_count else line_count - 1)):
-                    _sys.stdout.write("\033[2K\r\033[A")
-            prompt_len = len(str(prompt)) if prompt else 0
-            prompt_str = lines[0][:prompt_len]
-            input_str = (
-                lines[0][prompt_len:] if len(lines) == 1 else "\n".join([lines[0][prompt_len:]] + lines[1:])
-            )  # SEPARATE THE PROMPT AND THE INPUT
-            _sys.stdout.write(
-                "\033[2K\r" + FormatCodes.to_ansi(prompt_str) + ("\033[7m" if select_all else "") + input_str + "\033[27m"
-            )
-            last_line_count, last_console_width = line_count, console_width
-
-        def handle_enter():
-            if min_len is not None and len(result) < min_len:
-                return False
-            FormatCodes.print(f"[_]{end}" if reset_ansi else end, default_color=default_color)
-            return True
-
-        def handle_backspace_delete():
-            nonlocal result, select_all
-            if select_all:
-                result, select_all = "", False
-            elif result and event.name == "backspace":
-                result = result[:-1]
-            update_display(Console.w)
-
-        def handle_paste():
-            nonlocal result, select_all
-            if select_all:
-                result, select_all = "", False
-            filtered_text = "".join(char for char in _pyperclip.paste() if allowed_chars == CHARS.all or char in allowed_chars)
-            if max_len is None or len(result) + len(filtered_text) <= max_len:
-                result += filtered_text
-                update_display(Console.w)
-
-        def handle_select_all():
-            nonlocal select_all
-            select_all = True
-            update_display(Console.w)
-
-        def handle_character_input():
-            nonlocal result
-            if event.name is not None and ((allowed_chars == CHARS.all or event.name in allowed_chars) and
-                                           (max_len is None or len(result) < max_len)):
-                result += event.name
-                update_display(Console.w)
-
-        while True:
-            event = _keyboard.read_event()
-            if event.event_type == "down":
-                if event.name == "enter" and handle_enter():
-                    return result.rstrip("\n")
-                elif event.name in ("backspace", "delete", "entf"):
-                    handle_backspace_delete()
-                elif (event.name == "v" and _keyboard.is_pressed("ctrl")) or _mouse.is_pressed("right"):
-                    handle_paste()
-                elif event.name == "a" and _keyboard.is_pressed("ctrl"):
-                    handle_select_all()
-                elif event.name == "c" and _keyboard.is_pressed("ctrl"):
-                    raise KeyboardInterrupt
-                elif event.name == "esc":
-                    return None
-                elif event.name == "space":
-                    handle_character_input()
-                elif event.name is not None and len(event.name) == 1:
-                    handle_character_input()
+        allowed_chars: str = CHARS.ALL,  #type: ignore[assignment]
+        allow_paste: bool = True,
+        validator: Optional[Callable[[str], Optional[str]]] = None,
+    ) -> str:
+        """Acts like a standard Python `input()` a bunch of cool extra features.\n
+        ------------------------------------------------------------------------------------
+        - `prompt` -⠀the input prompt
+        - `start` -⠀something to print before the input
+        - `end` -⠀something to print after the input (e.g. `\\n`)
+        - `default_color` -⠀the default text color of the `prompt`
+        - `placeholder` -⠀a placeholder text that is shown when the input is empty
+        - `mask_char` -⠀if set, the input will be masked with this character
+        - `min_len` -⠀the minimum length of the input (required to submit)
+        - `max_len` -⠀the maximum length of the input (can't write further if reached)
+        - `allowed_chars` -⠀a string of characters that are allowed to be inputted
+          (default allows all characters)
+        - `allow_paste` -⠀whether to allow pasting text into the input or not
+        - `validator` -⠀a function that takes the input string and returns a string error
+          message if invalid, or nothing if valid
+        ------------------------------------------------------------------------------------
+        The input prompt can be formatted with special formatting codes. For more detailed
+        information about formatting codes, see the `format_codes` module documentation."""
+        result_text = ""
+        tried_pasting = False
+        filtered_chars = set()
+
+        class InputValidator(Validator):
+
+            def validate(self, document) -> None:
+                text_to_validate = result_text if mask_char else document.text
+                if min_len and len(text_to_validate) < min_len:
+                    raise ValidationError(message="", cursor_position=len(document.text))
+                if validator and validator(text_to_validate) not in ("", None):
+                    raise ValidationError(message="", cursor_position=len(document.text))
+
+        def bottom_toolbar() -> _pt.formatted_text.ANSI:
+            nonlocal tried_pasting
+            try:
+                if mask_char:
+                    text_to_check = result_text
                 else:
-                    select_all = False
-                    update_display(Console.w)
+                    app = _pt.application.get_app()
+                    text_to_check = app.current_buffer.text
+                toolbar_msgs = []
+                if max_len and len(text_to_check) > max_len:
+                    toolbar_msgs.append("[b|#FFF|bg:red]( Text too long! )")
+                if validator and text_to_check and (validation_error_msg := validator(text_to_check)) not in ("", None):
+                    toolbar_msgs.append(f"[b|#000|bg:br:red] {validation_error_msg} [_bg]")
+                if filtered_chars:
+                    plural = "" if len(char_list := "".join(sorted(filtered_chars))) == 1 else "s"
+                    toolbar_msgs.append(f"[b|#000|bg:yellow]( Char{plural} '{char_list}' not allowed )")
+                    filtered_chars.clear()
+                if min_len and len(text_to_check) < min_len:
+                    toolbar_msgs.append(f"[b|#000|bg:yellow]( Need {min_len - len(text_to_check)} more chars )")
+                if tried_pasting:
+                    toolbar_msgs.append("[b|#000|bg:br:yellow]( Pasting disabled )")
+                    tried_pasting = False
+                if max_len and len(text_to_check) == max_len:
+                    toolbar_msgs.append("[b|#000|bg:br:yellow]( Maximum length reached )")
+                return _pt.formatted_text.ANSI(FormatCodes.to_ansi(" ".join(toolbar_msgs)))
+            except Exception:
+                return _pt.formatted_text.ANSI("")
+
+        def process_insert_text(text: str) -> tuple[str, set[str]]:
+            removed_chars = set()
+            if not text: return "", removed_chars
+            processed_text = "".join(c for c in text if ord(c) >= 32)
+            if allowed_chars != CHARS.ALL:
+                filtered_text = ""
+                for char in processed_text:
+                    if char in allowed_chars:
+                        filtered_text += char
+                    else:
+                        removed_chars.add(char)
+                processed_text = filtered_text
+            if max_len:
+                if (remaining_space := max_len - len(result_text)) > 0:
+                    if len(processed_text) > remaining_space:
+                        processed_text = processed_text[:remaining_space]
+                else:
+                    processed_text = ""
+            return processed_text, removed_chars
+
+        def insert_text_event(event: KeyPressEvent) -> None:
+            nonlocal result_text, filtered_chars
+            try:
+                insert_text = event.data
+                if not insert_text: return
+                buffer = event.app.current_buffer
+                cursor_pos = buffer.cursor_position
+                insert_text, filtered_chars = process_insert_text(insert_text)
+                if insert_text:
+                    result_text = result_text[:cursor_pos] + insert_text + result_text[cursor_pos:]
+                    if mask_char:
+                        buffer.insert_text(mask_char[0] * len(insert_text))
+                    else:
+                        buffer.insert_text(insert_text)
+            except Exception:
+                pass
+
+        def remove_text_event(event: KeyPressEvent, is_backspace: bool = False) -> None:
+            nonlocal result_text
+            try:
+                buffer = event.app.current_buffer
+                cursor_pos = buffer.cursor_position
+                has_selection = buffer.selection_state is not None
+                if has_selection:
+                    start, end = buffer.document.selection_range()
+                    result_text = result_text[:start] + result_text[end:]
+                    buffer.cursor_position = start
+                    buffer.delete(end - start)
+                else:
+                    if is_backspace:
+                        if cursor_pos > 0:
+                            result_text = result_text[:cursor_pos - 1] + result_text[cursor_pos:]
+                            buffer.delete_before_cursor(1)
+                    else:
+                        if cursor_pos < len(result_text):
+                            result_text = result_text[:cursor_pos] + result_text[cursor_pos + 1:]
+                            buffer.delete(1)
+            except Exception:
+                pass
 
-    @staticmethod
-    def pwd_input(
-        prompt: object = "Password: ",
-        start="",
-        end="\n",
-        default_color: Optional[Rgba | Hexa] = COLOR.cyan,
-        allowed_chars: str = CHARS.standard_ascii,
-        min_len: Optional[int] = None,
-        max_len: Optional[int] = None,
-        reset_ansi: bool = True,
-    ) -> Optional[str]:
-        """Password input (preset for `Console.restricted_input()`)
-        that always masks the entered characters with asterisks."""
-        return Console.restricted_input(
-            prompt=prompt,
-            start=start,
-            end=end,
-            default_color=default_color,
-            allowed_chars=allowed_chars,
-            min_len=min_len,
-            max_len=max_len,
-            mask_char="*",
-            reset_ansi=reset_ansi,
+        kb = KeyBindings()
+
+        @kb.add(Keys.Delete)
+        def _(event: KeyPressEvent) -> None:
+            remove_text_event(event)
+
+        @kb.add(Keys.Backspace)
+        def _(event: KeyPressEvent) -> None:
+            remove_text_event(event, is_backspace=True)
+
+        @kb.add(Keys.ControlA)
+        def _(event: KeyPressEvent) -> None:
+            buffer = event.app.current_buffer
+            buffer.cursor_position = 0
+            buffer.start_selection()
+            buffer.cursor_position = len(buffer.text)
+
+        @kb.add(Keys.BracketedPaste)
+        def _(event: KeyPressEvent) -> None:
+            if allow_paste:
+                insert_text_event(event)
+            else:
+                nonlocal tried_pasting
+                tried_pasting = True
+
+        @kb.add(Keys.Any)
+        def _(event: KeyPressEvent) -> None:
+            insert_text_event(event)
+
+        custom_style = Style.from_dict({'bottom-toolbar': 'noreverse'})
+        session = _pt.PromptSession(
+            message=_pt.formatted_text.ANSI(FormatCodes.to_ansi(str(prompt), default_color=default_color)),
+            validator=InputValidator(),
+            validate_while_typing=True,
+            key_bindings=kb,
+            bottom_toolbar=bottom_toolbar,
+            placeholder=_pt.formatted_text.ANSI(FormatCodes.to_ansi(f"[i|br:black]{placeholder}[_i|_c]"))
+            if placeholder else "",
+            style=custom_style,
         )
+        FormatCodes.print(start, end="")
+        session.prompt()
+        FormatCodes.print(end, end="")
+        return result_text