xulbux 1.6.4__py3-none-any.whl → 1.6.6__py3-none-any.whl

xulbux/xx_data.py

@@ -1,6 +1,9 @@
+from ._consts_ import COLOR
+from .xx_format_codes import FormatCodes
 from .xx_string import String
 
-from typing import TypeAlias, Union
+from typing import TypeAlias, Optional, Union
+import base64 as _base64
 import math as _math
 import re as _re
 
@@ -10,6 +13,32 @@ DataStructure: TypeAlias = Union[list, tuple, set, frozenset, dict]
 
 class Data:
 
+    @staticmethod
+    def serialize_bytes(data: bytes | bytearray) -> dict[str, str]:
+        """Converts bytes or bytearray to a JSON-compatible format (dictionary) with explicit keys."""
+        if isinstance(data, (bytes, bytearray)):
+            key = "bytearray" if isinstance(data, bytearray) else "bytes"
+            try:
+                return {key: data.decode("utf-8"), "encoding": "utf-8"}
+            except UnicodeDecodeError:
+                pass
+            return {key: _base64.b64encode(data).decode("utf-8"), "encoding": "base64"}
+        raise TypeError("Unsupported data type")
+
+    @staticmethod
+    def deserialize_bytes(obj: dict[str, str]) -> bytes | bytearray:
+        """Converts a JSON-compatible bytes/bytearray format (dictionary) back to its original type."""
+        for key in ("bytes", "bytearray"):
+            if key in obj and "encoding" in obj:
+                if obj["encoding"] == "utf-8":
+                    data = obj[key].encode("utf-8")
+                elif obj["encoding"] == "base64":
+                    data = _base64.b64decode(obj[key].encode("utf-8"))
+                else:
+                    raise ValueError("Unknown encoding method")
+                return bytearray(data) if key == "bytearray" else data
+        raise ValueError("Invalid serialized data")
+
     @staticmethod
     def chars_count(data: DataStructure) -> int:
         """The sum of all the characters amount including the keys in dictionaries."""
@@ -31,26 +60,18 @@ class Data:
         if isinstance(data, dict):
             return {
                 k: (
-                    v
-                    if not isinstance(v, (list, tuple, set, frozenset, dict))
-                    else Data.remove_empty_items(v, spaces_are_empty)
+                    v if not isinstance(v,
+                                        (list, tuple, set, frozenset, dict)) else Data.remove_empty_items(v, spaces_are_empty)
                 )
                 for k, v in data.items()
                 if not String.is_empty(v, spaces_are_empty)
             }
         if isinstance(data, (list, tuple, set, frozenset)):
             return type(data)(
-                item
-                for item in (
-                    (
-                        item
-                        if not isinstance(item, (list, tuple, set, frozenset, dict))
-                        else Data.remove_empty_items(item, spaces_are_empty)
-                    )
-                    for item in data
-                    if not String.is_empty(item, spaces_are_empty)
-                )
-                if item not in ((), {}, set(), frozenset())
+                item for item in ((
+                    item if not isinstance(item, (list, tuple, set, frozenset,
+                                                  dict)) else Data.remove_empty_items(item, spaces_are_empty)
+                ) for item in data if not String.is_empty(item, spaces_are_empty)) if item not in ((), {}, set(), frozenset())
             )
         return data
 
@@ -131,7 +152,7 @@ class Data:
                 rf"^((?:(?!{_re.escape(comment_start)}).)*){_re.escape(comment_start)}(?:(?:(?!{_re.escape(comment_end)}).)*)(?:{_re.escape(comment_end)})?(.*?)$"
             )
 
-        def process_string(s: str) -> str | None:
+        def process_string(s: str) -> Optional[str]:
             if comment_end:
                 match = pattern.match(s)
                 if match:
@@ -144,7 +165,9 @@ class Data:
         def process_item(item: any) -> any:
             if isinstance(item, dict):
                 return {
-                    k: v for k, v in ((process_item(key), process_item(value)) for key, value in item.items()) if k is not None
+                    k: v
+                    for k, v in ((process_item(key), process_item(value)) for key, value in item.items())
+                    if k is not None
                 }
             if isinstance(item, (list, tuple, set, frozenset)):
                 processed = (v for v in map(process_item, item) if v is not None)
@@ -174,9 +197,7 @@ class Data:
         The paths from `ignore_paths` and the `path_sep` parameter work exactly the same way as for
         the function `Data.get_path_id()`. See its documentation for more details."""
 
-        def process_ignore_paths(
-            ignore_paths: str | list[str],
-        ) -> list[list[str]]:
+        def process_ignore_paths(ignore_paths: str | list[str], ) -> list[list[str]]:
             if isinstance(ignore_paths, str):
                 ignore_paths = [ignore_paths]
             return [path.split(path_sep) for path in ignore_paths if path]
@@ -187,9 +208,9 @@ class Data:
             ignore_paths: list[list[str]],
             current_path: list[str] = [],
         ) -> bool:
-            if any(current_path == path[: len(current_path)] for path in ignore_paths):
+            if any(current_path == path[:len(current_path)] for path in ignore_paths):
                 return True
-            if type(d1) != type(d2):
+            if type(d1) is not type(d2):
                 return False
             if isinstance(d1, dict):
                 if set(d1.keys()) != set(d2.keys()):
@@ -247,7 +268,7 @@ class Data:
         If `ignore_not_found` is `True`, the function will return `None` if the value is not found
         instead of raising an error."""
 
-        def process_path(path: str, data_obj: list | tuple | set | frozenset | dict) -> str | None:
+        def process_path(path: str, data_obj: DataStructure) -> Optional[str]:
             keys = path.split(path_sep)
             path_ids = []
             max_id_length = 0
@@ -300,7 +321,7 @@ class Data:
         The function will return the value (or key) from the path ID location, as long as the structure
         of `data` hasn't changed since creating the path ID to that value."""
 
-        def get_nested(data: list | tuple | set | frozenset | dict, path: list[int], get_key: bool) -> any:
+        def get_nested(data: DataStructure, path: list[int], get_key: bool) -> any:
             parent = None
             for i, idx in enumerate(path):
                 if isinstance(data, dict):
@@ -323,11 +344,7 @@ 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: str | list[str],
-        sep: str = "::",
-    ) -> list | tuple | dict:
+    def set_value_by_path_id(data: DataStructure, update_values: str | list[str], sep: str = "::") -> list | tuple | dict:
         """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
@@ -338,9 +355,7 @@ class Data:
         The value from path ID will be changed to the new value, as long as the
         structure of `data` hasn't changed since creating the path ID to that value."""
 
-        def update_nested(
-            data: list | tuple | set | frozenset | dict, path: list[int], value: any
-        ) -> list | tuple | set | frozenset | dict:
+        def update_nested(data: DataStructure, path: list[int], value: any) -> DataStructure:
             if len(path) == 1:
                 if isinstance(data, dict):
                     keys = list(data.keys())
@@ -364,11 +379,9 @@ class Data:
 
         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).strip())) == 2
-        ]
+        valid_entries = [(parts[0].strip(), parts[1])
+                         for update_value in update_values
+                         if len(parts := update_value.split(str(sep).strip())) == 2]
         if not valid_entries:
             raise ValueError(f"No valid update_values found: {update_values}")
         for path_id, new_val in valid_entries:
@@ -376,40 +389,15 @@ class Data:
             data = update_nested(data, path, new_val)
         return data
 
-    @staticmethod
-    def print(
-        data: DataStructure,
-        indent: int = 4,
-        compactness: int = 1,
-        sep: str = ", ",
-        max_width: int = 127,
-        as_json: bool = False,
-        end: str = "\n",
-    ) -> None:
-        """Print nicely formatted data structures.\n
-        ------------------------------------------------------------------------------
-        The indentation spaces-amount can be set with with `indent`.
-        There are three different levels of `compactness`:
-        - `0` expands everything possible
-        - `1` only expands if there's other lists, tuples or dicts inside of data or,
-          if the data's content is longer than `max_width`
-        - `2` keeps everything collapsed (all on one line)\n
-        ------------------------------------------------------------------------------
-        If `as_json` is set to `True`, the output will be in valid JSON format."""
-        print(
-            Data.to_str(data, indent, compactness, sep, max_width, as_json),
-            end=end,
-            flush=True,
-        )
-
     @staticmethod
     def to_str(
         data: DataStructure,
         indent: int = 4,
         compactness: int = 1,
-        sep: str = ", ",
         max_width: int = 127,
+        sep: str = ", ",
         as_json: bool = False,
+        _syntax_highlighting: dict[str, str] | bool = False,
     ) -> str:
         """Get nicely formatted data structure-strings.\n
         ------------------------------------------------------------------------------
@@ -421,106 +409,169 @@ 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):
+            if _syntax_highlighting is True:
+                _syntax_highlighting = {}
+            elif not isinstance(_syntax_highlighting, dict):
+                raise TypeError(f"Expected 'syntax_highlighting' to be a dict or bool. Got: {type(_syntax_highlighting)}")
+            _syntax_hl = {
+                "str": (f"[{COLOR.blue}]", "[_c]"),
+                "number": (f"[{COLOR.magenta}]", "[_c]"),
+                "literal": (f"[{COLOR.cyan}]", "[_c]"),
+                "type": (f"[i|{COLOR.lightblue}]", "[_i|_c]"),
+                "punctuation": (f"[{COLOR.darkgray}]", "[_c]"),
+            }
+            _syntax_hl.update({
+                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])
+                if isinstance(v, (list, tuple)) else
+                (f"{_syntax_hl['punctuation'][0]}{v}{_syntax_hl['punctuation'][1]}" if syntax_hl else v))
+            for k, v in punct_map.items()
+        }
 
-        def format_value(value: any, current_indent: int) -> str:
-            if isinstance(value, dict):
+        def format_value(value: any, current_indent: int = None) -> str:
+            if current_indent is not None and isinstance(value, dict):
                 return format_dict(value, current_indent + indent)
-            elif hasattr(value, "__dict__"):
+            elif current_indent is not None and hasattr(value, "__dict__"):
                 return format_dict(value.__dict__, current_indent + indent)
-            elif isinstance(value, (list, tuple, set, frozenset)):
+            elif current_indent is not None and isinstance(value, (list, tuple, set, frozenset)):
                 return format_sequence(value, current_indent + indent)
+            elif 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
+                        (k := next(iter(obj_dict)))
+                        + format_sequence((obj_dict[k], obj_dict["encoding"]), current_indent + indent)
+                    )
+                )
             elif isinstance(value, bool):
-                return str(value).lower() if as_json else str(value)
+                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
             elif isinstance(value, (int, float)):
-                return "null" if as_json and (_math.isinf(value) or _math.isnan(value)) else str(value)
+                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"[{value.real}, {value.imag}]" if as_json else str(value)
+                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)}"
+                    )
+                )
             elif value is None:
-                return "null" if as_json else "None"
+                val = "null" if as_json else "None"
+                return f"{_syntax_hl['literal'][0]}{val}{_syntax_hl['literal'][1]}" if syntax_hl else val
             else:
-                return '"' + String.escape(str(value), '"') + '"' if as_json else "'" + String.escape(str(value), "'") + "'"
+                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['"']
+                ) 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["'"]
+                ))
 
         def should_expand(seq: list | tuple | dict) -> bool:
             if compactness == 0:
                 return True
             if compactness == 2:
                 return False
-            complex_items = sum(1 for item in seq if isinstance(item, (list, tuple, dict, set, frozenset)))
+            complex_types = (list, tuple, dict, set, frozenset) + ((bytes, bytearray) if as_json else ())
+            complex_items = sum(1 for item in seq if isinstance(item, complex_types))
             return (
-                complex_items > 1
-                or (complex_items == 1 and len(seq) > 1)
-                or Data.chars_count(seq) + (len(seq) * len(sep)) > max_width
-            )
-
-        def format_key(k: any) -> str:
-            return (
-                '"' + String.escape(str(k), '"') + '"'
-                if as_json
-                else ("'" + String.escape(str(k), "'") + "'" if isinstance(k, str) else str(k))
+                complex_items > 1 or (complex_items == 1 and len(seq) > 1) or Data.chars_count(seq) +
+                (len(seq) * len(sep)) > max_width
             )
 
         def format_dict(d: dict, current_indent: int) -> str:
             if not d or compactness == 2:
-                return "{" + sep.join(f"{format_key(k)}: {format_value(v, current_indent)}" for k, v in d.items()) + "}"
+                return (
+                    punct["{"]
+                    + 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()):
-                return "{" + sep.join(f"{format_key(k)}: {format_value(v, current_indent)}" for k, v in d.items()) + "}"
+                return (
+                    punct["{"]
+                    + sep.join(f"{format_value(k)}{punct[':']} {format_value(v, current_indent)}" for k, v in d.items())
+                    + punct["}"]
+                )
             items = []
-            for key, value in d.items():
-                formatted_value = format_value(value, current_indent)
-                items.append(f'{" " * (current_indent + indent)}{format_key(key)}: {formatted_value}')
-            return "{\n" + ",\n".join(items) + f'\n{" " * current_indent}}}'
+            for k, val in d.items():
+                formatted_value = format_value(val, current_indent)
+                items.append(f"{' ' * (current_indent + indent)}{format_value(k)}{punct[':']} {formatted_value}")
+            return punct["{"] + "\n" + f"{sep}\n".join(items) + f"\n{' ' * current_indent}" + punct["}"]
 
         def format_sequence(seq, current_indent: int) -> str:
             if as_json:
                 seq = list(seq)
             if not seq or compactness == 2:
                 return (
-                    "[" + sep.join(format_value(item, current_indent) for item in seq) + "]"
-                    if isinstance(seq, list)
-                    else "(" + sep.join(format_value(item, current_indent) for item in seq) + ")"
+                    punct["["] + sep.join(format_value(item, current_indent)
+                                          for item in seq) + punct["]"] if isinstance(seq, list) else punct["("]
+                    + sep.join(format_value(item, current_indent) for item in seq) + punct[")"]
                 )
             if not should_expand(seq):
                 return (
-                    "[" + sep.join(format_value(item, current_indent) for item in seq) + "]"
-                    if isinstance(seq, list)
-                    else "(" + sep.join(format_value(item, current_indent) for item in seq) + ")"
+                    punct["["] + sep.join(format_value(item, current_indent)
+                                          for item in seq) + punct["]"] if isinstance(seq, list) else punct["("]
+                    + sep.join(format_value(item, current_indent) for item in seq) + punct[")"]
                 )
             items = [format_value(item, current_indent) for item in seq]
-            formatted_items = ",\n".join(f'{" " * (current_indent + indent)}{item}' for item in items)
+            formatted_items = f"{sep}\n".join(f'{" " * (current_indent + indent)}{item}' for item in items)
             if isinstance(seq, list):
-                return "[\n" + formatted_items + f'\n{" " * current_indent}]'
+                return f"{punct['[']}\n{formatted_items}\n{' ' * current_indent}{punct[']']}"
             else:
-                return "(\n" + formatted_items + f'\n{" " * current_indent})'
+                return f"{punct['(']}\n{formatted_items}\n{' ' * current_indent}{punct[')']}"
 
         return format_dict(data, 0) if isinstance(data, dict) else format_sequence(data, 0)
 
     @staticmethod
-    def _is_key(data: DataStructure, path_id: str) -> bool:
-        """Returns `True` if the path ID points to a key in `data` and `False` otherwise.\n
-        ------------------------------------------------------------------------------------
-        Input a list, tuple or dict as `data`, along with `path_id`, which is a path ID
-        that was created before using `Data.get_path_id()`."""
-
-        def check_nested(data: list | tuple | set | frozenset | dict, path: list[int]) -> bool:
-            for i, idx in enumerate(path):
-                if isinstance(data, dict):
-                    keys = list(data.keys())
-                    if i == len(path) - 1:
-                        return True
-                    try:
-                        data = data[keys[idx]]
-                    except IndexError:
-                        return False
-                elif isinstance(data, (list, tuple, set, frozenset)):
-                    return False
-                else:
-                    raise TypeError(f"Unsupported type {type(data)} at path {path[:i+1]}")
-            return False
-
-        if not isinstance(data, dict):
-            return False
-        path = Data.__sep_path_id(path_id)
-        return check_nested(data, path)
+    def print(
+        data: DataStructure,
+        indent: int = 4,
+        compactness: int = 1,
+        max_width: int = 127,
+        sep: str = ", ",
+        end: str = "\n",
+        as_json: bool = False,
+        syntax_highlighting: dict[str, str] | bool = {},
+    ) -> None:
+        """Print nicely formatted data structures.\n
+        ------------------------------------------------------------------------------
+        The indentation spaces-amount can be set with with `indent`.
+        There are three different levels of `compactness`:
+        - `0` expands everything possible
+        - `1` only expands if there's other lists, tuples or dicts inside of data or,
+          if the data's content is longer than `max_width`
+        - `2` keeps everything collapsed (all on one line)\n
+        ------------------------------------------------------------------------------
+        If `as_json` is set to `True`, the output will be in valid JSON format.\n
+        ------------------------------------------------------------------------------
+        The `syntax_highlighting` parameter is a dictionary with 5 keys for each part
+        of the data. The key's values are the formatting codes to apply to this data
+        part. The formatting can be changed by simply adding the key with the new
+        value inside the `syntax_highlighting` dictionary.\n
+        The keys with their default values are:
+        - `str: COLOR.["blue"]`
+        - `number: COLOR.["magenta"]`
+        - `literal: COLOR.["cyan"]`
+        - `type: "i|" + COLOR.["lightblue"]`
+        - `punctuation: COLOR.["darkgray"]`\n
+        For no syntax highlighting, set `syntax_highlighting` to `False` or `None`.\n
+        ------------------------------------------------------------------------------
+        For more detailed information about formatting codes, see `xx_format_codes`
+        module documentation."""
+        FormatCodes.print(
+            Data.to_str(data, indent, compactness, max_width, sep, as_json, syntax_highlighting),
+            end=end,
+        )
 
     @staticmethod
     def __sep_path_id(path_id: str) -> list[int]:
@@ -528,4 +579,4 @@ class Data:
             raise ValueError(f"Invalid path ID: {path_id}")
         id_part_len = int(path_id.split(">")[0])
         path_ids_str = path_id.split(">")[1]
-        return [int(path_ids_str[i : i + id_part_len]) for i in range(0, len(path_ids_str), id_part_len)]
+        return [int(path_ids_str[i:i + id_part_len]) for i in range(0, len(path_ids_str), id_part_len)]

xulbux/xx_env_path.py

@@ -1,9 +1,5 @@
 """
-Functions for modifying and checking the systems environment-variables:
-- `EnvPath.paths()`
-- `EnvPath.has_path()`
-- `EnvPath.add_path()`
-- `EnvPath.remove_path()`
+Functions for modifying and checking the systems environment-variables (especially the PATH object).
 """
 
 from .xx_path import Path

xulbux/xx_file.py

@@ -53,7 +53,7 @@ class File:
         """Tries to find the file and extend the path to be absolute and if the file was not found:\n
         Generate the absolute path to the file in the CWD or the running program's base-directory.\n
         ----------------------------------------------------------------------------------------------
-        If the `file` is not found in the above directories, it will be searched in the `search_in`
+        If the `file` is not found in predefined directories, it will be searched in the `search_in`
         directory/directories. If the file is still not found, it will return the path to the file in
         the base-dir per default or to the file in the CWD if `prefer_base_dir` is set to `False`.\n
         ----------------------------------------------------------------------------------------------

xulbux/xx_format_codes.py

@@ -153,30 +153,33 @@ 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 *
+from .xx_color import Color, rgba, hexa
 
+from typing import Optional, Pattern
 import ctypes as _ctypes
 import regex as _rx
 import sys as _sys
 import re as _re
 
-_CONSOLE_ANSI_CONFIGURED = False
 
-_PREFIX = {
+_CONSOLE_ANSI_CONFIGURED: bool = False
+
+_PREFIX: dict[str, set[str]] = {
     "BG": {"background", "bg"},
     "BR": {"bright", "br"},
 }
-_PREFIX_RX = {
+_PREFIX_RX: dict[str, str] = {
     "BG": rf"(?:{'|'.join(_PREFIX['BG'])})\s*:",
     "BR": rf"(?:{'|'.join(_PREFIX['BR'])})\s*:",
 }
-_COMPILED = {  # PRECOMPILE REGULAR EXPRESSIONS
+_COMPILED: dict[str, Pattern] = {  # PRECOMPILE REGULAR EXPRESSIONS
     "*": _re.compile(r"\[\s*([^]_]*?)\s*\*\s*([^]_]*?)\]"),
     "*color": _re.compile(r"\[\s*([^]_]*?)\s*\*color\s*([^]_]*?)\]"),
+    "ansi_seq": _re.compile(ANSI.char + r"(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])"),
     "formatting": _rx.compile(
-        Regex.brackets("[", "]", is_group=True)
+        Regex.brackets("[", "]", is_group=True, ignore_in_strings=False)
         + r"(?:\s*([/\\]?)\s*"
-        + Regex.brackets("(", ")", is_group=True, ignore_in_strings=False)
+        + Regex.brackets("(", ")", is_group=True, strip_spaces=False, ignore_in_strings=False)
         + r")?"
     ),
     "bg?_default": _re.compile(r"(?i)((?:" + _PREFIX_RX["BG"] + r")?)\s*default"),
@@ -246,6 +249,8 @@ class FormatCodes:
         -------------------------------------------------------------------------
         For exact information about how to use special formatting codes, see the
         `xx_format_codes` module documentation."""
+        if not isinstance(string, str):
+            string = str(string)
         if Color.is_valid_rgba(default_color, False):
             use_default = True
         elif Color.is_valid_hexa(default_color, False):
@@ -291,33 +296,25 @@ class FormatCodes:
                                     reset_keys.append("_bg")
                                     break
                     elif is_valid_color(k) or any(
-                        k_lower.startswith(pref_colon := f"{prefix}:") and is_valid_color(k[len(pref_colon) :])
-                        for prefix in _PREFIX["BR"]
-                    ):
+                            k_lower.startswith(pref_colon := f"{prefix}:") and is_valid_color(k[len(pref_colon):])
+                            for prefix in _PREFIX["BR"]):
                         reset_keys.append("_color")
                     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)
+                                              ).startswith(f"{ANSI.char}{ANSI.start}")
                 ]
             else:
                 ansi_resets = []
             if not (len(ansi_formats) == 1 and ansi_formats[0].count(f"{ANSI.char}{ANSI.start}") >= 1) and not all(
-                f.startswith(f"{ANSI.char}{ANSI.start}") for f in ansi_formats
-            ):
+                    f.startswith(f"{ANSI.char}{ANSI.start}") for f in ansi_formats):
                 return match.group(0)
             return (
-                "".join(ansi_formats)
-                + (
+                "".join(ansi_formats) + (
                     f"({FormatCodes.to_ansi(auto_reset_txt, default_color, brightness_steps, False)})"
-                    if escaped and auto_reset_txt
-                    else auto_reset_txt if auto_reset_txt else ""
-                )
-                + ("" if escaped else "".join(ansi_resets))
+                    if escaped and auto_reset_txt else auto_reset_txt if auto_reset_txt else ""
+                ) + ("" if escaped else "".join(ansi_resets))
             )
 
         string = "\n".join(_COMPILED["formatting"].sub(replace_keys, line) for line in string.split("\n"))
@@ -325,9 +322,19 @@ class FormatCodes:
 
     @staticmethod
     def escape_ansi(ansi_string: str) -> str:
-        """Escapes all ANSI codes in a string, so they are visible when output to the console."""
+        """Escapes all ANSI codes in the string, so they are visible when output to the console."""
         return ansi_string.replace(ANSI.char, ANSI.escaped_char)
 
+    @staticmethod
+    def remove_ansi(ansi_string: str) -> str:
+        """Removes all ANSI codes from the string."""
+        return _COMPILED["ansi_seq"].sub("", ansi_string)
+
+    @staticmethod
+    def remove_formatting(string: str) -> str:
+        """Removes all formatting codes from the string."""
+        return _COMPILED["ansi_seq"].sub("", FormatCodes.to_ansi(string))
+
     @staticmethod
     def __config_console() -> None:
         """Configure the console to be able to interpret ANSI formatting."""
@@ -347,7 +354,7 @@ class FormatCodes:
         format_key: str = None,
         brightness_steps: int = None,
         _modifiers: tuple[str, str] = (ANSI.default_color_modifiers["lighten"], ANSI.default_color_modifiers["darken"]),
-    ) -> str | None:
+    ) -> Optional[str]:
         """Get the `default_color` and lighter/darker versions of it as ANSI code."""
         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(
@@ -386,14 +393,9 @@ class FormatCodes:
         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,
-                    )
+                    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)
@@ -408,8 +410,7 @@ class FormatCodes:
                 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])
+                    if is_bg else ANSI.seq_color.format(rgb[0], rgb[1], rgb[2])
                 )
         except Exception:
             pass
@@ -420,10 +421,11 @@ class FormatCodes:
         """Normalizes the given format key."""
         k_parts = format_key.replace(" ", "").lower().split(":")
         prefix_str = "".join(
-            f"{prefix_key.lower()}:"
-            for prefix_key, prefix_values in _PREFIX.items()
+            f"{prefix_key.lower()}:" for prefix_key, prefix_values in _PREFIX.items()
             if any(k_part in prefix_values for k_part in k_parts)
         )
         return prefix_str + ":".join(
-            part for part in k_parts if part not in {val for values in _PREFIX.values() for val in values}
+            part for part in k_parts if part not in {val
+                                                     for values in _PREFIX.values()
+                                                     for val in values}
         )