xulbux 1.6.9__py3-none-any.whl → 1.7.0__py3-none-any.whl

xulbux/xx_console.py

@@ -8,7 +8,7 @@ For more detailed information about formatting codes, see the the `xx_format_cod
 from ._consts_ import COLOR, CHARS
 from .xx_format_codes import FormatCodes, _COMPILED
 from .xx_string import String
-from .xx_color import Color, rgba, hexa
+from .xx_color import Color, Rgba, Hexa
 
 from prompt_toolkit.key_binding.key_bindings import KeyBindings
 from typing import Optional, Any
@@ -103,14 +103,14 @@ class Args:
 
 class Console:
 
-    w: int = _ConsoleWidth()
+    w: int = _ConsoleWidth()  # type: ignore[assignment]
     """The width of the console in characters."""
-    h: int = _ConsoleHeight()
+    h: int = _ConsoleHeight()  # type: ignore[assignment]
     """The height of the console in lines."""
-    wh: tuple[int, int] = _ConsoleSize()
+    wh: tuple[int, int] = _ConsoleSize()  # type: ignore[assignment]
     """A tuple with the width and height of
     the console in characters and lines."""
-    usr: str = _ConsoleUser()
+    usr: str = _ConsoleUser()  # type: ignore[assignment]
     """The name of the current user."""
 
     @staticmethod
@@ -249,8 +249,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: hexa | rgba = None,
-        default_color: hexa | rgba = None,
+        title_bg_color: Optional[Rgba | Hexa] = None,
+        default_color: Optional[Rgba | Hexa] = None,
         _console_tabsize: int = 8,
     ) -> None:
         """Will print a formatted log message:
@@ -271,8 +271,12 @@ class Console:
         if format_linebreaks:
             clean_prompt, removals = FormatCodes.remove_formatting(str(prompt), get_removals=True, _ignore_linebreaks=True)
             prompt_lst = (String.split_count(l, Console.w - (title_len + tab_len)) for l in str(clean_prompt).splitlines())
-            prompt_lst = (item for lst in prompt_lst for item in (lst if isinstance(lst, list) else [lst]))
-            prompt = f"\n{' ' * title_len}\t".join(Console.__add_back_removed_parts(list(prompt_lst), removals))
+            prompt_lst = (
+                item for lst in prompt_lst for item in ([""] if lst == [] else (lst if isinstance(lst, list) else [lst]))
+            )
+            prompt = f"\n{' ' * title_len}\t".join(
+                Console.__add_back_removed_parts(list(prompt_lst), removals)  # type: ignore[assignment]
+            )
         else:
             prompt = str(prompt)
         if title == "":
@@ -328,8 +332,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: hexa | rgba = COLOR.yellow,
-        default_color: hexa | rgba = COLOR.text,
+        title_bg_color: Rgba | Hexa = COLOR.yellow,
+        default_color: Rgba | Hexa = COLOR.text,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
@@ -346,8 +350,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: hexa | rgba = COLOR.blue,
-        default_color: hexa | rgba = COLOR.text,
+        title_bg_color: Rgba | Hexa = COLOR.blue,
+        default_color: Rgba | Hexa = COLOR.text,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
@@ -362,8 +366,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: hexa | rgba = COLOR.teal,
-        default_color: hexa | rgba = COLOR.text,
+        title_bg_color: Rgba | Hexa = COLOR.teal,
+        default_color: Rgba | Hexa = COLOR.text,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
@@ -378,8 +382,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: hexa | rgba = COLOR.orange,
-        default_color: hexa | rgba = COLOR.text,
+        title_bg_color: Rgba | Hexa = COLOR.orange,
+        default_color: Rgba | Hexa = COLOR.text,
         pause: bool = False,
         exit: bool = False,
     ) -> None:
@@ -394,8 +398,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: hexa | rgba = COLOR.red,
-        default_color: hexa | rgba = COLOR.text,
+        title_bg_color: Rgba | Hexa = COLOR.red,
+        default_color: Rgba | Hexa = COLOR.text,
         pause: bool = False,
         exit: bool = True,
         reset_ansi=True,
@@ -411,8 +415,8 @@ class Console:
         format_linebreaks: bool = True,
         start: str = "",
         end: str = "\n",
-        title_bg_color: hexa | rgba = COLOR.magenta,
-        default_color: hexa | rgba = COLOR.text,
+        title_bg_color: Rgba | Hexa = COLOR.magenta,
+        default_color: Rgba | Hexa = COLOR.text,
         pause: bool = False,
         exit: bool = True,
         reset_ansi=True,
@@ -427,8 +431,8 @@ class Console:
         *values: object,
         start: str = "",
         end: str = "\n",
-        box_bg_color: str | hexa | rgba = "green",
-        default_color: hexa | rgba = "#000",
+        box_bg_color: str | Rgba | Hexa = "green",
+        default_color: Rgba | Hexa = "#000",
         w_padding: int = 2,
         w_full: bool = False,
     ) -> None:
@@ -443,7 +447,7 @@ class Console:
         -----------------------------------------------------------------------------------
         The box content can be formatted with special formatting codes. For more detailed
         information about formatting codes, see `xx_format_codes` module documentation."""
-        lines = [line.rstrip() for val in values for line in val.splitlines()]
+        lines = [line.rstrip() for val in values for line in str(val).splitlines()]
         unfmt_lines = [FormatCodes.remove_formatting(line) for line in lines]
         max_line_len = max(len(line) for line in unfmt_lines)
         pad_w_full = (Console.w - (max_line_len + (2 * w_padding))) if w_full else 0
@@ -466,7 +470,7 @@ class Console:
         prompt: object = "Do you want to continue?",
         start="",
         end="\n",
-        default_color: hexa | rgba = COLOR.cyan,
+        default_color: Rgba | Hexa = COLOR.cyan,
         default_is_yes: bool = True,
     ) -> bool:
         """Ask a yes/no question.\n
@@ -488,7 +492,7 @@ class Console:
         prompt: object = "",
         start="",
         end="\n",
-        default_color: hexa | rgba = COLOR.cyan,
+        default_color: Rgba | Hexa = COLOR.cyan,
         show_keybindings=True,
         input_prefix=" ⤷ ",
         reset_ansi=True,
@@ -511,7 +515,7 @@ class Console:
         def _(event):
             event.app.exit(result=event.app.current_buffer.document.text)
 
-        FormatCodes.print(start + prompt, default_color=default_color)
+        FormatCodes.print(start + str(prompt), default_color=default_color)
         if show_keybindings:
             FormatCodes.print("[dim][[b](CTRL+D)[dim] : end of input][_dim]")
         input_string = _prompt_toolkit.prompt(input_prefix, multiline=True, wrap_lines=True, key_bindings=kb)
@@ -523,11 +527,11 @@ class Console:
         prompt: object = "",
         start="",
         end="\n",
-        default_color: hexa | rgba = COLOR.cyan,
-        allowed_chars: str = CHARS.all,
-        min_len: int = None,
-        max_len: int = None,
-        mask_char: str = None,
+        default_color: Rgba | Hexa = COLOR.cyan,
+        allowed_chars: str = CHARS.all,  # type: ignore[assignment]
+        min_len: Optional[int] = None,
+        max_len: Optional[int] = None,
+        mask_char: Optional[str] = None,
         reset_ansi: bool = True,
     ) -> Optional[str]:
         """Acts like a standard Python `input()` with the advantage, that you can specify:
@@ -538,7 +542,7 @@ class Console:
         ---------------------------------------------------------------------------------------
         The input can be formatted with special formatting codes. For more detailed
         information about formatting codes, see the `xx_format_codes` module documentation."""
-        FormatCodes.print(start + prompt, default_color=default_color, end="")
+        FormatCodes.print(start + str(prompt), default_color=default_color, end="")
         result = ""
         select_all = False
         last_line_count = 1
@@ -594,7 +598,8 @@ class Console:
 
         def handle_character_input():
             nonlocal result
-            if (allowed_chars == CHARS.all or event.name in allowed_chars) and (max_len is None or len(result) < max_len):
+            if event.name is not None and ((allowed_chars == CHARS.all or event.name in allowed_chars) and
+                                           (max_len is None or len(result) < max_len)):
                 result += event.name
                 update_display(Console.w)
 
@@ -615,7 +620,7 @@ class Console:
                     return None
                 elif event.name == "space":
                     handle_character_input()
-                elif len(event.name) == 1:
+                elif event.name is not None and len(event.name) == 1:
                     handle_character_input()
                 else:
                     select_all = False
@@ -626,12 +631,22 @@ class Console:
         prompt: object = "Password: ",
         start="",
         end="\n",
-        default_color: hexa | rgba = COLOR.cyan,
+        default_color: Rgba | Hexa = COLOR.cyan,
         allowed_chars: str = CHARS.standard_ascii,
-        min_len: int = None,
-        max_len: int = None,
+        min_len: Optional[int] = None,
+        max_len: Optional[int] = None,
         reset_ansi: bool = True,
-    ) -> str:
+    ) -> Optional[str]:
         """Password input (preset for `Console.restricted_input()`)
         that always masks the entered characters with asterisks."""
-        return Console.restricted_input(prompt, start, end, default_color, allowed_chars, min_len, max_len, "*", reset_ansi)
+        return Console.restricted_input(
+            prompt=prompt,
+            start=start,
+            end=end,
+            default_color=default_color,
+            allowed_chars=allowed_chars,
+            min_len=min_len,
+            max_len=max_len,
+            mask_char="*",
+            reset_ansi=reset_ansi,
+        )

xulbux/xx_data.py

@@ -166,7 +166,7 @@ class Data:
 
         def process_string(s: str) -> Optional[str]:
             if comment_end:
-                match = pattern.match(s)
+                match = pattern.match(s)  # type: ignore[unbound]
                 if match:
                     start, end = match.group(1).strip(), match.group(2).strip()
                     return f"{start}{comment_sep if start and end else ''}{end}" or None
@@ -223,7 +223,7 @@ class Data:
                 return True
             if type(d1) is not type(d2):
                 return False
-            if isinstance(d1, dict):
+            if isinstance(d1, dict) and isinstance(d2, dict):
                 if set(d1.keys()) != set(d2.keys()):
                     return False
                 return all(compare(d1[key], d2[key], ignore_paths, current_path + [key]) for key in d1)
@@ -251,7 +251,7 @@ class Data:
         comment_start: str = ">>",
         comment_end: str = "<<",
         ignore_not_found: bool = False,
-    ) -> str | list[str]:
+    ) -> Optional[str | list[Optional[str]]]:
         """Generates a unique ID based on the path to a specific value within a nested data structure.\n
         -------------------------------------------------------------------------------------------------
         The `data` parameter is the list, tuple, or dictionary, which the id should be generated for.\n
@@ -355,12 +355,12 @@ class Data:
         return get_nested(data, Data.__sep_path_id(path_id), get_key)
 
     @staticmethod
-    def set_value_by_path_id(data: DataStructure, update_values: dict[str, Any]) -> list | tuple | dict:
+    def set_value_by_path_id(data: DataStructure, update_values: dict[str, Any]) -> DataStructure:
         """Updates the value/s from `update_values` in the `data`.\n
         --------------------------------------------------------------------------------
         Input a list, tuple or dict as `data`, along with `update_values`, which is a
         dictionary where keys are path IDs and values are the new values to insert:
-           { "1>": "new value", "path_id2": ["new value 1", "new value 2"], ... }
+           { "1>012": "new value", "1>31": ["new value 1", "new value 2"], ... }
         The path IDs should have been created using `Data.get_path_id()`.\n
         --------------------------------------------------------------------------------
         The value from path ID will be changed to the new value, as long as the
@@ -413,7 +413,8 @@ class Data:
         - `2` keeps everything collapsed (all on one line)\n
         ------------------------------------------------------------------------------
         If `as_json` is set to `True`, the output will be in valid JSON format."""
-        if syntax_hl := _syntax_highlighting not in (None, False):
+        _syntax_hl = {}
+        if do_syntax_hl := _syntax_highlighting not in (None, False):
             if _syntax_highlighting is True:
                 _syntax_highlighting = {}
             elif not isinstance(_syntax_highlighting, dict):
@@ -426,62 +427,62 @@ class Data:
                 "punctuation": (f"[{COLOR.darkgray}]", "[_c]"),
             }
             _syntax_hl.update({
-                k: [f"[{v}]", "[_]"] if k in _syntax_hl and v not in ("", None) else ["", ""]
+                k: (f"[{v}]", "[_]") if k in _syntax_hl and v not in ("", None) else ("", "")
                 for k, v in _syntax_highlighting.items()
             })
             sep = f"{_syntax_hl['punctuation'][0]}{sep}{_syntax_hl['punctuation'][1]}"
         punct_map = {"(": ("/(", "("), **{char: char for char in "'\":)[]{}"}}
         punct = {
-            k: ((f"{_syntax_hl['punctuation'][0]}{v[0]}{_syntax_hl['punctuation'][1]}" if syntax_hl else v[1])
+            k: ((f"{_syntax_hl['punctuation'][0]}{v[0]}{_syntax_hl['punctuation'][1]}" if do_syntax_hl else v[1])
                 if isinstance(v, (list, tuple)) else
-                (f"{_syntax_hl['punctuation'][0]}{v}{_syntax_hl['punctuation'][1]}" if syntax_hl else v))
+                (f"{_syntax_hl['punctuation'][0]}{v}{_syntax_hl['punctuation'][1]}" if do_syntax_hl else v))
             for k, v in punct_map.items()
         }
 
-        def format_value(value: Any, current_indent: int = None) -> str:
+        def format_value(value: Any, current_indent: Optional[int] = None) -> str:
             if current_indent is not None and isinstance(value, dict):
                 return format_dict(value, current_indent + indent)
             elif current_indent is not None and hasattr(value, "__dict__"):
                 return format_dict(value.__dict__, current_indent + indent)
             elif current_indent is not None and isinstance(value, IndexIterable):
                 return format_sequence(value, current_indent + indent)
-            elif isinstance(value, (bytes, bytearray)):
+            elif current_indent is not None and isinstance(value, (bytes, bytearray)):
                 obj_dict = Data.serialize_bytes(value)
                 return (
                     format_dict(obj_dict, current_indent + indent) if as_json else (
                         f"{_syntax_hl['type'][0]}{(k := next(iter(obj_dict)))}{_syntax_hl['type'][1]}"
-                        + format_sequence((obj_dict[k], obj_dict["encoding"]), current_indent + indent) if syntax_hl else
+                        + format_sequence((obj_dict[k], obj_dict["encoding"]), current_indent + indent) if do_syntax_hl else
                         (k := next(iter(obj_dict)))
                         + format_sequence((obj_dict[k], obj_dict["encoding"]), current_indent + indent)
                     )
                 )
             elif isinstance(value, bool):
                 val = str(value).lower() if as_json else str(value)
-                return f"{_syntax_hl['literal'][0]}{val}{_syntax_hl['literal'][1]}" if syntax_hl else val
+                return f"{_syntax_hl['literal'][0]}{val}{_syntax_hl['literal'][1]}" if do_syntax_hl else val
             elif isinstance(value, (int, float)):
                 val = "null" if as_json and (_math.isinf(value) or _math.isnan(value)) else str(value)
-                return f"{_syntax_hl['number'][0]}{val}{_syntax_hl['number'][1]}" if syntax_hl else val
-            elif isinstance(value, complex):
+                return f"{_syntax_hl['number'][0]}{val}{_syntax_hl['number'][1]}" if do_syntax_hl else val
+            elif current_indent is not None and isinstance(value, complex):
                 return (
                     format_value(str(value).strip("()")) if as_json else (
                         f"{_syntax_hl['type'][0]}complex{_syntax_hl['type'][1]}"
                         + format_sequence((value.real, value.imag), current_indent + indent)
-                        if syntax_hl else f"complex{format_sequence((value.real, value.imag), current_indent + indent)}"
+                        if do_syntax_hl else f"complex{format_sequence((value.real, value.imag), current_indent + indent)}"
                     )
                 )
             elif value is None:
                 val = "null" if as_json else "None"
-                return f"{_syntax_hl['literal'][0]}{val}{_syntax_hl['literal'][1]}" if syntax_hl else val
+                return f"{_syntax_hl['literal'][0]}{val}{_syntax_hl['literal'][1]}" if do_syntax_hl else val
             else:
                 return ((
                     punct['"'] + _syntax_hl["str"][0] + String.escape(str(value), '"') + _syntax_hl["str"][1]
-                    + punct['"'] if syntax_hl else punct['"'] + String.escape(str(value), '"') + punct['"']
+                    + punct['"'] if do_syntax_hl else punct['"'] + String.escape(str(value), '"') + punct['"']
                 ) if as_json else (
                     punct["'"] + _syntax_hl["str"][0] + String.escape(str(value), "'") + _syntax_hl["str"][1]
-                    + punct["'"] if syntax_hl else punct["'"] + String.escape(str(value), "'") + punct["'"]
+                    + punct["'"] if do_syntax_hl else punct["'"] + String.escape(str(value), "'") + punct["'"]
                 ))
 
-        def should_expand(seq: list | tuple | dict) -> bool:
+        def should_expand(seq: IndexIterable) -> bool:
             if compactness == 0:
                 return True
             if compactness == 2:
@@ -500,7 +501,7 @@ class Data:
                     + sep.join(f"{format_value(k)}{punct[':']} {format_value(v, current_indent)}"
                                for k, v in d.items()) + punct["}"]
                 )
-            if not should_expand(d.values()):
+            if not should_expand(list(d.values())):
                 return (
                     punct["{"]
                     + sep.join(f"{format_value(k)}{punct[':']} {format_value(v, current_indent)}"

xulbux/xx_env_path.py

@@ -1,5 +1,6 @@
 from .xx_path import Path
 
+from typing import Optional
 import sys as _sys
 import os as _os
 
@@ -13,7 +14,7 @@ class EnvPath:
         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:
+    def has_path(path: Optional[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()
@@ -25,21 +26,21 @@ class EnvPath:
         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:
+    def add_path(path: Optional[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:
+    def remove_path(path: Optional[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:
+    def __get(path: Optional[str] = None, cwd: bool = False, base_dir: bool = False) -> str:
         """Get and/or normalize the paths.\n
         ------------------------------------------------------------------------------------
         Raise an error if no path is provided and neither `cwd` or `base_dir` is `True`."""
@@ -56,7 +57,7 @@ class EnvPath:
         """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)
+        current_paths = list(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)]

xulbux/xx_file.py

@@ -19,8 +19,8 @@ class File:
         """Rename the extension of a file.\n
         --------------------------------------------------------------------------
         If `full_extension` is true, everything after the first dot in the
-        filename will be treated as the extension to replace. Otherwise, only the
-        part after the last dot is replaced.\n
+        filename will be treated as the extension to replace (e.g. `.tar.gz`).
+        Otherwise, only the part after the last dot is replaced (e.g. `.gz`).\n
         If the `camel_case_filename` parameter is true, the filename will be made
         CamelCase in addition to changing the files extension."""
         normalized_file = _os.path.normpath(file)

xulbux/xx_format_codes.py

@@ -152,10 +152,10 @@ Per default, you can also use `+` and `-` to get lighter and darker `default_col
 
 from ._consts_ import ANSI
 from .xx_string import String
-from .xx_regex import Regex
-from .xx_color import Color, rgba, hexa
+from .xx_regex import Regex, Match, Pattern
+from .xx_color import Color, rgba, Rgba, Hexa
 
-from typing import Optional, Pattern
+from typing import Optional
 import ctypes as _ctypes
 import regex as _rx
 import sys as _sys
@@ -205,7 +205,7 @@ class FormatCodes:
     @staticmethod
     def print(
         *values: object,
-        default_color: rgba | hexa = None,
+        default_color: Optional[Rgba | Hexa] = None,
         brightness_steps: int = 20,
         sep: str = " ",
         end: str = "\n",
@@ -223,7 +223,7 @@ class FormatCodes:
     @staticmethod
     def input(
         prompt: object = "",
-        default_color: rgba | hexa = None,
+        default_color: Optional[Rgba | Hexa] = None,
         brightness_steps: int = 20,
         reset_ansi: bool = False,
     ) -> str:
@@ -243,7 +243,7 @@ class FormatCodes:
     @staticmethod
     def to_ansi(
         string: str,
-        default_color: rgba | hexa = None,
+        default_color: Optional[Rgba | Hexa] = None,
         brightness_steps: int = 20,
         _default_start: bool = True,
     ) -> str:
@@ -253,9 +253,9 @@ class FormatCodes:
         `xx_format_codes` module documentation."""
         if not isinstance(string, str):
             string = str(string)
-        if Color.is_valid_rgba(default_color, False):
+        if default_color and Color.is_valid_rgba(default_color, False):  # type: ignore[assignment]
             use_default = True
-        elif Color.is_valid_hexa(default_color, False):
+        elif default_color and Color.is_valid_hexa(default_color, False):  # type: ignore[assignment]
             use_default, default_color = True, Color.to_rgba(default_color)
         else:
             use_default = False
@@ -264,9 +264,9 @@ class FormatCodes:
             string = _COMPILED["*color"].sub(r"[\1default\2]", string)  # REPLACE `[…|*color|…]` WITH `[…|default|…]`
 
         def is_valid_color(color: str) -> bool:
-            return color in ANSI.color_map or Color.is_valid_rgba(color) or Color.is_valid_hexa(color)
+            return bool((color in ANSI.color_map) or Color.is_valid_rgba(color) or Color.is_valid_hexa(color))
 
-        def replace_keys(match: _re.Match) -> str:
+        def replace_keys(match: Match) -> str:
             _formats = formats = match.group(1)
             auto_reset_escaped = match.group(2)
             auto_reset_txt = match.group(3)
@@ -280,8 +280,8 @@ class FormatCodes:
                 formats = FormatCodes.to_ansi(formats, default_color, brightness_steps, False)
             format_keys = [k.strip() for k in formats.split("|") if k.strip()]
             ansi_formats = [
-                r if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)) != k else f"[{k}]"
-                for k in format_keys
+                r if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)) != k  # type: ignore[assignment]
+                else f"[{k}]" for k in format_keys
             ]
             if auto_reset_txt and not auto_reset_escaped:
                 reset_keys = []
@@ -306,8 +306,9 @@ class FormatCodes:
                     else:
                         reset_keys.append(f"_{k}")
                 ansi_resets = [
-                    r for k in reset_keys if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)
-                                              ).startswith(f"{ANSI.char}{ANSI.start}")
+                    r for k in reset_keys
+                    if (r := FormatCodes.__get_replacement(k, default_color, brightness_steps)  # type: ignore[assignment]
+                        ).startswith(f"{ANSI.char}{ANSI.start}")
                 ]
             else:
                 ansi_resets = []
@@ -325,7 +326,8 @@ class FormatCodes:
                 )
 
         string = "\n".join(_COMPILED["formatting"].sub(replace_keys, line) for line in string.split("\n"))
-        return ((FormatCodes.__get_default_ansi(default_color) if _default_start else "") + string) if use_default else string
+        return (((FormatCodes.__get_default_ansi(default_color) or "") if _default_start else "")  # type: ignore[assignment]
+                + string) if use_default else string
 
     @staticmethod
     def escape_ansi(ansi_string: str) -> str:
@@ -346,7 +348,7 @@ class FormatCodes:
         if get_removals:
             removals = []
 
-            def replacement(match: _re.Match) -> str:
+            def replacement(match: Match) -> str:
                 start_pos = match.start() - sum(len(removed) for _, removed in removals)
                 if removals and removals[-1][0] == start_pos:
                     start_pos = removals[-1][0]
@@ -394,8 +396,8 @@ class FormatCodes:
     @staticmethod
     def __get_default_ansi(
         default_color: tuple,
-        format_key: str = None,
-        brightness_steps: int = None,
+        format_key: Optional[str] = None,
+        brightness_steps: Optional[int] = None,
         _modifiers: tuple[str, str] = (ANSI.default_color_modifiers["lighten"], ANSI.default_color_modifiers["darken"]),
     ) -> Optional[str]:
         """Get the `default_color` and lighter/darker versions of it as ANSI code."""
@@ -403,8 +405,9 @@ class FormatCodes:
             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]):
+        if format_key is None or not (format_key in _modifiers[0] or format_key in _modifiers[1]):
             return None
+        assert format_key is not None
         match = _COMPILED["modifier"].match(format_key)
         if not match:
             return None
@@ -415,23 +418,25 @@ class FormatCodes:
             if adjust and adjust > 0:
                 modifiers = mod
                 break
+        new_rgb = default_color
         if adjust == 0:
             return None
         elif modifiers in _modifiers[0]:
-            new_rgb = Color.adjust_lightness(default_color, (brightness_steps / 100) * adjust)
+            new_rgb = tuple(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)
+            new_rgb = tuple(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: rgba = None, brightness_steps: int = 20) -> str:
+    def __get_replacement(format_key: str, default_color: Optional[Rgba] = None, brightness_steps: int = 20) -> str:
         """Gives you the corresponding ANSI code for the given format key.
         If `default_color` is not `None`, the text color will be `default_color` if all formats
         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)
+        _default_color = tuple(Color.to_rgba(default_color)) if use_default else ()  # type: ignore[assignment]
         _format_key, format_key = format_key, FormatCodes.__normalize_key(format_key)  # NORMALIZE KEY AND SAVE ORIGINAL
         if use_default:
-            if new_default_color := FormatCodes.__get_default_ansi(default_color, format_key, brightness_steps):
+            if new_default_color := FormatCodes.__get_default_ansi(_default_color, format_key, brightness_steps):
                 return new_default_color
         for map_key in ANSI.codes_map:
             if (isinstance(map_key, tuple) and format_key in map_key) or format_key == map_key:
@@ -440,8 +445,8 @@ class FormatCodes:
                         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)
+        rgb_match = _COMPILED["rgb"].match(format_key)
+        hex_match = _COMPILED["hex"].match(format_key)
         try:
             if rgb_match:
                 is_bg = rgb_match.group(1)

xulbux/xx_json.py

@@ -26,13 +26,15 @@ class Json:
         if not json_file.endswith(".json"):
             json_file += ".json"
         file_path = Path.extend_or_make(json_file, prefer_script_dir=True)
+        if file_path is None:
+            raise FileNotFoundError(f"Could not find JSON file: {json_file}")
         with open(file_path, "r") as f:
             content = f.read()
         try:
             data = _json.loads(content)
         except _json.JSONDecodeError as e:
             raise ValueError(f"Error parsing JSON in '{file_path}':  {str(e)}")
