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

xulbux/xx_env_path.py

@@ -0,0 +1,113 @@
+"""
+Functions for modifying and checking the systems environment-variables:
+- `EnvPath.paths()`
+- `EnvPath.has_path()`
+- `EnvPath.add_path()`
+- `EnvPath.remove_path()`
+"""
+
+from .xx_path import Path
+
+import os as _os
+import sys as _sys
+
+
+class EnvPath:
+
+    @staticmethod
+    def paths(as_list: bool = False) -> str | list:
+        """Get the PATH environment variable."""
+        paths = _os.environ.get("PATH", "")
+        return paths.split(_os.pathsep) if as_list else paths
+
+    @staticmethod
+    def has_path(path: str = None, cwd: bool = False, base_dir: bool = False) -> bool:
+        """Check if a path is present in the PATH environment variable."""
+        if cwd:
+            path = _os.getcwd()
+        elif base_dir:
+            path = Path.get(base_dir=True)
+        elif path is None:
+            raise ValueError("A path must be provided or either 'cwd' or 'base_dir' must be True.")
+        paths = EnvPath.paths(as_list=True)
+        return _os.path.normpath(path) in [_os.path.normpath(p) for p in paths]
+
+    @staticmethod
+    def add_path(
+        path: str = None,
+        cwd: bool = False,
+        base_dir: bool = False,
+    ) -> None:
+        """Add a path to the PATH environment variable."""
+        path = EnvPath.__get(path, cwd, base_dir)
+        if not EnvPath.has_path(path):
+            EnvPath.__persistent(path, add=True)
+
+    @staticmethod
+    def remove_path(
+        path: str = None,
+        cwd: bool = False,
+        base_dir: bool = False,
+    ) -> None:
+        """Remove a path from the PATH environment variable."""
+        path = EnvPath.__get(path, cwd, base_dir)
+        if EnvPath.has_path(path):
+            EnvPath.__persistent(path, remove=True)
+
+    @staticmethod
+    def __get(
+        path: str = None,
+        cwd: bool = False,
+        base_dir: bool = False,
+    ) -> list:
+        """Get and/or normalize the paths.<br>
+        Raise an error if no path is provided and<br>
+        neither `cwd` or `base_dir` is `True`."""
+        if cwd:
+            path = _os.getcwd()
+        elif base_dir:
+            path = Path.get(base_dir=True)
+        elif path is None:
+            raise ValueError("A path must be provided or either 'cwd' or 'base_dir' must be True.")
+        return _os.path.normpath(path)
+
+    @staticmethod
+    def __persistent(path: str, add: bool = False, remove: bool = False) -> None:
+        """Add or remove a path from PATH persistently across sessions as well as the current session."""
+        if add == remove:
+            raise ValueError("Either add or remove must be True, but not both.")
+        current_paths = EnvPath.paths(as_list=True)
+        path = _os.path.normpath(path)
+        if remove:
+            current_paths = [p for p in current_paths if _os.path.normpath(p) != _os.path.normpath(path)]
+        elif add:
+            current_paths.append(path)
+        _os.environ["PATH"] = new_path = _os.pathsep.join(sorted(set(filter(bool, current_paths))))
+        if _sys.platform == "win32":  # Windows
+            try:
+                import winreg as _winreg
+
+                key = _winreg.OpenKey(
+                    _winreg.HKEY_CURRENT_USER,
+                    "Environment",
+                    0,
+                    _winreg.KEY_ALL_ACCESS,
+                )
+                _winreg.SetValueEx(key, "PATH", 0, _winreg.REG_EXPAND_SZ, new_path)
+                _winreg.CloseKey(key)
+            except ImportError:
+                print("Warning: Unable to make persistent changes on Windows.")
+        else:  # UNIX-like (Linux/macOS)
+            shell_rc_file = _os.path.expanduser(
+                "~/.bashrc" if _os.path.exists(_os.path.expanduser("~/.bashrc")) else "~/.zshrc"
+            )
+            with open(shell_rc_file, "r+") as f:
+                content = f.read()
+                f.seek(0)
+                if remove:
+                    new_content = [line for line in content.splitlines() if not line.endswith(f':{path}"')]
+                    f.write("\n".join(new_content))
+                else:
+                    f.write(f'{content.rstrip()}\n# Added by XulbuX\nexport PATH="{new_path}"\n')
+                f.truncate()
+            _os.system(f"source {shell_rc_file}")

