xulbux 1.5.7__py3-none-any.whl → 1.5.8__py3-none-any.whl

xulbux/__init__.py

@@ -1,5 +1,5 @@
 """
- >>> import XulbuX as xx
+ >>> import xulbux as xx
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   • CUSTOM TYPES:
      • rgba(int,int,int,float)
@@ -9,17 +9,17 @@
   • FILE OPERATIONS          xx.File
   • JSON FILE OPERATIONS     xx.Json
   • SYSTEM ACTIONS           xx.System
-  • MANAGE ENVIRONMENT VARS  xx.EnvVars
-  • CMD LOG AND ACTIONS      xx.Cmd
-  • PRETTY PRINTING          xx.FormatCodes
-  • COLOR OPERATIONS         xx.Color
+  • MANAGE THE ENV PATH VAR  xx.EnvPath
+  • CONSOLE LOG AND ACTIONS  xx.Console
+  • EASY PRETTY PRINTING     xx.FormatCodes
+  • WORKING WITH COLORS      xx.Color
   • DATA OPERATIONS          xx.Data
-  • STR OPERATIONS           xx.String
+  • STRING OPERATIONS        xx.String
   • CODE STRING OPERATIONS   xx.Code
   • REGEX PATTERN TEMPLATES  xx.Regex
 """
 
-__version__ = "1.5.7"
+__version__ = "1.5.8"
 __author__ = "XulbuX"
 __email__ = "xulbux.real@gmail.com"
 __license__ = "MIT"
