xulbux 1.6.5__tar.gz → 1.6.6__tar.gz

{xulbux-1.6.5/src/xulbux.egg-info → xulbux-1.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xulbux
-Version: 1.6.5
+Version: 1.6.6
 Summary: A library which includes a lot of really helpful functions.
 Author-email: XulbuX <xulbux.real@gmail.com>
 License: MIT License
@@ -45,6 +45,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: keyboard>=0.13.5
 Requires-Dist: mouse>=0.7.1
+Requires-Dist: prompt_toolkit>=3.0.41
 Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: regex>=2023.10.3
 Provides-Extra: dev
@@ -52,6 +53,7 @@ Requires-Dist: pytest>=7.4.2; extra == "dev"
 Requires-Dist: black>=23.7.0; extra == "dev"
 Requires-Dist: isort>=5.12.0; extra == "dev"
 Requires-Dist: flake8>=6.1.0; extra == "dev"
+Requires-Dist: flake8-pyproject>=1.2.3; extra == "dev"
 
 # **$\color{#8085FF}\Huge\textsf{XulbuX}$**
 

{xulbux-1.6.5 → xulbux-1.6.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xulbux"
-version = "1.6.5"
+version = "1.6.6"
 authors = [{ name = "XulbuX", email = "xulbux.real@gmail.com" }]
 description = "A library which includes a lot of really helpful functions."
 readme = "README.md"
@@ -13,6 +13,7 @@ requires-python = ">=3.10.0"
 dependencies = [
   "keyboard>=0.13.5",
   "mouse>=0.7.1",
+  "prompt_toolkit>=3.0.41",
   "pyperclip>=1.9.0",
   "regex>=2023.10.3",
 ]
@@ -21,6 +22,7 @@ optional-dependencies = { dev = [
   "black>=23.7.0",
   "isort>=5.12.0",
   "flake8>=6.1.0",
+  "flake8-pyproject>=1.2.3",
 ] }
 classifiers = [
   "Intended Audience :: Developers",
@@ -103,11 +105,11 @@ use_parentheses = true
 ensure_newline_before_comments = true
 
 [tool.flake8]
+max-complexity = 12
 max-line-length = 127
-extend-ignore = ["E203", "E266", "E501", "W503", "E303"]
-max-complexity = 18
-select = ["B", "C", "E", "F", "W", "T4", "B9"]
-per-file-ignores = ["__init__.py:F401,F403"]
+select = ["E", "F", "W", "C90"]
+extend-ignore = ["E203", "E266", "W503"]
+per-file-ignores = ["__init__.py:F403,F405"]
 
 [tool.setuptools]
 packages = ["xulbux"]

{xulbux-1.6.5 → xulbux-1.6.6}/src/xulbux/__init__.py

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

{xulbux-1.6.5 → xulbux-1.6.6}/src/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-1.6.6/src/xulbux/_consts_.py

@@ -0,0 +1,158 @@
+from dataclasses import dataclass
+from typing import TypeAlias
+
+
+FormattableString: TypeAlias = str
+
+
+@dataclass
+class COLOR:
+    """Color presets used in the XulbuX library."""
+
+    text = "#A5D6FF"
+    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 = "#3EDEE6"
+    ice = "#77DBEF"
+    lightblue = "#60AAFF"
+    blue = "#8085FF"
+    lavender = "#9B7DFF"
+    purple = "#AD68FF"
+    magenta = "#C860FF"
+    pink = "#F162EF"
+    rose = "#FF609F"
+
+
+class _AllTextCharacters:
+    pass
+
+
+@dataclass
+class CHARS:
+    """Strings with only certain text characters."""
+
+    # CODE TO SIGNAL, ALL CHARACTERS ARE ALLOWED
+    all = _AllTextCharacters
+
+    # DIGIT SETS
+    digits: str = "0123456789"
+    float_digits: str = digits + "."
+    hex_digits: str = digits + "#abcdefABCDEF"
+
+    # LETTER CATEGORIES
+    lowercase: str = "abcdefghijklmnopqrstuvwxyz"
+    lowercase_extended: str = lowercase + "äëïöüÿàèìòùáéíóúýâêîôûãñõåæç"
+    uppercase: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    uppercase_extended: str = uppercase + "ÄËÏÖÜÀÈÌÒÙÁÉÍÓÚÝÂÊÎÔÛÃÑÕÅÆÇß"
+
+    # COMBINED LETTER SETS
+    letters: str = lowercase + uppercase
+    letters_extended: str = lowercase_extended + uppercase_extended
+
+    # ASCII sets
+    special_ascii: str = " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
+    special_ascii_extended: str = special_ascii + "ø£Ø׃ªº¿®¬½¼¡«»░▒▓│┤©╣║╗╝¢¥┐└┴┬├─┼╚╔╩╦╠═╬¤ðÐı┘┌█▄¦▀µþÞ¯´≡­±‗¾¶§÷¸°¨·¹³²■ "
+    standard_ascii: str = special_ascii + digits + letters
+    full_ascii: str = special_ascii_extended + digits + letters_extended
+
+
+class ANSI:
+    """Constants and class-methods for use of ANSI escape codes."""
+
+    escaped_char: str = "\\x1b"
+    CHAR = char = "\x1b"
+    START = start = "["
+    SEP = sep = ";"
+    END = end = "m"
+    default_color_modifiers: dict[str, str] = {"lighten": "+l", "darken": "-d"}
+
+    @classmethod
+    def seq(cls, parts: int = 1) -> str:
+        """Generate an ANSI sequence with `parts` amount of placeholders."""
+        return cls.CHAR + cls.START + cls.SEP.join(["{}" for _ in range(parts)]) + cls.END
+
+    seq_color: FormattableString = CHAR + START + "38" + SEP + "2" + SEP + "{}" + SEP + "{}" + SEP + "{}" + END
+    seq_bg_color: FormattableString = CHAR + START + "48" + SEP + "2" + SEP + "{}" + SEP + "{}" + SEP + "{}" + END
+
+    color_map: list[str] = [
+        ########### DEFAULT CONSOLE COLOR NAMES ############
+        "black",
+        "red",
+        "green",
+        "yellow",
+        "blue",
+        "magenta",
+        "cyan",
+        "white",
+    ]
+
+    codes_map: dict[str | tuple[str, ...], int] = {
+        ################# SPECIFIC RESETS ##################
+        "_": 0,
+        ("_bold", "_b"): 22,
+        ("_dim", "_d"): 22,
+        ("_italic", "_i"): 23,
+        ("_underline", "_u"): 24,
+        ("_double-underline", "_du"): 24,
+        ("_inverse", "_invert", "_in"): 27,
+        ("_hidden", "_hide", "_h"): 28,
+        ("_strikethrough", "_s"): 29,
+        ("_color", "_c"): 39,
+        ("_background", "_bg"): 49,
+        ################### TEXT STYLES ####################
+        ("bold", "b"): 1,
+        ("dim", "d"): 2,
+        ("italic", "i"): 3,
+        ("underline", "u"): 4,
+        ("inverse", "invert", "in"): 7,
+        ("hidden", "hide", "h"): 8,
+        ("strikethrough", "s"): 9,
+        ("double-underline", "du"): 21,
+        ################## DEFAULT COLORS ##################
+        "black": 30,
+        "red": 31,
+        "green": 32,
+        "yellow": 33,
+        "blue": 34,
+        "magenta": 35,
+        "cyan": 36,
+        "white": 37,
+        ############## BRIGHT DEFAULT COLORS ###############
+        "br:black": 90,
+        "br:red": 91,
+        "br:green": 92,
+        "br:yellow": 93,
+        "br:blue": 94,
+        "br:magenta": 95,
+        "br:cyan": 96,
+        "br:white": 97,
+        ############ DEFAULT BACKGROUND COLORS #############
+        "bg:black": 40,
+        "bg:red": 41,
+        "bg:green": 42,
+        "bg:yellow": 43,
+        "bg:blue": 44,
+        "bg:magenta": 45,
+        "bg:cyan": 46,
+        "bg:white": 47,
+        ######### BRIGHT DEFAULT BACKGROUND COLORS #########
+        "bg:br:black": 100,
+        "bg:br:red": 101,
+        "bg:br:green": 102,
+        "bg:br:yellow": 103,
+        "bg:br:blue": 104,
+        "bg:br:magenta": 105,
+        "bg:br:cyan": 106,
+        "bg:br:white": 107,
+    }

xulbux-1.6.6/src/xulbux/xx_code.py

@@ -0,0 +1,100 @@
+from .xx_string import String
+from .xx_regex import Regex
+from .xx_data import Data
+
+import regex as _rx
+
+
+class Code:
+
+    @staticmethod
+    def add_indent(code: str, indent: int) -> str:
+        """Adds `indent` spaces at the beginning of each line."""
+        indented_lines = [" " * indent + line for line in code.splitlines()]
+        return "\n".join(indented_lines)
+
+    @staticmethod
+    def get_tab_spaces(code: str) -> int:
+        """Will try to get the amount of spaces used for indentation."""
+        code_lines = String.get_lines(code, remove_empty_lines=True)
+        indents = [len(line) - len(line.lstrip()) for line in code_lines]
+        non_zero_indents = [i for i in indents if i > 0]
+        return min(non_zero_indents) if non_zero_indents else 0
+
+    @staticmethod
+    def change_tab_size(code: str, new_tab_size: int, remove_empty_lines: bool = False) -> str:
+        """Replaces all tabs with `new_tab_size` spaces.\n
+        ----------------------------------------------------------------------------------
+        If `remove_empty_lines` is `True`, empty lines will be removed in the process."""
+        code_lines = String.get_lines(code, remove_empty_lines=True)
+        lines = code_lines if remove_empty_lines else String.get_lines(code)
+        tab_spaces = Code.get_tab_spaces(code)
+        if (tab_spaces == new_tab_size) or tab_spaces == 0:
+            if remove_empty_lines:
+                return "\n".join(code_lines)
+            return code
+        result = []
+        for line in lines:
+            stripped = line.lstrip()
+            indent_level = (len(line) - len(stripped)) // tab_spaces
+            new_indent = " " * (indent_level * new_tab_size)
+            result.append(new_indent + stripped)
+        return "\n".join(result)
+
+    @staticmethod
+    def get_func_calls(code: str) -> list:
+        """Will try to get all function calls and return them as a list."""
+        funcs = _rx.findall(r"(?i)" + Regex.func_call(), code)
+        nested_func_calls = []
+        for _, func_attrs in funcs:
+            nested_calls = _rx.findall(r"(?i)" + Regex.func_call(), func_attrs)
+            if nested_calls:
+                nested_func_calls.extend(nested_calls)
+        return Data.remove_duplicates(funcs + nested_func_calls)
+
+    @staticmethod
+    def is_js(code: str, funcs: list = ["__", "$t", "$lang"]) -> bool:
+        """Will check if the code is very likely to be JavaScript."""
+        funcs = "|".join(funcs)
+        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
+        )
+        return bool(js_pattern.fullmatch(code))

{xulbux-1.6.5 → xulbux-1.6.6}/src/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: