xulbux 1.6.5__py3-none-any.whl → 1.6.7__py3-none-any.whl

xulbux/__init__.py

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

xulbux/_cli_.py

@@ -1,5 +1,5 @@
 from . import __version__
-from ._consts_ import DEFAULT
+from ._consts_ import COLOR
 from .xx_format_codes import FormatCodes
 from .xx_console import Console
 
@@ -7,20 +7,20 @@ from .xx_console import Console
 def help_command():
     """Show some info about the library, with a brief explanation of how to use it."""
     color = {
-        "lib": DEFAULT.color["ice"],
-        "import": DEFAULT.color["red"],
-        "class": DEFAULT.color["lavender"],
-        "types": DEFAULT.color["lightblue"],
-        "punctuators": DEFAULT.color["darkgray"],
+        "lib": COLOR.ice,
+        "import": COLOR.red,
+        "class": COLOR.lavender,
+        "types": COLOR.lightblue,
+        "punctuators": COLOR.darkgray,
     }
     FormatCodes.print(
         rf"""  [_|b|#7075FF]               __  __
   [b|#7075FF]  _  __ __  __/ / / /_  __  ___  __
   [b|#7075FF] | |/ // / / / / / __ \/ / / | |/ /
   [b|#7075FF] > , </ /_/ / /_/ /_/ / /_/ /> , <
-  [b|#7075FF]/_/|_|\____/\__/\____/\____//_/|_|  [*|BG:{DEFAULT.color['gray']}|#000] v[b]{__version__} [*]
+  [b|#7075FF]/_/|_|\____/\__/\____/\____//_/|_|  [*|BG:{COLOR.gray}|#000] v[b]{__version__} [*]
 
-  [i|{DEFAULT.color['coral']}]A TON OF COOL FUNCTIONS, YOU NEED![*]
+  [i|{COLOR.coral}]A TON OF COOL FUNCTIONS, YOU NEED![*]
 
   [b|#75A2FF]Usage:[*]
     [{color['punctuators']}]# GENERAL LIBRARY[*]
@@ -48,6 +48,6 @@ def help_command():
   [_]
   [dim](Press any key to exit...)
   """,
-        default_color=DEFAULT.text_color,
+        default_color=COLOR.text
     )
     Console.pause_exit(pause=True)

xulbux/_consts_.py

@@ -1,76 +1,110 @@
-class DEFAULT:
-
-    text_color: str = "#95B5FF"
-    color: dict[str, str] = {
-        "white": "#F1F2FF",
-        "lightgray": "#B6B7C0",
-        "gray": "#7B7C8D",
-        "darkgray": "#67686C",
-        "black": "#202125",
-        "red": "#FF606A",
-        "coral": "#FF7069",
-        "orange": "#FF876A",
-        "tangerine": "#FF9962",
-        "gold": "#FFAF60",
-        "yellow": "#FFD260",
-        "green": "#7EE787",
-        "teal": "#50EAAF",
-        "cyan": "#3EE6DE",
-        "ice": "#77EFEF",
-        "lightblue": "#60AAFF",
-        "blue": "#8085FF",
-        "lavender": "#9B7DFF",
-        "purple": "#AD68FF",
-        "magenta": "#C860FF",
-        "pink": "#EE60BB",
-        "rose": "#FF6090",
-    }
-
-
+from dataclasses import dataclass
+from typing import TypeAlias
+
+
+FormattableString: TypeAlias = str
+"""A `str` object that is made to be formatted with the `.format()` method."""
+
+
+@dataclass
+class COLOR:
+    """Color presets used in the `xulbux` library."""
+
+    text = "#A5D6FF"
+    """The default text color used in the `xulbux` library."""
+
+    white = "#F1F2FF"
+    lightgray = "#B6B7C0"
+    gray = "#7B7C8D"
+    darkgray = "#67686C"
+    black = "#202125"
+    red = "#FF606A"
+    coral = "#FF7069"
+    orange = "#FF876A"
+    tangerine = "#FF9962"
+    gold = "#FFAF60"
+    yellow = "#FFD260"
+    lime = "#C9F16E"
+    green = "#7EE787"
+    teal = "#50EAAF"
+    cyan = "#3EDEE6"
+    ice = "#77DBEF"
+    lightblue = "#60AAFF"
+    blue = "#8085FF"
+    lavender = "#9B7DFF"
+    purple = "#AD68FF"
+    magenta = "#C860FF"
+    pink = "#F162EF"
+    rose = "#FF609F"
+
+
+class _AllTextCharacters:
+    pass
+
+
+@dataclass
 class CHARS:
