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

xulbux/xx_path.py

@@ -5,41 +5,48 @@ import sys as _sys
 import os as _os
 
 
-
-
 class Path:
 
     @staticmethod
-    def get(cwd:bool = False, base_dir:bool = False) -> str|list:
+    def get(cwd: bool = False, base_dir: bool = False) -> str | list:
         paths = []
         if cwd:
             paths.append(_os.getcwd())
         if base_dir:
-            if getattr(_sys, 'frozen', False):
+            if getattr(_sys, "frozen", False):
                 base_path = _os.path.dirname(_sys.executable)
             else:
-                main_module = _sys.modules['__main__']
-                if hasattr(main_module, '__file__'):
+                main_module = _sys.modules["__main__"]
+                if hasattr(main_module, "__file__"):
                     base_path = _os.path.dirname(_os.path.abspath(main_module.__file__))
-                elif hasattr(main_module, '__spec__') and main_module.__spec__ and getattr(main_module.__spec__, 'origin', None):
+                elif (
+                    hasattr(main_module, "__spec__") and main_module.__spec__ and getattr(main_module.__spec__, "origin", None)
+                ):
                     base_path = _os.path.dirname(_os.path.abspath(main_module.__spec__.origin))
                 else:
-                    raise RuntimeError('Can only get base directory if ran from a file.')
+                    raise RuntimeError("Can only get base directory if ran from a file.")
             paths.append(base_path)
         return paths[0] if len(paths) == 1 else paths
 
     @staticmethod
-    def extend(path:str, search_in:str|list[str] = None, raise_error:bool = False, correct_path:bool = False) -> str:
-        if path in (None, ''):
+    def extend(
+        path: str,
+        search_in: str | list[str] = None,
+        raise_error: bool = False,
+        correct_path: bool = False,
+    ) -> str:
+        if path in (None, ""):
             return path
-        def get_closest_match(dir:str, part:str) -> str|None:
+
+        def get_closest_match(dir: str, part: str) -> str | None:
             try:
                 files_and_dirs = _os.listdir(dir)
                 matches = _difflib.get_close_matches(part, files_and_dirs, n=1, cutoff=0.6)
                 return matches[0] if matches else None
-            except:
+            except Exception:
                 return None
-        def find_path(start:str, parts:list[str]) -> str|None:
+
+        def find_path(start: str, parts: list[str]) -> str | None:
             current = start
             for part in parts:
                 if _os.path.isfile(current):
@@ -49,23 +56,30 @@ class Path:
                 if current is None:
                     return None
             return current if _os.path.exists(current) and current != start else None
-        def expand_env_path(p:str) -> str:
-            if not '%' in p:
+
+        def expand_env_path(p: str) -> str:
+            if "%" not in p:
                 return p
-            parts = p.split('%')
+            parts = p.split("%")
             for i in range(1, len(parts), 2):
                 if parts[i].upper() in _os.environ:
                     parts[i] = _os.environ[parts[i].upper()]
-            return ''.join(parts)
+            return "".join(parts)
+
         path = _os.path.normpath(expand_env_path(path))
         if _os.path.isabs(path):
             drive, rel_path = _os.path.splitdrive(path)
             rel_path = rel_path.lstrip(_os.sep)
-            search_dirs = [drive + _os.sep] if drive else [_os.sep]
+            search_dirs = (drive + _os.sep) if drive else [_os.sep]
         else:
             rel_path = path.lstrip(_os.sep)
             base_dir = Path.get(base_dir=True)
-            search_dirs = [_os.getcwd(), base_dir, _os.path.expanduser('~'), _tempfile.gettempdir()]
+            search_dirs = (
+                _os.getcwd(),
+                base_dir,
+                _os.path.expanduser("~"),
+                _tempfile.gettempdir(),
+            )
         if search_in:
             search_dirs.extend([search_in] if isinstance(search_in, str) else search_in)
         path_parts = rel_path.split(_os.sep)
@@ -74,13 +88,14 @@ class Path:
             if _os.path.exists(full_path):
                 return full_path
             match = find_path(search_dir, path_parts) if correct_path else None
-            if match: return match
+            if match:
+                return match
         if raise_error:
-            raise FileNotFoundError(f'Path \'{path}\' not found in specified directories.')
+            raise FileNotFoundError(f"Path '{path}' not found in specified directories.")
         return _os.path.join(search_dirs[0], rel_path)
 
     @staticmethod
-    def remove(path:str, only_content:bool = False) -> None:
+    def remove(path: str, only_content: bool = False) -> None:
         if not _os.path.exists(path):
             return None
         if not only_content:
@@ -94,4 +109,4 @@ class Path:
                     elif _os.path.isdir(file_path):
                         _shutil.rmtree(file_path)
                 except Exception as e:
-                    raise Exception(f'Failed to delete {file_path}. Reason: {e}')
+                    raise Exception(f"Failed to delete {file_path}. Reason: {e}")

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 = True) -> str:
         """Matches an RGBA color inside a string.\n
         --------------------------------------------------------------------------------
         The RGBA color can be in the formats (for `fix_sep = ','`):<br>
@@ -78,21 +87,25 @@ class Regex:
         `a` 0-1 (float: opacity)\n
         --------------------------------------------------------------------------------
         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]'
+        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}})))
+        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 = True) -> str:
         """Matches a HSLA color inside a string.\n
         --------------------------------------------------------------------------------
         The HSLA color can be in the formats (for `fix_sep = ','`):<br>
@@ -110,15 +123,37 @@ class Regex:
         `a` 0-1 (float: opacity)\n
         --------------------------------------------------------------------------------
         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]'
+        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])))
+        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*\)?)"
+        )
+
+    @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):<br>
+        `RGB`<br>
+        `RGBA` (if `allow_alpha=True`)<br>
+        `RRGGBB`<br>
+        `RRGGBBAA` (if `allow_alpha=True`)\n
+        --------------------------------------------------------------------------
+        ### Valid ranges:<br>
+        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

@@ -1,64 +1,116 @@
 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 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,<br>
+        the string will be put inside of. So if your string will be `"string"`,<br>
+        you should pass `"` to the parameter `str_quotes`.<br>
+        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 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 is_empty(string: str, spaces_are_empty: bool = False):
+        """Returns `True` if the string is empty and `False` otherwise.<br>
+        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.<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 +123,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