xulbux 1.6.2__py3-none-any.whl → 1.6.4__py3-none-any.whl

xulbux/__init__.py

@@ -19,7 +19,7 @@
   • REGEX PATTERN TEMPLATES  xx.Regex
 """
 
-__version__ = "1.6.2"
+__version__ = "1.6.4"
 __author__ = "XulbuX"
 __email__ = "xulbux.real@gmail.com"
 __license__ = "MIT"

xulbux/_consts_.py

@@ -58,12 +58,12 @@ class ANSI:
 
     global CHAR, START, SEP, END
 
-    char_esc = r"\x1b"
+    escaped_char = "\\x1b"
     CHAR = char = "\x1b"
     START = start = "["
     SEP = sep = ";"
     END = end = "m"
-    modifier = {"lighten": "+l", "darken": "-d"}
+    default_color_modifiers = {"lighten": "+l", "darken": "-d"}
 
     def seq(parts: int = 1) -> str:
         """Generate an ANSI sequence with `parts` amount of placeholders."""

xulbux/xx_format_codes.py

@@ -1,38 +1,78 @@
 """
-Functions to be able to use special (easy) formatting codes directly inside some message (string).\n
-These codes, when used within following functions, will change the look of log within the console:
+Methods to transform formatting codes to ANSI and use them for pretty console output:
 - `FormatCodes.print()` (print a special format-codes containing string)
 - `FormatCodes.input()` (input with a special format-codes containing prompt)
 - `FormatCodes.to_ansi()` (transform all special format-codes into ANSI codes in a string)\n
---------------------------------------------------------------------------------------------------------------------
-How to change the text format and color?\n
-Example string with formatting codes:
-```string
-[bold]This is bold text, [#F08]which is pink now [black|BG:#FF0088] and now it changed`
-to black with a pink background. [_]And this is the boring text, where everything is reset.
+------------------------------------------------------------------------------------------------------------------------------------
+### The Easy Formatting
+
+First, let's take a look at a small example of what a highly styled print string with formatting could look like using this module:
+```regex
+This here is just unformatted text. [b|u|br:blue](Next we have text that is bright blue + bold + underlined.)\\n
+[#000|bg:#F67](Then there's also black text with a red background.) And finally the ([i](boring)) plain text again.
 ```
-⇾ Instead of writing the formats all separate `[x][y][z]` you can join them like this `[x|y|z]`\n
---------------------------------------------------------------------------------------------------------------------
-You can also automatically reset a certain format, behind text like shown in the following example:
-```string
-This is normal text [b](which is bold now) but now it was automatically reset to normal.
+
+How all of this exactly works is explained in the sections below. 🠫
+
+------------------------------------------------------------------------------------------------------------------------------------
+#### Formatting Codes and Keys
+
+In this module, you can apply styles and colors using simple formatting codes.
+These formatting codes consist of one or multiple different formatting keys in between square brackets.
+
+If a formatting code is placed in a print-string, the formatting of that code will be applied to everything behind it until its
+formatting is reset. If applying multiple styles and colors in the same place, instead of writing the formatting keys all into
+separate brackets (e.g. `[x][y][z]`), they can also be put in a single pair of brackets, separated by pipes (e.g. `[x|y|z]`).
+
+A list of all possible formatting keys can be found under all possible formatting keys.
+
+------------------------------------------------------------------------------------------------------------------------------------
+#### Auto Resetting Formatting Codes
+
+Certain formatting can automatically be reset, behind a certain amount of text, just like shown in the following example:
+```regex
+This is plain text, [br:blue](which is bright blue now.) Now it was automatically reset to plain again.
 ```
-This will only reset formats, that have a reset listed below. Colors and BG-colors won't be reset.\n
-This is what will happen, if you use it with a color-format:
-```string
-[cyan]This is cyan text [b](which is bold now.) Now it's not bold any more but still cyan.
+
+This will only reset formatting codes, that have a specific reset listed below.
+That means if you use it where another formatting is already applied, that formatting is still there after the automatic reset:
+```regex
+[cyan]This is cyan text, [dim](which is dimmed now.) Now it's not dimmed any more but still cyan.
 ```