xulbux/xx_file.py

@@ -1,50 +1,56 @@
-from .xx_string import *
-from .xx_path import *
+from .xx_string import String
+from .xx_path import Path
 
 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:
+    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()}'
+        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)
+            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:
+    def rename_extension(file_path: str, new_extension: str) -> str:
         directory, filename_with_ext = _os.path.split(file_path)
-        filename = filename_with_ext.split('.')[0]
+        filename = filename_with_ext.split(".")[0]
         camel_case_filename = String.to_camel_case(filename)
-        new_filename = f'{camel_case_filename}{new_extension}'
+        new_filename = f"{camel_case_filename}{new_extension}"
         new_file_path = _os.path.join(directory, new_filename)
         return new_file_path
 
     @staticmethod
-    def create(content:str = '', file:str = 'new_file.txt', force:bool = False) -> str:
+    def create(content: str = "", file: str = "new_file.txt", force: bool = False) -> str:
         """Create a file with ot without content.\n
         ----------------------------------------------------------------------------
         The function will throw a `FileExistsError` if the file already exists.<br>
         To overwrite the file, set the `force` parameter to `True`."""
         if _os.path.exists(file) and not force:
-            with open(file, 'r', encoding='utf-8') as existing_file:
+            with open(file, "r", encoding="utf-8") as existing_file:
                 existing_content = existing_file.read()
                 if existing_content == content:
-                    raise FileExistsError('Already created this file. (nothing changed)')
-            raise FileExistsError('File already exists.')
-        with open(file, 'w', encoding='utf-8') as f:
+                    raise FileExistsError("Already created this file. (nothing changed)")
+            raise FileExistsError("File already exists.")
+        with open(file, "w", encoding="utf-8") as f:
             f.write(content)
         full_path = _os.path.abspath(file)
         return full_path

xulbux/xx_format_codes.py

@@ -64,127 +64,200 @@ Unlike the standard cmd colors, the default color can be changed by using the fo
 - `[dd]` will darken the `default_color` text by `2 × brightness_steps`%
 - `[ddd]` will darken the `default_color` text by `3 × brightness_steps`%
 - ... etc.\n