-
-    # CODE TO SIGNAL, ALL CHARACTERS ARE ALLOWED
-    all = "<*allowed>"
-
-    # DIGIT SETS
-    digits = "0123456789"
-    float_digits = digits + "."
-    hex_digits = digits + "#abcdefABCDEF"
-
-    # LETTER CATEGORIES
-    lowercase = "abcdefghijklmnopqrstuvwxyz"
-    lowercase_extended = lowercase + "äëïöüÿàèìòùáéíóúýâêîôûãñõåæç"
-    uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    uppercase_extended = uppercase + "ÄËÏÖÜÀÈÌÒÙÁÉÍÓÚÝÂÊÎÔÛÃÑÕÅÆÇß"
-
-    # COMBINED LETTER SETS
-    letters = lowercase + uppercase
-    letters_extended = lowercase_extended + uppercase_extended
-
-    # ASCII sets
-    special_ascii = " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
-    special_ascii_extended = special_ascii + "ø£Ø׃ªº¿®¬½¼¡«»░▒▓│┤©╣║╗╝¢¥┐└┴┬├─┼╚╔╩╦╠═╬¤ðÐı┘┌█▄¦▀µþÞ¯´≡­±‗¾¶§÷¸°¨·¹³²■ "
-    standard_ascii = special_ascii + digits + letters
-    full_ascii = special_ascii_extended + digits + letters_extended
+    """Text character sets."""
+
+    all = _AllTextCharacters
+    """Code to signal that all characters are allowed."""
+
+    digits: str = "0123456789"
+    """Digits: `0`-`9`"""
+    float_digits: str = digits + "."
+    """Digits: `0`-`9` with decimal point `.`"""
+    hex_digits: str = digits + "#abcdefABCDEF"
+    """Digits: `0`-`9` Letters: `a`-`f` `A`-`F` and a hashtag `#`"""
+
+    lowercase: str = "abcdefghijklmnopqrstuvwxyz"
+    """Lowercase letters `a`-`z`"""
+    lowercase_extended: str = lowercase + "äëïöüÿàèìòùáéíóúýâêîôûãñõåæç"
+    """Lowercase letters `a`-`z` with all lowercase diacritic letters."""
+    uppercase: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    """Uppercase letters `A`-`Z`"""
+    uppercase_extended: str = uppercase + "ÄËÏÖÜÀÈÌÒÙÁÉÍÓÚÝÂÊÎÔÛÃÑÕÅÆÇß"
+    """Uppercase letters `A`-`Z` with all uppercase diacritic letters."""
+
+    letters: str = lowercase + uppercase
+    """Lowercase and uppercase letters `a`-`z` and `A`-`Z`"""
+    letters_extended: str = lowercase_extended + uppercase_extended
+    """Lowercase and uppercase letters `a`-`z` `A`-`Z` and all diacritic letters."""
+
+    special_ascii: str = " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
+    """All ASCII special characters."""
+    special_ascii_extended: str = special_ascii + "ø£Ø׃ªº¿®¬½¼¡«»░▒▓│┤©╣║╗╝¢¥┐└┴┬├─┼╚╔╩╦╠═╬¤ðÐı┘┌█▄¦▀µþÞ¯´≡­±‗¾¶§÷¸°¨·¹³²■ "
+    """All ASCII special characters with the extended ASCII special characters."""
+    standard_ascii: str = special_ascii + digits + letters
+    """All standard ASCII characters."""
+    full_ascii: str = special_ascii_extended + digits + letters_extended
+    """All characters in the ASCII table."""
 
 
 class ANSI:
