xulbux 1.5.8__py3-none-any.whl → 1.5.9__py3-none-any.whl

xulbux/__init__.py

@@ -19,12 +19,12 @@
   • REGEX PATTERN TEMPLATES  xx.Regex
 """
 
-__version__ = "1.5.8"
+__version__ = "1.5.9"
 __author__ = "XulbuX"
 __email__ = "xulbux.real@gmail.com"
 __license__ = "MIT"
 __copyright__ = "Copyright (c) 2024 XulbuX"
-__url__ = "https://github.com/XulbuX-dev/Python/tree/main/Libraries/XulbuX"
+__url__ = "https://github.com/XulbuX-dev/PythonLibraryXulbuX"
 __description__ = "A library which includes a lot of really helpful functions."
 __all__ = [
     "_consts_",

xulbux/_cli_.py

@@ -32,7 +32,7 @@ def help_command():
     [dim](•) CUSTOM TYPES:
        [dim](•) [{color['class']}]rgba[{color['punctuators']}]/([i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]float[_|{color['punctuators']}])[*]
        [dim](•) [{color['class']}]hsla[{color['punctuators']}]/([i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]int[_|{color['punctuators']}],[i|{color['types']}]float[_|{color['punctuators']}])[*]
-       [dim](•) [{color['class']}]hexa[{color['punctuators']}]/([i|{color['types']}]str[_|{color['punctuators']}])[*]
+       [dim](•) [{color['class']}]hexa[{color['punctuators']}]/([i|{color['types']}]str[_|{color['punctuators']}]|[i|{color['types']}]int[_|{color['punctuators']}])[*]
     [dim](•) PATH OPERATIONS          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Path[*]
     [dim](•) FILE OPERATIONS          [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]File[*]
     [dim](•) JSON FILE OPERATIONS     [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Json[*]
@@ -47,6 +47,7 @@ def help_command():
     [dim](•) REGEX PATTERN TEMPLATES  [{color['lib']}]xx[{color['punctuators']}].[{color['class']}]Regex[*]
   [_]
   [dim](Press any key to exit...)
-  """
+  """,
+        default_color=DEFAULT.text_color,
     )
     Console.pause_exit(pause=True)

xulbux/_consts_.py

@@ -58,6 +58,7 @@ class ANSI:
 
     global CHAR, START, SEP, END
 
+    char_esc = r"\x1b"
     CHAR = char = "\x1b"
     START = start = "["
     SEP = sep = ";"

xulbux/xx_code.py

@@ -16,7 +16,7 @@ class Code:
     @staticmethod
     def get_tab_spaces(code: str) -> int:
         """Will try to get the amount of spaces used for indentation."""
-        code_lines = String.get_string_lines(code, remove_empty_lines=True)
+        code_lines = String.get_lines(code, remove_empty_lines=True)
         indents = [len(line) - len(line.lstrip()) for line in code_lines]
         non_zero_indents = [i for i in indents if i > 0]
         return min(non_zero_indents) if non_zero_indents else 0
@@ -26,8 +26,8 @@ class Code:
         """Replaces all tabs with `new_tab_size` spaces.<br>
         If `remove_empty_lines` is `True`, empty lines will be removed in the process.
         """
-        code_lines = String.get_string_lines(code, remove_empty_lines=True)
-        lines = code_lines if remove_empty_lines else String.get_string_lines(code)
+        code_lines = String.get_lines(code, remove_empty_lines=True)
+        lines = code_lines if remove_empty_lines else String.get_lines(code)
         tab_spaces = Code.get_tab_spaces(code)
         if (tab_spaces == new_tab_size) or tab_spaces == 0:
             if remove_empty_lines:

xulbux/xx_color.py

@@ -904,28 +904,25 @@ class Color:
 
     @staticmethod
     def text_color_for_on_bg(
-        title_bg_color: rgba | hexa = 0xFFF,
+        text_bg_color: rgba | hexa = 0xFFF,
     ) -> rgba | hexa:
-        (was_hexa, hexa_prefix), was_int = Color.is_valid_hexa(title_bg_color, get_prefix=True), isinstance(
-            title_bg_color, int
-        )
-        title_bg_color = Color.to_rgba(title_bg_color)
-        brightness = 0.2126 * title_bg_color[0] + 0.7152 * title_bg_color[1] + 0.0722 * title_bg_color[2]
+        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(f"{hexa_prefix}FFF") if was_hexa else rgba(255, 255, 255))
+            (hexa("#FFF") if was_hexa else rgba(255, 255, 255))
             if brightness < 128
-            else ((0x000 if was_int else hexa(f"{hexa_prefix}000")) if was_hexa else rgba(0, 0, 0))
+            else ((0x000 if was_int else hexa("#000")) if was_hexa else rgba(0, 0, 0))
         )
 
     @staticmethod
-    def adjust_lightness(color: rgba | hexa, brightness_change: float) -> rgba | hexa:
+    def adjust_lightness(color: rgba | hexa, lightness_change: float) -> rgba | hexa:
         """In- or decrease the lightness of the input color.\n
         ----------------------------------------------------------------------------------------------------
         **color** (rgba|hexa): HEX or RGBA color<br>
