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

xulbux/xx_color.py

@@ -8,7 +8,7 @@
 `hexa`:
     A HEX color: is a string in the format `RGB`, `RGBA`, `RRGGBB` or `RRGGBBAA` (where `R` `G` `B` `A` are hexadecimal digits).
 
----------------------------------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------------------------------
 The `Color` class, which contains all sorts of different color-related methods:
 - validate colors:
     - is valid rgba
@@ -37,9 +37,9 @@ import re as _re
 
 
 class rgba:
-    """An RGB/RGBA color: is a tuple of 3 integers, representing the red (`0`-`255`), green (`0`-`255`), and blue (`0`-`255`).<br>
+    """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
-    -------------------------------------------------------------------------------------------------------------------------------
+    -----------------------------------------------------------------------------------------------------------------------------
     Includes methods:
     - `to_hsla()` to convert to HSL color
     - `to_hexa()` to convert to HEX color
@@ -59,7 +59,10 @@ 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):
+    def __init__(self, r: int, g: int, b: int, a: float = None, _validate: bool = True):
+        if not _validate:
+            self.r, self.g, self.b, self.a = r, g, b, a
+            return
         if any(isinstance(x, rgba) for x in (r, g, b)):
             raise ValueError("Color is already a rgba() color")
         elif not all(isinstance(x, int) and 0 <= x <= 255 for x in (r, g, b)):
@@ -68,27 +71,27 @@ class rgba:
                 (r, g, b),
             )
         elif a is not None and not (isinstance(a, (int, float)) and 0 <= a <= 1):
-            raise ValueError("Alpha channel must be a float/int in [0.0, 1.0]: got", a)
+            raise ValueError(f"Alpha channel must be a float/int in [0.0, 1.0]: got '{a}'")
         self.r, self.g, self.b = r, g, b
-        self.a = (1.0 if a > 1.0 else float(a)) if a else None
+        self.a = None if a is None else (1.0 if a > 1.0 else float(a))
 
     def __len__(self):
-        return 4 if self.a else 3
+        return 3 if self.a is None else 4
 
     def __iter__(self):
-        return iter((self.r, self.g, self.b) + ((self.a,) if self.a else ()))
+        return iter((self.r, self.g, self.b) + (() if self.a is None else (self.a,)))
 
     def __dict__(self):
         return self.dict()
 
     def __getitem__(self, index):
-        return ((self.r, self.g, self.b) + ((self.a,) if self.a else ()))[index]
+        return ((self.r, self.g, self.b) + (() if self.a is None else (self.a,)))[index]
 
     def __repr__(self):
-        return f'rgba({self.r}, {self.g}, {self.b}{f", {self.a}" if self.a else ""})'
+        return f'rgba({self.r}, {self.g}, {self.b}{"" if self.a is None else f", {self.a}"})'
 
     def __str__(self):
-        return f'({self.r}, {self.g}, {self.b}{f", {self.a}" if self.a else ""})'
+        return f'({self.r}, {self.g}, {self.b}{"" if self.a is None else f", {self.a}"})'
 
     def __eq__(self, other):
         if not isinstance(other, rgba):
@@ -102,7 +105,7 @@ class rgba:
 
     def dict(self) -> dict:
         """Returns the color components as a dictionary with keys `'r'`, `'g'`, `'b'` and optionally `'a'`"""
-        return dict(r=self.r, g=self.g, b=self.b, a=self.a) if self.a else dict(r=self.r, g=self.g, b=self.b)
+        return dict(r=self.r, g=self.g, b=self.b) if self.a is None else dict(r=self.r, g=self.g, b=self.b, a=self.a)
 
     def values(self) -> tuple:
         """Returns the color components as separate values `r, g, b, a`"""
@@ -110,11 +113,11 @@ 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)
+        return hsla(*self._rgb_to_hsl(self.r, self.g, self.b), self.a, _validate=False)
 
     def to_hexa(self) -> "hexa":
         """Returns the color as a `hexa()` color"""
-        return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
+        return hexa("", self.r, self.g, self.b, self.a)
 
     def has_alpha(self) -> bool:
         """Returns `True` if the color has an alpha channel and `False` otherwise"""
@@ -123,50 +126,50 @@ class rgba:
     def lighten(self, amount: float) -> "rgba":
         """Increases the colors lightness by the specified amount (`0.0`-`1.0`)"""
         self.r, self.g, self.b, self.a = self.to_hsla().lighten(amount).to_rgba().values()
-        return rgba(self.r, self.g, self.b, self.a)
+        return rgba(self.r, self.g, self.b, self.a, _validate=False)
 
     def darken(self, amount: float) -> "rgba":
         """Decreases the colors lightness by the specified amount (`0.0`-`1.0`)"""
         self.r, self.g, self.b, self.a = self.to_hsla().darken(amount).to_rgba().values()
-        return rgba(self.r, self.g, self.b, self.a)
+        return rgba(self.r, self.g, self.b, self.a, _validate=False)
 
     def saturate(self, amount: float) -> "rgba":
         """Increases the colors saturation by the specified amount (`0.0`-`1.0`)"""
         self.r, self.g, self.b, self.a = self.to_hsla().saturate(amount).to_rgba().values()
-        return rgba(self.r, self.g, self.b, self.a)
+        return rgba(self.r, self.g, self.b, self.a, _validate=False)
 
     def desaturate(self, amount: float) -> "rgba":
         """Decreases the colors saturation by the specified amount (`0.0`-`1.0`)"""
         self.r, self.g, self.b, self.a = self.to_hsla().desaturate(amount).to_rgba().values()
-        return rgba(self.r, self.g, self.b, self.a)
+        return rgba(self.r, self.g, self.b, self.a, _validate=False)
 
     def rotate(self, degrees: int) -> "rgba":
         """Rotates the colors hue by the specified number of degrees"""
         self.r, self.g, self.b, self.a = self.to_hsla().rotate(degrees).to_rgba().values()
-        return rgba(self.r, self.g, self.b, self.a)
+        return rgba(self.r, self.g, self.b, self.a, _validate=False)
 
     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:
             self.a = 1 - self.a
-        return rgba(self.r, self.g, self.b, self.a)
+        return rgba(self.r, self.g, self.b, self.a, _validate=False)
 
     def grayscale(self) -> "rgba":
         """Converts the color to grayscale using the luminance formula"""
         self.r = self.g = self.b = Color.luminance(self.r, self.g, self.b)
-        return rgba(self.r, self.g, self.b, self.a)
+        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":
-        """Blends the current color with another color using the specified ratio (`0.0`-`1.0`):<br>
-        If `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (2:0 mixture)<br>
-        If `ratio` is `0.5` it means 50% of both colors (1:1 mixture)<br>
-        If `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:2 mixture)"""
+        """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)
+        - if `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:2 mixture)"""
         if not (isinstance(ratio, (int, float)) and 0 <= ratio <= 1):
             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)
+                other = rgba(*other, _validate=False)
             else:
                 raise TypeError("'other' must be a valid RGBA color")
         ratio *= 2
@@ -175,7 +178,7 @@ class rgba:
         self.b = max(0, min(255, int(round((self.b * (2 - ratio)) + (other.b * ratio)))))
         none_alpha = self.a is None and (len(other) <= 3 or other[3] is None)
         if not none_alpha:
-            self_a = self.a if self.a is not None else 1
+            self_a = 1 if self.a is None else self.a
             other_a = (other[3] if other[3] is not None else 1) if len(other) > 3 else 1
             if additive_alpha:
                 self.a = max(0, min(1, (self_a * (2 - ratio)) + (other_a * ratio)))
@@ -189,11 +192,11 @@ class rgba:
                 )
         else:
             self.a = None
-        return rgba(self.r, self.g, self.b, None if none_alpha else self.a)
+        return rgba(self.r, self.g, self.b, None if none_alpha else self.a, _validate=False)
 
     def is_dark(self) -> bool:
         """Returns `True` if the color is considered dark (`lightness < 50%`)"""
-        return (0.299 * self.r + 0.587 * self.g + 0.114 * self.b) < 128
+        return self.to_hsla().is_dark()
 
     def is_light(self) -> bool:
         """Returns `True` if the color is considered light (`lightness >= 50%`)"""
@@ -211,7 +214,7 @@ class rgba:
         """Returns a new color with the specified alpha value"""
         if not (isinstance(alpha, (int, float)) and 0 <= alpha <= 1):
             raise ValueError("'alpha' must be a float/int in [0.0, 1.0]")
-        return rgba(self.r, self.g, self.b, alpha)
+        return rgba(self.r, self.g, self.b, alpha, _validate=False)
 
     def complementary(self) -> "rgba":
         """Returns the complementary color (180 degrees on the color wheel)"""
@@ -237,9 +240,9 @@ class rgba:
 
 
 class hsla:
-    """A HSL/HSLA color: is a tuple of 3 integers, representing hue (`0`-`360`), saturation (`0`-`100`), and lightness (`0`-`100`).<br>
+    """A HSL/HSLA color: is a tuple of 3 integers, representing hue (`0`-`360`), saturation (`0`-`100`), and lightness (`0`-`100`).\n
     Also includes an optional 4th param, which is a float, that represents the alpha channel (`0.0`-`1.0`).\n
-    ------------------------------------------------------------------------------------------------------------------------------------
+    ----------------------------------------------------------------------------------------------------------------------------------
     Includes methods:
     - `to_rgba()` to convert to RGB color
     - `to_hexa()` to convert to HEX color
@@ -259,7 +262,10 @@ 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):
+    def __init__(self, h: int, s: int, l: int, a: float = None, _validate: bool = True):
+        if not _validate:
+            self.h, self.s, self.l, self.a = h, s, l, a
+            return
         if any(isinstance(x, hsla) for x in (h, s, l)):
             raise ValueError("Color is already a hsla() color")
         elif not (isinstance(h, int) and (0 <= h <= 360) and all(isinstance(x, int) and (0 <= x <= 100) for x in (s, l))):
@@ -268,27 +274,27 @@ class hsla:
                 (h, s, l),
             )
         elif a is not None and (not isinstance(a, (int, float)) or not 0 <= a <= 1):
-            raise ValueError("Alpha channel must be a float/int in [0.0, 1.0]: got", a)
+            raise ValueError(f"Alpha channel must be a float/int in [0.0, 1.0]: got '{a}'")
         self.h, self.s, self.l = h, s, l
-        self.a = (1.0 if a > 1.0 else float(a)) if a else None
+        self.a = None if a is None else (1.0 if a > 1.0 else float(a))
 
     def __len__(self):
-        return 4 if self.a else 3
+        return 3 if self.a is None else 4
 
     def __iter__(self):
-        return iter((self.h, self.s, self.l) + ((self.a,) if self.a else ()))
+        return iter((self.h, self.s, self.l) + (() if self.a is None else (self.a,)))
 
     def __dict__(self):
         return self.dict()
 
     def __getitem__(self, index):
-        return ((self.h, self.s, self.l) + ((self.a,) if self.a else ()))[index]
+        return ((self.h, self.s, self.l) + (() if self.a is None else (self.a,)))[index]
 
     def __repr__(self):
-        return f'hsla({self.h}, {self.s}, {self.l}{f", {self.a}" if self.a else ""})'
+        return f'hsla({self.h}, {self.s}, {self.l}{"" if self.a is None else f", {self.a}"})'
 
     def __str__(self):
-        return f'({self.h}, {self.s}, {self.l}{f", {self.a}" if self.a else ""})'
+        return f'({self.h}, {self.s}, {self.l}{"" if self.a is None else f", {self.a}"})'
 
     def __eq__(self, other):
         if not isinstance(other, hsla):
@@ -302,7 +308,7 @@ class hsla:
 
     def dict(self) -> dict:
         """Returns the color components as a dictionary with keys `'h'`, `'s'`, `'l'` and optionally `'a'`"""
-        return dict(h=self.h, s=self.s, l=self.l, a=self.a) if self.a else dict(h=self.h, s=self.s, l=self.l)
+        return dict(h=self.h, s=self.s, l=self.l) if self.a is None else dict(h=self.h, s=self.s, l=self.l, a=self.a)
 
     def values(self) -> tuple:
         """Returns the color components as separate values `h, s, l, a`"""
@@ -310,12 +316,12 @@ 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)
+        return rgba(*self._hsl_to_rgb(self.h, self.s, self.l), self.a, _validate=False)
 
     def to_hexa(self) -> "hexa":
         """Returns the color as a `hexa()` color"""
         r, g, b = self._hsl_to_rgb(self.h, self.s, self.l)
-        return hexa(f'#{r:02X}{g:02X}{b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
+        return hexa("", r, g, b, self.a)
 
     def has_alpha(self) -> bool:
         """Returns `True` if the color has an alpha channel and `False` otherwise"""
@@ -326,33 +332,33 @@ class hsla:
         if not (isinstance(amount, (int, float)) and 0 <= amount <= 1):
             raise ValueError("'amount' must be a float/int in [0.0, 1.0]")
         self.l = int(min(100, self.l + (100 - self.l) * amount))
-        return hsla(self.h, self.s, self.l, self.a)
+        return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
     def darken(self, amount: float) -> "hsla":
         """Decreases the colors lightness by the specified amount (`0.0`-`1.0`)"""
         if not (isinstance(amount, (int, float)) and 0 <= amount <= 1):
             raise ValueError("'amount' must be a float/int in [0.0, 1.0]")
         self.l = int(max(0, self.l * (1 - amount)))
-        return hsla(self.h, self.s, self.l, self.a)
+        return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
     def saturate(self, amount: float) -> "hsla":
         """Increases the colors saturation by the specified amount (`0.0`-`1.0`)"""
         if not (isinstance(amount, (int, float)) and 0 <= amount <= 1):
             raise ValueError("'amount' must be a float/int in [0.0, 1.0]")
         self.s = int(min(100, self.s + (100 - self.s) * amount))
-        return hsla(self.h, self.s, self.l, self.a)
+        return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
     def desaturate(self, amount: float) -> "hsla":
         """Decreases the colors saturation by the specified amount (`0.0`-`1.0`)"""
         if not (isinstance(amount, (int, float)) and 0 <= amount <= 1):
             raise ValueError("'amount' must be a float/int in [0.0, 1.0]")
         self.s = int(max(0, self.s * (1 - amount)))
-        return hsla(self.h, self.s, self.l, self.a)
+        return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
     def rotate(self, degrees: int) -> "hsla":
         """Rotates the colors hue by the specified number of degrees"""
         self.h = (self.h + degrees) % 360
-        return hsla(self.h, self.s, self.l, self.a)
+        return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
     def invert(self, invert_alpha: bool = False) -> "hsla":
         """Inverts the color by rotating hue by 180 degrees and inverting lightness"""
@@ -360,21 +366,21 @@ class hsla:
         self.l = 100 - self.l
         if invert_alpha:
             self.a = 1 - self.a
-        return hsla(self.h, self.s, self.l, self.a)
+        return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
     def grayscale(self) -> "hsla":
         """Converts the color to grayscale using the luminance formula"""
         l = Color.luminance(*self._hsl_to_rgb(self.h, self.s, self.l))
-        self.h, self.s, self.l, _ = rgba(l, l, l).to_hsla().values()
-        return hsla(self.h, self.s, self.l, self.a)
+        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":
-        """Blends the current color with another color using the specified ratio (`0.0`-`1.0`):<br>
-        If `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (2:0 mixture)<br>
-        If `ratio` is `0.5` it means 50% of both colors (1:1 mixture)<br>
-        If `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:2 mixture)"""
+        """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)
+        - if `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:2 mixture)"""
         self.h, self.s, self.l, self.a = self.to_rgba().blend(Color.to_rgba(other), ratio, additive_alpha).to_hsla().values()
-        return hsla(self.h, self.s, self.l, self.a)
+        return hsla(self.h, self.s, self.l, self.a, _validate=False)
 
     def is_dark(self) -> bool:
         """Returns `True` if the color is considered dark (`lightness < 50%`)"""
@@ -396,11 +402,11 @@ class hsla:
         """Returns a new color with the specified alpha value"""
         if not (isinstance(alpha, (int, float)) and 0 <= alpha <= 1):
             raise ValueError("'alpha' must be a float/int in [0.0, 1.0]")
-        return hsla(self.h, self.s, self.l, alpha)
+        return hsla(self.h, self.s, self.l, alpha, _validate=False)
 
     def complementary(self) -> "hsla":
         """Returns the complementary color (180 degrees on the color wheel)"""
-        return hsla((self.h + 180) % 360, self.s, self.l, self.a)
+        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
@@ -432,7 +438,7 @@ class hsla:
 class hexa:
     """A HEX color: is a string representing a hexadecimal color code with optional alpha channel.\n
     -------------------------------------------------------------------------------------------------
-    Supports formats: RGB, RGBA, RRGGBB, RRGGBBAA (with or without prefix)<br>
+    Supports formats: RGB, RGBA, RRGGBB, RRGGBBAA (with or without prefix)
     Includes methods:
     - `to_rgba()` to convert to RGB color
     - `to_hsla()` to convert to HSL color
@@ -452,7 +458,10 @@ 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):
+    def __init__(self, color: str | int, _r: int = None, _g: int = None, _b: int = None, _a: float = None):
+        if all(x is not None for x in (_r, _g, _b)):
+            self.r, self.g, self.b, self.a = _r, _g, _b, _a
+            return
         if isinstance(color, hexa):
             raise ValueError("Color is already a hexa() color")
         if isinstance(color, str):
@@ -491,27 +500,31 @@ class hexa:
             else:
                 raise ValueError(f"Invalid HEX format '{color}'")
         elif isinstance(color, int):
-            self.r, self.g, self.b, self.a = Color.hex_int_to_rgba(color)
+            self.r, self.g, self.b, self.a = Color.hex_int_to_rgba(color).values()
         else:
-            raise TypeError("HEX color must be of type 'str' or 'int': got", type(color))
+            raise TypeError(f"HEX color must be of type 'str' or 'int': got '{type(color)}'")
 
     def __len__(self):
-        return 4 if self.a else 3
+        return 3 if self.a is None else 4
 
     def __iter__(self):
-        return iter((f"{self.r:02X}", f"{self.g:02X}", f"{self.b:02X}") + ((f"{int(self.a * 255):02X}",) if self.a else ()))
+        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):
         return self.dict()
 
     def __getitem__(self, index):
-        return ((f"{self.r:02X}", f"{self.g:02X}", f"{self.b:02X}") + ((f"{int(self.a * 255):02X}",) if self.a else ()))[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):
-        return f'hexa(#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""})'
+        return f'hexa(#{self.r:02X}{self.g:02X}{self.b:02X}{"" if self.a is None else f"{int(self.a * 255):02X}"})'
 
     def __str__(self):
-        return f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}'
+        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):
         if not isinstance(other, hexa):
@@ -526,14 +539,14 @@ 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(
+            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}",
                 a=f"{int(self.a * 255):02X}",
             )
-            if self.a
-            else dict(r=f"{self.r:02X}", g=f"{self.g:02X}", b=f"{self.b:02X}")
         )
 
     def values(self) -> tuple:
@@ -546,7 +559,8 @@ class hexa:
             self.r,
             self.g,
             self.b,
-            (round(self.a, 2) if round_alpha else self.a) if self.a else None,
+            None if self.a is None else (round(self.a, 2) if round_alpha else self.a),
+            _validate=False,
         )
 
     def to_hsla(self, round_alpha: bool = True) -> "hsla":
@@ -560,47 +574,47 @@ class hexa:
     def lighten(self, amount: float) -> "hexa":
         """Increases the colors lightness by the specified amount (`0.0`-`1.0`)"""
         self.r, self.g, self.b, self.a = self.to_rgba(False).lighten(amount).values()
-        return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
+        return hexa("", self.r, self.g, self.b, self.a)
 
     def darken(self, amount: float) -> "hexa":
         """Decreases the colors lightness by the specified amount (`0.0`-`1.0`)"""
         self.r, self.g, self.b, self.a = self.to_rgba(False).darken(amount).values()
-        return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
+        return hexa("", self.r, self.g, self.b, self.a)
 
     def saturate(self, amount: float) -> "hexa":
         """Increases the colors saturation by the specified amount (`0.0`-`1.0`)"""
         self.r, self.g, self.b, self.a = self.to_rgba(False).saturate(amount).values()
-        return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
+        return hexa("", self.r, self.g, self.b, self.a)
 
     def desaturate(self, amount: float) -> "hexa":
         """Decreases the colors saturation by the specified amount (`0.0`-`1.0`)"""
         self.r, self.g, self.b, self.a = self.to_rgba(False).desaturate(amount).values()
-        return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
+        return hexa("", self.r, self.g, self.b, self.a)
 
     def rotate(self, degrees: int) -> "hexa":
         """Rotates the colors hue by the specified number of degrees"""
         self.r, self.g, self.b, self.a = self.to_rgba(False).rotate(degrees).values()
-        return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
+        return hexa("", self.r, self.g, self.b, self.a)
 
     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:
             self.a = 1 - self.a
-        return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
+        return hexa("", self.r, self.g, self.b, self.a)
 
     def grayscale(self) -> "hexa":
         """Converts the color to grayscale using the luminance formula"""
         self.r = self.g = self.b = Color.luminance(self.r, self.g, self.b)
-        return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
+        return hexa("", self.r, self.g, self.b, self.a)
 
     def blend(self, other: "hexa", ratio: float = 0.5, additive_alpha: bool = False) -> "rgba":
-        """Blends the current color with another color using the specified ratio (`0.0`-`1.0`):<br>
-        If `ratio` is `0.0` it means 100% of the current color and 0% of the `other` color (2:0 mixture)<br>
-        If `ratio` is `0.5` it means 50% of both colors (1:1 mixture)<br>
-        If `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:2 mixture)"""
+        """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)
+        - if `ratio` is `1.0` it means 0% of the current color and 100% of the `other` color (0:2 mixture)"""
         self.r, self.g, self.b, self.a = self.to_rgba(False).blend(Color.to_rgba(other), ratio, additive_alpha).values()
-        return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(self.a * 255):02X}" if self.a else ""}')
+        return hexa("", self.r, self.g, self.b, self.a)
 
     def is_dark(self) -> bool:
         """Returns `True` if the color is considered dark (`lightness < 50%`)"""
@@ -608,7 +622,7 @@ class hexa:
 
     def is_light(self) -> bool:
         """Returns `True` if the color is considered light (`lightness >= 50%`)"""
-        return self.to_hsla(False).is_light()
+        return not self.is_dark()
 
     def is_grayscale(self) -> bool:
         """Returns `True` if the color is grayscale (`saturation == 0`)"""
@@ -616,13 +630,13 @@ class hexa:
 
     def is_opaque(self) -> bool:
         """Returns `True` if the color has no transparency (`alpha == 1.0`)"""
-        return self.to_hsla(False).is_opaque()
+        return self.a == 1 or self.a is None
 
     def with_alpha(self, alpha: float) -> "hexa":
         """Returns a new color with the specified alpha value"""
         if not (isinstance(alpha, (int, float)) and 0 <= alpha <= 1):
             raise ValueError("'alpha' must be in [0.0, 1.0]")
-        return hexa(f'#{self.r:02X}{self.g:02X}{self.b:02X}{f"{int(alpha * 255):02X}" if alpha else ""}')
+        return hexa("", self.r, self.g, self.b, alpha)
 
     def complementary(self) -> "hexa":
         """Returns the complementary color (180 degrees on the color wheel)"""
@@ -723,10 +737,9 @@ class Color:
     @staticmethod
     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`.<br>
-        Returns `True` if the color has an alpha channel and `False` otherwise.
-        """
+        ---------------------------------------------------------------------------
+        Input a RGBA, HSLA or HEXA color as `color`.
+        Returns `True` if the color has an alpha channel and `False` otherwise."""
         if isinstance(color, (rgba, hsla, hexa)):
             return color.has_alpha()
         if Color.is_valid_hexa(color):
@@ -749,15 +762,11 @@ class Color:
         if isinstance(color, (hsla, hexa)):
             return color.to_rgba()
         elif Color.is_valid_hsla(color):
-            return hsla(*color).to_rgba() if Color.has_alpha(color) else hsla(color[0], color[1], color[2]).to_rgba()
+            return hsla(*color, _validate=False).to_rgba()
         elif Color.is_valid_hexa(color):
             return hexa(color).to_rgba()
         elif Color.is_valid_rgba(color):
-            return (
-                color
-                if isinstance(color, rgba)
-                else (rgba(*color) if Color.has_alpha(color) else rgba(color[0], color[1], color[2]))
-            )
+            return color if isinstance(color, rgba) else (rgba(*color, _validate=False))
         raise ValueError(f"Invalid color format '{color}'")
 
     @staticmethod
@@ -766,15 +775,11 @@ class Color:
         if isinstance(color, (rgba, hexa)):
             return color.to_hsla()
         elif Color.is_valid_rgba(color):
-            return rgba(*color).to_hsla() if Color.has_alpha(color) else rgba(color[0], color[1], color[2]).to_hsla()
+            return rgba(*color, _validate=False).to_hsla()
         elif Color.is_valid_hexa(color):
             return hexa(color).to_hsla()
         elif Color.is_valid_hsla(color):
-            return (
-                color
-                if isinstance(color, hsla)
-                else (hsla(*color) if Color.has_alpha(color) else hsla(color[0], color[1], color[2]))
-            )
+            return color if isinstance(color, hsla) else (hsla(*color, _validate=False))
         raise ValueError(f"Invalid color format '{color}'")
 
     @staticmethod
@@ -783,18 +788,18 @@ class Color:
         if isinstance(color, (rgba, hsla)):
             return color.to_hexa()
         elif Color.is_valid_rgba(color):
-            return rgba(*color).to_hexa() if Color.has_alpha(color) else rgba(color[0], color[1], color[2]).to_hexa()
+            return rgba(*color, _validate=False).to_hexa()
         elif Color.is_valid_hsla(color):
-            return hsla(*color).to_hexa() if Color.has_alpha(color) else hsla(color[0], color[1], color[2]).to_hexa()
+            return hsla(*color, _validate=False).to_hexa()
         elif Color.is_valid_hexa(color):
-            return color if isinstance(color, hexa) else hexa(f"#{color}")
+            return color if isinstance(color, hexa) else hexa(color)
         raise ValueError(f"Invalid color format '{color}'")
 
     @staticmethod
     def str_to_rgba(string: str, only_first: bool = False) -> rgba | list[rgba] | None:
-        """Will try to recognize RGBA colors inside a string and output the found ones as RGBA objects.<br>
-        If `only_first` is `True` only the first found color will be returned (not as a list).
-        """
+        """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)."""
         if only_first:
             match = _re.search(Regex.rgb_str(allow_alpha=True), string)
             if not match:
@@ -805,6 +810,7 @@ class Color:
                 int(m[1]),
                 int(m[2]),
                 ((int(m[3]) if "." not in m[3] else float(m[3])) if m[3] else None),
+                _validate=False,
             )
         else:
             matches = _re.findall(Regex.rgb_str(allow_alpha=True), string)
@@ -816,6 +822,7 @@ class Color:
                     int(m[1]),
                     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
             ]
@@ -829,51 +836,55 @@ class Color:
         preserve_original: bool = False,
     ) -> int:
         """Convert RGBA channels to a HEXA integer (alpha is optional).\n
-        -------------------------------------------------------------------------------------------------------------------------
-        To preserve leading zeros, the function will add a `1` at the beginning, if the HEX integer would start with a `0`.<br>
-        This could affect the color a little bit, but will make sure, that it won't be interpreted as a completely different<br>
-        color, when initializing it as a `hexa()` color or changing it back to RGBA using `Color.hex_int_to_rgba()`.\n
-        ⇾ **You can disable this behavior by setting `preserve_original` to `True`**"""
+        --------------------------------------------------------------------------------------------
+        To preserve leading zeros, the function will add a `1` at the beginning, if the HEX integer
+        would start with a `0`.
+        This could affect the color a little bit, but will make sure, that it won't be interpreted
+        as a completely different color, when initializing it as a `hexa()` color or changing it
+        back to RGBA using `Color.hex_int_to_rgba()`.\n
+        ⇾ You can disable this behavior by setting `preserve_original` to `True`"""
         r = max(0, min(255, int(r)))
         g = max(0, min(255, int(g)))
         b = max(0, min(255, int(b)))
-        if a is not None:
+        if a is None:
+            hex_int = (r << 16) | (g << 8) | b
+            if not preserve_original and (hex_int & 0xF00000) == 0:
+                hex_int |= 0x010000
+        else:
             a = max(0, min(255, int(a * 255)))
             hex_int = (r << 24) | (g << 16) | (b << 8) | a
             if not preserve_original and r == 0:
                 hex_int |= 0x01000000
-        else:
-            hex_int = (r << 16) | (g << 8) | b
-            if not preserve_original and (hex_int & 0xF00000) == 0:
-                hex_int |= 0x010000
         return hex_int
 
     @staticmethod
-    def hex_int_to_rgba(hex_int: int, preserve_original: bool = False) -> tuple[int, int, int, float | None]:
+    def hex_int_to_rgba(hex_int: int, preserve_original: bool = False) -> rgba:
         """Convert a HEX integer to RGBA channels.\n
-        -----------------------------------------------------------------------------------------------
-        If the red channel is `1` after conversion, it will be set to `0`, because when converting<br>
-        from RGBA to a HEX integer, the first `0` will be set to `1` to preserve leading zeros.<br>
+        -------------------------------------------------------------------------------------------
+        If the red channel is `1` after conversion, it will be set to `0`, because when converting
+        from RGBA to a HEX integer, the first `0` will be set to `1` to preserve leading zeros.
         This is the correction, so the color doesn't even look slightly different.\n
-        ⇾ **You can disable this behavior by setting `preserve_original` to `True`**"""
+        ⇾ You can disable this behavior by setting `preserve_original` to `True`"""
         if not isinstance(hex_int, int):
             raise ValueError("Input must be an integer")
         hex_str = f"{hex_int:x}"
         if len(hex_str) <= 6:
             hex_str = hex_str.zfill(6)
-            return (
+            return rgba(
                 r if (r := int(hex_str[0:2], 16)) != 1 or preserve_original else 0,
                 int(hex_str[2:4], 16),
                 int(hex_str[4:6], 16),
                 None,
+                _validate=False,
             )
         elif len(hex_str) <= 8:
             hex_str = hex_str.zfill(8)
-            return (
+            return rgba(
                 r if (r := int(hex_str[0:2], 16)) != 1 or preserve_original else 0,
                 int(hex_str[2:4], 16),
                 int(hex_str[4:6], 16),
                 int(hex_str[6:8], 16) / 255.0,
+                _validate=False,
             )
         else:
             raise ValueError(f"Invalid HEX integer '0x{hex_str}': expected in range [0x000000, 0xFFFFFF]")
@@ -882,10 +893,10 @@ class Color:
     def luminance(r: int, g: int, b: int, output_type: type = None) -> int | float:
         """Gets the colors luminance using the luminance formula.\n
         ------------------------------------------------------------
-        The param `output_type` can be set to:<br>
-        *`int`*   =⠀integer in [0, 100]<br>
-        *`float`* =⠀float in [0.0, 1.0]<br>
-        `None`    =⠀integer in [0, 255]"""
+        The param `output_type` can be set to:
+        - `int`   =⠀integer in [0, 100]
+        - `float` =⠀float in [0.0, 1.0]
+        - `None`  =⠀integer in [0, 255]"""
         r, g, b = r / 255.0, g / 255.0, b / 255.0
         if r < 0.03928:
             r = r / 12.92
@@ -904,25 +915,25 @@ class Color:
 
     @staticmethod
     def text_color_for_on_bg(
-        text_bg_color: rgba | hexa = 0xFFF,
+        text_bg_color: rgba | hexa = "#FFF",
     ) -> rgba | hexa:
         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("#FFF") if was_hexa else rgba(255, 255, 255))
+            (hexa("", 255, 255, 255) if was_hexa else rgba(255, 255, 255, _validate=False))
             if brightness < 128
-            else ((0x000 if was_int else hexa("#000")) if was_hexa else rgba(0, 0, 0))
+            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:
         """In- or decrease the lightness of the input color.\n
-        ----------------------------------------------------------------------------------------------------
-        **color** (rgba|hexa): HEX or RGBA color<br>
-        **lightness_change** (float): float between -1.0 (darken by `100%`) and 1.0 (lighten by `100%`)\n
-        ----------------------------------------------------------------------------------------------------
-        **returns** (rgba|hexa): the adjusted color in the format of the input color"""
+        -----------------------------------------------------------------------------------------------------
+        - color (rgba|hexa): HEX or RGBA color
+        - lightness_change (float): float between -1.0 (darken by `100%`) and 1.0 (lighten by `100%`)\n
+        -----------------------------------------------------------------------------------------------------
+        returns (rgba|hexa): the adjusted color in the format of the input color"""
         was_hexa = Color.is_valid_hexa(color)
         color = Color.to_hsla(color)
         h, s, l, a = (
@@ -932,16 +943,16 @@ class Color:
             color[3] if Color.has_alpha(color) else None,
         )
         l = int(max(0, min(100, l + lightness_change * 100)))
-        return Color.to_hexa((h, s, l, a)) if was_hexa else Color.to_rgba((h, s, l, a))
+        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:
         """In- or decrease the saturation of the input color.\n
-        ---------------------------------------------------------------------------------------------------------
-        **color** (rgba|hexa): HEX or RGBA color<br>
-        **saturation_change** (float): float between -1.0 (saturate by `100%`) and 1.0 (desaturate by `100%`)\n
-        ---------------------------------------------------------------------------------------------------------
-        **returns** (rgba|hexa): the adjusted color in the format of the input color"""
+        -----------------------------------------------------------------------------------------------------------
+        - color (rgba|hexa): HEX or RGBA color
+        - saturation_change (float): float between -1.0 (saturate by `100%`) and 1.0 (desaturate by `100%`)\n
+        -----------------------------------------------------------------------------------------------------------
+        returns (rgba|hexa): the adjusted color in the format of the input color"""
         was_hexa = Color.is_valid_hexa(color)
         color = Color.to_hsla(color)
         h, s, l, a = (
@@ -951,4 +962,4 @@ class Color:
             color[3] if Color.has_alpha(color) else None,
         )
         s = int(max(0, min(100, s + saturation_change * 100)))
-        return Color.to_hexa((h, s, l, a)) if was_hexa else Color.to_rgba((h, s, l, a))
+        return hsla(h, s, l, a, _validate=False).to_hexa() if was_hexa else hsla(h, s, l, a, _validate=False).to_rgba()