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

xulbux/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.7.0"
+__version__ = "1.7.2"
 __author__ = "XulbuX"
 __email__ = "xulbux.real@gmail.com"
 __license__ = "MIT"

xulbux/_consts_.py

@@ -94,8 +94,6 @@ class ANSI:
     """The separator between ANSI escape sequence parts."""
     END = end = "m"
     """The end of an ANSI escape sequence."""
-    default_color_modifiers: dict[str, str] = {"lighten": "+l", "darken": "-d"}
-    """Characters to modify the lightness of the default color with."""
 
     @classmethod
     def seq(cls, parts: int = 1) -> FormattableString:
@@ -107,7 +105,7 @@ class ANSI:
     seq_bg_color: FormattableString = CHAR + START + "48" + SEP + "2" + SEP + "{}" + SEP + "{}" + SEP + "{}" + END
     """The ANSI escape sequence for setting the background RGB color."""
 
-    color_map: list[str] = [
+    color_map: tuple[str, ...] = (
         ########### DEFAULT CONSOLE COLOR NAMES ############
         "black",
         "red",
@@ -117,7 +115,7 @@ class ANSI:
         "magenta",
         "cyan",
         "white",
-    ]
+    )
     """The console default color names."""
 
     codes_map: dict[str | tuple[str, ...], int] = {

xulbux/xx_code.py

@@ -53,7 +53,7 @@ class Code:
         return list(Data.remove_duplicates(funcs + nested_func_calls))
 
     @staticmethod
-    def is_js(code: str, funcs: list = ["__", "$t", "$lang"]) -> bool:
+    def is_js(code: str, funcs: list[str] = ["__", "$t", "$lang"]) -> bool:
         """Will check if the code is very likely to be JavaScript."""
         if not code or len(code.strip()) < 3:
             return False

xulbux/xx_color.py

@@ -33,7 +33,7 @@ The `Color` class, which contains all sorts of different color-related methods:
 
 from .xx_regex import Regex
 
-from typing import Annotated, TypeAlias, Iterator, Optional, Literal, Union
+from typing import Annotated, TypeAlias, Iterator, Optional, Literal, Union, Any, cast
 import re as _re
 
 
@@ -42,6 +42,10 @@ Int_0_255 = Annotated[int, "An integer value between 0 and 255, inclusive."]
 Int_0_360 = Annotated[int, "An integer value between 0 and 360, inclusive."]
 Float_0_1 = Annotated[float, "A float value between 0.0 and 1.0, inclusive."]
 
+AnyRgba: TypeAlias = Any
+AnyHsla: TypeAlias = Any
+AnyHexa: TypeAlias = Any
+
 Rgba: TypeAlias = Union[
     tuple[Int_0_255, Int_0_255, Int_0_255],
     tuple[Int_0_255, Int_0_255, Int_0_255, Float_0_1],
@@ -178,7 +182,7 @@ class rgba:
             self.a = 1 - self.a
         return rgba(self.r, self.g, self.b, self.a, _validate=False)
 
-    def grayscale(self, method: str = "wcag2") -> "rgba":
+    def grayscale(self, method: Literal["wcag2", "wcag3", "simple", "bt601"] = "wcag2") -> "rgba":
         """Converts the color to grayscale using the luminance formula.\n
         ------------------------------------------------------------------
         The `method` is the luminance calculation method to use:
@@ -387,7 +391,7 @@ class hsla:
             self.a = 1 - self.a
         return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
-    def grayscale(self, method: str = "wcag2") -> "hsla":
+    def grayscale(self, method: Literal["wcag2", "wcag3", "simple", "bt601"] = "wcag2") -> "hsla":
         """Converts the color to grayscale using the luminance formula.\n
         ------------------------------------------------------------------
         The `method` is the luminance calculation method to use:
@@ -496,7 +500,7 @@ class hexa:
         self.b: int
         self.a: Optional[float]
         if all(x is not None for x in (_r, _g, _b)):
-            self.r, self.g, self.b, self.a = _r, _g, _b, _a  # type: ignore[assignment]
+            self.r, self.g, self.b, self.a = cast(int, _r), cast(int, _g), cast(int, _b), _a
             return
         if isinstance(color, hexa):
             raise ValueError("Color is already a hexa() color")
@@ -628,7 +632,7 @@ class hexa:
             self.a = 1 - self.a
         return hexa("", self.r, self.g, self.b, self.a)
 
-    def grayscale(self, method: str = "wcag2") -> "hexa":
+    def grayscale(self, method: Literal["wcag2", "wcag3", "simple", "bt601"] = "wcag2") -> "hexa":
         """Converts the color to grayscale using the luminance formula.\n
         ------------------------------------------------------------------
         The `method` is the luminance calculation method to use:
@@ -677,7 +681,7 @@ class hexa:
 class Color:
 
     @staticmethod
-    def is_valid_rgba(color: Rgba, allow_alpha: bool = True) -> bool:
+    def is_valid_rgba(color: AnyRgba, allow_alpha: bool = True) -> bool:
         try:
             if isinstance(color, rgba):
                 return True
@@ -685,7 +689,7 @@ class Color:
                 if allow_alpha and Color.has_alpha(color):
                     return (
                         0 <= color[0] <= 255 and 0 <= color[1] <= 255 and 0 <= color[2] <= 255
-                        and (0 <= color[3] <= 1 or color[3] is None)  # type: ignore[index]
+                        and (0 <= color[3] <= 1 or color[3] is None)
                     )
                 elif len(color) == 3:
                     return 0 <= color[0] <= 255 and 0 <= color[1] <= 255 and 0 <= color[2] <= 255
@@ -708,7 +712,7 @@ class Color:
             return False
 
     @staticmethod
-    def is_valid_hsla(color: Hsla, allow_alpha: bool = True) -> bool:
+    def is_valid_hsla(color: AnyHsla, allow_alpha: bool = True) -> bool:
         try:
             if isinstance(color, hsla):
                 return True
@@ -716,7 +720,7 @@ class Color:
                 if allow_alpha and Color.has_alpha(color):
                     return (
                         0 <= color[0] <= 360 and 0 <= color[1] <= 100 and 0 <= color[2] <= 100
-                        and (0 <= color[3] <= 1 or color[3] is None)  # type: ignore[index]
+                        and (0 <= color[3] <= 1 or color[3] is None)
                     )
                 elif len(color) == 3:
                     return 0 <= color[0] <= 360 and 0 <= color[1] <= 100 and 0 <= color[2] <= 100
@@ -734,12 +738,13 @@ class Color:
                     return False
             elif isinstance(color, str):
                 return bool(_re.fullmatch(Regex.hsla_str(allow_alpha=allow_alpha), color))
+            return False
         except Exception:
             return False
 
     @staticmethod
     def is_valid_hexa(
-        color: Hexa,
+        color: AnyHexa,
         allow_alpha: bool = True,
         get_prefix: bool = False,
     ) -> bool | tuple[bool, Optional[Literal['#', '0x']]]:
@@ -754,14 +759,15 @@ class Color:
                                  (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 False
         except Exception:
             return (False, None) if get_prefix else False
 
     @staticmethod
-    def is_valid(color: Rgba | Hsla | Hexa, allow_alpha: bool = True) -> bool:
+    def is_valid(color: AnyRgba | AnyHsla | AnyHexa, allow_alpha: bool = True) -> bool:
         return bool(
-            Color.is_valid_rgba(color, allow_alpha) or Color.is_valid_hsla(color, allow_alpha)  # type: ignore[assignment]
-            or Color.is_valid_hexa(color, allow_alpha)  # type: ignore[assignment]
+            Color.is_valid_rgba(color, allow_alpha) or Color.is_valid_hsla(color, allow_alpha)
+            or Color.is_valid_hexa(color, allow_alpha)
         )
 
     @staticmethod
@@ -772,7 +778,7 @@ class Color:
         Returns `True` if the color has an alpha channel and `False` otherwise."""
         if isinstance(color, (rgba, hsla, hexa)):
             return color.has_alpha()
-        if Color.is_valid_hexa(color):  # type: ignore[assignment]
+        if Color.is_valid_hexa(color):
             if isinstance(color, str):
                 if color.startswith("#"):
                     color = color[1:]
@@ -791,11 +797,11 @@ class Color:
         """Will try to convert any color type to a color of type RGBA."""
         if isinstance(color, (hsla, hexa)):
             return color.to_rgba()
-        elif Color.is_valid_hsla(color):  # type: ignore[assignment]
+        elif Color.is_valid_hsla(color):
             return hsla(*color, _validate=False).to_rgba()  # type: ignore[not-iterable]
-        elif Color.is_valid_hexa(color):  # type: ignore[assignment]
-            return hexa(color).to_rgba()  # type: ignore[assignment]
-        elif Color.is_valid_rgba(color):  # type: ignore[assignment]
+        elif Color.is_valid_hexa(color):
+            return hexa(cast(str | int, color)).to_rgba()
+        elif Color.is_valid_rgba(color):
             return color if isinstance(color, rgba) else (rgba(*color, _validate=False))  # type: ignore[not-iterable]
         raise ValueError(f"Invalid color format '{color}'")
 
@@ -804,11 +810,11 @@ class Color:
         """Will try to convert any color type to a color of type HSLA."""
         if isinstance(color, (rgba, hexa)):
             return color.to_hsla()
-        elif Color.is_valid_rgba(color):  # type: ignore[assignment]
+        elif Color.is_valid_rgba(color):
             return rgba(*color, _validate=False).to_hsla()  # type: ignore[not-iterable]
-        elif Color.is_valid_hexa(color):  # type: ignore[assignment]
-            return hexa(color).to_hsla()  # type: ignore[assignment]
-        elif Color.is_valid_hsla(color):  # type: ignore[assignment]
+        elif Color.is_valid_hexa(color):
+            return hexa(cast(str | int, color)).to_hsla()
+        elif Color.is_valid_hsla(color):
             return color if isinstance(color, hsla) else (hsla(*color, _validate=False))  # type: ignore[not-iterable]
         raise ValueError(f"Invalid color format '{color}'")
 
@@ -817,12 +823,12 @@ class Color:
         """Will try to convert any color type to a color of type HEXA."""
         if isinstance(color, (rgba, hsla)):
             return color.to_hexa()
-        elif Color.is_valid_rgba(color):  # type: ignore[assignment]
+        elif Color.is_valid_rgba(color):
             return rgba(*color, _validate=False).to_hexa()  # type: ignore[not-iterable]
-        elif Color.is_valid_hsla(color):  # type: ignore[assignment]
+        elif Color.is_valid_hsla(color):
             return hsla(*color, _validate=False).to_hexa()  # type: ignore[not-iterable]
-        elif Color.is_valid_hexa(color):  # type: ignore[assignment]
-            return color if isinstance(color, hexa) else hexa(color)  # type: ignore[assignment]
+        elif Color.is_valid_hexa(color):
+            return color if isinstance(color, hexa) else hexa(cast(str | int, color))
         raise ValueError(f"Invalid color format '{color}'")
 
     @staticmethod
@@ -919,7 +925,13 @@ class Color:
             raise ValueError(f"Invalid HEX integer '0x{hex_str}': expected in range [0x000000, 0xFFFFFF]")
 
     @staticmethod
-    def luminance(r: int, g: int, b: int, output_type: Optional[type] = None, method: str = "wcag2") -> int | float:
+    def luminance(
+        r: int,
+        g: int,
+        b: int,
+        output_type: Optional[type] = None,
+        method: Literal["wcag2", "wcag3", "simple", "bt601"] = "wcag2",
+    ) -> int | float:
         """Calculates the relative luminance of a color according to various standards.\n
         ----------------------------------------------------------------------------------
         The `output_type` controls the range of the returned luminance value:
@@ -963,7 +975,7 @@ class Color:
 
     @staticmethod
     def text_color_for_on_bg(text_bg_color: Rgba | Hexa) -> rgba | hexa | int:
-        was_hexa, was_int = Color.is_valid_hexa(text_bg_color), isinstance(text_bg_color, int)  # type: ignore[assignment]
+        was_hexa, was_int = Color.is_valid_hexa(text_bg_color), isinstance(text_bg_color, int)
         text_bg_color = Color.to_rgba(text_bg_color)
         brightness = 0.2126 * text_bg_color[0] + 0.7152 * text_bg_color[1] + 0.0722 * text_bg_color[2]
         return (((0xFFFFFF if was_int else hexa("", 255, 255, 255)) if was_hexa else rgba(255, 255, 255, _validate=False))
@@ -978,22 +990,22 @@ class Color:
         - lightness_change (float): float between -1.0 (darken by `100%`) and 1.0 (lighten by `100%`)\n
         -----------------------------------------------------------------------------------------------------
         returns (rgba|hexa): the adjusted color in the format of the input color"""
-        was_hexa = Color.is_valid_hexa(color)  # type: ignore[assignment]
-        _color: hsla = Color.to_hsla(color)  # type: ignore[assignment]
+        was_hexa = Color.is_valid_hexa(color)
+        _color: hsla = Color.to_hsla(color)
         h, s, l, a = (int(_color[0]), int(_color[1]), int(_color[2]), _color[3] if Color.has_alpha(_color) else None)
         l = int(max(0, min(100, l + lightness_change * 100)))
         return hsla(h, s, l, a, _validate=False).to_hexa() if was_hexa else hsla(h, s, l, a, _validate=False).to_rgba()
 
     @staticmethod
-    def adjust_saturation(color: Rgba | Hsla | Hexa, saturation_change: float) -> rgba | hexa:
+    def adjust_saturation(color: Rgba | Hexa, saturation_change: float) -> rgba | hexa:
         """In- or decrease the saturation of the input color.\n
         -----------------------------------------------------------------------------------------------------------
         - color (rgba|hexa): HEX or RGBA color
         - saturation_change (float): float between -1.0 (saturate by `100%`) and 1.0 (desaturate by `100%`)\n
         -----------------------------------------------------------------------------------------------------------
         returns (rgba|hexa): the adjusted color in the format of the input color"""
-        was_hexa = Color.is_valid_hexa(color)  # type: ignore[assignment]
-        _color: hsla = Color.to_hsla(color)  # type: ignore[assignment]
+        was_hexa = Color.is_valid_hexa(color)
+        _color: hsla = Color.to_hsla(color)
         h, s, l, a = (int(_color[0]), int(_color[1]), int(_color[2]), _color[3] if Color.has_alpha(_color) else None)
         s = int(max(0, min(100, s + saturation_change * 100)))
         return hsla(h, s, l, a, _validate=False).to_hexa() if was_hexa else hsla(h, s, l, a, _validate=False).to_rgba()

xulbux/xx_console.py

@@ -11,7 +11,7 @@ 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, Any
+from typing import Optional, Literal, Mapping, Any, cast
 import prompt_toolkit as _prompt_toolkit
 import pyperclip as _pyperclip
 import keyboard as _keyboard
@@ -25,20 +25,29 @@ import os as _os
 class _ConsoleWidth:
 
     def __get__(self, obj, owner=None):
-        return _os.get_terminal_size().columns
+        try:
+            return _os.get_terminal_size().columns
+        except OSError:
+            return 80
 
 
 class _ConsoleHeight:
 
     def __get__(self, obj, owner=None):
-        return _os.get_terminal_size().lines
+        try:
+            return _os.get_terminal_size().lines
+        except OSError:
+            return 24
 
 
 class _ConsoleSize:
 
     def __get__(self, obj, owner=None):
-        size = _os.get_terminal_size()
-        return (size.columns, size.lines)
+        try:
+            size = _os.get_terminal_size()
+            return (size.columns, size.lines)
+        except OSError:
+            return (80, 24)
 
 
 class _ConsoleUser:
@@ -48,25 +57,31 @@ class _ConsoleUser:
 
 
 class ArgResult:
-    """Exists: if the argument was found or not\n
-    Value: the value from behind the found argument"""
+    """Represents the result of a parsed command-line argument and contains the following attributes:
+    - `exists` -⠀if the argument was found or not
+    - `value` -⠀the value given with the found argument\n
+    --------------------------------------------------------------------------------------------------------
+    When the `ArgResult` instance is accessed as a boolean it will correspond to the `exists` attribute."""
 
     def __init__(self, exists: bool, value: Any):
-        self.exists = exists
-        self.value = value
+        self.exists: bool = exists
+        self.value: Any = value
 
     def __bool__(self):
         return self.exists
 
 
 class Args:
-    """Stores found command arguments under their aliases with their results."""
+    """Container for parsed command-line arguments, allowing attribute-style access.
+    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):
-        for key, value in kwargs.items():
-            if not key.isidentifier():
-                raise TypeError(f"Argument alias '{key}' is invalid. It must be a valid Python variable name.")
-            setattr(self, key, ArgResult(**value))
+    def __init__(self, **kwargs: dict[str, 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)
 
     def __len__(self):
         return len(vars(self))
@@ -74,6 +89,9 @@ class Args:
     def __contains__(self, key):
         return hasattr(self, key)
 
+    def __getattr__(self, name: str) -> ArgResult:
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
     def __getitem__(self, key):
         if isinstance(key, int):
             return list(self.__iter__())[key]
@@ -108,14 +126,13 @@ class Console:
     h: int = _ConsoleHeight()  # type: ignore[assignment]
     """The height of the console in lines."""
     wh: tuple[int, int] = _ConsoleSize()  # type: ignore[assignment]
-    """A tuple with the width and height of
-    the console in characters and lines."""
+    """A tuple with the width and height of the console in characters and lines."""
     usr: str = _ConsoleUser()  # type: ignore[assignment]
     """The name of the current user."""
 
     @staticmethod
     def get_args(
-        find_args: dict[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]],
         allow_spaces: bool = False
     ) -> Args:
         """Will search for the specified arguments in the command line
@@ -223,13 +240,13 @@ class Console:
         exit_code: int = 0,
         reset_ansi: bool = False,
     ) -> None:
-        """Will print the `last_prompt` and then pause the program if `pause` is set
+        """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)
         if reset_ansi:
             FormatCodes.print("[_]", end="")
         if pause:
-            _keyboard.read_event()
+            _keyboard.read_key(suppress=True)
         if exit:
             _sys.exit(exit_code)
 
@@ -267,7 +284,11 @@ class Console:
         information about formatting codes, see `xx_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)
-        title_color = "_color" if not title_bg_color else Color.text_color_for_on_bg(title_bg_color)
+        if title_bg_color is not None and Color.is_valid(title_bg_color):
+            title_bg_color = Color.to_hexa(title_bg_color)
+            title_color = Color.text_color_for_on_bg(title_bg_color)
+        else:
+            title_color = "_color" if title_bg_color is None else "#000"
         if format_linebreaks:
             clean_prompt, removals = FormatCodes.remove_formatting(str(prompt), get_removals=True, _ignore_linebreaks=True)
             prompt_lst = (String.split_count(l, Console.w - (title_len + tab_len)) for l in str(clean_prompt).splitlines())
@@ -275,7 +296,7 @@ class Console:
                 item for lst in prompt_lst for item in ([""] if lst == [] else (lst if isinstance(lst, list) else [lst]))
             )
             prompt = f"\n{' ' * title_len}\t".join(
-                Console.__add_back_removed_parts(list(prompt_lst), removals)  # type: ignore[assignment]
+                Console.__add_back_removed_parts(list(prompt_lst), cast(tuple[tuple[int, str], ...], removals))
             )
         else:
             prompt = str(prompt)
@@ -332,8 +353,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Rgba | Hexa = COLOR.yellow,
-        default_color: Rgba | Hexa = COLOR.text,
+        title_bg_color: Optional[Rgba | Hexa] = COLOR.yellow,
+        default_color: Optional[Rgba | Hexa] = COLOR.text,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
@@ -350,8 +371,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Rgba | Hexa = COLOR.blue,
-        default_color: Rgba | Hexa = COLOR.text,
+        title_bg_color: Optional[Rgba | Hexa] = COLOR.blue,
+        default_color: Optional[Rgba | Hexa] = COLOR.text,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
@@ -366,8 +387,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Rgba | Hexa = COLOR.teal,
-        default_color: Rgba | Hexa = COLOR.text,
+        title_bg_color: Optional[Rgba | Hexa] = COLOR.teal,
+        default_color: Optional[Rgba | Hexa] = COLOR.text,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
@@ -382,8 +403,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Rgba | Hexa = COLOR.orange,
-        default_color: Rgba | Hexa = COLOR.text,
+        title_bg_color: Optional[Rgba | Hexa] = COLOR.orange,
+        default_color: Optional[Rgba | Hexa] = COLOR.text,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
@@ -398,11 +419,11 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Rgba | Hexa = COLOR.red,
-        default_color: Rgba | Hexa = COLOR.text,
+        title_bg_color: Optional[Rgba | Hexa] = COLOR.red,
+        default_color: Optional[Rgba | Hexa] = COLOR.text,
         pause: bool = False,
         exit: bool = True,
-        reset_ansi=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."""
@@ -415,11 +436,11 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: Rgba | Hexa = COLOR.magenta,
-        default_color: Rgba | Hexa = COLOR.text,
+        title_bg_color: Optional[Rgba | Hexa] = COLOR.magenta,
+        default_color: Optional[Rgba | Hexa] = COLOR.text,
         pause: bool = False,
         exit: bool = True,
-        reset_ansi=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."""
@@ -427,18 +448,18 @@ class Console:
         Console.pause_exit(pause, exit, reset_ansi=reset_ansi)
 
     @staticmethod
-    def log_box(
+    def log_box_filled(
         *values: object,
         start: str = "",
         end: str = "\n",
         box_bg_color: str | Rgba | Hexa = "green",
-        default_color: Rgba | Hexa = "#000",
+        default_color: Optional[Rgba | Hexa] = None,
         w_padding: int = 2,
         w_full: bool = False,
     ) -> None:
-        """Will print a box, containing a formatted log message:
+        """Will print a box with a colored background, containing a formatted log message:
         - `*values` -⠀the box content (each value is on a new line)
-        - `start` -⠀something to print before the log box is printed
+        - `start` -⠀something to print before the log box is printed (e.g. `\\n`)
         - `end` -⠀something to print after the log box is printed (e.g. `\\n`)
         - `box_bg_color` -⠀the background color of the box
         - `default_color` -⠀the default text color of the `*values`
@@ -447,30 +468,108 @@ class Console:
         -----------------------------------------------------------------------------------
         The box content can be formatted with special formatting codes. For more detailed
         information about formatting codes, see `xx_format_codes` module documentation."""
-        lines = [line.rstrip() for val in values for line in str(val).splitlines()]
-        unfmt_lines = [FormatCodes.remove_formatting(line) for line in lines]
-        max_line_len = max(len(line) for line in unfmt_lines)
+        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)
         lines = [
             f"[bg:{box_bg_color}]{' ' * w_padding}{line}" + " " *
-            ((w_padding + max_line_len - len(unfmt)) + pad_w_full) + "[_bg]" for line, unfmt in zip(lines, unfmt_lines)
+            ((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}[_bg]\n"
+            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}[_bg]",
+            + f"\n[bg:{box_bg_color}]{pady}[_]",
+            default_color=default_color or "#000",
+            sep="\n",
+            end=end,
+        )
+
+    @staticmethod
+    def log_box_bordered(
+        *values: object,
+        start: str = "",
+        end: str = "\n",
+        border_type: Literal["standard", "rounded", "strong", "double"] = "rounded",
+        border_style: str | Rgba | Hexa = f"dim|{COLOR.gray}",
+        default_color: Optional[Rgba | Hexa] = None,
+        w_padding: int = 1,
+        w_full: bool = False,
+        _border_chars: Optional[tuple[str, str, str, str, str, str, str, str]] = None,
+    ) -> None:
+        """Will print a bordered box, containing a formatted log message:
+        - `*values` -⠀the box content (each value is on a new line)
+        - `start` -⠀something to print before the log box is printed (e.g. `\\n`)
+        - `end` -⠀something to print after the log box is printed (e.g. `\\n`)
+        - `border_type` -⠀one of the predefined border character sets
+        - `border_style` -⠀the style of the border (special formatting codes)
+        - `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
+        - `_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
+        ---------------------------------------------------------------------------------------
+        The `border_type` can be one of the following:
+        - `"standard" = ('┌', '─', '┐', '│', '┘', '─', '└', '│')`
+        - `"rounded" = ('╭', '─', '╮', '│', '╯', '─', '╰', '│')`
+        - `"strong" = ('┏', '━', '┓', '┃', '┛', '━', '┗', '┃')`
+        - `"double" = ('╔', '═', '╗', '║', '╝', '═', '╚', '║')`\n
+        The order of the characters is always:
+        1. top-left corner
+        2. top border
+        3. top-right corner
+        4. right border
+        5. bottom-right corner
+        6. bottom border
+        7. bottom-left corner
+        8. left border"""
+        borders = {
+            "standard": ('┌', '─', '┐', '│', '┘', '─', '└', '│'),
+            "rounded": ('╭', '─', '╮', '│', '╯', '─', '╰', '│'),
+            "strong": ('┏', '━', '┓', '┃', '┛', '━', '┗', '┃'),
+            "double": ('╔', '═', '╗', '║', '╝', '═', '╚', '║'),
+        }
+        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)
+        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)
+        ]
+        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]}[_]"
+        FormatCodes.print(
+            f"{start}{border_t}[_]\n" + "\n".join(lines) + f"\n{border_b}[_]",
             default_color=default_color,
             sep="\n",
             end=end,
         )
 
+    @staticmethod
+    def __prepare_log_box(
+        values: tuple[object, ...],
+        default_color: Optional[Rgba | Hexa] = None,
+    ) -> tuple[list[str], list[tuple[str, tuple[tuple[int, str], ...]]], int]:
+        """Prepares the log box content and returns it along with the max line length."""
+        lines = [line for val in values for line in str(val).splitlines()]
+        unfmt_lines = [FormatCodes.remove_formatting(line, default_color) for line in lines]
+        max_line_len = max(len(line) for line in unfmt_lines)
+        return lines, cast(list[tuple[str, tuple[tuple[int, str], ...]]], unfmt_lines), max_line_len
+
     @staticmethod
     def confirm(
         prompt: object = "Do you want to continue?",
         start="",
         end="\n",
-        default_color: Rgba | Hexa = COLOR.cyan,
+        default_color: Optional[Rgba | Hexa] = COLOR.cyan,
         default_is_yes: bool = True,
     ) -> bool:
         """Ask a yes/no question.\n
@@ -480,7 +579,7 @@ class Console:
         confirmed = input(
             FormatCodes.to_ansi(
                 f'{start}  {str(prompt)} [_|dim](({"Y" if default_is_yes else "y"}/{"n" if default_is_yes else "N"}):  )',
-                default_color,
+                default_color=default_color,
             )
         ).strip().lower() in (("", "y", "yes") if default_is_yes else ("y", "yes"))
         if end:
@@ -492,9 +591,9 @@ class Console:
         prompt: object = "",
         start="",
         end="\n",
-        default_color: Rgba | Hexa = COLOR.cyan,
+        default_color: Optional[Rgba | Hexa] = COLOR.cyan,
         show_keybindings=True,
-        input_prefix=" ⤷ ",
+        input_prefix=" ⮡ ",
         reset_ansi=True,
     ) -> str:
         """An input where users can input (and paste) text over multiple lines.\n
@@ -527,7 +626,7 @@ class Console:
         prompt: object = "",
         start="",
         end="\n",
-        default_color: Rgba | Hexa = COLOR.cyan,
+        default_color: Optional[Rgba | Hexa] = COLOR.cyan,
         allowed_chars: str = CHARS.all,  # type: ignore[assignment]
         min_len: Optional[int] = None,
         max_len: Optional[int] = None,
@@ -631,7 +730,7 @@ class Console:
         prompt: object = "Password: ",
         start="",
         end="\n",
-        default_color: Rgba | Hexa = COLOR.cyan,
+        default_color: Optional[Rgba | Hexa] = COLOR.cyan,
         allowed_chars: str = CHARS.standard_ascii,
         min_len: Optional[int] = None,
         max_len: Optional[int] = None,

xulbux/xx_format_codes.py

@@ -133,9 +133,13 @@ the formatting code:
 #### Additional Formatting Codes when a `default_color` is set
 
 1. `[*]` resets everything, just like `[_]`, but the text color will remain in `default_color`
-2. `[*color]` will reset the text color, just like `[_color]`, but then also make it `default_color`
+  (if no `default_color` is set, it resets everything, exactly like `[_]`)
+2. `[*color]` `[*c]` will reset the text color, just like `[_color]`, but then also make it `default_color`
+  (if no `default_color` is set, both are treated as invalid formatting codes)
 3. `[default]` will just color the text in `default_color`
+  (if no `default_color` is set, it's treated as an invalid formatting code)
 4. `[background:default]` `[BG:default]` will color the background in `default_color`
+  (if no `default_color` is set, both are treated as invalid formatting codes)\n
 
 Unlike the standard console colors, the default color can be changed by using the following modifiers:
 
@@ -148,6 +152,7 @@ Unlike the standard console colors, the default color can be changed by using th
 - `[ddd]` will darken the `default_color` text by `3 × brightness_steps`%
 - ... etc.
 Per default, you can also use `+` and `-` to get lighter and darker `default_color` versions.
+All of these lighten/darken formatting codes are treated as invalid if no `default_color` is set.
 """
 
 from ._consts_ import ANSI
@@ -155,7 +160,7 @@ from .xx_string import String
 from .xx_regex import Regex, Match, Pattern
 from .xx_color import Color, rgba, Rgba, Hexa
 
-from typing import Optional
+from typing import Optional, cast
 import ctypes as _ctypes
 import regex as _rx
 import sys as _sys
@@ -164,6 +169,11 @@ import re as _re
 
 _CONSOLE_ANSI_CONFIGURED: bool = False
 
+_ANSI_SEQ_1: str = ANSI.seq(1)
+_DEFAULT_COLOR_MODS: dict[str, str] = {
+    "lighten": "+l",
+    "darken": "-d",
+}
 _PREFIX: dict[str, set[str]] = {
     "BG": {"background", "bg"},
     "BR": {"bright", "br"},
@@ -174,7 +184,7 @@ _PREFIX_RX: dict[str, str] = {
 }
 _COMPILED: dict[str, Pattern] = {  # PRECOMPILE REGULAR EXPRESSIONS
     "*": _re.compile(r"\[\s*([^]_]*?)\s*\*\s*([^]_]*?)\]"),
-    "*color": _re.compile(r"\[\s*([^]_]*?)\s*\*color\s*([^]_]*?)\]"),
+    "*color": _re.compile(r"\[\s*([^]_]*?)\s*\*c(?:olor)?\s*([^]_]*?)\]"),
     "ansi_seq": _re.compile(ANSI.char + r"(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])"),
     "formatting": _rx.compile(
         Regex.brackets("[", "]", is_group=True, ignore_in_strings=False)
@@ -189,7 +199,7 @@ _COMPILED: dict[str, Pattern] = {  # PRECOMPILE REGULAR EXPRESSIONS
     "modifier": _re.compile(
         r"(?i)((?:BG\s*:)?)\s*("
         + "|".join(
-            [f"{_re.escape(m)}+" for m in ANSI.default_color_modifiers["lighten"] + ANSI.default_color_modifiers["darken"]]
+            [f"{_re.escape(m)}+" for m in _DEFAULT_COLOR_MODS["lighten"] + _DEFAULT_COLOR_MODS["darken"]]
         )
         + r")$"
     ),
@@ -246,6 +256,7 @@ class FormatCodes:
         default_color: Optional[Rgba | Hexa] = None,
         brightness_steps: int = 20,
         _default_start: bool = True,
+        _validate_default: bool = True,
     ) -> str:
         """Convert the formatting codes inside a string to ANSI formatting.\n
         -------------------------------------------------------------------------
@@ -253,15 +264,22 @@ class FormatCodes:
         `xx_format_codes` module documentation."""
         if not isinstance(string, str):
             string = str(string)
-        if default_color and Color.is_valid_rgba(default_color, False):  # type: ignore[assignment]
-            use_default = True
-        elif default_color and Color.is_valid_hexa(default_color, False):  # type: ignore[assignment]
-            use_default, default_color = True, Color.to_rgba(default_color)
+        use_default, default_specified = False, default_color is not None
+        if _validate_default and default_specified:
+            if Color.is_valid_rgba(default_color, False):
+                use_default = True
+            elif Color.is_valid_hexa(default_color, False):
+                use_default, default_color = True, Color.to_rgba(default_color)  # type: ignore[assignment]
         else:
-            use_default = False
+            use_default = default_specified
+        default_color = cast(Optional[rgba], default_color)
         if use_default:
             string = _COMPILED["*"].sub(r"[\1_|default\2]", string)  # REPLACE `[…|*|…]` WITH `[…|_|default|…]`
-            string = _COMPILED["*color"].sub(r"[\1default\2]", string)  # REPLACE `[…|*color|…]` WITH `[…|default|…]`
+            string = _COMPILED["*color"].sub(
+                r"[\1default\2]", string
+            )  # REPLACE `[…|*color|…]` OR `[…|*c|…]` WITH `[…|default|…]`
+        else:
+            string = _COMPILED["*"].sub(r"[\1_\2]", string)  # REPLACE `[…|*|…]` WITH `[…|_|…]`
 
         def is_valid_color(color: str) -> bool:
             return bool((color in ANSI.color_map) or Color.is_valid_rgba(color) or Color.is_valid_hexa(color))
@@ -273,15 +291,27 @@ class FormatCodes:
             if formats_escaped := bool(_COMPILED["escape_char_cond"].match(match.group(0))):
                 _formats = formats = _COMPILED["escape_char"].sub(r"\1", formats)  # REMOVE / OR \\
             if auto_reset_txt and auto_reset_txt.count("[") > 0 and auto_reset_txt.count("]") > 0:
-                auto_reset_txt = FormatCodes.to_ansi(auto_reset_txt, default_color, brightness_steps, False)
+                auto_reset_txt = FormatCodes.to_ansi(
+                    auto_reset_txt,
+                    default_color,
+                    brightness_steps,
+                    _default_start=False,
+                    _validate_default=False,
+                )
             if not formats:
                 return match.group(0)
             if formats.count("[") > 0 and formats.count("]") > 0:
-                formats = FormatCodes.to_ansi(formats, default_color, brightness_steps, False)
+                formats = FormatCodes.to_ansi(
+                    formats,
+                    default_color,
+                    brightness_steps,
+                    _default_start=False,
+                    _validate_default=False,
+                )
             format_keys = [k.strip() for k in formats.split("|") if k.strip()]
             ansi_formats = [
-                r if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)) != k  # type: ignore[assignment]
-                else f"[{k}]" for k in format_keys
+                r if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)) != k else f"[{k}]"
+                for k in format_keys
             ]
             if auto_reset_txt and not auto_reset_escaped:
                 reset_keys = []
@@ -292,7 +322,7 @@ class FormatCodes:
                         if k_set & _PREFIX["BR"]:
                             for i in range(len(k)):
                                 if is_valid_color(k[i:]):
-                                    reset_keys.extend(["_bg", "_color"])
+                                    reset_keys.extend(["_bg", "default"] if use_default else ["_bg", "_c"])
                                     break
                         else:
                             for i in range(len(k)):
@@ -302,13 +332,12 @@ class FormatCodes:
                     elif is_valid_color(k) or any(
                             k_lower.startswith(pref_colon := f"{prefix}:") and is_valid_color(k[len(pref_colon):])
                             for prefix in _PREFIX["BR"]):
-                        reset_keys.append("_color")
+                        reset_keys.append("default" if use_default else "_c")
                     else:
                         reset_keys.append(f"_{k}")
                 ansi_resets = [
-                    r for k in reset_keys
-                    if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)  # type: ignore[assignment]
-                        ).startswith(f"{ANSI.char}{ANSI.start}")
+                    r for k in reset_keys if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)
+                                              ).startswith(f"{ANSI.char}{ANSI.start}")
                 ]
             else:
                 ansi_resets = []
@@ -320,14 +349,14 @@ class FormatCodes:
             else:
                 return (
                     "".join(ansi_formats) + (
-                        f"({FormatCodes.to_ansi(auto_reset_txt, default_color, brightness_steps, False)})"
+                        f"({FormatCodes.to_ansi(auto_reset_txt, default_color, brightness_steps, _default_start=False, _validate_default=False)})"
                         if auto_reset_escaped and auto_reset_txt else auto_reset_txt if auto_reset_txt else ""
                     ) + ("" if auto_reset_escaped else "".join(ansi_resets))
                 )
 
         string = "\n".join(_COMPILED["formatting"].sub(replace_keys, line) for line in string.split("\n"))
-        return (((FormatCodes.__get_default_ansi(default_color) or "") if _default_start else "")  # type: ignore[assignment]
-                + string) if use_default else string
+        return (((FormatCodes.__get_default_ansi(default_color) or "") if _default_start else "")
+                + string) if default_color is not None else string
 
     @staticmethod
     def escape_ansi(ansi_string: str) -> str:
@@ -366,6 +395,7 @@ class FormatCodes:
     @staticmethod
     def remove_formatting(
         string: str,
+        default_color: Optional[Rgba | Hexa] = None,
         get_removals: bool = False,
         _ignore_linebreaks: bool = False,
     ) -> str | tuple[str, tuple[tuple[int, str], ...]]:
@@ -375,7 +405,7 @@ class FormatCodes:
         Each tuple contains the position of the removed formatting code and the removed formatting code.\n
         If `_ignore_linebreaks` is true, linebreaks will be ignored for the removal positions."""
         return FormatCodes.remove_ansi(
-            FormatCodes.to_ansi(string),
+            FormatCodes.to_ansi(string, default_color=default_color),
             get_removals=get_removals,
             _ignore_linebreaks=_ignore_linebreaks,
         )
@@ -395,19 +425,21 @@ class FormatCodes:
 
     @staticmethod
     def __get_default_ansi(
-        default_color: tuple,
+        default_color: rgba,
         format_key: Optional[str] = None,
         brightness_steps: Optional[int] = None,
-        _modifiers: tuple[str, str] = (ANSI.default_color_modifiers["lighten"], ANSI.default_color_modifiers["darken"]),
+        _modifiers: tuple[str, str] = (_DEFAULT_COLOR_MODS["lighten"], _DEFAULT_COLOR_MODS["darken"]),
     ) -> Optional[str]:
         """Get the `default_color` and lighter/darker versions of it as ANSI code."""
-        if not brightness_steps or (format_key and _COMPILED["bg?_default"].search(format_key)):
+        if not isinstance(default_color, rgba):
+            return None
+        _default_color: tuple[int, int, int] = tuple(default_color)[:3]
+        if brightness_steps is None or (format_key and _COMPILED["bg?_default"].search(format_key)):
             return (ANSI.seq_bg_color if format_key and _COMPILED["bg_default"].search(format_key) else ANSI.seq_color).format(
-                *default_color[:3]
+                *_default_color
             )
         if format_key is None or not (format_key in _modifiers[0] or format_key in _modifiers[1]):
             return None
-        assert format_key is not None
         match = _COMPILED["modifier"].match(format_key)
         if not match:
             return None
@@ -418,7 +450,7 @@ class FormatCodes:
             if adjust and adjust > 0:
                 modifiers = mod
                 break
-        new_rgb = default_color
+        new_rgb = _default_color
         if adjust == 0:
             return None
         elif modifiers in _modifiers[0]:
@@ -428,19 +460,17 @@ class FormatCodes:
         return (ANSI.seq_bg_color if is_bg else ANSI.seq_color).format(*new_rgb[:3])
 
     @staticmethod
-    def __get_replacement(format_key: str, default_color: Optional[Rgba] = None, brightness_steps: int = 20) -> str:
+    def __get_replacement(format_key: str, default_color: Optional[rgba], brightness_steps: int = 20) -> str:
         """Gives you the corresponding ANSI code for the given format key.
         If `default_color` is not `None`, the text color will be `default_color` if all formats
         are reset or you can get lighter or darker version of `default_color` (also as BG)"""
-        use_default = default_color and Color.is_valid_rgba(default_color, False)
-        _default_color = tuple(Color.to_rgba(default_color)) if use_default else ()  # type: ignore[assignment]
         _format_key, format_key = format_key, FormatCodes.__normalize_key(format_key)  # NORMALIZE KEY AND SAVE ORIGINAL
-        if use_default:
-            if new_default_color := FormatCodes.__get_default_ansi(_default_color, format_key, brightness_steps):
-                return new_default_color
+        if default_color and (new_default_color := FormatCodes.__get_default_ansi(default_color, format_key,
+                                                                                  brightness_steps)):
+            return new_default_color
         for map_key in ANSI.codes_map:
             if (isinstance(map_key, tuple) and format_key in map_key) or format_key == map_key:
-                return ANSI.seq().format(
+                return _ANSI_SEQ_1.format(
                     next((
                         v for k, v in ANSI.codes_map.items() if format_key == k or (isinstance(k, tuple) and format_key in k)
                     ), None)

xulbux/xx_regex.py

@@ -11,13 +11,13 @@ class Regex:
 
     @staticmethod
     def quotes() -> str:
-        """Matches everything inside quotes. (strings)\n
+        """Matches pairs of quotes. (strings)\n
         --------------------------------------------------------------------------------
         Will create two named groups:
         - `quote` the quote type (single or double)
         - `string` everything inside the found quote pair\n
-        --------------------------------------------------------------------------------
-        Attention: Requires non standard library `regex` not standard library `re`!"""
+        ---------------------------------------------------------------------------------
+        Attention: Requires non-standard library `regex`, not standard library `re`!"""
         return r'(?P<quote>[\'"])(?P<string>(?:\\.|(?!\g<quote>).)*?)\g<quote>'
 
     @staticmethod
@@ -28,16 +28,16 @@ class Regex:
         strip_spaces: bool = True,
         ignore_in_strings: bool = True,
     ) -> str:
-        """Matches everything inside brackets, including other nested brackets.\n
-        --------------------------------------------------------------------------------
+        """Matches everything inside pairs of brackets, including other nested brackets.\n
+        -----------------------------------------------------------------------------------
         If `is_group` is true, you will be able to reference the matched content as a
         group (e.g. `match.group(…)` or `r'\\…'`).
         If `strip_spaces` is true, it will ignore spaces around the content inside the
         brackets.
         If `ignore_in_strings` is true and a bracket is inside a string (e.g. `'...'`
         or `"..."`), it will not be counted as the matching closing bracket.\n
-        --------------------------------------------------------------------------------
-        Attention: Requires non standard library `regex` not standard library `re`!"""
+        -----------------------------------------------------------------------------------
+        Attention: Requires non-standard library `regex`, not standard library `re`!"""
         g, b1, b2, s1, s2 = (
             "" if is_group else "?:",
             _rx.escape(bracket1) if len(bracket1) == 1 else bracket1,
@@ -73,8 +73,8 @@ class Regex:
         1. function name
         2. the function's arguments\n
         If no `func_name` is given, it will match any function call.\n
-        --------------------------------------------------------------------------------
-        Attention: Requires non standard library `regex` not standard library `re`!"""
+        ---------------------------------------------------------------------------------
+        Attention: Requires non-standard library `regex`, not standard library `re`!"""
         return (
             r"(?<=\b)(" + (r"[\w_]+" if func_name is None else func_name) + r")\s*" + Regex.brackets("(", ")", is_group=True)
         )

{xulbux-1.7.0.dist-info → xulbux-1.7.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xulbux
-Version: 1.7.0
+Version: 1.7.2
 Summary: A Python library which includes lots of helpful classes, types and functions aiming to make common programming tasks simpler.
 Author-email: XulbuX <xulbux.real@gmail.com>
 License-Expression: MIT
@@ -34,14 +34,14 @@ Requires-Dist: flake8>=6.1.0; extra == "dev"
 Requires-Dist: flake8-pyproject>=1.2.3; extra == "dev"
 Dynamic: license-file
 
-# **$\color{#8085FF}\Huge\textsf{XulbuX}$**
+# **$\Huge\textsf{XulbuX}$**
 
-**$\color{#8085FF}\textsf{XulbuX}$** is library that contains many useful classes, types, and functions,
+**XulbuX** is library that contains many useful classes, types, and functions,
 ranging from console logging and working with colors to file management and system operations.
 The library is designed to simplify common programming tasks and improve code readability through its collection of tools.
 
-For precise information about the library, see the library's [wiki page](https://github.com/XulbuX/PythonLibraryXulbuX/wiki).<br>
-For the libraries latest changes and updates, see the [change log](https://github.com/XulbuX/PythonLibraryXulbuX/blob/main/CHANGELOG.md).
+For precise information about the library, see the library's [**wiki page**](https://github.com/XulbuX/PythonLibraryXulbuX/wiki).<br>
+For the libraries latest changes and updates, see the [**change log**](https://github.com/XulbuX/PythonLibraryXulbuX/blob/main/CHANGELOG.md).
 
 <br>
 
@@ -81,20 +81,20 @@ from xulbux import rgba, hsla, hexa
 
 ## Modules
 
-| Module                                                                                                                                                            | Short Description                                                                                  |
-| :---------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------- |
-| [![xx_code](https://img.shields.io/badge/xx__code-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_code)                         | advanced code-string operations (*changing the indent, finding function calls, ...*)               |
-| [![xx_color](https://img.shields.io/badge/xx__color-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_color)                      | everything around colors (*converting, blending, searching colors in strings, ...*)                |
-| [![xx_console](https://img.shields.io/badge/xx__console-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_console)                | advanced actions related to the console (*pretty logging, advanced inputs, ...*)                   |
-| [![xx_data](https://img.shields.io/badge/xx__data-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_data)                         | advanced operations with data structures (*compare, generate path ID's, pretty print/format, ...*) |
+| Module                                                                                                                                                     | Short Description                                                                                  |
+| :--------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------- |
+| [![xx_code](https://img.shields.io/badge/xx__code-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_code)                          | advanced code-string operations (*changing the indent, finding function calls, ...*)               |
+| [![xx_color](https://img.shields.io/badge/xx__color-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_color)                       | everything around colors (*converting, blending, searching colors in strings, ...*)                |
+| [![xx_console](https://img.shields.io/badge/xx__console-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_console)                 | advanced actions related to the console (*pretty logging, advanced inputs, ...*)                   |
+| [![xx_data](https://img.shields.io/badge/xx__data-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_data)                          | advanced operations with data structures (*compare, generate path ID's, pretty print/format, ...*) |
 | [![xx_env_path](https://img.shields.io/badge/xx__env__path-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_env_path)             | getting and editing the PATH variable (*get paths, check for paths, add paths, ...*)               |
-| [![xx_file](https://img.shields.io/badge/xx__file-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_file)                         | advanced working with files (*create files, rename file-extensions, ...*)                          |
+| [![xx_file](https://img.shields.io/badge/xx__file-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_file)                          | advanced working with files (*create files, rename file-extensions, ...*)                          |
 | [![xx_format_codes](https://img.shields.io/badge/xx__format__codes-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_format_codes) | easy pretty printing with custom format codes (*print, inputs, custom format codes to ANSI, ...*)  |
-| [![xx_json](https://img.shields.io/badge/xx__json-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_json)                         | advanced working with json files (*read, create, update, ...*)                                     |
-| [![xx_path](https://img.shields.io/badge/xx__path-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_path)                         | advanced path operations (*get paths, smart-extend relative paths, delete paths, ...*)             |
-| ![xx_regex](https://img.shields.io/badge/xx__regex-6065FF?style=flat)                                                                                     | generated regex pattern-templates (*match bracket- and quote pairs, match colors, ...*)            |
-| [![xx_string](https://img.shields.io/badge/xx__string-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_string)                   | helpful actions when working with strings. (*normalize, escape, decompose, ...*)                   |
-| ![xx_system](https://img.shields.io/badge/xx__system-6065FF?style=flat)                                                                                   | advanced system actions (*restart with message, check installed Python libs, ...*)                 |
+| [![xx_json](https://img.shields.io/badge/xx__json-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_json)                          | advanced working with json files (*read, create, update, ...*)                                     |
+| [![xx_path](https://img.shields.io/badge/xx__path-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_path)                          | advanced path operations (*get paths, smart-extend relative paths, delete paths, ...*)             |
+| ![xx_regex](https://img.shields.io/badge/xx__regex-6065FF?style=flat)                                                                                      | generated regex pattern-templates (*match bracket- and quote pairs, match colors, ...*)            |
+| [![xx_string](https://img.shields.io/badge/xx__string-6065FF?style=flat)](https://github.com/XulbuX/PythonLibraryXulbuX/wiki/xx_string)                    | helpful actions when working with strings. (*normalize, escape, decompose, ...*)                   |
+| ![xx_system](https://img.shields.io/badge/xx__system-6065FF?style=flat)                                                                                    | advanced system actions (*restart with message, check installed Python libs, ...*)                 |
 
 <br>
 
@@ -111,15 +111,15 @@ def main() -> None:
 
     # LET THE USER ENTER A HEXA COLOR IN ANY HEXA FORMAT
     input_clr = FormatCodes.input(
-      "\n[b](Enter a HEXA color in any format) [dim](>) "
+        "\n[b](Enter a HEXA color in any format) [dim](>) "
     )
 
     # ANNOUNCE INDEXING THE INPUT COLOR
     Console.log(
-      "INDEX",
-      "Indexing the input HEXA color...",
-      start="\n",
-      title_bg_color=COLOR.blue,
+        "INDEX",
+        "Indexing the input HEXA color...",
+        start="\n",
+        title_bg_color=COLOR.blue,
     )
 
     try:
@@ -129,16 +129,16 @@ def main() -> None:
     except ValueError:
         # ANNOUNCE THE ERROR AND EXIT THE PROGRAM
         Console.fail(
-          "The input HEXA color is invalid.",
-          end="\n\n",
-          exit=True,
+            "The input HEXA color is invalid.",
+            end="\n\n",
+            exit=True,
         )
 
     # ANNOUNCE STARTING THE CONVERSION
     Console.log(
-      "CONVERT",
-      "Converting the HEXA color into different types...",
-      title_bg_color=COLOR.tangerine,
+        "CONVERT",
+        "Converting the HEXA color into different types...",
+        title_bg_color=COLOR.tangerine,
     )
 
     # CONVERT THE HEXA COLOR INTO THE TWO OTHER COLOR TYPES
@@ -147,14 +147,16 @@ def main() -> None:
 
     # ANNOUNCE THE SUCCESSFUL CONVERSION
     Console.done(
-      "Successfully converted color into different types.",
-      end="\n\n",
+        "Successfully converted color into different types.",
+        end="\n\n",
     )
 
     # PRETTY PRINT THE COLOR IN DIFFERENT TYPES
-    FormatCodes.print(f"[b](HEXA:) [i|white]({hexa_color})")
-    FormatCodes.print(f"[b](RGBA:) [i|white]({rgba_color})")
-    FormatCodes.print(f"[b](HSLA:) [i|white]({hsla_color})\n")
+    Console.log_box_bordered(
+        f"[b](HEXA:) [i|white]({hexa_color})",
+        f"[b](RGBA:) [i|white]({rgba_color})",
+        f"[b](HSLA:) [i|white]({hsla_color})",
+    )
 
 
 if __name__ == "__main__":
@@ -165,4 +167,4 @@ if __name__ == "__main__":
 <br>
 
 --------------------------------------------------------------
-[View this library on PyPI](https://pypi.org/project/XulbuX/)
+[View this library on **PyPI**](https://pypi.org/project/XulbuX/)

xulbux-1.7.2.dist-info/RECORD

@@ -0,0 +1,21 @@
+xulbux/__init__.py,sha256=vd8y5L0AwqnxqXm_IAJ5grbfm8ZkcSHJx36n1KUQTlc,815
+xulbux/_cli_.py,sha256=J4vfJHLJEYxCZzA_VJUB46w2WGShfdYFoetsLG5PfKo,3428
+xulbux/_consts_.py,sha256=4CLJE-YH3si2YQ-IHcjsT5PW0D7vGvm8ZH13rUoG5cE,6166
+xulbux/xx_code.py,sha256=b8MJId-BmZOsBH38z-h055op7qIICdsTT3rFJ7SWkiE,6111
+xulbux/xx_color.py,sha256=Thj7fFTc8x-VmYyULI3HQW0uCk9dIihwrGUwuXGn83s,49744
+xulbux/xx_console.py,sha256=c61EXVGQo_OL_MUWb4oXbIr6EKesm1v-FwxBIe47ZTg,34866
+xulbux/xx_data.py,sha256=nEfVwK6-ILaL3K-bLezKpG1G7117CY5ZgC3BGwANrUE,30886
+xulbux/xx_env_path.py,sha256=x56mKK4lSvU5yMCAs8k0RVIqXWUJcpcHYz5HoZ_RklM,4160
+xulbux/xx_file.py,sha256=KerXOvKS93zIoAt36YTYuZboSmxVFVf2WcOrDcdwXfE,2627
+xulbux/xx_format_codes.py,sha256=-tSsgy1tRelmU5x5ZS7ujaiXntyRqk1sm759tyvVIyU,24698
+xulbux/xx_json.py,sha256=V7vdfpvSe9wpktR_c8zG_Meix7x9IRmn66k5nB3HUyo,7457
+xulbux/xx_path.py,sha256=lLAEVZrW0TAwCewlONFVQcQ_8tVn9LTJZVOZpeGvE5s,7673
+xulbux/xx_regex.py,sha256=_BtMHRDNcD9zF4SL87dQuUVZcYGfZx9H5YNSDiEtzm8,8059
+xulbux/xx_string.py,sha256=QaTo0TQ9m_2USNgQNaVw5ivQt-A1E-e5x8OpIB3xIlY,5561
+xulbux/xx_system.py,sha256=Tsx4wgztUg46KloqcGeiFkarDoM3EgJLXw3XNxgHBmU,6460
+xulbux-1.7.2.dist-info/licenses/LICENSE,sha256=6NflEcvzFEe8_JFVNCPVwZBwBhlLLd4vqQi8WiX_Xk4,1084
+xulbux-1.7.2.dist-info/METADATA,sha256=vlIkVkj97ZLjiFajkGrSZ5O0GDrzuIunJ1E1iqY-QTA,9209
+xulbux-1.7.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xulbux-1.7.2.dist-info/entry_points.txt,sha256=a3womfLIMZKnOFiyy-xnVb4g2qkZsHR5FbKKkljcGns,94
+xulbux-1.7.2.dist-info/top_level.txt,sha256=FkK4EZajwfP36fnlrPaR98OrEvZpvdEOdW1T5zTj6og,7
+xulbux-1.7.2.dist-info/RECORD,,

xulbux-1.7.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-xulbux/__init__.py,sha256=TbXPioXPENwpR9t4lvqBBhV4cby0JGdIrSzzdMFYrEc,815
-xulbux/_cli_.py,sha256=J4vfJHLJEYxCZzA_VJUB46w2WGShfdYFoetsLG5PfKo,3428
-xulbux/_consts_.py,sha256=AuYTTmqrP2lawyVGlPLUaP1syxOoPA-ejJGH7WlwFzk,6314
-xulbux/xx_code.py,sha256=w9yO-GPMeaE-xDi-L3VtpPpWpu5jOwagfMsG93aXANE,6106
-xulbux/xx_color.py,sha256=ZEV9AG3MtgNMh4t4VexmBiaperan1pHO4d_VPCdv188,49923
-xulbux/xx_console.py,sha256=WmH6YURaA-Y-LNB-2kZc8SuPxoZim8ZmzsuI01V9vcM,28682
-xulbux/xx_data.py,sha256=nEfVwK6-ILaL3K-bLezKpG1G7117CY5ZgC3BGwANrUE,30886
-xulbux/xx_env_path.py,sha256=x56mKK4lSvU5yMCAs8k0RVIqXWUJcpcHYz5HoZ_RklM,4160
-xulbux/xx_file.py,sha256=KerXOvKS93zIoAt36YTYuZboSmxVFVf2WcOrDcdwXfE,2627
-xulbux/xx_format_codes.py,sha256=fOFidFDBYV-rUXOlYTeKIZarfh9Q1jSUCGYyk8pg-ic,23397
-xulbux/xx_json.py,sha256=V7vdfpvSe9wpktR_c8zG_Meix7x9IRmn66k5nB3HUyo,7457
-xulbux/xx_path.py,sha256=lLAEVZrW0TAwCewlONFVQcQ_8tVn9LTJZVOZpeGvE5s,7673
-xulbux/xx_regex.py,sha256=ejqVs4a-eCSTrSQfENoyl0AVztb8BuI2TNl-wzMQwYw,8048
-xulbux/xx_string.py,sha256=QaTo0TQ9m_2USNgQNaVw5ivQt-A1E-e5x8OpIB3xIlY,5561
-xulbux/xx_system.py,sha256=Tsx4wgztUg46KloqcGeiFkarDoM3EgJLXw3XNxgHBmU,6460
-xulbux-1.7.0.dist-info/licenses/LICENSE,sha256=6NflEcvzFEe8_JFVNCPVwZBwBhlLLd4vqQi8WiX_Xk4,1084
-xulbux-1.7.0.dist-info/METADATA,sha256=symGYQzZhSYyGcwM_dGI3FETAcqgTL-ft90CLtJoNlY,9222
-xulbux-1.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xulbux-1.7.0.dist-info/entry_points.txt,sha256=a3womfLIMZKnOFiyy-xnVb4g2qkZsHR5FbKKkljcGns,94
-xulbux-1.7.0.dist-info/top_level.txt,sha256=FkK4EZajwfP36fnlrPaR98OrEvZpvdEOdW1T5zTj6og,7
-xulbux-1.7.0.dist-info/RECORD,,