-        **brightness_change** (float): float between -1.0 (darken by `100%`) and 1.0 (lighten by `100%`)\n
+        **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
-        """
+        **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 = (
@@ -934,7 +931,7 @@ class Color:
             color[2],
             color[3] if Color.has_alpha(color) else None,
         )
-        l = int(max(0, min(100, l + brightness_change * 100)))
+        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))
 
     @staticmethod
@@ -944,8 +941,7 @@ class Color:
         **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
-        """
+        **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 = (

xulbux/xx_file.py

@@ -6,29 +6,6 @@ import os as _os
 
 class File:
 
-    @staticmethod
-    def _make_path(
-        filename: str,
-        filetype: str,
-        search_in: str | list[str] = None,
-        prefer_base_dir: bool = True,
-        correct_path: bool = False,
-    ) -> str:
-        """Get the path to a file in the cwd, the base-dir, or predefined directories.\n
-        --------------------------------------------------------------------------------------
-        If the `filename` is not found in the above directories, it will be searched<br>
-        in the `search_in` directory/directories. If the file is still not found, it will<br>
-        return the path to the file in the base-dir per default or to the file in the<br>
-        cwd if `prefer_base_dir` is set to `False`."""
-        if not filename.lower().endswith(f".{filetype.lower()}"):
-            filename = f"{filename}.{filetype.lower()}"
-        try:
-            return Path.extend(filename, search_in, True, correct_path)
-        except FileNotFoundError:
-            return (
-                _os.path.join(Path.get(base_dir=True), filename) if prefer_base_dir else _os.path.join(_os.getcwd(), filename)
-            )
-
     @staticmethod
     def rename_extension(file_path: str, new_extension: str) -> str:
         directory, filename_with_ext = _os.path.split(file_path)
@@ -54,3 +31,26 @@ class File:
             f.write(content)
         full_path = _os.path.abspath(file)
         return full_path
+
+    @staticmethod
+    def make_path(
+        filename: str,
+        filetype: str,
+        search_in: str | list[str] = None,
+        prefer_base_dir: bool = True,
+        correct_path: bool = False,
+    ) -> str:
+        """Create the path to a file in the cwd, the base-dir, or predefined directories.\n
+        --------------------------------------------------------------------------------------
+        If the `filename` is not found in the above directories, it will be searched<br>
+        in the `search_in` directory/directories. If the file is still not found, it will<br>
+        return the path to the file in the base-dir per default or to the file in the<br>
+        cwd if `prefer_base_dir` is set to `False`."""
+        if not filename.lower().endswith(f".{filetype.lower()}"):
+            filename = f"{filename}.{filetype.lower()}"
+        try:
+            return Path.extend(filename, search_in, True, correct_path)
+        except FileNotFoundError:
+            return (
+                _os.path.join(Path.get(base_dir=True), filename) if prefer_base_dir else _os.path.join(_os.getcwd(), filename)
+            )

xulbux/xx_format_codes.py

@@ -124,7 +124,8 @@ class FormatCodes:
     def to_ansi(
         string: str, default_color: hexa | rgba = None, brightness_steps: int = 20, _default_start: bool = True
     ) -> str:
-        result = ""
+        result, bg_kwd, color_pref = string, {"bg"}, {"br", "bright"}
+
         if Color.is_valid_rgba(default_color, False):
             use_default = True
         elif Color.is_valid_hexa(default_color, False):
@@ -135,32 +136,48 @@ class FormatCodes:
             string = COMPILED["*"].sub(r"[\1_|default\2]", string)  # REPLACE `[…|*|…]` WITH `[…|_|default|…]`
             string = COMPILED["*color"].sub(r"[\1default\2]", string)  # REPLACE `[…|*color|…]` WITH `[…|default|…]`
 
+        def is_valid_color(color: str) -> bool:
+            return color in ANSI.color_map or Color.is_valid_rgba(color) or Color.is_valid_hexa(color)
+
         def replace_keys(match: _re.Match) -> str:
-            format_keys = match.group(1)
-            esc = match.group(2)
+            formats = match.group(1)
+            escaped = match.group(2)
             auto_reset_txt = match.group(3)
-            if not format_keys:
+            if auto_reset_txt and auto_reset_txt.count("[") > 0 and auto_reset_txt.count("]") > 0:
+                auto_reset_txt = FormatCodes.to_ansi(auto_reset_txt, default_color, brightness_steps, False)
+            if not formats:
                 return match.group(0)
-            format_keys = [k.strip() for k in format_keys.split("|") if k.strip()]
-            ansi_formats = [FormatCodes.__get_replacement(k, default_color, brightness_steps) for k in format_keys]
-            if auto_reset_txt and not esc:
-                reset_keys = [
-                    (
-                        "_color"
-                        if k in ANSI.color_map or Color.is_valid_rgba(k) or Color.is_valid_hexa(k)
-                        else (
-                            "_bg"
-                            if ({"bg", "bright", "br"} & set(k.lower().split(":")))
-                            and len(k.split(":")) <= 3
-                            and any(
-                                k[i:] in ANSI.color_map or Color.is_valid_rgba(k[i:]) or Color.is_valid_hexa(k[i:])
-                                for i in range(len(k))
-                            )
-                            else f"_{k}"
-                        )
-                    )
-                    for k in format_keys
-                ]
+            if formats.count("[") > 0 and formats.count("]") > 0:
+                formats = FormatCodes.to_ansi(formats, default_color, brightness_steps, False)
+            format_keys = [k.strip() for k in formats.split("|") if k.strip()]
+            ansi_formats = [
+                r if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)) != k else f"[{k}]"
+                for k in format_keys
+            ]
+            if auto_reset_txt and not escaped:
+                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:
+                            for i in range(len(k)):
+                                if is_valid_color(k[i:]):
+                                    reset_keys.extend(["_bg", "_color"])
+                                    break
+                        else:
+                            for i in range(len(k)):
+                                if is_valid_color(k[i:]):
+                                    reset_keys.append("_bg")
+                                    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
+                    ):
+                        reset_keys.append("_color")
+                    else:
+                        reset_keys.append(f"_{k}")
                 ansi_resets = [
                     r
                     for k in reset_keys
@@ -170,24 +187,27 @@ class FormatCodes:
                 ]
             else:
                 ansi_resets = []