-Per default, you can also use `+` and `-` to get lighter and darker `default_color` versions.<br>
-This can also be changed by changing the param `_modifiers = ('+l', '-d')`.
+Per default, you can also use `+` and `-` to get lighter and darker `default_color` versions.
 """
 
-
 from ._consts_ import ANSI
-from .xx_string import *
-from .xx_regex import *
+from .xx_string import String
+from .xx_regex import Regex
 from .xx_color import *
-from .xx_data import *
 
+from functools import lru_cache
 import ctypes as _ctypes
 import regex as _rx
 import sys as _sys
 import re as _re
 
 
+COMPILED = {  # PRECOMPILE REGULAR EXPRESSIONS
+    "*": _re.compile(r"\[\s*([^]_]*?)\s*\*\s*([^]_]*?)\]"),
+    "*color": _re.compile(r"\[\s*([^]_]*?)\s*\*color\s*([^]_]*?)\]"),
+    "format": _rx.compile(
+        Regex.brackets("[", "]", is_group=True) + r"(?:\s*([/\\]?)\s*" + Regex.brackets("(", ")", is_group=True) + r")?"
+    ),
+    "bg?_default": _re.compile(r"(?i)((?:BG\s*:)?)\s*default"),
+    "bg_default": _re.compile(r"(?i)BG\s*:\s*default"),
+    "modifier": _re.compile(
+        rf'(?i)((?:BG\s*:)?)\s*({"|".join([f"{_re.escape(m)}+" for m in ANSI.modifier["lighten"] + ANSI.modifier["darken"]])})$'
+    ),
+    "rgb": _re.compile(r"(?i)^\s*(BG\s*:)?\s*(?:rgb|rgba)?\s*\(?\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)?\s*$"),
+    "hex": _re.compile(r"(?i)^\s*(BG\s*:)?\s*(?:#|0x)?([0-9A-F]{6}|[0-9A-F]{3})\s*$"),
+}
 
 
 class FormatCodes:
 
     @staticmethod
-    def print(*values:object, default_color:hexa|rgba = None, brightness_steps:int = 20, sep:str = ' ', end:str = '\n') -> None:
+    def print(
+        *values: object,
+        default_color: hexa | rgba = None,
+        brightness_steps: int = 20,
+        sep: str = " ",
+        end: str = "\n",
+        flush: bool = True,
+    ) -> None:
         FormatCodes.__config_console()
-        _sys.stdout.write(FormatCodes.to_ansi(sep.join(map(str, values)), default_color, brightness_steps) + end)
-        _sys.stdout.flush()
+        _sys.stdout.write(FormatCodes.to_ansi(sep.join(map(str, values)) + end, default_color, brightness_steps))
+        if flush:
+            _sys.stdout.flush()
 
     @staticmethod
-    def input(prompt:object = '', default_color:hexa|rgba = None, brightness_steps:int = 20) -> str:
+    def input(
+        prompt: object = "",
+        default_color: hexa | rgba = None,
+        brightness_steps: int = 20,
+    ) -> str:
         FormatCodes.__config_console()
         return input(FormatCodes.to_ansi(prompt, default_color, brightness_steps))
 
     @staticmethod
-    def to_ansi(string:str, default_color:hexa|rgba = None, brightness_steps:int = 20, _default_start:bool = True) -> str:
-        result, use_default = '', default_color and (Color.is_valid_rgba(default_color, False) or Color.is_valid_hexa(default_color, False))
+    def to_ansi(
+        string: str, default_color: hexa | rgba = None, brightness_steps: int = 20, _default_start: bool = True
+    ) -> str:
+        result = ""
+        if Color.is_valid_rgba(default_color, False):
+            use_default = True
+        elif Color.is_valid_hexa(default_color, False):
+            use_default, default_color = True, Color.to_rgba(default_color)
+        else:
+            use_default = False
         if use_default:
-            string = _re.sub(r'\[\s*([^]_]*?)\s*\*\s*([^]_]*?)\]', r'[\1_|default\2]', string)  # REPLACE `[…|*|…]` WITH `[…|_|default|…]`
-            string = _re.sub(r'\[\s*([^]_]*?)\s*\*color\s*([^]_]*?)\]', r'[\1default\2]', string)  # REPLACE `[…|*color|…]` WITH `[…|default|…]`
-        def replace_keys(match:_rx.Match) -> str:
-            format_keys, esc, auto_reset_txt = match.group(1), match.group(2), match.group(3)
+            string = COMPILED["*"].sub(r"[\1_|default\2]", string)  # REPLACE `[…|*|…]` WITH `[…|_|default|…]`
+            string = COMPILED["*color"].sub(r"[\1default\2]", string)  # REPLACE `[…|*color|…]` WITH `[…|default|…]`
+
+        def replace_keys(match: _re.Match) -> str:
+            format_keys = match.group(1)
+            esc = match.group(2)
+            auto_reset_txt = match.group(3)
             if not format_keys:
                 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
+                ]
+                ansi_resets = [
+                    r
+                    for k in reset_keys
+                    if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)).startswith(
+                        f"{ANSI.char}{ANSI.start}"
+                    )
+                ]
             else:
-                format_keys = [k.replace(' ', '') for k in format_keys.split('|') if k.replace(' ', '')]
-                ansi_resets, 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 Color.is_valid(k) or k in ANSI.color_map
-                        else '_bg' if (set(k.lower().split(':')) & {'bg', 'bright', 'br'} and len(k.split(':')) <= 3 and any(Color.is_valid(k[i:]) or k[i:] in ANSI.color_map for i in range(len(k))))
-                        else f'_{k}' for k in format_keys]
-                    ansi_resets = [r for k in reset_keys if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)).startswith(f'{ANSI.char}{ANSI.start}')]
-            if 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 else auto_reset_txt) if auto_reset_txt else '') + ('' if esc else ''.join(ansi_resets))
-        result = '\n'.join(_rx.sub(Regex.brackets('[', ']', is_group=True) + r'(?:\s*([/\\]?)\s*' + Regex.brackets('(', ')', is_group=True) + r')?', replace_keys, line) for line in string.splitlines())
-        return (FormatCodes.__get_default_ansi(default_color) if _default_start else '') + result if use_default else result
+                ansi_resets = []
+            if 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
+                    else auto_reset_txt if auto_reset_txt else ""
+                )
+                + ("" if esc 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
+        )
 
     @staticmethod
+    @lru_cache(maxsize=64)
     def __config_console() -> None:
         _sys.stdout.flush()
         kernel32 = _ctypes.windll.kernel32
         h = kernel32.GetStdHandle(-11)
         mode = _ctypes.c_ulong()
         kernel32.GetConsoleMode(h, _ctypes.byref(mode))
-        kernel32.SetConsoleMode(h, mode.value | 0x0004)  # ENABLE VIRTUAL TERMINAL PROCESSING
+        kernel32.SetConsoleMode(h, mode.value | 0x0004)
 
     @staticmethod
-    def __get_default_ansi(default_color:hexa|rgba, format_key:str = None, brightness_steps:int = None, _modifiers:tuple[str,str] = ('+l', '-d')) -> str|None:
-        if Color.is_valid_hexa(default_color, False):
-            default_color = Color.to_rgba(default_color)
-        if not brightness_steps or (format_key and _re.search(r'(?i)((?:BG\s*:)?)\s*default', format_key)):
-            if format_key and _re.search(r'(?i)BG\s*:\s*default', format_key):
-                return ANSI.seq_bg_color.format(default_color[0], default_color[1], default_color[2])
-            return ANSI.seq_color.format(default_color[0], default_color[1], default_color[2])
-        match = _re.match(rf'(?i)((?:BG\s*:)?)\s*({"|".join([f"{_re.escape(m)}+" for m in _modifiers[0] + _modifiers[1]])})$', format_key)
-        if not match or not match.group(2):
+    def __get_default_ansi(
+        default_color: tuple,
+        format_key: str = None,
+        brightness_steps: int = None,
+        _modifiers: tuple[str, str] = (ANSI.modifier["lighten"], ANSI.modifier["darken"]),
+    ) -> str | None:
+        if not brightness_steps or (format_key and COMPILED["bg?_default"].search(format_key)):
+            return (ANSI.seq_bg_color if format_key and COMPILED["bg_default"].search(format_key) else ANSI.seq_color).format(
+                *default_color[:3]
+            )
+        if not (format_key in _modifiers[0] or format_key in _modifiers[1]):
             return None
-        is_bg, modifier = match.group(1), match.group(2)
-        new_rgb, lighten, darken = None, None, None
-        for mod in _modifiers[0]:
-            lighten = String.get_repeated_symbol(modifier, mod)
-            if lighten and lighten > 0:
-                new_rgb = Color.adjust_lightness(default_color, (brightness_steps / 100) * lighten)
+        match = COMPILED["modifier"].match(format_key)
+        if not match:
+            return None
+        is_bg, modifiers = match.groups()
+        adjust = 0
+        for mod in _modifiers[0] + _modifiers[1]:
+            adjust = String.single_char_repeats(modifiers, mod)
+            if adjust and adjust > 0:
+                modifiers = mod
                 break
-        if not new_rgb:
-            for mod in _modifiers[1]:
-                darken = String.get_repeated_symbol(modifier, mod)
-                if darken and darken > 0:
-                    new_rgb = Color.adjust_lightness(default_color, -(brightness_steps / 100) * darken)
-                    break
-        if new_rgb:
-            return ANSI.seq_bg_color.format(new_rgb[0], new_rgb[1], new_rgb[2]) if is_bg else ANSI.seq_color.format(new_rgb[0], new_rgb[1], new_rgb[2])
+        if adjust == 0:
+            return None
+        elif modifiers in _modifiers[0]:
+            new_rgb = Color.adjust_lightness(default_color, (brightness_steps / 100) * adjust)
+        elif modifiers in _modifiers[1]:
+            new_rgb = Color.adjust_lightness(default_color, -(brightness_steps / 100) * adjust)
+        return (ANSI.seq_bg_color if is_bg else ANSI.seq_color).format(*new_rgb[:3])
 
     @staticmethod
-    def __get_replacement(format_key:str, default_color:hexa|rgba = None, brightness_steps:int = 20, _modifiers:tuple[str, str] = ('+l', '-d')) -> str:
+    def __get_replacement(format_key: str, default_color: rgba = None, brightness_steps: int = 20) -> str:
         """Gives you the corresponding ANSI code for the given format key.<br>
         If `default_color` is not `None`, the text color will be `default_color` if all formats<br>
-        are reset or you can get lighter or darker version of `default_color` (also as BG) by<br>
-        using one or more `_modifiers` symbols as a format key ()"""
-        def key_exists(key:str) -> bool:
-            for map_key in ANSI.codes_map:
-                if isinstance(map_key, tuple) and key in map_key:
-                    return True
-                elif key == map_key:
-                    return True
-            return False
-        def get_value(key:str) -> any:
-            for map_key in ANSI.codes_map:
-                if isinstance(map_key, tuple) and key in map_key:
-                    return ANSI.codes_map[map_key]
-                elif key == map_key:
-                    return ANSI.codes_map[map_key]
-            return None
-        use_default = default_color and (Color.is_valid_rgba(default_color, False) or Color.is_valid_hexa(default_color, False))
-        _format_key, format_key = format_key, FormatCodes.__normalize(format_key)
+        are reset or you can get lighter or darker version of `default_color` (also as BG)"""
+        use_default = default_color and Color.is_valid_rgba(default_color, False)
+        _format_key, format_key = format_key, (  # NORMALIZE THE FORMAT KEY (+ SAVE ORIGINAL)
+            "bg:" if "bg" in (parts := format_key.replace(" ", "").lower().split(":")) else ""
+        ) + ("bright:" if any(x in parts for x in ("bright", "br")) else "") + ":".join(
+            p for p in parts if p not in ("bg", "bright", "br")
+        )
         if use_default:
-            new_default_color = FormatCodes.__get_default_ansi(default_color, format_key, brightness_steps, _modifiers)
-            if new_default_color:
+            if new_default_color := FormatCodes.__get_default_ansi(default_color, format_key, brightness_steps):
                 return new_default_color
-        if key_exists(format_key):
-            return ANSI.seq().format(get_value(format_key))
-        rgb_match = _re.match(r'(?i)\s*(BG\s*:)?\s*(?:rgb|rgba)?\s*\(?\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)?\s*', format_key)
-        hex_match = _re.match(r'(?i)\s*(BG\s*:)?\s*(?:#|0x)?([0-9A-F]{8}|[0-9A-F]{6}|[0-9A-F]{4}|[0-9A-F]{3})\s*', format_key)
+        for map_key in ANSI.codes_map:
+            if (isinstance(map_key, tuple) and format_key in map_key) or format_key == map_key:
+                return ANSI.seq().format(
+                    next(
+                        (
+                            v
+                            for k, v in ANSI.codes_map.items()
+                            if format_key == k or (isinstance(k, tuple) and format_key in k)
+                        ),
+                        None,
+                    )
+                )
+        rgb_match = _re.match(COMPILED["rgb"], format_key)
+        hex_match = _re.match(COMPILED["hex"], format_key)
         try:
             if rgb_match:
                 is_bg = rgb_match.group(1)
@@ -194,19 +267,11 @@ class FormatCodes:
             elif hex_match:
                 is_bg = hex_match.group(1)
                 rgb = Color.to_rgba(hex_match.group(2))
-                return ANSI.seq_bg_color.format(rgb[0], rgb[1], rgb[2]) if is_bg else ANSI.seq_color.format(rgb[0], rgb[1], rgb[2])
-        except Exception: pass
+                return (
+                    ANSI.seq_bg_color.format(rgb[0], rgb[1], rgb[2])
+                    if is_bg
+                    else ANSI.seq_color.format(rgb[0], rgb[1], rgb[2])
+                )
+        except Exception:
+            pass
         return _format_key
-
-    @staticmethod
-    def __normalize(format_key:str) -> str:
-        """Put the given format key in the correct format:<br>
-        `1` put `BG:` as first key-part<br>
-        `2` put `bright:` or `br:` as second key-part<br>
-        `3` put everything else behind<br>
-        `4` everything in lower case"""
-        format_key = format_key.replace(' ', '').lower().strip()
-        if ':' in format_key:
-            key_parts = format_key.split(':')
-            format_key = ('bg:' if 'bg' in key_parts else '') + ('bright:' if 'bright' in key_parts or 'br' in key_parts else '') + ''.join(Data.remove(key_parts, ['bg', 'bright', 'br']))
-        return format_key

xulbux/xx_json.py

@@ -1,16 +1,19 @@
-from .xx_data import *
-from .xx_file import *
+from .xx_data import Data
+from .xx_file import File
 
 import json as _json
 import os as _os
 
 
-
-
 class Json:
 
     @staticmethod
-    def read(json_file:str, comment_start:str = '>>', comment_end:str = '<<', return_original:bool = False) -> dict|tuple[dict,dict]:
+    def read(
+        json_file: str,
+        comment_start: str = ">>",
+        comment_end: str = "<<",
+        return_original: bool = False,
+    ) -> dict | tuple[dict, dict]:
         """Read JSON files, ignoring comments.\n
         -------------------------------------------------------------------------
         If only `comment_start` is found at the beginning of an item,<br>
@@ -19,8 +22,8 @@ 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)
-        with open(file_path, 'r') as f:
+        file_path = File._make_path(json_file, "json", prefer_base_dir=True)
+        with open(file_path, "r") as f:
             content = f.read()
         try:
             data = _json.loads(content)
@@ -32,21 +35,33 @@ class Json:
         return (processed_data, data) if return_original else processed_data
 
     @staticmethod
-    def create(content:dict, new_file:str = 'config', indent:int = 2, compactness:int = 1, force:bool = False) -> str:
-        file_path = File._make_path(new_file, 'json', prefer_base_dir=True)
+    def create(
+        content: dict,
+        new_file: str = "config",
+        indent: int = 2,
+        compactness: int = 1,
+        force: bool = False,
+    ) -> str:
+        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:
+            with open(file_path, "r", encoding="utf-8") as existing_f:
                 existing_content = _json.load(existing_f)
                 if existing_content == content:
-                    raise FileExistsError(f'Already created this file. (nothing changed)')
-            raise FileExistsError('File already exists.')
-        with open(file_path, 'w', encoding='utf-8') as f:
+                    raise FileExistsError("Already created this file. (nothing changed)")
+            raise FileExistsError("File already exists.")
+        with open(file_path, "w", encoding="utf-8") as f:
             f.write(Data.to_str(content, indent, compactness, as_json=True))
         full_path = _os.path.abspath(file_path)
         return full_path
 
     @staticmethod
-    def update(json_file:str, update_values:str|list[str], comment_start:str = '>>', comment_end:str = '<<', sep:tuple[str,str] = ('->', '::')) -> None:
+    def update(
+        json_file: str,
+        update_values: str | list[str],
+        comment_start: str = ">>",
+        comment_end: str = "<<",
+        sep: tuple[str, str] = ("->", "::"),
+    ) -> None:
         """Function to easily update single/multiple values inside JSON files.\n
         --------------------------------------------------------------------------------------------------------
         The param `json_file` is the path to the JSON file or just the name of the JSON file to be updated.\n
@@ -67,15 +82,20 @@ class Json:
         --------------------------------------------------------------------------------------------------------
         If only `comment_start` is found at the beginning of an item, the whole item is counted<br>
         as a comment and therefore ignored. If `comment_start` and `comment_end` are found<br>
-        inside an item, the the section from `comment_start` to `comment_end` is ignored."""
+        inside an item, the the section from `comment_start` to `comment_end` is ignored.
+        """
         if isinstance(update_values, str):
             update_values = [update_values]
-        valid_entries = [(parts[0].strip(), parts[1]) for update_value in update_values if len(parts := update_value.split(str(sep[1]).strip())) == 2]
-        value_paths, new_values = (zip(*valid_entries) if valid_entries else ([], []))
+        valid_entries = [
+            (parts[0].strip(), parts[1])
+            for update_value in update_values
+            if len(parts := update_value.split(str(sep[1]).strip())) == 2
+        ]
+        value_paths, new_values = zip(*valid_entries) if valid_entries else ([], [])
         processed_data, data = Json.read(json_file, comment_start, comment_end, return_original=True)
         update = []
         for value_path, new_value in zip(value_paths, new_values):
             path_id = Data.get_path_id(processed_data, value_path)
-            update.append(f'{path_id}::{new_value}')
+            update.append(f"{path_id}::{new_value}")
         updated = Data.set_value_by_path_id(data, update)
         Json.create(updated, json_file, force=True)