-        processed_data = Data.remove_comments(data, comment_start, comment_end)
+        processed_data = dict(Data.remove_comments(data, comment_start, comment_end))
         if not processed_data:
             raise ValueError(f"The JSON file '{file_path}' is empty or contains only comments.")
         return (processed_data, data) if return_original else processed_data
@@ -135,24 +137,23 @@ class Json:
                         raise TypeError(f"Cannot navigate through {type(current).__name__}")
             return data_obj
 
+        update = {}
         for value_path, new_value in update_values.items():
             try:
                 path_id = Data.get_path_id(
                     data=processed_data,
                     value_paths=value_path,
                     path_sep=path_sep,
-                    ignore_not_found=True,
                 )
                 if path_id is not None:
-                    if 'update' not in locals():
-                        update = {}
                     update[path_id] = new_value
                 else:
+                    keys = value_path.split(path_sep)
                     keys = value_path.split(path_sep)
                     data = create_nested_path(data, keys, new_value)
             except Exception:
                 keys = value_path.split(path_sep)
                 data = create_nested_path(data, keys, new_value)
-        if 'update' in locals() and update:
+        if "update" in locals() and update:
             data = Data.set_value_by_path_id(data, update)
-        Json.create(json_file=json_file, data=data, force=True)
+        Json.create(json_file=json_file, data=dict(data), force=True)