xulbux 1.6.9__py3-none-any.whl → 1.7.1__py3-none-any.whl

xulbux/__init__.py

@@ -1,8 +1,8 @@
-__version__ = "1.6.9"
+__version__ = "1.7.1"
 __author__ = "XulbuX"
 __email__ = "xulbux.real@gmail.com"
 __license__ = "MIT"
-__copyright__ = "Copyright (c) 2025 XulbuX"
+__copyright__ = "Copyright (c) 2024 XulbuX"
 __url__ = "https://github.com/XulbuX/PythonLibraryXulbuX"
 __description__ = "A library which includes a lot of really helpful functions."
 __all__ = [

xulbux/_cli_.py

@@ -7,11 +7,13 @@ 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": COLOR.ice,
-        "import": COLOR.red,
-        "class": COLOR.lavender,
-        "types": COLOR.lightblue,
+        "class": COLOR.tangerine,
+        "const": COLOR.red,
+        "func": COLOR.cyan,
+        "import": COLOR.neongreen,
+        "lib": COLOR.orange,
         "punctuators": COLOR.darkgray,
+        "code_border": COLOR.gray,
     }
     FormatCodes.print(
         rf"""  [_|b|#7075FF]               __  __
@@ -22,29 +24,20 @@ def help_command():
 
   [i|{COLOR.coral}]A TON OF COOL FUNCTIONS, YOU NEED![*]
 
-  [b|#75A2FF]Usage:[*]
-    [{color['punctuators']}]# GENERAL LIBRARY[*]
-    [{color['import']}]import [{color['lib']}]xulbux [{color['import']}]as [{color['lib']}]xx[*]
-    [{color['punctuators']}]# CUSTOM TYPES[*]
-    [{color['import']}]from [{color['lib']}]xulbux [{color['import']}]import [{color['lib']}]rgba[{color['punctuators']}], [{color['lib']}]hsla[{color['punctuators']}], [{color['lib']}]hexa[*]
-
-  [b|#75A2FF]Includes:[*]
-    [dim](•) CUSTOM TYPES:
-       [dim](•) [{color['class']}]rgba[{color['punctuators']}]/([i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]float[_|{color['punctuators']}])[*]
-       [dim](•) [{color['class']}]hsla[{color['punctuators']}]/([i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]float[_|{color['punctuators']}])[*]
-       [dim](•) [{color['class']}]hexa[{color['punctuators']}]/([i|{color['types']}]str[_|{color['punctuators']}]|[i|{color['types']}]int[_|{color['punctuators']}])[*]
-    [dim](•) CODE STRING OPERATIONS   [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Code[*]
-    [dim](•) WORKING WITH COLORS      [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Color[*]
-    [dim](•) CONSOLE LOG AND ACTIONS  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Console[*]
-    [dim](•) PATH OPERATIONS          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Path[*]
-    [dim](•) FILE OPERATIONS          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]File[*]
-    [dim](•) JSON FILE OPERATIONS     [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Json[*]
-    [dim](•) SYSTEM ACTIONS           [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]System[*]
-    [dim](•) MANAGE THE ENV PATH VAR  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]EnvPath[*]
-    [dim](•) EASY PRETTY PRINTING     [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]FormatCodes[*]
-    [dim](•) DATA OPERATIONS          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Data[*]
-    [dim](•) STRING OPERATIONS        [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]String[*]
-    [dim](•) REGEX PATTERN TEMPLATES  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Regex[*]
+  [b|#FCFCFF]Usage:[*]
+  [dim|{color['code_border']}](╭────────────────────────────────────────────────────╮)
+  [dim|{color['code_border']}](│) [{color['punctuators']}]# CONSTANTS[*]                                        [dim|{color['code_border']}](│)
+  [dim|{color['code_border']}](│) [{color['import']}]from [{color['lib']}]xulbux [{color['import']}]import [{color['const']}]COLOR[{color['punctuators']}], [{color['const']}]CHARS[{color['punctuators']}], [{color['const']}]ANSI[*]              [dim|{color['code_border']}](│)
+  [dim|{color['code_border']}](│) [{color['punctuators']}]# Classes[*]                                          [dim|{color['code_border']}](│)
+  [dim|{color['code_border']}](│) [{color['import']}]from [{color['lib']}]xulbux [{color['import']}]import [{color['class']}]Code[{color['punctuators']}], [{color['class']}]Color[{color['punctuators']}], [{color['class']}]Console[{color['punctuators']}], ...[*]       [dim|{color['code_border']}](│)
+  [dim|{color['code_border']}](│) [{color['punctuators']}]# types[*]                                            [dim|{color['code_border']}](│)
+  [dim|{color['code_border']}](│) [{color['import']}]from [{color['lib']}]xulbux [{color['import']}]import [{color['func']}]rgba[{color['punctuators']}], [{color['func']}]hsla[{color['punctuators']}], [{color['func']}]hexa[*]                [dim|{color['code_border']}](│)
+  [dim|{color['code_border']}](╰────────────────────────────────────────────────────╯)
+  [b|#FCFCFF]Documentation:[*]
+  [dim|{color['code_border']}](╭────────────────────────────────────────────────────╮)
+  [dim|{color['code_border']}](│) [#DADADD]For more information see the GitHub page.          [dim|{color['code_border']}](│)
+  [dim|{color['code_border']}](│) [u|#8085FF](https://github.com/XulbuX/PythonLibraryXulbuX/wiki) [dim|{color['code_border']}](│)
+  [dim|{color['code_border']}](╰────────────────────────────────────────────────────╯)
   [_]
   [dim](Press any key to exit...)
   """,

xulbux/_consts_.py

@@ -26,6 +26,7 @@ class COLOR:
     yellow = "#FFD260"
     lime = "#C9F16E"
     green = "#7EE787"
+    neongreen = "#4CFF85"
     teal = "#50EAAF"
     cyan = "#3EDEE6"
     ice = "#77DBEF"

xulbux/xx_code.py

@@ -50,7 +50,7 @@ class Code:
             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)
+        return list(Data.remove_duplicates(funcs + nested_func_calls))
 
     @staticmethod
     def is_js(code: str, funcs: list = ["__", "$t", "$lang"]) -> bool:

xulbux/xx_color.py

@@ -33,10 +33,40 @@ The `Color` class, which contains all sorts of different color-related methods:
 
 from .xx_regex import Regex
 
-from typing import Optional
+from typing import Annotated, TypeAlias, Iterator, Optional, Literal, Union, Any, cast
 import re as _re
 
 
+Int_0_100 = Annotated[int, "An integer value between 0 and 100, inclusive."]
+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],
+    list[Int_0_255],
+    list[Union[Int_0_255, Float_0_1]],
+    dict[str, Union[int, float]],
+    "rgba",
+    str,
+]
+Hsla: TypeAlias = Union[
+    tuple[Int_0_360, Int_0_100, Int_0_100],
+    tuple[Int_0_360, Int_0_100, Int_0_100, Float_0_1],
+    list[Union[Int_0_360, Int_0_100]],
+    list[Union[Int_0_360, Int_0_100, Float_0_1]],
+    dict[str, Union[int, float]],
+    "hsla",
+    str,
+]
+Hexa: TypeAlias = Union[str, int, "hexa"]
+
+
 class rgba:
     """An RGB/RGBA color: is a tuple of 3 integers, representing the red (`0`-`255`), green (`0`-`255`), and blue (`0`-`255`).\n
     Also includes an optional 4th param, which is a float, that represents the alpha channel (`0.0`-`1.0`).\n
@@ -60,7 +90,11 @@ class rgba:
     - `with_alpha(alpha)` to create a new color with different alpha
     - `complementary()` to get the complementary color"""
 
-    def __init__(self, r: int, g: int, b: int, a: float = None, _validate: bool = True):
+    def __init__(self, r: int, g: int, b: int, a: Optional[float] = None, _validate: bool = True):
+        self.r: int
+        self.g: int
+        self.b: int
+        self.a: Optional[float]
         if not _validate:
             self.r, self.g, self.b, self.a = r, g, b, a
             return
@@ -79,13 +113,10 @@ class rgba:
     def __len__(self) -> int:
         return 3 if self.a is None else 4
 
-    def __iter__(self) -> iter:
+    def __iter__(self) -> Iterator:
         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:
+    def __getitem__(self, index: int) -> int | float:
         return ((self.r, self.g, self.b) + (() if self.a is None else (self.a, )))[index]
 
     def __repr__(self) -> str:
@@ -94,7 +125,7 @@ class rgba:
     def __str__(self) -> str:
         return f'({self.r}, {self.g}, {self.b}{"" if self.a is None else f", {self.a}"})'
 
-    def __eq__(self, other: "rgba") -> bool:
+    def __eq__(self, other: "rgba") -> bool:  # type: ignore[override]
         if not isinstance(other, rgba):
             return False
         return (self.r, self.g, self.b, self.a) == (other.r, other.g, other.b, other.a)
@@ -109,7 +140,7 @@ class rgba:
 
     def to_hsla(self) -> "hsla":
         """Returns the color as a `hsla()` color"""
-        return hsla(*self._rgb_to_hsl(self.r, self.g, self.b), self.a, _validate=False)
+        return hsla(*self._rgb_to_hsl(self.r, self.g, self.b), self.a, _validate=False)  # type: ignore[positional-arguments]
 
     def to_hexa(self) -> "hexa":
         """Returns the color as a `hexa()` color"""
@@ -147,11 +178,11 @@ class rgba:
     def invert(self, invert_alpha: bool = False) -> "rgba":
         """Inverts the color by rotating hue by 180 degrees and inverting lightness"""
         self.r, self.g, self.b = 255 - self.r, 255 - self.g, 255 - self.b
-        if invert_alpha:
+        if invert_alpha and self.a is not None:
             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:
@@ -159,10 +190,10 @@ class rgba:
         - `"wcag3"` Draft WCAG 3.0 standard with improved coefficients
         - `"simple"` Simple arithmetic mean (less accurate)
         - `"bt601"` ITU-R BT.601 standard (older TV standard)"""
-        self.r = self.g = self.b = Color.luminance(self.r, self.g, self.b, method=method)
+        self.r = self.g = self.b = int(Color.luminance(self.r, self.g, self.b, method=method))
         return rgba(self.r, self.g, self.b, self.a, _validate=False)
 
-    def blend(self, other: "rgba", ratio: float = 0.5, additive_alpha: bool = False) -> "rgba":
+    def blend(self, other: Rgba, ratio: float = 0.5, additive_alpha: bool = False) -> "rgba":
         """Blends the current color with another color using the specified ratio (`0.0`-`1.0`):
         - if `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (2:0 mixture)
         - if `ratio` is `0.5` it means 50% of both colors (1:1 mixture)
@@ -171,7 +202,7 @@ class rgba:
             raise ValueError("'ratio' must be a float/int in [0.0, 1.0]")
         elif not isinstance(other, rgba):
             if Color.is_valid_rgba(other):
-                other = rgba(*other, _validate=False)
+                other = Color.to_rgba(other)
             else:
                 raise TypeError("'other' must be a valid RGBA color")
         ratio *= 2
@@ -217,20 +248,20 @@ class rgba:
         return self.to_hsla().complementary().to_rgba()
 
     def _rgb_to_hsl(self, r: int, g: int, b: int) -> tuple:
-        r, g, b = r / 255.0, g / 255.0, b / 255.0
-        max_c, min_c = max(r, g, b), min(r, g, b)
+        _r, _g, _b = r / 255.0, g / 255.0, b / 255.0
+        max_c, min_c = max(_r, _g, _b), min(_r, _g, _b)
         l = (max_c + min_c) / 2
         if max_c == min_c:
             h = s = 0
         else:
             delta = max_c - min_c
             s = delta / (1 - abs(2 * l - 1))
-            if max_c == r:
-                h = ((g - b) / delta) % 6
-            elif max_c == g:
-                h = ((b - r) / delta) + 2
+            if max_c == _r:
+                h = ((_g - _b) / delta) % 6
+            elif max_c == _g:
+                h = ((_b - _r) / delta) + 2
             else:
-                h = ((r - g) / delta) + 4
+                h = ((_r - _g) / delta) + 4
             h /= 6
         return int(round(h * 360)), int(round(s * 100)), int(round(l * 100))
 
@@ -258,7 +289,11 @@ class hsla:
     - `with_alpha(alpha)` to create a new color with different alpha
     - `complementary()` to get the complementary color"""
 
-    def __init__(self, h: int, s: int, l: int, a: float = None, _validate: bool = True):
+    def __init__(self, h: int, s: int, l: int, a: Optional[float] = None, _validate: bool = True):
+        self.h: int
+        self.s: int
+        self.l: int
+        self.a: Optional[float]
         if not _validate:
             self.h, self.s, self.l, self.a = h, s, l, a
             return
@@ -277,13 +312,10 @@ class hsla:
     def __len__(self) -> int:
         return 3 if self.a is None else 4
 
-    def __iter__(self) -> iter:
+    def __iter__(self) -> Iterator:
         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:
+    def __getitem__(self, index: int) -> int | float:
         return ((self.h, self.s, self.l) + (() if self.a is None else (self.a, )))[index]
 
     def __repr__(self) -> str:
@@ -292,7 +324,7 @@ class hsla:
     def __str__(self) -> str:
         return f'({self.h}°, {self.s}%, {self.l}%{"" if self.a is None else f", {self.a}"})'
 
-    def __eq__(self, other: "hsla") -> bool:
+    def __eq__(self, other: "hsla") -> bool:  # type: ignore[override]
         if not isinstance(other, hsla):
             return False
         return (self.h, self.s, self.l, self.a) == (other.h, other.s, other.l, other.a)
@@ -307,7 +339,7 @@ class hsla:
 
     def to_rgba(self) -> "rgba":
         """Returns the color as a `rgba()` color"""
-        return rgba(*self._hsl_to_rgb(self.h, self.s, self.l), self.a, _validate=False)
+        return rgba(*self._hsl_to_rgb(self.h, self.s, self.l), self.a, _validate=False)  # type: ignore[positional-arguments]
 
     def to_hexa(self) -> "hexa":
         """Returns the color as a `hexa()` color"""
@@ -355,11 +387,11 @@ class hsla:
         """Inverts the color by rotating hue by 180 degrees and inverting lightness"""
         self.h = (self.h + 180) % 360
         self.l = 100 - self.l
-        if invert_alpha:
+        if invert_alpha and self.a is not None:
             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:
@@ -367,11 +399,11 @@ class hsla:
         - `"wcag3"` Draft WCAG 3.0 standard with improved coefficients
         - `"simple"` Simple arithmetic mean (less accurate)
         - `"bt601"` ITU-R BT.601 standard (older TV standard)"""
-        l = Color.luminance(*self._hsl_to_rgb(self.h, self.s, self.l), method=method)
+        l = int(Color.luminance(*self._hsl_to_rgb(self.h, self.s, self.l), method=method))
         self.h, self.s, self.l, _ = rgba(l, l, l, _validate=False).to_hsla().values()
         return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
-    def blend(self, other: "hsla", ratio: float = 0.5, additive_alpha: bool = False) -> "rgba":
+    def blend(self, other: Hsla, ratio: float = 0.5, additive_alpha: bool = False) -> "hsla":
         """Blends the current color with another color using the specified ratio (`0.0`-`1.0`):
         - if `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (2:0 mixture)
         - if `ratio` is `0.5` it means 50% of both colors (1:1 mixture)
@@ -406,9 +438,9 @@ class hsla:
         return hsla((self.h + 180) % 360, self.s, self.l, self.a, _validate=False)
 
     def _hsl_to_rgb(self, h: int, s: int, l: int) -> tuple:
-        h, s, l = h / 360, s / 100, l / 100
-        if s == 0:
-            r = g = b = int(l * 255)
+        _h, _s, _l = h / 360, s / 100, l / 100
+        if _s == 0:
+            r = g = b = int(_l * 255)
         else:
 
             def hue_to_rgb(p, q, t):
@@ -424,11 +456,11 @@ class hsla:
                     return p + (q - p) * (2 / 3 - t) * 6
                 return p
 
-            q = l * (1 + s) if l < 0.5 else l + s - l * s
-            p = 2 * l - q
-            r = int(round(hue_to_rgb(p, q, h + 1 / 3) * 255))
-            g = int(round(hue_to_rgb(p, q, h) * 255))
-            b = int(round(hue_to_rgb(p, q, h - 1 / 3) * 255))
+            q = _l * (1 + _s) if _l < 0.5 else _l + _s - _l * _s
+            p = 2 * _l - q
+            r = int(round(hue_to_rgb(p, q, _h + 1 / 3) * 255))
+            g = int(round(hue_to_rgb(p, q, _h) * 255))
+            b = int(round(hue_to_rgb(p, q, _h - 1 / 3) * 255))
         return r, g, b
 
 
@@ -455,9 +487,20 @@ class hexa:
     - `with_alpha(alpha)` to create a new color with different alpha
     - `complementary()` to get the complementary color"""
 
-    def __init__(self, color: str | int, _r: int = None, _g: int = None, _b: int = None, _a: float = None):
+    def __init__(
+        self,
+        color: str | int,
+        _r: Optional[int] = None,
+        _g: Optional[int] = None,
+        _b: Optional[int] = None,
+        _a: Optional[float] = None,
+    ):
+        self.r: int
+        self.g: int
+        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
+            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")
@@ -504,14 +547,11 @@ class hexa:
     def __len__(self) -> int:
         return 3 if self.a is None else 4
 
-    def __iter__(self) -> iter:
+    def __iter__(self) -> Iterator:
         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:
+    def __getitem__(self, index: int) -> str | 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]
 
@@ -521,7 +561,7 @@ class hexa:
     def __str__(self) -> str:
         return f'#{self.r:02X}{self.g:02X}{self.b:02X}{"" if self.a is None else f"{int(self.a * 255):02X}"}'
 
-    def __eq__(self, other: "hexa") -> bool:
+    def __eq__(self, other: "hexa") -> bool:  # type: ignore[override]
         """Returns whether the other color is equal to this one."""
         if not isinstance(other, hexa):
             return False
@@ -588,11 +628,11 @@ class hexa:
     def invert(self, invert_alpha: bool = False) -> "hexa":
         """Inverts the color by rotating hue by 180 degrees and inverting lightness"""
         self.r, self.g, self.b, self.a = self.to_rgba(False).invert().values()
-        if invert_alpha:
+        if invert_alpha and self.a is not None:
             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:
@@ -600,10 +640,10 @@ class hexa:
         - `"wcag3"` Draft WCAG 3.0 standard with improved coefficients
         - `"simple"` Simple arithmetic mean (less accurate)
         - `"bt601"` ITU-R BT.601 standard (older TV standard)"""
-        self.r = self.g = self.b = Color.luminance(self.r, self.g, self.b, method=method)
+        self.r = self.g = self.b = int(Color.luminance(self.r, self.g, self.b, method=method))
         return hexa("", self.r, self.g, self.b, self.a)
 
-    def blend(self, other: "hexa", ratio: float = 0.5, additive_alpha: bool = False) -> "rgba":
+    def blend(self, other: Hexa, ratio: float = 0.5, additive_alpha: bool = False) -> "hexa":
         """Blends the current color with another color using the specified ratio (`0.0`-`1.0`):
         - if `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (2:0 mixture)
         - if `ratio` is `0.5` it means 50% of both colors (1:1 mixture)
@@ -641,7 +681,7 @@ class hexa:
 class Color:
 
     @staticmethod
-    def is_valid_rgba(color: str | list | tuple | dict, allow_alpha: bool = True) -> bool:
+    def is_valid_rgba(color: AnyRgba, allow_alpha: bool = True) -> bool:
         try:
             if isinstance(color, rgba):
                 return True
@@ -672,7 +712,7 @@ class Color:
             return False
 
     @staticmethod
-    def is_valid_hsla(color: str | list | tuple | dict, allow_alpha: bool = True) -> bool:
+    def is_valid_hsla(color: AnyHsla, allow_alpha: bool = True) -> bool:
         try:
             if isinstance(color, hsla):
                 return True
@@ -698,11 +738,16 @@ 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: str | int, allow_alpha: bool = True, get_prefix: bool = False) -> bool | tuple[bool, str]:
+    def is_valid_hexa(
+        color: AnyHexa,
+        allow_alpha: bool = True,
+        get_prefix: bool = False,
+    ) -> bool | tuple[bool, Optional[Literal['#', '0x']]]:
         try:
             if isinstance(color, hexa):
                 return (True, "#") if get_prefix else True
@@ -714,18 +759,19 @@ 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: str | list | tuple | dict, 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)
             or Color.is_valid_hexa(color, allow_alpha)
         )
 
     @staticmethod
-    def has_alpha(color: rgba | hsla | hexa) -> bool:
+    def has_alpha(color: Rgba | Hsla | Hexa) -> bool:
         """Check if the given color has an alpha channel.\n
         ---------------------------------------------------------------------------
         Input a RGBA, HSLA or HEXA color as `color`.
@@ -747,42 +793,42 @@ class Color:
         return False
 
     @staticmethod
-    def to_rgba(color: hsla | hexa) -> rgba:
+    def to_rgba(color: Rgba | Hsla | Hexa) -> rgba:
         """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):
-            return hsla(*color, _validate=False).to_rgba()
+            return hsla(*color, _validate=False).to_rgba()  # type: ignore[not-iterable]
         elif Color.is_valid_hexa(color):
-            return hexa(color).to_rgba()
+            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))
+            return color if isinstance(color, rgba) else (rgba(*color, _validate=False))  # type: ignore[not-iterable]
         raise ValueError(f"Invalid color format '{color}'")
 
     @staticmethod
-    def to_hsla(color: rgba | hexa) -> hsla:
+    def to_hsla(color: Rgba | Hsla | Hexa) -> hsla:
         """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):
-            return rgba(*color, _validate=False).to_hsla()
+            return rgba(*color, _validate=False).to_hsla()  # type: ignore[not-iterable]
         elif Color.is_valid_hexa(color):
-            return hexa(color).to_hsla()
+            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))
+            return color if isinstance(color, hsla) else (hsla(*color, _validate=False))  # type: ignore[not-iterable]
         raise ValueError(f"Invalid color format '{color}'")
 
     @staticmethod
-    def to_hexa(color: rgba | hsla) -> hexa:
+    def to_hexa(color: Rgba | Hsla | Hexa) -> hexa:
         """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):
-            return rgba(*color, _validate=False).to_hexa()
+            return rgba(*color, _validate=False).to_hexa()  # type: ignore[not-iterable]
         elif Color.is_valid_hsla(color):
-            return hsla(*color, _validate=False).to_hexa()
+            return hsla(*color, _validate=False).to_hexa()  # type: ignore[not-iterable]
         elif Color.is_valid_hexa(color):
-            return color if isinstance(color, hexa) else hexa(color)
+            return color if isinstance(color, hexa) else hexa(cast(str | int, color))
         raise ValueError(f"Invalid color format '{color}'")
 
     @staticmethod
@@ -821,7 +867,7 @@ class Color:
         r: int,
         g: int,
         b: int,
-        a: float = None,
+        a: Optional[float] = None,
         preserve_original: bool = False,
     ) -> int:
         """Convert RGBA channels to a HEXA integer (alpha is optional).\n
@@ -879,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: 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:
@@ -891,21 +943,21 @@ class Color:
         - `"wcag3"` Draft WCAG 3.0 standard with improved coefficients
         - `"simple"` Simple arithmetic mean (less accurate)
         - `"bt601"` ITU-R BT.601 standard (older TV standard)"""
-        r, g, b = r / 255.0, g / 255.0, b / 255.0
+        _r, _g, _b = r / 255.0, g / 255.0, b / 255.0
         if method == "simple":
-            luminance = (r + g + b) / 3
+            luminance = (_r + _g + _b) / 3
         elif method == "bt601":
-            luminance = 0.299 * r + 0.587 * g + 0.114 * b
+            luminance = 0.299 * _r + 0.587 * _g + 0.114 * _b
         elif method == "wcag3":
-            r = Color._linearize_srgb(r)
-            g = Color._linearize_srgb(g)
-            b = Color._linearize_srgb(b)
-            luminance = 0.2126729 * r + 0.7151522 * g + 0.0721750 * b
+            _r = Color._linearize_srgb(_r)
+            _g = Color._linearize_srgb(_g)
+            _b = Color._linearize_srgb(_b)
+            luminance = 0.2126729 * _r + 0.7151522 * _g + 0.0721750 * _b
         else:
-            r = Color._linearize_srgb(r)
-            g = Color._linearize_srgb(g)
-            b = Color._linearize_srgb(b)
-            luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b
+            _r = Color._linearize_srgb(_r)
+            _g = Color._linearize_srgb(_g)
+            _b = Color._linearize_srgb(_b)
+            luminance = 0.2126 * _r + 0.7152 * _g + 0.0722 * _b
         if output_type == int:
             return round(luminance * 100)
         elif output_type == float:
@@ -922,15 +974,16 @@ class Color:
             return ((c + 0.055) / 1.055)**2.4
 
     @staticmethod
-    def text_color_for_on_bg(text_bg_color: rgba | hexa) -> rgba | hexa:
+    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)
         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
+        return (((0xFFFFFF if was_int else 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:
+    def adjust_lightness(color: Rgba | Hexa, lightness_change: float) -> rgba | hexa:
         """In- or decrease the lightness of the input color.\n
         -----------------------------------------------------------------------------------------------------
         - color (rgba|hexa): HEX or RGBA color
@@ -938,18 +991,13 @@ class Color:
         -----------------------------------------------------------------------------------------------------
         returns (rgba|hexa): the adjusted color in the format of the input color"""
         was_hexa = Color.is_valid_hexa(color)
-        color = Color.to_hsla(color)
-        h, s, l, a = (
-            color[0],
-            color[1],
-            color[2],
-            color[3] if Color.has_alpha(color) else None,
-        )
+        _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 | 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
@@ -957,12 +1005,7 @@ class Color:
         -----------------------------------------------------------------------------------------------------------
         returns (rgba|hexa): the adjusted color in the format of the input color"""
         was_hexa = Color.is_valid_hexa(color)
-        color = Color.to_hsla(color)
-        h, s, l, a = (
-            color[0],
-            color[1],
-            color[2],
-            color[3] if Color.has_alpha(color) else None,
-        )
+        _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()