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

xulbux/__init__.py

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

xulbux/_consts_.py

@@ -116,14 +116,14 @@ class ANSI:
         "cyan": 36,
         "white": 37,
         ########## BRIGHT DEFAULT CONSOLE COLORS ###########
-        ("bright:black", "br:black"): 90,
-        ("bright:red", "br:red"): 91,
-        ("bright:green", "br:green"): 92,
-        ("bright:yellow", "br:yellow"): 93,
-        ("bright:blue", "br:blue"): 94,
-        ("bright:magenta", "br:magenta"): 95,
-        ("bright:cyan", "br:cyan"): 96,
-        ("bright:white", "br:white"): 97,
+        "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 CONSOLE BACKGROUND COLORS #########
         "bg:black": 40,
         "bg:red": 41,
@@ -134,12 +134,12 @@ class ANSI:
         "bg:cyan": 46,
         "bg:white": 47,
         ##### BRIGHT DEFAULT CONSOLE BACKGROUND COLORS #####
-        ("bg:bright:black", "bg:br:black"): 100,
-        ("bg:bright:red", "bg:br:red"): 101,
-        ("bg:bright:green", "bg:br:green"): 102,
-        ("bg:bright:yellow", "bg:br:yellow"): 103,
-        ("bg:bright:blue", "bg:br:blue"): 104,
-        ("bg:bright:magenta", "bg:br:magenta"): 105,
-        ("bg:bright:cyan", "bg:br:cyan"): 106,
-        ("bg:bright:white", "bg:br:white"): 107,
+        "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/xx_color.py

@@ -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)):
@@ -70,25 +73,25 @@ class rgba:
         elif a is not None and not (isinstance(a, (int, float)) and 0 <= a <= 1):
             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,39 +126,39 @@ 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`):
@@ -166,7 +169,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)
+                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)"""
@@ -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))):
@@ -270,25 +276,25 @@ class hsla:
         elif a is not None and (not isinstance(a, (int, float)) or not 0 <= a <= 1):
             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,13 +366,13 @@ 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`):
@@ -374,7 +380,7 @@ class hsla:
         - 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