-If you want to ignore the `()` brackets you can put a `\\` or `/` between:
-```string
-[cyan]This is cyan text [b]/(which is bold now.) And now it is still bold and cyan.
+
+If you want to ignore the auto-reset functionality of `()` brackets, you can put a `\\` or `/` between them and
+the formatting code:
+```regex
+[cyan]This is cyan text, [u]/(which is underlined now.) And now it is still underlined and cyan.
 ```
-⇾ To see these examples in action, you can put them into the `FormatCodes.print()` function.\n
---------------------------------------------------------------------------------------------------------------------
-All possible formatting codes:
-- HEX colors:  `[#F08]` or `[#FF0088]` (with or without leading #)
-- RGB colors:  `[rgb(255, 0, 136)]`
-- background colors:  `[BG:#F08]`
-- standard cmd colors:
+
+------------------------------------------------------------------------------------------------------------------------------------
+#### All possible Formatting Keys
+
+- RGB colors:
+  Change the text color directly with an RGB color inside the square brackets. (With or without `rgb()` brackets doesn't matter.)
+  Examples:
+  - `[rgb(115, 117, 255)]`
+  - `[(255, 0, 136)]`
+  - `[255, 0, 136]`
+- HEX colors:
+  Change the text color directly with a HEX color inside the square brackets. (If `RGB` or `RRGGBB` formatting code is used,
+  and if there's a `#` or `0x` prefix, doesn't matter.)
+  Examples:
+  - `[#7788FF]`
+  - `[7788FF]`
+  - `[#78F]`
+  - `[78F]`
+- background RGB / HEX colors:
+  Change the background color directly with an RGB or HEX color inside the square brackets, using the `background:` `BG:` prefix.
+  (Same RGB / HEX formatting code rules as for text color.)
+  Examples:
+  - `[background:rgb(115, 117, 255)]`
+  - `[BG:(255, 0, 136)]`
+  - `[background:#7788FF]`
+  - `[BG:#78F]`
+- standard console colors:
+  Change the text color to one of the standard console colors by just writing the color name in the square brackets.
   - `[black]`
   - `[red]`
   - `[green]`
@@ -41,39 +81,64 @@ All possible formatting codes:
   - `[magenta]`
   - `[cyan]`
   - `[white]`
-- bright cmd colors: `[bright:black]` or `[br:black]`, `[bright:red]` or `[br:red]`, ...
-- background cmd colors: `[BG:black]`, `[BG:red]`, ...
-- bright background cmd colors: `[BG:bright:black]` or `[BG:br:black]`, `[BG:bright:red]` or `[BG:br:red]`, ...\n
-  ⇾ The order of `BG:` and `bright:` or `br:` does not matter.
-- text formats:
-  - `[bold]` or `[b]`
+- bright console colors:
+  Use the prefix `bright:` `BR:` to use the bright variant of the standard console color.
+  Examples:
+  - `[bright:black]` `[BR:black]`
+  - `[bright:red]` `[BR:red]`
+  - ...
+- Background console colors:
+  Use the prefix `background:` `BG:` to set the background to a standard console color. (Not all consoles support bright
+  standard colors.)
+  Examples:
+  - `[background:black]` `[BG:black]`
+  - `[background:red]` `[BG:red]`
+  - ...
+- Bright background console colors:
+  Combine the prefixes `background:` / `BG:` and `bright:` / `BR:` to set the background to a bright console color.
+  (The order of the prefixes doesn't matter.)
+  Examples:
+  - `[background:bright:black]` `[BG:BR:black]`
+  - `[background:bright:red]` `[BG:BR:red]`
+  - ...
+- Text styles:
+  Use the built-in text formatting to change the style of the text. There are long and short forms for each formatting code.
+  (Not all consoles support all text styles.)
+  - `[bold]` `[b]`
   - `[dim]`
-  - `[italic]` or `[i]`
-  - `[underline]` or `[u]`
-  - `[inverse]`, `[invert]` or `[in]`
-  - `[hidden]`, `[hide]` or `[h]`
-  - `[strikethrough]` or `[s]`
-  - `[double-underline]` or `[du]`
-- specific reset:
-  - `[_bold]` or `[_b]`
+  - `[italic]` `[i]`
+  - `[underline]` `[u]`
+  - `[inverse]` `[invert]` `[in]`
+  - `[hidden]` `[hide]` `[h]`
+  - `[strikethrough]` `[s]`
+  - `[double-underline]` `[du]`
+- Specific reset:
+  Use these reset codes to remove a specific style, color or background. Again, there are long and
+  short forms for each reset code.
+  - `[_bold]` `[_b]`
   - `[_dim]`
-  - `[_italic]` or `[_i]`
-  - `[_underline]` or `[_u]`
-  - `[_inverse]`, `[_invert]` or `[_in]`
-  - `[_hidden]`, `[_hide]` or `[_h]`
-  - `[_strikethrough]` or `[_s]`
-  - `[_double-underline]` or `[_du]`
-  - `[_color]` or `[_c]`
-  - `[_background]` or `[_bg]`
-- total reset:
+  - `[_italic]` `[_i]`
+  - `[_underline]` `[_u]`
+  - `[_inverse]` `[_invert]` `[_in]`
+  - `[_hidden]` `[_hide]` `[_h]`
+  - `[_strikethrough]` `[_s]`
+  - `[_double-underline]` `[_du]`
+  - `[_color]` `[_c]`
+  - `[_background]` `[_bg]`
+- Total reset:
+  This will reset all previously applied formatting codes.
   - `[_]`
---------------------------------------------------------------------------------------------------------------------
-Additional formats when a `default_color` is set:
-- `[*]` will reset everything, just like `[_]`, but the text-color will remain in `default_color`
-- `[*color]` will reset the text-color, just like `[_color]`, but then also make it `default_color`
-- `[default]` will just color the text in `default_color`,
-- `[BG:default]` will color the background in `default_color`\n
-Unlike the standard cmd colors, the default color can be changed by using the following modifiers:
+
+------------------------------------------------------------------------------------------------------------------------------------
+#### 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`
+3. `[default]` will just color the text in `default_color`
+4. `[background:default]` `[BG:default]` will color the background in `default_color`
+
+Unlike the standard console colors, the default color can be changed by using the following modifiers:
+
 - `[l]` will lighten the `default_color` text by `brightness_steps`%
 - `[ll]` will lighten the `default_color` text by `2 × brightness_steps`%
 - `[lll]` will lighten the `default_color` text by `3 × brightness_steps`%
@@ -81,7 +146,7 @@ Unlike the standard cmd colors, the default color can be changed by using the fo
 - `[d]` will darken the `default_color` text by `brightness_steps`%
 - `[dd]` will darken the `default_color` text by `2 × brightness_steps`%
 - `[ddd]` will darken the `default_color` text by `3 × brightness_steps`%
-- ... etc.\n
+- ... etc.
 Per default, you can also use `+` and `-` to get lighter and darker `default_color` versions.
 """
 
@@ -90,38 +155,43 @@ from .xx_string import String
 from .xx_regex import Regex
 from .xx_color import *
 
-from functools import lru_cache
 import ctypes as _ctypes
 import regex as _rx
 import sys as _sys
 import re as _re
 
-PREFIX = {
+_CONSOLE_ANSI_CONFIGURED = False
+
+_PREFIX = {
     "BG": {"background", "bg"},
     "BR": {"bright", "br"},
 }
-PREFIXES = {val for values in PREFIX.values() for val in values}
-PREFIX_RX = {
-    "BG": rf"(?:{'|'.join(PREFIX['BG'])})\s*:",
-    "BR": rf"(?:{'|'.join(PREFIX['BR'])})\s*:",
+_PREFIX_RX = {
+    "BG": rf"(?:{'|'.join(_PREFIX['BG'])})\s*:",
+    "BR": rf"(?:{'|'.join(_PREFIX['BR'])})\s*:",
 }
-COMPILED = {  # PRECOMPILE REGULAR EXPRESSIONS
+_COMPILED = {  # PRECOMPILE REGULAR EXPRESSIONS
     "*": _re.compile(r"\[\s*([^]_]*?)\s*\*\s*([^]_]*?)\]"),
     "*color": _re.compile(r"\[\s*([^]_]*?)\s*\*color\s*([^]_]*?)\]"),
-    "format": _rx.compile(
-        Regex.brackets("[", "]", is_group=True) + r"(?:\s*([/\\]?)\s*" + Regex.brackets("(", ")", is_group=True) + r")?"
+    "formatting": _rx.compile(
+        Regex.brackets("[", "]", is_group=True)
+        + r"(?:\s*([/\\]?)\s*"
+        + Regex.brackets("(", ")", is_group=True, ignore_in_strings=False)
+        + r")?"
     ),
-    "bg?_default": _re.compile(r"(?i)((?:" + PREFIX_RX["BG"] + r")?)\s*default"),
-    "bg_default": _re.compile(r"(?i)" + PREFIX_RX["BG"] + r"\s*default"),
+    "bg?_default": _re.compile(r"(?i)((?:" + _PREFIX_RX["BG"] + r")?)\s*default"),
+    "bg_default": _re.compile(r"(?i)" + _PREFIX_RX["BG"] + r"\s*default"),
     "modifier": _re.compile(
         r"(?i)((?:BG\s*:)?)\s*("
-        + "|".join([f"{_re.escape(m)}+" for m in ANSI.modifier["lighten"] + ANSI.modifier["darken"]])
+        + "|".join(
+            [f"{_re.escape(m)}+" for m in ANSI.default_color_modifiers["lighten"] + ANSI.default_color_modifiers["darken"]]
+        )
         + r")$"
     ),
     "rgb": _re.compile(
-        r"(?i)^\s*(" + PREFIX_RX["BG"] + r")?\s*(?:rgb|rgba)?\s*\(?\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)?\s*$"
+        r"(?i)^\s*(" + _PREFIX_RX["BG"] + r")?\s*(?:rgb|rgba)?\s*\(?\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)?\s*$"
     ),
-    "hex": _re.compile(r"(?i)^\s*(" + PREFIX_RX["BG"] + r")?\s*(?:#|0x)?([0-9A-F]{6}|[0-9A-F]{3})\s*$"),
+    "hex": _re.compile(r"(?i)^\s*(" + _PREFIX_RX["BG"] + r")?\s*(?:#|0x)?([0-9A-F]{6}|[0-9A-F]{3})\s*$"),
 }
 
 
@@ -130,14 +200,14 @@ class FormatCodes:
     @staticmethod
     def print(
         *values: object,
-        default_color: hexa | rgba = None,
+        default_color: rgba | hexa = None,
         brightness_steps: int = 20,
         sep: str = " ",
         end: str = "\n",
         flush: bool = True,
     ) -> None:
-        """Print a string that can be formatted using special formatting codes.\n
-        --------------------------------------------------------------------------
+        """A print function, whose print values can be formatted using formatting codes.\n
+        -----------------------------------------------------------------------------------
         For exact information about how to use special formatting codes, see the
         `xx_format_codes` module documentation."""
         FormatCodes.__config_console()
@@ -148,29 +218,32 @@ class FormatCodes:
     @staticmethod
     def input(
         prompt: object = "",
-        default_color: hexa | rgba = None,
+        default_color: rgba | hexa = None,
         brightness_steps: int = 20,
         reset_ansi: bool = False,
     ) -> str:
-        """An input, which's prompt can be formatted using special formatting codes.\n
-        -------------------------------------------------------------------------------
-        If `reset_ansi` is true, all ANSI formatting will be reset, after the user has
-        confirmed the input and the program continues.\n
-        -------------------------------------------------------------------------------
+        """An input, whose prompt can be formatted using formatting codes.\n
+        -------------------------------------------------------------------------
+        If `reset_ansi` is true, all ANSI formatting will be reset, after the
+        user confirms the input and the program continues to run.\n
+        -------------------------------------------------------------------------
         For exact information about how to use special formatting codes, see the
         `xx_format_codes` module documentation."""
         FormatCodes.__config_console()
-        user_input = input(FormatCodes.to_ansi(prompt, default_color, brightness_steps))
+        user_input = input(FormatCodes.to_ansi(str(prompt), default_color, brightness_steps))
         if reset_ansi:
-            _sys.stdout.write("\x1b[0m")
+            _sys.stdout.write(f"{ANSI.char}[0m")
         return user_input
 
     @staticmethod
     def to_ansi(
-        string: str, default_color: hexa | rgba = None, brightness_steps: int = 20, _default_start: bool = True
+        string: str,
+        default_color: rgba | hexa = None,
+        brightness_steps: int = 20,
+        _default_start: bool = True,
     ) -> str:
-        """Convert the special formatting codes inside a string to printable ANSI codes.\n
-        -----------------------------------------------------------------------------------
+        """Convert the formatting codes inside a string to ANSI formatting.\n
+        -------------------------------------------------------------------------
         For exact information about how to use special formatting codes, see the
         `xx_format_codes` module documentation."""
         if Color.is_valid_rgba(default_color, False):
@@ -180,8 +253,8 @@ class FormatCodes:
         else:
             use_default = False
         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["*"].sub(r"[\1_|default\2]", string)  # REPLACE `[…|*|…]` WITH `[…|_|default|…]`
+            string = _COMPILED["*color"].sub(r"[\1default\2]", string)  # REPLACE `[…|*color|…]` WITH `[…|default|…]`
 
         def is_valid_color(color: str) -> bool:
             return color in ANSI.color_map or Color.is_valid_rgba(color) or Color.is_valid_hexa(color)
@@ -206,8 +279,8 @@ class FormatCodes:
                 for k in format_keys:
                     k_lower = k.lower()
                     k_set = set(k_lower.split(":"))
-                    if PREFIX["BG"] & k_set and len(k_set) <= 3:
-                        if k_set & PREFIX["BR"]:
+                    if _PREFIX["BG"] & k_set and len(k_set) <= 3:
+                        if k_set & _PREFIX["BR"]:
                             for i in range(len(k)):
                                 if is_valid_color(k[i:]):
                                     reset_keys.extend(["_bg", "_color"])
@@ -219,7 +292,7 @@ class FormatCodes:
                                     break
                     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"]
+                        for prefix in _PREFIX["BR"]
                     ):
                         reset_keys.append("_color")
                     else:
@@ -247,40 +320,42 @@ class FormatCodes:
                 + ("" if escaped else "".join(ansi_resets))
             )
 
-        string = "\n".join(COMPILED["format"].sub(replace_keys, line) for line in string.split("\n"))
+        string = "\n".join(_COMPILED["formatting"].sub(replace_keys, line) for line in string.split("\n"))
         return (FormatCodes.__get_default_ansi(default_color) if _default_start else "") + string if use_default else string
 
     @staticmethod
-    def escape_ansi(ansi_string: str, escaped_char: str = ANSI.char_esc) -> str:
-        """Makes the string printable with the ANSI formats visible."""
-        return ansi_string.replace(ANSI.char, escaped_char)
+    def escape_ansi(ansi_string: str) -> str:
+        """Escapes all ANSI codes in a string, so they are visible when output to the console."""
+        return ansi_string.replace(ANSI.char, ANSI.escaped_char)
 
     @staticmethod
-    @lru_cache(maxsize=64)
     def __config_console() -> None:
         """Configure the console to be able to interpret ANSI formatting."""
-        _sys.stdout.flush()
-        kernel32 = _ctypes.windll.kernel32
-        h = kernel32.GetStdHandle(-11)
-        mode = _ctypes.c_ulong()
-        kernel32.GetConsoleMode(h, _ctypes.byref(mode))
-        kernel32.SetConsoleMode(h, mode.value | 0x0004)
+        global _CONSOLE_ANSI_CONFIGURED
+        if not _CONSOLE_ANSI_CONFIGURED:
+            _sys.stdout.flush()
+            kernel32 = _ctypes.windll.kernel32
+            h = kernel32.GetStdHandle(-11)
+            mode = _ctypes.c_ulong()
+            kernel32.GetConsoleMode(h, _ctypes.byref(mode))
+            kernel32.SetConsoleMode(h, mode.value | 0x0004)
+            _CONSOLE_ANSI_CONFIGURED = True
 
     @staticmethod
     def __get_default_ansi(
         default_color: tuple,
         format_key: str = None,
         brightness_steps: int = None,
-        _modifiers: tuple[str, str] = (ANSI.modifier["lighten"], ANSI.modifier["darken"]),
+        _modifiers: tuple[str, str] = (ANSI.default_color_modifiers["lighten"], ANSI.default_color_modifiers["darken"]),
     ) -> str | None:
-        """Get the `default_color` and lighter/darker versions of it in ANSI format."""
-        if not brightness_steps 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(
+        """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)):
+            return (ANSI.seq_bg_color if format_key and _COMPILED["bg_default"].search(format_key) else ANSI.seq_color).format(
                 *default_color[:3]
             )
         if not (format_key in _modifiers[0] or format_key in _modifiers[1]):
             return None
-        match = COMPILED["modifier"].match(format_key)
+        match = _COMPILED["modifier"].match(format_key)
         if not match:
             return None
         is_bg, modifiers = match.groups()
@@ -320,8 +395,8 @@ class FormatCodes:
                         None,
                     )
                 )
-        rgb_match = _re.match(COMPILED["rgb"], format_key)
-        hex_match = _re.match(COMPILED["hex"], format_key)
+        rgb_match = _re.match(_COMPILED["rgb"], format_key)
+        hex_match = _re.match(_COMPILED["hex"], format_key)
         try:
             if rgb_match:
                 is_bg = rgb_match.group(1)
@@ -341,15 +416,14 @@ class FormatCodes:
         return _format_key
 
     @staticmethod
-    @lru_cache(maxsize=64)
     def __normalize_key(format_key: str) -> str:
         """Normalizes the given format key."""
         k_parts = format_key.replace(" ", "").lower().split(":")
         prefix_str = "".join(
             f"{prefix_key.lower()}:"
-            for prefix_key, prefix_values in PREFIX.items()
+            for prefix_key, prefix_values in _PREFIX.items()
             if any(k_part in prefix_values for k_part in k_parts)
         )
         return prefix_str + ":".join(
-            part for part in k_parts if part not in {val for values in PREFIX.values() for val in values}
+            part for part in k_parts if part not in {val for values in _PREFIX.values() for val in values}
         )

xulbux/xx_regex.py

@@ -9,6 +9,7 @@ Really long regex code presets:
 `hsla_str` match a HSLA color
 """
 
+import regex as _rx
 import re as _re
 
 
@@ -17,25 +18,33 @@ class Regex:
     @staticmethod
     def quotes() -> str:
         """Matches everything inside 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`!"""
         return r'(?P<quote>[\'"])(?P<string>(?:\\.|(?!\g<quote>).)*?)\g<quote>'
 
     @staticmethod
-    def brackets(bracket1: str = "(", bracket2: str = ")", is_group: bool = False) -> str:
+    def brackets(bracket1: str = "(", bracket2: str = ")", is_group: bool = False, ignore_in_strings: bool = True) -> str:
         """Matches everything inside 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 `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`!"""
         g, b1, b2 = (
             "" if is_group else "?:",
-            _re.escape(bracket1) if len(bracket1) == 1 else bracket1,
-            _re.escape(bracket2) if len(bracket2) == 1 else bracket2,
+            _rx.escape(bracket1) if len(bracket1) == 1 else bracket1,
+            _rx.escape(bracket2) if len(bracket2) == 1 else bracket2,
         )
-        return rf'{b1}\s*({g}(?:[^{b1}{b2}"\']|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'|{b1}(?:[^{b1}{b2}"\']|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'|(?R))*{b2})*)\s*{b2}'
+        if ignore_in_strings:
+            return rf'{b1}\s*({g}(?:[^{b1}{b2}"\']|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'|{b1}(?:[^{b1}{b2}"\']|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'|(?R))*{b2})*)\s*{b2}'
+        else:
+            return rf"{b1}\s*({g}(?:[^{b1}{b2}]|{b1}(?:[^{b1}{b2}]|(?R))*{b2})*)\s*{b2}"
 
     @staticmethod
     def outside_strings(pattern: str = r".*") -> str:
@@ -48,22 +57,27 @@ class Regex:
         ignore_pattern: str = "",
         is_group: bool = False,
     ) -> str:
-        """Matches everything except `disallowed_pattern`, unless the `disallowed_pattern` is found inside a string (`'...'` or `"..."`).\n
-        ------------------------------------------------------------------------------------------------------------------------------------
-        The `ignore_pattern` is just always ignored. For example if `disallowed_pattern` is `>` and `ignore_pattern` is `->`, the `->`
-        -arrows will be allowed, even though they have `>` in them. If `is_group` is `True`, you will be able to reference the matched
-        content as a group (e.g. `match.group(int)` or `r'\\int'`)."""
+        """Matches everything except `disallowed_pattern`, unless the `disallowed_pattern`
+        is found inside a string (`'...'` or `"..."`).\n
+        ------------------------------------------------------------------------------------
+        The `ignore_pattern` is just always ignored. For example if `disallowed_pattern` is
+        `>` and `ignore_pattern` is `->`, the `->`-arrows will be allowed, even though they
+        have `>` in them.
+        If `is_group` is true, you will be able to reference the matched content as a group
+        (e.g. `match.group(…)` or `r'\\…'`)."""
         return rf'({"" if is_group else "?:"}(?:(?!{ignore_pattern}).)*(?:(?!{Regex.outside_strings(disallowed_pattern)}).)*)'
 
     @staticmethod
     def func_call(func_name: str = None) -> str:
-        """Match a function call
-        - `1` function name
-        - `2` the function's arguments\n
+        """Match a function call, and get back two groups:
+        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`!"""
-        return r"(?<=\b)(" + (func_name if func_name else r"[\w_]+") + r")\s*" + Regex.brackets("(", ")", is_group=True)
+        return (
+            r"(?<=\b)(" + (r"[\w_]+" if func_name is None else func_name) + r")\s*" + Regex.brackets("(", ")", is_group=True)
+        )
 
     @staticmethod
     def rgba_str(fix_sep: str = ",", allow_alpha: bool = True) -> str:
@@ -76,11 +90,10 @@ class Regex:
         - `(r, g, b, a)` (if `allow_alpha=True`)
         - `r, g, b`
         - `r, g, b, a` (if `allow_alpha=True`)\n
-        ----------------------------------------------------------------------------
-        ### Valid ranges:
-        - `r` 0-255 (amount: red)
-        - `g` 0-255 (amount: green)
-        - `b` 0-255 (amount: blue)
+        #### Valid ranges:
+        - `r` 0-255 (int: red)
+        - `g` 0-255 (int: green)
+        - `b` 0-255 (int: blue)
         - `a` 0-1 (float: opacity)\n
         ----------------------------------------------------------------------------
         If the `fix_sep` is set to nothing, any char that is not a letter or number
@@ -112,11 +125,10 @@ class Regex:
         - `(h, s, l, a)` (if `allow_alpha=True`)
         - `h, s, l`
         - `h, s, l, a` (if `allow_alpha=True`)\n
-        ----------------------------------------------------------------------------
-        ### Valid ranges:
-        - `h` 0-360 (degrees: hue)
-        - `s` 0-100 (percentage: saturation)
-        - `l` 0-100 (percentage: lightness)
+        #### Valid ranges:
+        - `h` 0-360 (int: hue)
+        - `s` 0-100 (int: saturation)
+        - `l` 0-100 (int: lightness)
         - `a` 0-1 (float: opacity)\n
         ----------------------------------------------------------------------------
         If the `fix_sep` is set to nothing, any char that is not a letter or number
@@ -146,9 +158,8 @@ class Regex:
         - `RGBA` (if `allow_alpha=True`)
         - `RRGGBB`
         - `RRGGBBAA` (if `allow_alpha=True`)\n
-        ----------------------------------------------------------------------
-        ### Valid ranges:
-        each channel from 0-9 and A-F (case insensitive)"""
+        #### Valid ranges:
+        every channel from 0-9 and A-F (case insensitive)"""
         return (
             r"(?i)^(?:#|0x)?[0-9A-F]{8}|[0-9A-F]{6}|[0-9A-F]{4}|[0-9A-F]{3}$"
             if allow_alpha

xulbux/xx_system.py

@@ -41,7 +41,7 @@ class System:
             if not force:
                 output = _subprocess.check_output("tasklist", shell=True).decode()
                 processes = [line.split()[0] for line in output.splitlines()[3:] if line.strip()]
-                if len(processes) > 2:  # EXCLUDING THE PYTHON PROCESS AND CMD
+                if len(processes) > 2:  # EXCLUDING THE PYTHON PROCESS AND CONSOLE
                     raise RuntimeError("Processes are still running. Use the parameter `force=True` to restart anyway.")
             if prompt:
                 _os.system(f'shutdown /r /t {wait} /c "{prompt}"')

{xulbux-1.6.2.dist-info → xulbux-1.6.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xulbux
-Version: 1.6.2
+Version: 1.6.4
 Summary: A library which includes a lot of really helpful functions.
 Author-email: XulbuX <xulbux.real@gmail.com>
 License: MIT License
@@ -31,7 +31,7 @@ Project-URL: Documentation, https://github.com/XulbuX-dev/PythonLibraryXulbuX/wi
 Project-URL: Homepage, https://github.com/XulbuX-dev/PythonLibraryXulbuX
 Project-URL: License, https://github.com/XulbuX-dev/PythonLibraryXulbuX/blob/main/LICENSE
 Project-URL: Source Code, https://github.com/XulbuX-dev/PythonLibraryXulbuX/tree/main/src
-Keywords: xulbux,python,library,utility,helper,functions,tools,classes,types,methods,cmd,code,color,data,structures,env,environment,file,format,json,path,regex,string,system,operations,presets
+Keywords: xulbux,python,library,utility,helper,functions,tools,classes,types,methods,cmd,console,code,color,data,structures,env,environment,file,format,json,path,regex,string,system,operations,presets
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -89,19 +89,19 @@ from xulbux import rgba, hsla, hexa
 # Modules
 
 | | |
-| :------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------- |
-| <h3>[`xx_code`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_code)</h3>         | advanced code-string operations (*changing the indent, finding function calls, ...*)               |
-| <h3>[`xx_color`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_color)</h3>       | everything around colors (*converting, blending, searching colors in strings, ...*)                |
-| <h3>[`xx_console`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_console)</h3>   | advanced actions related to the console (*pretty logging, advanced inputs, ...*)                   |
-| <h3>[`xx_data`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_data)</h3>         | advanced operations with data structures (*compare, generate path ID's, pretty print/format, ...*) |
-| <h3>[`xx_env_path`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_env_path)</h3> | getting and editing the PATH variable (*get paths, check for paths, add paths, ...*)               |
-| <h3>[`xx_file`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_file)</h3>         | advanced working with files (*create files, rename file-extensions, ...*)                          |
-| <h3>`xx_format_codes`</h3>                                                                   | easy pretty printing with custom format codes (*print, inputs, custom format codes to ANSI, ...*)  |
-| <h3>`xx_json`</h3>                                                                           | advanced working with json files (*read, create, update, ...*)                                     |
-| <h3>`xx_path`</h3>                                                                           | advanced path operations (*get paths, smart-extend relative paths, delete paths, ...*)             |
-| <h3>`xx_regex`</h3>                                                                          | generated regex pattern-templates (*match bracket- and quote pairs, match colors, ...*)            |
-| <h3>[`xx_string`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_string)</h3>     | helpful actions when working with strings. (*normalize, escape, decompose, ...*)                   |
-| <h3>`xx_system`</h3>                                                                         | advanced system actions (*restart with message, check installed Python libs, ...*)                 |
+| :--------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------- |
+| <h3>[`xx_code`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_code)</h3>                 | advanced code-string operations (*changing the indent, finding function calls, ...*)               |
+| <h3>[`xx_color`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_color)</h3>               | everything around colors (*converting, blending, searching colors in strings, ...*)                |
+| <h3>[`xx_console`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_console)</h3>           | advanced actions related to the console (*pretty logging, advanced inputs, ...*)                   |
+| <h3>[`xx_data`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_data)</h3>                 | advanced operations with data structures (*compare, generate path ID's, pretty print/format, ...*) |
+| <h3>[`xx_env_path`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_env_path)</h3>         | getting and editing the PATH variable (*get paths, check for paths, add paths, ...*)               |
+| <h3>[`xx_file`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_file)</h3>                 | advanced working with files (*create files, rename file-extensions, ...*)                          |
+| <h3>[`xx_format_codes`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_format_codes)</h3> | easy pretty printing with custom format codes (*print, inputs, custom format codes to ANSI, ...*)  |
+| <h3>`xx_json`</h3>                                                                                   | advanced working with json files (*read, create, update, ...*)                                     |
+| <h3>`xx_path`</h3>                                                                                   | advanced path operations (*get paths, smart-extend relative paths, delete paths, ...*)             |
+| <h3>`xx_regex`</h3>                                                                                  | generated regex pattern-templates (*match bracket- and quote pairs, match colors, ...*)            |
+| <h3>[`xx_string`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_string)</h3>             | helpful actions when working with strings. (*normalize, escape, decompose, ...*)                   |
+| <h3>`xx_system`</h3>                                                                                 | advanced system actions (*restart with message, check installed Python libs, ...*)                 |
 
 
 <br>

{xulbux-1.6.2.dist-info → xulbux-1.6.4.dist-info}/RECORD

@@ -1,21 +1,21 @@
-xulbux/__init__.py,sha256=fxqdXSxUa_iDtV2MWdq4aBXV3B0pQWgz2xHpLnm84zw,1658
+xulbux/__init__.py,sha256=VbGUDMdLbSCMOJk62Fm7QTSyKiC9AtQmO_VutJgjwIY,1658
 xulbux/_cli_.py,sha256=U25ZrtpQgpKXtvOSTBBbh7-AJ_WTeZ95A66DQARAqzo,3558
-xulbux/_consts_.py,sha256=qAkg6ZwTKhQFcpHpfXjF4QEao8hpDEECRGqrv8oxkCo,4572
+xulbux/_consts_.py,sha256=0JWj691rOojP8KKE_AJpF8O5WwMRJH4fAvzkwLXd1VM,4591
 xulbux/xx_code.py,sha256=yBP5WxCxNxjBiS6nVAmUBJpD0hX6fgnh5RWq-NmrnaY,5222
 xulbux/xx_color.py,sha256=cDlgrekH88ZEBj8leIIlJbYzsf1RdS8RW3oGvuUfvC0,45129
 xulbux/xx_console.py,sha256=rd31686X9eXB8__lcLaV7unWzIdXGM2yMOt9zNCsGbs,15079
 xulbux/xx_data.py,sha256=OEKLbI1XeNTrittdz3s3mvQk8YrBoSovj9O1H-b7ArY,25844
 xulbux/xx_env_path.py,sha256=iv3Jw0TsNDbbL_NySnazvIP9Iv9swymhiJIr2B3EG8k,4388
 xulbux/xx_file.py,sha256=-58YnqKvrs5idIF91UzEki7o7qnskFvnQYkBaRrp7Vw,3122
-xulbux/xx_format_codes.py,sha256=hTQBowcFX0gyAtjsYvgrEZK2EQ83b0W-IyqIUTkJAig,16986
+xulbux/xx_format_codes.py,sha256=ywF0MfGZRlWuYopLUAFBm9g-vAkXE8IIumII90gaCIE,19836
 xulbux/xx_json.py,sha256=q60lOj8Xg8c4L9cBu6SBZdJzFC7QbjDfFwcKKzBKj5w,5173
 xulbux/xx_path.py,sha256=_xkH9cowPdi3nHw2q_TvN_i_5oG6GJut-QwPBLxnrAQ,4519
-xulbux/xx_regex.py,sha256=zyxkS1bLlrSq26ErhO4UtrimIhW71_a7kox6ArCoK58,7670
+xulbux/xx_regex.py,sha256=S1-MIk2qG4vHdxuaHGhMe5PHfY1SF9kncg8iQ8HJgS4,8002
 xulbux/xx_string.py,sha256=Wa3qHxnk7AIpAVAn1vI_GBtkfYFwy4F_Xtj83ojEPKc,7168
-xulbux/xx_system.py,sha256=uBpB1eKbR-bddO87jbWdoi5NScLnrxJONbyqU49LmCs,6426
-xulbux-1.6.2.dist-info/LICENSE,sha256=6NflEcvzFEe8_JFVNCPVwZBwBhlLLd4vqQi8WiX_Xk4,1084
-xulbux-1.6.2.dist-info/METADATA,sha256=PyPr14LhmMVg952AQ-5uxp5jd3GSFRVCOxjPfsQ7ebo,6836
-xulbux-1.6.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-xulbux-1.6.2.dist-info/entry_points.txt,sha256=a3womfLIMZKnOFiyy-xnVb4g2qkZsHR5FbKKkljcGns,94
-xulbux-1.6.2.dist-info/top_level.txt,sha256=FkK4EZajwfP36fnlrPaR98OrEvZpvdEOdW1T5zTj6og,7
-xulbux-1.6.2.dist-info/RECORD,,
+xulbux/xx_system.py,sha256=M3VGU3Tf3nDU59DjIJgDXJOqNB80Vr0wf15Vcnb5UCo,6430
+xulbux-1.6.4.dist-info/LICENSE,sha256=6NflEcvzFEe8_JFVNCPVwZBwBhlLLd4vqQi8WiX_Xk4,1084
+xulbux-1.6.4.dist-info/METADATA,sha256=TabSXy5WGWo8P5zrwjklaOnO73Ay3JeHn3MA16nT33U,6948
+xulbux-1.6.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+xulbux-1.6.4.dist-info/entry_points.txt,sha256=a3womfLIMZKnOFiyy-xnVb4g2qkZsHR5FbKKkljcGns,94
+xulbux-1.6.4.dist-info/top_level.txt,sha256=FkK4EZajwfP36fnlrPaR98OrEvZpvdEOdW1T5zTj6og,7
+xulbux-1.6.4.dist-info/RECORD,,