+    """Constants and class-methods for use of ANSI escape codes."""
 
-    global CHAR, START, SEP, END
-
-    escaped_char = "\\x1b"
+    escaped_char: str = "\\x1b"
+    """The printable ANSI escape character."""
     CHAR = char = "\x1b"
+    """The ANSI escape character."""
     START = start = "["
+    """The start of an ANSI escape sequence."""
     SEP = sep = ";"
+    """The separator between ANSI escape sequence parts."""
     END = end = "m"
-    default_color_modifiers = {"lighten": "+l", "darken": "-d"}
+    """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."""
 
-    def seq(parts: int = 1) -> str:
+    @classmethod
+    def seq(cls, parts: int = 1) -> FormattableString:
         """Generate an ANSI sequence with `parts` amount of placeholders."""
-        return CHAR + START + SEP.join(["{}" for _ in range(parts)]) + END
+        return cls.CHAR + cls.START + cls.SEP.join(["{}" for _ in range(parts)]) + cls.END
 
-    seq_color: str = CHAR + START + "38" + SEP + "2" + SEP + "{}" + SEP + "{}" + SEP + "{}" + END
-    seq_bg_color: str = CHAR + START + "48" + SEP + "2" + SEP + "{}" + SEP + "{}" + SEP + "{}" + END
+    seq_color: FormattableString = CHAR + START + "38" + SEP + "2" + SEP + "{}" + SEP + "{}" + SEP + "{}" + END
+    """The ANSI escape sequence for setting the text RGB color."""
+    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] = [
         ########### DEFAULT CONSOLE COLOR NAMES ############
@@ -83,8 +117,9 @@ class ANSI:
         "cyan",
         "white",
     ]
+    """The console default color names."""
 