-            if not all(f.startswith(f"{ANSI.char}{ANSI.start}") for f in ansi_formats):
+            if not (len(ansi_formats) == 1 and ansi_formats[0].count(f"{ANSI.char}{ANSI.start}") >= 1) and not all(
+                f.startswith(f"{ANSI.char}{ANSI.start}") for f in ansi_formats
+            ):
                 return match.group(0)
             return (
                 "".join(ansi_formats)
                 + (
                     f"({FormatCodes.to_ansi(auto_reset_txt, default_color, brightness_steps, False)})"
-                    if esc and auto_reset_txt
+                    if escaped and auto_reset_txt
                     else auto_reset_txt if auto_reset_txt else ""
                 )
-                + ("" if esc else "".join(ansi_resets))
+                + ("" if escaped else "".join(ansi_resets))
             )
 
-        return (
-            (FormatCodes.__get_default_ansi(default_color) if _default_start else "")
-            + (result := "\n".join(COMPILED["format"].sub(replace_keys, line) for line in string.split("\n")))
-            if use_default
-            else result
-        )
+        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
+
+    @staticmethod
+    def escape_ansi(ansi_string: str, escaped_char: str = ANSI.char_esc) -> str:
+        """Makes the string printable with the ANSI formats visible."""
+        return ansi_string.replace(ANSI.char, escaped_char)
 
     @staticmethod
     @lru_cache(maxsize=64)

xulbux/xx_json.py

@@ -22,7 +22,7 @@ class Json:
         the the section from `comment_start` to `comment_end` is ignored.<br>
         If `return_original` is set to `True`, the original JSON is returned<br>
         additionally. (returns: `[processed_json, original_json]`)"""
-        file_path = File._make_path(json_file, "json", prefer_base_dir=True)
+        file_path = File.make_path(json_file, "json", prefer_base_dir=True)
         with open(file_path, "r") as f:
             content = f.read()
         try:
@@ -42,7 +42,7 @@ class Json:
         compactness: int = 1,
         force: bool = False,
     ) -> str:
-        file_path = File._make_path(new_file, "json", prefer_base_dir=True)
+        file_path = File.make_path(new_file, "json", prefer_base_dir=True)
         if _os.path.exists(file_path) and not force:
             with open(file_path, "r", encoding="utf-8") as existing_f:
                 existing_content = _json.load(existing_f)

xulbux/xx_regex.py

@@ -22,16 +22,14 @@ class Regex:
         **`quote`** the quote type (single or double)<br>
         **`string`** everything inside the found quote pair\n
         ------------------------------------------------------------------------------------
-        **Attention:** Requires non standard library `regex` not standard library `re`!
-        """
+        **Attention:** Requires non standard library `regex` not standard library `re`!"""
         return r'(?P<quote>[\'"])(?P<string>(?:\\.|(?!\g<quote>).)*?)\g<quote>'
 
     @staticmethod
     def brackets(bracket1: str = "(", bracket2: str = ")", is_group: bool = False) -> str:
         """Matches everything inside brackets, including other nested brackets.\n
         ------------------------------------------------------------------------------------
-        **Attention:** Requires non standard library `regex` not standard library `re`!
-        """
+        **Attention:** Requires non standard library `regex` not standard library `re`!"""
         g, b1, b2 = (
             "" if is_group else "?:",
             _re.escape(bracket1) if len(bracket1) == 1 else bracket1,
@@ -51,10 +49,10 @@ class Regex:
         is_group: bool = False,
     ) -> str:
         """Matches everything except `disallowed_pattern`, unless the `disallowed_pattern` is found inside a string (`'...'` or `"..."`).\n
-        ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-        The `ignore_pattern` is just always ignored. For example if `disallowed_pattern` is `>` and `ignore_pattern` is `->`, the `->`-arrows will be allowed, even though they have `>` in them.<br>
-        If `is_group` is `True`, you will be able to reference the matched content as a group (e.g. <code>match.group(<i>int</i>)</code> or <code>r'\\<i>int</i>'</code>).
-        """
+        ------------------------------------------------------------------------------------------------------------------------------------
+        The `ignore_pattern` is just always ignored. For example if `disallowed_pattern` is `>` and `ignore_pattern` is `->`, the `->`<br>
+        -arrows will be allowed, even though they have `>` in them. If `is_group` is `True`, you will be able to reference the matched<br>
+        content as a group (e.g. <code>match.group(<i>int</i>)</code> or <code>r'\\<i>int</i>'</code>)."""
         return rf'({"" if is_group else "?:"}(?:(?!{ignore_pattern}).)*(?:(?!{Regex.outside_strings(disallowed_pattern)}).)*)'
 
     @staticmethod
@@ -64,8 +62,7 @@ class Regex:
         **`2`** the function's arguments\n
         If no `func_name` is given, it will match any function call.\n
         ------------------------------------------------------------------------------------
-        **Attention:** Requires non standard library `regex` not standard library `re`!
-        """
+        **Attention:** Requires non standard library `regex` not standard library `re`!"""
         return r"(?<=\b)(" + (func_name if func_name else r"[\w_]+") + r")\s*" + Regex.brackets("(", ")", is_group=True)
 
     @staticmethod

xulbux/xx_string.py

@@ -5,36 +5,54 @@ class String:
 
     @staticmethod
     def to_type(string: str) -> any:
-        """Will convert a string to a type."""
-        if string.lower() in ("true", "false"):  # BOOLEAN
+        """Will convert a string to the found type."""
+        string = string.strip()  # Clean up whitespace
+        # BOOLEAN
+        if _re.match(r"(?i)^(true|false)$", string):
             return string.lower() == "true"
-        elif string.lower() in ("none", "null", "undefined"):  # NONE
+        # NONE
+        elif _re.match(r"(?i)^(none|null|undefined)$", string):
             return None
-        elif string.startswith("[") and string.endswith("]"):  # LIST
-            return [String.to_type(item.strip()) for item in string[1:-1].split(",") if item.strip()]
-        elif string.startswith("(") and string.endswith(")"):  # TUPLE
-            return tuple(String.to_type(item.strip()) for item in string[1:-1].split(",") if item.strip())
-        elif string.startswith("{") and string.endswith("}"):  # SET
-            return {String.to_type(item.strip()) for item in string[1:-1].split(",") if item.strip()}
-        elif string.startswith("{") and string.endswith("}") and ":" in string:  # DICTIONARY
+        # INTEGER
+        elif _re.match(r"^-?\d+$", string):
+            return int(string)
+        # FLOAT
+        elif _re.match(r"^-?\d+\.\d+$", string):
+            return float(string)
+        # COMPLEX
+        elif _re.match(r"^(-?\d+(\.\d+)?[+-]\d+(\.\d+)?j)$", string):
+            return complex(string)
+        # QUOTED STRING
+        elif _re.match(r'^["\'](.*)["\']$', string):
+            return string[1:-1]
+        # BYTES
+        elif _re.match(r"^b['\"](.*)['\"]$", string):
+            return bytes(string[2:-1], "utf-8")
+        # LIST
+        elif _re.match(r"^\[(.*)\]$", string):
+            return [
+                String.to_type(item.strip()) for item in _re.findall(r"(?:[^,\[\]]+|\[.*?\]|\(.*?\)|\{.*?\})+", string[1:-1])
+            ]
+        # TUPLE
+        elif _re.match(r"^\((.*)\)$", string):
+            return tuple(
+                String.to_type(item.strip()) for item in _re.findall(r"(?:[^,\(\)]+|\[.*?\]|\(.*?\)|\{.*?\})+", string[1:-1])
+            )
+        # DICTIONARY
+        elif _re.match(r"^\{(.*)\}$", string) and ":" in string:
             return {
                 String.to_type(k.strip()): String.to_type(v.strip())
-                for k, v in (item.split(":") for item in string[1:-1].split(",") if item.strip())
+                for k, v in _re.findall(
+                    r"((?:[^:,{}]+|\[.*?\]|\(.*?\)|\{.*?\})+)\s*:\s*((?:[^:,{}]+|\[.*?\]|\(.*?\)|\{.*?\})+)", string[1:-1]
+                )
             }
-        try:  # NUMBER (INT OR FLOAT)
-            if "." in string or "e" in string.lower():
-                return float(string)
-            else:
-                return int(string)
-        except ValueError:
-            pass
-        if string.startswith(("'", '"')) and string.endswith(("'", '"')):  # STRING (WITH OR WITHOUT QUOTES)
-            return string[1:-1]
-        try:  # COMPLEX
-            return complex(string)
-        except ValueError:
-            pass
-        return string  # IF NOTHING ELSE MATCHES, RETURN AS IS
+        # SET
+        elif _re.match(r"^\{(.*?)\}$", string):
+            return {
+                String.to_type(item.strip()) for item in _re.findall(r"(?:[^,{}]+|\[.*?\]|\(.*?\)|\{.*?\})+", string[1:-1])
+            }
+        # RETURN AS IS (str)
+        return string
 
     @staticmethod
     def normalize_spaces(string: str, tab_spaces: int = 4) -> str:
@@ -87,8 +105,7 @@ class String:
     @staticmethod
     def single_char_repeats(string: str, char: str) -> int | bool:
         """If the string consists of only the same `char`, it returns the number of times it is present.<br>
-        If the string doesn't consist of only the same character, it returns `False`.
-        """
+        If the string doesn't consist of only the same character, it returns `False`."""
         if len(string) == len(char) * string.count(char):
             return string.count(char)
         else:
@@ -97,20 +114,27 @@ class String:
     @staticmethod
     def decompose(case_string: str, seps: str = "-_", lower_all: bool = True) -> list[str]:
         """Will decompose the string (*any type of casing, also mixed*) into parts."""
-        return [(part.lower() if lower_all else part) for part in _re.split(rf"(?<=[a-z])(?=[A-Z])|[{seps}]", case_string)]
+        return [
+            (part.lower() if lower_all else part)
+            for part in _re.split(rf"(?<=[a-z])(?=[A-Z])|[{_re.escape(seps)}]", case_string)
+        ]
 
     @staticmethod
-    def to_camel_case(string: str) -> str:
-        """Will convert the string of any type of casing to camel case."""
-        return "".join(part.capitalize() for part in String.decompose(string))
+    def to_camel_case(string: str, upper: bool = True) -> str:
+        """Will convert the string of any type of casing to UpperCamelCase or lowerCamelCase if `upper` is false."""
+        return (
+            (parts := String.decompose(string))[0].lower()
+            if upper
+            else "" + "".join(part.capitalize() for part in (parts[1:] if upper else parts))
+        )
 
     @staticmethod
-    def to_snake_case(string: str, sep: str = "_", screaming: bool = False) -> str:
-        """Will convert the string of any type of casing to snake case."""
-        return sep.join(part.upper() if screaming else part for part in String.decompose(string))
+    def to_delimited_case(string: str, delimiter: str = "_", screaming: bool = False) -> str:
+        """Will convert the string of any type of casing to casing delimited by `delimiter`."""
+        return delimiter.join(part.upper() if screaming else part for part in String.decompose(string))
 
     @staticmethod
-    def get_string_lines(string: str, remove_empty_lines: bool = False) -> list[str]:
+    def get_lines(string: str, remove_empty_lines: bool = False) -> list[str]:
         """Will split the string into lines."""
         if not remove_empty_lines:
             return string.splitlines()
@@ -128,46 +152,10 @@ class String:
         ----------------------------------------------------------------------------------------------
         If `max_consecutive` is `0`, it will remove all consecutive empty lines.<br>
         If `max_consecutive` is bigger than `0`, it will only allow `max_consecutive` consecutive<br>
-        empty lines and everything above it will be cut down to `max_consecutive` empty lines.
-        """
+        empty lines and everything above it will be cut down to `max_consecutive` empty lines."""
         return _re.sub(r"(\n\s*){2,}", r"\1" * (max_consecutive + 1), string)
 
     @staticmethod
     def split_count(string: str, count: int) -> list[str]:
         """Will split the string every `count` characters."""
         return [string[i : i + count] for i in range(0, len(string), count)]
-
-    @staticmethod
-    def multi_strip(string: str, strip_chars: str = " _-") -> str:
-        """Will remove all leading and trailing `strip_chars` from the string."""
-        for char in string:
-            if char in strip_chars:
-                string = string[1:]
-            else:
-                break
-        for char in string[::-1]:
-            if char in strip_chars:
-                string = string[:-1]
-            else:
-                break
-        return string
-
-    @staticmethod
-    def multi_lstrip(string: str, strip_chars: str = " _-") -> str:
-        """Will remove all leading `strip_chars` from the string."""
-        for char in string:
-            if char in strip_chars:
-                string = string[1:]
-            else:
-                break
-        return string
-
-    @staticmethod
-    def multi_rstrip(string: str, strip_chars: str = " _-") -> str:
-        """Will remove all trailing `strip_chars` from the string."""
-        for char in string[::-1]:
-            if char in strip_chars:
-                string = string[:-1]
-            else:
-                break
-        return string

xulbux-1.5.9.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.1
+Name: xulbux
+Version: 1.5.9
+Summary: A library which includes a lot of really helpful functions.
+Author-email: XulbuX <xulbux.real@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 XulbuX
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Bug Reports, https://github.com/XulbuX-dev/PythonLibraryXulbuX/issues
+Project-URL: Changelog, https://github.com/XulbuX-dev/PythonLibraryXulbuX/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki
+Project-URL: Homepage, https://github.com/XulbuX-dev/PythonLibraryXulbuX
+Project-URL: License, https://github.com/XulbuX-dev/PythonLibraryXulbuX/blob/main/LICENSE
+Project-URL: Source Code, https://github.com/XulbuX-dev/PythonLibraryXulbuX/tree/main/src
+Keywords: xulbux,python,library,utility,helper,functions,tools,classes,types,methods,cmd,code,color,data,structures,env,environment,file,format,json,path,regex,string,system,operations,presets
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: keyboard>=0.13.5
+Requires-Dist: mouse>=0.7.1
+Requires-Dist: pyperclip>=1.9.0
+Requires-Dist: regex>=2023.10.3
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.2; extra == "dev"
+Requires-Dist: black>=23.7.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: flake8>=6.1.0; extra == "dev"
+
+# **$\color{#8085FF}\Huge\textsf{XulbuX}$**
+
+**$\color{#8085FF}\textsf{XulbuX}$** is a library which includes a lot of really helpful classes, types and functions.
+
+For precise information about the library, see the library's [Wiki page](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki).<br>
+For the libraries latest changes, see the [change log](https://github.com/XulbuX-dev/PythonLibraryXulbuX/blob/main/CHANGELOG.md).
+
+
+## Installation
+
+To install the library and all its dependencies, open a console and run the command:
+```prolog
+pip install xulbux
+```
+
+To upgrade the library to the latest available version, run the following command in your console:
+```prolog
+pip install --upgrade xulbux
+```
+
+
+## Usage
+
+Import the full library under the alias `xx`, so it's classes, types and functions are accessible with `xx.Class.method()`, `xx.type()` and `xx.function()`:
+```python
+import xulbux as xx
+```
+So you don't have to write `xx` in front of the library's types, you can import them directly:
+```python
+from xulbux import rgba, hsla, hexa
+```
+
+
+# Modules
+
+| | |
+| :------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------- |
+| <h3>[`xx_code`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_code)</h3>         | advanced code-string operations (*changing the indent, finding function calls, ...*)               |
+| <h3>[`xx_color`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_color)</h3>       | everything around colors (*converting, blending, searching colors in strings, ...*)                |
+| <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_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, ...*)             |
+| <h3>`xx_regex`</h3>                                                                          | generated regex pattern-templates (*match bracket- and quote pairs, match colors, ...*)            |
+| <h3>[`xx_string`](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki/xx_string)</h3>     | helpful actions when working with strings. (*normalize, escape, decompose, ...*)                   |
+| <h3>`xx_system`</h3>                                                                         | advanced system actions (*restart with message, check installed Python libs, ...*)                 |
+
+
+<br>
+
+--------------------------------------------------------------
+[View this library on PyPI](https://pypi.org/project/XulbuX/)

xulbux-1.5.9.dist-info/RECORD

@@ -0,0 +1,21 @@
+xulbux/__init__.py,sha256=1I5Hbze_27gyM9k1JJ_JZdVUV8EM-7zQrNNpbvUtToE,1658
+xulbux/_cli_.py,sha256=U25ZrtpQgpKXtvOSTBBbh7-AJ_WTeZ95A66DQARAqzo,3558
+xulbux/_consts_.py,sha256=2-swueg8B5retfsAQqmR8nFNc06tqAwpL__TOv3V4kw,4882
+xulbux/xx_code.py,sha256=dAksTh2Fw6-XTIGn8eEJVUlvJOsrWbctDZJDk4cs8FQ,5137
+xulbux/xx_color.py,sha256=AqMqPCwDQZVQwkQUM0IOO47GzKNhKapoCwDifs-ewI8,44906
+xulbux/xx_console.py,sha256=Xzl73_LTyt9AW09KAV9tsGdEdiltxPJwJq9nZChWrUQ,15482
+xulbux/xx_data.py,sha256=cwjJeQHwf-b9yE6UTI0DO7US-hWtgTmIdvwKH5KKtmI,25969
+xulbux/xx_env_path.py,sha256=ITdJ4DKh1zAvZrV5kph1z0jUDBhwEtOP4u1OKW0hMts,4309
+xulbux/xx_file.py,sha256=nO2FtxqlBaW84L-qiTcQf16Im2xD-ZKPAytJDG4RCRw,2618
+xulbux/xx_format_codes.py,sha256=NIleZ9TrXdF0i9UMCZP7ZI_k1ChJjYlHCFAcHZHHq2c,14891
+xulbux/xx_json.py,sha256=1xAYBmpb4o8hOS_TaMQW2E5pZdE1YqbUdSJm-53wm-s,5054
+xulbux/xx_path.py,sha256=KB1HGYCxFB3_T97RVACajy3-QiksbviZVIW9-iQcr4s,4558
+xulbux/xx_regex.py,sha256=-dU1x4GDhFKEg0uQPT6uw9Yyo0vo7f98TtlicG9uBJo,7872
+xulbux/xx_string.py,sha256=SC5Wn-rp601sre5cTFCVrvKeHr6v1Y_GIkqMcLWF4b0,7128
+xulbux/xx_system.py,sha256=yehO57ggWDRJbeFoTE1VisW4QrbkqZzAyjKoL3xHx9k,3935
+xulbux-1.5.9.dist-info/LICENSE,sha256=6NflEcvzFEe8_JFVNCPVwZBwBhlLLd4vqQi8WiX_Xk4,1084
+xulbux-1.5.9.dist-info/METADATA,sha256=Exj7GULPxlgsB9PlaASWXeD9JX4wPmy1pnasSp7vR3A,6836
+xulbux-1.5.9.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+xulbux-1.5.9.dist-info/entry_points.txt,sha256=a3womfLIMZKnOFiyy-xnVb4g2qkZsHR5FbKKkljcGns,94
+xulbux-1.5.9.dist-info/top_level.txt,sha256=FkK4EZajwfP36fnlrPaR98OrEvZpvdEOdW1T5zTj6og,7
+xulbux-1.5.9.dist-info/RECORD,,

{xulbux-1.5.8.dist-info → xulbux-1.5.9.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

xulbux-1.5.9.dist-info/top_level.txt

@@ -0,0 +1 @@
+xulbux

xulbux-1.5.8.dist-info/METADATA

@@ -1,101 +0,0 @@
-Metadata-Version: 2.3
-Name: xulbux
-Version: 1.5.8
-Summary: A library which includes a lot of really helpful functions.
-Project-URL: Homepage, https://github.com/XulbuX-dev/PythonLibraryXulbuX
-Project-URL: Bug Reports, https://github.com/XulbuX-dev/PythonLibraryXulbuX/issues
-Project-URL: Documentation, https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki
-Project-URL: Source Code, https://github.com/XulbuX-dev/PythonLibraryXulbuX/tree/main/src
-Project-URL: Changelog, https://github.com/XulbuX-dev/PythonLibraryXulbuX/blob/main/CHANGELOG.md
-Author-email: XulbuX <xulbux.real@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2024 XulbuX
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-Keywords: classes,cmd,code,color,data,env,environment,file,format,functions,helper,json,library,methods,operations,path,presets,python,regex,string,structures,system,tools,types,utility,xulbux
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.10.0
-Requires-Dist: keyboard>=0.13.5
-Requires-Dist: mouse>=0.7.1
-Requires-Dist: pyperclip>=1.9.0
-Requires-Dist: regex>=2023.10.3
-Provides-Extra: dev
-Requires-Dist: black>=23.7.0; extra == 'dev'
-Requires-Dist: flake8>=6.1.0; extra == 'dev'
-Requires-Dist: isort>=5.12.0; extra == 'dev'
-Requires-Dist: pytest>=7.4.2; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# **$\color{#8085FF}\Huge\textsf{XulbuX}$**
-
-**$\color{#8085FF}\textsf{XulbuX}$** is a library which includes a lot of really helpful classes, types and functions.
-
-For the libraries latest changes, see the [change log](https://github.com/XulbuX-dev/PythonLibraryXulbuX/blob/main/CHANGELOG.md).<br>
-For precise information about the library, see the library's [Wiki page](https://github.com/XulbuX-dev/PythonLibraryXulbuX/wiki).
-
-
-## Installation
-
-On all operating systems, run the following command:
-```bash
-pip install xulbux
-```
-
-
-## Usage
-
-```python
-# GENERAL LIBRARY
-import xulbux as xx
-# CUSTOM TYPES
-from xulbux import rgba, hsla, hexa
-```
-The library **$\color{#8085FF}\textsf{XulbuX}$** (*below used as* `xx` *with above imported types*) contains the following modules:
-```python
-  • CUSTOM TYPES:
-     • rgba(int,int,int,float)
-     • hsla(int,int,int,float)
-     • hexa(str)
-  • PATH OPERATIONS          xx.Path
-  • FILE OPERATIONS          xx.File
-  • JSON FILE OPERATIONS     xx.Json
-  • SYSTEM ACTIONS           xx.System
-  • MANAGE THE ENV PATH VAR  xx.EnvPath
-  • CONSOLE LOG AND ACTIONS  xx.Console
-  • EASY PRETTY PRINTING     xx.FormatCodes
-  • WORKING WITH COLORS      xx.Color
-  • DATA OPERATIONS          xx.Data
-  • STRING OPERATIONS        xx.String
-  • CODE STRING OPERATIONS   xx.Code
-  • REGEX PATTERN TEMPLATES  xx.Regex
-```
-
-
-<br>
-
---------------------------------------------------------------
-[View this library on PyPI](https://pypi.org/project/XulbuX/)

xulbux-1.5.8.dist-info/RECORD

@@ -1,20 +0,0 @@
-xulbux/__init__.py,sha256=yhdvShCcbcLeBfKckjurNcrkCHIj1wWEezgtQPbytGI,1672
-xulbux/_cli_.py,sha256=zCa4dROOwJ3TPIH8ed1gezRj309ljGOAapICRqq4OKs,3464
-xulbux/_consts_.py,sha256=HqBCzFYSk9LS2TrxPCQBQcEjEB8McLodH4ZGZ8yP3Ec,4858
-xulbux/xx_code.py,sha256=v3fhHelqxFXtp2RI7sY7mXusRKdiyOEzy_rmrC3N-Os,5158
-xulbux/xx_color.py,sha256=Ib_jVAYHl3uVUvWUv1jE_QHScNvIPgm9KxEl2xSJfQo,45019
-xulbux/xx_console.py,sha256=Xzl73_LTyt9AW09KAV9tsGdEdiltxPJwJq9nZChWrUQ,15482
-xulbux/xx_data.py,sha256=cwjJeQHwf-b9yE6UTI0DO7US-hWtgTmIdvwKH5KKtmI,25969
-xulbux/xx_env_path.py,sha256=ITdJ4DKh1zAvZrV5kph1z0jUDBhwEtOP4u1OKW0hMts,4309
-xulbux/xx_file.py,sha256=Zhlx7TZ0u2wcl_7khgpMCoqlrcfsbiOh03sj4nsuPaQ,2616
-xulbux/xx_format_codes.py,sha256=hRQ4Vecw2TTa-g5pKshLP-pep_Da7iy38o879McCrOc,13547
-xulbux/xx_json.py,sha256=Sz-UicwU2vdTud4itMV-ljqePzpNByu5WgnX4lEUVRc,5056
-xulbux/xx_path.py,sha256=KB1HGYCxFB3_T97RVACajy3-QiksbviZVIW9-iQcr4s,4558
-xulbux/xx_regex.py,sha256=ce-K62uk1nvayOvLAtMQSD-IwKiVu2IATj0s1C1u6pM,7956
-xulbux/xx_string.py,sha256=cQOvektdBKKe4CuBw6VOoxTElayghk0SQPuLdMILn9A,7650
-xulbux/xx_system.py,sha256=yehO57ggWDRJbeFoTE1VisW4QrbkqZzAyjKoL3xHx9k,3935
-xulbux-1.5.8.dist-info/METADATA,sha256=B95tctbGYaeyy-_nvGssLk08OJNWaFUF1JeTD5_wi2A,4340
-xulbux-1.5.8.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-xulbux-1.5.8.dist-info/entry_points.txt,sha256=a3womfLIMZKnOFiyy-xnVb4g2qkZsHR5FbKKkljcGns,94
-xulbux-1.5.8.dist-info/licenses/LICENSE,sha256=6NflEcvzFEe8_JFVNCPVwZBwBhlLLd4vqQi8WiX_Xk4,1084
-xulbux-1.5.8.dist-info/RECORD,,