@@ -28,11 +28,11 @@ __url__ = "https://github.com/XulbuX-dev/Python/tree/main/Libraries/XulbuX"
 __description__ = "A library which includes a lot of really helpful functions."
 __all__ = [
     "_consts_",
-    "xx_cmd",
+    "xx_console",
     "xx_code",
     "xx_color",
     "xx_data",
-    "xx_env_vars",
+    "xx_env_path",
     "xx_file",
     "xx_format_codes",
     "xx_json",
@@ -43,11 +43,11 @@ __all__ = [
 ]
 
 from ._consts_ import *
-from .xx_cmd import *
 from .xx_code import *
 from .xx_color import *
+from .xx_console import *
 from .xx_data import *
-from .xx_env_vars import *
+from .xx_env_path import *
 from .xx_file import *
 from .xx_format_codes import *
 from .xx_json import *

xulbux/_cli_.py

@@ -1,7 +1,7 @@
 from . import __version__
 from ._consts_ import DEFAULT
-from .xx_format_codes import *
-from .xx_cmd import *
+from .xx_format_codes import FormatCodes
+from .xx_console import Console
 
 
 def help_command():
@@ -24,9 +24,9 @@ def help_command():
 
   [b|#75A2FF]Usage:[*]
     [{color['punctuators']}]# GENERAL LIBRARY[*]
-    [{color['import']}]import [{color['lib']}]XulbuX [{color['import']}]as [{color['lib']}]xx[*]
+    [{color['import']}]import [{color['lib']}]xulbux [{color['import']}]as [{color['lib']}]xx[*]
     [{color['punctuators']}]# CUSTOM TYPES[*]
-    [{color['import']}]from [{color['lib']}]XulbuX [{color['import']}]import [{color['lib']}]rgba[{color['punctuators']}], [{color['lib']}]hsla[{color['punctuators']}], [{color['lib']}]hexa[*]
+    [{color['import']}]from [{color['lib']}]xulbux [{color['import']}]import [{color['lib']}]rgba[{color['punctuators']}], [{color['lib']}]hsla[{color['punctuators']}], [{color['lib']}]hexa[*]
 
   [b|#75A2FF]Includes:[*]
     [dim](•) CUSTOM TYPES:
@@ -37,16 +37,16 @@ def help_command():
     [dim](•) FILE OPERATIONS          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]File[*]
     [dim](•) JSON FILE OPERATIONS     [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Json[*]
     [dim](•) SYSTEM ACTIONS           [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]System[*]
-    [dim](•) MANAGE ENVIRONMENT VARS  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Env_vars[*]
-    [dim](•) CMD LOG AND ACTIONS      [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Cmd[*]
-    [dim](•) PRETTY PRINTING          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]FormatCodes[*]
-    [dim](•) COLOR OPERATIONS         [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Color[*]
+    [dim](•) MANAGE THE ENV PATH VAR  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]EnvPath[*]
+    [dim](•) CONSOLE LOG AND ACTIONS  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Console[*]
+    [dim](•) EASY PRETTY PRINTING     [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]FormatCodes[*]
+    [dim](•) WORKING WITH COLORS      [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Color[*]
     [dim](•) DATA OPERATIONS          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Data[*]
-    [dim](•) STR OPERATIONS           [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]String[*]
+    [dim](•) STRING OPERATIONS        [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]String[*]
     [dim](•) CODE STRING OPERATIONS   [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Code[*]
     [dim](•) REGEX PATTERN TEMPLATES  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Regex[*]
   [_]
   [dim](Press any key to exit...)
   """
     )
-    Cmd.pause_exit(pause=True)
+    Console.pause_exit(pause=True)

xulbux/xx_code.py

@@ -1,6 +1,6 @@
-from .xx_string import *
-from .xx_regex import *
-from .xx_data import *
+from .xx_string import String
+from .xx_regex import Regex
+from .xx_data import Data
 
 import regex as _rx
 

xulbux/xx_color.py

@@ -31,7 +31,7 @@ The `Color` class, which contains all sorts of different color-related methods:
     - saturation
 """
 
-from .xx_regex import *
+from .xx_regex import Regex
 
 import re as _re
 
@@ -159,10 +159,9 @@ class rgba:
 
     def blend(self, other: "rgba", ratio: float = 0.5, additive_alpha: bool = False) -> "rgba":
         """Blends the current color with another color using the specified ratio (`0.0`-`1.0`):<br>
-        If `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (1:0 mixture)<br>
+        If `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (2:0 mixture)<br>
         If `ratio` is `0.5` it means 50% of both colors (1:1 mixture)<br>
-        If `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:1 mixture)
-        """
+        If `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:2 mixture)"""
         if not (isinstance(ratio, (int, float)) and 0 <= ratio <= 1):
             raise ValueError("'ratio' must be a float/int in [0.0, 1.0]")
         elif not isinstance(other, rgba):
@@ -193,11 +192,11 @@ class rgba:
         return rgba(self.r, self.g, self.b, None if none_alpha else self.a)
 
     def is_dark(self) -> bool:
-        """Returns `True` if the color is considered dark (luminance < 128)"""
+        """Returns `True` if the color is considered dark (`lightness < 50%`)"""
         return (0.299 * self.r + 0.587 * self.g + 0.114 * self.b) < 128
 
     def is_light(self) -> bool:
-        """Returns `True` if the color is considered light (luminance >= 128)"""
+        """Returns `True` if the color is considered light (`lightness >= 50%`)"""
         return not self.is_dark()
 
     def is_grayscale(self) -> bool:
@@ -371,19 +370,18 @@ class hsla:
 
     def blend(self, other: "hsla", ratio: float = 0.5, additive_alpha: bool = False) -> "rgba":
         """Blends the current color with another color using the specified ratio (`0.0`-`1.0`):<br>
-        If `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (1:0 mixture)<br>
+        If `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (2:0 mixture)<br>
         If `ratio` is `0.5` it means 50% of both colors (1:1 mixture)<br>
-        If `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:1 mixture)
-        """
+        If `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:2 mixture)"""
         self.h, self.s, self.l, self.a = self.to_rgba().blend(Color.to_rgba(other), ratio, additive_alpha).to_hsla().values()
         return hsla(self.h, self.s, self.l, self.a)
 
     def is_dark(self) -> bool:
-        """Returns `True` if the color is considered dark (`lightness < 50`)"""
+        """Returns `True` if the color is considered dark (`lightness < 50%`)"""
         return self.l < 50
 
     def is_light(self) -> bool:
-        """Returns `True` if the color is considered light (`lightness >= 50`)"""
+        """Returns `True` if the color is considered light (`lightness >= 50%`)"""
         return not self.is_dark()
 
     def is_grayscale(self) -> bool:
@@ -598,19 +596,18 @@ class hexa:
 
     def blend(self, other: "hexa", ratio: float = 0.5, additive_alpha: bool = False) -> "rgba":
         """Blends the current color with another color using the specified ratio (`0.0`-`1.0`):<br>
-        If `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (1:0 mixture)<br>
+        If `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (2:0 mixture)<br>
         If `ratio` is `0.5` it means 50% of both colors (1:1 mixture)<br>
-        If `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:1 mixture)
-        """
+        If `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:2 mixture)"""
         self.r, self.g, self.b, self.a = self.to_rgba(False).blend(Color.to_rgba(other), ratio, additive_alpha).values()
         return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
 
     def is_dark(self) -> bool:
-        """Returns `True` if the color is considered dark (converted `lightness < 50`)"""
+        """Returns `True` if the color is considered dark (`lightness < 50%`)"""
         return self.to_hsla(False).is_dark()
 
     def is_light(self) -> bool:
-        """Returns `True` if the color is considered light (`lightness >= 50`)"""
+        """Returns `True` if the color is considered light (`lightness >= 50%`)"""
         return self.to_hsla(False).is_light()
 
     def is_grayscale(self) -> bool:
@@ -658,7 +655,7 @@ class Color:
                     )
                 return 0 <= color["r"] <= 255 and 0 <= color["g"] <= 255 and 0 <= color["b"] <= 255
             elif isinstance(color, str):
-                return bool(_re.fullmatch(Regex.rgba_str(), color))
+                return bool(_re.fullmatch(Regex.rgba_str(allow_alpha=allow_alpha), color))
             return False
         except Exception:
             return False
@@ -689,29 +686,29 @@ class Color:
                 else:
                     return 0 <= color["h"] <= 360 and 0 <= color["s"] <= 100 and 0 <= color["l"] <= 100
             elif isinstance(color, str):
-                return bool(_re.fullmatch(Regex.hsla_str(), color))
+                return bool(_re.fullmatch(Regex.hsla_str(allow_alpha=allow_alpha), color))
         except Exception:
             return False
 
     @staticmethod
-    def is_valid_hexa(color: str, allow_alpha: bool = True, get_prefix: bool = False) -> bool | tuple[bool, str]:
+    def is_valid_hexa(color: str | int, allow_alpha: bool = True, get_prefix: bool = False) -> bool | tuple[bool, str]:
         try:
             if isinstance(color, hexa):
                 return (True, "#")
             elif isinstance(color, int):
                 is_valid = 0 <= color <= (0xFFFFFFFF if allow_alpha else 0xFFFFFF)
                 return (is_valid, "0x") if get_prefix else is_valid
-            else:
-                if color.startswith("#"):
-                    color, prefix = color[1:], "#"
-                elif color.startswith("0x"):
-                    color, prefix = color[2:], "0x"
-                pattern = (
-                    r"(?i)^[0-9A-F]{8}|[0-9A-F]{6}|[0-9A-F]{4}|[0-9A-F]{3}$"
-                    if allow_alpha
-                    else r"(?i)^[0-9A-F]{6}|[0-9A-F]{3}$"
+            elif isinstance(color, str):
+                color, prefix = (
+                    (color[1:], "#")
+                    if color.startswith("#")
+                    else (color[2:], "0x") if color.startswith("0x") else (color, None)
+                )
+                return (
+                    (bool(_re.fullmatch(Regex.hexa_str(allow_alpha=allow_alpha), color)), prefix)
+                    if get_prefix
+                    else bool(_re.fullmatch(Regex.hexa_str(allow_alpha=allow_alpha), color))
                 )
-                return (bool(_re.fullmatch(pattern, color)), prefix) if get_prefix else bool(_re.fullmatch(pattern, color))
         except Exception:
             return (False, None) if get_prefix else False
 
@@ -798,19 +795,30 @@ class Color:
         """Will try to recognize RGBA colors inside a string and output the found ones as RGBA objects.<br>
         If `only_first` is `True` only the first found color will be returned (not as a list).
         """
-        matches = _re.findall(Regex.rgb_str(allow_alpha=True), string)
-        if not matches:
-            return None
-        result = [
-            rgba(
+        if only_first:
+            match = _re.search(Regex.rgb_str(allow_alpha=True), string)
+            if not match:
+                return None
+            m = match.groups()
+            return rgba(
                 int(m[0]),
                 int(m[1]),
                 int(m[2]),
                 ((int(m[3]) if "." not in m[3] else float(m[3])) if m[3] else None),
             )
-            for m in matches
-        ]
-        return result[0] if len(result) == 1 or only_first else result
+        else:
+            matches = _re.findall(Regex.rgb_str(allow_alpha=True), string)
+            if not matches:
+                return None
+            return [
+                rgba(
+                    int(m[0]),
+                    int(m[1]),
+                    int(m[2]),
+                    ((int(m[3]) if "." not in m[3] else float(m[3])) if m[3] else None),
+                )
+                for m in matches
+            ]
 
     @staticmethod
     def rgba_to_hex_int(
@@ -818,40 +826,43 @@ class Color:
         g: int,
         b: int,
         a: float = None,
-        _preserve_original: bool = False,
+        preserve_original: bool = False,
     ) -> int:
         """Convert RGBA channels to a HEXA integer (alpha is optional).\n
         -------------------------------------------------------------------------------------------------------------------------
-        To preserve leading zeros, the function will add a `1` at the beginning, if the HEX value would start with a `0`.<br>
+        To preserve leading zeros, the function will add a `1` at the beginning, if the HEX integer would start with a `0`.<br>
         This could affect the color a little bit, but will make sure, that it won't be interpreted as a completely different<br>
-        color, when initializing it as a `hexa()` color or changing it back to RGBA using `Color.hex_to_rgba()`.\n
-        ⇾ **You can disable this behavior by setting `_preserve_original` to `True`**
-        """
+        color, when initializing it as a `hexa()` color or changing it back to RGBA using `Color.hex_int_to_rgba()`.\n
+        ⇾ **You can disable this behavior by setting `preserve_original` to `True`**"""
         r = max(0, min(255, int(r)))
         g = max(0, min(255, int(g)))
         b = max(0, min(255, int(b)))
         if a is not None:
-            if isinstance(a, float):
-                a = int(a * 255)
-            a = max(0, min(255, int(a)))
+            a = max(0, min(255, int(a * 255)))
             hex_int = (r << 24) | (g << 16) | (b << 8) | a
-            if not _preserve_original and r == 0:
+            if not preserve_original and r == 0:
                 hex_int |= 0x01000000
         else:
             hex_int = (r << 16) | (g << 8) | b
-            if not _preserve_original and (hex_int & 0xF00000) == 0:
+            if not preserve_original and (hex_int & 0xF00000) == 0:
                 hex_int |= 0x010000
         return hex_int
 
     @staticmethod
-    def hex_int_to_rgba(hex_int: int) -> tuple[int, int, int, float | int | None]:
+    def hex_int_to_rgba(hex_int: int, preserve_original: bool = False) -> tuple[int, int, int, float | None]:
+        """Convert a HEX integer to RGBA channels.\n
+        -----------------------------------------------------------------------------------------------
+        If the red channel is `1` after conversion, it will be set to `0`, because when converting<br>
+        from RGBA to a HEX integer, the first `0` will be set to `1` to preserve leading zeros.<br>
+        This is the correction, so the color doesn't even look slightly different.\n
+        ⇾ **You can disable this behavior by setting `preserve_original` to `True`**"""
         if not isinstance(hex_int, int):
-            raise ValueError("Input must be an integer (hex value)")
+            raise ValueError("Input must be an integer")
         hex_str = f"{hex_int:x}"
         if len(hex_str) <= 6:
             hex_str = hex_str.zfill(6)
             return (
-                int(hex_str[0:2], 16),
+                r if (r := int(hex_str[0:2], 16)) != 1 or preserve_original else 0,
                 int(hex_str[2:4], 16),
                 int(hex_str[4:6], 16),
                 None,
@@ -859,7 +870,7 @@ class Color:
         elif len(hex_str) <= 8:
             hex_str = hex_str.zfill(8)
             return (
-                int(hex_str[0:2], 16),
+                r if (r := int(hex_str[0:2], 16)) != 1 or preserve_original else 0,
                 int(hex_str[2:4], 16),
                 int(hex_str[4:6], 16),
                 int(hex_str[6:8], 16) / 255.0,

xulbux/{xx_cmd.py → xx_console.py}

@@ -1,28 +1,28 @@
 """
 Functions for logging and other small actions within the console:
-- `Cmd.get_args()`
-- `Cmd.user()`
-- `Cmd.is_admin()`
-- `Cmd.pause_exit()`
-- `Cmd.cls()`
-- `Cmd.log()`
-- `Cmd.debug()`
-- `Cmd.info()`
-- `Cmd.done()`
-- `Cmd.warn()`
-- `Cmd.fail()`
-- `Cmd.exit()`
-- `Cmd.confirm()`
-- `Cmd.restricted_input()`
-- `Cmd.pwd_input()`\n
+- `Console.get_args()`
+- `Console.user()`
+- `Console.is_admin()`
+- `Console.pause_exit()`
+- `Console.cls()`
+- `Console.log()`
+- `Console.debug()`
+- `Console.info()`
+- `Console.done()`
+- `Console.warn()`
+- `Console.fail()`
+- `Console.exit()`
+- `Console.confirm()`
+- `Console.restricted_input()`
+- `Console.pwd_input()`\n
 ----------------------------------------------------------------------------------------------------------
 You can also use special formatting codes directly inside the log message to change their appearance.<br>
 For more detailed information about formatting codes, see the the `xx_format_codes` description.
 """
 
 from ._consts_ import DEFAULT, CHARS
-from .xx_format_codes import *
-from .xx_string import *
+from .xx_format_codes import FormatCodes
+from .xx_string import String
 from .xx_color import *
 
 from contextlib import suppress
@@ -36,7 +36,7 @@ import sys as _sys
 import os as _os
 
 
-class Cmd:
+class Console:
 
     @staticmethod
     def get_args(find_args: dict) -> dict[str, dict[str, any]]:
@@ -62,7 +62,7 @@ class Cmd:
         return getattr(_shutil.get_terminal_size(), "lines", 24)
 
     def wh() -> tuple[int, int]:
-        return Cmd.w(), Cmd.h()
+        return Console.w(), Console.h()
 
     def user() -> str:
         return _os.getenv("USER") or _os.getenv("USERNAME") or _getpass.getuser()
@@ -153,8 +153,8 @@ class Cmd:
         """A preset for `log()`: `DEBUG` log message with the options to pause<br>
         at the message and exit the program after the message was printed."""
         if active:
-            Cmd.log("DEBUG", prompt, start, end, title_bg_color, default_color)
-            Cmd.pause_exit(pause, exit)
+            Console.log("DEBUG", prompt, start, end, title_bg_color, default_color)
+            Console.pause_exit(pause, exit)
 
     @staticmethod
     def info(
@@ -168,8 +168,8 @@ class Cmd:
     ) -> None:
         """A preset for `log()`: `INFO` log message with the options to pause<br>
         at the message and exit the program after the message was printed."""
-        Cmd.log("INFO", prompt, start, end, title_bg_color, default_color)
-        Cmd.pause_exit(pause, exit)
+        Console.log("INFO", prompt, start, end, title_bg_color, default_color)
+        Console.pause_exit(pause, exit)
 
     @staticmethod
     def done(
@@ -183,8 +183,8 @@ class Cmd:
     ) -> None:
         """A preset for `log()`: `DONE` log message with the options to pause<br>
         at the message and exit the program after the message was printed."""
-        Cmd.log("DONE", prompt, start, end, title_bg_color, default_color)
-        Cmd.pause_exit(pause, exit)
+        Console.log("DONE", prompt, start, end, title_bg_color, default_color)
+        Console.pause_exit(pause, exit)
 
     @staticmethod
     def warn(
@@ -198,8 +198,8 @@ class Cmd:
     ) -> None:
         """A preset for `log()`: `WARN` log message with the options to pause<br>
         at the message and exit the program after the message was printed."""
-        Cmd.log("WARN", prompt, start, end, title_bg_color, default_color)
-        Cmd.pause_exit(pause, exit)
+        Console.log("WARN", prompt, start, end, title_bg_color, default_color)
+        Console.pause_exit(pause, exit)
 
     @staticmethod
     def fail(
@@ -214,8 +214,8 @@ class Cmd:
     ) -> None:
         """A preset for `log()`: `FAIL` log message with the options to pause<br>
         at the message and exit the program after the message was printed."""
-        Cmd.log("FAIL", prompt, start, end, title_bg_color, default_color)
-        Cmd.pause_exit(pause, exit, reset_ansi=reset_ansi)
+        Console.log("FAIL", prompt, start, end, title_bg_color, default_color)
+        Console.pause_exit(pause, exit, reset_ansi=reset_ansi)
 
     @staticmethod
     def exit(
@@ -230,8 +230,8 @@ class Cmd:
     ) -> None:
         """A preset for `log()`: `EXIT` log message with the options to pause<br>
         at the message and exit the program after the message was printed."""
-        Cmd.log("EXIT", prompt, start, end, title_bg_color, default_color)
-        Cmd.pause_exit(pause, exit, reset_ansi=reset_ansi)
+        Console.log("EXIT", prompt, start, end, title_bg_color, default_color)
+        Console.pause_exit(pause, exit, reset_ansi=reset_ansi)
 
     @staticmethod
     def confirm(
@@ -253,7 +253,7 @@ class Cmd:
             )
         ).strip().lower() in (("", "y", "yes") if default_is_yes else ("y", "yes"))
         if end:
-            Cmd.log("", end, end="")
+            Console.log("", end, end="")
         return confirmed
 
     @staticmethod
@@ -317,7 +317,7 @@ class Cmd:
                 result, select_all = "", False
             elif result and event.name == "backspace":
                 result = result[:-1]
-            update_display(Cmd.w())
+            update_display(Console.w())
 
         def handle_paste():
             nonlocal result, select_all
@@ -326,25 +326,25 @@ class Cmd:
             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(Cmd.w())
+                update_display(Console.w())
 
         def handle_select_all():
             nonlocal select_all
             select_all = True
-            update_display(Cmd.w())
+            update_display(Console.w())
 
         def handle_copy():
             nonlocal select_all
             with suppress(KeyboardInterrupt):
                 select_all = False
-                update_display(Cmd.w())
+                update_display(Console.w())
                 _pyperclip.copy(result)
 
         def handle_character_input():
             nonlocal result
             if (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(Cmd.w())
+                update_display(Console.w())
 
         while True:
             event = _keyboard.read_event()
@@ -367,7 +367,7 @@ class Cmd:
                     handle_character_input()
                 else:
                     select_all = False
-                    update_display(Cmd.w())
+                    update_display(Console.w())
 
     @staticmethod
     def pwd_input(
@@ -378,4 +378,4 @@ class Cmd:
         _reset_ansi: bool = True,
     ) -> str:
         """Password input that masks the entered characters with asterisks."""
-        return Cmd.restricted_input(prompt, allowed_chars, min_len, max_len, "*", _reset_ansi)
+        return Console.restricted_input(prompt, allowed_chars, min_len, max_len, "*", _reset_ansi)