xulbux 1.5.5__py3-none-any.whl → 1.5.7__py3-none-any.whl

xulbux/xx_regex.py

@@ -9,12 +9,9 @@ Really long regex code presets:<br>
 `hsla_str` match a HSLA color
 """
 
-
 import re as _re
 
 
-
-
 class Regex:
 
     @staticmethod
@@ -25,42 +22,54 @@ 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:
+    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
+        **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:
+    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:
+    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.<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>)."""
+        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>).
+        """
         return rf'({"" if is_group else "?:"}(?:(?!{ignore_pattern}).)*(?:(?!{Regex.outside_strings(disallowed_pattern)}).)*)'
 
     @staticmethod
-    def func_call(func_name:str = None) -> str:
+    def func_call(func_name: str = None) -> str:
         """Match a function call<br>
         **`1`** function name<br>
         **`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)
+        **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 = False) -> str:
+    def rgba_str(fix_sep: str = ",", allow_alpha: bool = False) -> str:
         """Matches an RGBA color inside a string.\n
         --------------------------------------------------------------------------------
         The RGBA color can be in the formats (for `fix_sep = ','`):<br>
@@ -79,20 +88,24 @@ class Regex:
         --------------------------------------------------------------------------------
         If the `fix_sep` is set to nothing, any char that is not a letter or number<br>
         can be used to separate the RGB values, including just a space."""
-        if fix_sep in (None, ''):
-            fix_sep = r'[^0-9A-Z]'
+        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}})))
+        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)
+            (?:\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*\)?)'
+            \s*\)?)"""
+            if allow_alpha
+            else rf"(?ix)(?:rgb|rgba)?\s*(?:\(?\s*{rgb_part}\s*\)?)"
+        )
 
     @staticmethod
-    def hsla_str(fix_sep:str = ',', allow_alpha:bool = False) -> str:
+    def hsla_str(fix_sep: str = ",", allow_alpha: bool = False) -> str:
         """Matches a HSLA color inside a string.\n
         --------------------------------------------------------------------------------
         The HSLA color can be in the formats (for `fix_sep = ','`):<br>
@@ -111,14 +124,18 @@ class Regex:
         --------------------------------------------------------------------------------
         If the `fix_sep` is set to nothing, any char that is not a letter or number<br>
         can be used to separate the HSL values, including just a space."""
-        if fix_sep in (None, ''):
-            fix_sep = r'[^0-9A-Z]'
+        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])))
+        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)
+            (?:\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*\)?)'
+            \s*\)?)"""
+            if allow_alpha
+            else rf"(?ix)(?:hsl|hsla)?\s*(?:\(?\s*{hsl_part}\s*\)?)"
+        )

xulbux/xx_string.py

@@ -1,64 +1,87 @@
 import re as _re
 
 
-
-
 class String:
 
     @staticmethod
-    def to_type(value:str) -> any:
+    def to_type(string: str) -> any:
         """Will convert a string to a type."""
-        if value.lower() in ['true', 'false']:  # BOOLEAN
-            return value.lower() == 'true'
-        elif value.lower() in ['none', 'null', 'undefined']:  # NONE
+        if string.lower() in ("true", "false"):  # BOOLEAN
+            return string.lower() == "true"
+        elif string.lower() in ("none", "null", "undefined"):  # NONE
             return None
-        elif value.startswith('[') and value.endswith(']'):  # LIST
-            return [String.to_type(item.strip()) for item in value[1:-1].split(',') if item.strip()]
-        elif value.startswith('(') and value.endswith(')'):  # TUPLE
-            return tuple(String.to_type(item.strip()) for item in value[1:-1].split(',') if item.strip())
-        elif value.startswith('{') and value.endswith('}'):  # SET
-            return {String.to_type(item.strip()) for item in value[1:-1].split(',') if item.strip()}
-        elif value.startswith('{') and value.endswith('}') and ':' in value:  # DICTIONARY
-            return {String.to_type(k.strip()): String.to_type(v.strip()) for k, v in [item.split(':') for item in value[1:-1].split(',') if item.strip()]}
+        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
+            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())
+            }
         try:  # NUMBER (INT OR FLOAT)
-            if '.' in value or 'e' in value.lower():
-                return float(value)
+            if "." in string or "e" in string.lower():
+                return float(string)
             else:
-                return int(value)
-        except ValueError: pass
-        if value.startswith(("'", '"')) and value.endswith(("'", '"')):  # STRING (WITH OR WITHOUT QUOTES)
-            return value[1:-1]
+                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(value)
-        except ValueError: pass
-        return value  # IF NOTHING ELSE MATCHES, RETURN AS IS
+            return complex(string)
+        except ValueError:
+            pass
+        return string  # IF NOTHING ELSE MATCHES, RETURN AS IS
+
+    @staticmethod
+    def normalize_spaces(string: str, tab_spaces: int = 4) -> str:
+        """Replaces all special space characters with normal spaces.<br>
+        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 get_repeated_symbol(string:str, symbol:str) -> int|bool:
-        """If the string consists of one repeating `symbol`, it returns the number of times it is repeated.<br>
-        If the string doesn't consist of one repeating symbol, it returns `False`."""
-        if len(string) == len(symbol) * string.count(symbol):
-            return string.count(symbol)
+    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 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]:
+    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])|[{seps}]", case_string)]
 
     @staticmethod
-    def to_camel_case(string:str) -> str:
+    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))
+        return "".join(part.capitalize() for part in String.decompose(string))
 
     @staticmethod
-    def to_snake_case(string:str, sep:str = '_', screaming:bool = False) -> str:
+    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))
 
     @staticmethod
-    def get_string_lines(string:str, remove_empty_lines:bool = False) -> list[str]:
+    def get_string_lines(string: str, remove_empty_lines: bool = False) -> list[str]:
         """Will split the string into lines."""
         if not remove_empty_lines:
             return string.splitlines()
@@ -71,46 +94,51 @@ class String:
         return non_empty_lines
 
     @staticmethod
-    def remove_consecutive_empty_lines(string:str, max_consecutive:int = 0) -> str:
+    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.<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."""
-        return _re.sub(r'(\n\s*){2,}', r'\1' * (max_consecutive + 1), string)
+        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_every_chars(string:str, split:int) -> list[str]:
-        """Will split the string every `split` characters."""
-        return [string[i:i + split] for i in range(0, len(string), split)]
+    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:
+    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
+            else:
+                break
         for char in string[::-1]:
             if char in strip_chars:
                 string = string[:-1]
-            else: break
+            else:
+                break
         return string
 
     @staticmethod
-    def multi_lstrip(string:str, strip_chars:str = ' _-') -> str:
+    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
+            else:
+                break
         return string
 
     @staticmethod
-    def multi_rstrip(string:str, strip_chars:str = ' _-') -> str:
+    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
+            else:
+                break
         return string

xulbux/xx_system.py

@@ -5,71 +5,82 @@ 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:
+    def restart(
+        prompt: object = None,
+        wait: int = 0,
+        continue_program: bool = False,
+        force: bool = False,
+    ) -> None:
         """Starts a system restart:<br>
         `prompt` is the message to be displayed in the systems restart notification.<br>
         `wait` is the time to wait until restarting in seconds.<br>
         `continue_program` is whether to continue the current Python program after calling this function.<br>
-        `force` is whether to force a restart even if other processes are still running."""
+        `force` is whether to force a restart even if other processes are still running.
+        """
         system = _platform.system().lower()
-        if system == 'windows':
+        if system == "windows":
             if not force:
-                output = _subprocess.check_output('tasklist', shell=True).decode()
+                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.')
+                    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')
+                _os.system("shutdown /r /t 0")
             if continue_program:
-                print(f'Restarting in {wait} seconds...')
+                print(f"Restarting in {wait} seconds...")
                 _time.sleep(wait)
-        elif system in ['linux', 'darwin']:
+        elif system in ("linux", "darwin"):
             if not force:
-                output = _subprocess.check_output(['ps', '-A']).decode()
+                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.')
+                    raise RuntimeError("Processes are still running. Use the parameter `force=True` to restart anyway.")
             if prompt:
-                _subprocess.Popen(['notify-send', 'System Restart', prompt])
+                _subprocess.Popen(["notify-send", "System Restart", prompt])
                 _time.sleep(wait)
             try:
-                _subprocess.run(['sudo', 'shutdown', '-r', 'now'])
+                _subprocess.run(["sudo", "shutdown", "-r", "now"])
             except _subprocess.CalledProcessError:
-                raise PermissionError('Failed to restart: insufficient privileges. Ensure sudo permissions are granted.')
+                raise PermissionError("Failed to restart: insufficient privileges. Ensure sudo permissions are granted.")
             if continue_program:
-                print(f'Restarting in {wait} seconds...')
+                print(f"Restarting in {wait} seconds...")
                 _time.sleep(wait)
         else:
-            raise NotImplementedError(f'Restart not implemented for `{system}`')
+            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]:
+    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."""
+        - 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)
+            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:')
+            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.')
+                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)
+            _subprocess.check_call([_sys.executable, "-m", "pip", "install"] + missing)
             return None
         except _subprocess.CalledProcessError:
             return missing

{xulbux-1.5.5.dist-info → xulbux-1.5.7.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: XulbuX
-Version: 1.5.5
+Version: 1.5.7
 Summary: A library which includes a lot of really helpful functions.
-Project-URL: Homepage, https://github.com/XulbuX-dev/Python/tree/main/Libraries/XulbuX
-Project-URL: Bug Reports, https://github.com/XulbuX-dev/Python/issues
-Project-URL: Documentation, https://github.com/XulbuX-dev/Python/wiki
-Project-URL: Source Code, https://github.com/XulbuX-dev/Python/tree/main/Libraries/XulbuX/src
-Project-URL: Changelog, https://github.com/XulbuX-dev/Python/blob/main/Libraries/XulbuX/CHANGELOG.md
+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
         
@@ -29,7 +29,7 @@ License: MIT License
         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,helpful,json,library,methods,operations,path,presets,python,regex,string,structures,system,tools,types,utility,xulbux
+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
@@ -41,17 +41,21 @@ 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: pytest>=7.0; 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/Python/blob/main/Libraries/XulbuX/CHANGELOG.md).<br>
-For precise information about the library, see the library's [Wiki page](https://github.com/XulbuX-dev/Python/wiki).
+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

xulbux-1.5.7.dist-info/RECORD

@@ -0,0 +1,20 @@
+xulbux/__init__.py,sha256=h6v5Ld_jy1LeTD8hZLfOZUIljUScCRu1FnHRJP1Dp54,1660
+xulbux/_cli_.py,sha256=W6qLGAY5F17bVDCkgtU-XOwqe_UyXBxBonW8e0Gso74,3437
+xulbux/_consts_.py,sha256=HqBCzFYSk9LS2TrxPCQBQcEjEB8McLodH4ZGZ8yP3Ec,4858
+xulbux/xx_cmd.py,sha256=K8U96QSAbLgDG65zIQdniSFtJUqUgKoaHhxgyaq5qBQ,15315
+xulbux/xx_code.py,sha256=PDZi1HNzGfEfoI646N5FQOAL3nZ7cE8eETmW6pl-szA,5146
+xulbux/xx_color.py,sha256=sUZKZdx6dMNL48G5o_SHYMnYPx3sbGoGiu6NpeJkPSw,44053
+xulbux/xx_data.py,sha256=2lYt0kiZxgqqA0e8u8k6VQr8juVzrZRAgio4ehUteSc,27876
+xulbux/xx_env_vars.py,sha256=nJQtddsfDo2HDG1vzmcmz2h79N3jV-J-fLayGpASRUE,2706
+xulbux/xx_file.py,sha256=pQrTsTvaa8tBHOrN9pu2r7qxi8Wzon5V43TfVGitxko,2608
+xulbux/xx_format_codes.py,sha256=OqzegaaiLJ09id6LI842bH4oyXOXbVrBM5q5jh6-z7I,13562
+xulbux/xx_json.py,sha256=wAIwC5IO8oepsYoF1tN5c4DOjSBvT2HZakUxmA-F3BE,5050
+xulbux/xx_path.py,sha256=KB1HGYCxFB3_T97RVACajy3-QiksbviZVIW9-iQcr4s,4558
+xulbux/xx_regex.py,sha256=yTGtNtuW2Cng714iuwxWz9wDN3Bw06rzXfPUVvfiXvk,7159
+xulbux/xx_string.py,sha256=znfeRrAu8OA3Dd0cmMsOm2zXZKzudS4ZuH2Pny2ulEw,6212
+xulbux/xx_system.py,sha256=yehO57ggWDRJbeFoTE1VisW4QrbkqZzAyjKoL3xHx9k,3935
+xulbux-1.5.7.dist-info/METADATA,sha256=dLdhkqGBSyklBIzk_A4zgViiXfxTKoPlYuWigz_rr-0,4336
+xulbux-1.5.7.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+xulbux-1.5.7.dist-info/entry_points.txt,sha256=KX2dtQr5OW5WdHcNqgj6rxFTqliIBNcNQq_FBOGS-0A,94
+xulbux-1.5.7.dist-info/licenses/LICENSE,sha256=6NflEcvzFEe8_JFVNCPVwZBwBhlLLd4vqQi8WiX_Xk4,1084
+xulbux-1.5.7.dist-info/RECORD,,

{xulbux-1.5.5.dist-info → xulbux-1.5.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.1
+Generator: hatchling 1.26.3
 Root-Is-Purelib: true
 Tag: py3-none-any

xulbux-1.5.7.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.5.5.dist-info/RECORD

@@ -1,20 +0,0 @@
-xulbux/__help__.py,sha256=2p_CLFMoEu4Coqs2d3dFuoZ16NQTI6aZkctVjSmq7mE,4098
-xulbux/__init__.py,sha256=8I7GLhkT_P3-KIDDZmAlbIgxmQfoh3ujgv5_aPzQt8g,1644
-xulbux/_consts_.py,sha256=vquutpFVjJsGqRi78EboXbyMczqMdAPZVnAyqcwzJ6k,5313
-xulbux/xx_cmd.py,sha256=9rmnq7YkgfzBoCpcyai0FKZTcBPpMjw3L15-FORUdnI,14070
-xulbux/xx_code.py,sha256=wnQuA0gfxd-Q_sCW-R3Sqw4Ld6u4TQMRAJGzMgTDiqk,5520
-xulbux/xx_color.py,sha256=TqsY5akT9vzHMWJZQ0Ggev5DIzfHaCcq0Tgd-sp15TM,42106
-xulbux/xx_data.py,sha256=U9qzEZFVV_I6CgjbENfz2SuhvIN31Y9t_EtOhccF-6c,26127
-xulbux/xx_env_vars.py,sha256=zN0xFtqukQO9TdR-Ci7sky4s5m2wjQQUfhrhdcNaS1Y,2394
-xulbux/xx_file.py,sha256=CEv5n-ZG_l7HK2ClVQWRiqlERaHhHeGvy0W4rr8OrMI,2513
-xulbux/xx_format_codes.py,sha256=O7DnVnzwa1riiHP9DbRtpMD1LNrOKMT4xpwngt49iPo,12939
-xulbux/xx_json.py,sha256=Z4617tA2VJIdHxQIGCbx99ubLTYj1Dky75C7qiORkWg,4827
-xulbux/xx_path.py,sha256=P_r8WzJygtDCFuQxcEONlkW_exkHxRaqJoUxnPBetyo,4338
-xulbux/xx_regex.py,sha256=s3AsnlMrwblz57BjygV-fjgFn0AguopvZLCKWHVd3ZA,6921
-xulbux/xx_string.py,sha256=gwwY8pTB7d6gJgp8lo8pUftnyJBna0VQ4oFFc_AmOjo,5297
-xulbux/xx_system.py,sha256=2zqqT_oqCPDPzaUBSNMC8awRhSUHQtwIwju9pIQQQQ4,3797
-xulbux-1.5.5.dist-info/METADATA,sha256=PorHfyAoYZ3R8blKx0TAlsqqT9qcZ5auVdlVBJ97L5Y,4162
-xulbux-1.5.5.dist-info/WHEEL,sha256=3U_NnUcV_1B1kPkYaPzN-irRckL5VW_lytn0ytO_kRY,87
-xulbux-1.5.5.dist-info/entry_points.txt,sha256=hfQ1MjdOLVbINRpbJVzNcqRbAouwYF4a-5kzO69zcHE,46
-xulbux-1.5.5.dist-info/licenses/LICENSE,sha256=6NflEcvzFEe8_JFVNCPVwZBwBhlLLd4vqQi8WiX_Xk4,1084
-xulbux-1.5.5.dist-info/RECORD,,

xulbux-1.5.5.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-xulbux-help = __help__:help