@@ -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(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,39 +574,39 @@ 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`):
@@ -600,7 +614,7 @@ class hexa:
         - 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)"""
@@ -748,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
@@ -765,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
@@ -782,11 +788,11 @@ 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
@@ -804,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)
@@ -815,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
             ]
@@ -838,19 +846,19 @@ class Color:
         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
@@ -862,19 +870,21 @@ class Color:
         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]")
@@ -911,9 +921,9 @@ class Color:
         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
@@ -933,7 +943,7 @@ 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:
@@ -952,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()

xulbux/xx_console.py

@@ -29,7 +29,6 @@ from contextlib import suppress
 import pyperclip as _pyperclip
 import keyboard as _keyboard
 import getpass as _getpass
-import ctypes as _ctypes
 import shutil as _shutil
 import mouse as _mouse
 import sys as _sys
@@ -67,17 +66,6 @@ class Console:
     def user() -> str:
         return _os.getenv("USER") or _os.getenv("USERNAME") or _getpass.getuser()
 
-    def is_admin() -> bool:
-        try:
-            if _os.name == "nt":
-                return _ctypes.windll.shell32.IsUserAnAdmin() != 0
-            elif _os.name == "posix":
-                return _os.geteuid() == 0
-            else:
-                return False
-        except Exception:
-            return False
-
     @staticmethod
     def pause_exit(
         pause: bool = False,

xulbux/xx_env_path.py

@@ -8,8 +8,8 @@ Functions for modifying and checking the systems environment-variables:
 
 from .xx_path import Path
 
-import os as _os
 import sys as _sys
+import os as _os
 
 
 class EnvPath:

xulbux/xx_format_codes.py

@@ -11,7 +11,7 @@ Example string with formatting codes:
 [bold]This is bold text, [#F08]which is pink now [black|BG:#FF0088] and now it changed`
 to black with a pink background. [_]And this is the boring text, where everything is reset.
 ```
-⇾ Instead of writing the formats all separate `[…][…][…]` you can join them like this `[…|…|…]`\n
+⇾ Instead of writing the formats all separate `[x][y][z]` you can join them like this `[x|y|z]`\n
 --------------------------------------------------------------------------------------------------------------------
 You can also automatically reset a certain format, behind text like shown in the following example:
 ```string
@@ -31,7 +31,6 @@ If you want to ignore the `()` brackets you can put a `\\` or `/` between:
 All possible formatting codes:
 - HEX colors:  `[#F08]` or `[#FF0088]` (with or without leading #)
 - RGB colors:  `[rgb(255, 0, 136)]`
-- bright colors:  `[bright:#F08]`
 - background colors:  `[BG:#F08]`
 - standard cmd colors:
   - `[black]`
@@ -55,10 +54,21 @@ All possible formatting codes:
   - `[hidden]`, `[hide]` or `[h]`
   - `[strikethrough]` or `[s]`
   - `[double-underline]` or `[du]`
-- specific reset:  `[_bold]` or `[_b]`, `[_dim]`, ... or `[_color]` or `[_c]`, `[_background]` or `[_bg]`
-- total reset: `[_]` (only if no `default_color` is set, otherwise see ↓ )
+- specific reset:
+  - `[_bold]` or `[_b]`
+  - `[_dim]`
+  - `[_italic]` or `[_i]`
+  - `[_underline]` or `[_u]`
+  - `[_inverse]`, `[_invert]` or `[_in]`
+  - `[_hidden]`, `[_hide]` or `[_h]`
+  - `[_strikethrough]` or `[_s]`
+  - `[_double-underline]` or `[_du]`
+  - `[_color]` or `[_c]`
+  - `[_background]` or `[_bg]`
+- total reset:
+  - `[_]`
 --------------------------------------------------------------------------------------------------------------------
-Special formatting when param `default_color` is set to a color:
+Additional formats when a `default_color` is set:
 - `[*]` will reset everything, just like `[_]`, but the text-color will remain in `default_color`
 - `[*color]` will reset the text-color, just like `[_color]`, but then also make it `default_color`
 - `[default]` will just color the text in `default_color`,
@@ -86,20 +96,32 @@ import regex as _rx
 import sys as _sys
 import re as _re
 
-
+PREFIX = {
+    "BG": {"background", "bg"},
+    "BR": {"bright", "br"},
+}
+PREFIXES = {val for values in PREFIX.values() for val in values}
+PREFIX_RX = {
+    "BG": rf"(?:{'|'.join(PREFIX['BG'])})\s*:",
+    "BR": rf"(?:{'|'.join(PREFIX['BR'])})\s*:",
+}
 COMPILED = {  # PRECOMPILE REGULAR EXPRESSIONS
     "*": _re.compile(r"\[\s*([^]_]*?)\s*\*\s*([^]_]*?)\]"),
     "*color": _re.compile(r"\[\s*([^]_]*?)\s*\*color\s*([^]_]*?)\]"),
     "format": _rx.compile(
         Regex.brackets("[", "]", is_group=True) + r"(?:\s*([/\\]?)\s*" + Regex.brackets("(", ")", is_group=True) + r")?"
     ),
-    "bg?_default": _re.compile(r"(?i)((?:BG\s*:)?)\s*default"),
-    "bg_default": _re.compile(r"(?i)BG\s*:\s*default"),
+    "bg?_default": _re.compile(r"(?i)((?:" + PREFIX_RX["BG"] + r")?)\s*default"),
+    "bg_default": _re.compile(r"(?i)" + PREFIX_RX["BG"] + r"\s*default"),
     "modifier": _re.compile(
-        rf'(?i)((?:BG\s*:)?)\s*({"|".join([f"{_re.escape(m)}+" for m in ANSI.modifier["lighten"] + ANSI.modifier["darken"]])})$'
+        r"(?i)((?:BG\s*:)?)\s*("
+        + "|".join([f"{_re.escape(m)}+" for m in ANSI.modifier["lighten"] + ANSI.modifier["darken"]])
+        + r")$"
     ),
-    "rgb": _re.compile(r"(?i)^\s*(BG\s*:)?\s*(?:rgb|rgba)?\s*\(?\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)?\s*$"),
-    "hex": _re.compile(r"(?i)^\s*(BG\s*:)?\s*(?:#|0x)?([0-9A-F]{6}|[0-9A-F]{3})\s*$"),
+    "rgb": _re.compile(
+        r"(?i)^\s*(" + PREFIX_RX["BG"] + r")?\s*(?:rgb|rgba)?\s*\(?\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)?\s*$"
+    ),
+    "hex": _re.compile(r"(?i)^\s*(" + PREFIX_RX["BG"] + r")?\s*(?:#|0x)?([0-9A-F]{6}|[0-9A-F]{3})\s*$"),
 }
 
 
@@ -114,6 +136,10 @@ class FormatCodes:
         end: str = "\n",
         flush: bool = True,
     ) -> None:
+        """Print a string that can be formatted using special formatting codes.\n
+        --------------------------------------------------------------------------
+        For exact information about how to use special formatting codes, see the
+        `xx_format_codes` module documentation."""
         FormatCodes.__config_console()
         _sys.stdout.write(FormatCodes.to_ansi(sep.join(map(str, values)) + end, default_color, brightness_steps))
         if flush:
@@ -124,16 +150,29 @@ class FormatCodes:
         prompt: object = "",
         default_color: hexa | rgba = None,
         brightness_steps: int = 20,
+        reset_ansi: bool = False,
     ) -> str:
+        """An input, which's prompt can be formatted using special formatting codes.\n
+        -------------------------------------------------------------------------------
+        If `reset_ansi` is true, all ANSI formatting will be reset, after the user has
+        confirmed the input and the program continues.\n
+        -------------------------------------------------------------------------------
+        For exact information about how to use special formatting codes, see the
+        `xx_format_codes` module documentation."""
         FormatCodes.__config_console()
-        return input(FormatCodes.to_ansi(prompt, default_color, brightness_steps))
+        user_input = input(FormatCodes.to_ansi(prompt, default_color, brightness_steps))
+        if reset_ansi:
+            _sys.stdout.write("\x1b[0m")
+        return user_input
 
     @staticmethod
     def to_ansi(
         string: str, default_color: hexa | rgba = None, brightness_steps: int = 20, _default_start: bool = True
     ) -> str:
-        result, bg_kwd, color_pref = string, {"bg"}, {"br", "bright"}
-
+        """Convert the special formatting codes inside a string to printable ANSI codes.\n
+        -----------------------------------------------------------------------------------
+        For exact information about how to use special formatting codes, see the
+        `xx_format_codes` module documentation."""
         if Color.is_valid_rgba(default_color, False):
             use_default = True
         elif Color.is_valid_hexa(default_color, False):
@@ -166,10 +205,9 @@ class FormatCodes:
                 reset_keys = []
                 for k in format_keys:
                     k_lower = k.lower()
-                    k_parts = k_lower.split(":")
-                    k_set = set(k_parts)
-                    if bg_kwd & k_set and len(k_parts) <= 3:
-                        if k_set & color_pref:
+                    k_set = set(k_lower.split(":"))
+                    if PREFIX["BG"] & k_set and len(k_set) <= 3:
+                        if k_set & PREFIX["BR"]:
                             for i in range(len(k)):
                                 if is_valid_color(k[i:]):
                                     reset_keys.extend(["_bg", "_color"])
@@ -181,7 +219,7 @@ class FormatCodes:
                                     break
                     elif is_valid_color(k) or any(
                         k_lower.startswith(pref_colon := f"{prefix}:") and is_valid_color(k[len(pref_colon) :])
-                        for prefix in color_pref
+                        for prefix in PREFIX["BR"]
                     ):
                         reset_keys.append("_color")
                     else:
@@ -209,8 +247,8 @@ class FormatCodes:
                 + ("" if escaped else "".join(ansi_resets))
             )
 
-        result = "\n".join(COMPILED["format"].sub(replace_keys, line) for line in string.split("\n"))
-        return (FormatCodes.__get_default_ansi(default_color) if _default_start else "") + result if use_default else result
+        string = "\n".join(COMPILED["format"].sub(replace_keys, line) for line in string.split("\n"))
+        return (FormatCodes.__get_default_ansi(default_color) if _default_start else "") + string if use_default else string
 
     @staticmethod
     def escape_ansi(ansi_string: str, escaped_char: str = ANSI.char_esc) -> str:
@@ -220,6 +258,7 @@ class FormatCodes:
     @staticmethod
     @lru_cache(maxsize=64)
     def __config_console() -> None:
+        """Configure the console to be able to interpret ANSI formatting."""
         _sys.stdout.flush()
         kernel32 = _ctypes.windll.kernel32
         h = kernel32.GetStdHandle(-11)
@@ -234,6 +273,7 @@ class FormatCodes:
         brightness_steps: int = None,
         _modifiers: tuple[str, str] = (ANSI.modifier["lighten"], ANSI.modifier["darken"]),
     ) -> str | None:
+        """Get the `default_color` and lighter/darker versions of it in ANSI format."""
         if not brightness_steps or (format_key and COMPILED["bg?_default"].search(format_key)):
             return (ANSI.seq_bg_color if format_key and COMPILED["bg_default"].search(format_key) else ANSI.seq_color).format(
                 *default_color[:3]
@@ -264,11 +304,7 @@ class FormatCodes:
         If `default_color` is not `None`, the text color will be `default_color` if all formats
         are reset or you can get lighter or darker version of `default_color` (also as BG)"""
         use_default = default_color and Color.is_valid_rgba(default_color, False)
-        _format_key, format_key = format_key, (  # NORMALIZE THE FORMAT KEY (+ SAVE ORIGINAL)
-            "bg:" if "bg" in (parts := format_key.replace(" ", "").lower().split(":")) else ""
-        ) + ("bright:" if any(x in parts for x in ("bright", "br")) else "") + ":".join(
-            p for p in parts if p not in ("bg", "bright", "br")
-        )
+        _format_key, format_key = format_key, FormatCodes.__normalize_key(format_key)  # NORMALIZE KEY AND SAVE ORIGINAL
         if use_default:
             if new_default_color := FormatCodes.__get_default_ansi(default_color, format_key, brightness_steps):
                 return new_default_color
@@ -303,3 +339,17 @@ class FormatCodes:
         except Exception:
             pass
         return _format_key
+
+    @staticmethod
+    @lru_cache(maxsize=64)
+    def __normalize_key(format_key: str) -> str:
+        """Normalizes the given format key."""
+        k_parts = format_key.replace(" ", "").lower().split(":")
+        prefix_str = "".join(
+            f"{prefix_key.lower()}:"
+            for prefix_key, prefix_values in PREFIX.items()
+            if any(k_part in prefix_values for k_part in k_parts)
+        )
+        return prefix_str + ":".join(
+            part for part in k_parts if part not in {val for values in PREFIX.values() for val in values}
+        )

xulbux/xx_system.py

@@ -1,12 +1,29 @@
 import subprocess as _subprocess
 import platform as _platform
+import ctypes as _ctypes
 import time as _time
 import sys as _sys
 import os as _os
 
 
+class ProcessNotFoundError(Exception):
+    pass
+
+
 class System:
 
+    @staticmethod
+    def is_elevated() -> bool:
+        """Returns `True` if the current user is an admin and `False` otherwise."""
+        try:
+            if _os.name == "nt":
+                return _ctypes.windll.shell32.IsUserAnAdmin() != 0
+            elif _os.name == "posix":
+                return _os.geteuid() == 0
+        except:
+            pass
+        return False
+
     @staticmethod
     def restart(
         prompt: object = None,
@@ -83,3 +100,38 @@ class System:
             return None
         except _subprocess.CalledProcessError:
             return missing
+
+    @staticmethod
+    def elevate(win_title: str | None = None, args: list | None = None) -> bool:
+        """Attempts to start a new process with elevated privileges.\n
+        ---------------------------------------------------------------------------------
+        The param `win_title` is window the title of the elevated process.
+        The param `args` is the arguments to be passed to the elevated process.\n
+        After the elevated process started, the original process will exit.
+        This means, that this method has to be run at the beginning of the program or
+        will have to continue in a new window after elevation.\n
+        ---------------------------------------------------------------------------------
+        Returns `True` if the current process already has elevated privileges and raises
+        a `PermissionError` if the user denied the elevation or the elevation failed."""
+        if System.is_elevated():
+            return True
+        if _os.name == "nt":  # WINDOWS
+            if win_title:
+                args_str = f'-c "import ctypes; ctypes.windll.kernel32.SetConsoleTitleW(\\"{win_title}\\"); exec(open(\\"{_sys.argv[0]}\\").read())" {" ".join(args)}"'
+            else:
+                args_str = f'-c "exec(open(\\"{_sys.argv[0]}\\").read())" {" ".join(args)}'
+            result = _ctypes.windll.shell32.ShellExecuteW(None, "runas", _sys.executable, args_str, None, 1)
+            if result <= 32:
+                raise PermissionError("Failed to launch elevated process.")
+            else:
+                _sys.exit(0)
+        else:  # POSIX
+            cmd = ["pkexec"]
+            if win_title:
+                cmd.extend(["--description", win_title])
+            cmd.extend([_sys.executable] + _sys.argv[1:] + ([] if args is None else args))
+            proc = _subprocess.Popen(cmd)
+            proc.wait()
+            if proc.returncode != 0:
+                raise PermissionError("Process elevation was denied.")
+            _sys.exit(0)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xulbux
-Version: 1.6.1
+Version: 1.6.2
 Summary: A library which includes a lot of really helpful functions.
 Author-email: XulbuX <xulbux.real@gmail.com>
 License: MIT License
@@ -95,7 +95,7 @@ from xulbux import rgba, hsla, hexa
 | <h3>[`xx_console`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_console)</h3>   | advanced actions related to the console (*pretty logging, advanced inputs, ...*)                   |
 | <h3>[`xx_data`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_data)</h3>         | advanced operations with data structures (*compare, generate path ID's, pretty print/format, ...*) |
 | <h3>[`xx_env_path`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_env_path)</h3> | getting and editing the PATH variable (*get paths, check for paths, add paths, ...*)               |
-| <h3>`xx_file`</h3>                                                                           | advanced working with files (*create files, rename file-extensions, ...*)                          |
+| <h3>[`xx_file`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_file)</h3>         | advanced working with files (*create files, rename file-extensions, ...*)                          |
 | <h3>`xx_format_codes`</h3>                                                                   | easy pretty printing with custom format codes (*print, inputs, custom format codes to ANSI, ...*)  |
 | <h3>`xx_json`</h3>                                                                           | advanced working with json files (*read, create, update, ...*)                                     |
 | <h3>`xx_path`</h3>                                                                           | advanced path operations (*get paths, smart-extend relative paths, delete paths, ...*)             |

xulbux-1.6.2.dist-info/RECORD

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

xulbux-1.6.1.dist-info/RECORD

@@ -1,21 +0,0 @@
-xulbux/__init__.py,sha256=ayM2Gomwlns0lEDdbUZ6uxtrDIQRb0ldSOyqguQ_ON8,1658
-xulbux/_cli_.py,sha256=U25ZrtpQgpKXtvOSTBBbh7-AJ_WTeZ95A66DQARAqzo,3558
-xulbux/_consts_.py,sha256=2-swueg8B5retfsAQqmR8nFNc06tqAwpL__TOv3V4kw,4882
-xulbux/xx_code.py,sha256=yBP5WxCxNxjBiS6nVAmUBJpD0hX6fgnh5RWq-NmrnaY,5222
-xulbux/xx_color.py,sha256=sRW0Fr8CFfM2EsUubEO74aLRTseCu5VulXyjqDcahEw,44895
-xulbux/xx_console.py,sha256=ydDPYyGZ5OVHIkCiJO_eaAJI-8k97L5vQ7v1SoUUmWI,15436
-xulbux/xx_data.py,sha256=OEKLbI1XeNTrittdz3s3mvQk8YrBoSovj9O1H-b7ArY,25844
-xulbux/xx_env_path.py,sha256=5CvKpItzA4n8nvF7RwOmZwgs4erGltZqRJ3VD-9dFzo,4388
-xulbux/xx_file.py,sha256=-58YnqKvrs5idIF91UzEki7o7qnskFvnQYkBaRrp7Vw,3122
-xulbux/xx_format_codes.py,sha256=TkdHaiKXpZxVoUN6oEcsGXITgxrxzkghMCde2Kw-kQg,14806
-xulbux/xx_json.py,sha256=q60lOj8Xg8c4L9cBu6SBZdJzFC7QbjDfFwcKKzBKj5w,5173
-xulbux/xx_path.py,sha256=_xkH9cowPdi3nHw2q_TvN_i_5oG6GJut-QwPBLxnrAQ,4519
-xulbux/xx_regex.py,sha256=zyxkS1bLlrSq26ErhO4UtrimIhW71_a7kox6ArCoK58,7670
-xulbux/xx_string.py,sha256=Wa3qHxnk7AIpAVAn1vI_GBtkfYFwy4F_Xtj83ojEPKc,7168
-xulbux/xx_system.py,sha256=Eyf4MbZpaHHKv71SOcM_EK0bvT4PGG0KLwAXx4m60vo,3918
-xulbux-1.6.1.dist-info/LICENSE,sha256=6NflEcvzFEe8_JFVNCPVwZBwBhlLLd4vqQi8WiX_Xk4,1084
-xulbux-1.6.1.dist-info/METADATA,sha256=NLrtou5gw1j1FQ3PLIsI09UCoowzZg7xtJzVl5l9mi0,6836
-xulbux-1.6.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-xulbux-1.6.1.dist-info/entry_points.txt,sha256=a3womfLIMZKnOFiyy-xnVb4g2qkZsHR5FbKKkljcGns,94
-xulbux-1.6.1.dist-info/top_level.txt,sha256=FkK4EZajwfP36fnlrPaR98OrEvZpvdEOdW1T5zTj6og,7
-xulbux-1.6.1.dist-info/RECORD,,