xulbux 1.6.1__py3-none-any.whl

xulbux/xx_regex.py

@@ -0,0 +1,156 @@
+"""
+Really long regex code presets:
+`quotes` match everything inside quotes
+`brackets` match everything inside brackets
+`outside_strings` match the pattern but not inside strings
+`all_except` match everything except a certain pattern
+`func_call` match a function call
+`rgba_str` match an RGBA color
+`hsla_str` match a HSLA color
+"""
+
+import re as _re
+
+
+class Regex:
+
+    @staticmethod
+    def quotes() -> str:
+        """Matches everything inside quotes. (strings)\n
+        ------------------------------------------------------------------------------------
+        Will create two named groups:
+        - `quote` the quote type (single or double)
+        - `string` everything inside the found quote pair\n
+        ------------------------------------------------------------------------------------
+        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`!"""
+        g, b1, b2 = (
+            "" if is_group else "?:",
+            _re.escape(bracket1) if len(bracket1) == 1 else bracket1,
+            _re.escape(bracket2) if len(bracket2) == 1 else bracket2,
+        )
+        return rf'{b1}\s*({g}(?:[^{b1}{b2}"\']|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'|{b1}(?:[^{b1}{b2}"\']|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\'|(?R))*{b2})*)\s*{b2}'
+
+    @staticmethod
+    def outside_strings(pattern: str = r".*") -> str:
+        """Matches the `pattern` only when it is not found inside a string (`'...'` or `"..."`)."""
+        return rf'(?<!["\'])(?:{pattern})(?!["\'])'
+
+    @staticmethod
+    def all_except(
+        disallowed_pattern: str,
+        ignore_pattern: str = "",
+        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. If `is_group` is `True`, you will be able to reference the matched
+        content as a group (e.g. `match.group(int)` or `r'\\int'`)."""
+        return rf'({"" if is_group else "?:"}(?:(?!{ignore_pattern}).)*(?:(?!{Regex.outside_strings(disallowed_pattern)}).)*)'
+
+    @staticmethod
+    def func_call(func_name: str = None) -> str:
+        """Match a function call
+        - `1` function name
+        - `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`!"""
+        return r"(?<=\b)(" + (func_name if func_name else r"[\w_]+") + r")\s*" + Regex.brackets("(", ")", is_group=True)
+
+    @staticmethod
+    def rgba_str(fix_sep: str = ",", allow_alpha: bool = True) -> str:
+        """Matches an RGBA color inside a string.\n
+        ----------------------------------------------------------------------------
+        The RGBA color can be in the formats (for `fix_sep = ','`):
+        - `rgba(r, g, b)`
+        - `rgba(r, g, b, a)` (if `allow_alpha=True`)
+        - `(r, g, b)`
+        - `(r, g, b, a)` (if `allow_alpha=True`)
+        - `r, g, b`
+        - `r, g, b, a` (if `allow_alpha=True`)\n
+        ----------------------------------------------------------------------------
+        ### Valid ranges:
+        - `r` 0-255 (amount: red)
+        - `g` 0-255 (amount: green)
+        - `b` 0-255 (amount: blue)
+        - `a` 0-1 (float: opacity)\n
+        ----------------------------------------------------------------------------
+        If the `fix_sep` is set to nothing, any char that is not a letter or number
+        can be used to separate the RGBA values, including just a space."""
+        if fix_sep in (None, ""):
+            fix_sep = r"[^0-9A-Z]"
+        else:
+            fix_sep = _re.escape(fix_sep)
+        rgb_part = rf"""((?:0*(?:25[0-5]|2[0-4][0-9]|1?[0-9]{{1,2}})))
+            (?:\s*{fix_sep}\s*)((?:0*(?:25[0-5]|2[0-4][0-9]|1?[0-9]{{1,2}})))
+            (?:\s*{fix_sep}\s*)((?:0*(?:25[0-5]|2[0-4][0-9]|1?[0-9]{{1,2}})))"""
+        return (
+            rf"""(?ix)
+            (?:rgb|rgba)?\s*(?:\(?\s*{rgb_part}
+                (?:(?:\s*{fix_sep}\s*)((?:0*(?:0?\.[0-9]+|1\.0+|[0-9]+\.[0-9]+|[0-9]+))))?
+            \s*\)?)"""
+            if allow_alpha
+            else rf"(?ix)(?:rgb|rgba)?\s*(?:\(?\s*{rgb_part}\s*\)?)"
+        )
+
+    @staticmethod
+    def hsla_str(fix_sep: str = ",", allow_alpha: bool = True) -> str:
+        """Matches a HSLA color inside a string.\n
+        ----------------------------------------------------------------------------
+        The HSLA color can be in the formats (for `fix_sep = ','`):
+        - `hsla(h, s, l)`
+        - `hsla(h, s, l, a)` (if `allow_alpha=True`)
+        - `(h, s, l)`
+        - `(h, s, l, a)` (if `allow_alpha=True`)
+        - `h, s, l`
+        - `h, s, l, a` (if `allow_alpha=True`)\n
+        ----------------------------------------------------------------------------
+        ### Valid ranges:
+        - `h` 0-360 (degrees: hue)
+        - `s` 0-100 (percentage: saturation)
+        - `l` 0-100 (percentage: lightness)
+        - `a` 0-1 (float: opacity)\n
+        ----------------------------------------------------------------------------
+        If the `fix_sep` is set to nothing, any char that is not a letter or number
+        can be used to separate the HSLA values, including just a space."""
+        if fix_sep in (None, ""):
+            fix_sep = r"[^0-9A-Z]"
+        else:
+            fix_sep = _re.escape(fix_sep)
+        hsl_part = rf"""((?:0*(?:360|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])))
+            (?:\s*{fix_sep}\s*)((?:0*(?:100|[1-9][0-9]|[0-9])))
+            (?:\s*{fix_sep}\s*)((?:0*(?:100|[1-9][0-9]|[0-9])))"""
+        return (
+            rf"""(?ix)
+            (?:hsl|hsla)?\s*(?:\(?\s*{hsl_part}
+                (?:(?:\s*{fix_sep}\s*)((?:0*(?:0?\.[0-9]+|1\.0+|[0-9]+\.[0-9]+|[0-9]+))))?
+            \s*\)?)"""
+            if allow_alpha
+            else rf"(?ix)(?:hsl|hsla)?\s*(?:\(?\s*{hsl_part}\s*\)?)"
+        )
+
+    @staticmethod
+    def hexa_str(allow_alpha: bool = True) -> str:
+        """Matches a HEXA color inside a string.\n
+        ----------------------------------------------------------------------
+        The HEXA color can be in the formats (prefix `#`, `0x` or no prefix):
+        - `RGB`
+        - `RGBA` (if `allow_alpha=True`)
+        - `RRGGBB`
+        - `RRGGBBAA` (if `allow_alpha=True`)\n
+        ----------------------------------------------------------------------
+        ### Valid ranges:
+        each channel from 0-9 and A-F (case insensitive)"""
+        return (
+            r"(?i)^(?:#|0x)?[0-9A-F]{8}|[0-9A-F]{6}|[0-9A-F]{4}|[0-9A-F]{3}$"
+            if allow_alpha
+            else r"(?i)^(?:#|0x)?[0-9A-F]{6}|[0-9A-F]{3}$"
+        )

xulbux/xx_string.py

@@ -0,0 +1,159 @@
+import re as _re
+
+
+class String:
+
+    @staticmethod
+    def to_type(string: str) -> any:
+        """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"
+        # NONE
+        elif _re.match(r"(?i)^(none|null|undefined)$", string):
+            return None
+        # 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 _re.findall(
+                    r"((?:[^:,{}]+|\[.*?\]|\(.*?\)|\{.*?\})+)\s*:\s*((?:[^:,{}]+|\[.*?\]|\(.*?\)|\{.*?\})+)", string[1:-1]
+                )
+            }
+        # 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:
+        """Replaces all special space characters with normal spaces.
+        Also replaces tab characters with `tab_spaces` spaces."""
+        return (
+            string.replace("\t", " " * tab_spaces)
+            .replace("\u2000", " ")
+            .replace("\u2001", " ")
+            .replace("\u2002", " ")
+            .replace("\u2003", " ")
+            .replace("\u2004", " ")
+            .replace("\u2005", " ")
+            .replace("\u2006", " ")
+            .replace("\u2007", " ")
+            .replace("\u2008", " ")
+            .replace("\u2009", " ")
+            .replace("\u200A", " ")
+        )
+
+    @staticmethod
+    def escape(string: str, str_quotes: str = '"') -> str:
+        """Escapes the special characters and quotes inside a string.\n
+        ---------------------------------------------------------------------------
+        `str_quotes` can be either `"` or `'` and should match the quotes,
+        the string will be put inside of. So if your string will be `"string"`,
+        you should pass `"` to the parameter `str_quotes`.
+        That way, if the string includes the same quotes, they will be escaped."""
+        string = (
+            string.replace("\\", r"\\")
+            .replace("\n", r"\n")
+            .replace("\r", r"\r")
+            .replace("\t", r"\t")
+            .replace("\b", r"\b")
+            .replace("\f", r"\f")
+            .replace("\a", r"\a")
+        )
+        if str_quotes == '"':
+            string = string.replace(r"\\'", "'").replace(r'"', r"\"")
+        elif str_quotes == "'":
+            string = string.replace(r'\\"', '"').replace(r"'", r"\'")
+        return string
+
+    @staticmethod
+    def is_empty(string: str, spaces_are_empty: bool = False):
+        """Returns `True` if the string is empty and `False` otherwise.\n
+        -------------------------------------------------------------------------------------------
+        If `spaces_are_empty` is true, it will also return `True` if the string is only spaces."""
+        return (string in (None, "")) or (spaces_are_empty and isinstance(string, str) and not string.strip())
+
+    @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.
+        - 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:
+            return False
+
+    @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])|[{_re.escape(seps)}]", case_string)
+        ]
+
+    @staticmethod
+    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."""
+        parts = String.decompose(string)
+        return ("" if upper else parts[0].lower()) + "".join(part.capitalize() for part in (parts if upper else parts[1:]))
+
+    @staticmethod
+    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_lines(string: str, remove_empty_lines: bool = False) -> list[str]:
+        """Will split the string into lines."""
+        if not remove_empty_lines:
+            return string.splitlines()
+        lines = string.splitlines()
+        if not lines:
+            return []
+        non_empty_lines = [line for line in lines if line.strip()]
+        if not non_empty_lines:
+            return []
+        return non_empty_lines
+
+    @staticmethod
+    def remove_consecutive_empty_lines(string: str, max_consecutive: int = 0) -> str:
+        """Will remove consecutive empty lines from the string.\n
+        --------------------------------------------------------------------------------------------
+        - If `max_consecutive` is `0`, it will remove all consecutive empty lines.
+        - If `max_consecutive` is bigger than `0`, it will only allow `max_consecutive` consecutive
+        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)]

xulbux/xx_system.py

@@ -0,0 +1,85 @@
+import subprocess as _subprocess
+import platform as _platform
+import time as _time
+import sys as _sys
+import os as _os
+
+
+class System:
+
+    @staticmethod
+    def restart(
+        prompt: object = None,
+        wait: int = 0,
+        continue_program: bool = False,
+        force: bool = False,
+    ) -> None:
+        """Starts a system restart:
+        - `prompt` is the message to be displayed in the systems restart notification.
+        - `wait` is the time to wait until restarting in seconds.
+        - `continue_program` is whether to continue the current Python program after calling this function.
+        - `force` is whether to force a restart even if other processes are still running."""
+        system = _platform.system().lower()
+        if system == "windows":
+            if not force:
+                output = _subprocess.check_output("tasklist", shell=True).decode()
+                processes = [line.split()[0] for line in output.splitlines()[3:] if line.strip()]
+                if len(processes) > 2:  # EXCLUDING THE PYTHON PROCESS AND CMD
+                    raise RuntimeError("Processes are still running. Use the parameter `force=True` to restart anyway.")
+            if prompt:
+                _os.system(f'shutdown /r /t {wait} /c "{prompt}"')
+            else:
+                _os.system("shutdown /r /t 0")
+            if continue_program:
+                print(f"Restarting in {wait} seconds...")
+                _time.sleep(wait)
+        elif system in ("linux", "darwin"):
+            if not force:
+                output = _subprocess.check_output(["ps", "-A"]).decode()
+                processes = output.splitlines()[1:]  # EXCLUDE HEADER
+                if len(processes) > 2:  # EXCLUDING THE PYTHON PROCESS AND PS
+                    raise RuntimeError("Processes are still running. Use the parameter `force=True` to restart anyway.")
+            if prompt:
+                _subprocess.Popen(["notify-send", "System Restart", prompt])
+                _time.sleep(wait)
+            try:
+                _subprocess.run(["sudo", "shutdown", "-r", "now"])
+            except _subprocess.CalledProcessError:
+                raise PermissionError("Failed to restart: insufficient privileges. Ensure sudo permissions are granted.")
+            if continue_program:
+                print(f"Restarting in {wait} seconds...")
+                _time.sleep(wait)
+        else:
+            raise NotImplementedError(f"Restart not implemented for `{system}`")
+
+    @staticmethod
+    def check_libs(
+        lib_names: list[str],
+        install_missing: bool = False,
+        confirm_install: bool = True,
+    ) -> None | list[str]:
+        """Checks if the given list of libraries are installed. If not:
+        - If `install_missing` is `False` the missing libraries will be returned as a list.
+        - If `install_missing` is `True` the missing libraries will be installed.
+        - If `confirm_install` is `True` the user will first be asked if they want to install the missing libraries."""
+        missing = []
+        for lib in lib_names:
+            try:
+                __import__(lib)
+            except ImportError:
+                missing.append(lib)
+        if not missing:
+            return None
+        elif not install_missing:
+            return missing
+        if confirm_install:
+            print("The following required libraries are missing:")
+            for lib in missing:
+                print(f"- {lib}")
+            if input("Do you want to install them now (Y/n):  ").strip().lower() not in ("", "y", "yes"):
+                raise ImportError("Missing required libraries.")
+        try:
+            _subprocess.check_call([_sys.executable, "-m", "pip", "install"] + missing)
+            return None
+        except _subprocess.CalledProcessError:
+            return missing

xulbux-1.6.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+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.

xulbux-1.6.1.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.2
+Name: xulbux
+Version: 1.6.1
+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.6.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+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,,

xulbux-1.6.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

xulbux-1.6.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+xulbux-help = xulbux._cli_:help_command
+xx-help = xulbux._cli_:help_command

xulbux-1.6.1.dist-info/top_level.txt

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