-    codes_map: dict[str | tuple[str], int] = {
+    codes_map: dict[str | tuple[str, ...], int] = {
         ################# SPECIFIC RESETS ##################
         "_": 0,
         ("_bold", "_b"): 22,
@@ -143,3 +178,4 @@ class ANSI:
         "bg:br:cyan": 106,
         "bg:br:white": 107,
     }
+    """All custom format keys and their corresponding ANSI format number codes."""

xulbux/xx_code.py

@@ -59,47 +59,42 @@ class Code:
         js_pattern = _rx.compile(
             Regex.outside_strings(
                 r"""^(?:
-            (\$[\w_]+)\s*                      # JQUERY-STYLE VARIABLES
-            |(\$[\w_]+\s*\()                   # JQUERY-STYLE FUNCTION CALLS
-            |(("""
-                + funcs
-                + r")"
-                + Regex.brackets("()")
-                + r"""\s*) # PREDEFINED FUNCTION CALLS
-            |(\bfunction\s*\()                 # FUNCTION DECLARATIONS
-            |(\b(var|let|const)\s+[\w_]+\s*=)  # VARIABLE DECLARATIONS
-            |(\b(if|for|while|switch)\s*\()    # CONTROL STRUCTURES
-            |(\b(return|throw)\s+)             # RETURN OR THROW STATEMENTS
-            |(\bnew\s+[\w_]+\()                # OBJECT INSTANTIATION
-            |(\b[\w_]+\s*=>\s*{)               # ARROW FUNCTIONS
-            |(\b(true|false|null|undefined)\b) # JAVASCRIPT LITERALS
-            |(\b(document|window|console)\.)   # BROWSER OBJECTS
-            |(\b[\w_]+\.(forEach|map|filter|reduce)\() # ARRAY METHODS
-            |(/[^/\n\r]*?/[gimsuy]*)           # REGULAR EXPRESSIONS
-            |(===|!==|\+\+|--|\|\||&&)         # JAVASCRIPT-SPECIFIC OPERATORS
-            |(\bclass\s+[\w_]+)                # CLASS DECLARATIONS
-            |(\bimport\s+.*?from\s+)           # IMPORT STATEMENTS
-            |(\bexport\s+(default\s+)?)        # EXPORT STATEMENTS
-            |(\basync\s+function)              # ASYNC FUNCTIONS
-            |(\bawait\s+)                      # AWAIT KEYWORD
-            |(\btry\s*{)                       # TRY-CATCH BLOCKS
-            |(\bcatch\s*\()
-            |(\bfinally\s*{)
-            |(\byield\s+)                      # GENERATOR FUNCTIONS
-            |(\[.*?\]\s*=)                     # DESTRUCTURING ASSIGNMENT
-            |(\.\.\.)                          # SPREAD OPERATOR
-            |(==|!=|>=|<=|>|<)                 # COMPARISON OPERATORS
-            |(\+=|-=|\*=|/=|%=|\*\*=)          # COMPOUND ASSIGNMENT OPERATORS
-            |(\+|-|\*|/|%|\*\*)                # ARITHMETIC OPERATORS
-            |(&|\||\^|~|<<|>>|>>>)             # BITWISE OPERATORS
-            |(\?|:)                            # TERNARY OPERATOR
-            |(\bin\b)                          # IN OPERATOR
-            |(\binstanceof\b)                  # INSTANCEOF OPERATOR
-            |(\bdelete\b)                      # DELETE OPERATOR
-            |(\btypeof\b)                      # TYPEOF OPERATOR
-            |(\bvoid\b)                        # VOID OPERATOR
-        )[\s\S]*$"""
-            ),
-            _rx.VERBOSE | _rx.IGNORECASE,
+                (\$[\w_]+)\s*                      # JQUERY-STYLE VARIABLES
+                |(\$[\w_]+\s*\()                   # JQUERY-STYLE FUNCTION CALLS
+                |((""" + funcs + r")" + Regex.brackets("()") + r"""\s*) # PREDEFINED FUNCTION CALLS
+                |(\bfunction\s*\()                 # FUNCTION DECLARATIONS
+                |(\b(var|let|const)\s+[\w_]+\s*=)  # VARIABLE DECLARATIONS
+                |(\b(if|for|while|switch)\s*\()    # CONTROL STRUCTURES
+                |(\b(return|throw)\s+)             # RETURN OR THROW STATEMENTS
+                |(\bnew\s+[\w_]+\()                # OBJECT INSTANTIATION
+                |(\b[\w_]+\s*=>\s*{)               # ARROW FUNCTIONS
+                |(\b(true|false|null|undefined)\b) # JAVASCRIPT LITERALS
+                |(\b(document|window|console)\.)   # BROWSER OBJECTS
+                |(\b[\w_]+\.(forEach|map|filter|reduce)\() # ARRAY METHODS
+                |(/[^/\n\r]*?/[gimsuy]*)           # REGULAR EXPRESSIONS
+                |(===|!==|\+\+|--|\|\||&&)         # JAVASCRIPT-SPECIFIC OPERATORS
+                |(\bclass\s+[\w_]+)                # CLASS DECLARATIONS
+                |(\bimport\s+.*?from\s+)           # IMPORT STATEMENTS
+                |(\bexport\s+(default\s+)?)        # EXPORT STATEMENTS
+                |(\basync\s+function)              # ASYNC FUNCTIONS
+                |(\bawait\s+)                      # AWAIT KEYWORD
+                |(\btry\s*{)                       # TRY-CATCH BLOCKS
+                |(\bcatch\s*\()
+                |(\bfinally\s*{)
+                |(\byield\s+)                      # GENERATOR FUNCTIONS
+                |(\[.*?\]\s*=)                     # DESTRUCTURING ASSIGNMENT
+                |(\.\.\.)                          # SPREAD OPERATOR
+                |(==|!=|>=|<=|>|<)                 # COMPARISON OPERATORS
+                |(\+=|-=|\*=|/=|%=|\*\*=)          # COMPOUND ASSIGNMENT OPERATORS
+                |(\+|-|\*|/|%|\*\*)                # ARITHMETIC OPERATORS
+                |(&|\||\^|~|<<|>>|>>>)             # BITWISE OPERATORS
+                |(\?|:)                            # TERNARY OPERATOR
+                |(\bin\b)                          # IN OPERATOR
+                |(\binstanceof\b)                  # INSTANCEOF OPERATOR
+                |(\bdelete\b)                      # DELETE OPERATOR
+                |(\btypeof\b)                      # TYPEOF OPERATOR
+                |(\bvoid\b)                        # VOID OPERATOR
+                )[\s\S]*$"""
+            ), _rx.VERBOSE | _rx.IGNORECASE
         )
         return bool(js_pattern.fullmatch(code))

xulbux/xx_color.py

@@ -33,6 +33,7 @@ The `Color` class, which contains all sorts of different color-related methods:
 
 from .xx_regex import Regex
 
+from typing import Optional
 import re as _re
 
 
@@ -79,13 +80,13 @@ class rgba:
         return 3 if self.a is None else 4
 
     def __iter__(self) -> iter:
-        return iter((self.r, self.g, self.b) + (() if self.a is None else (self.a,)))
+        return iter((self.r, self.g, self.b) + (() if self.a is None else (self.a, )))
 
     def __dict__(self) -> dict:
         return self.dict()
 
     def __getitem__(self, index: int) -> int:
-        return ((self.r, self.g, self.b) + (() if self.a is None else (self.a,)))[index]
+        return ((self.r, self.g, self.b) + (() if self.a is None else (self.a, )))[index]
 
     def __repr__(self) -> str:
         return f'rgba({self.r}, {self.g}, {self.b}{"" if self.a is None else f", {self.a}"})'
@@ -183,13 +184,7 @@ class rgba:
             if additive_alpha:
                 self.a = max(0, min(1, (self_a * (2 - ratio)) + (other_a * ratio)))
             else:
-                self.a = max(
-                    0,
-                    min(
-                        1,
-                        (self_a * (1 - (ratio / 2))) + (other_a * (ratio / 2)),
-                    ),
-                )
+                self.a = max(0, min(1, (self_a * (1 - (ratio / 2))) + (other_a * (ratio / 2))))
         else:
             self.a = None
         return rgba(self.r, self.g, self.b, None if none_alpha else self.a, _validate=False)
@@ -282,13 +277,13 @@ class hsla:
         return 3 if self.a is None else 4
 
     def __iter__(self) -> iter:
-        return iter((self.h, self.s, self.l) + (() if self.a is None else (self.a,)))
+        return iter((self.h, self.s, self.l) + (() if self.a is None else (self.a, )))
 
     def __dict__(self) -> dict:
         return self.dict()
 
     def __getitem__(self, index: int) -> int:
-        return ((self.h, self.s, self.l) + (() if self.a is None else (self.a,)))[index]
+        return ((self.h, self.s, self.l) + (() if self.a is None else (self.a, )))[index]
 
     def __repr__(self) -> str:
         return f'hsla({self.h}, {self.s}, {self.l}{"" if self.a is None else f", {self.a}"})'
@@ -508,17 +503,15 @@ class hexa:
         return 3 if self.a is None else 4
 
     def __iter__(self) -> iter:
-        return iter(
-            (f"{self.r:02X}", f"{self.g:02X}", f"{self.b:02X}") + (() if self.a is None else (f"{int(self.a * 255):02X}",))
-        )
+        return iter((f"{self.r:02X}", f"{self.g:02X}", f"{self.b:02X}")
+                    + (() if self.a is None else (f"{int(self.a * 255):02X}", )))
 
     def __dict__(self) -> dict:
         return self.dict()
 
     def __getitem__(self, index: int) -> int:
-        return (
-            (f"{self.r:02X}", f"{self.g:02X}", f"{self.b:02X}") + (() if self.a is None else (f"{int(self.a * 255):02X}",))
-        )[index]
+        return ((f"{self.r:02X}", f"{self.g:02X}", f"{self.b:02X}") + (() if self.a is None else
+                                                                       (f"{int(self.a * 255):02X}", )))[index]
 
     def __repr__(self) -> str:
         return f'hexa(#{self.r:02X}{self.g:02X}{self.b:02X}{"" if self.a is None else f"{int(self.a * 255):02X}"})'
@@ -539,9 +532,7 @@ class hexa:
     def dict(self) -> dict:
         """Returns the color components as a dictionary with hex string values for keys `'r'`, `'g'`, `'b'` and optionally `'a'`"""
         return (
-            dict(r=f"{self.r:02X}", g=f"{self.g:02X}", b=f"{self.b:02X}")
-            if self.a is None
-            else dict(
+            dict(r=f"{self.r:02X}", g=f"{self.g:02X}", b=f"{self.b:02X}") if self.a is None else dict(
                 r=f"{self.r:02X}",
                 g=f"{self.g:02X}",
                 b=f"{self.b:02X}",
@@ -653,18 +644,14 @@ class Color:
             elif isinstance(color, (list, tuple)):
                 if allow_alpha and Color.has_alpha(color):
                     return (
-                        0 <= color[0] <= 255
-                        and 0 <= color[1] <= 255
-                        and 0 <= color[2] <= 255
+                        0 <= color[0] <= 255 and 0 <= color[1] <= 255 and 0 <= color[2] <= 255
                         and (0 <= color[3] <= 1 or color[3] is None)
                     )
                 return 0 <= color[0] <= 255 and 0 <= color[1] <= 255 and 0 <= color[2] <= 255
             elif isinstance(color, dict):
                 if allow_alpha and Color.has_alpha(color):
                     return (
-                        0 <= color["r"] <= 255
-                        and 0 <= color["g"] <= 255
-                        and 0 <= color["b"] <= 255
+                        0 <= color["r"] <= 255 and 0 <= color["g"] <= 255 and 0 <= color["b"] <= 255
                         and (0 <= color["a"] <= 1 or color["a"] is None)
                     )
                 return 0 <= color["r"] <= 255 and 0 <= color["g"] <= 255 and 0 <= color["b"] <= 255
@@ -682,9 +669,7 @@ class Color:
             elif isinstance(color, (list, tuple)):
                 if allow_alpha and Color.has_alpha(color):
                     return (
-                        0 <= color[0] <= 360
-                        and 0 <= color[1] <= 100
-                        and 0 <= color[2] <= 100
+                        0 <= color[0] <= 360 and 0 <= color[1] <= 100 and 0 <= color[2] <= 100
                         and (0 <= color[3] <= 1 or color[3] is None)
                     )
                 else:
@@ -692,9 +677,7 @@ class Color:
             elif isinstance(color, dict):
                 if allow_alpha and Color.has_alpha(color):
                     return (
-                        0 <= color["h"] <= 360
-                        and 0 <= color["s"] <= 100
-                        and 0 <= color["l"] <= 100
+                        0 <= color["h"] <= 360 and 0 <= color["s"] <= 100 and 0 <= color["l"] <= 100
                         and (0 <= color["a"] <= 1 or color["a"] is None)
                     )
                 else:
@@ -713,24 +696,17 @@ class Color:
                 is_valid = 0 <= color <= (0xFFFFFFFF if allow_alpha else 0xFFFFFF)
                 return (is_valid, "0x") if get_prefix else is_valid
             elif isinstance(color, str):
-                color, prefix = (
-                    (color[1:], "#")
-                    if color.startswith("#")
-                    else (color[2:], "0x") if color.startswith("0x") else (color, None)
-                )
-                return (
-                    (bool(_re.fullmatch(Regex.hexa_str(allow_alpha=allow_alpha), color)), prefix)
-                    if get_prefix
-                    else bool(_re.fullmatch(Regex.hexa_str(allow_alpha=allow_alpha), color))
-                )
+                color, prefix = ((color[1:], "#") if color.startswith("#") else
+                                 (color[2:], "0x") if color.startswith("0x") else (color, None))
+                return ((bool(_re.fullmatch(Regex.hexa_str(allow_alpha=allow_alpha), color)),
+                         prefix) if get_prefix else bool(_re.fullmatch(Regex.hexa_str(allow_alpha=allow_alpha), color)))
         except Exception:
             return (False, None) if get_prefix else False
 
     @staticmethod
     def is_valid(color: str | list | tuple | dict, allow_alpha: bool = True) -> bool:
         return (
-            Color.is_valid_rgba(color, allow_alpha)
-            or Color.is_valid_hsla(color, allow_alpha)
+            Color.is_valid_rgba(color, allow_alpha) or Color.is_valid_hsla(color, allow_alpha)
             or Color.is_valid_hexa(color, allow_alpha)
         )
 
@@ -796,7 +772,7 @@ class Color:
         raise ValueError(f"Invalid color format '{color}'")
 
     @staticmethod
-    def str_to_rgba(string: str, only_first: bool = False) -> rgba | list[rgba] | None:
+    def str_to_rgba(string: str, only_first: bool = False) -> Optional[rgba | list[rgba]]:
         """Will try to recognize RGBA colors inside a string and output the found ones as RGBA objects.\n
         --------------------------------------------------------------------------------------------------
         If `only_first` is `True` only the first found color will be returned (not as a list)."""
@@ -823,8 +799,7 @@ class Color:
                     int(m[2]),
                     ((int(m[3]) if "." not in m[3] else float(m[3])) if m[3] else None),
                     _validate=False,
-                )
-                for m in matches
+                ) for m in matches
             ]
 
     @staticmethod
@@ -901,15 +876,15 @@ class Color:
         if r < 0.03928:
             r = r / 12.92
         else:
-            r = ((r + 0.055) / 1.055) ** 2.4
+            r = ((r + 0.055) / 1.055)**2.4
         if g < 0.03928:
             g = g / 12.92
         else:
-            g = ((g + 0.055) / 1.055) ** 2.4
+            g = ((g + 0.055) / 1.055)**2.4
         if b < 0.03928:
             b = b / 12.92
         else:
-            b = ((b + 0.055) / 1.055) ** 2.4
+            b = ((b + 0.055) / 1.055)**2.4
         l = 0.2126 * r + 0.7152 * g + 0.0722 * b
         return round(l * 100) if isinstance(output_type, int) else round(l * 255) if output_type is None else l
 
@@ -918,11 +893,8 @@ class Color:
         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 (
-            (hexa("", 255, 255, 255) if was_hexa else rgba(255, 255, 255, _validate=False))
-            if brightness < 128
-            else ((0x000 if was_int else hexa("", 0, 0, 0)) if was_hexa else rgba(0, 0, 0, _validate=False))
-        )
+        return ((hexa("", 255, 255, 255) if was_hexa else rgba(255, 255, 255, _validate=False)) if brightness < 128 else
+                ((0x000 if was_int else hexa("", 0, 0, 0)) if was_hexa else rgba(0, 0, 0, _validate=False)))
 
     @staticmethod
     def adjust_lightness(color: rgba | hexa, lightness_change: float) -> rgba | hexa: